पॉपिंग के दौरान फोर्स फुटर नाविक राज्य को फिर से लोड करने के लिए


108

मैं StatefulWidgetबटन के साथ स्पंदन में एक है, जो मुझे दूसरे StatefulWidgetका उपयोग करने के लिए नेविगेट करता है Navigator.push()। दूसरे विजेट पर मैं वैश्विक स्थिति (कुछ उपयोगकर्ता प्राथमिकताएं) बदल रहा हूं। जब मैं दूसरे विजेट से पहली तक वापस आता हूं, Navigator.pop()तो पहले विजेट का उपयोग पुरानी स्थिति में होता है, लेकिन मैं इसे फिर से लोड करना चाहता हूं। कोई आईडिया कि इसे कैसे किया जाए? मेरे पास एक विचार है लेकिन यह बदसूरत दिखता है:

  1. दूसरा विजेट हटाने के लिए पॉप (वर्तमान एक)
  2. पहला विजेट हटाने के लिए फिर से पॉप (पिछले एक)
  3. पहला विजेट धक्का (यह redraw मजबूर करना चाहिए)

1
कोई जवाब नहीं, बस एक सामान्य टिप्पणी: मेरे मामले में, जो मुझे यहां ला रहा है वह इस बात को हल करने के साथ साझा किया जाएगा कि मुझे साझा करने के लिए गारंटी दी गई है, जहां मुझे एक अद्यतन पृष्ठ पर एक पल पहले लिखा गया एक अद्यतन प्रीफ़ वापस पाने की गारंटी है। । : \ तब भी .then (...) का उपयोग हमेशा मुझे लंबित-लिखने वाले अपडेट किए गए डेटा से नहीं मिल रहा है।
क्रिस एचएच

बस नए पेज से पॉप पर एक मान लौटाया, मेरी समस्या हल कर दी। Flutter.dev/docs/cookbook/navigation/returning-data
जो

जवाबों:


85

वहाँ कुछ चीजें आप यहाँ कर सकते हैं। @ माही का उत्तर सही होने के बाद थोड़ा अधिक रसीला हो सकता है और वास्तव में शो डाइलॉग के बजाय पुश का उपयोग कर सकता है जैसा कि ओपी के बारे में पूछ रहा था। यह एक उदाहरण है जो उपयोग करता है Navigator.push:

import 'package:flutter/material.dart';

class SecondPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return new Container(
      color: Colors.green,
      child: new Column(
        children: <Widget>[
          new RaisedButton(
            onPressed: () => Navigator.pop(context),
            child: new Text("back"),
          ),
        ],
      ),
    );
  }
}

class FirstPage extends StatefulWidget {
  @override
  State<StatefulWidget> createState() => new FirstPageState();
}

class FirstPageState extends State<FirstPage> {

  Color color = Colors.white;

  @override
  Widget build(BuildContext context) {
    return new Container(
      color: color,
      child: new Column(
        children: <Widget>[
          new RaisedButton(
              child: new Text("next"),
              onPressed: () {
                Navigator
                    .push(
                  context,
                  new MaterialPageRoute(builder: (context) => new SecondPage()),
                )
                    .then((value) {
                  setState(() {
                    color = color == Colors.white ? Colors.grey : Colors.white;
                  });
                });
              }),
        ],
      ),
    );
  }
}

void main() => runApp(
      new MaterialApp(
        builder: (context, child) => new SafeArea(child: child),
        home: new FirstPage(),
      ),
    );

हालांकि, ऐसा करने का एक और तरीका है जो आपके उपयोग-मामले को अच्छी तरह से फिट कर सकता है। आप उपयोग कर रहे हैं globalअपने प्रथम पृष्ठ के निर्माण को प्रभावित करता है कि कुछ के रूप में, आप एक इस्तेमाल कर सकते हैं InheritedWidget अपने वैश्विक उपयोगकर्ता वरीयताओं को परिभाषित करने के लिए, और जब भी बदल रहे हैं अपने FirstPage पुनर्निर्माण करेंगे। यह भी एक स्टेटलेस विजेट के भीतर काम करता है जैसा कि नीचे दिखाया गया है (लेकिन एक स्टेटफुल विजेट में भी काम करना चाहिए)।

स्पंदन में विरासत में मिली एक मिसाल ऐप का थीम है, हालांकि वे इसे सीधे विजेट के बजाय एक विजेट के भीतर परिभाषित करते हैं जैसा कि मैंने यहां किया है।

