Compartilhar via

Tutorial: Conectar usuários no aplicativo shell .NET MAUI usando um locatário externo

Aplica-se a: Círculo branco com símbolo X cinza. Locatários de força de trabalho Círculo verde com marca de verificação branca. Locatários externos (saiba mais)

Este tutorial é a parte final de uma série que demonstra como criar um aplicativo shell .NET MAUI (interface do usuário do aplicativo multiplataforma) do .NET e prepará-lo para autenticação usando o centro de administração do Microsoft Entra. Na Parte 2 desta série , você adicionou um auxiliar de cliente personalizado da MSAL (Biblioteca de Autenticação da Microsoft) para inicializar o SDK da MSAL, instalar as bibliotecas necessárias e incluir um recurso de imagem. Esta etapa final demonstra como adicionar código de entrada e saída no .NET MAUI e executar o aplicativo shell na plataforma Android.

Neste tutorial, você:

  • Adicione o código de entrada e de saída.
  • Modifique o shell do aplicativo.
  • Adicionar código específico da plataforma.
  • Adicionar configurações de aplicativo.
  • Execute e teste o aplicativo shell do .NET MAUI.

Pré-requisitos

Adicionar código de entrada e de saída

A interface do usuário (UI) de um aplicativo .NET MAUI é criada com objetos que são mapeados para os controles nativos de cada plataforma de destino. Os principais grupos de controle usados para criar a interface do usuário de um aplicativo MAUI do .NET são páginas, layouts e exibições.

Adicionar página de exibição principal

As próximas etapas organizarão nosso código para que main view seja definido.

  1. Exclua MainPage.xaml e MainPage.xaml.cs do seu projeto, eles não são mais necessários. No painel Gerenciador de Soluções, localize a entrada para MainPage.xaml, clique com o botão direito do mouse e selecione Excluir.

  2. Clique com o botão direito do mouse no projeto SignInMaui e selecione Adicionar>Nova Pasta. Nomeie a pasta Views.

  3. Clique com o botão direito do mouse nos Modos de Exibição.

  4. Selecione Adicionar>Novo Item....

  5. Selecione .NET MAUI na lista de modelos.

  6. Selecione o modelo do .NET MAUI ContentPage (XAML ). Nomeie o arquivo MainView.xaml.

  7. Selecione Adicionar.

  8. O arquivo MainView.xaml será aberto em uma nova guia de documento, exibindo toda a marcação XAML que representa a interface do usuário da página. Substitua a marcação XAML pela marcação a seguir:

    <?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="SignInMaui.Views.MainView"
             Title="Microsoft Entra External ID"
             >
    <Shell.BackButtonBehavior>
        <BackButtonBehavior IsVisible="False" IsEnabled="False" />
    </Shell.BackButtonBehavior>

    <ScrollView>
        <VerticalStackLayout 
            Spacing="25" 
            Padding="30,0" 
            VerticalOptions="Center">

            <Image
                Source="external_id.png"
                SemanticProperties.Description="External ID"
                HeightRequest="200"
                HorizontalOptions="Center" />

            <Label 
                Text="CIAM"
                SemanticProperties.HeadingLevel="Level1"
                FontSize="26"
                HorizontalOptions="Center" />

            <Label 
                Text="MAUI sample"
                SemanticProperties.HeadingLevel="Level1"
                FontSize="26"
                HorizontalOptions="Center" />

            <Button 
                x:Name="SignInButton"
                Text="Sign In"
                SemanticProperties.Hint="Sign In"
                Clicked="OnSignInClicked"
                HorizontalOptions="Center"
                IsEnabled="False"/>

        </VerticalStackLayout>
    </ScrollView>
 
</ContentPage>

  9. Salve o arquivo.

    Vamos especificar as partes principais dos controles XAML colocados na página:

    • <ContentPage> é o objeto raiz da classe MainView.
    • <VerticalStackLayout> é o objeto filho do ContentPage. Este controle de layout organiza seus elementos filhos verticalmente, um após o outro.
    • <Image> exibe uma imagem, nesse caso, ela está usando o azureactive_directory.png_ que você baixou anteriormente.
    • <Label> controla o texto de exibição.
    • <Button> pode ser pressionado pelo usuário, o que gera o Clicked evento. Você pode executar o código em resposta ao evento Clicked.
    • Clicked="OnSignInClicked" o Clicked evento do botão é atribuído ao OnSignInClicked manipulador de eventos, que será definido no arquivo code-behind. Você criará esse código na próxima etapa.

