Identidades autenticadas por el desarrollador - Amazon Cognito
Descripción del flujo de autenticaciónDefinición de un nombre de proveedor de desarrollador y asociación de dicho nombre a un grupo de identidadesImplementación de un proveedor de identidadActualización de la asignación de inicios de sesión (solo Android e iOS)Obtención de un token (lado del servidor)Conexión con una identidad social existenteCompatibilidad con la transición entre proveedores

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Identidades autenticadas por el desarrollador

Amazon Cognito es compatible con las identidades autenticadas por el desarrollador y con la federación de identidades web mediante Configurar Facebook como un IdP de grupos de identidades, Configurar Google como un IdP de grupo de identidades, Configuración de Login with Amazon como un IdP de grupos de identidades y Configurar el inicio de sesión con Apple como un IdP de grupo de identidades. Con las identidades autenticadas por el desarrollador, puede registrar y autenticar a los usuarios mediante su propio proceso de autenticación existente y, al mismo tiempo, utilizar Amazon Cognito para sincronizar los datos de los usuarios y acceder a los recursos. AWS El uso de las identidades autenticadas por el desarrollador implica una interacción entre el dispositivo del usuario final, el backend para la autenticación y Amazon Cognito. Para obtener más información, consulte Descripción de la autenticación de Amazon Cognito, parte 2: Identidades autenticadas por desarrolladores, en el blog. AWS

Descripción del flujo de autenticación

La GetOpenIdTokenForDeveloperIdentityAPIoperación puede iniciar la autenticación del desarrollador tanto para la autenticación básica como para la mejorada. Esto API autentica una solicitud con credenciales administrativas. El Logins mapa es un nombre de proveedor desarrollador de un grupo de identidades, por ejemplo, login.mydevprovider combinado con un identificador personalizado.

Ejemplo:

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

Autenticación mejorada

Llame a la GetCredentialsForIdentityAPIoperación con un Logins mapa con el nombre cognito-identity.amazonaws.com y el valor del token desdeGetOpenIdTokenForDeveloperIdentity.

Ejemplo:

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

GetCredentialsForIdentitycon identidades autenticadas por el desarrollador, devuelve credenciales temporales para el rol autenticado predeterminado del grupo de identidades.

Autenticación básica

Llame a la AssumeRoleWithWebIdentityAPIoperación y solicite la RoleArn de cualquier IAM rol que tenga definida una relación de confianza adecuada. Establezca el valor del WebIdentityToken token del que se obtuvoGetOpenIdTokenForDeveloperIdentity.

Para obtener información sobre el flujo de autenticación de las identidades autenticadas por el desarrollador y en qué se diferencian de las identidades de los proveedores externos, consulte. Flujo de autenticación de grupos de identidades

Definición de un nombre de proveedor de desarrollador y asociación de dicho nombre a un grupo de identidades

Para utilizar las identidades autenticadas por el desarrollador, es preciso que el proveedor de desarrollador tenga un grupo de identidades asociado. Para ello, siga estos pasos:

Para agregar un proveedor de desarrolladores personalizado

  1. Elija Grupos de identidades en la consola de Amazon Cognito. Seleccione un grupo de identidades.

  2. Elija la pestaña Acceso de usuario.

  3. Seleccione Agregar proveedor de identidades.

  4. Elija un Proveedor de desarrolladores personalizado.

  5. Ingrese un Nombre de proveedor de desarrolladores. No puede cambiar ni eliminar el proveedor de desarrolladores después de agregarlo.

  6. Seleccione Guardar cambios.

Nota: una vez que se haya definido el nombre del proveedor, este no podrá modificarse.

Para obtener más indicaciones sobre cómo trabajar con la consola de Amazon Cognito, consulte Uso de la consola de Amazon Cognito.

Implementación de un proveedor de identidad

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 identidades autenticadas por el desarrollador, implementa tu propia clase de proveedor de identidades que se extienda. 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 identidades autenticadas por el desarrollador, implementa tu propia clase de proveedor de identidades que se extienda. 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;
    }
}

Actualización de la asignación de inicios de sesión (solo Android e iOS)

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

iOS SDK solo llama a tu logins método para obtener el mapa de inicios de sesión más reciente si no hay credenciales o si han caducado. Si quieres forzar la SDK obtención de nuevas credenciales (por ejemplo, si tu usuario final ha pasado de estar sin autenticar a autenticarse y quieres que las credenciales coincidan con las del usuario autenticado), llama a tu. clearCredentials credentialsProvider

[credentialsProvider clearCredentials];

iOS - Swift

