Ciclo de vida de la aplicación

Las aplicaciones .NET Multi-platform App UI (.NET MAUI) suelen tener cuatro estados de ejecución: not running, running, deactivated y stopped. .NET MAUI genera eventos de ciclo de vida multiplataforma en la clase Window cuando una aplicación pasa del estado de no en ejecución al estado en ejecución, del estado en ejecución al estado desactivado, del estado desactivado al estado detenido, del estado detenido al estado en ejecución y del estado detenido al estado no en ejecución.

El siguiente diagrama muestra una vista general del ciclo de vida de la aplicación .NET MAUI:

En el diagrama, el óvalo gris indica que la aplicación no se carga en la memoria. Los óvalos azules claros indican que la aplicación está en la memoria. El texto de los arcos indica los eventos que genera .NET MAUI, que proporcionan notificaciones a la aplicación en ejecución.

El estado de ejecución de una aplicación depende del historial de la aplicación. Por ejemplo, cuando se instala una aplicación por primera vez o se inicia un dispositivo, la aplicación se puede considerar que no está en ejecución. Cuando se inicia la aplicación, se generan los eventos Created y Activated y la aplicación está en ejecución. Si otra ventana de aplicación obtiene el foco, se genera el evento Deactivated y la aplicación está desactivada. Si el usuario cambia a otra aplicación o vuelve a la pantalla de inicio del dispositivo, de modo que la ventana de la aplicación deja de estar visible, se generan los eventos Deactivated y Stopped y la aplicación está detenida. Si el usuario vuelve a la aplicación, se genera el evento Resuming y la aplicación está en ejecución. Como alternativa, un usuario podría finalizar una aplicación mientras se ejecuta. En esta situación, la aplicación se desactiva luego se detiene, se genera el evento Destroying y la aplicación no está en ejecución. Del mismo modo, un dispositivo podría finalizar una aplicación mientras se detiene, debido a restricciones de recursos y se genera el evento Destroying y la aplicación no está en ejecución.

Además, .NET MAUI permite a las aplicaciones recibir notificaciones cuando se generan eventos de ciclo de vida de la plataforma. Para obtener más información, consulta Eventos del ciclo de vida de la plataforma.

Eventos de ciclo de vida multiplataforma

La clase Window define los siguientes eventos de ciclo de vida multiplataforma:

Estos eventos multiplataforma se asignan a diferentes eventos de plataforma y en la tabla siguiente se muestra esta asignación:

Además, la clase Window también define un evento Backgrounding que se genera en iOS y Mac Catalyst cuando la ventana está cerrada o entra en un estado en segundo plano. Un objeto BackgroundingEventArgs acompaña a este evento y cualquier estado string debe conservarse en la propiedad State del objeto BackgroundingEventArgs, que el sistema operativo conservará hasta que sea el momento de reanudar la ventana. Cuando se reanuda la ventana, el argumento IActivationState proporciona el estado a la invalidación CreateWindow.

Además de estos eventos, la clase Window tiene los siguientes métodos de ciclo de vida reemplazables:

• OnCreated, que se invoca cuando se genera el evento Created.
• OnActivated, que se invoca cuando se genera el evento Activated.
• OnDeactivated, que se invoca cuando se genera el evento Deactivated.
• OnStopped, que se invoca cuando se genera el evento Stopped.
• OnResumed, que se invoca cuando se genera el evento Resumed.
• OnDestroying, que se invoca cuando se genera el evento Destroying.
• OnBackgrounding, que se invoca cuando se genera el evento Backgrounding.

Para suscribirte a los eventos Window de ciclo de vida, invalida el método CreateWindow de la clase App para crear una instancia de Window en la que puedas suscribirte a eventos:

namespace MyMauiApp
{
    public partial class App : Application
    {
        public App()
        {
            InitializeComponent();

            MainPage = new MainPage();
        }

        protected override Window CreateWindow(IActivationState activationState)
        {
            Window window = base.CreateWindow(activationState);

            window.Created += (s, e) =>
            {
                // Custom logic
            };

            return window;
        }
    }
}

