Arrêter le gestionnaire d'après le frgment a été détruit

J'ai un Fragment qui met en place un ListView et crée un Handler pour mettre à jour le Listview périodiquement. Cependant, il semble que la Handler fonctionne encore après la Fragment a été détruit.

Voici le code.

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {

    //boilerplate code

    final Handler handler = new Handler();
    handler.post(new Runnable() {
        @Override
        public void run() {
            assignAdapter();
            handler.postDelayed(this, 15000);
        }
    });

    return v;
}

La mise à jour de la ListView après la destruction de la Fragment entraîne l'application crash. Comment puis-je causer la Handler pour arrêter le Fragment est détruit? Je voudrais aussi savoir quels sont les effets que si toute la suspension de l'application sur le Handler.

OriginalL'auteur Sandah Aung | 2015-04-21

  1. 18

    Vous avez besoin pour mettre en œuvre gestionnaire comme ce

    private Handler myHandler;
private Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        //Do Something
    }
};

@Override
public void onDestroy () {

    mHandler.removeCallbacks(myRunnable);
    super.onDestroy ();

}

    OriginalL'auteur Murtaza Khursheed Hussain

  2. 4

    Vous avez besoin de stocker une référence à votre gestionnaire et praticable dans le fragment, puis lorsque le fragment est détruit, vous devez supprimer les rappels à partir du gestionnaire de passage dans l'exécutable.

    private Handler mHandler;
private Runnable mRunnable;

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {

    //boilerplate code

    mRunnable = new Runnable() {
        @Override
        public void run() {
            assignAdapter();
            handler.postDelayed(this, 15000);
        }
    };

    mHandler = new Handler(mRunnable);
    mHandler.post();

    return v;
}

@Override
public void onDestroy() {
    mHandler.removeCallbacks(mRunnable);
    super.onDestroy();
}
    J'ai placé dans onDetach().

    OriginalL'auteur Nicholas Hall

  3. 1

    Une autre façon de stopper le gestionnaire avec l'utilisation de WeakReference le fragment:

    static final class UpdateUIRunnable implements Runnable {

        final WeakReference<RouteGuideFragment> weakRefToParent;
        final Handler handler;

        public UpdateUIRunnable(RouteGuideFragment fragment, Handler handler) {
            weakRefToParent = new WeakReference<RouteGuideFragment>(fragment);
            this.handler = handler;
        }

        public void scheduleNextRun() {
            handler.postDelayed(this, INTERVAL_TO_REDRAW_UI);
        }

        @Override
        public void run() {
            RouteGuideFragment fragment = weakRefToParent.get();

            if (fragment == null || fragment.hasBeenDestroyed()) {
                Log.d("UIUpdateRunnable", "Killing updater -> fragment has been destroyed.");
                return;
            }

            if (fragment.adapter != null) {
                try {
                    fragment.adapter.forceUpdate();
                } finally {
                    //schedule again
                    this.scheduleNextRun();
                }
            }
        }
    }

    où fragment.hasBeenDestroyed() est tout simplement un getter pour mDestroyed propriété d'un fragment:

    @Override
public void onDestroy() {
    super.onDestroy();
    mDestroyed = true;
}
    c'est une méthode efficace pour éviter les entrées en phase nationale d'erreur pendant la mise à jour de la vue 🙂 bon travail

    OriginalL'auteur Kuba Spatny

  4. 0

    Quelqu'un a posté une autre question similaire, et le problème est dû à un bogue dans le ChildFragmentManager. Fondamentalement, la ChildFragmentManager se retrouve avec une fracture interne de l'état lorsqu'il est détaché de la Activity. Jetez un oeil à la réponse originale à cette question ici

    OriginalL'auteur Yaco Zaragoza

  5. -1

    Utilisation Rxjava, de son mieux

    subscription = Observable.timer(1000, TimeUnit.MILLISECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(aLong -> whatToDo());

private void whatToDo() {
   System.out.println("Called after 1 second");
}

    Puis dans ondestroy() appel de la méthode

    RxUtils.unsubscribe(subscription);
    comment est le meilleur? Vous avez besoin d'élaborer
    Rxjava fournit de nombreux intégré des fonctions telles que sauter, subscribeOn, observeOn et de beaucoup d'autres qui peuvent être révélées utiles par conséquent, il est mieux. Ne consultez Rxjava.

    OriginalL'auteur Raghav Sharma