Developer-authenticated identités

Android

Pour utiliser des identités authentifiées par le développeur, implémentez votre propre classe de fournisseur d'identité qui étend AWSAbstractCognitoIdentityProvider. Votre classe de fournisseur d'identité doit retourner un objet de réponse contenant le jeton comme attribut.

Vous trouverez ci-après un exemple de base d'un fournisseur d'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;
    }

  }
}

Pour utiliser ce fournisseur d'identité, vous devez le transmettre dans CognitoCachingCredentialsProvider. Voici un exemple :

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

iOS – objective-C

Pour utiliser des identités authentifiées par le développeur, implémentez votre propre classe de fournisseur d'identité qui étend AWSCognitoCredentialsProviderHelper. Votre classe de fournisseur d'identité doit retourner un objet de réponse contenant le jeton comme attribut.

@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

Pour utiliser ce fournisseur d'identité, transmettez-le dans AWSCognitoCredentialsProvider comme illustré dans l'exemple suivant :

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

Si vous souhaitez prendre en charge les identités non authentifiées et les identités authentifiées par le développeur, remplacez la méthode logins dans votre implémentation de AWSCognitoCredentialsProviderHelper.

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

Si vous souhaitez prendre en charge les identités authentifiées par le développeur et les fournisseurs sociaux, vous devez gérer qui est le fournisseur actuel dans votre implémentation logins de 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

Pour utiliser des identités authentifiées par le développeur, implémentez votre propre classe de fournisseur d'identité qui étend AWSCognitoCredentialsProviderHelper. Votre classe de fournisseur d'identité doit retourner un objet de réponse contenant le jeton comme attribut.

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

Pour utiliser ce fournisseur d'identité, transmettez-le dans AWSCognitoCredentialsProvider comme illustré dans l'exemple suivant :

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

Si vous souhaitez prendre en charge les identités non authentifiées et les identités authentifiées par le développeur, remplacez la méthode logins dans votre implémentation de AWSCognitoCredentialsProviderHelper.

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

Si vous souhaitez prendre en charge les identités authentifiées par le développeur et les fournisseurs sociaux, vous devez gérer qui est le fournisseur actuel dans votre implémentation logins de 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

Une fois que vous obtenez un ID d'identité et un jeton de session à partir de votre système backend, transmettez-les au fournisseur AWS.CognitoIdentityCredentials. La clé de connexion doit correspondre à la valeur demandée par le jetoniss. Pour les pools d'identités dans les régions qui utilisent l'émetteur mondial, utilisezcognito-identity.amazonaws.com. Pour les groupes d'identités dans d'autres régions, utilisezcognito-identity.region.amazonaws.com. Pour de plus amples informations, veuillez consulter Format d'émetteur de jetons régional.

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

Unity

Afin d'utiliser les identités authentifiées par le développeur, vous devez étendre CognitoAWSCredentials et remplacer la méthode RefreshIdentity pour récupérer l'ID d'identité utilisateur et le jeton à partir de votre système backend, puis les renvoyer. Voici un exemple simple de fournisseur d'identité qui contacte un système backend hypothétique à l'adresse « example.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);
    }
}

Le code ci-dessus utilise un objet de répartiteur de thread pour appeler une co-routine. Si vous n'avez pas la possibilité de le faire dans votre projet, vous pouvez utiliser le script suivant dans vos scènes :

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

Afin d'utiliser les identités authentifiées par le développeur, vous devez étendre CognitoAWSCredentials et remplacer la méthode RefreshIdentity pour récupérer l'ID d'identité utilisateur et le jeton à partir de votre système backend, puis les renvoyer. Voici un exemple élémentaire de fournisseur d'identité qui contacte un système backend hypothétique à l'adresse « example.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

Une fois que l'utilisateur est authentifié avec votre système d'authentification, mettez à jour le mappage des connexions avec le nom du fournisseur de développement et un ID utilisateur de développeur. Il s'agit d'une chaîne alphanumérique qui identifie de manière unique un utilisateur dans votre système d'authentification. Veillez à appeler la méthode refresh après la mise à jour de la carte de connexions, car il se peut que l'identityId ait changé :

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

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

iOS  – objective-C

Le kit SDK iOS appelle uniquement votre méthode logins pour obtenir la dernière carte de connexions s'il n'existe pas d'informations d'identification ou si celles-ci ont expiré. Si vous voulez forcer le kit SDK à obtenir de nouvelles informations d'identification (par exemple, votre utilisateur final est passé de non authentifié à authentifié et vous souhaitez des informations d'identification pour l'utilisateur authentifié), appelez clearCredentials sur votre credentialsProvider.

[credentialsProvider clearCredentials];

iOS – swift

Le kit SDK iOS appelle uniquement votre méthode logins pour obtenir la dernière carte de connexions s'il n'existe pas d'informations d'identification ou si celles-ci ont expiré. Si vous voulez forcer le kit SDK à obtenir les nouvelles informations d'identification (par exemple, votre utilisateur final est passé de non authentifié à authentifié et vous souhaitez des informations d'identification pour l'utilisateur authentifié), appelez clearCredentials sur votre credentialsProvider.

credentialsProvider.clearCredentials()

Android

Votre application peut nécessiter de prendre en charge les identités authentifiées ou non authentifiées via les fournisseurs publics (Login with Amazon, Se connecter avec Apple, Facebook ou Google), ainsi que les identités authentifiées par le développeur. La principale différence entre les identités authentifiées par le développeur et les autres (identités non authentifiées ou authentifiées via un fournisseur public) réside dans le mode de récupération de l'ID d'identité et du jeton. Pour les autres identités, l'application mobile interagit directement avec Amazon Cognito au lieu de communiquer avec votre système d'authentification. Par conséquent, l'application mobile doit être capable de prendre en charge deux flux distincts selon le choix de l'utilisateur de l'application. Pour cela, vous devez apporter des modifications au fournisseur d'identités personnalisées.

La méthode refresh vérifie le mappage des connexions. Si ce mappage n'est pas vide et qu'il contient une clé avec le nom du fournisseur du développement, appelez votre système backend. Sinon, appelez la IdentityId méthode get et renvoyez 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;
   }
}

De même, la méthode getIdentityId propose deux flux en fonction du contenu de la carte de connexions :

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

Votre application peut nécessiter de prendre en charge les identités authentifiées ou non authentifiées via les fournisseurs publics (Login with Amazon, Se connecter avec Apple, Facebook ou Google), ainsi que les identités authentifiées par le développeur. Pour ce faire, remplacez la AWSCognitoCredentialsProviderHelper logins méthode afin de pouvoir renvoyer la carte de connexion correcte en fonction du fournisseur d'identité actuel. Cet exemple montre comment vous pouvez alterner entre une identité non authentifiée, Facebook et authentifiée par le développeur.

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

Lorsque vous passez d'une identité non authentifiée à une identité authentifiée, vous devez appeler [credentialsProvider clearCredentials]; pour forcer le kit SDK à obtenir les nouvelles informations d'identification authentifiées. Lorsque vous basculez entre deux fournisseurs authentifiés et que vous n'essayez pas de lier les deux fournisseurs (par exemple, si vous ne fournissez pas de jetons pour plusieurs fournisseurs dans votre dictionnaire de connexions), appelez [credentialsProvider clearKeychain];. Cela efface les informations d'identification et l'identité, et force le kit SDK à obtenir de nouvelles informations d'identification.

iOS – swift

Votre application peut nécessiter de prendre en charge les identités authentifiées ou non authentifiées via les fournisseurs publics (Login with Amazon, Se connecter avec Apple, Facebook ou Google), ainsi que les identités authentifiées par le développeur. Pour ce faire, remplacez la AWSCognitoCredentialsProviderHelper logins méthode afin de pouvoir renvoyer la carte de connexion correcte en fonction du fournisseur d'identité actuel. Cet exemple montre comment vous pouvez alterner entre une identité non authentifiée, Facebook et authentifiée par le développeur.

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

Lorsque vous passez d'une identité non authentifiée à une identité authentifiée, vous devez appeler credentialsProvider.clearCredentials() pour forcer le kit SDK à obtenir les nouvelles informations d'identification authentifiées. Lorsque vous basculez entre deux fournisseurs authentifiés et que vous n'essayez pas de lier les deux fournisseurs (vous ne fournissez pas de jetons pour plusieurs fournisseurs dans votre dictionnaire de connexions), vous devez appeler credentialsProvider.clearKeychain(). Cela efface les informations d'identification et l'identité, et force le kit SDK à obtenir de nouvelles informations d'identification.

Unity

Votre application peut nécessiter de prendre en charge les identités authentifiées ou non authentifiées via les fournisseurs publics (Login with Amazon, Se connecter avec Apple, Facebook ou Google), ainsi que les identités authentifiées par le développeur. La principale différence entre les identités authentifiées par le développeur et les autres (identités non authentifiées ou authentifiées via un fournisseur public) réside dans le mode de récupération de l'ID d'identité et du jeton. Pour les autres identités, l'application mobile interagit directement avec Amazon Cognito au lieu de communiquer avec votre système d'authentification. L'application mobile doit être capable de prendre en charge deux flux distincts selon le choix de l'utilisateur de l'application. Pour cela, vous devrez apporter des modifications au fournisseur d'identités personnalisées.

La méthode recommandée pour le faire dans Unity est d'étendre votre fournisseur d'identité depuis AmazonCognitoEnhancedIdentityProvide au lieu de AbstractCognitoIdentityProvider et d'appeler la RefreshAsync méthode parent au lieu de la vôtre au cas où l'utilisateur ne serait pas authentifié avec votre propre backend. Si l'utilisateur est authentifié, vous pouvez utiliser le flux expliqué précédemment.

Xamarin

Votre application peut nécessiter de prendre en charge les identités authentifiées ou non authentifiées via les fournisseurs publics (Login with Amazon, Se connecter avec Apple, Facebook ou Google), ainsi que les identités authentifiées par le développeur. La principale différence entre les identités authentifiées par le développeur et les autres (identités non authentifiées ou authentifiées via un fournisseur public) réside dans le mode de récupération de l'ID d'identité et du jeton. Pour les autres identités, l'application mobile interagit directement avec Amazon Cognito au lieu de communiquer avec votre système d'authentification. L'application mobile doit être capable de prendre en charge deux flux distincts selon le choix de l'utilisateur de l'application. Pour cela, vous devez apporter des modifications au fournisseur d'identités personnalisées.