Como alternativa, para consumir las invalidaciones del ciclo de vida, crea una clase que derive de la clase Window.

namespace MyMauiApp
{
    public class MyWindow : Window
    {
        public MyWindow() : base()
        {
        }

        public MyWindow(Page page) : base(page)
        {
        }

        protected override void OnCreated()
        {
            // Register services
        }
    }
}

Después, la clase derivada de Window se puede consumir invalidando el método CreateWindow de la clase App para devolver una instancia MyWindow.

Eventos de ciclo de vida de la plataforma

.NET MAUI define delegados que se invocan en respuesta a los eventos de ciclo de vida de la plataforma que se generan. Los controladores se pueden especificar para estos delegados, mediante métodos con nombre o funciones anónimas, que se ejecutan cuando se invoca al delegado. Este mecanismo permite a las aplicaciones recibir notificaciones cuando se generan eventos comunes del ciclo de vida de la plataforma.

Android

En la tabla siguiente se enumeran los delegados .NET MAUI que se invocan en respuesta a los eventos de ciclo de vida de Android que se generan:

Para responder a la invocación de un delegado de ciclo de vida de Android, llama al método ConfigureLifecycleEvents en el objeto MauiAppBuilder del método MauiProgram de la clase CreateMauiapp. Después, en el objeto ILifecycleBuilder, llama al método AddAndroid y especifica el elemento Action que registra controladores para los delegados necesarios:

using Microsoft.Maui.LifecycleEvents;

namespace PlatformLifecycleDemo
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .ConfigureLifecycleEvents(events =>
                {
#if ANDROID
                    events.AddAndroid(android => android
                        .OnActivityResult((activity, requestCode, resultCode, data) => LogEvent(nameof(AndroidLifecycle.OnActivityResult), requestCode.ToString()))
                        .OnStart((activity) => LogEvent(nameof(AndroidLifecycle.OnStart)))
                        .OnCreate((activity, bundle) => LogEvent(nameof(AndroidLifecycle.OnCreate)))
                        .OnBackPressed((activity) => LogEvent(nameof(AndroidLifecycle.OnBackPressed)) && false)
                        .OnStop((activity) => LogEvent(nameof(AndroidLifecycle.OnStop))));
#endif
                    static bool LogEvent(string eventName, string type = null)
                    {
                        System.Diagnostics.Debug.WriteLine($"Lifecycle event: {eventName}{(type == null ? string.Empty : $" ({type})")}");
                        return true;
                    }
                });

            return builder.Build();
        }
    }
}

Para obtener más información sobre el ciclo de vida de la aplicación Android, consulta Cómo interpretar el ciclo de vida de una actividad en developer.android.com.

iOS y Mac Catalyst

En la siguiente tabla se enumeran los delegados de .NET MAUI que se invocan en respuesta a los eventos de ciclo de vida de iOS y Mac Catalyst que se generan:

Para responder a un delegado de ciclo de vida de iOS y Mac Catalyst que se invoca, llame al método ConfigureLifecycleEvents en el objeto MauiAppBuilder del método CreateMauiapp de la clase MauiProgram. Después, en el objeto ILifecycleBuilder, llama al método AddiOS y especifica el elemento Action que registra controladores para los delegados necesarios:

using Microsoft.Maui.LifecycleEvents;

namespace PlatformLifecycleDemo
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .ConfigureLifecycleEvents(events =>
                {
#if IOS || MACCATALYST
                    events.AddiOS(ios => ios
                        .OnActivated((app) => LogEvent(nameof(iOSLifecycle.OnActivated)))
                        .OnResignActivation((app) => LogEvent(nameof(iOSLifecycle.OnResignActivation)))
                        .DidEnterBackground((app) => LogEvent(nameof(iOSLifecycle.DidEnterBackground)))
                        .WillTerminate((app) => LogEvent(nameof(iOSLifecycle.WillTerminate))));
#endif
                    static bool LogEvent(string eventName, string type = null)
                    {
                        System.Diagnostics.Debug.WriteLine($"Lifecycle event: {eventName}{(type == null ? string.Empty : $" ({type})")}");
                        return true;
                    }
                });

            return builder.Build();
        }
    }
}