import 'package:flutter/material.dart';
import 'package:meta/meta.dart';

class SecondPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return new Container(
      color: Colors.green,
      child: new Column(
        children: <Widget>[
          new RaisedButton(
            onPressed: () {
              ColorDefinition.of(context).toggleColor();
              Navigator.pop(context);
            },
            child: new Text("back"),
          ),
        ],
      ),
    );
  }
}

class ColorDefinition extends InheritedWidget {
  ColorDefinition({
    Key key,
    @required Widget child,
  }): super(key: key, child: child);

  Color color = Colors.white;

  static ColorDefinition of(BuildContext context) {
    return context.inheritFromWidgetOfExactType(ColorDefinition);
  }

  void toggleColor() {
    color = color == Colors.white ? Colors.grey : Colors.white;
    print("color set to $color");
  }

  @override
  bool updateShouldNotify(ColorDefinition oldWidget) =>
      color != oldWidget.color;
}

class FirstPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    var color = ColorDefinition.of(context).color;

    return new Container(
      color: color,
      child: new Column(
        children: <Widget>[
          new RaisedButton(
              child: new Text("next"),
              onPressed: () {
                Navigator.push(
                  context,
                  new MaterialPageRoute(builder: (context) => new SecondPage()),
                );
              }),
        ],
      ),
    );
  }
}

void main() => runApp(
      new MaterialApp(
        builder: (context, child) => new SafeArea(
              child: new ColorDefinition(child: child),
            ),
        home: new FirstPage(),
      ),
    );

यदि आप विरासत में दिए गए विजेट का उपयोग करते हैं, तो आपको उस पृष्ठ के पॉप को देखने के लिए परेशान होने की ज़रूरत नहीं है, जो बुनियादी उपयोग के मामलों के लिए काम करेगा, लेकिन अधिक जटिल परिदृश्य में समस्याएँ हो सकती हैं।


उत्कृष्ट, पहला मामला मेरे लिए पूरी तरह से काम करता था (दूसरा एक अधिक जटिल स्थिति के लिए एकदम सही है)। दूसरे पेज से OnWillPopUp का उपयोग करना मेरे लिए स्पष्ट नहीं था; और बिलकुल भी काम नहीं किया।
cdsaenz

अरे, क्या होगा अगर मैं अपनी सूची आइटम को अपडेट करना चाहता हूं। मान लीजिए कि मेरे प्रथम पृष्ठ में सूची आइटम हैं और दूसरे पृष्ठ में आइटम विवरण है। मैं आइटम का मूल्य अपडेट कर रहा हूं और मैं चाहता हूं कि यह सूची आइटम पर वापस अपडेट हो जाए। कैसे प्राप्त करें?
अंचल मेहता

@AanalMehta मैं आपको एक त्वरित सिफारिश दे सकता हूं - या तो एक बैकएंड स्टोर (यानी sqflite टेबल या इन-मेमोरी सूची) का उपयोग करें जो दोनों पृष्ठों से उपयोग किया जाता है, और तब आप अपने विजेट को किसी भी तरह ताज़ा करने के लिए मजबूर कर सकते हैं (मैं व्यक्तिगत रूप से) एक वृद्धिशील काउंटर का उपयोग किया है जिसे मैं पहले सेटस्टैट में बदलता हूं - यह सबसे साफ समाधान नहीं है लेकिन यह काम करता है) ... या, आप फिर से मूल पृष्ठ में बदलावों को पास कर सकते हैं। तब फ़ंक्शन, अपनी सूची में संशोधन करें, और फिर पुनर्निर्माण करें (लेकिन ध्यान दें कि किसी सूची में परिवर्तन करने से एक ताज़ा ट्रिगर नहीं होता है, इसलिए एक बार फिर से वृद्धि काउंटर का उपयोग करें)।
rmtmckenzie

@AanalMehta लेकिन अगर वह मदद नहीं करता है, तो मैं आपको कुछ अन्य उत्तरों की तलाश करने की सलाह दूंगा जो अधिक प्रासंगिक हो सकते हैं (मुझे यकीन है कि मैंने सूची आदि के बारे में कुछ देखा है), या एक नया प्रश्न पूछें।
rmtmckenzie

