Ciclo de vida do aplicativo

Artigo
05/15/2024

Os aplicativos .NET MAUI (.NET Multi-platform App UI) geralmente têm quatro estados de execução: não executando, em execução, desativado e interrompido. O .NET MAUI gera eventos de ciclo de vida multiplataforma na classe Window quando um aplicativo faz a transição do estado não executando para o estado em execução, do estado em execução para o estado desativado, do estado desativado para o estado interrompido, do estado interrompido para o estado em execução e do estado interrompido para o estado não executando.

O seguinte diagrama mostra uma visão geral do ciclo de vida do aplicativo .NET MAUI:

Ciclo de vida do aplicativo .NET MAUI

No diagrama, o oval cinza indica que o aplicativo não é carregado na memória. As ovais azul-claros indicam que o aplicativo está na memória. O texto em arcos indica eventos gerados pelo .NET MAUI, que fornecem notificações para o aplicativo em execução.

O estado de execução de um aplicativo depende do histórico do aplicativo. Por exemplo, quando um aplicativo é instalado pela primeira vez ou um dispositivo é iniciado, o aplicativo pode ser considerado como não executando. Quando o aplicativo é iniciado, os eventos Created e Activated são gerados e o aplicativo está em execução. Se uma janela do aplicativo diferente ganhar foco, o evento Deactivated será acionado e o aplicativo será desativado. Se o usuário alternar para um aplicativo diferente ou retornar para a tela Inicial do dispositivo, para que a janela do aplicativo não fique mais visível, os eventos Deactivated e Stopped serão gerados e o aplicativo será interrompido. Se o usuário retornar para o aplicativo, o evento Resuming será gerado e o aplicativo estará em execução. Como alternativa, um aplicativo pode ser encerrado por um usuário durante a execução. Nessa situação, o aplicativo é desativado e depois interrompido; o evento Destroying é gerado e o aplicativo está no estado não executando. Da mesma forma, um dispositivo pode encerrar um aplicativo enquanto ele está parado, devido a restrições de recursos, e o evento Destroying é gerado e o aplicativo está no estado não executando.

Além disso, o .NET MAUI permite que os aplicativos sejam notificados quando os eventos do ciclo de vida da plataforma forem gerados. Para obter mais informações, confira Eventos de ciclo de vida da plataforma.

Eventos de ciclo de vida multiplataforma

A classe Window define os seguintes eventos de ciclo de vida multiplataforma:

Evento	Descrição	Ação a ser tomada
`Created`	Esse evento é gerado após a criação da janela nativa. Neste ponto, a janela multiplataforma terá um manipulador de janela nativo, mas a janela talvez não esteja visível ainda.
`Activated`	Esse evento é gerado quando a janela é ativada e é, ou se tornará, a janela focada.
`Deactivated`	Esse evento é gerado quando a janela não é mais a janela focada. No entanto, a janela ainda pode estar visível.
`Stopped`	Esse evento é gerado quando a janela não está mais visível. Não há nenhuma garantia de que um aplicativo será retomado desse estado, pois ele pode ser encerrado pelo sistema operacional.	Desconecte-se de processos de execução prolongada ou cancele as solicitações pendentes que possam consumir recursos do dispositivo.
`Resumed`	Esse evento é gerado quando um aplicativo é retomado após ser interrompido. Esse evento não será gerado na primeira vez que seu aplicativo for iniciado e só poderá ser gerado se o evento `Stopped` tiver sido gerado anteriormente.	Assine todos os eventos necessários e atualize qualquer conteúdo que esteja na página visível.
`Destroying`	Esse evento é gerado quando a janela nativa está sendo destruída e desalocada. A mesma janela multiplataforma pode ser usada em uma nova janela nativa quando o aplicativo é reaberto.	Remova todas as assinaturas de evento anexadas à janela nativa.

Esses eventos multiplataforma são mapeados para diferentes eventos de plataforma, e a seguinte tabela mostra esse mapeamento:

Evento	Android	iOS	Windows
`Created`	`OnPostCreate`	`FinishedLaunching`	`Created`
`Activated`	`OnResume`	`OnActivated`	`Activated` (`CodeActivated` e `PointerActivated`)
`Deactivated`	`OnPause`	`OnResignActivation`	`Activated` (`Deactivated`)
`Stopped`	`OnStop`	`DidEnterBackground`	`VisibilityChanged`
`Resumed`	`OnRestart`	`WillEnterForeground`	`Resumed`
`Destroying`	`OnDestroy`	`WillTerminate`	`Closed`