Para obtener más información sobre el ciclo de vida de la aplicación de iOS, consulta Managing Your App's Life Cycle en developer.apple.com.

Windows

En la tabla siguiente se enumeran los delegados de .NET MAUI que se invocan en respuesta a los eventos de ciclo de vida de Windows que se generan:

.NET MAUI expone mensajes nativos específicos de Windows como un evento de ciclo de vida con el delegado OnPlatformMessage. El objeto WindowsPlatformMessageEventArgs que acompaña a este delegado incluye una propiedad MessageId de tipo uint. El valor de esta propiedad se puede examinar para determinar qué mensaje se ha pasado a la ventana de tu aplicación. Para obtener más información sobre los mensajes de Windows, consulta Mensajes de Windows (Introducción a Win32 y C++). Para obtener una lista de constantes de mensajes de ventana, consulta Notificaciones de ventana.

Para responder a la invocación de un delegado de ciclo de vida de Windows, llama al método ConfigureLifecycleEvents en el objeto MauiAppBuilder del método CreateMauiApp de tu clase MauiProgram. Después, en el objeto ILifecycleBuilder, llama al método AddWindows y especifica el elemento Action que registra controladores para los delegados necesarios:

using Microsoft.Maui.LifecycleEvents;

namespace PlatformLifecycleDemo
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .ConfigureLifecycleEvents(events =>
                {
#if WINDOWS
                    events.AddWindows(windows => windows
                           .OnActivated((window, args) => LogEvent(nameof(WindowsLifecycle.OnActivated)))
                           .OnClosed((window, args) => LogEvent(nameof(WindowsLifecycle.OnClosed)))
                           .OnLaunched((window, args) => LogEvent(nameof(WindowsLifecycle.OnLaunched)))
                           .OnLaunching((window, args) => LogEvent(nameof(WindowsLifecycle.OnLaunching)))
                           .OnVisibilityChanged((window, args) => LogEvent(nameof(WindowsLifecycle.OnVisibilityChanged)))
                           .OnPlatformMessage((window, args) =>
                           {
                               if (args.MessageId == Convert.ToUInt32("031A", 16))
                               {
                                   // System theme has changed
                               }
                           }));
#endif
                    static bool LogEvent(string eventName, string type = null)
                    {
                        System.Diagnostics.Debug.WriteLine($"Lifecycle event: {eventName}{(type == null ? string.Empty : $" ({type})")}");
                        return true;
                    }
                });

            return builder.Build();
        }
    }
}

Recuperar el objeto Window

El código de la plataforma puede recuperar el objeto Window de la aplicación de los eventos del ciclo de vida de la plataforma, con el método de extensión GetWindow:

using Microsoft.Maui.LifecycleEvents;

namespace PlatformLifecycleDemo
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .ConfigureLifecycleEvents(events =>
                {
#if WINDOWS
                    events.AddWindows(windows => windows
                            .OnClosed((window, args) =>
                            {
                                IWindow appWindow = window.GetWindow();
                            }));
#endif
                });

            return builder.Build();
        }
    }
}

Eventos de ciclo de vida personalizados

Si bien .NET MAUI define delegados que se invocan en respuesta a eventos de ciclo de vida de la plataforma que se generan, solo expone un conjunto común de eventos de ciclo de vida de la plataforma. Pero también incluye un mecanismo, normalmente para los autores de bibliotecas, que permite a las aplicaciones recibir notificaciones cuando se generan eventos adicionales del ciclo de vida de la plataforma. El proceso para llevarlo a cabo es el siguiente:

• Registra un controlador de eventos para un evento de ciclo de vida de la plataforma que .NET MAUI no exponga.
• En el controlador de eventos para el evento de ciclo de vida de la plataforma, recupere la instancia ILifecycleEventService y llama a su método InvokeEvents, especificando el nombre del evento de la plataforma como argumento.

