web-dev-qa-db-fra.com

Qu'est-ce que l'observateur du cycle de vie et comment l'utiliser correctement?

J'ai lu de nouveaux composants architecturaux sur Android. Donc, je voulais demander ce que sont les observateurs du cycle de vie et pourquoi en avons-nous besoin? Dans quels cas est-ce utile? Merci pour votre réponse!

javaandroidmvvmandroid-lifecycleandroid-livedata
14
Nazarii Moshenskiy

Vous pouvez utiliser ProcessLifecycleOwner pour les applications LifeCycle Event. Vous pouvez implémenter Lifecycler Observer dans votre classe d'application

public class MyApplication extends MultiDexApplication implements LifecycleObserver

@Override
public void onCreate() {
    super.onCreate();

    ProcessLifecycleOwner.get().getLifecycle().addObserver(this);

}

// Ajout de la méthode Lifecycle pour voir l'arrière-plan et le premier plan de l'application

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void appInResumeState() {
    Toast.makeText(this,"In Foreground",Toast.LENGTH_LONG).show();
}

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void appInPauseState() {
    Toast.makeText(this,"In Background",Toast.LENGTH_LONG).show();
}

// Ajouter dans le fichier build.gradle

implementation 'Android.Arch.lifecycle:extensions:1.1.1'

// également en activités ou fragment

L'utilisation peut également les utiliser pour réduire la complexité du code en créant différents composants qui implémentent l'observateur du cycle de vie, puis transmettent le cycle de vie de l'activité à ces composants. De cette façon, vous pouvez diviser l'énorme complexité en différents composants.

class MainActivity : AppCompatActivity() ,LifecycleObserver{

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        ReduceComplexComponent().registerLifecycle(lifecycle)

    }

}

class ReduceComplexComponent : LifecycleObserver{

    registerLifecycle(lifecycle : Lifecycle){
       lifecycle.addObserver(this)
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun resume() {
       Log.d("OnResume","ON_RESUME")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun pause() {
       Log.d("onPause","ON_PAUSE")
    }
}

De cette façon, vous pouvez écouter une activité ou un événement de cycle de vie de fragment dans des composants séparés.

Nous pouvons également récupérer manuellement l'état actuel de notre instance de cycle de vie dans Activity et ce que nous pouvons faire en utilisant son getCurrentState ()

Un État a également une méthode isAtLeast () que nous pouvons utiliser pour effectuer des comparaisons avec l'état actuel du cycle de vie

9
Alok Gupta

Vous les utilisez afin de réduire les rappels et les nettoyages de composants dus à Lifecycle events De votre application. Par exemple, vous avez un Handler/Runnable Qui s'exécute à partir d'un Thread quelque part et vous devez avoir des rappels/interfaces pour arrêter et supprimer la fonction listener lorsque onStop() est appelé; ainsi, en utilisant les nouveaux "composants Jetpack LifeCycle Architecture", vous pouvez rendre votre composant/classe "sensible au cycle de vie", donc le contrôler facilement à partir de l'activité/du fragment qui l'utilise!

Plus d'informations comme indiqué ci-dessus: https://developer.Android.com/topic/libraries/architecture/lifecycle

1
kevoroid

Peut être un peu tard pour la fête, mais un autre cas d'utilisation agréable des cycles de vie (à l'exception des éléments évidents de ViewModel) consiste à laisser de nombreux composants de l'application se désinscrire eux-mêmes lorsque l'activité pertinente est détruite, ou tout simplement hors de écran.

Par exemple, j'ai une fabrique statique qui crée des boîtes de dialogue, et en utilisant le cycle de vie, je peux fermer les boîtes de dialogue sans encombrer l'activité de l'hôte avec les vieux trucs comme Dialog mDialog = ... Et void onPause(){ ... if (mDialog !null && mDialog.isShowing()) mDialog.cancel() }

Du code:

DialogUtils.Java:

public static void showConfirmDialog(Lifecycle lifecycle, String title, String msg, Runnable okRunnable) {
    AlertDialog dialog = AlertDialog.Builder(mAppContext)
    /* configuration stuff ... */
        .build();

    dialog.show();

    lifecycle.addObserver(new LifecycleObserver() {
          @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
          public void cancelDialog() {
            if (dialog.isShowing()) { // if not already dismissed by main-button tap 
              dialog.cancel();
            }
          }
    });
}

MyActivity.Java:

public class MyActivity extends AppCompatActivity {

    /* stuff... onCreate()... other stuff... */

    private void confirmDeleteUser(User user){
        DialogUtils.showConfirmDialog(
            MyActivity.this.getLifecycle(), // all activities & fragment have lifecycles
            "Confirm Delete",
            "Action cannot be undone. Sure to continue?",
            new Runnable() { /* stuff... */ }
        );
        // Voilà! 
        // activity no needs to store reference to the dialog and cancel manually on pause
        // it's a fire-and-forget action
    }
}
1
Re'em

LifeCycleObserver fait partie de Google publié Android Jetpack Composants de LifeCycle Architecture, et c'est une interface qui vous permet d'observer un composant observable compatible avec LifeCycle, généralement un LifeCycleOwner (Activité/Fragment), afin d'interagir avec le LifeCycle événements et états associés à ce composant; afin que vous puissiez surveiller les événements du cycle de vie de premier plan et d'arrière-plan.

Voici quelques liens utiles avec une utilisation typique

0
Zain