Identidades autenticadas por el desarrollador

Android

Para usar las identidades autenticadas por el desarrollador, implemente su propia clase de proveedor de identidad que amplía AWSAbstractCognitoIdentityProvider. La clase de proveedor de identidad debe devolver un objeto de respuesta que contenga el token como un atributo.

El siguiente es un ejemplo básico de un proveedor de identidades.

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

  }
}

Para utilizar este proveedor de identidad, tiene que pasarlo en CognitoCachingCredentialsProvider. A continuación se muestra un ejemplo:

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

iOS - Objective-C

Para usar las identidades autenticadas por el desarrollador, implemente su propia clase de proveedor de identidades que amplía AWSCognitoCredentialsProviderHelper. La clase de proveedor de identidad debe devolver un objeto de respuesta que contenga el token como un atributo.

@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

Para utilizar este proveedor de identidad, tiene que pasarlo en AWSCognitoCredentialsProvider, como se muestra en el ejemplo siguiente:

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 quiere dar soporte a las identidades sin autenticar y a las identidades autenticadas por el desarrollador, anule el método logins en la implementación de AWSCognitoCredentialsProviderHelper.

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

Si quiere dar soporte a las identidades autenticadas por el desarrollador y a los proveedores sociales, debe administrar quién es el proveedor actual en la implementación 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

Para usar las identidades autenticadas por el desarrollador, implemente su propia clase de proveedor de identidades que amplía AWSCognitoCredentialsProviderHelper. La clase de proveedor de identidad debe devolver un objeto de respuesta que contenga el token como un atributo.

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

Para utilizar este proveedor de identidad, tiene que pasarlo en AWSCognitoCredentialsProvider, como se muestra en el ejemplo siguiente:

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 quiere dar soporte a las identidades sin autenticar y a las identidades autenticadas por el desarrollador, anule el método logins en la implementación de AWSCognitoCredentialsProviderHelper.

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

Si quiere dar soporte a las identidades autenticadas por el desarrollador y a los proveedores sociales, debe administrar quién es el proveedor actual en la implementación 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

Una vez que obtenga un ID de identidad y un token de sesión del backend, deberá pasarlos al proveedor de AWS.CognitoIdentityCredentials. A continuación se muestra un ejemplo.

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

Unity

Para usar las identidades autenticadas por el desarrollador, debe ampliar CognitoAWSCredentials y anular el método RefreshIdentity para recuperar el ID y el token de identidad del usuario del backend y devolverlos. A continuación, se muestra un ejemplo sencillo de un proveedor de identidad que se pone en contacto con un hipotético backend en "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);
    }
}

El código anterior utiliza un objeto distribuidor de subprocesos para llamar a una corutina. Si no dispone de una forma de hacerlo en su proyecto, puede utilizar el script siguiente en sus escenas:

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

Para usar las identidades autenticadas por el desarrollador, debe ampliar CognitoAWSCredentials y anular el método RefreshIdentity para recuperar el ID y el token de identidad del usuario del backend y devolverlos. A continuación, se muestra un ejemplo sencillo de un proveedor de identidades que contacta con un hipotético backend en "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

Después de autenticar correctamente al usuario con su propio sistema de autenticación, actualice la asignación de inicios de sesión con el nombre del proveedor de desarrollador y un identificador de usuario de desarrollador. Se trata de una cadena alfanumérica que identifica de forma exclusiva a un usuario en el sistema de autenticación. Asegúrese de llamar al método refresh después de actualizar la asignación de inicios de sesión, ya que identityId podría haber cambiado:

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

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

iOS - Objective-C

El SDK para iOS solo llama al método logins para obtener la última asignación de inicios de sesión si no hay credenciales o estas han caducado. Si quiere obligar al SDK a obtener nuevas credenciales (por ejemplo, el usuario final ha pasado de no estar autenticado a estar autenticado y usted quiere credenciales sobre el usuario autenticado), llame a clearCredentials en su credentialsProvider.

[credentialsProvider clearCredentials];

iOS - Swift

El SDK para iOS solo llama al método logins para obtener la última asignación de inicios de sesión si no hay credenciales o estas han caducado. Si quiere obligar al SDK a obtener nuevas credenciales (por ejemplo, el usuario final ha pasado de no estar autenticado a estar autenticado y usted quiere credenciales sobre el usuario autenticado), llame a clearCredentials en su credentialsProvider.

