Xamarin.Android
Appens livscykel - Xamarin.Andorid

Introduktion

Anmärkningar

Applikationens livscykel

Först och främst bör du veta att du kan utöka Android.Applikationsklass så att du kan komma åt två viktiga metoder relaterade till appens livscykel:

• OnCreate - Ringas när applikationen startar innan några andra applikationsobjekt har skapats (som MainActivity).

• OnTerminate - Den här metoden är avsedd att användas i emulerade processmiljöer. Det kommer aldrig att kallas på en produktions Android-enhet, där processer tas bort genom att helt enkelt döda dem; Ingen användarkod (inklusive detta återuppringning) körs när du gör det. Från dokumentationen: https://developer.android.com/reference/android/app/Application.html#onTerminate ()

I Xamarin.Android-applikationen kan du utöka Application Class på det sätt som presenteras nedan. Lägg till en ny klass som heter "MyApplication.cs" till ditt projekt:

[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();
    }
}

Som du skrev ovan kan du använda OnCreate-metoden. Du kan till exempel initialisera den lokala databasen här eller ställa in en extra konfiguration.

Det finns också fler metoder som kan åsidosättas som: OnConfigurationChanged eller OnLowMemory.

Aktivitetslivscykel

Aktivitetslivscykeln är ganska mer komplex. Som ni vet är aktivitet en enda sida i Android-appen där användaren kan utföra interaktion med den.

På diagrammet nedan kan du se hur Android Aktivitetslivscykel ser ut:

Som du kan se finns det ett specifikt flöde av aktivitetens livscykel. I mobilapplikationen har du naturligtvis metoder i varje aktivitetsklass som hanterar specifikt livscykelfragment:

[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");
    }
}

Det finns en bra beskrivning i den officiella Android-dokumentationen:

• Hela livslängden för en aktivitet sker mellan det första samtalet till onCreate (Bundle) till ett enda slutligt samtal till onDestroy (). En aktivitet gör all installation av "global" status i onCreate () och släpper alla återstående resurser i onDestroy (). Om den till exempel har en tråd som körs i bakgrunden för att ladda ner data från nätverket, kan den skapa den tråden i onCreate () och sedan stoppa tråden i onDestroy ().

• Den synliga livslängden för en aktivitet sker mellan ett samtal till onStart () tills ett motsvarande samtal till onStop (). Under denna tid kan användaren se aktiviteten på skärmen, även om den kanske inte är i förgrunden och interagerar med användaren. Mellan dessa två metoder kan du behålla resurser som behövs för att visa aktiviteten för användaren. Till exempel kan du registrera en BroadcastReceiver i onStart () för att övervaka för ändringar som påverkar ditt UI och avregistrera den i onStop () när användaren inte längre ser vad du visar. Metoderna onStart () och onStop () kan kallas flera gånger eftersom aktiviteten blir synlig och dold för användaren.

• En aktivitets förgrundslivstid sker mellan ett samtal till onResume () tills ett motsvarande samtal till onPause (). Under denna tid står aktiviteten framför alla andra aktiviteter och interagerar med användaren. En aktivitet kan ofta gå mellan de återupptagna och pausade tillstånden - till exempel när enheten går i vila, när ett aktivitetsresultat levereras, när en ny avsikt levereras - så koden i dessa metoder bör vara ganska lätt.

Fragmentens livscykel

Som du vet kan du ha en aktivitet men olika fragment inbäddade i den. Därför är fragmentlivscykeln också viktig för utvecklare.

På diagrammet nedan kan du se hur Android-fragmentets livscykel ser ut:

Som beskrivs i den officiella Android-dokumentationen bör du implementera minst under tre metoder:

• OnCreate - systemet kallar detta när du skapar fragmentet. Inom din implementering bör du initiera viktiga komponenter i fragmentet som du vill behålla när fragmentet pausas eller stoppas och sedan återupptas.

• OnCreateView - Systemet kallar detta när det är dags för fragmentet att rita sitt användargränssnitt för första gången. För att rita ett användargränssnitt för ditt fragment måste du returnera en vy från den här metoden som är roten till ditt fragments layout. Du kan returnera null om fragmentet inte ger ett användargränssnitt.

• OnPause - Systemet kallar den här metoden som den första indikationen på att användaren lämnar fragmentet (även om det inte alltid betyder att fragmentet förstörs). Det är vanligtvis där du bör göra ändringar som bör fortsätta utöver den aktuella användarsessionen (eftersom användaren kanske inte kommer tillbaka).

Här är provimplementering i 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();
    }
}

Naturligtvis kan du lägga till ytterligare metoder här om du vill hantera olika tillstånd.

Fullständigt prov på GitHub

Om du vill få basprojekt med metoder som beskrivs nedan kan du ladda ner Xamarin.Android-applikationsmall från min GitHub. Du kan hitta exempel på:

• Användningscykelmetoder
• Aktivitetslivscykelmetoder
• Fragmentets livscykelmetoder

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