@rmtmckenzie वास्तव में मैंने उपरोक्त एक समाधान की कोशिश की। मैंने चैन गेस को तब लागू किया था, लेकिन यह प्रतिबिंबित नहीं होगा। मुझे लगता है कि अब मेरे पास प्रदाताओं का उपयोग करने का केवल एक ही विकल्प है। वैसे भी, आपकी मदद के लिए बहुत बहुत धन्यवाद।
अंचल मेहता

20

2 चीजें हैं, पासिंग डेटा

  • प्रथम पृष्ठ से २

    यह 1 पृष्ठ में प्रयोग करें

    // sending "Foo" from 1st
    Navigator.push(context, MaterialPageRoute(builder: (_) => Page2("Foo")));
    

    इसे 2 पेज में इस्तेमाल करें।

    class Page2 extends StatelessWidget {
      final String string;
    
      Page2(this.string); // receiving "Foo" in 2nd
    
      ...
    }
    

  • दूसरा पेज 1 से

    इसे 2 पेज में इस्तेमाल करें

    // sending "Bar" from 2nd
    Navigator.pop(context, "Bar");
    

    1 पृष्ठ में इसका उपयोग करें, यह वही है जो पहले इस्तेमाल किया गया था लेकिन थोड़ा संशोधन के साथ।

    // receiving "Bar" in 1st
    String received = await Navigator.push(context, MaterialPageRoute(builder: (_) => Page2("Foo")));
    

Navigator.popUntil पद्धति का उपयोग करते हुए रूट C से पॉपिंग करते समय मैं रूट A को कैसे पुनः लोड कर सकता हूं।
विनोथ विनो

1
@VinothVino ऐसा करने का कोई प्रत्यक्ष तरीका नहीं है, बस आपको कुछ प्रकार के वर्कअराउंड करने की आवश्यकता है।
CopsOnRoad

@CopsOnRoad गतिविधि में टैबबार डायलॉग सबमिट बटन से दूसरे टैब पर कॉल करने के लिए नेविगेटर से क्लिक करें। दूसरा टैब पर पुनर्निर्देशित करने के लिएushpplaceplace।
एसजे

13

आसान चाल का उपयोग है Navigator.pushReplacement विधि

पृष्ठ 1

Navigator.pushReplacement(
  context,
  MaterialPageRoute(
    builder: (context) => Page2(),
  ),
);

पृष्ठ 2

Navigator.pushReplacement(
  context,
  MaterialPageRoute(
    builder: (context) => Page1(),
  ),
);

इस तरह आप नेविगेटर स्टैक खो रहे हैं। बैक बटन के साथ स्क्रीन को पॉप करने के बारे में क्या?
एनकाउब

11

आप pushReplacement का उपयोग कर सकते हैं और नया रूट निर्दिष्ट कर सकते हैं


1
लेकिन आप नाविक ढेर खो रहे हैं। यदि आप Android बैक बटन का उपयोग करके स्क्रीन को पॉप करते हैं तो क्या होगा?
एनकाउबोस

5

यह काम वास्तव में अच्छा है, मैं इस डॉक्टर से स्पंदन पृष्ठ से मिला: स्पंदन डॉक्टर

मैंने पहले पृष्ठ से नेविगेशन को नियंत्रित करने की विधि को परिभाषित किया।

_navigateAndDisplaySelection(BuildContext context) async {
    final result = await Navigator.push(
      context,
      MaterialPageRoute(builder: (context) => AddDirectionPage()),
    );

    //below you can get your result and update the view with setState
    //changing the value if you want, i just wanted know if i have to  
    //update, and if is true, reload state

    if (result) {
      setState(() {});
    }
  }

इसलिए, मैं इसे एक इंकवेल से एक्शन विधि में कहता हूं, लेकिन इसे एक बटन से भी कहा जा सकता है:

onTap: () {
   _navigateAndDisplaySelection(context);
},

और अंत में दूसरे पृष्ठ में, कुछ वापस करने के लिए (मैंने एक बूल लौटाया, आप जो चाहें वापस कर सकते हैं):

onTap: () {
  Navigator.pop(context, true);
}

1
तुम भी बस await Navigator....और पॉप में एक परिणाम मान छोड़ सकते हैं ।
0llie

5

मेरे लिए यह काम करने लगता है:

Navigator.of(context).pushNamed("/myRoute").then((value) => setState(() {}));

