Identità autenticate dagli sviluppatori (pool di identità) - Amazon Cognito
Informazioni sul flusso di autenticazioneDefinisci un nome del provider per sviluppatori e associalo con un pool di identitàImplementa un provider di identitàAggiornamento della mappa degli accessi (solo Android e iOS)Ottenimento di un token (lato server)Connessione a un'identità social esistenteSupporto delle transizioni tra provider

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Identità autenticate dagli sviluppatori (pool di identità)

Amazon Cognito supporta identità autenticate dagli sviluppatori oltre alla federazione delle identità web tramite Configurazione di Facebook come pool di identità IdP, Configurazione di Google come IdP del pool di identità, Configurazione di Login with Amazon come IdP di pool di identità e Configurazione di Accedi con Apple come IdP del pool di identità. Con le identità autenticate dagli sviluppatori, puoi registrare e autenticare gli utenti tramite il tuo processo di autenticazione esistente, continuando a utilizzare Amazon Cognito per sincronizzare i dati degli utenti e accedere alle risorse. AWS L'utilizzo di identità autenticate dagli sviluppatori prevede l'interazione tra il dispositivo dell'utente finale, il back-end per l'autenticazione e Amazon Cognito. Per maggiori dettagli, consulta Understanding Amazon Cognito Authentication Part 2: Developer Authenticated Identities nel blog. AWS

Informazioni sul flusso di autenticazione

Il funzionamento dell'GetOpenIdTokenForDeveloperIdentityAPI può avviare l'autenticazione degli sviluppatori sia per l'autenticazione avanzata che per quella di base. Questa API autentica una richiesta con credenziali amministrative. La Logins mappa è il nome di un provider di sviluppatori di pool di identità, ad esempio login.mydevprovider abbinato a un identificatore personalizzato.

Esempio:

"Logins": {
        "login.mydevprovider": "my developer identifier"
    }

Autenticazione avanzata

Chiama l'operazione GetCredentialsForIdentityAPI con una Logins mappa con il nome cognito-identity.amazonaws.com e il valore del token daGetOpenIdTokenForDeveloperIdentity.

Esempio:

"Logins": {
        "cognito-identity.amazonaws.com": "eyJra12345EXAMPLE"
    }

GetCredentialsForIdentitycon identità autenticate dallo sviluppatore restituisce credenziali temporanee per il ruolo autenticato predefinito del pool di identità.

Autenticazione di base

Chiama l'operazione AssumeRoleWithWebIdentityAPI e richiedi qualsiasi ruolo IAM che abbia una relazione di trust appropriata definita. RoleArn Imposta il valore di WebIdentityToken per il token ottenuto daGetOpenIdTokenForDeveloperIdentity.

Per informazioni sull'authflow delle identità autenticate dagli sviluppatori e su come si differenziano dalle identità dei provider esterni, consulta. Flusso di autenticazione dei pool di identità (identità federate)

Definisci un nome del provider per sviluppatori e associalo con un pool di identità

Per usare le identità autenticate dagli sviluppatori, sarà necessario un pool di identità associato al provider degli sviluppatori. A tale scopo, procedere nel modo seguente:

Per aggiungere un provider degli sviluppatori personalizzato

  1. Scegli Pool di identità dalla console di Amazon Cognito. Seleziona un pool di identità.

  2. Seleziona la scheda Accesso utente.

  3. Seleziona Aggiungi provider di identità.

  4. Scegli Provider degli sviluppatori personalizzato.

  5. Inserisci un Nome del provider di sviluppatori. Non è possibile modificare o eliminare il provider degli sviluppatori dopo averlo aggiunto.

  6. Seleziona Salva modifiche.

Nota: una volta impostato, il nome del provider non può essere modificato.

Per ulteriori istruzioni su come utilizzare la console di Amazon Cognito, consulta Utilizzo della console Amazon Cognito.

Implementa un provider di identità

Android

Per utilizzare le identità autenticate dagli sviluppatori, implementa la tua classe di provider di identità che estende AWSAbstractCognitoIdentityProvider. La tua classe di provider di identità dovrebbe restituire un oggetto di risposta contenente il token come attributo.

