Chiamare l'API Microsoft Graph da un'app AndroidCall the Microsoft Graph API from an Android app

Questa guida dimostra come un'applicazione Android nativa può ottenere un token di accesso e chiamare l'API Microsoft Graph o altre API che richiedono token di accesso dall'endpoint di Azure Active Directory v2.This guide demonstrates how a native Android application can get an access token and call Microsoft Graph API or other APIs that require access tokens from Azure Active Directory v2 endpoint.

Al termine di questa guida, l'applicazione sarà in grado di chiamare un'API protetta usando sia account personali (ad esempio, outlook.com, live.com e altri) sia account aziendali o di istituti di istruzione di proprietà di aziende o organizzazioni con Azure Active Directory.At the end of this guide, your application will be able to call a protected API using personal accounts (including outlook.com, live.com, and others) as well as work and school accounts from any company or organization that has Azure Active Directory.

Come interpretare questo esempioHow this sample works

Come interpretare questo esempio

L'esempio creato in questa guida si basa su uno scenario in cui viene usata un'applicazione Android per eseguire query su un'API Web che accetta token dall'endpoint di Azure Active Directory v2, in questo caso l'API Microsoft Graph.The sample created by this guide is based on a scenario where an Android application is used to query a Web API that accepts tokens from Azure Active Directory v2 endpoint – in this case, Microsoft Graph API. Per questo scenario, viene aggiunto un token a richieste HTTP tramite l'intestazione di autorizzazione.For this scenario, a token is added to HTTP requests via the Authorization header. L'acquisizione e il rinnovo del token vengono gestiti da Microsoft Authentication Library (MSAL).Token acquisition and renewal is handled by the Microsoft Authentication Library (MSAL).

PrerequisitiPre-requisites

  • Questa installazione guidata è basata su Android Studio, ma è accettabile anche qualsiasi altro ambiente di sviluppo di applicazioni Android.This guided setup is focused on Android Studio, but any other Android application development environment is also acceptable.
  • È necessario Android SDK 21 o versione successiva (è consigliato SDK 25).Android SDK 21 or newer is required (SDK 25 is recommended).
  • Per questa versione di Microsoft Authentication Library (MSAL) per Android è necessario Google Chrome o un Web browser che usa schede personalizzate.Google Chrome or a web browser using Custom Tabs is required for this release of Microsoft Authentication Library (MSAL) for Android.

Nota: Google Chrome non è incluso in Visual Studio Emulator for Android.Note: Google Chrome is not included on Visual Studio Emulator for Android. È consigliabile testare questo codice in un emulatore con API 25 o in un'immagine con API 21 o versione successiva in cui è installato Google Chrome.We recommend you to test this code on an Emulator with API 25 or an image with API 21 or newer that has with Google Chrome installed.

Come gestire l'acquisizione dei token per accedere a un'API Web protettaHow to handle token acquisition to access a protected Web API

Dopo che l'utente ha eseguito l'autenticazione, l'applicazione di esempio riceve un token che può essere usato per eseguire query nell'API Microsoft Graph o in un'API Web protetta da Microsoft Azure Active Directory v2.After the user authenticates, the sample application receives a token that can be used to query Microsoft Graph API or a Web API secured by Microsoft Azure Active Directory v2.

API come Microsoft Graph richiedono un token di accesso per consentire l'accesso a risorse specifiche, ad esempio per leggere un profilo utente, accedere al calendario dell'utente o inviare un messaggio di posta elettronica.APIs such as Microsoft Graph require an access token to allow accessing specific resources – for example, to read a user’s profile, access user’s calendar or send an email. L'applicazione può richiedere un token di accesso usando la libreria MSAL per accedere alle risorse tramite la definizione di ambiti API.Your application can request an access token using MSAL to access these resources by specifying API scopes. Il token di accesso ottenuto viene quindi aggiunto all'intestazione di autorizzazione HTTP per ogni chiamata effettuata alla risorsa protetta.This access token is then added to the HTTP Authorization header for every call made against the protected resource.