Manipular o evento OnSignInClicked

O próximo passo é adicionar o código do evento Clicked do botão.

  1. No painel Gerenciador de Soluções do Visual Studio, expanda o arquivo MainView.xaml para revelar seu arquivo code-behind MainView.xaml.cs. Abra o MainView.xaml.cs e substitua o conteúdo do arquivo pelo seguinte código:

    // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using SignInMaui.MSALClient;
using Microsoft.Identity.Client;

namespace SignInMaui.Views
{
    public partial class MainView : ContentPage
    {
        public MainView()
        {
            InitializeComponent();

            IAccount cachedUserAccount = PublicClientSingleton.Instance.MSALClientHelper.FetchSignedInUserFromCache().Result;

            _ = Dispatcher.DispatchAsync(async () =>
            {
                if (cachedUserAccount == null)
                {
                    SignInButton.IsEnabled = true;
                }
                else
                {
                    await Shell.Current.GoToAsync("claimsview");
                }
            });
        }

        private async void OnSignInClicked(object sender, EventArgs e)
        {
            await PublicClientSingleton.Instance.AcquireTokenSilentAsync();
            await Shell.Current.GoToAsync("claimsview");
        }
        protected override bool OnBackButtonPressed() { return true; }

    }
}

    A MainView classe é uma página de conteúdo responsável por mostrar a visão principal do aplicativo. No construtor, ele recupera a conta de usuário armazenada em cache usando MSALClientHelper da instância PublicClientSingleton e habilita o botão de login, se nenhuma conta de usuário armazenada em cache for encontrada.

    Quando o botão de login é clicado, ele chama o método AcquireTokenSilentAsync para adquirir um token silenciosamente e navega até a página claimsview usando o método Shell.Current.GoToAsync. Além disso, o método OnBackButtonPressed é substituído para retornar verdadeiro, indicando que o botão voltar está desabilitado para essa exibição.

Adicionar página de visualização de declarações

As próximas etapas organizarão o código para que essa ClaimsView página seja definida. A página exibirá as declarações do usuário encontradas no token de ID.

  1. No painel Gerenciador de Soluções do Visual Studio, clique com o botão direito do mouse nos Modos de Exibição.

  2. Selecione Adicionar>Novo Item....

  3. Selecione .NET MAUI na lista de modelos.

  4. Selecione o modelo do .NET MAUI ContentPage (XAML ). Nomeie o arquivo ClaimsView.xaml.

  5. Selecione Adicionar.

  6. O arquivo ClaimsView.xaml será aberto em uma nova guia de documento, exibindo toda a marcação XAML que representa a interface do usuário da página. Substitua a marcação XAML pela marcação a seguir:

    <?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="SignInMaui.Views.ClaimsView"
             Title="ID Token View">
    <Shell.BackButtonBehavior>
        <BackButtonBehavior IsVisible="False" IsEnabled="False" />
    </Shell.BackButtonBehavior>
    <VerticalStackLayout>
        <Label 
            Text="CIAM"
            FontSize="26"
            HorizontalOptions="Center" />
        <Label 
            Text="MAUI sample"
            FontSize="26"
            Padding="0,0,0,20"
            HorizontalOptions="Center" />

        <Label 
            Padding="0,20,0,0"
            VerticalOptions="Center" 
            HorizontalOptions="Center"
            FontSize="18"
            Text="Claims found in ID token"
            />
        <ListView ItemsSource="{Binding IdTokenClaims}"
                  x:Name="Claims">
            <ListView.ItemTemplate>
                <DataTemplate>
                    <ViewCell>
                        <Grid Padding="0, 0, 0, 0">
                            <Label Grid.Column="1" 
                                   Text="{Binding}" 
                                   HorizontalOptions="Center" />
                        </Grid>
                    </ViewCell>
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>
        <Button
            x:Name="SignOutButton"
            Text="Sign Out"
            HorizontalOptions="Center"
            Clicked="SignOutButton_Clicked" />
    </VerticalStackLayout>