Di seguito è riportato un esempio di base di provider di identità.

public class DeveloperAuthenticationProvider extends AWSAbstractCognitoDeveloperIdentityProvider {

  private static final String developerProvider = "<Developer_provider_name>";

  public DeveloperAuthenticationProvider(String accountId, String identityPoolId, Regions region) {
    super(accountId, identityPoolId, region);
    // Initialize any other objects needed here.
  }

  // Return the developer provider name which you choose while setting up the
  // identity pool in the &COG; Console

  @Override
  public String getProviderName() {
    return developerProvider;
  }

  // Use the refresh method to communicate with your backend to get an
  // identityId and token.

  @Override
  public String refresh() {

    // Override the existing token
    setToken(null);

    // Get the identityId and token by making a call to your backend
    // (Call to your backend)

    // Call the update method with updated identityId and token to make sure
    // these are ready to be used from Credentials Provider.

    update(identityId, token);
    return token;

  }

  // If the app has a valid identityId return it, otherwise get a valid
  // identityId from your backend.

  @Override
  public String getIdentityId() {

    // Load the identityId from the cache
    identityId = cachedIdentityId;

    if (identityId == null) {
       // Call to your backend
    } else {
       return identityId;
    }

  }
}

Per utilizzare questo provider di identità, è necessario passarlo in CognitoCachingCredentialsProvider. Ecco un esempio:

DeveloperAuthenticationProvider developerProvider = new DeveloperAuthenticationProvider( null, "IDENTITYPOOLID", context, Regions.USEAST1);
CognitoCachingCredentialsProvider credentialsProvider = new CognitoCachingCredentialsProvider( context, developerProvider, Regions.USEAST1);

iOS - objective-C

Per utilizzare le identità autenticate dagli sviluppatori, implementa la tua classe di provider di identità che estende AWSCognitoCredentialsProviderHelper. La tua classe di provider di identità dovrebbe restituire un oggetto di risposta contenente il token come attributo.

@implementation DeveloperAuthenticatedIdentityProvider
/*
 * Use the token method to communicate with your backend to get an
 * identityId and token.
 */

- (AWSTask <NSString*> *) token {
    //Write code to call your backend:
    //Pass username/password to backend or some sort of token to authenticate user
    //If successful, from backend call getOpenIdTokenForDeveloperIdentity with logins map 
    //containing "your.provider.name":"enduser.username"
    //Return the identity id and token to client
    //You can use AWSTaskCompletionSource to do this asynchronously

    // Set the identity id and return the token
    self.identityId = response.identityId;
    return [AWSTask taskWithResult:response.token];
}

@end

Per utilizzare questo provider di identità, è necessario passarlo in AWSCognitoCredentialsProvider, come illustrato nell'esempio seguente:

DeveloperAuthenticatedIdentityProvider * devAuth = [[DeveloperAuthenticatedIdentityProvider alloc] initWithRegionType:AWSRegionYOUR_IDENTITY_POOL_REGION 
                                         identityPoolId:@"YOUR_IDENTITY_POOL_ID"
                                        useEnhancedFlow:YES
                                identityProviderManager:nil];
AWSCognitoCredentialsProvider *credentialsProvider = [[AWSCognitoCredentialsProvider alloc]
                                                          initWithRegionType:AWSRegionYOUR_IDENTITY_POOL_REGION
                                                          identityProvider:devAuth];

Se intendi supportare sia le identità non autenticate sia le identità autenticate dagli sviluppatori, sostituisci il metodo logins nell'implementazione di AWSCognitoCredentialsProviderHelper.

- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins {
    if(/*logic to determine if user is unauthenticated*/) {
        return [AWSTask taskWithResult:nil];
    }else{
        return [super logins];
    }
}

Se intendi supportare le identità autenticate dagli sviluppatori e i provider social, devi indicare chi è il provider attuale nell'implementazione logins di AWSCognitoCredentialsProviderHelper.

- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins {
    if(/*logic to determine if user is unauthenticated*/) {
        return [AWSTask taskWithResult:nil];
    }else if (/*logic to determine if user is Facebook*/){
        return [AWSTask taskWithResult: @{ AWSIdentityProviderFacebook : [FBSDKAccessToken currentAccessToken] }];
    }else {
        return [super logins];
    }
}

iOS - Swift

Per utilizzare le identità autenticate dagli sviluppatori, implementa la tua classe di provider di identità che estende AWSCognitoCredentialsProviderHelper. La tua classe di provider di identità dovrebbe restituire un oggetto di risposta contenente il token come attributo.

import AWSCore
/*
 * Use the token method to communicate with your backend to get an
 * identityId and token.
 */
class DeveloperAuthenticatedIdentityProvider : AWSCognitoCredentialsProviderHelper {
    override func token() -> AWSTask<NSString> {
    //Write code to call your backend:
    //pass username/password to backend or some sort of token to authenticate user, if successful, 
    //from backend call getOpenIdTokenForDeveloperIdentity with logins map containing "your.provider.name":"enduser.username"
    //return the identity id and token to client
    //You can use AWSTaskCompletionSource to do this asynchronously

    // Set the identity id and return the token
    self.identityId = resultFromAbove.identityId
    return AWSTask(result: resultFromAbove.token)
}

Per utilizzare questo provider di identità, è necessario passarlo in AWSCognitoCredentialsProvider, come illustrato nell'esempio seguente:

let devAuth = DeveloperAuthenticatedIdentityProvider(regionType: .YOUR_IDENTITY_POOL_REGION, identityPoolId: "YOUR_IDENTITY_POOL_ID", useEnhancedFlow: true, identityProviderManager:nil)
let credentialsProvider = AWSCognitoCredentialsProvider(regionType: .YOUR_IDENTITY_POOL_REGION, identityProvider:devAuth)
let configuration = AWSServiceConfiguration(region: .YOUR_IDENTITY_POOL_REGION, credentialsProvider:credentialsProvider)
AWSServiceManager.default().defaultServiceConfiguration = configuration

Se intendi supportare sia le identità non autenticate sia le identità autenticate dagli sviluppatori, sostituisci il metodo logins nell'implementazione di AWSCognitoCredentialsProviderHelper.

override func logins () -> AWSTask<NSDictionary> {
    if(/*logic to determine if user is unauthenticated*/) {
        return AWSTask(result:nil)
    }else {
        return super.logins()
    }
}

Se intendi supportare le identità autenticate dagli sviluppatori e i provider social, devi indicare chi è il provider attuale nell'implementazione logins di AWSCognitoCredentialsProviderHelper.

override func logins () -> AWSTask<NSDictionary> {
    if(/*logic to determine if user is unauthenticated*/) {
        return AWSTask(result:nil)
    }else if (/*logic to determine if user is Facebook*/){
        if let token = AccessToken.current?.authenticationToken {
            return AWSTask(result: [AWSIdentityProviderFacebook:token])
        }
        return AWSTask(error:NSError(domain: "Facebook Login", code: -1 , userInfo: ["Facebook" : "No current Facebook access token"]))
    }else {
        return super.logins()
    }
}

JavaScript

Una volta ottenuti un ID identità e un token della sessione dal back-end, sarà necessario passarli nel provider AWS.CognitoIdentityCredentials. Ecco un esempio:

AWS.config.credentials = new AWS.CognitoIdentityCredentials({
   IdentityPoolId: 'IDENTITY_POOL_ID',
   IdentityId: 'IDENTITY_ID_RETURNED_FROM_YOUR_PROVIDER',
   Logins: {
      'cognito-identity.amazonaws.com': 'TOKEN_RETURNED_FROM_YOUR_PROVIDER'
   }
});

Unità

Per utilizzare le identità autenticate dagli sviluppatori, è necessario estendere CognitoAWSCredentials e sostituire il metodo RefreshIdentity per recuperare l'ID identità e il token dell'utente dal back-end, quindi restituirli. Di seguito è riportato un semplice esempio di provider di identità che si mette in contatto con un ipotetico back-end in "esempio.com":

using UnityEngine;
using System.Collections;
using Amazon.CognitoIdentity;
using System.Collections.Generic;
using ThirdParty.Json.LitJson;
using System;
using System.Threading;

public class DeveloperAuthenticatedCredentials : CognitoAWSCredentials
{
    const string PROVIDER_NAME = "example.com";
    const string IDENTITY_POOL = "IDENTITY_POOL_ID";
    static readonly RegionEndpoint REGION = RegionEndpoint.USEast1;