La memorizzazione nella cache e l'aggiornamento dei token di accesso vengono gestiti dalla libreria MSAL e non devono quindi essere effettuati dall'applicazione.MSAL manages caching and refreshing access tokens for you, so your application doesn't need to.

LibrerieLibraries

Questa guida usa le librerie seguenti:This guide uses the following libraries:

LibreriaLibrary DESCRIZIONEDescription
com.microsoft.identity.clientcom.microsoft.identity.client Microsoft Authentication Library (MSAL)Microsoft Authentication Library (MSAL)

Configurare il progettoSet up your project

Se invece si preferisce scaricare questo progetto Android Studio di esempio,Prefer to download this sample's Android Studio project instead? Scaricare un progetto e passare direttamente al passaggio di configurazione per configurare il codice di esempio prima di eseguirlo.Download a project and skip to the Configuration step to configure the code sample before executing .

Creare un nuovo progettoCreate a new project

  1. Aprire Android Studio. Passare a File > New > New ProjectOpen Android Studio, go to: File > New > New Project
  2. Assegnare un nome all'applicazione e fare clic su NextName your application and click Next
  3. Assicurarsi di selezionare API 21 or newer (Android 5.0) (API 21 o più recente - Android 5.0) e fare clic su NextMake sure to select API 21 or newer (Android 5.0) and click Next
  4. Lasciare Empty Activity, fare clic su Next e quindi su FinishLeave Empty Activity, click Next, then Finish

Aggiungere Microsoft Authentication Library (MSAL) al progettoAdd the Microsoft Authentication Library (MSAL) to your project

  1. In Android Studio, passare a Gradle Scripts > build.gradle (Module: app)In Android Studio, go to: Gradle Scripts > build.gradle (Module: app)
  2. Copiare e incollare il codice seguente in Dependencies:Copy and paste the following code under Dependencies:
compile ('com.microsoft.identity.client:msal:0.1.+') {
    exclude group: 'com.android.support', module: 'appcompat-v7'
}
compile 'com.android.volley:volley:1.0.0'

Informazioni sul pacchettoAbout this package

Il pacchetto precedente consente di installare Microsoft Authentication Library (MSAL),The package above installs the Microsoft Authentication Library (MSAL). che gestisce l'acquisizione, la memorizzazione nella cache e l'aggiornamento dei token utente usati per accedere ad API protette dall'endpoint Azure Active Directory v2.MSAL handles acquiring, caching and refreshing user tokens used to access APIs protected by Azure Active Directory v2 endpoint.

Creare l'interfaccia utente dell'applicazioneCreate your application’s UI

  1. Aprire activity_main.xml in res > layoutOpen: activity_main.xml under res > layout
  2. Modificare il layout di attività da android.support.constraint.ConstraintLayout o altro a LinearLayoutChange the activity layout from android.support.constraint.ConstraintLayout or other to LinearLayout
  3. Aggiungere la proprietà android:orientation="vertical" al nodo LinearLayoutAdd android:orientation="vertical" property to LinearLayout node
  4. Copiare e incollare il codice seguente nel nodo LinearLayout, sostituendo il contenuto corrente:Copy and 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>

Usare Microsoft Authentication Library (MSAL) per ottenere un token per l'API Microsoft GraphUse the Microsoft Authentication Library (MSAL) to get a token for the Microsoft Graph API

  1. Aprire: MainActivity (in app > java > {domain}.{appname})Open: MainActivity (under app > java > {domain}.{appname})
  2. Aggiungere le importazioni seguenti:Add the following imports:
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.*;
  1. Sostituire la classe MainActivity con quella seguente:Replace the MainActivity class with below:
public class MainActivity extends AppCompatActivity {