</ContentPage>

    Esse código de marcação XAML representa o layout da interface do usuário para uma visualização de requisição em um aplicativo .NET MAUI. Ele começa definindo o ContentPage com um título e desabilitando o comportamento do botão voltar.

    Dentro de um VerticalStackLayout, há vários Label elementos exibindo texto estático, seguidos por um ListView nome Claims que se associa a uma coleção chamada IdTokenClaims para exibir as declarações encontradas no token de ID. Cada declaração é renderizada dentro de um ViewCell usando um DataTemplate e exibida como um Label centralizado dentro de uma Grade.

    Por fim, há um Sign Out botão centralizado na parte inferior do layout, que dispara o SignOutButton_Clicked manipulador de eventos quando clicado.

Manipular os dados do ClaimsView

A próxima etapa é adicionar o código para manipular ClaimsView dados.

  1. No painel Gerenciador de Soluções do Visual Studio, expanda o arquivo ClaimsView.xaml para revelar seu arquivo code-behind ClaimsView.xaml.cs. Abra o ClaimsView.xaml.cs e substitua o conteúdo do arquivo pelo seguinte código:

    using SignInMaui.MSALClient;
using Microsoft.Identity.Client;

namespace SignInMaui.Views;

public partial class ClaimsView : ContentPage
{
    public IEnumerable<string> IdTokenClaims { get; set; } = new string[] {"No claims found in ID token"};
    public ClaimsView()
    {
        BindingContext = this;
        InitializeComponent();

        _ = SetViewDataAsync();
    }

    private async Task SetViewDataAsync()
    {
        try
        {
            _ = await PublicClientSingleton.Instance.AcquireTokenSilentAsync();

            IdTokenClaims = PublicClientSingleton.Instance.MSALClientHelper.AuthResult.ClaimsPrincipal.Claims.Select(c => c.Value);

            Claims.ItemsSource = IdTokenClaims;
        }

        catch (MsalUiRequiredException)
        {
            await Shell.Current.GoToAsync("claimsview");
        }
    }

    protected override bool OnBackButtonPressed() { return true; }

    private async void SignOutButton_Clicked(object sender, EventArgs e)
    {
        await PublicClientSingleton.Instance.SignOutAsync().ContinueWith((t) =>
        {
            return Task.CompletedTask;
        });

        await Shell.Current.GoToAsync("mainview");
    }
}

    O código ClaimsView.xaml.cs representa o código subjacente para uma exibição de reivindicação em um aplicativo MAUI do .NET. Ele começa importando os namespaces necessários e definindo a ClaimsView classe, que se estende ContentPage. A propriedade IdTokenClaims é um enumerador de cadeias de caracteres, inicialmente definida como uma única cadeia de caracteres indicando que nenhuma declaração foi encontrada.

    O ClaimsView construtor define o contexto de associação para a instância atual, inicializa os componentes de exibição e chama o SetViewDataAsync método de forma assíncrona. O SetViewDataAsync método tenta adquirir um token de forma silenciosa, recupera as declarações do resultado da autenticação e define a propriedade IdTokenClaims para exibi-las no elemento ListView chamado Claims. Se um MsalUiRequiredException ocorrer, indicando que a interação com o usuário é necessária para autenticação, o aplicativo navega até a página de declarações.

    O método OnBackButtonPressed substitui o comportamento do botão voltar para sempre retornar verdadeiro, impedindo que o usuário volte a partir dessa exibição. O SignOutButton_Clicked manipulador de eventos desconecta o usuário usando a instância PublicClientSingleton, e após concluir, navega até o main view.

Modifique o aplicativo Shell

A AppShell classe define a hierarquia visual de um aplicativo, a marcação XAML usada na criação da interface do usuário do aplicativo. Atualize o AppShell para que ele saiba sobre o Views.

  1. Clique duas vezes no AppShell.xaml arquivo no painel Gerenciador de Soluções para abrir o editor XAML. Substitua a marcação XAML pelo código a seguir:

    <?xml version="1.0" encoding="UTF-8" ?>