    private string login = null;

    public DeveloperAuthenticatedCredentials(string loginAlias)
        : base(IDENTITY_POOL, REGION)
    {
        login = loginAlias;
    }

    protected override IdentityState RefreshIdentity()
    {
        IdentityState state = null;
        ManualResetEvent waitLock = new ManualResetEvent(false);
        MainThreadDispatcher.ExecuteCoroutineOnMainThread(ContactProvider((s) =>
        {
            state = s;
            waitLock.Set();
        }));
        waitLock.WaitOne();
        return state;
    }

    IEnumerator ContactProvider(Action<IdentityState> callback)
    {
        WWW www = new WWW("http://example.com/?username="+login);
        yield return www;
        string response = www.text;

        JsonData json = JsonMapper.ToObject(response);

        //The backend has to send us back an Identity and a OpenID token
        string identityId = json["IdentityId"].ToString();
        string token = json["Token"].ToString();

        IdentityState state = new IdentityState(identityId, PROVIDER_NAME, token, false);
        callback(state);
    }
}

Il codice in alto utilizza un oggetto dispatcher di thread per chiamare una co-routine. Se non disponi di un modo per eseguire questa operazione nel tuo progetto, puoi utilizzare i seguenti script nelle scene:

using System;
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class MainThreadDispatcher : MonoBehaviour
{
    static Queue<IEnumerator> _coroutineQueue = new Queue<IEnumerator>();
    static object _lock = new object();

    public void Update()
    {
        while (_coroutineQueue.Count > 0)
        {
            StartCoroutine(_coroutineQueue.Dequeue());
        }
    }

    public static void ExecuteCoroutineOnMainThread(IEnumerator coroutine)
    {
        lock (_lock) {
            _coroutineQueue.Enqueue(coroutine);
        }
    }
}

Xamarin

Per utilizzare le identità autenticate dagli sviluppatori, è necessario estendere CognitoAWSCredentials e sostituire il metodo RefreshIdentity per recuperare l'ID identità e il token dell'utente dal back-end, quindi restituirli. Di seguito è riportato un esempio di base di provider di un identità che si mette in contatto con un ipotetico back-end in "esempio.com":

public class DeveloperAuthenticatedCredentials : CognitoAWSCredentials
{
    const string PROVIDER_NAME = "example.com";
    const string IDENTITY_POOL = "IDENTITY_POOL_ID";
    static readonly RegionEndpoint REGION = RegionEndpoint.USEast1;
    private string login = null;

    public DeveloperAuthenticatedCredentials(string loginAlias)
        : base(IDENTITY_POOL, REGION)
    {
        login = loginAlias;
    }

