Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
Identità autenticate dagli sviluppatori
Amazon Cognito supporta identità autenticate dagli sviluppatori oltre alla federazione delle identità web tramite Configurazione di Facebook come pool di identità IdP, Configurazione di Google come IdP del pool di identità, Configurazione di Login with Amazon come IdP di pool di identità e Configurazione di Accedi con Apple come IdP del pool di identità. Con le identità autenticate dagli sviluppatori, puoi registrare e autenticare gli utenti tramite il tuo processo di autenticazione esistente, continuando a utilizzare Amazon Cognito per sincronizzare i dati degli utenti e accedere alle risorse. AWS L'utilizzo di identità autenticate dagli sviluppatori prevede l'interazione tra il dispositivo dell'utente finale, il back-end per l'autenticazione e Amazon Cognito. Per maggiori dettagli, consulta Understanding Amazon Cognito Authentication Part 2: Developer Authenticated Identities
Informazioni sul flusso di autenticazione
L'GetOpenIdTokenForDeveloperIdentityAPIoperazione può avviare l'autenticazione degli sviluppatori sia per l'autenticazione avanzata che per quella di base. Ciò API autentica una richiesta con credenziali amministrative. La Logins
mappa è il nome di un provider di sviluppatori di pool di identità login.mydevprovider
abbinato a un identificatore personalizzato.
Esempio:
"Logins": { "login.mydevprovider": "my developer identifier" }
Autenticazione avanzata
Chiama l'GetCredentialsForIdentityAPIoperazione con una Logins
mappa con il nome cognito-identity.amazonaws.com
e il valore del token daGetOpenIdTokenForDeveloperIdentity
.
Esempio:
"Logins": { "cognito-identity.amazonaws.com": "eyJra12345EXAMPLE" }
GetCredentialsForIdentity
con identità autenticate dallo sviluppatore restituisce credenziali temporanee per il ruolo autenticato predefinito del pool di identità.
Autenticazione di base
Chiama l'AssumeRoleWithWebIdentityAPIoperazione e richiedi l'RoleArn
assegnazione di qualsiasi IAM ruolo per cui sia definita una relazione di fiducia appropriata. Imposta il valore di WebIdentityToken
per il token ottenuto daGetOpenIdTokenForDeveloperIdentity
.
Per informazioni sull'authflow delle identità autenticate dagli sviluppatori e su come si differenziano dalle identità dei provider esterni, consulta. Flusso di autenticazione dei pool di identità
Definisci un nome del provider per sviluppatori e associalo con un pool di identità
Per usare le identità autenticate dagli sviluppatori, sarà necessario un pool di identità associato al provider degli sviluppatori. A tale scopo, procedi nel modo seguente:
Per aggiungere un provider degli sviluppatori personalizzato
-
Scegli Pool di identità dalla console di Amazon Cognito
. Seleziona un pool di identità. -
Seleziona la scheda Accesso utente.
-
Seleziona Aggiungi provider di identità.
-
Scegli Provider degli sviluppatori personalizzato.
-
Inserisci un Nome del provider di sviluppatori. Non è possibile modificare o eliminare il provider degli sviluppatori dopo averlo aggiunto.
-
Seleziona Salva modifiche.
Nota: una volta impostato, il nome del provider non può essere modificato.
Per ulteriori istruzioni su come utilizzare la console di Amazon Cognito, consulta Utilizzo della console Amazon Cognito.
Implementa un provider di identità
Android
Per utilizzare le identità autenticate dagli sviluppatori, implementa la tua classe di provider di identità che estende AWSAbstractCognitoIdentityProvider
. La tua classe di provider di identità dovrebbe restituire un oggetto di risposta contenente il token come attributo.
Di seguito è riportato un esempio di base di provider di identità.
public class DeveloperAuthenticationProvider extends AWSAbstractCognitoDeveloperIdentityProvider { private static final String developerProvider = "<Developer_provider_name>"; public DeveloperAuthenticationProvider(String accountId, String identityPoolId, Regions region) { super(accountId, identityPoolId, region); // Initialize any other objects needed here. } // Return the developer provider name which you choose while setting up the // identity pool in the &COG; Console @Override public String getProviderName() { return developerProvider; } // Use the refresh method to communicate with your backend to get an // identityId and token. @Override public String refresh() { // Override the existing token setToken(null); // Get the identityId and token by making a call to your backend // (Call to your backend) // Call the update method with updated identityId and token to make sure // these are ready to be used from Credentials Provider. update(identityId, token); return token; } // If the app has a valid identityId return it, otherwise get a valid // identityId from your backend. @Override public String getIdentityId() { // Load the identityId from the cache identityId = cachedIdentityId; if (identityId == null) { // Call to your backend } else { return identityId; } } }
Per utilizzare questo provider di identità, è necessario passarlo in CognitoCachingCredentialsProvider
. Ecco un esempio:
DeveloperAuthenticationProvider developerProvider = new DeveloperAuthenticationProvider( null, "IDENTITYPOOLID", context, Regions.USEAST1); CognitoCachingCredentialsProvider credentialsProvider = new CognitoCachingCredentialsProvider( context, developerProvider, Regions.USEAST1);
iOS - objective-C
Per utilizzare identità autenticate dagli sviluppatori, implementate la vostra classe di provider di identità che estende. AWSCognitoCredentialsProviderHelper
@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 identità autenticate dagli sviluppatori, implementate la vostra classe di provider di identità che si estende. AWSCognitoCredentialsProviderHelper
import AWSCore /* * Use the token method to communicate with your backend to get an * identityId and token. */ class DeveloperAuthenticatedIdentityProvider : AWSCognitoCredentialsProviderHelper { override func token() -> AWSTask<NSString> { //Write code to call your backend: //pass username/password to backend or some sort of token to authenticate user, if successful, //from backend call getOpenIdTokenForDeveloperIdentity with logins map containing "your.provider.name":"enduser.username" //return the identity id and token to client //You can use AWSTaskCompletionSource to do this asynchronously // Set the identity id and return the token self.identityId = resultFromAbove.identityId return AWSTask(result: resultFromAbove.token) }
Per utilizzare questo provider di identità, è necessario passarlo in AWSCognitoCredentialsProvider
, come illustrato nell'esempio seguente:
let devAuth = DeveloperAuthenticatedIdentityProvider(regionType: .YOUR_IDENTITY_POOL_REGION, identityPoolId: "YOUR_IDENTITY_POOL_ID", useEnhancedFlow: true, identityProviderManager:nil) let credentialsProvider = AWSCognitoCredentialsProvider(regionType: .YOUR_IDENTITY_POOL_REGION, identityProvider:devAuth) let configuration = AWSServiceConfiguration(region: .YOUR_IDENTITY_POOL_REGION, credentialsProvider:credentialsProvider) AWSServiceManager.default().defaultServiceConfiguration = configuration
Se intendi supportare sia le identità non autenticate sia le identità autenticate dagli sviluppatori, sostituisci il metodo logins
nell'implementazione di AWSCognitoCredentialsProviderHelper
.
override func logins () -> AWSTask<NSDictionary> { if(/*logic to determine if user is unauthenticated*/) { return AWSTask(result:nil) }else { return super.logins() } }
Se intendi supportare le identità autenticate dagli sviluppatori e i provider social, devi indicare chi è il provider attuale nell'implementazione logins
di AWSCognitoCredentialsProviderHelper
.
override func logins () -> AWSTask<NSDictionary> { if(/*logic to determine if user is unauthenticated*/) { return AWSTask(result:nil) }else if (/*logic to determine if user is Facebook*/){ if let token = AccessToken.current?.authenticationToken { return AWSTask(result: [AWSIdentityProviderFacebook:token]) } return AWSTask(error:NSError(domain: "Facebook Login", code: -1 , userInfo: ["Facebook" : "No current Facebook access token"])) }else { return super.logins() } }
JavaScript
Una volta ottenuti un ID identità e un token della sessione dal back-end, sarà necessario passarli nel provider AWS.CognitoIdentityCredentials
. Ecco un esempio:
AWS.config.credentials = new AWS.CognitoIdentityCredentials({ IdentityPoolId: 'IDENTITY_POOL_ID', IdentityId: 'IDENTITY_ID_RETURNED_FROM_YOUR_PROVIDER', Logins: { 'cognito-identity.amazonaws.com': 'TOKEN_RETURNED_FROM_YOUR_PROVIDER' } });
Unità
Per utilizzare le identità autenticate dagli sviluppatori, è necessario estendere CognitoAWSCredentials
e sostituire il metodo RefreshIdentity
per recuperare l'ID identità e il token dell'utente dal back-end, quindi restituirli. Di seguito è riportato un semplice esempio di provider di identità che si mette in contatto con un ipotetico back-end in "esempio.com":
using UnityEngine; using System.Collections; using Amazon.CognitoIdentity; using System.Collections.Generic; using ThirdParty.Json.LitJson; using System; using System.Threading; public class DeveloperAuthenticatedCredentials : CognitoAWSCredentials { const string PROVIDER_NAME = "example.com"; const string IDENTITY_POOL = "IDENTITY_POOL_ID"; static readonly RegionEndpoint REGION = RegionEndpoint.USEast1; private string login = null; public DeveloperAuthenticatedCredentials(string loginAlias) : base(IDENTITY_POOL, REGION) { login = loginAlias; } protected override IdentityState RefreshIdentity() { IdentityState state = null; ManualResetEvent waitLock = new ManualResetEvent(false); MainThreadDispatcher.ExecuteCoroutineOnMainThread(ContactProvider((s) => { state = s; waitLock.Set(); })); waitLock.WaitOne(); return state; } IEnumerator ContactProvider(Action<IdentityState> callback) { WWW www = new WWW("http://example.com/?username="+login); yield return www; string response = www.text; JsonData json = JsonMapper.ToObject(response); //The backend has to send us back an Identity and a OpenID token string identityId = json["IdentityId"].ToString(); string token = json["Token"].ToString(); IdentityState state = new IdentityState(identityId, PROVIDER_NAME, token, false); callback(state); } }
Il codice in alto utilizza un oggetto dispatcher di thread per chiamare una co-routine. Se non disponi di un modo per eseguire questa operazione nel tuo progetto, puoi utilizzare i seguenti script nelle scene:
using System; using UnityEngine; using System.Collections; using System.Collections.Generic; public class MainThreadDispatcher : MonoBehaviour { static Queue<IEnumerator> _coroutineQueue = new Queue<IEnumerator>(); static object _lock = new object(); public void Update() { while (_coroutineQueue.Count > 0) { StartCoroutine(_coroutineQueue.Dequeue()); } } public static void ExecuteCoroutineOnMainThread(IEnumerator coroutine) { lock (_lock) { _coroutineQueue.Enqueue(coroutine); } } }
Xamarin
Per utilizzare le identità autenticate dagli sviluppatori, è necessario estendere CognitoAWSCredentials
e sostituire il metodo RefreshIdentity
per recuperare l'ID identità e il token dell'utente dal back-end, quindi restituirli. Di seguito è riportato un esempio di base di provider di un identità che si mette in contatto con un ipotetico back-end in "esempio.com":
public class DeveloperAuthenticatedCredentials : CognitoAWSCredentials { const string PROVIDER_NAME = "example.com"; const string IDENTITY_POOL = "IDENTITY_POOL_ID"; static readonly RegionEndpoint REGION = RegionEndpoint.USEast1; private string login = null; public DeveloperAuthenticatedCredentials(string loginAlias) : base(IDENTITY_POOL, REGION) { login = loginAlias; } protected override async Task<IdentityState> RefreshIdentityAsync() { IdentityState state = null; //get your identity and set the state return state; } }
Aggiornamento della mappa degli accessi (solo Android e iOS)
Android
Una volta completata correttamente l'autenticazione dell'utente con il sistema di autenticazione, aggiorna la mappa degli accessi con il nome del provider degli sviluppatori e un identificatore utente per gli sviluppatori. Questa è una stringa alfanumerica che identifica in maniera univoca un utente nel sistema di autenticazione. Assicurati di chiamare il metodo refresh
dopo aver aggiornato la mappa degli accessi, poiché identityId
potrebbe essere cambiato:
HashMap<String, String> loginsMap = new HashMap<String, String>(); loginsMap.put(developerAuthenticationProvider.getProviderName(), developerUserIdentifier); credentialsProvider.setLogins(loginsMap); credentialsProvider.refresh();
iOS - Objective-C
iOS chiama il tuo logins
metodo per ottenere la mappa degli accessi più recente SDK solo se non ci sono credenziali o sono scadute. Se desideri forzarli a ottenere nuove credenziali (ad esempio, l'utente finale è passato da non autenticato a autenticato e desideri credenziali relative all'utente autenticato), chiama il tuo. SDK clearCredentials
credentialsProvider
[credentialsProvider clearCredentials];
iOS - Swift
iOS chiama il tuo logins
metodo per ottenere la mappa degli accessi più recente SDK solo se non ci sono credenziali o sono scadute. Se vuoi forzarli a ottenere nuove credenziali (ad esempio, il tuo utente finale è passato da non autenticato a autenticato e desideri credenziali contro l'utente autenticato), chiama il tuo. SDK clearCredentials
credentialsProvider
credentialsProvider.clearCredentials()
Ottenimento di un token (lato server)
Si ottiene un token chiamando. GetOpenIdTokenForDeveloperIdentity Questo API deve essere richiamato dal backend utilizzando le credenziali AWS dello sviluppatore. Non deve essere richiamato dal client. SDK APIriceve l'ID del pool di identità Cognito, una mappa di accesso contenente il nome del provider di identità come chiave e l'identificatore come valore e, facoltativamente, un ID di identità Cognito (ad esempio, stai autenticando un utente non autenticato). L'identificatore può essere il nome utente dell'utente, un indirizzo e-mail o un valore numerico. APIRisponde alla chiamata con un ID Cognito univoco per l'utente e un token OpenID Connect per l'utente finale.
Qualche consiglio da tenere a mente relativamente al token restituito da GetOpenIdTokenForDeveloperIdentity
:
-
Puoi specificare un periodo di scadenza personalizzato per il token in modo da memorizzarlo nella cache. Se non fornisci alcun periodo di scadenza personalizzato, il token è valido per 15 minuti.
-
È possibile impostare un periodo massimo di durata del token di 24 ore.
-
Sii consapevole delle implicazioni di sicurezza relative all'aumento della durata del token. Se un utente malintenzionato ottiene questo token, può scambiarlo con AWS credenziali per l'utente finale per la durata del token.
I seguenti frammenti di codice Java mostrano come inizializzare un client Amazon Cognito e recuperare un token per un'identità autenticata dagli sviluppatori.
// authenticate your end user as appropriate // .... // if authenticated, initialize a cognito client with your AWS developer credentials AmazonCognitoIdentity identityClient = new AmazonCognitoIdentityClient( new BasicAWSCredentials("access_key_id", "secret_access_key") ); // create a new request to retrieve the token for your end user GetOpenIdTokenForDeveloperIdentityRequest request = new GetOpenIdTokenForDeveloperIdentityRequest(); request.setIdentityPoolId("YOUR_COGNITO_IDENTITY_POOL_ID"); request.setIdentityId("YOUR_COGNITO_IDENTITY_ID"); //optional, set this if your client has an //identity ID that you want to link to this //developer account // set up your logins map with the username of your end user HashMap<String,String> logins = new HashMap<>(); logins.put("YOUR_IDENTITY_PROVIDER_NAME","YOUR_END_USER_IDENTIFIER"); request.setLogins(logins); // optionally set token duration (in seconds) request.setTokenDuration(60 * 15l); GetOpenIdTokenForDeveloperIdentityResult response = identityClient.getOpenIdTokenForDeveloperIdentity(request); // obtain identity id and token to return to your client String identityId = response.getIdentityId(); String token = response.getToken(); //code to return identity id and token to client //...
Seguendo i passaggi precedenti, sarai in grado di integrare le identità autenticate dagli sviluppatori nell'app. In caso di problemi o domande, non esitare a scrivere sui nostri forum
Connessione a un'identità social esistente
Quando utilizzi le identità autenticate dagli sviluppatori, tutti i collegamenti dei provider devono essere eseguiti dal back-end. Per collegare un'identità personalizzata all'identità social di un utente (Login with Amazon, Accedi con Apple, Facebook o Google), aggiungi il token del provider di identità alla mappa degli accessi quando GetOpenIdTokenForDeveloperIdentitychiami. Per rendere possibile ciò, quando richiami il backend del client SDK per autenticare l'utente finale, trasmetti anche il token del provider social dell'utente finale.
Ad esempio, se stai cercando di collegare un'identità personalizzata a Facebook, oltre all'identificatore del provider di identità, sarà necessario aggiungere alla mappa degli accessi anche il token di Facebook quando chiami GetOpenIdTokenForDeveloperIdentity
.
logins.put("YOUR_IDENTITY_PROVIDER_NAME","YOUR_END_USER_IDENTIFIER"); logins.put("graph.facebook.com","END_USERS_FACEBOOK_ACCESSTOKEN");
Supporto delle transizioni tra provider
Android
L'applicazione potrebbe richiedere il supporto di identità non autenticate o di identità autenticate tramite provider pubblici (Login with Amazon, Accedi con Apple, Facebook o Google) oltre alle identità autenticate dagli sviluppatori. La differenza essenziale tra le identità autenticate dagli sviluppatori e le altre identità (identità non autenticate e identità autenticate tramite provider pubblico) è il modo in cui viene ottenuto il token and. identityId 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. getIdentityIdAltrimenti, chiama il metodo e restituisci null.
public String refresh() { setToken(null); // If the logins map is not empty make a call to your backend // to get the token and identityId if (getProviderName() != null && !this.loginsMap.isEmpty() && this.loginsMap.containsKey(getProviderName())) { /** * This is where you would call your backend **/ // now set the returned identity id and token in the provider update(identityId, token); return token; } else { // Call getIdentityId method and return null this.getIdentityId(); return null; } }
Analogamente il metodo getIdentityId
dispone di due flussi, in base al contenuto della mappa degli accessi:
public String getIdentityId() { // Load the identityId from the cache identityId = cachedIdentityId; if (identityId == null) { // If the logins map is not empty make a call to your backend // to get the token and identityId if (getProviderName() != null && !this.loginsMap.isEmpty() && this.loginsMap.containsKey(getProviderName())) { /** * This is where you would call your backend **/ // now set the returned identity id and token in the provider update(identityId, token); return token; } else { // Otherwise call &COG; using getIdentityId of super class return super.getIdentityId(); } } else { return identityId; } }
iOS - Objective-C
L'applicazione potrebbe richiedere il supporto di identità non autenticate o di identità autenticate tramite provider pubblici (Login with Amazon, Accedi con Apple, Facebook o Google) oltre alle identità autenticate dagli sviluppatori. Per fare ciò, sostituisci il AWSCognitoCredentialsProviderHelperlogins
metodo per poter restituire la mappa di accesso corretta in base all'attuale provider di identità. Questo esempio illustra come muoversi tra un'identità non autenticata, un'identità autenticata da Facebook e dagli sviluppatori.
- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins { if(/*logic to determine if user is unauthenticated*/) { return [AWSTask taskWithResult:nil]; }else if (/*logic to determine if user is Facebook*/){ return [AWSTask taskWithResult: @{ AWSIdentityProviderFacebook : [FBSDKAccessToken currentAccessToken] }]; }else { return [super logins]; } }
Quando passi da non autenticato a autenticato, dovresti chiamare per forzarlo [credentialsProvider clearCredentials];
a ottenere nuove credenziali SDK 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];
. Ciò cancellerà sia le credenziali che l'identità e li costringerà a ottenerne di nuove. SDK
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ò, sostituisci il AWSCognitoCredentialsProviderHelperlogins
metodo per poter restituire la mappa di accesso corretta in base all'attuale provider di identità. Questo esempio illustra come muoversi tra un'identità non autenticata, un'identità autenticata da Facebook e dagli sviluppatori.
override func logins () -> AWSTask<NSDictionary> { if(/*logic to determine if user is unauthenticated*/) { return AWSTask(result:nil) }else if (/*logic to determine if user is Facebook*/){ if let token = AccessToken.current?.authenticationToken { return AWSTask(result: [AWSIdentityProviderFacebook:token]) } return AWSTask(error:NSError(domain: "Facebook Login", code: -1 , userInfo: ["Facebook" : "No current Facebook access token"])) }else { return super.logins() } }
Quando passi da non autenticato a autenticato, dovresti chiamare per forzarlo credentialsProvider.clearCredentials()
a ottenere nuove credenziali SDK 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()
. Ciò cancellerà sia le credenziali che l'identità e li costringerà a ottenerne di nuove. SDK
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 essenziale tra le identità autenticate dagli sviluppatori e le altre identità (identità non autenticate e identità autenticate tramite provider pubblico) è il modo in cui vengono ottenuti i token and. identityId Per altre identità, l'applicazione per dispositivi mobili interagisce direttamente con Amazon Cognito anziché contattare il sistema di autenticazione. L'applicazione per dispositivi mobili deve essere in grado di supportare due flussi distinti, a seconda della scelta dell'utente dell'app. Per questo motivo sarà necessario apportare alcune modifiche al provider di identità personalizzato.
Il modo consigliato per farlo in Unity è estendere il proprio provider di identità anziché chiamare il RefreshAsync metodo principale AmazonCognitoEnhancedIdentityProvide anziché il proprio nel AbstractCognitoIdentityProvider 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 essenziale tra le identità autenticate dagli sviluppatori e le altre identità (identità non autenticate e identità autenticate tramite provider pubblico) è il modo in cui vengono ottenuti il token and. identityId 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.