Xamarin.Android
Cykl życia aplikacji - Xamarin.Andorid

Wprowadzenie

Uwagi

Cykl życia aplikacji

Przede wszystkim powinieneś wiedzieć, że możesz rozszerzyć klasę Android.Application, aby uzyskać dostęp do dwóch ważnych metod związanych z cyklem życia aplikacji:

• OnCreate - Wywoływany podczas uruchamiania aplikacji, zanim zostaną utworzone inne obiekty aplikacji (takie jak MainActivity).

• OnTerminate - ta metoda jest przeznaczona do użycia w emulowanych środowiskach procesowych. Nigdy nie zostanie wywołany na produkcyjnym urządzeniu z Androidem, gdzie procesy są usuwane po prostu przez ich zabicie; Nie wykonuje się przy tym żadnego kodu użytkownika (w tym tego wywołania zwrotnego). Z dokumentacji: https://developer.android.com/reference/android/app/Application.html#onTerminate ()

W aplikacji Xamarin.Android można rozszerzyć klasę aplikacji w sposób przedstawiony poniżej. Dodaj nową klasę o nazwie „MyApplication.cs” do swojego projektu:

[Application]
public class MyApplication : Application
{
    public MyApplication(IntPtr handle, JniHandleOwnership ownerShip) : base(handle, ownerShip)
    {
    }

    public override void OnCreate()
    {
        base.OnCreate();
    }

    public override void OnTerminate()
    {
        base.OnTerminate();
    }
}

Jak napisałeś powyżej, możesz użyć metody OnCreate. Możesz na przykład zainicjować lokalną bazę danych tutaj lub skonfigurować dodatkową konfigurację.

Istnieje również więcej metod, które można zastąpić, takich jak: OnConfigurationChanged lub OnLowMemory.

Cykl życia aktywności

Cykl życia aktywności jest znacznie bardziej złożony. Jak wiadomo Aktywność to pojedyncza strona w aplikacji na Androida, na której użytkownik może wykonywać z nią interakcje.

Na poniższym diagramie możesz zobaczyć, jak wygląda cykl życia Android:

Jak widać, istnieje specyficzny przebieg cyklu życia działania. W aplikacji mobilnej masz oczywiście metody w każdej klasie Activity, które obsługują określony fragment cyklu życia:

[Activity(Label = "LifecycleApp", MainLauncher = true, Icon = "@mipmap/icon")]
public class MainActivity : Activity
{
    protected override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);
        Log.Debug("OnCreate", "OnCreate called, Activity components are being created");

        // Set our view from the "main" layout resource
        SetContentView(Resource.Layout.MainActivity);
    }

    protected override void OnStart()
    {
        Log.Debug("OnStart", "OnStart called, App is Active");
        base.OnStart();
    }

    protected override void OnResume()
    {
        Log.Debug("OnResume", "OnResume called, app is ready to interact with the user");
        base.OnResume();
    }

    protected override void OnPause()
    {
        Log.Debug("OnPause", "OnPause called, App is moving to background");
        base.OnPause();
    }

    protected override void OnStop()
    {
        Log.Debug("OnStop", "OnStop called, App is in the background");
        base.OnStop();
    }

    protected override void OnDestroy()
    {
        base.OnDestroy();
        Log.Debug("OnDestroy", "OnDestroy called, App is Terminating");
    }
}

Dobry opis znajduje się w oficjalnej dokumentacji Androida:

• Cały czas trwania działania ma miejsce od pierwszego wywołania do onCreate (pakiet) do pojedynczego końcowego wywołania do onDestroy (). Działanie wykona całą konfigurację stanu „globalnego” w funkcji onCreate () i zwolni wszystkie pozostałe zasoby w funkcji onDestroy (). Na przykład, jeśli wątek działa w tle, aby pobrać dane z sieci, może utworzyć ten wątek w funkcji onCreate (), a następnie zatrzymać wątek w funkcji onDestroy ().