    protected override async Task<IdentityState> RefreshIdentityAsync()
    {
        IdentityState state = null;
        //get your identity and set the state
        return state;
    }
}

Aggiornamento della mappa degli accessi (solo Android e iOS)

Android

Una volta completata correttamente l'autenticazione dell'utente con il sistema di autenticazione, aggiorna la mappa degli accessi con il nome del provider degli sviluppatori e un identificatore utente per gli sviluppatori. Questa è una stringa alfanumerica che identifica in maniera univoca un utente nel sistema di autenticazione. Assicurati di chiamare il metodo refresh dopo aver aggiornato la mappa degli accessi, poiché identityId potrebbe essere cambiato:

HashMap<String, String> loginsMap = new HashMap<String, String>();
loginsMap.put(developerAuthenticationProvider.getProviderName(), developerUserIdentifier);

credentialsProvider.setLogins(loginsMap);
credentialsProvider.refresh();

iOS - objective-C

L'SDK per iOS chiama solo il metodo logins per ottenere le mappe degli accessi più recenti se non sono disponibili le credenziali o se sono scadute. Se vuoi forzare l'SDK a ottenere nuove credenziali (ad esempio, l'utente è passato dall'essere non autenticato a essere autenticato e desideri credenziali rispetto all'utente autenticato), chiama clearCredentials su credentialsProvider.

[credentialsProvider clearCredentials];

iOS - Swift

L'SDK per iOS chiama solo il metodo logins per ottenere le mappe degli accessi più recenti se non sono disponibili le credenziali o se sono scadute. Se vuoi forzare l'SDK a ottenere nuove credenziali (ad esempio, se il tuo utente è passato dall'essere non autenticato a essere autenticato e vuoi avere delle credenziali dell'utente autenticato), chiama clearCredentials sul tuo credentialsProvider.

credentialsProvider.clearCredentials()

Ottenimento di un token (lato server)

È possibile ottenere un GetOpenIdTokenForDeveloperIdentitytoken chiamando. Questa API deve essere richiamata dal backend utilizzando le credenziali AWS dello sviluppatore. Non deve essere invocata dall'SDK client. L'API riceve l'ID pool di identità di Cognito, una mappa degli accessi contenente il nome del provider di identità come chiave e l'identificatore come valore, e, facoltativamente, un ID identità di Cognito (ad esempio, se stai rendendo autenticato un utente non autenticato). L'identificatore può essere il nome utente dell'utente, un indirizzo e-mail o un valore numerico. L'API risponde alla tua chiamata con un ID di Cognito univoco per il tuo utente e con un token Cognito OpenID Connect per l'utente finale.

Qualche consiglio da tenere a mente relativamente al token restituito da GetOpenIdTokenForDeveloperIdentity:

  • Puoi specificare un periodo di scadenza personalizzato per il token in modo da memorizzarlo nella cache. Se non fornisci alcun periodo di scadenza personalizzato, il token è valido per 15 minuti.

  • È possibile impostare un periodo massimo di durata del token di 24 ore.

  • Sii consapevole delle implicazioni di sicurezza relative all'aumento della durata del token. Se un utente malintenzionato ottiene questo token, può scambiarlo con AWS credenziali per l'utente finale per la durata del token.

I seguenti frammenti di codice Java mostrano come inizializzare un client Amazon Cognito e recuperare un token per un'identità autenticata dagli sviluppatori.

// authenticate your end user as appropriate
// ....

// if authenticated, initialize a cognito client with your AWS developer credentials
AmazonCognitoIdentity identityClient = new AmazonCognitoIdentityClient(
  new BasicAWSCredentials("access_key_id", "secret_access_key")
);

// create a new request to retrieve the token for your end user
GetOpenIdTokenForDeveloperIdentityRequest request =
  new GetOpenIdTokenForDeveloperIdentityRequest();
request.setIdentityPoolId("YOUR_COGNITO_IDENTITY_POOL_ID");

request.setIdentityId("YOUR_COGNITO_IDENTITY_ID"); //optional, set this if your client has an
                                                   //identity ID that you want to link to this 
                                                   //developer account

// set up your logins map with the username of your end user
HashMap<String,String> logins = new HashMap<>();
logins.put("YOUR_IDENTITY_PROVIDER_NAME","YOUR_END_USER_IDENTIFIER");
request.setLogins(logins);

// optionally set token duration (in seconds)
request.setTokenDuration(60 * 15l);
GetOpenIdTokenForDeveloperIdentityResult response =
  identityClient.getOpenIdTokenForDeveloperIdentity(request);

// obtain identity id and token to return to your client
String identityId = response.getIdentityId();
String token = response.getToken();

//code to return identity id and token to client
//...

Seguendo i passaggi precedenti, sarai in grado di integrare le identità autenticate dagli sviluppatori nell'app. In caso di problemi o domande, non esitare a scrivere sui nostri forum.

Connessione a un'identità social esistente

Quando utilizzi le identità autenticate dagli sviluppatori, tutti i collegamenti dei provider devono essere eseguiti dal back-end. Per collegare un'identità personalizzata all'identità social di un utente (Login with Amazon, Accedi con Apple, Facebook o Google), aggiungi il token del provider di identità alla mappa degli accessi quando GetOpenIdTokenForDeveloperIdentitychiami. Per far sì che ciò accada, quando chiami il back-end dal tuo SDK client per autenticare l'utente finale, trasmetti anche il token del provider del social dell'utente finale.

Ad esempio, se stai cercando di collegare un'identità personalizzata a Facebook, oltre all'identificatore del provider di identità, sarà necessario aggiungere alla mappa degli accessi anche il token di Facebook quando chiami GetOpenIdTokenForDeveloperIdentity.

logins.put("YOUR_IDENTITY_PROVIDER_NAME","YOUR_END_USER_IDENTIFIER");
logins.put("graph.facebook.com","END_USERS_FACEBOOK_ACCESSTOKEN");

Supporto delle transizioni tra provider

Android

L'applicazione potrebbe richiedere il supporto di identità non autenticate o di identità autenticate tramite provider pubblici (Login with Amazon, Accedi con Apple, Facebook o Google) oltre alle identità autenticate dagli sviluppatori. La differenza principale tra le identità autenticate dagli sviluppatori e altre identità (identità non autenticate e identità autenticate tramite provider pubblici) risiede nella modalità in cui identityId e token vengono ottenuti. Per altre identità, l'applicazione per dispositivi mobili interagisce direttamente con Amazon Cognito anziché contattare il sistema di autenticazione. Pertanto, l'applicazione mobile deve essere in grado di supportare due flussi distinti, a seconda della scelta dell'utente dell'app. Per questo motivo sarà necessario apportare alcune modifiche al provider di identità personalizzato.

Il metodo refresh controlla la mappa degli accessi. Se la mappa non è vuota e contiene una chiave con il nome del provider degli sviluppatori, chiama il back-end. Altrimenti, chiama il getIdentityId metodo e restituisci null.

public String refresh() {

   setToken(null);

   // If the logins map is not empty make a call to your backend
   // to get the token and identityId
   if (getProviderName() != null &&
      !this.loginsMap.isEmpty() &&
      this.loginsMap.containsKey(getProviderName())) {

      /**
       * This is where you would call your backend
       **/

      // now set the returned identity id and token in the provider
      update(identityId, token);
      return token;

   } else {
      // Call getIdentityId method and return null
      this.getIdentityId();
      return null;
   }
}

Analogamente il metodo getIdentityId dispone di due flussi, in base al contenuto della mappa degli accessi:

public String getIdentityId() {

   // Load the identityId from the cache
   identityId = cachedIdentityId;

   if (identityId == null) {

      // If the logins map is not empty make a call to your backend
      // to get the token and identityId

      if (getProviderName() != null && !this.loginsMap.isEmpty()
         && this.loginsMap.containsKey(getProviderName())) {

         /**
           * This is where you would call your backend
          **/

         // now set the returned identity id and token in the provider
         update(identityId, token);
         return token;

      } else {
         // Otherwise call &COG; using getIdentityId of super class
         return super.getIdentityId();
      }

   } else {
      return identityId;
   }

}

iOS - Objective-C

L'applicazione potrebbe richiedere il supporto di identità non autenticate o di identità autenticate tramite provider pubblici (Login with Amazon, Accedi con Apple, Facebook o Google) oltre alle identità autenticate dagli sviluppatori. Per fare ciò, sovrascrivi il AWSCognitoCredentialsProviderHelperloginsmetodo per poter restituire la mappa di accesso corretta in base all'attuale provider di identità. Questo esempio illustra come muoversi tra un'identità non autenticata, un'identità autenticata da Facebook e dagli sviluppatori.

- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins {
    if(/*logic to determine if user is unauthenticated*/) {
        return [AWSTask taskWithResult:nil];
    }else if (/*logic to determine if user is Facebook*/){
        return [AWSTask taskWithResult: @{ AWSIdentityProviderFacebook : [FBSDKAccessToken currentAccessToken] }];
    }else {
        return [super logins];
    }
}

Quando effettui la transizione da non autenticato ad autenticato, è necessario chiamare [credentialsProvider clearCredentials]; per forzare l'SDK a ricevere nuove credenziali autenticate. Quando si passa tra due provider autenticati e non si cerca di collegarli (ad esempio, se non vengono forniti token per più provider nel dizionario degli accessi), chiama [credentialsProvider clearKeychain];. Questo cancellerà sia le credenziali che le identità e forzerà l'SDK a ottenerne di nuove.

iOS - Swift

L'applicazione potrebbe richiedere il supporto di identità non autenticate o di identità autenticate tramite provider pubblici (Login with Amazon, Accedi con Apple, Facebook o Google) oltre alle identità autenticate dagli sviluppatori. A tale scopo, sostituisci il AWSCognitoCredentialsProviderHelperloginsmetodo per poter restituire la mappa di accesso corretta in base all'attuale provider di identità. Questo esempio illustra come muoversi tra un'identità non autenticata, un'identità autenticata da Facebook e dagli sviluppatori.

override func logins () -> AWSTask<NSDictionary> {
    if(/*logic to determine if user is unauthenticated*/) {
        return AWSTask(result:nil)
    }else if (/*logic to determine if user is Facebook*/){
        if let token = AccessToken.current?.authenticationToken {
            return AWSTask(result: [AWSIdentityProviderFacebook:token])
        }
        return AWSTask(error:NSError(domain: "Facebook Login", code: -1 , userInfo: ["Facebook" : "No current Facebook access token"]))
    }else {
        return super.logins()
    }
}

Quando effettui la transizione da non autenticato ad autenticato, è necessario chiamare credentialsProvider.clearCredentials() per forzare l'SDK a ricevere nuove credenziali autenticate. Quando alterni tra due provider autenticati e non cerchi di collegarli (ad esempio, se non fornisci token per più provider nel tuo dizionario degli accessi), è necessario chiamare credentialsProvider.clearKeychain(). Questo cancellerà sia le credenziali che le identità e forzerà l'SDK a ottenerne di nuove.

Unità

L'applicazione potrebbe richiedere il supporto di identità non autenticate o di identità autenticate tramite provider pubblici (Login with Amazon, Accedi con Apple, Facebook o Google) oltre alle identità autenticate dagli sviluppatori. La differenza principale tra le identità autenticate dagli sviluppatori e altre identità (identità non autenticate e identità autenticate tramite provider pubblici) risiede nella modalità in cui identityId e token vengono ottenuti. Per altre identità, l'applicazione per dispositivi mobili interagisce direttamente con Amazon Cognito anziché contattare il sistema di autenticazione. L'applicazione per dispositivi mobili deve essere in grado di supportare due flussi distinti, a seconda della scelta dell'utente dell'app. Per questo motivo sarà necessario apportare alcune modifiche al provider di identità personalizzato.

Il modo consigliato per farlo in Unity è estendere il proprio provider di AbstractCognitoIdentityProvider identità AmazonCognitoEnhancedIdentityProvide anziché chiamare il RefreshAsync metodo principale anziché il proprio nel caso in cui l'utente non sia autenticato con il proprio backend. Se l'utente viene autenticato, puoi utilizzare lo stesso flusso spiegato precedentemente.

Xamarin

L'applicazione potrebbe richiedere il supporto di identità non autenticate o di identità autenticate tramite provider pubblici (Login with Amazon, Accedi con Apple, Facebook o Google) oltre alle identità autenticate dagli sviluppatori. La differenza principale tra le identità autenticate dagli sviluppatori e altre identità (identità non autenticate e identità autenticate tramite provider pubblici) risiede nella modalità in cui identityId e token vengono ottenuti. Per altre identità, l'applicazione per dispositivi mobili interagisce direttamente con Amazon Cognito anziché contattare il sistema di autenticazione. L'applicazione per dispositivi mobili deve essere in grado di supportare due flussi distinti, a seconda della scelta dell'utente dell'app. Per questo motivo sarà necessario apportare alcune modifiche al provider di identità personalizzato.