फिर बस Navigator.pop()बच्चे को बुलाओ ।


4

इसे वहां रखें जहां आप दूसरी स्क्रीन पर जा रहे हैं (async फ़ंक्शन के अंदर)

Function f;
f= await Navigator.pushNamed(context, 'ScreenName');
f();

जहां आप पॉपिंग कर रहे हैं वहां इसे लगाएं

Navigator.pop(context, () {
 setState(() {});
});

setStateअंदर कहा जाता है popबंद डेटा अद्यतन करने के लिए।


2
आप setStateतर्क के रूप में वास्तव में कहाँ से गुजरते हैं ? आप मूल रूप से setStateएक बंद के अंदर बुला रहे हैं । इसे तर्क के रूप में नहीं पारित कर रहे हैं।
Volkan ग्वेन

यह सटीक उत्तर है जिसकी मुझे तलाश थी। मैं मूल रूप से एक पूरा हैंडलर चाहता था Navigator.pop
डेविड चोपिन

3

मेरा समाधान सेकंडपेज पर एक फ़ंक्शन पैरामीटर जोड़कर चला गया, फिर पुनः लोडिंग फ़ंक्शन प्राप्त किया जो फ़र्स्टपेज से किया जा रहा है, फिर नेवीगेटर.पॉप (संदर्भ) लाइन से पहले फ़ंक्शन को निष्पादित किया।

पहला पन्ना

refresh() {
setState(() {
//all the reload processes
});
}

फिर अगले पृष्ठ पर धकेलने पर ...

Navigator.push(context, new MaterialPageRoute(builder: (context) => new SecondPage(refresh)),);

secondpage

final Function refresh;
SecondPage(this.refresh); //constructor

फिर नाविक पॉप लाइन से पहले,

widget.refresh(); // just refresh() if its statelesswidget
Navigator.pop(context);

पिछले पृष्ठ से पुनः लोड किए जाने वाले सभी चीज़ों को पॉप के बाद अपडेट किया जाना चाहिए।


1

dynamic resultजब आप संदर्भ को पॉप कर रहे हों तब आप वापस पास कर सकते हैं और तब कॉल कर सकते हैं setState((){})जब मूल्य trueअन्यथा राज्य को छोड़ दें जैसा कि यह है।

मैंने आपके संदर्भ के लिए कुछ कोड स्निपेट चिपकाए हैं।

handleClear() async {
    try {
      var delete = await deleteLoanWarning(
        context,
        'Clear Notifications?',
        'Are you sure you want to clear notifications. This action cannot be undone',
      );
      if (delete.toString() == 'true') {
        //call setState here to rebuild your state.

      }
    } catch (error) {
      print('error clearing notifications' + error.toString());
             }
  }



Future<bool> deleteLoanWarning(BuildContext context, String title, String msg) async {

  return await showDialog<bool>(
        context: context,
        child: new AlertDialog(
          title: new Text(
            title,
            style: new TextStyle(fontWeight: fontWeight, color: CustomColors.continueButton),
            textAlign: TextAlign.center,
          ),
          content: new Text(
            msg,
            textAlign: TextAlign.justify,
          ),
          actions: <Widget>[
            new Container(
              decoration: boxDecoration(),
              child: new MaterialButton(
                child: new Text('NO',),
                onPressed: () {
                  Navigator.of(context).pop(false);
                },
              ),
            ),
            new Container(
              decoration: boxDecoration(),
              child: new MaterialButton(
                child: new Text('YES', ),
                onPressed: () {
                  Navigator.of(context).pop(true);
                },
              ),
            ),
          ],
        ),
      ) ??
      false;
}

सादर, माही


मुझे यकीन नहीं है कि मैं समझता हूं कि दूसरे भाग को कैसे करना है। सबसे पहले बस Navigator.pop(context, true), सही है? लेकिन मैं इस trueमूल्य को कैसे प्राप्त कर सकता हूं ? का उपयोग कर BuildContext?
20-20 को bartektartanus

मेरे लिए काम नहीं कर रहा है। मैंने परिणाम का उपयोग पुश से किया है, जिसे सेटस्टेट कहा जाता है और मिलाsetState() called after dispose(): This error happens if you call setState() on a State object for a widget that no longer appears in the widget tree (e.g., whose parent widget no longer includes the widget in its build). This error can occur when code calls setState() from a timer or an animation callback. The preferred solution is to cancel the timer or stop listening to the animation in the dispose() callback. ....
bartektartanus