    final static String CLIENT_ID = "[Enter the application Id here]";
    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 AuthenticationResult authResult;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        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 = null;
        if (sampleApp == null) {
            sampleApp = new PublicClientApplication(
                    this.getApplicationContext(),
                    CLIENT_ID);
        }

  /* Attempt to get a user and acquireTokenSilent
   * If this fails we do an interactive request
   */
        List<User> users = null;

        try {
            users = sampleApp.getUsers();

            if (users != null && users.size() == 1) {
          /* We have 1 user */

                sampleApp.acquireTokenSilentAsync(SCOPES, users.get(0), getAuthSilentCallback());
            } else {
          /* We have no user */

          /* Let's do an interactive request */
                sampleApp.acquireToken(this, SCOPES, getAuthInteractiveCallback());
            }
        } catch (MsalClientException e) {
            Log.d(TAG, "MSAL Exception Generated while getting users: " + e.toString());

        } catch (IndexOutOfBoundsException e) {
            Log.d(TAG, "User at this position does not exist: " + e.toString());
        }

    }

//
// App callbacks for MSAL
// ======================
// getActivity() - returns activity so we can acquireToken within a callback
// getAuthSilentCallback() - callback defined to handle acquireTokenSilent() case
// getAuthInteractiveCallback() - callback defined to handle acquireToken() case
//

    public Activity getActivity() {
        return this;
    }

    /* Callback method for acquireTokenSilent 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(AuthenticationResult 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 MsalError.java */
                } 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 canceled 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(AuthenticationResult 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 MsalError.java */
                } else if (exception instanceof MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
                }
            }

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

    /* 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.getUser().getName());
        findViewById(R.id.graphData).setVisibility(View.VISIBLE);
    }

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

    /* Handles the redirect from the System Browser */
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        sampleApp.handleInteractiveRequestRedirect(requestCode, resultCode, data);
    }

}

Altre informazioniMore Information

Acquisizione di un token utente in modo interattivoGetting a user token interactive

Se si chiama il metodo AcquireTokenAsync, viene visualizzata una finestra in cui si chiede all'utente di eseguire l'accesso.Calling the AcquireTokenAsync method results in a window prompting the user to sign in. In genere, le applicazioni chiedono agli utenti di accedere in modo interattivo la prima volta che devono accedere a una risorsa protetta o quando un'operazione invisibile di acquisizione di un token ha esito negativo (ad esempio, perché la password dell'utente è scaduta).Applications usually require a user to sign in interactively the first time they need to access a protected resource, or when a silent operation to acquire a token fails (e.g. the user’s password expired).

Acquisizione di un token utente in modo invisibileGetting a user token silently

