Xamarin.Android
App levenscyclus - Xamarin.Andorid

Invoering

Opmerkingen

Applicatie levenscyclus

Allereerst moet u weten dat u Android.Application-klasse kunt uitbreiden, zodat u toegang hebt tot twee belangrijke methoden met betrekking tot de levenscyclus van apps:

• OnCreate - Wordt aangeroepen wanneer de toepassing wordt gestart voordat andere toepassingsobjecten zijn gemaakt (zoals MainActivity).

• OnTerminate - Deze methode is bedoeld voor gebruik in geëmuleerde procesomgevingen. Het zal nooit worden aangeroepen op een productie-Android-apparaat, waar processen worden verwijderd door ze eenvoudigweg te doden; Er wordt geen gebruikerscode (inclusief deze callback) uitgevoerd. Uit de documentatie: https://developer.android.com/reference/android/app/Application.html#onTerminate ()

In Xamarin.Android-applicatie kunt u de toepassingsklasse op de onderstaande manier uitbreiden. Voeg een nieuwe klasse met de naam "MyApplication.cs" toe aan uw project:

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

Zoals u hierboven schreef, kunt u de OnCreate-methode gebruiken. U kunt hier bijvoorbeeld de lokale database initialiseren of een extra configuratie instellen.

Er zijn ook meer methoden die kunnen worden genegeerd, zoals: OnConfigurationChanged of OnLowMemory.

Activiteit levenscyclus

De levenscyclus van activiteiten is behoorlijk complex. Zoals u weet, is Activiteit één pagina in de Android-app waar de gebruiker er interactie mee kan uitvoeren.

In het onderstaande diagram kunt u zien hoe de Android Activity lifecycle eruit ziet:

Zoals u kunt zien, is er een specifieke stroom van activiteitenlevenscyclus. In de mobiele applicatie heb je natuurlijk methoden in elke activiteitsklasse die een specifiek levenscyclusfragment verwerken:

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

Er is een goede beschrijving in de officiële Android-documentatie:

• De hele levensduur van een activiteit vindt plaats tussen de eerste aanroep naar onCreate (bundel) tot een enkele laatste aanroep naar onDestroy (). Een activiteit zal alle instellingen van de "algemene" status in onCreate () uitvoeren en alle resterende bronnen in onDestroy () vrijgeven. Als het bijvoorbeeld een thread op de achtergrond heeft om gegevens van het netwerk te downloaden, kan het die thread maken in onCreate () en de thread stoppen in onDestroy ().

• De zichtbare levensduur van een activiteit vindt plaats tussen een aanroep van onStart () tot een overeenkomstige aanroep van onStop (). Gedurende deze tijd kan de gebruiker de activiteit op het scherm zien, hoewel deze mogelijk niet op de voorgrond staat en interactie heeft met de gebruiker. Tussen deze twee methoden kunt u middelen behouden die nodig zijn om de activiteit aan de gebruiker te tonen. U kunt bijvoorbeeld een BroadcastReceiver registreren in onStart () om te controleren op wijzigingen die van invloed zijn op uw gebruikersinterface en de registratie ongedaan maken in onStop () wanneer de gebruiker niet meer ziet wat u weergeeft. De methoden onStart () en onStop () kunnen meerdere keren worden aangeroepen, omdat de activiteit zichtbaar en verborgen wordt voor de gebruiker.

• De voorgrondduur van een activiteit vindt plaats tussen een aanroep van onResume () tot een overeenkomstige aanroep van onPause (). Gedurende deze tijd staat de activiteit voor alle andere activiteiten en interactie met de gebruiker. Een activiteit kan vaak tussen de hervatte en gepauzeerde status gaan - bijvoorbeeld wanneer het apparaat in slaapstand gaat, wanneer een activiteitsresultaat wordt afgeleverd, wanneer een nieuwe intentie wordt afgeleverd - dus de code in deze methoden moet redelijk licht zijn.

Fragment levenscyclus

Zoals u weet, kunt u één activiteit maar verschillende fragmenten erin hebben. Daarom is een fragmentlevenscyclus ook belangrijk voor ontwikkelaars.

In het onderstaande diagram kunt u zien hoe de Android-fragmentlevenscyclus eruit ziet:

Zoals beschreven in de officiële Android-documentatie, moet u ten minste drie methoden implementeren:

• OnCreate - het systeem noemt dit bij het maken van het fragment. Binnen uw implementatie moet u essentiële componenten van het fragment initialiseren dat u wilt behouden wanneer het fragment wordt gepauzeerd of gestopt en vervolgens wordt hervat.

• OnCreateView - Het systeem roept dit aan wanneer het tijd is voor het fragment om zijn gebruikersinterface voor het eerst te tekenen. Als u een gebruikersinterface voor uw fragment wilt tekenen, moet u een weergave van deze methode retourneren die de basis is van de lay-out van uw fragment. U kunt null retourneren als het fragment geen gebruikersinterface biedt.

• OnPause - Het systeem noemt deze methode als de eerste indicatie dat de gebruiker het fragment verlaat (hoewel dit niet altijd betekent dat het fragment wordt vernietigd). Dit is meestal waar u wijzigingen moet doorvoeren die moeten worden voortgezet na de huidige gebruikerssessie (omdat de gebruiker mogelijk niet terugkomt).

Hier is een voorbeeldimplementatie in 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();
    }
}

Natuurlijk kunt u hier extra methoden toevoegen als u verschillende statussen wilt verwerken.

Volledig voorbeeld op GitHub

Als je een basisproject wilt krijgen met de hieronder beschreven methoden, kun je de Xamarin.Android-toepassingssjabloon downloaden van mijn GitHub. U kunt voorbeelden vinden voor:

• Toepassingslevenscyclusmethoden
• Methoden voor activiteitenlevenscyclus
• Fragment levenscyclusmethoden

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