Além disso, a classe Window também define um evento Backgrounding gerado no iOS e no Mac Catalyst quando a janela é fechada ou entra em um estado em segundo plano. Um objeto BackgroundingEventArgs acompanha esse evento e qualquer estado string deve ser mantido na propriedade State do objeto BackgroundingEventArgs, que o sistema operacional preservará até que seja hora de retomar a janela. Quando a janela é retomada, o estado é fornecido pelo argumento IActivationState para a substituição de CreateWindow.

Além desses eventos, a classe Window também tem os seguintes métodos de ciclo de vida substituíveis:

OnCreated, que é invocado quando o evento Created é gerado.
OnActivated, que é invocado quando o evento Activated é gerado.
OnDeactivated, que é invocado quando o evento Deactivated é gerado.
OnStopped, que é invocado quando o evento Stopped é gerado.
OnResumed, que é invocado quando o evento Resumed é gerado.
OnDestroying, que é invocado quando o evento Destroying é gerado.
OnBackgrounding, que é invocado quando o evento Backgrounding é gerado.

Para assinar os eventos de ciclo de vida Window, substitua o método CreateWindow na classe App para criar uma instância Window na qual você pode assinar 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 as substituições do ciclo de vida, crie uma classe que derive da classe Window

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

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

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

A classe derivada de Window pode ser consumida substituindo o método CreateWindow na classe App para retornar uma instância MyWindow.

Aviso

Um InvalidOperationException será gerado se a propriedade App.MainPage for definida e o método CreateWindow criar um objeto Window usando a substituição que aceita um argumento Page.

Eventos de ciclo de vida da plataforma

O .NET MAUI define delegados invocados em resposta aos eventos de ciclo de vida da plataforma que estão sendo gerados. Os manipuladores podem ser especificados para esses delegados, usando métodos nomeados ou funções anônimas, que são executados quando o delegado é invocado. Esse mecanismo permite que os aplicativos sejam notificados quando eventos comuns de ciclo de vida da plataforma são gerados.

Importante

O método ConfigureLifecycleEvents está no namespace Microsoft.Maui.LifecycleEvents.

Android

A seguinte tabela lista os delegados do .NET MAUI invocados em resposta aos eventos de ciclo de vida do Android que estão sendo gerados:

Delegar	Argumentos	Descrição	Comentários
`OnActivityResult`	`Android.App.Activity`, `int`, `Android.App.Result`, `Android.Content.Intent?`	Invocado quando uma atividade que você iniciou é encerrada.
`OnApplicationConfigurationChanged`	`Android.App.Application`, `Android.Content.Res.Configuration`	Invocado quando a configuração do dispositivo é alterada enquanto o componente está em execução.
`OnApplicationCreate`	`Android.App.Application`	Invocado quando o aplicativo é iniciado, antes de uma atividade, um serviço ou objetos receptores (exceto provedores de conteúdo) terem sido criados.
`OnApplicationCreating`	`Android.App.Application`	Invocado quando o aplicativo está iniciando, antes de uma atividade, um serviço ou objetos receptores (exceto provedores de conteúdo) terem sido criados.
`OnApplicationLowMemory`	`Android.App.Application`	Invocado quando o sistema está executando com pouca memória e os processos em execução ativa devem reduzir o uso de memória.
`OnApplicationTrimMemory`	`Android.App.Application`, `Android.Content.TrimMemory`	Invocado quando o sistema operacional determina que é um bom momento para um processo reduzir a memória desnecessária de seu processo.
`OnBackPressed`	`Android.App.Activity`	Invocado quando a atividade detectou um pressionamento da tecla voltar.
`OnConfigurationChanged`	`Android.App.Activity`, `Android.Content.Res.Configuration`	Invocado quando a configuração do dispositivo é alterada enquanto a atividade está em execução.
`OnCreate`	`Android.App.Activity`, `Android.OS.Bundle?`	Gerado quando a atividade é criada.
`OnDestroy`	`Android.App.Activity`	Invocado quando a atividade está terminando ou porque o sistema está destruindo temporariamente a instância de atividade para economizar espaço.	Sempre chame a implementação da superclasse.
`OnNewIntent`	`Android.App.Activity`, `Android.Content.Intent?`	Invocado quando a atividade é reiniciada enquanto está na parte superior da pilha de atividades em vez de uma nova instância da atividade ser iniciada.
`OnPause`	`Android.App.Activity`	Invocado quando uma atividade está entrando em segundo plano, mas ainda não foi encerrada.	Sempre chame a implementação da superclasse.
`OnPostCreate`	`Android.App.Activity`, `Android.OS.Bundle?`	Invocado quando a inicialização da atividade é concluída, depois que `OnStart` e `OnRestoreInstanceState` foram chamados.	Sempre chame a implementação da superclasse. Esse é um evento somente do sistema que geralmente não deve ser usado por aplicativos.
`OnPostResume`	`Android.App.Activity`	Invocado quando a retomada da atividade é concluída, depois que `OnResume` foi chamado.	Sempre chame a implementação da superclasse. Esse é um evento somente do sistema que geralmente não deve ser usado por aplicativos.
`OnRequestPermissionsResult`	`Android.App.Activity`, `int`, `string[]`, `Android.Content.PM.Permission[]`	Invocado como um retorno de chamada para o resultado da solicitação de permissões.
`OnRestart`	`Android.App.Activity`	Invocado após `OnStop` quando a atividade atual está sendo exibida novamente para o usuário (o usuário navegou de volta para ela).	Sempre chame a implementação da superclasse.
`OnRestoreInstanceState`	`Android.App.Activity`, `Android.OS.Bundle`	Invocado após `OnStart` quando a atividade está sendo reinicializada de um estado salvo anteriormente.
`OnResume`	`Android.App.Activity`	Invocado após `OnRestoreInstanceState`, `OnRestart`ou `OnPause`, para indicar que a atividade está ativa e pronta para receber entrada.
`OnSaveInstanceState`	`Android.App.Activity`, `Android.OS.Bundle`	Invocado para recuperar o estado por instância de uma atividade que está sendo encerrada para que o estado possa ser restaurado em `OnCreate` ou `OnRestoreInstanceState`.
`OnStart`	`Android.App.Activity`	Invocado após `OnCreate` ou `OnRestart` quando a atividade foi interrompida, mas agora está sendo exibida para o usuário.	Sempre chame a implementação da superclasse.
`OnStop`	`Android.App.Activity`	Invocado quando a atividade não está mais visível para o usuário.	Sempre chame a implementação da superclasse.