AcquireTokenSilentAsync gestisce le acquisizioni e i rinnovi dei token senza alcuna interazione da parte dell'utente.AcquireTokenSilentAsync handles token acquisitions and renewal without any user interaction. Dopo aver eseguito AcquireTokenAsync la prima volta, per le chiamate successive il metodo comunemente usato per ottenere token per accedere a risorse protette è AcquireTokenSilentAsync: le chiamate per richiedere o rinnovare token vengono effettuate in modo invisibile per l'utente.After AcquireTokenAsync is executed for the first time, AcquireTokenSilentAsync is the method commonly used to obtain tokens to access protected resources for subsequent calls - as calls to request or renew tokens are made silently. Alla fine, tuttavia, AcquireTokenSilentAsync avrà esito negativo perché, ad esempio, l'utente si sarà disconnesso o avrà modificato la password in un altro dispositivo.Eventually, AcquireTokenSilentAsync will fail – e.g. the user has signed out, or has changed their password on another device. Se MSAL rileva che il problema può essere risolto richiedendo un'azione interattiva, viene attivata una MsalUiRequiredException.When MSAL detects that the issue can be resolved by requiring an interactive action, it fires an MsalUiRequiredException. L'applicazione può gestire questa eccezione in due modi:Your application can handle this exception in two ways:

  1. Effettuare subito una chiamata a AcquireTokenAsync, in modo da chiedere all'utente di eseguire l'accesso.Make a call against AcquireTokenAsync immediately, which results in prompting the user to sign-in. Questo criterio viene usato in genere nelle applicazioni online in cui non sono disponibili contenuti offline per l'utente.This pattern is usually used in online applications where there is no offline content in the application available for the user. L'esempio generato in questa installazione guidata usa questo criterio, che è possibile vedere in pratica la prima volta che si esegue l'esempio: poiché nessun utente ha mai usato l'applicazione, PublicClientApp.Users.FirstOrDefault conterrà un valore null e verrà generata un'eccezione MsalUiRequiredException.The sample generated by this guided setup uses this pattern: you can see it in action the first time you execute the sample: because no user ever used the application, PublicClientApp.Users.FirstOrDefault will contain a null value, and an MsalUiRequiredException exception will be thrown. Il codice dell'esempio gestirà quindi l'eccezione chiamando AcquireTokenAsync, ovvero chiedendo all'utente di eseguire l'eccesso.The code in the sample then handles the exception by calling AcquireTokenAsync resulting in prompting the user to sign-in.
  2. Le applicazioni possono anche generare un'indicazione visiva per informare l'utente che è necessario un accesso interattivo, in modo da consentire di scegliere il momento più opportuno per accedere. In alternativa, l'applicazione riproverà a eseguire AcquireTokenSilentAsync in un secondo momento.Applications can also make a visual indication to the user that an interactive sign-in is required, so the user can select the right time to sign in, or the application can retry AcquireTokenSilentAsync at a later time. Questo metodo viene usato in genere quando l'utente può accedere alle funzionalità dell'applicazione senza essere interrotto, ad esempio quando nell'applicazione sono disponibili contenuti offline.This is commonly used when the user is able to access functionality of the application without being disrupted - for example, there is offline content available in the application. In questo caso, l'utente può decidere quando eseguire l'accesso per accedere alla risorsa protetta o per aggiornare informazioni obsolete. In alternativa, l'applicazione può decidere di riprovare a eseguire AcquireTokenSilentAsync se la rete viene ripristinata dopo essere stata temporaneamente non disponibile.In this case, the user can decide when they want to sign in to access the protected resource, or to refresh the outdated information, or your application can decide to retry AcquireTokenSilentAsync when network is restored after being unavailable temporarily.

Chiamare l'API Microsoft Graph usando il token appena ottenutoCall the Microsoft Graph API using the token you just obtained

  1. Aggiungere i metodi seguenti alla classe MainActivity:Add the following methods into the MainActivity class:
/* 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() throws AuthFailureError {
            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 = (TextView) findViewById(R.id.graphData);
    graphText.setText(graphResponse.toString());
}

Altre informazioni sull'esecuzione di una chiamata REST a un'API protettaMore information about making a REST call against a protected API

In questa applicazione di esempio, callGraphAPI chiama getAccessToken e quindi effettua una richiesta HTTP GET a una risorsa che richiede un token e restituisce il contenuto.In this sample application, callGraphAPI calls getAccessToken and then makes an HTTP GET request against a resource that requires a token and returns the content. Questo metodo aggiunge il token acquisito nell'intestazione di autorizzazione HTTP.This method adds the acquired token in the HTTP Authorization header. Per questo esempio, la risorsa è l'endpoint me dell'API Microsoft Graph, che consente di visualizzare informazioni sul profilo dell'utente.For this sample, the resource is the Microsoft Graph API me endpoint – which displays the user's profile information.

Configurazione della disconnessioneSetup Sign-out

  1. Aggiungere i metodi seguenti alla classe MainActivity:Add the following methods into the MainActivity class:
/* Clears a user's tokens from the cache.
 * Logically similar to "sign out" but only signs out of this app.
 */