• Widoczny czas życia działania występuje między wywołaniem onStart (), aż do odpowiedniego wywołania onStop (). W tym czasie użytkownik może zobaczyć aktywność na ekranie, chociaż może ona nie znajdować się na pierwszym planie i wchodzić w interakcje z użytkownikiem. Pomiędzy tymi dwiema metodami możesz utrzymywać zasoby potrzebne do pokazania aktywności użytkownikowi. Na przykład można zarejestrować BroadcastReceiver w onStart (), aby monitorować zmiany wpływające na interfejs użytkownika, i wyrejestrować go w onStop (), gdy użytkownik nie widzi już tego, co wyświetla. Metody onStart () i onStop () można wywoływać wiele razy, ponieważ aktywność staje się widoczna i ukryta dla użytkownika.

• Cykl życia działania na pierwszym planie ma miejsce między wywołaniem onResume (), aż do odpowiedniego wywołania onPause (). W tym czasie aktywność znajduje się przed wszystkimi innymi aktywnościami i wchodzi w interakcję z użytkownikiem. Aktywność często może przechodzić między stanami wznowionym i wstrzymanym - na przykład, gdy urządzenie przechodzi w tryb uśpienia, gdy dostarczany jest wynik działania, gdy dostarczana jest nowa intencja - więc kod w tych metodach powinien być dość lekki.

Cykl życia fragmentu

Jak wiesz, możesz mieć jedną aktywność, ale osadzone w niej różne fragmenty. Dlatego cykl życia fragmentów jest również ważny dla programistów.

Na poniższym schemacie możesz zobaczyć, jak wygląda cykl życia fragmentów Androida:

Jak opisano w oficjalnej dokumentacji Androida, należy wdrożyć co najmniej trzy metody:

• OnCreate - system wywołuje to podczas tworzenia fragmentu. W ramach implementacji powinieneś zainicjować niezbędne komponenty fragmentu, które chcesz zachować, gdy fragment zostanie wstrzymany lub zatrzymany, a następnie wznowiony.

• OnCreateView - system wywołuje to, gdy fragment po raz pierwszy rysuje interfejs użytkownika. Aby narysować interfejs użytkownika dla swojego fragmentu, musisz zwrócić widok z tej metody, który jest głównym układem fragmentu. Możesz zwrócić null, jeśli fragment nie zawiera interfejsu użytkownika.

• OnPause - system wywołuje tę metodę jako pierwszą wskazówkę, że użytkownik opuszcza fragment (choć nie zawsze oznacza to, że fragment jest niszczony). W tym miejscu zwykle należy zatwierdzić wszelkie zmiany, które należy utrwalić poza bieżącą sesją użytkownika (ponieważ użytkownik może nie wrócić).

Oto przykładowa implementacja w Xamarin.Android:

public class MainFragment : Fragment
{
    public override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);

        // Create your fragment here
        // You should initialize essential components of the fragment
        // that you want to retain when the fragment is paused or stopped, then resumed.
    }

    public override View OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
    {
        // Use this to return your custom view for this Fragment
        // The system calls this when it's time for the fragment to draw its user interface for the first time.

        var mainView = inflater.Inflate(Resource.Layout.MainFragment, container, false);
        return mainView;
    }

    public override void OnPause()
    {
        // The system calls this method as the first indication that the user is leaving the fragment 

        base.OnPause();
    }
}

Oczywiście możesz dodać tutaj dodatkowe metody, jeśli chcesz obsługiwać różne stany.

Pełna próbka na GitHub

Jeśli chcesz uzyskać projekt podstawowy metodami opisanymi poniżej, możesz pobrać szablon aplikacji Xamarin.Android z mojego GitHub. Możesz znaleźć przykłady:

• Metody cyklu życia aplikacji
• Metody cyklu życia aktywności
• Metody cyklu życia fragmentów

https://github.com/Daniel-Krzyczkowski/XamarinAndroid/tree/master/AndroidLifecycle/LifecycleApp