Importante

Cada delegado tem um método de extensão correspondente com nome idêntico, que pode ser chamado para registrar um manipulador para o delegado.

Para responder a um delegado de ciclo de vida do Android que está sendo chamado, chame o método ConfigureLifecycleEvents no objeto MauiAppBuilder no método CreateMauiapp de sua classe MauiProgram. Em seguida, no objeto ILifecycleBuilder, chame o método AddAndroid e especifique o Action que registra manipuladores para os delegados necessários:

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 obter mais informações sobre o ciclo de vida do aplicativo Android, consulte Noções básicas sobre o ciclo de vida da atividade no developer.android.com.

iOS

A seguinte tabela lista os delegados do .NET MAUI invocados em resposta aos eventos de ciclo de vida do iOS que estão sendo gerados:

Delegar	Argumentos	Descrição
`ApplicationSignificantTimeChange`	`UIKit.UIApplication`	Invocado quando ocorre uma alteração significativa de horário, como meia-noite, hora alterada pela operadora ou início ou parada do horário de verão.
`ContinueUserActivity`	`UIKit.UIApplication`, `Foundation.NSUserActivity`, `UIKit.UIApplicationRestorationHandler`	Invocado quando o aplicativo recebe dados associados a uma atividade do usuário, como transferir uma atividade de um dispositivo diferente usando a Entrega.
`DidEnterBackground`	`UIKit.UIApplication`	Invocado quando o aplicativo entrou em segundo plano.
`FinishedLaunching`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Invocado quando o aplicativo é iniciado.
`OnActivated`	`UIKit.UIApplication`	Invocado quando o aplicativo é iniciado e sempre que o aplicativo retorna para o primeiro plano.
`OnResignActivation`	`UIKit.UIApplication`	Invocado quando o aplicativo está prestes a entrar em segundo plano, ser suspenso ou quando o usuário recebe uma interrupção, como uma chamada telefônica ou um texto.
`OpenUrl`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Invocado quando o aplicativo deve abrir uma URL especificada.
`PerformActionForShortcutItem`	`UIKit.UIApplication`, `UIKit.UIApplicationShortcutItem`, `UIKit.UIOperationHandler`	Invocado quando uma ação rápida da tela inicial é iniciada.
`PerformFetch`	`UIKit.UIApplication`, `Action<UIBackgroundFetchResult>`	Invocado para informar ao aplicativo que ele poderá iniciar uma operação de busca se ele tiver dados a serem baixados.
`SceneContinueUserActivity`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Invocado para lidar com a atividade relacionada à Entrega especificada.
`SceneDidDisconnect`	`UIKit.UIScene`	Invocado quando uma cena é removida do aplicativo.
`SceneDidEnterBackground`	`UIKit.UIScene`	Invocado quando uma cena está em execução em segundo plano e não está na tela.
`SceneDidFailToContinueUserActivity`	`UIKit.UIScene`, `string`, `Foundation.NSError`	Invocado para informar ao usuário que não foi possível concluir a atividade.
`SceneDidUpdateUserActivity`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Invocado quando a atividade especificada é atualizada.
`SceneOnActivated`	`UIKit.UIScene`	Invocado quando a cena se torna ativa e capaz de responder a eventos do usuário.
`SceneOnResignActivation`	`UIKit.UIScene`	Invocado quando a cena está prestes a sair do estado ativo e parar de responder aos eventos do usuário.
`SceneOpenUrl`	`UIKit.UIScene`, `Foundation.NSSet<UIKit.UIOpenUrlContext>`	Invocado quando uma cena solicita a abertura de uma ou mais URLs.
`SceneRestoreInteractionState`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Invocado para restaurar o estado da atividade.
`SceneWillConnect`	`UIKit.UIScene`, `UIKit.UISceneSession`, `UIKit.UISceneConnectionOptions`	Invocado quando uma cena é adicionada ao aplicativo.
`SceneWillContinueUserActivity`	`UIKit.UIScene`, `string`	Invocado para se preparar para receber dados relacionados à Entrega.
`SceneWillEnterForeground`	`UIKit.UIScene`	Invocado quando uma cena está prestes a ser executada em primeiro plano e fica visível para o usuário.
`WillEnterForeground`	`UIKit.UIApplication`	Invocado se o aplicativo retornar de um estado em segundo plano.
`WillFinishLaunching`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Invocado quando a inicialização do aplicativo foi iniciada, mas a restauração do estado ainda não ocorreu.
`WillTerminate`	`UIKit.UIApplication`	Invocado se o aplicativo está sendo encerrado devido a restrições de memória ou diretamente pelo usuário.
`WindowSceneDidUpdateCoordinateSpace`	`UIKit.UIWindowScene`, `UIKit.IUICoordinateSpace`, `UIKit.UIInterfaceOrientation`, `UIKit.UITraitCollection`	Invocado quando o tamanho, a orientação ou as características de uma cena mudam.

