Android Architecture Components: Lifecycles

Jest to cykl artykułów poświęcony komponentom architektury Androida. Wszystkie artykuły znajdziesz na tej stronie.

W poprzednim wpisie opisałem pierwszy komponent architektury Androida. Dziś zajmiemy się łatwiejszym komponentem i bierzemy na warsztać Lifecycles.

Android Architecture Components: Lifecycles

Cykl życia to jedna z pierwszych rzeczy, której uczą się osoby rozpoczynające tworzenia aplikacji na system Android. Jako programista musisz odpowiednio zarządzać cyklem życia aplikacji, co nie zawsze jest łatwe, szczególnie jeśli Twoja aplikacja zawiera jednocześnie wiele asynchronicznych połączeń.
Biblioteka Lifecycles oferuje nowe podejście do tego zadania, Jest to zestaw klas i interfejsów, które umożliwiają lepsze zarządzanie cyklem życia aktywności lub fragmentu. Komponent LifeCycles posiada następujące klasy, którymi będziemy się zajmować:

Lifecycle

Zgodnie z dokumentacją Lifecycle jest klasą abstrakcyjną. Trzyma stan cyklu życia aktywności lub fragmentu, a inne obiekty mogą obserwować ten stan. Istnieją dwa sposoby aby śledzić ten stan. Za pomocą: svent i state.

Uzupełnij wiedze o: Fragmenty a back Stack w Androidzie

Event

Event jest zdarzeniem cyklu życia, które zostało wywołane zmianą cyklu życia na przykład przez zmianę rotacji urządzenia. W klasach możemy realizować wywołania zwrotne dla każdego z tych zdarzeń. Pakiet arch.lifecycle zawiera adnotację, których możemy używać, co oznacza, że ​​możemy dodawać adnotacje do metod w naszej klasie, które powinny być uruchamiane w określonych zdarzeniach cyklu życia. Możemy wyróżnić następujące zdarzenia:

  • ON_CREATE
  • ON_START
  • ON_PAUSE
  • ON_RESUME
  • ON_STOP
  • ON_DESTROY
  • ON_ANY

ON_ANY – jest to specjalne zdarzenie, które pasuje do wszystkich zdarzeń właściciela cyklu życia. Możesz stworzyć jedną metodę, która będzie reagować na wszystkie zdarzenia cyklu życia aktywności lub fragmentu.

State

Stan cyklu życia jest zasadniczo punktem pomiędzy dwoma zdarzeniami cyklu życia. Po wywołaniu zdarzenia przejdzie z jednego stanu, a następnie pozostawi go i wejdzie w inny stan po uruchomieniu innego zdarzenia.


Jak widać na powyższym diagramie, nasza instancja Lifecycle może znajdować się w jednym z pięciu stanów w danym momencie, są to:

  • INITIALISED  - stan cyklu życia w początkowym punkcie startowym
  • DESTROYED – stan cyklu życia po zdarzeniu ON_DESTROY
  • CREATED  - stan cyklu życia po zdarzeniu ON_CREATE, ale przed zdarzeniem ON_START. Jest również w tym stanie po zdarzeniu ON_STOP i przed ON_DESTROY .
  • STARTED  - stan cyklu życia po ON_START i przed zdarzeniem ON_RESUME. Jest również w tym stanie po zdarzeniu ON_PAUSE i przed ON_STOP
  • RESUME– stan cyklu życia po zdarzeniu ON_RESUME

Jeśli chcemy sprawdzić aktualny stan naszego Lifecycle możemy to zrobić za pomocą metody getCurrentState(). Może to być przydatne do sprawdzania stanu komponentu przed wykonaniem jakiejś operacji. Oprócz tego możemy skorzystać z isAtLeast(). Metoda ta zwraca wartość logiczną. Przydaje się do porównania stanu w stosunku do obecnego stanu cyklu życia.

if ( lifeCycle.currentState.isAtLeast(Lifecycle.State.CREATE )) {
     ...
}

LifeCycleOwner