<Shell
    x:Class="SignInMaui.AppShell"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:local="clr-namespace:SignInMaui.Views"
    Shell.FlyoutBehavior="Disabled">

    <ShellContent
        Title="Home"
        ContentTemplate="{DataTemplate local:MainView}"
        Route="MainPage" />
</Shell>

    O código XAML define uma AppShell classe que desabilita o comportamento do submenu e define o conteúdo principal para um ShellContent elemento com um título Home e um modelo de conteúdo apontando para a MainView classe.

  2. No painel Gerenciador de Soluções do Visual Studio, expanda o arquivo AppShell.xaml para revelar seu arquivo code-behind AppShell.xaml.cs. Abra o AppShell.xaml.cs e substitua o conteúdo do arquivo pelo seguinte código:

    // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
using SignInMaui.Views;

namespace SignInMaui;

public partial class AppShell : Shell
{
    public AppShell()
    {
        InitializeComponent();
        Routing.RegisterRoute("mainview", typeof(MainView));
        Routing.RegisterRoute("claimsview", typeof(ClaimsView));
    }
}

    Você atualiza o arquivo AppShell.xaml.cs para incluir os registros de rota necessários para o MainView e o ClaimsView. Ao chamar o InitializeComponent() método, você garante a inicialização da AppShell classe. O método RegisterRoute() associa as rotas mainview e claimsview aos seus respectivos tipos de exibição, MainView e ClaimsView.

Adicionar código específico da plataforma

Um projeto de aplicativo .NET MAUI contém uma pasta Plataformas, com cada pasta filho representando uma plataforma que o .NET MAUI pode direcionar. Para fornecer um comportamento específico do aplicativo Android para complementar a classe de aplicativo padrão, siga estas etapas:

  1. Clique duas vezes no Platforms/Android/AndroidManifest.xml arquivo no painel Gerenciador de Soluções para abrir o editor XML. Atualize as propriedades a seguir:

    • Defina Nome do aplicativo como MAUI CIAM.
    • Defina o nome do pacote como SignInMaui.Droid.
    • Defina a versão mínima do Android como Android 5.0 (API de nível 21).

  2. Clique duas vezes no Platforms/Android/MainActivity.cs arquivo no painel Gerenciador de Soluções para abrir o editor csharp. Substitua o conteúdo do arquivo pelo seguinte código:

    // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
using Android.App;
using Android.Content;
using Android.Content.PM;
using Android.OS;
using SignInMaui.MSALClient;
using Microsoft.Identity.Client;

namespace SignInMaui;

