Xamarin.Android
Ciclo de vida de la aplicación - Xamarin.Andorid

Introducción

Observaciones

Ciclo de vida de la aplicación

En primer lugar, debe saber que puede extender la clase de aplicación Android.Aplication para que pueda acceder a dos métodos importantes relacionados con el ciclo de vida de la aplicación:

• OnCreate: se llama cuando se inicia la aplicación, antes de que se hayan creado otros objetos de la aplicación (como MainActivity).

• OnTerminate: este método es para uso en entornos de procesos emulados. Nunca se llamará a un dispositivo Android de producción, donde los procesos se eliminan simplemente matándolos; No se ejecuta ningún código de usuario (incluida esta devolución de llamada) al hacerlo. De la documentación: https://developer.android.com/reference/android/app/Application.html#onTerminate ()

En la aplicación Xamarin.Android, puede extender la clase de aplicación de la forma que se presenta a continuación. Agregue una nueva clase llamada "MyApplication.cs" a su proyecto:

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

Como escribiste anteriormente puedes usar el método OnCreate. Por ejemplo, puede inicializar la base de datos local aquí o configurar alguna configuración adicional.

También hay más métodos que se pueden anular, como: OnConfigurationChanged o OnLowMemory.

Ciclo de vida de la actividad

El ciclo de vida de la actividad es bastante más complejo. Como saben, Activity es una página única en la aplicación de Android donde el usuario puede interactuar con ella.

En el diagrama a continuación puedes ver cómo se ve el ciclo de vida de la actividad de Android:

Como puede ver, hay un flujo específico del ciclo de vida de la actividad. En la aplicación móvil, tienes métodos de curso en cada clase de actividad que manejan un fragmento de ciclo de vida específico:

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

Hay una buena descripción en la documentación oficial de Android:

• Toda la vida útil de una actividad transcurre desde la primera llamada a onCreate (Bundle) hasta una única llamada final a onDestroy (). Una actividad realizará toda la configuración del estado "global" en onCreate () y liberará todos los recursos restantes en onDestroy (). Por ejemplo, si tiene un hilo ejecutándose en segundo plano para descargar datos de la red, puede crear ese hilo en onCreate () y luego detener el hilo en onDestroy ().

• El tiempo de vida visible de una actividad ocurre entre una llamada a onStart () hasta una llamada correspondiente a onStop (). Durante este tiempo, el usuario puede ver la actividad en pantalla, aunque es posible que no esté en primer plano y no interactúe con el usuario. Entre estos dos métodos puede mantener los recursos necesarios para mostrar la actividad al usuario. Por ejemplo, puede registrar un BroadcastReceiver en onStart () para monitorear los cambios que afectan su UI, y anular el registro en onStop () cuando el usuario ya no vea lo que está mostrando. Los métodos onStart () y onStop () se pueden llamar varias veces, a medida que la actividad se hace visible y oculta para el usuario.

• El tiempo de vida de una actividad en primer plano ocurre entre una llamada a onResume () hasta una llamada correspondiente a onPause (). Durante este tiempo, la actividad está delante de todas las demás actividades e interactúa con el usuario. Con frecuencia, una actividad puede ir entre los estados de reanudación y pausa, por ejemplo, cuando el dispositivo entra en modo de suspensión, cuando se entrega un resultado de actividad, cuando se entrega una nueva intención, por lo que el código de estos métodos debe ser bastante ligero.

Ciclo de vida del fragmento

Como usted sabe, puede tener una actividad pero diferentes fragmentos incrustados en ella. Es por eso que el ciclo de vida del fragmento también es importante para los desarrolladores.

En el diagrama a continuación, puede ver cómo se ve el ciclo de vida del fragmento de Android:

Como se describe en la documentación oficial de Android, debe implementar al menos tres métodos a continuación:

• OnCreate: el sistema lo llama al crear el fragmento. Dentro de su implementación, debe inicializar los componentes esenciales del fragmento que desea conservar cuando el fragmento se detiene o se detiene, y luego se reanuda.

• OnCreateView: el sistema lo llama cuando llega el momento de que el fragmento dibuje su interfaz de usuario por primera vez. Para dibujar una IU para su fragmento, debe devolver una Vista desde este método que es la raíz del diseño de su fragmento. Puede devolver nulo si el fragmento no proporciona una interfaz de usuario.

• OnPause: el sistema llama a este método como la primera indicación de que el usuario está dejando el fragmento (aunque no siempre significa que se está destruyendo el fragmento). Por lo general, aquí es donde debe realizar cualquier cambio que deba persistir más allá de la sesión del usuario actual (porque es posible que el usuario no regrese).

Aquí está la implementación de ejemplo en 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();
    }
}

Por supuesto, puede agregar métodos adicionales aquí si desea manejar diferentes estados.

Muestra completa en GitHub

Si desea obtener el proyecto base con los métodos que se describen a continuación, puede descargar la plantilla de la aplicación Xamarin.Android desde mi GitHub. Puedes encontrar ejemplos para:

• Métodos de ciclo de vida de la aplicación.
• Métodos del ciclo de vida de la actividad.
• Métodos del ciclo de vida del fragmento.

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