हम्म, यह दिलचस्प है कि आपने if(!mounted) return;हर कॉल से पहले setState((){});इस तरह से उपयोग किया है कि आप डिस्पोज किए गए विजेट या विजेट को अपडेट करने से बच सकते हैं जो अब सक्रिय नहीं हैं।
माही

कोई त्रुटि नहीं है, लेकिन यह भी काम नहीं कर रहा है जैसा कि मैंने भविष्यवाणी की है;)
bartektartanus

मेरे पास @bartektartanus जैसा ही मुद्दा है। अगर मैं जोड़ देता हूं तो सेटस्टैट से पहले माउंट किया जाता है, मेरा राज्य कभी सेट नहीं होगा। यह सरल लगता है लेकिन मैंने कुछ घंटों के बाद इसका पता नहीं लगाया है।
स्विफ्ट

1

मेरे एक स्टेटलेस विजेट के पुनर्निर्माण के लिए मजबूर करने की आवश्यकता है। स्टेटफुल का उपयोग नहीं करना चाहता था। इस समाधान के साथ आया:

await Navigator.of(context).pushNamed(...);
ModalRoute.of(enclosingWidgetContext);

ध्यान दें कि संदर्भ और enclosingWidgetContext समान या अलग संदर्भ हो सकते हैं। यदि, उदाहरण के लिए, आप StreamBuilder के अंदर से धक्का देते हैं, तो वे अलग होंगे।

हम यहाँ ModalRoute के साथ कुछ भी नहीं करते हैं। अकेले सदस्यता लेने का कार्य पुनर्निर्माण के लिए मजबूर करने के लिए पर्याप्त है।


1

अगर आप अलर्ट डायलॉग का इस्तेमाल कर रहे हैं तो आप फ्यूचर का इस्तेमाल कर सकते हैं जो डायलॉग खारिज होने पर पूरा होता है। भविष्य के पूरा होने के बाद आप विजेट को फिर से लोड करने के लिए मजबूर कर सकते हैं।

पहला पन्ना

onPressed: () async {
    await showDialog(
       context: context,
       builder: (BuildContext context) {
            return AlertDialog(
                 ....
            );
       }
    );
    setState(() {});
}

चेतावनी संवाद में

Navigator.of(context).pop();

0

आज मुझे उसी स्थिति का सामना करना पड़ा, लेकिन मैं इसे बहुत आसान तरीके से हल करने में कामयाब रहा, मैंने सिर्फ एक वैश्विक चर को परिभाषित किया जो कि पहले राज्य के वर्ग में इस्तेमाल किया गया था, और जब मैं एक दूसरे राज्य के विजेट पर नेविगेट करता हूं तो मैं इसे वैश्विक मूल्य को अपडेट करने देता हूं चर जो स्वचालित रूप से पहले विजेट को अद्यतन करने के लिए मजबूर करता है। यहाँ एक उदाहरण है (मैंने इसे जल्दी में लिखा था इसलिए मैंने एक मचान या सामग्री ऐप नहीं डाला था, मैं सिर्फ अपनी बात को स्पष्ट करना चाहता था):

import 'package:flutter/material.dart';
int count = 0 ;

class FirstPage extends StatefulWidget {
FirstPage({Key key}) : super(key: key);

@override
_FirstPageState createState() => _FirstPageState();
}

