Developer-authenticated 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. La chiave di accesso deve corrispondere alla dichiarazione del token. iss Per i pool di identità nelle regioni che utilizzano l'emittente globale, usa. cognito-identity.amazonaws.com Per i pool di identità in altre regioni, usacognito-identity.region.amazonaws.com. Per ulteriori informazioni, consulta Formato regionale dell'emittente del token.

const token = 'TOKEN_RETURNED_FROM_YOUR_PROVIDER';

// Extract the issuer from the token
const payload = token.split('.')[1];
const claims = JSON.parse(Buffer.from(payload, 'base64url').toString());
const providerName = claims.iss;

AWS.config.credentials = new AWS.CognitoIdentityCredentials({
   IdentityPoolId: 'IDENTITY_POOL_ID',
   IdentityId: 'IDENTITY_ID_RETURNED_FROM_YOUR_PROVIDER',
   Logins: {
      [providerName]: token
   }
});

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;
    }
}

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()

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 IdentityId metodo get e restituisce 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 AWSCognitoCredentialsProviderHelper logins metodo per poter restituire la mappa degli accessi 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. Per fare ciò, sovrascrivi il AWSCognitoCredentialsProviderHelper logins metodo per poter restituire la mappa degli accessi 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 provider di identità da AmazonCognitoEnhancedIdentityProvide invece di AbstractCognitoIdentityProvider e chiamare il RefreshAsync metodo principale invece del 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.