Conectar usuários e chamar o Microsoft Graph em um aplicativo AndroidSign in users and call the Microsoft Graph from an Android app

Neste tutorial, você aprenderá como integrar um aplicativo Android à plataforma de identidade da Microsoft.In this tutorial, you'll learn how to integrate an Android app with the Microsoft identity platform. Seu aplicativo conectará um usuário, obterá um token de acesso para chamar a API do Microsoft Graph e fará uma solicitação para a API do Microsoft Graph.Your app will sign in a user, get an access token to call the Microsoft Graph API, and make a request to the Microsoft Graph API.

Após concluir este guia, seu aplicativo aceitará conexões de contas Microsoft pessoais (incluindo outlook.com, live.com e outras) e contas corporativas ou de estudante de qualquer empresa ou organização que utilize o Azure Active Directory.When you've completed the guide, your application will accept sign-ins of personal Microsoft accounts (including outlook.com, live.com, and others) and work or school accounts from any company or organization that uses Azure Active Directory.

Como este tutorial funcionaHow this tutorial works

Mostra como funciona o aplicativo de exemplo gerado por este tutorial

O aplicativo deste tutorial conectará usuários e obterá dados no nome deles.The app in this tutorial will sign in users and get data on their behalf. Esses dados serão acessados por meio de uma API protegida (API do Microsoft Graph) que exige autorização e é protegida pela plataforma de identidade da Microsoft.This data will be accessed through a protected API (Microsoft Graph API) that requires authorization and is protected by the Microsoft identity platform.

Mais especificamente:More specifically:

  • Seu aplicativo conectará o usuário por meio de um navegador ou do Microsoft Authenticator e pelo Portal da Empresa do Intune.Your app will sign in the user either through a browser or the Microsoft Authenticator and Intune Company Portal.
  • O usuário final aceitará as permissões solicitadas por seu aplicativo.The end user will accept the permissions your application has requested.
  • Será emitido um token de acesso para seu aplicativo para a API do Microsoft Graph.Your app will be issued an access token for the Microsoft Graph API.
  • O token de acesso será incluído na solicitação HTTP para API Web.The access token will be included in the HTTP request to the web API.
  • Processe a resposta do Microsoft Graph.Process the Microsoft Graph response.

Esta amostra usa a MSAL (Biblioteca de Autenticação da Microsoft) para Android para implementar a Autenticação: com.microsoft.identity.client.This sample uses the Microsoft Authentication library for Android (MSAL) to implement Authentication: com.microsoft.identity.client.

A MSAL automaticamente renovará tokens, fornecerá o SSO (logon único) entre outros aplicativos no dispositivo e ajudará a gerenciar as contas.MSAL will automatically renew tokens, deliver single sign-on (SSO) between other apps on the device, and manage the Account(s).

Pré-requisitosPrerequisites

  • Este tutorial exige o Android Studio versão 16 ou posterior (19 e posterior é recomendado).This tutorial requires Android Studio version 16 or later (19+ is recommended).

Criar um projetoCreate a project

Este tutorial irá criar um novo projeto.This tutorial will create a new project. Se, ao invés disso, você quiser baixar o tutorial concluído, baixe o código.If you want to download the completed tutorial instead, download the code.

  1. Abra o Android Studio e selecione Iniciar um novo projeto do Android Studio.Open Android Studio, and select Start a new Android Studio project.
  2. Selecione Atividade Básica e, em seguida, Avançar.Select Basic Activity and select Next.
  3. Nome do seu aplicativo.Name your application.
  4. Guarde o nome do pacote.Save the package name. Você o inserirá mais tarde no portal do Azure.You will enter it later into the Azure portal.
  5. Defina o Nível mínimo da API como API 19 ou superior e clique em Concluir.Set the Minimum API level to API 19 or higher, and click Finish.
  6. Na exibição do projeto, escolha Projeto na lista suspensa para exibir os arquivos do projeto que são e que não são a fonte, abra app/build.gradle e defina targetSdkVersion como 27.In the project view, choose Project in the dropdown to display source and non-source project files, open app/build.gradle and set targetSdkVersion to 27.

Registre seu aplicativoRegister your application

  1. Vá para o Portal do Azure.Go to the Azure portal.

  2. Abra a folha Registros de aplicativo e clique em +Novo registro.Open the App registrations blade and click +New registration.

  3. Insira um Nome para seu aplicativo e, em seguida, sem definir um URI de Redirecionamento, clique em Registrar.Enter a Name for your app and then, without setting a Redirect URI, click Register.

  4. Na seção Gerenciar do painel que aparece, selecione Autenticação > + Adicionar uma plataforma > Android.In the Manage section of the pane that appears, select Authentication > + Add a platform > Android.

  5. Insira o nome do pacote do seu projeto.Enter your project's Package Name. Se você baixou o código, esse valor é com.azuresamples.msalandroidapp.If you downloaded the code, this value is com.azuresamples.msalandroidapp.

  6. Na seção Hash de assinatura da página Configurar seu aplicativo Android, clique em Gerar um hash de assinatura de desenvolvimento.In the Signature hash section of the Configure your Android app page, click Generating a development Signature Hash. e copie o comando KeyTool para usar para sua plataforma.and copy the KeyTool command to use for your platform.

    Observação

    KeyTool.exe é instalado como parte do JDK (Java Development Kit).KeyTool.exe is installed as part of the Java Development Kit (JDK). Você também precisará instalar a ferramenta OpenSSL para executar o comando KeyTool.You must also install the OpenSSL tool to execute the KeyTool command.

  7. Insira o Hash de assinatura gerado por KeyTool.Enter the Signature hash generated by KeyTool.

  8. Clique em Configure e salve a Configuração da MSAL exibida na página Configuração do Android para que você possa inseri-la quando configurar o aplicativo mais tarde.Click Configure and save the MSAL Configuration that appears in the Android configuration page so you can enter it when you configure your app later. Clique em Concluído.Click Done.

Compilar seu aplicativoBuild your app

Adicionar o registro do seu aplicativoAdd your app registration

  1. No painel do projeto do Android Studio, navegue até app\src\main\res.In Android Studio's project pane, navigate to app\src\main\res.

  2. Clique com o botão direito do mouse em res e escolha Novo > Diretório.Right-click res and choose New > Directory. Insira raw como o nome do novo diretório e clique em OK.Enter raw as the new directory name and click OK.

  3. Em app > src > res > raw, crie um novo arquivo JSON chamado auth_config.json e cole a Configuração da MSAL que você salvou anteriormente.In app > src > res > raw, create a new JSON file called auth_config.json and paste the MSAL Configuration that you saved earlier. Confira Configuração de MSAL para obter mais informações.See MSAL Configuration for more info.

  4. Em app > src > main > AndroidManifest.xml, adicione a atividade BrowserTabActivity abaixo.In app > src > main > AndroidManifest.xml, add the BrowserTabActivity activity below. Essa entrada permite que a Microsoft faça uma chamada de retorno ao aplicativo após concluir a autenticação:This entry allows Microsoft to call back to your application after it completes the authentication:

    <!--Intent filter to capture System Browser or Authenticator calling back to our app after sign-in-->
    <activity
        android:name="com.microsoft.identity.client.BrowserTabActivity">
        <intent-filter>
            <action android:name="android.intent.action.VIEW" />
            <category android:name="android.intent.category.DEFAULT" />
            <category android:name="android.intent.category.BROWSABLE" />
            <data android:scheme="msauth"
                android:host="Enter_the_Package_Name"
                android:path="/Enter_the_Signature_Hash" />
        </intent-filter>
    </activity>
    

    Substitua o nome do pacote que você registrou no portal do Azure para o valor android:host=.Substitute the package name you registered in the Azure portal for the android:host= value. Substitua o hash da chave que você registrou no portal do Azure para o valor android:path=.Substitute the key hash you registered in the Azure portal for the android:path= value. O hash de assinatura não deve ser codificado por URL.The Signature Hash should not be URL encoded.

  5. Dentro do AndroidManifest.xml, logo acima da tag <application>, adicione as seguintes permissões:Inside the AndroidManifest.xml, just above the <application> tag, add the following permissions:

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    

Criar a interface do usuário do aplicativoCreate the app's UI

  1. Na janela de projeto do Android Studio, navegue até app > src > main > res > layout, abra activity_main.xml e abra o modo de exibição de Texto.In the Android Studio project window, navigate to app > src > main > res > layout and open activity_main.xml and open the Text view.

  2. Altere o layout da atividade, por exemplo: de <androidx.coordinatorlayout.widget.CoordinatorLayout para <androidx.coordinatorlayout.widget.LinearLayout.Change the activity layout, for example: <androidx.coordinatorlayout.widget.CoordinatorLayout to <androidx.coordinatorlayout.widget.LinearLayout.

  3. Adicionar o propriedade android:orientation="vertical" ao nó LinearLayout.Add the android:orientation="vertical" property to the LinearLayout node.

  4. Cole o seguinte código no nó LinearLayout, substituindo o conteúdo atual:Paste the following code into the LinearLayout node, replacing the current content:

    <TextView
        android:text="Welcome, "
        android:textColor="#3f3f3f"
        android:textSize="50px"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginLeft="10dp"
        android:layout_marginTop="15dp"
        android:id="@+id/welcome"
        android:visibility="invisible"/>
    
    <Button
        android:id="@+id/callGraph"
        android:text="Call Microsoft Graph"
        android:textColor="#FFFFFF"
        android:background="#00a1f1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="200dp"
        android:textAllCaps="false" />
    
    <TextView
        android:text="Getting Graph Data..."
        android:textColor="#3f3f3f"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginLeft="5dp"
        android:id="@+id/graphData"
        android:visibility="invisible"/>
    
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="0dip"
        android:layout_weight="1"
        android:gravity="center|bottom"
        android:orientation="vertical" >
    
        <Button
            android:text="Sign Out"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginBottom="15dp"
            android:textColor="#FFFFFF"
            android:background="#00a1f1"
            android:textAllCaps="false"
            android:id="@+id/clearCache"
            android:visibility="invisible" />
    </LinearLayout>
    

Adicionar MSAL ao seu projetoAdd MSAL to your project

  1. Na janela do projeto do Android Studio, navegue até app > src > gradle.In the Android Studio project window, navigate to app > src > build.gradle.

  2. Em Dependências, cole o seguinte:Under Dependencies, paste the following:

    implementation 'com.android.volley:volley:1.1.1'
    implementation 'com.microsoft.identity.client:msal:0.3.+'
    

Usar a MSALUse MSAL

Agora, faça alterações dentro de MainActivity.java para adicionar e usar a MSAL em seu aplicativo.Now make changes inside MainActivity.java to add and use MSAL in your app. Na janela do projeto do Android Studio, navegue até app > src > main > java > com.example.msal e abra MainActivity.java.In the Android Studio project window, navigate to app > src > main > java > com.example.msal, and open MainActivity.java.

Importações necessáriasRequired imports

Adicione as seguintes importações próximo à parte superior de MainActivity.java:Add the following imports near the top of MainActivity.java:

import android.app.Activity;
import android.content.Intent;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
import com.android.volley.*;
import com.android.volley.toolbox.JsonObjectRequest;
import com.android.volley.toolbox.Volley;
import org.json.JSONObject;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.microsoft.identity.client.*;
import com.microsoft.identity.client.exception.*;

Criar uma instância da MSALInstantiate MSAL

Na classe MainActivity, precisaremos criar uma instância da MSAL juntamente com algumas configurações sobre o que o aplicativo fará, incluindo os escopos e a API Web que desejamos acessar.Inside the MainActivity class, we'll need to instantiate MSAL along with a few configurations about what are app will do including the scopes and web API we want to access.

Copie as seguintes variáveis dentro da classe MainActivity:Copy the following variables inside the MainActivity class:

final static String SCOPES [] = {"https://graph.microsoft.com/User.Read"};
final static String MSGRAPH_URL = "https://graph.microsoft.com/v1.0/me";

/* UI & Debugging Variables */
private static final String TAG = MainActivity.class.getSimpleName();
Button callGraphButton;
Button signOutButton;

/* Azure AD Variables */
private PublicClientApplication sampleApp;
private IAuthenticationResult authResult;

Substitua o conteúdo de onCreate() pelo código a seguir para criar a instância da MSAL:Replace the contents of onCreate() with the following code to instantiate MSAL:

super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

callGraphButton = (Button) findViewById(R.id.callGraph);
signOutButton = (Button) findViewById(R.id.clearCache);

callGraphButton.setOnClickListener(new View.OnClickListener() {
    public void onClick(View v) {
        onCallGraphClicked();
    }
});

signOutButton.setOnClickListener(new View.OnClickListener() {
    public void onClick(View v) {
        onSignOutClicked();
    }
});

/* Configure your sample app and save state for this activity */
sampleApp = new PublicClientApplication(
        this.getApplicationContext(),
        R.raw.auth_config);

/* Attempt to get a user and acquireTokenSilent */
sampleApp.getAccounts(new PublicClientApplication.AccountsLoadedCallback() {
    @Override
    public void onAccountsLoaded(final List<IAccount> accounts) {
        if (!accounts.isEmpty()) {
            /* This sample doesn't support multi-account scenarios, use the first account */
            sampleApp.acquireTokenSilentAsync(SCOPES, accounts.get(0), getAuthSilentCallback());
        } else {
            /* No accounts */
        }
    }
});

O código acima tenta conectar silenciosamente os usuários quando eles abrem o aplicativo por meio de getAccounts() e, se bem-sucedidos, acquireTokenSilentAsync().The code above attempts to sign in users silently when they open your application through getAccounts() and, if successful, acquireTokenSilentAsync(). Nas próximas seções, implementaremos o manipulador de retorno de chamada para o caso de não haver contas conectadas.In the next few sections, we'll implement the callback handler for the case there are no signed in accounts.

Usar a MSAL para obter tokensUse MSAL to get Tokens

Agora, podemos implementar a interface de usuário do aplicativo lógica de processamento e a obtenção de tokens interativamente por meio da MSAL.Now, we can implement the app's UI processing logic and getting tokens interactively through MSAL.

A MSAL expõe dois métodos principais para obter tokens: acquireTokenSilentAsync() e acquireToken().MSAL exposes two primary methods for getting tokens: acquireTokenSilentAsync() and acquireToken().

acquireTokenSilentAsync() conecta um usuário e obtém tokens sem qualquer interação do usuário se uma conta estiver presente.acquireTokenSilentAsync() signs in a user and get tokens without any user interaction if an account is present. Se tiver êxito, a MSAL enviará os tokens para seu aplicativo, se falhar, ela irá gerar um MsalUiRequiredException.If it succeeds, MSAL will handoff the tokens to your app, if it fails it will generate a MsalUiRequiredException. Se essa exceção for gerada ou se você quiser que seu usuário tenha uma experiência de conexão interativa (credenciais, MFA ou outras políticas de acesso condicional podem ou não ser necessárias), use acquireToken().If this exception is generated, or you want the user to have an interactive sign in experience (credentials, mfa, or other Conditional Access policies may or may not be required), then use acquireToken().

acquireToken() exibe a interface do usuário ao tentar conectar o usuário e obter tokens.acquireToken() displays UI when attempting to sign in the user and get tokens. No entanto, ele pode usar cookies de sessão no navegador ou uma conta no Microsoft Authenticator para fornecer uma experiência de SSO interativo.However, it may use session cookies in the browser, or an account in the Microsoft authenticator, to provide the interactive-SSO experience.

Crie os três métodos de interface do usuário a seguir dentro da classe MainActivity:Create the following three UI methods inside the MainActivity class:

/* Set the UI for successful token acquisition data */
private void updateSuccessUI() {
    callGraphButton.setVisibility(View.INVISIBLE);
    signOutButton.setVisibility(View.VISIBLE);
    findViewById(R.id.welcome).setVisibility(View.VISIBLE);
    ((TextView) findViewById(R.id.welcome)).setText("Welcome, " +
            authResult.getAccount().getUsername());
    findViewById(R.id.graphData).setVisibility(View.VISIBLE);
}

/* Set the UI for signed out account */
private void updateSignedOutUI() {
    callGraphButton.setVisibility(View.VISIBLE);
    signOutButton.setVisibility(View.INVISIBLE);
    findViewById(R.id.welcome).setVisibility(View.INVISIBLE);
    findViewById(R.id.graphData).setVisibility(View.INVISIBLE);
    ((TextView) findViewById(R.id.graphData)).setText("No Data");

    Toast.makeText(getBaseContext(), "Signed Out!", Toast.LENGTH_SHORT)
            .show();
}

/* Use MSAL to acquireToken for the end-user
 * Callback will call Graph api w/ access token & update UI
 */
private void onCallGraphClicked() {
    sampleApp.acquireToken(getActivity(), SCOPES, getAuthInteractiveCallback());
}

Adicione os seguintes métodos para obter a atividade atual e processar retornos de chamada silenciosos e interativos:Add the following methods to get the current activity and process silent & interactive callbacks:

public Activity getActivity() {
    return this;
}

/* Callback used in for silent acquireToken calls.
 * Looks if tokens are in the cache (refreshes if necessary and if we don't forceRefresh)
 * else errors that we need to do an interactive request.
 */
private AuthenticationCallback getAuthSilentCallback() {
    return new AuthenticationCallback() {

        @Override
        public void onSuccess(IAuthenticationResult authenticationResult) {
            /* Successfully got a token, call graph now */
            Log.d(TAG, "Successfully authenticated");

            /* Store the authResult */
            authResult = authenticationResult;

            /* call graph */
            callGraphAPI();

            /* update the UI to post call graph state */
            updateSuccessUI();
        }

        @Override
        public void onError(MsalException exception) {
            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: " + exception.toString());

            if (exception instanceof MsalClientException) {
                /* Exception inside MSAL, more info inside the exception */
            } else if (exception instanceof MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            } else if (exception instanceof MsalUiRequiredException) {
                /* Tokens expired or no session, retry with interactive */
            }
        }

        @Override
        public void onCancel() {
            /* User cancelled the authentication */
            Log.d(TAG, "User cancelled login.");
        }
    };
}

/* Callback used for interactive request.  If succeeds we use the access
 * token to call the Microsoft Graph. Does not check cache
 */
private AuthenticationCallback getAuthInteractiveCallback() {
    return new AuthenticationCallback() {

        @Override
        public void onSuccess(IAuthenticationResult authenticationResult) {
            /* Successfully got a token, call graph now */
            Log.d(TAG, "Successfully authenticated");
            Log.d(TAG, "ID Token: " + authenticationResult.getIdToken());

            /* Store the auth result */
            authResult = authenticationResult;

            /* call graph */
            callGraphAPI();

            /* update the UI to post call graph state */
            updateSuccessUI();
        }

        @Override
        public void onError(MsalException exception) {
            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: " + exception.toString());

            if (exception instanceof MsalClientException) {
                /* Exception inside MSAL, more info inside the exception */
            } else if (exception instanceof MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            }
        }

        @Override
        public void onCancel() {
            /* User cancelled the authentication */
            Log.d(TAG, "User cancelled login.");
        }
    };
}

Usar a MSAL para saídaUse MSAL for Sign-out

Em seguida, adicione o suporte para saída.Next, add support for sign-out.

Importante

A saída com a MSAL remove todas as informações conhecidas sobre um usuário deste aplicativo, mas o usuário ainda terá uma sessão ativa em seu dispositivo.Signing out with MSAL removes all known information about a user from the application, but the user will still have an active session on their device. Se o usuário tentar entrar novamente, ele poderá ver a interface do usuário de entrada, mas talvez não precise inserir novamente suas credenciais, pois a sessão do dispositivo ainda estará ativa.If the user attempts to sign in again they may see sign-in UI, but may not need to reenter their credentials because the device session is still active.

Para adicionar funcionalidade de saída, adicione o seguinte método dentro da classe MainActivity.To add sign-out capability, add the following method inside the MainActivity class. Esse método percorre todas as contas e as remove:This method cycles through all accounts and removes them:

/* Clears an account's tokens from the cache.
 * Logically similar to "sign out" but only signs out of this app.
 * User will get interactive SSO if trying to sign back-in.
 */
private void onSignOutClicked() {
    /* Attempt to get a user and acquireTokenSilent
     * If this fails we do an interactive request
     */
    sampleApp.getAccounts(new PublicClientApplication.AccountsLoadedCallback() {
        @Override
        public void onAccountsLoaded(final List<IAccount> accounts) {

            if (accounts.isEmpty()) {
                /* No accounts to remove */

            } else {
                for (final IAccount account : accounts) {
                    sampleApp.removeAccount(
                            account,
                            new PublicClientApplication.AccountsRemovedCallback() {
                        @Override
                        public void onAccountsRemoved(Boolean isSuccess) {
                            if (isSuccess) {
                                /* successfully removed account */
                            } else {
                                /* failed to remove account */
                            }
                        }
                    });
                }
            }

            updateSignedOutUI();
        }
    });
}

Chamar a API do Microsoft GraphCall the Microsoft Graph API

Após recebermos um token, podemos fazer uma solicitação para a API do Microsoft Graph. O token de acesso estará dentro de AuthenticationResult dentro do método onSuccess() do retorno de chamada de autenticação.Once we have received a token, we can make a request to the Microsoft Graph API The access token will be inside the AuthenticationResult inside the auth callback's onSuccess() method. Para criar uma solicitação autorizada, seu aplicativo precisará adicionar o token de acesso ao cabeçalho HTTP:To construct an authorized request, your app will need to add the access token to the HTTP header:

chave de cabeçalhoheader key valuevalue
AutorizaçãoAuthorization Bearer <access-token>Bearer <access-token>

Adicione os dois métodos a seguir dentro da classe MainActivity para o grafo de chamadas e atualize a interface do usuário:Add the following two methods inside the MainActivity class to call graph and update the UI:

/* Use Volley to make an HTTP request to the /me endpoint from MS Graph using an access token */
private void callGraphAPI() {
    Log.d(TAG, "Starting volley request to graph");

    /* Make sure we have a token to send to graph */
    if (authResult.getAccessToken() == null) {return;}

    RequestQueue queue = Volley.newRequestQueue(this);
    JSONObject parameters = new JSONObject();

    try {
        parameters.put("key", "value");
    } catch (Exception e) {
        Log.d(TAG, "Failed to put parameters: " + e.toString());
    }
    JsonObjectRequest request = new JsonObjectRequest(Request.Method.GET, MSGRAPH_URL,
            parameters,new Response.Listener<JSONObject>() {
        @Override
        public void onResponse(JSONObject response) {
            /* Successfully called graph, process data and send to UI */
            Log.d(TAG, "Response: " + response.toString());

            updateGraphUI(response);
        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            Log.d(TAG, "Error: " + error.toString());
        }
    }) {
        @Override
        public Map<String, String> getHeaders() {
            Map<String, String> headers = new HashMap<>();
            headers.put("Authorization", "Bearer " + authResult.getAccessToken());
            return headers;
        }
    };

    Log.d(TAG, "Adding HTTP GET to Queue, Request: " + request.toString());

    request.setRetryPolicy(new DefaultRetryPolicy(
            3000,
            DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
            DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
    queue.add(request);
}

/* Sets the graph response */
private void updateGraphUI(JSONObject graphResponse) {
    TextView graphText = findViewById(R.id.graphData);
    graphText.setText(graphResponse.toString());
}

Aplicativos de várias contasMulti-account applications

Este aplicativo foi criado para um cenário de conta única.This app is built for a single account scenario. A MSAL também dá suporte a cenários de várias contas, mas requer algum trabalho adicional dos aplicativos.MSAL also supports multi-account scenarios, but it requires some additional work from apps. Você precisará criar a interface do usuário para ajudar a selecionar qual conta deseja usar para cada ação que requer tokens do usuário.You will need to create UI to help user's select which account they want to use for each action that requires tokens. Como alternativa, seu aplicativo pode implementar uma heurística para selecionar qual conta usar por meio do método getAccounts().Alternatively, your app can implement a heuristic to select which account to use via the getAccounts() method.

Testar seu aplicativoTest your app

Executar localmenteRun locally

Compilar e implantar o aplicativo em um emulador ou dispositivo de teste.Build and deploy the app to a test device or emulator. Você deve conseguir conectar e obter tokens para o Azure AD ou contas Microsoft pessoais.You should be able to sign in and get tokens for Azure AD or personal Microsoft accounts.

Após entrar, este aplicativo exibirá os dados retornados do ponto de extremidade /me do Microsoft Graph.After you sign in, the app will display the data returned from the Microsoft Graph /me endpoint.

Na primeira vez que um usuário entrar no seu aplicativo, ele será solicitado pela identidade da Microsoft a consentir com as permissões solicitadas.The first time any user signs into your app, they will be prompted by Microsoft identity to consent to the permissions requested. Embora a maioria dos usuários seja capaz de dar seu consentimento, alguns locatários do Azure AD desabilitaram o consentimento do usuário, que exige que os administradores consintam em nome de todos os usuários.While most users are capable of consenting, some Azure AD tenants have disabled user consent which requires admins to consent on behalf of all users. Para dar suporte a esse cenário, registre os escopos do seu aplicativo no portal do Azure.To support this scenario, register your app's scopes in the Azure portal.

Obter ajudaGet help

Visite Ajuda e suporte se você tiver algum problema com este tutorial ou com a plataforma de identidade da Microsoft.Visit Help and support if you have trouble with this tutorial or with the Microsoft identity platform.

Ajude-nos a melhorar a plataforma de identidade da Microsoft.Help us improve the Microsoft identity platform. Deixe sua opinião respondendo a uma breve pesquisa de duas perguntas.Tell us what you think by completing a short two-question survey.