iOS SDK solo llama a tu logins método para obtener el mapa de inicios de sesión más reciente si no hay credenciales o si han caducado. Si quieres forzar la SDK obtención de nuevas credenciales (por ejemplo, si tu usuario final ha pasado de estar sin autenticar a autenticarse y quieres que las credenciales coincidan con las del usuario autenticado), recurre al tuyo. clearCredentials credentialsProvider

credentialsProvider.clearCredentials()

Obtención de un token (lado del servidor)

Para obtener un token, llame. GetOpenIdTokenForDeveloperIdentity APIDebes invocarlo desde tu backend con las credenciales de AWS desarrollador. No se debe invocar desde el clienteSDK. APIRecibe el ID del grupo de identidades de Cognito; un mapa de inicios de sesión que contiene el nombre de su proveedor de identidad como clave y el identificador como valor; y opcionalmente, un ID de identidad de Cognito (por ejemplo, está autenticando a un usuario no autenticado). El identificador puede ser el nombre de usuario del usuario, una dirección de correo electrónico o un valor numérico. APIResponde a su llamada con un ID de Cognito único para su usuario y un token de OpenID Connect para el usuario final.

Tenga en cuenta los siguientes puntos sobre el token devuelto por GetOpenIdTokenForDeveloperIdentity:

  • Puede especificar una duración de vencimiento personalizada para el token para poder almacenarlo en la caché. Si no la proporciona, el token será válido durante 15 minutos.

  • La duración máxima del token que puede definir es de 24 horas.

  • Piense en las implicaciones para la seguridad que supone aumentar el token de duración. Si un atacante obtiene este token, puede cambiarlo por AWS credenciales para el usuario final durante el tiempo que dure el token.

En el siguiente fragmento Java, se muestra cómo inicializar un cliente de Amazon Cognito y recuperar un token para una identidad autenticada por el desarrollador.

// 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
//...

Si sigue los pasos anteriores, debe tener la posibilidad de integrar las identidades autenticadas por el desarrollador en la aplicación. Si tiene algún problema o alguna pregunta, no dude en publicar en nuestros foros.

Conexión con una identidad social existente

Toda vinculación de proveedores efectuada durante el uso de identidades autenticadas por el desarrollador se debe realizar desde el backend. Para conectar una identidad personalizada a la identidad social de un usuario (Login with Amazon, Sign in with Apple, Facebook o Google), añade el token del proveedor de identidad al mapa de inicios de sesión cuando llames GetOpenIdTokenForDeveloperIdentity. Para que esto sea posible, cuando llames a tu servidor desde tu cliente SDK para autenticar a tu usuario final, también debes pasarle el token del proveedor de redes sociales del usuario final.

Por ejemplo, si está intentando vincular una identidad personalizada a Facebook, añada el token de Facebook, además del identificador del proveedor de identidad, a la asignación de inicios de sesión cuando llame a GetOpenIdTokenForDeveloperIdentity.

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

Compatibilidad con la transición entre proveedores

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 esencial entre las identidades autenticadas por el desarrollador y otras identidades (las identidades no autenticadas y las identidades autenticadas que utilizan un proveedor público) es la forma en que se obtienen el token y. identityId 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, llama al método y devuelve null. getIdentityId

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 AWSCognitoCredentialsProviderHelperloginsmétodo para poder devolver el mapa de inicios de sesión correcto 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 pases de no autenticado a autenticado, debes llamar [credentialsProvider clearCredentials]; para forzar la obtención de nuevas credenciales autenticadasSDK. 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á tanto las credenciales como la identidad y las obligará 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 AWSCognitoCredentialsProviderHelperloginsmétodo para poder devolver el mapa de inicios de sesión correcto 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 pases de no autenticado a autenticado, debes llamar credentialsProvider.clearCredentials() para forzar la obtención de nuevas credenciales autenticadasSDK. 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á tanto las credenciales como la identidad y las obligará 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 esencial entre las identidades autenticadas por el desarrollador y otras identidades (las identidades no autenticadas y las identidades autenticadas que utilizan un proveedor público) es la forma en que se obtienen el token y. identityId 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 forma recomendada de hacerlo en Unity es ampliar el proveedor de identidades desde y llamar al RefreshAsync método principal AmazonCognitoEnhancedIdentityProvide en lugar del AbstractCognitoIdentityProvider tuyo propio en caso de que el usuario no esté autenticado con tu propio servidor. 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 esencial entre las identidades autenticadas por el desarrollador y otras identidades (las identidades no autenticadas y las identidades autenticadas que utilizan un proveedor público) es la forma en que se obtienen el token y el token. identityId 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.