private void onSignOutClicked() {

    /* Attempt to get a user and remove their cookies from cache */
    List<User> users = null;

    try {
        users = sampleApp.getUsers();

        if (users == null) {
            /* We have no users */

        } else if (users.size() == 1) {
            /* We have 1 user */
            /* Remove from token cache */
            sampleApp.remove(users.get(0));
            updateSignedOutUI();

        }
        else {
            /* We have multiple users */
            for (int i = 0; i < users.size(); i++) {
                sampleApp.remove(users.get(i));
            }
        }

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

    } catch (MsalClientException e) {
        Log.d(TAG, "MSAL Exception Generated while getting users: " + e.toString());

    } catch (IndexOutOfBoundsException e) {
        Log.d(TAG, "User at this position does not exist: " + e.toString());
    }
}

/* Set the UI for signed-out user */
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");
}

Altre informazioniMore information

L'oggetto onSignOutClicked sopra riportato rimuove l'utente dalla cache utente di MSAL: in questo modo, MSAL dimenticherà l'utente corrente e un'eventuale richiesta futura di acquisizione di un token riuscirà solo se effettuata in modo interattivo.onSignOutClicked above removes the user from MSAL user cache – this will effectively tell MSAL to forget the current user so a future request to acquire a token will only succeed if it is made to be interactive. Anche se l'applicazione in questo esempio supporta un unico utente, MSAL supporta anche scenari in cui è possibile eseguire contemporaneamente l'accesso di più account, come nel caso di un'applicazione di posta elettronica in cui un utente dispone di più account.Although the application in this sample supports a single user, MSAL supports scenarios where multiple accounts can be signed-in at the same time – an example is an email application where a user has multiple accounts.

Creare un'applicazione (Rapida)Create an application (Express)

È ora necessario registrare l'applicazione nel portale di registrazione delle applicazioni Microsoft:Now you need to register your application in the Microsoft Application Registration Portal:

  1. Registrare l'applicazione tramite il portale di registrazione delle applicazioni MicrosoftRegister your application via the Microsoft Application Registration Portal
  2. Immettere un nome per l'applicazione e l'indirizzo di posta elettronicaEnter a name for your application and your email
  3. Assicurarsi che l'opzione per l'installazione guidata sia selezionataMake sure the option for Guided Setup is checked
  4. Seguire le istruzioni per ottenere l'ID dell'applicazione e incollarlo nel codiceFollow the instructions to obtain the application ID and paste it into your code

Aggiungere le informazioni di registrazione dell'applicazione alla soluzione (Avanzata)Add your application registration information to your solution (Advanced)

È ora necessario registrare l'applicazione nel portale di registrazione delle applicazioni Microsoft:Now you need to register your application in the Microsoft Application Registration Portal:

  1. Passare al portale di registrazione delle applicazioni Microsoft per registrare un'applicazioneGo to the Microsoft Application Registration Portal to register an application
  2. Immettere un nome per l'applicazione e l'indirizzo di posta elettronicaEnter a name for your application and your email
  3. Assicurarsi che l'opzione per l'installazione guidata sia deselezionataMake sure the option for Guided Setup is unchecked
  4. Fare clic su Add Platform, selezionare Native Application e quindi fare clic su SalvaClick Add Platform, then select Native Application and hit Save
  5. Aprire MainActivity (in app > java > {host}.{namespace})Open MainActivity (under app > java > {host}.{namespace})
  6. Sostituire [Enter the application Id here] nella riga che inizia con final static String CLIENT_ID con l'ID dell'applicazione appena registrata:Replace the [Enter the application Id here] in the line starting with final static String CLIENT_ID with the application ID you just registered:
final static String CLIENT_ID = "[Enter the application Id here]";
  1. Aprire AndroidManifest.xml (in app > manifests). Aggiungere l'attività seguente al nodo manifest\application.Open AndroidManifest.xml (under app > manifests) Add the following activity to manifest\application node. Verrà registrata un'attività BrowserTabActivity per consentire al sistema operativo di riavviare l'applicazione dopo il completamento dell'autenticazione:This registers a BrowserTabActivity to allow the OS to resume your application after completing the authentication:
<!--Intent filter to capture System Browser 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" />

        <!--Add in your scheme/host from registered redirect URI-->
        <!--By default, the scheme should be similar to 'msal[appId]' -->
        <data android:scheme="msal[Enter the application Id here]"
            android:host="auth" />
    </intent-filter>
</activity>
  1. In BrowserTabActivity sostituire [Enter the application Id here] con l'ID dell'applicazione.In the BrowserTabActivity, replace [Enter the application Id here] with the application ID.

Testare il codiceTest your code

  1. Distribuire il codice nel dispositivo/emulatore.Deploy your code to your device/emulator.
  2. Quando si è pronti per eseguire il test dell'applicazione, usare un account Microsoft Azure Active Directory (aziendale o dell'istituto di istruzione) o un account Microsoft (live.com, outlook.com) per accedere.When you're ready to test your application, use a Microsoft Azure Active Directory account (work or school account) or a Microsoft account (live.com, outlook.com) to sign in.

    Testare l'applicazione Test your application

    Immettere nome utente e passwordEnter username and password

Al primo accesso all'applicazione viene richiesto di specificare il consenso per permettere all'applicazione di accedere al profilo e di completare l'accesso per l'utente:The first time that you sign in to your application, you're prompted to provide your consent to allow the application to access your profile and to sign you in:

Specificare il consenso per l'accesso all'applicazione

Visualizzare i risultati dell'applicazioneView application results

Dopo l'accesso dovrebbero essere visualizzati i risultati restituiti dalla chiamata all'API Microsoft Graph.After you sign in, you should see the results that are returned by the call to the Microsoft Graph API. La chiamata all'endpoint me dell'API Microsoft Graph restituisce il profilo utente https://graph.microsoft.com/v1.0/me.The call to the Microsoft Graph API me endpoint returns the user profile https://graph.microsoft.com/v1.0/me. Per un elenco di endpoint di Microsoft Graph comuni, vedere la documentazione per sviluppatori dell'API Microsoft Graph.For a list of common Microsoft Graph endpoints, see the Microsoft Graph API developer documentation.

Altre informazioni sugli ambiti e sulle autorizzazioni delegateMore information about scopes and delegated permissions

L'API Microsoft Graph richiede l'ambito user.read per leggere il profilo dell'utente.The Microsoft Graph API requires the user.read scope to read a user's profile. Per impostazione predefinita, questo ambito viene aggiunto automaticamente in ogni applicazione registrata nel portale di registrazione.This scope is automatically added by default in every application that's registered on the registration portal. Altre API per Microsoft Graph e le API personalizzate per il server di back-end potrebbero richiedere anche altri ambiti.Other APIs for Microsoft Graph, as well as custom APIs for your back-end server, might require additional scopes. L'API Microsoft Graph richiede l'ambito Calendars.Read per elencare i calendari dell'utente.The Microsoft Graph API requires the Calendars.Read scope to list the user’s calendars.

Per accedere ai calendari dell'utente nel contesto di un'applicazione, aggiungere l'autorizzazione delegata Calendars.Read alle informazioni di registrazione dell'applicazione.To access the user’s calendars in the context of an application, add the Calendars.Read delegated permission to the application registration information. Aggiungere quindi l'ambito Calendars.Read alla chiamata acquireTokenSilent.Then, add the Calendars.Read scope to the acquireTokenSilent call.

Nota

Con l'aumentare del numero di ambiti è possibile che all'utente venga chiesto di esprimere anche altri tipi di consenso.The user might be prompted for additional consents as you increase the number of scopes.

Guida e supportoHelp and support

Se è necessaria assistenza, se si vuole segnalare un problema o si vogliono ottenere altre informazioni sulle opzioni di supporto, vedere l'articolo seguente:If you need help, want to report an issue, or want to learn more about your support options, see the following article: