App client pubbliche con account singolo e multiplo

Questo articolo illustra i tipi usati in app client pubbliche con account singolo e multiplo, con particolare attenzione alle app client pubbliche con account singolo.

Il Azure Active Directory Authentication Library (ADAL) modella il server. Il Libreria di Autenticazione Microsoft (MSAL) modella invece l'applicazione client. La maggior parte delle app Android è considerata client pubblici. Un client pubblico è un'app che non può mantenere un segreto in modo sicuro.

MSAL specializza l'API di PublicClientApplication per semplificare e chiarire l'esperienza di sviluppo per le app che consentono di usare un solo account alla volta. PublicClientApplication è sottoclassato da SingleAccountPublicClientApplication e MultipleAccountPublicClientApplication. Il diagramma seguente illustra la relazione tra queste classi.

Applicazione client pubblica con account singolo

La SingleAccountPublicClientApplication classe consente di creare un'app basata su MSAL che consente l'accesso a un singolo account alla volta. SingleAccountPublicClientApplication differisce da PublicClientApplication nei modi seguenti:

• MSAL tiene traccia dell'account attualmente connesso.
  • Se l'app usa un broker (impostazione predefinita durante la registrazione dell'app Microsoft Entra) e viene installata in un dispositivo in cui è presente un broker, MSAL verificherà che l'account sia ancora disponibile nel dispositivo.
• signIn consente di accedere in modo esplicito e separato dagli ambiti di richiesta.
• acquireTokenSilent non richiede un parametro account. Se si fornisce un account e l'account fornito non corrisponde all'account attualmente rilevato da MSAL, viene generata l'eccezione MsalClientException.
• acquireToken non consente all'utente di cambiare account. Se l'utente tenta di passare a un account diverso, viene generata un'eccezione.
• getCurrentAccount restituisce un oggetto risultato che fornisce quanto segue:
  • Valore booleano che indica se l'account è stato modificato. Un account può essere modificato in seguito alla rimozione dal dispositivo, ad esempio.
  • L'account precedente. Ciò è utile se è necessario eseguire una pulizia dei dati locale quando l'account viene rimosso dal dispositivo o quando un nuovo account è connesso.
  • currentAccount.
• signOut rimuove tutti i token associati al client dal dispositivo.

Quando un broker di autenticazione Android, ad esempio Microsoft Authenticator, Il collegamento a Windows (LTW) o Intune Portale aziendale viene installato nel dispositivo e l'app è configurata per l'uso del broker, signOut non rimuoverà l'account dal dispositivo.

Scenario con account singolo

Il codice pseudo seguente illustra l'uso di SingleAccountPublicClientApplication.

// Construct Single Account Public Client Application
ISingleAccountPublicClientApplication app = PublicClientApplication.createSingleAccountPublicClientApplication(getApplicationContext(), R.raw.msal_config);

String[] scopes = {"User.Read"};
IAccount mAccount = null;

// Acquire a token interactively
// The user will get a UI prompt before getting the token.
SignInParameters signInParameters = SignInParameters.builder()
        .withActivity(getActivity()) // Pass the current activity
        .withScopes(scopes) // Specify the scopes
        .withCallback(new AuthenticationCallback() {
            @Override
            public void onSuccess(IAuthenticationResult authenticationResult){
                mAccount = authenticationResult.getAccount();
            }
    
            @Override
            public void onError(MsalException exception){
            }
    
            @Override
            public void onCancel(){
            }
        })
        .build();


app.signIn(signInParameters);

// Load Account Specific Data
getDataForAccount(account);

// Get Current Account
ICurrentAccountResult currentAccountResult = app.getCurrentAccount();
if (currentAccountResult.didAccountChange()){
    // Account Changed Clear existing account data
    clearDataForAccount(currentAccountResult.getPriorAccount());
    mAccount = currentAccountResult.getCurrentAccount();
    if (account != null){
        //load data for new account
        getDataForAccount(account);
    }
}

// Sign out
if (app.signOut()) {
    clearDataForAccount(mAccount);
    mAccount = null;
}

Applicazione client pubblica con più account

La MultipleAccountPublicClientApplication classe viene usata per creare app basate su MSAL che consentono l'accesso contemporaneamente a più account. Consente di ottenere, aggiungere e rimuovere account come indicato di seguito:

Aggiungi un account

Usare uno o più account nell'applicazione chiamando acquireToken una o più volte.

Ottieni gli account

• Chiamare getAccount per ottenere un account specifico.
• Chiamare getAccountsper ottenere un elenco di account attualmente noti all'app.

La tua app non sarà in grado di elencare tutti gli account della piattaforma di identità Microsoft presenti sul dispositivo e noti all'app broker. Può enumerare solo gli account usati dall'app. Gli account rimossi dal dispositivo non verranno restituiti da queste funzioni.

Rimuovere un account

Rimuovere un account chiamando removeAccount con un identificatore di account.

Se l'app è configurata per l'uso di un broker e un broker viene installato nel dispositivo, l'account non verrà rimosso dal broker quando chiami removeAccount. Vengono rimossi solo i token associati al client.

Scenario con più account

Lo pseudocode seguente illustra come creare un'app per più account, elencare gli account nel dispositivo e acquisire i token.

// Construct Multiple Account Public Client Application
IMultipleAccountPublicClientApplication app = PublicClientApplication.createMultipleAccountPublicClientApplication(getApplicationContext(), R.raw.msal_config);

String[] scopes = {"User.Read"};
IAccount mAccount = null;

// Acquire a token interactively
// The user will be required to interact with a UI to obtain a token
AcquireTokenParameters acquireTokenParameters = new AcquireTokenParameters.Builder()
        .startAuthorizationFromActivity(getActivity())
        .withScopes(scopes)
        .withCallback(new AuthenticationCallback(){
    
            @Override
            public void onSuccess(IAuthenticationResult authenticationResult) {
                mAccount = authenticationResult.getAccount();
            }
    
            @Override
            public void onError(MsalException exception){
            }
    
            @Override
            public void onCancel(){
            }
         })
        .build();
app.acquireToken(acquireTokenParameters);


...

// Get the default authority
String authority = app.getConfiguration().getDefaultAuthority().getAuthorityURL().toString();

// Get a list of accounts on the device
List<IAccount> accounts = app.getAccounts();

// Pick an account to obtain a token from without prompting the user to sign in
IAccount selectedAccount = accounts.get(0);

// Get a token without prompting the user
AcquireTokenSilentParameters acquireTokenSilentParameters = new AcquireTokenSilentParameters.Builder()
        .withScopes(scopes)
        .forAccount(selectedAccount)
        .fromAuthority(authority)
        .withCallback(new SilentAuthenticationCallback() {

            @Override
            public void onSuccess(IAuthenticationResult authenticationResult) {
                mAccount = authenticationResult.getAccount();
            }
    
            @Override
            public void onError(MsalException exception){
            }
        })
        .build();
app.acquireTokenSilentAsync(acquireTokenSilentParameters);