Después, las aplicaciones que quieran recibir la notificación del evento de ciclo de vida de la plataforma deben modificar el método CreateMauiApp de su clase MauiProgram para llamar al método ConfigureLifecycleEvents en el objeto MauiAppBuilder. Después, en el objeto ILifecycleBuilder, llama al método AddEvent y especifica el nombre del evento de la plataforma y el elemento Action que se invocará cuando se genere el evento de plataforma.

Ejemplo

El evento Window.SizeChanged de WinUI 3 se produce cuando la ventana de la aplicación nativa se ha representado por primera vez o ha cambiado su tamaño de representación. .NET MAUI no expone este evento de plataforma como un evento de ciclo de vida. Pero las aplicaciones pueden recibir notificaciones cuando se genera este evento de plataforma mediante el siguiente enfoque:

• Registra un controlador de eventos para el evento de ciclo de vida de la plataforma Window.SizeChanged:

  using Microsoft.Maui.LifecycleEvents;
  ...
  
  public static MauiApp CreateMauiApp()
  {
        var builder = MauiApp.CreateBuilder();
        builder
              .UseMauiApp<App>()
              .ConfigureLifecycleEvents(events =>
              {
  #if WINDOWS
                    events.AddWindows(windows => windows
                           .OnWindowCreated(window =>
                           {
                                  window.SizeChanged += OnSizeChanged;
                           }));
  #endif
              });
  
        return builder.Build();
  }    
  

• En el controlador de eventos para el evento de ciclo de vida de la plataforma, recupere la instancia ILifecycleEventService y llama a su método InvokeEvents, especificando el nombre del evento de la plataforma como su argumento:

  using Microsoft.Maui.LifecycleEvents;
  ...
  
  #if WINDOWS
          static void OnSizeChanged(object sender, Microsoft.UI.Xaml.WindowSizeChangedEventArgs args)
          {
              ILifecycleEventService service = MauiWinUIApplication.Current.Services.GetRequiredService<ILifecycleEventService>();
              service.InvokeEvents(nameof(Microsoft.UI.Xaml.Window.SizeChanged));
          }
  #endif
  

  El tipo MauiWinUIApplication en Windows se puede usar para acceder a la instancia de aplicación nativa a través de su propiedad Current. El tipo MauiApplication en Android se puede usar para acceder a la instancia de aplicación nativa. Del mismo modo, el tipo MauiUIApplicationDelegate en iOS se puede usar para acceder a la instancia de aplicación nativa.

  Advertencia

  Invocar un evento no registrado, con el método InvokeEvents, no genera una excepción.

• En el método CreateMauiApp de la clase MauiProgram , llama al método ConfigureLifecycleEvents en el objeto MauiAppBuilder . Después en el objeto ILifecycleBuilder, llama al método AddEvent y especifica el nombre del evento de plataforma y el elemento Action que se invocará cuando se genere el evento de plataforma:

  using Microsoft.Maui.LifecycleEvents;
  
  namespace PlatformLifecycleDemo
  {
      public static class MauiProgram
      {
          public static MauiApp CreateMauiApp()
          {
              var builder = MauiApp.CreateBuilder();
              builder
                  .UseMauiApp<App>()
                  .ConfigureLifecycleEvents(events =>
                  {
  #if WINDOWS
                      events.AddWindows(windows => windows
                             .OnWindowCreated(window =>
                             {
                                    window.SizeChanged += OnSizeChanged;
                             }));
  
                      events.AddEvent(nameof(Microsoft.UI.Xaml.Window.SizeChanged), () => LogEvent("Window SizeChanged"));
  #endif
                      static bool LogEvent(string eventName, string type = null)
                      {
                          System.Diagnostics.Debug.WriteLine($"Lifecycle event: {eventName}{(type == null ? string.Empty : $" ({type})")}");
                          return true;
                      }
                  });
  
              return builder.Build();
          }
      }
  }
  

El efecto general es que cuando un usuario cambia el tamaño de la ventana de la aplicación en Windows, se ejecuta la acción especificada en el método AddEvent.