Importante

Cada delegado, com exceção de PerformFetch, tem um método de extensão correspondente com nome idêntico, que pode ser chamado para registrar um manipulador para o delegado.

Para responder a um delegado de ciclo de vida do iOS que está sendo chamado, chame o método ConfigureLifecycleEvents no objeto MauiAppBuilder no método CreateMauiapp da sua classe MauiProgram. Em seguida, no objeto ILifecycleBuilder, chame o método AddiOS e especifique o Action que registra manipuladores para os delegados necessários:

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
                    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 obter mais informações sobre o ciclo de vida do aplicativo iOS, consulte Gerenciar o ciclo de vida do seu aplicativo em developer.apple.com.

Windows

A seguinte tabela lista os delegados do .NET MAUI invocados em resposta aos eventos de ciclo de vida do Windows que estão sendo gerados:

Delegar	Argumentos	Descrição
`OnActivated`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowActivatedEventArgs`	Invocado quando o evento Activated da plataforma é gerado, caso o aplicativo não seja retomado.
`OnClosed`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowEventArgs`	Invocado quando o evento Closed da plataforma é gerado.
`OnLaunched`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.LaunchActivatedEventArgs`	Invocado pela substituição de Application.OnLaunched do .NET MAUI depois que a janela nativa foi criada e ativada.
`OnLaunching`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.LaunchActivatedEventArgs`	Invocado pela substituição de Application.OnLaunched do .NET MAUI antes que a janela nativa tenha sido criada e ativada.
`OnPlatformMessage`	`Microsoft.UI.Xaml.Window`, `WindowsPlatformMessageEventArgs`	Invocado quando o .NET MAUI recebe mensagens nativas específicas do Windows.
`OnPlatformWindowSubclassed`	`Microsoft.UI.Xaml.Window`, `WindowsPlatformWindowSubclassedEventArgs`	Invocado pelo .NET MAUI quando a janela Win32 é uma subclasse.
`OnResumed`	`Microsoft.UI.Xaml.Window`	Invocado quando o evento `Activated` da plataforma é gerado, caso o aplicativo seja retomado.
`OnVisibilityChanged`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowVisibilityChangedEventArgs`	Invocado quando o evento VisibilityChanged da plataforma é gerado.
`OnWindowCreated`	`Microsoft.UI.Xaml.Window`	Invocado quando a janela nativa é criada para o `Window`multiplataforma.

O .NET MAUI expõe mensagens nativas específicas do Windows como um evento de ciclo de vida com o delegado OnPlatformMessage. O objeto WindowsPlatformMessageEventArgs que acompanha esse delegado inclui uma propriedade MessageId, do tipo uint. O valor dessa propriedade pode ser examinado para determinar qual mensagem foi passada para a janela do aplicativo. Para obter mais informações sobre mensagens do Windows, consulte Mensagens do Windows (Introdução ao Win32 e C++). Para obter uma lista de constantes de mensagens de janelas, consulte Notificações de janelas.

Importante

Cada delegado tem um método de extensão correspondente com nome idêntico, que pode ser chamado para registrar um manipulador para o delegado.

Para responder a um delegado de ciclo de vida do Windows que está sendo chamado, chame o método ConfigureLifecycleEvents no objeto MauiAppBuilder no método CreateMauiApp da sua classe MauiProgram. Em seguida, no objeto ILifecycleBuilder, chame o método AddWindows e especifique o Action que registra manipuladores para os delegados necessários:

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 o objeto de janela

O código da plataforma pode recuperar o objeto Window do aplicativo de eventos de ciclo de vida da plataforma, com o método de extensão 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

Embora o .NET MAUI defina delegados que são invocados em resposta aos eventos de ciclo de vida da plataforma que estão sendo gerados, ele expõe apenas um conjunto comum de eventos de ciclo de vida da plataforma. No entanto, ele também inclui um mecanismo, normalmente para autores de biblioteca, que permite que os aplicativos sejam notificados quando eventos adicionais de ciclo de vida da plataforma são gerados. O processo para realizar isso é o seguinte:

Registre um manipulador de eventos para um evento de ciclo de vida da plataforma que não seja exposto pelo .NET MAUI.
No manipulador de eventos para o evento de ciclo de vida da plataforma, recupere a instância ILifecycleEventService e chame seu método InvokeEvents, especificando o nome do evento da plataforma como seu argumento.

Em seguida, os aplicativos que desejam receber a notificação do evento de ciclo de vida da plataforma devem modificar o método CreateMauiApp de sua classe MauiProgram para chamar o método ConfigureLifecycleEvents no objeto MauiAppBuilder. Em seguida, no objeto ILifecycleBuilder, chame o método AddEvent e especifique o nome do evento da plataforma e o Action que será invocado quando o evento da plataforma for gerado.

Exemplo

O evento Window.SizeChanged do WinUI 3 ocorre quando a janela do aplicativo nativo foi renderizada pela primeira vez ou alterou seu tamanho de renderização. O .NET MAUI não expõe esse evento de plataforma como um evento de ciclo de vida. No entanto, os aplicativos podem receber notificação quando esse evento de plataforma é gerado usando a seguinte abordagem:

Registre um manipulador de eventos para o evento de ciclo de vida da 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();
}

No manipulador de eventos para o evento de ciclo de vida da plataforma, recupere a instância ILifecycleEventService e chame seu método InvokeEvents, especificando o nome do evento da plataforma como seu 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
```
O tipo MauiWinUIApplication no Windows pode ser usado para acessar a instância de aplicativo nativo por meio de sua propriedade Current. O tipo MauiApplication no Android pode ser usado para acessar a instância de aplicativo nativo. Da mesma forma, o tipo MauiUIApplicationDelegate no iOS pode ser usado para acessar a instância de aplicativo nativo.

Aviso

Invocar um evento não registrado, com o método InvokeEvents, não gera uma exceção.

No método CreateMauiApp da classe MauiProgram, chame o método ConfigureLifecycleEvents no objeto MauiAppBuilder. Em seguida, no objeto ILifecycleBuilder, chame o método AddEvent e especifique o nome do evento da plataforma e o Action que será invocado quando o evento da plataforma for gerado:

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

O efeito geral é o seguinte: quando um usuário altera o tamanho da janela do aplicativo no Windows, a ação especificada no método AddEvent é executada.

Observação

O método AddEvent também tem uma sobrecarga que permite que um delegado seja especificado.

Share via

Ciclo de vida do aplicativo

Eventos de ciclo de vida multiplataforma

Eventos de ciclo de vida da plataforma

Android

iOS

Windows

Recuperar o objeto de janela

Eventos de ciclo de vida personalizados

Exemplo

Comentários

Recursos adicionais