credentialsProvider.clearCredentials()

Android

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. La diferencia fundamental entre las identidades autenticadas por el desarrollador y otras identidades (identidades sin autenticar e identidades autenticadas mediante un proveedor público) radica en la forma de obtener identityId y el token. En el caso de las demás identidades, la aplicación móvil interactúa directamente con Amazon Cognito, en lugar de contactar con el sistema de autenticación. Por lo tanto, la aplicación móvil debería poder admitir dos flujos diferentes en función de la elección realizada por el usuario de la aplicación. Para esto, tendrá que realizar algunos cambios en el proveedor de identidades personalizado.

El método refresh comprueba el mapa de inicios de sesión. Si el mapa no está vacío y tiene una clave con el nombre del proveedor de desarrolladores, llame al backend. De lo contrario, llame al método getIdentityId y devuelva un valor nulo.

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

Igualmente, el método getIdentityId tendrá dos flujos, en función del contenido de la asignación de inicios de sesión:

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

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. Para ello, anule el método de AWSCognitoCredentialsProviderHelper de logins para poder devolver el mapa correcto de los inicios de sesión en función del proveedor de identidad actual. En este ejemplo se muestra cómo puede moverse entre identidades sin autenticar e identidades autenticadas mediante Facebook o por el desarrollador.

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

Cuando pase de identidades sin autenticar a identidades autenticadas, llame a [credentialsProvider clearCredentials]; para obligar al SDK a obtener credenciales autenticadas nuevas. Cuando cambie entre dos proveedores autenticados y no esté intentando vincularlos (por ejemplo, no proporciona tokens para varios proveedores en el diccionario de inicios de sesión), llame a [credentialsProvider clearKeychain];. Esto borrará las credenciales y la identidad y obligará al SDK a obtener otras nuevas.

iOS - Swift

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. Para ello, anule el método de AWSCognitoCredentialsProviderHelper de logins para poder devolver el mapa correcto de los inicios de sesión en función del proveedor de identidad actual. En este ejemplo se muestra cómo puede moverse entre identidades sin autenticar e identidades autenticadas mediante Facebook o por el desarrollador.

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

Cuando pase de identidades sin autenticar a identidades autenticadas, llame a credentialsProvider.clearCredentials() para obligar al SDK a obtener credenciales autenticadas nuevas. Cuando cambie entre dos proveedores autenticados y no esté intentando vincularlos (por ejemplo, no proporciona tokens para varios proveedores en el diccionario de inicios de sesión), llame a credentialsProvider.clearKeychain(). Esto borrará las credenciales y la identidad y obligará al SDK a obtener otras nuevas.

Unity

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. La diferencia fundamental entre las identidades autenticadas por el desarrollador y otras identidades (identidades sin autenticar e identidades autenticadas mediante un proveedor público) radica en la forma de obtener identityId y el token. En el caso de las demás identidades, la aplicación móvil interactúa directamente con Amazon Cognito, en lugar de contactar con el sistema de autenticación. La aplicación móvil debería poder admitir dos flujos diferentes en función de la elección realizada por el usuario de la aplicación. Para ello, tendrá que realizar algunos cambios en el proveedor de identidad personalizado.

La manera recomendada de hacerlo en Unity consiste en ampliar su proveedor de identidad desde AmazonCognitoEnhancedIdentityProvide y no desde AbstractCognitoIdentityProvider, y llamar al método RefreshAsync principal y no al método propio, en caso de que el usuario no esté autenticado en su backend. Si el usuario está autenticado, puede utilizar el mismo flujo explicado anteriormente.

Xamarin

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. La diferencia fundamental entre las identidades autenticadas por el desarrollador y otras identidades (identidades sin autenticar e identidades autenticadas mediante un proveedor público) radica en la forma de obtener identityId y el token. En el caso de las demás identidades, la aplicación móvil interactúa directamente con Amazon Cognito, en lugar de contactar con el sistema de autenticación. La aplicación móvil debería poder admitir dos flujos diferentes en función de la elección realizada por el usuario de la aplicación. Para esto, tendrá que realizar algunos cambios en el proveedor de identidades personalizado.