[Activity(Theme = "@style/Maui.SplashTheme", MainLauncher = true, ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation | ConfigChanges.UiMode | ConfigChanges.ScreenLayout | ConfigChanges.SmallestScreenSize | ConfigChanges.Density)]
public class MainActivity : MauiAppCompatActivity
{
    protected override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);
        // configure platform specific params
        PlatformConfig.Instance.RedirectUri = $"msal{PublicClientSingleton.Instance.MSALClientHelper.AzureAdConfig.ClientId}://auth";
        PlatformConfig.Instance.ParentWindow = this;

        // Initialize MSAL and platformConfig is set
        _ = Task.Run(async () => await PublicClientSingleton.Instance.MSALClientHelper.InitializePublicClientAppAsync()).Result;
    }

    protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
    {
        base.OnActivityResult(requestCode, resultCode, data);
        AuthenticationContinuationHelper.SetAuthenticationContinuationEventArgs(requestCode, resultCode, data);
    }
}

    Vamos detalhar as principais partes do código que você adicionou:

    • As declarações necessárias using estão incluídas no topo.
    • A MainActivity classe é definida, herdando de MauiAppCompatActivity, que é a classe base para a plataforma Android no .NET MAUI.
    • O atributo [Activity] é aplicado à MainActivity classe, especificando várias configurações para a atividade do Android.
      • Theme = "@style/Maui.SplashTheme" Define o tema inicial da atividade.
      • MainLauncher = true designa esta atividade como o principal ponto de entrada do aplicativo.
      • ConfigurationChanges especifica as alterações de configuração que a atividade pode manipular, como tamanho da tela, orientação, modo de interface do usuário, layout da tela, menor tamanho de tela e densidade.
    • OnCreate é substituído para fornecer lógica personalizada quando a atividade está sendo criada.
      • base.OnCreate(savedInstanceState) chama a implementação base do método.
      • PlatformConfig.Instance.RedirectUri é definido como um valor gerado dinamicamente com base em PublicClientSingleton.Instance.MSALClientHelper.AzureAdConfig.ClientId. Ele configura o URI de redirecionamento para o cliente MSAL.
      • PlatformConfig.Instance.ParentWindow é definido como a instância de atividade atual, que especifica a janela pai para operações relacionadas à autenticação.
      • PublicClientSingleton.Instance.MSALClientHelper.InitializePublicClientAppAsync() inicializa o aplicativo cliente MSAL de forma assíncrona usando um método auxiliar de uma instância singleton chamada MSALClientHelper. O Task.Run é usado para executar a inicialização em um thread em segundo plano e .Result é usado para aguardar de forma síncrona a conclusão da tarefa.
    • OnActivityResult é substituído para manipular o resultado de uma atividade iniciada pela atividade atual.
      • base.OnActivityResult(requestCode, resultCode, data) chama a implementação base do método.
      • AuthenticationContinuationHelper.SetAuthenticationContinuationEventArgs(requestCode, resultCode, data) Define os argumentos do evento de continuação de autenticação com base no código de solicitação recebido, no código de resultado e nos dados de intenção. Isso é usado para continuar o fluxo de autenticação depois que uma atividade externa retorna um resultado.

  3. No painel Gerenciador de Soluções do Visual Studio, selecione Plataformas.

  4. Clique com o botão direito do mouse na pasta >AndroidAdicionar>novo item....

  5. Selecione Classe de Itens> C#. Atribua um nome ao arquivo MsalActivity.cs.

  6. Substitua o conteúdo do MsalActivity.cs arquivo pelo seguinte código:

    // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Android.App;
using Android.Content;
using Android.OS;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using Microsoft.Identity.Client;

namespace MauiAppBasic.Platforms.Android.Resources
{
    [Activity(Exported =true)]
    [IntentFilter(new[] { Intent.ActionView },
        Categories = new[] { Intent.CategoryBrowsable, Intent.CategoryDefault },
        DataHost = "auth",
        DataScheme = "msalEnter_the_Application_Id_Here")]
    public class MsalActivity : BrowserTabActivity
    {
    }
}

    Vamos detalhar as principais partes do código que você adicionou:

    • MsalActivity class é declarada dentro do MauiAppBasic.Platforms.Android.Resources namespace. A classe herda da BrowserTabActivity classe, indicando que ela estende sua funcionalidade.
    • A classe é decorada com o atributo, o [Activity(Exported = true)] que significa que a atividade é exportada e pode ser acessada por outros métodos.
    • Um filtro de intent é especificado usando o atributo "[IntentFilter(...)]". Ele configura a atividade para interceptar a ActionView intenção.
    • O filtro de intent é definido para lidar com o ActionView intent com o (msalEnter_the_Application_Id_Here) e DataHost ("auth") especificados DataScheme . Essa configuração permite que a atividade manipule o processo de autenticação interceptando e processando a ActionView intenção. Substitua Enter_the_Application_Id_Here pela ID do aplicativo (cliente) do aplicativo que você registrou anteriormente.

Adicionar configurações de aplicativo

As configurações permitem a separação de dados que configura o comportamento de um aplicativo do código, permitindo que o comportamento seja alterado sem recriar o aplicativo. O MauiAppBuilder fornece o ConfigurationManager para definir as configurações em nosso aplicativo .NET MAUI. Vamos adicionar o appsettings.json arquivo como um EmbeddedResource.