Każda klasa, która implementuje interfejs LifeCycleOwner wskazuje, że posiada cykl życia. Zazwyczaj jest to aktywność lub fragment. Posiada metodę getLifecycle(), która musi być wdrożona przez tą klasę. Możemy także tworzyć niestandardowe komponenty LifeCycleOwner używając LifeCycleRegistry. Metody klasy których możemy użyć do zarządzania to:

  • addObserver()  - za pomocą tej metody możemy dodać instancję Observer, która będzie powiadamiać nas za każdym razem, gdy nasz LifecycleOwner się zmieni.
  • removeObserver()  - metoda ta może zostać wywołana w celu usunięcia danego obserwatora z listy obserwatorów. Usunięcie obserwatora z cyklu życia oznacza, że ​​nie będzie już otrzymywać żadnych zdarzeń.

To tutaj pobieramy instancję Lifecycle, a następnie dodajemy do niej Observer’a. Oznacza to teraz, że obserwujemy wszelkie zdarzenia związane z cyklem życia, które mogą zostać uruchomione. Ten interfejs nie deklaruje żadnych metod (oprócz tej wymienionej wyżej), które są wymagane do wdrożenia, ale opiera się na metodach opisanych w adnotacjach OnLifecycleEvent.

Uzupełnij wiedzę o: Tworzymy przewijany toolbar

LifeCycleObserver

Jest to interfejs implementujący LifeCycleObserver. Interakcja z wydarzeniami LifeCycle odbywa się za pomocą adnotacji OnLifecycleEvent. W tej klasie tworzymy metody, które są nam potrzebne do obsługi zdarzeń cyklu życia.

Pokaż mi w końcu kod!

Tak więc, jeśli mielibyśmy wdrożyć bibliotekę Lifecycles w naszym projekt możemy po prostu zrobić tak:

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getLifecycle().addObserver(new ObserverLifecycle() );
    }
}
class ObserverLifecycle implements LifecycleObserver {
    private static final String TAG = "ObserverLifecycle";
    @OnLifecycleEvent(Event.ON_START)
    public void onStart() {
        Log.e(TAG, "ON_START");
    }
    @OnLifecycleEvent(Event.ON_PAUSE)
    public void onPause() {
        Log.e(TAG, "ON_PAUSE");
    }
    @OnLifecycleEvent(Event.ON_RESUME)
    public void onResume() {
        Log.e(TAG, "ON_RESUME");
    }
    @OnLifecycleEvent(Event.ON_STOP)
    public void onStop() {
        Log.e(TAG, "ON_STOP");
    }
    @OnLifecycleEvent(Event.ON_ANY)
    public void onAny() {
        Log.e(TAG, "ON_ANY");
    }
}

Nic trudnego, prawda 😉 W aktywności wywołujemy tylko jedną metodę, która dodaje nasz obserwator. Zdefiniowana jest również prosta klasa, która rozszerza interfejs LifecycleObserver i dodaje definicje metod z adnotacjami OnLifeCycleEvent dla zdarzeń cyklu życia. Oczywiście przykład jest bardzo uproszczony, w codzinnym życiu kod jest bardziej rozbudowany.
Nie zapomnij dodać biblioteki do swojego projektu. 

Podsumowanie

Teraz, gdy lepiej rozumiemy, jak działa komponent Lifecycles jesteśmy w stanie lepiej obsługiwać zmiany konfiguracji w naszej aplikacji. Ale to nie wystarczy. W następnym wpisie przyjrzymy się komponentowi ViewModel, który w połączeniu już znanymi nam sekcjami daje wieksze możliwość przechowywania i zarządzania danymi związanymi z interfejsem użytkownika.

Nie zapomnij polubić stronę MYENV na Facebooku oraz śledźić nowe wpisy za pomocą kanału RSSTwittera. Oraz udostępnić ten wpis innym osobom, aby też mogli skorzystać z tej wiedzy. W tym celu skorzystaj z przycisków poniższych. Będę Ci za to bardzo wdzięczny. Dzięki!
Miłego dnia i Miłego kodowania ? 

Menu