class _FirstPageState extends State<FirstPage> {
@override
Widget build(BuildContext context) {
return InkWell(
onTap(){
Navigator.of(context).push(MaterialPageRoute(builder: (context) =>
                  new SecondPage());
},
child: Text('First', style : TextStyle(fontSize: count == 0 ? 20.0 : 12.0)),
),

}


class SecondPage extends StatefulWidget {
SecondPage({Key key}) : super(key: key);

@override
_SecondPageState createState() => _SecondPageState();
}

class _SecondPageState extends State<SecondPage> {
@override
Widget build(BuildContext context) {
return IconButton(
         icon: new Icon(Icons.add),
         color: Colors.amber,
         iconSize: 15.0,
         onPressed: (){
         count++ ;
         },
       ),
     }

4
परिवर्तनशील चर स्वतः विजेट का पुनर्निर्माण नहीं करेगा। इसके बाद Navigator.pop()राज्य को फिर से बुलाए जाने से पहले Navigator.push()रखा setStateजाएगा, इस कोड में क्या नहीं होता है। क्या मैं कुछ भूल रहा हूँ?
रिकार्डो BRGWeb

0

इस सरल कोड ने मुझे रूट पर जाने और राज्य को फिर से लोड करने के लिए काम किया:

    ...
    onPressed: () {
         Navigator.of(context).pushNamedAndRemoveUntil('/', ModalRoute.withName('/'));
                },
    ...

0

संक्षेप में, आप विजेट घड़ी राज्य बनाना चाहिए। इसके लिए आपको राज्य प्रबंधन की आवश्यकता है।

मेरा तरीका प्रदाता पर आधारित है जिसे फ़्लटर आर्किटेक्चर नमूने और साथ ही फ़्लटर डॉक्स में समझाया गया है । कृपया उन्हें अधिक संक्षिप्त विवरण के लिए देखें लेकिन कमोबेश चरण निम्न हैं:

  • अपने राज्य मॉडल को उन राज्यों के साथ परिभाषित करें जिन्हें विजेट को देखने की आवश्यकता है।

आपके पास कुछ API प्रक्रिया के लिए कई राज्यों के कहने dataऔर isLoadingप्रतीक्षा करने के लिए हो सकता है । मॉडल ही फैली हुई है ChangeNotifier

  • विजेट्स को लपेटें जो वॉचर क्लास के साथ उन राज्यों पर निर्भर करते हैं।

यह Consumerया हो सकता है Selector

  • जब आपको "पुनः लोड" करने की आवश्यकता होती है, तो आप मूल रूप से उन राज्यों को अपडेट करते हैं और परिवर्तनों को प्रसारित करते हैं।

राज्य मॉडल के लिए वर्ग निम्नानुसार अधिक या कम दिखाई देगा। ध्यान दें कि notifyListenersकिन परिवर्तनों को प्रसारित करता है।

class DataState extends ChangeNotifier{

  bool isLoading;
  
  Data data;

  Future loadData(){
    isLoading = true;
    notifyListeners();

    service.get().then((newData){
      isLoading = false;
      data = newData;
      notifyListeners();
    });
  }
  
}

अब विजेट के लिए। यह बहुत कंकाल कोड होने जा रहा है।

return ChangeNotifierProvider(

  create: (_) => DataState()..loadData(),
      
  child: ...{
    Selector<DataState, bool>(

        selector: (context, model) => model.isLoading,

        builder: (context, isLoading, _) {
          if (isLoading) {
            return ProgressBar;
          }

          return Container(

              child: Consumer<DataState>(builder: (context, dataState, child) {

                 return WidgetData(...);

              }
          ));
        },
      ),
  }
);

राज्य मॉडल का उदाहरण ChangeNotifierProvider द्वारा प्रदान किया गया है। चयनकर्ता और उपभोक्ता क्रमशः isLoadingऔर प्रत्येक के लिए राज्यों को देखते dataहैं। नहीं है उन दोनों के बीच ज्यादा अंतर नहीं है, लेकिन व्यक्तिगत रूप से आप उन्हें कैसे उपयोग अपने बिल्डरों क्या प्रदान पर निर्भर करेगा। उपभोक्ता राज्य मॉडल तक पहुँच प्रदान करता है इसलिए कॉलिंगloadData किसी भी विजेट को सीधे उसके नीचे करना सरल है।

यदि नहीं तो आप उपयोग कर सकते हैं Provider.of। यदि हम दूसरी स्क्रीन से लौटने पर पेज को रिफ्रेश करना चाहते हैं तो हम कुछ ऐसा कर सकते हैं:

await Navigator.push(context, 
  MaterialPageRoute(
    builder: (_) {
     return Screen2();
));

Provider.of<DataState>(context, listen: false).loadData();


0

मेरे लिए काम किया:

...
onPressed: (){pushUpdate('/somePageName');}
...

pushUpdate (string pageName) async {      //in the same class
  await pushPage(context, pageName);
  setState(() {});
}


//---------------------------------------------
//general sub
pushPage (context, namePage) async {
  await Navigator.pushNamed(context, namePage);
}

इस मामले में कोई फर्क नहीं पड़ता कि आप कैसे पॉप (यूआई में बटन या एंड्रॉइड में "बैक") अपडेट करते हैं।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.