Para criar appsettings.json, siga estas etapas:

  1. No painel Gerenciador de Soluções do Visual Studio, clique com o botão direito do mouse no projeto >Adicionar>Novo Item....

  2. Selecione Web>JavaScript JSON Configuration File. Atribua um nome ao arquivo appsettings.json.

  3. Selecione Adicionar.

  4. Selecione appsettings.json

  5. No painel Propriedades , defina a Ação de Build como recurso Inserido.

  6. No painel Propriedades , defina Copiar para Diretório de Saída como Copiar sempre.

  7. Substitua o conteúdo do appsettings.json arquivo pelo seguinte código:

    {
  "AzureAd": {
    "Authority": "https://Enter_the_Tenant_Subdomain_Here.ciamlogin.com/",
    "ClientId": "Enter_the_Application_Id_Here",
    "CacheFileName": "msal_cache.txt",
    "CacheDir": "C:/temp"
  },
  "DownstreamApi": {
    "Scopes": "openid offline_access"
  }
}

  8. No appsettings.json, encontre o espaço reservado:

    1. Enter_the_Tenant_Subdomain_Here e substitua-o pelo subdomínio do Diretório (locatário). Por exemplo, se o domínio primário do locatário for contoso.onmicrosoft.com, use contoso. Se você não tiver o nome do locatário, saiba como ler os detalhes do locatário.
    2. Enter_the_Application_Id_Here e substitua pela ID de Aplicativo (Cliente) do aplicativo registrado anteriormente.

Usar domínio de URL personalizado (opcional)

Use um domínio personalizado para marcar totalmente a URL de autenticação. Do ponto de vista do usuário, os usuários permanecem em seu domínio durante o processo de autenticação, em vez de serem redirecionados para ciamlogin.com nome de domínio.

Siga estas etapas para usar um domínio personalizado:

  1. Use as etapas mencionadas em Habilitar domínios de URL personalizados para aplicativos de locatários externos para habilitar domínios de URL personalizados para seu locatário externo.

  2. Abra appsettings.json arquivo:

    1. Atualize o valor da Authority propriedade para https://Enter_the_Custom_Domain_Here/Enter_the_Tenant_ID_Here. Substitua Enter_the_Custom_Domain_Here pelo domínio de URL personalizado e Enter_the_Tenant_ID_Here pela ID do locatário. Se você não tiver o nome do locatário, saiba como ler os detalhes do locatário.
    2. Adicione a propriedade knownAuthorities com o valor [Enter_the_Custom_Domain_Here].

Depois de fazer as alterações no arquivo appsettings.json, se o domínio de URL personalizado for login.contoso.com e sua ID de locatário for aaaabbbb-0000-cccc-1111-dddd2222eeee, o arquivo deverá ser semelhante ao seguinte trecho de código:

{
  "AzureAd": {
    "Authority": "https://login.contoso.com/aaaabbbb-0000-cccc-1111-dddd2222eeee",
    "ClientId": "Enter_the_Application_Id_Here",
    "CacheFileName": "msal_cache.txt",
    "CacheDir": "C:/temp",
    "KnownAuthorities": ["login.contoso.com"]
  },
  "DownstreamApi": {
    "Scopes": "openid offline_access"
  }
}

Executar e testar o aplicativo móvel .NET MAUI

Os aplicativos .NET MAUI são projetados para serem executados em vários sistemas operacionais e dispositivos. Você precisará selecionar qual destino deseja testar e depurar seu aplicativo.

Defina o Destino de Depuração na barra de ferramentas do Visual Studio para o dispositivo com o qual você deseja depurar e testar. As etapas a seguir demonstram a configuração do Destino de Depuração para Android:

  1. Selecione a lista suspensa Destino de Depuração.
  2. Selecione Android Emulators.
  3. Selecione o dispositivo emulador.

Execute o aplicativo pressionando F5 ou selecione o botão de reprodução na parte superior do Visual Studio.

  1. Agora você pode testar o aplicativo de exemplo .NET MAUI para Android. Depois de executar o aplicativo, a janela do aplicativo Android será exibida em um emulador:

    Captura de tela do botão de logon no aplicativo Android.

  2. Na janela do Android que aparecer, selecione o botão Entrar. Uma janela do navegador será aberta e solicitará suas credenciais de acesso.

    Captura de tela do prompt de usuário para inserir as credenciais no aplicativo Android.

    Durante o processo de entrada, você será solicitado a conceder várias permissões (para permitir que o aplicativo acesse seus dados). Após a entrada e o consentimento bem-sucedidos, a tela do aplicativo exibe a página principal.

    Captura de tela da página principal no aplicativo Android após a entrada.

Consulte também

  • Last updated on