Esta página foi traduzida pela API Cloud Translation.

Autenticar usando Apple e Unity

Você pode permitir que seus usuários se autentiquem com o Firebase usando o ID Apple usando o SDK do Firebase para realizar o fluxo de login do OAuth 2.0 de ponta a ponta.

Antes de você começar

Para fazer login de usuários que usam a Apple, primeiro configure Sign In with Apple no site do desenvolvedor da Apple e, em seguida, ative a Apple como provedor de login para seu projeto do Firebase.

Participe do Programa de Desenvolvedores Apple

O Sign In with Apple só pode ser configurado por membros do Apple Developer Program .

O login da Apple deve estar ativado e configurado corretamente em seu projeto do Firebase. A configuração do Apple Developer varia entre as plataformas Android e Apple. Siga a seção "Configurar login com Apple" dos guias iOS+ e/ou Android antes de continuar.

No console do Firebase , abra a seção Auth . Na guia Método de login , habilite o provedor Apple .
Defina as configurações do provedor de login da Apple:
1. Se você estiver implantando seu aplicativo apenas em plataformas Apple, poderá deixar os campos ID do serviço, ID da equipe Apple, chave privada e ID da chave vazios.
2. Para suporte em dispositivos Android:
  1. Adicione o Firebase ao seu projeto Android . Certifique-se de registrar a assinatura SHA-1 do seu aplicativo ao configurá-lo no Console do Firebase.
  2. No console do Firebase , abra a seção Auth . Na guia Método de login , habilite o provedor Apple . Especifique o ID do serviço que você criou na seção anterior. Além disso, na seção de configuração do fluxo de código OAuth, especifique seu Apple Team ID e a chave privada e o ID de chave que você criou na seção anterior.

Cumpra os requisitos de dados anonimizados da Apple

Sign In with Apple oferece aos usuários a opção de anonimizar seus dados, incluindo seu endereço de e-mail, ao fazer login. Os usuários que escolhem esta opção possuem endereços de e-mail com o domínio privaterelay.appleid.com . Ao usar o Sign In with Apple em seu aplicativo, você deve cumprir quaisquer políticas ou termos de desenvolvedor aplicáveis da Apple em relação a esses IDs Apple anônimos.

Isso inclui obter qualquer consentimento necessário do usuário antes de associar qualquer informação pessoal de identificação direta a um ID Apple anônimo. Ao usar o Firebase Authentication, isso pode incluir as seguintes ações:

Vincule um endereço de e-mail a um ID Apple anônimo ou vice-versa.
Vincule um número de telefone a um ID Apple anônimo ou vice-versa
Vincule uma credencial social não anônima (Facebook, Google, etc.) a um ID Apple anônimo ou vice-versa.

A lista acima não é exaustiva. Consulte o Contrato de licença do Apple Developer Program na seção Assinatura da sua conta de desenvolvedor para garantir que seu aplicativo atenda aos requisitos da Apple.

Acesse a classe `Firebase.Auth.FirebaseAuth`

A classe FirebaseAuth é o gateway para todas as chamadas de API. É acessível por meio de FirebaseAuth.DefaultInstance .

Firebase.Auth.FirebaseAuth auth = Firebase.Auth.FirebaseAuth.DefaultInstance;

Lidar com o fluxo de login com o SDK do Firebase

O processo para fazer login na Apple varia entre as plataformas Apple e Android.

Nas plataformas Apple

Instale um plug-in de terceiros para lidar com o login da Apple e a geração de token, como o Sign In With Apple Asset Storage Package do Unity . Pode ser necessário alterar o código para analisar a string nonce aleatória gerada em seu estado de string bruta para uso em operações do Firebase (ou seja, armazenar uma cópia dela antes que o formulário de resumo SHA256 do nonce seja criado).

Use a string de token resultante e o nonce bruto para construir uma credencial do Firebase e fazer login no Firebase.

Firebase.Auth.Credential credential =
    Firebase.Auth.OAuthProvider.GetCredential("apple.com", appleIdToken, rawNonce, null);
auth.SignInAndRetrieveDataWithCredentialAsync(credential).ContinueWith(task => {
  if (task.IsCanceled) {
    Debug.LogError("SignInAndRetrieveDataWithCredentialAsync was canceled.");
    return;
  }
  if (task.IsFaulted) {
    Debug.LogError("SignInAndRetrieveDataWithCredentialAsync encountered an error: " + task.Exception);
    return;
  }

  Firebase.Auth.AuthResult result = task.Result;
  Debug.LogFormat("User signed in successfully: {0} ({1})",
      result.User.DisplayName, result.User.UserId);
});

O mesmo padrão pode ser usado com ReauthenticateAsync , que pode ser usado para recuperar credenciais novas para operações confidenciais que exigem login recente. Para obter mais informações, consulte Gerenciar usuários .

Ao vincular ao Apple Sign In em plataformas Apple, você pode encontrar um erro informando que uma conta existente do Firebase já foi vinculada à conta Apple. Quando isso ocorrer, uma Firebase.Auth.FirebaseAccountLinkException será lançada em vez da Firebase.FirebaseException padrão. Nesse caso, a exceção inclui uma propriedade UserInfo.UpdatedCredential que, se válida, pode ser usada para fazer login do usuário vinculado à Apple por meio de FirebaseAuth.SignInAndRetrieveDataWithCredentialAsync . A credencial atualizada evita a necessidade de gerar um novo token de login da Apple com nonce para a operação de login.

auth.CurrentUser.LinkWithCredentialAsync(
  Firebase.Auth.OAuthProvider.GetCredential("apple.com", idToken, rawNonce, null))
    .ContinueWithOnMainThread( task => {
      if (task.IsCompletedSuccessfully) {
        // Link Success
      } else {
        if (task.Exception != null) {
          foreach (Exception exception in task.Exception.Flatten().InnerExceptions) {
            Firebase.Auth.FirebaseAccountLinkException firebaseEx =
              exception as Firebase.Auth.FirebaseAccountLinkException;
            if (firebaseEx != null && firebaseEx.UserInfo.UpdatedCredential.IsValid()) {
              // Attempt to sign in with the updated credential.
              auth.SignInAndRetrieveDataWithCredentialAsync(firebaseEx.UserInfo.UpdatedCredential).
                ContinueWithOnMainThread( authResultTask => {
                  // Handle Auth result.
                });
            } else {
              Debug.Log("Link with Apple failed:" + firebaseEx );
            }
          } // end for loop
        }
      }
    });

No Android

No Android, autentique seus usuários com o Firebase integrando o login OAuth genérico baseado na Web ao seu aplicativo usando o SDK do Firebase para realizar o fluxo de login de ponta a ponta.

Para lidar com o fluxo de login com o SDK do Firebase, siga estas etapas:

Construa uma instância de FederatedOAuthProviderData configurada com o ID do provedor apropriado para Apple.

Firebase.Auth.FederatedOAuthProviderData providerData =
  new Firebase.Auth.FederatedOAuthProviderData();

providerData.ProviderId = "apple.com";

Opcional: Especifique escopos adicionais do OAuth 2.0 além do padrão que você deseja solicitar do provedor de autenticação.
```
providerData.Scopes = new List<string>();
providerData.Scopes.Add("email");
providerData.Scopes.Add("name");
```
Opcional: se desejar exibir a tela de login da Apple em um idioma diferente do inglês, defina o parâmetro locale . Consulte os documentos Sign In with Apple para obter as localidades suportadas.
```
providerData.CustomParameters = new Dictionary<string,string>;

// Localize to French.
providerData.CustomParameters.Add("language", "fr");
```

Depois que os dados do seu provedor forem configurados, use-os para criar um FederatedOAuthProvider.

// Construct a FederatedOAuthProvider for use in Auth methods.
Firebase.Auth.FederatedOAuthProvider provider =
  new Firebase.Auth.FederatedOAuthProvider();
provider.SetProviderData(providerData);

Autentique-se com o Firebase usando o objeto do provedor Auth. Observe que, diferentemente de outras operações do FirebaseAuth, isso assumirá o controle da sua IU, exibindo uma visualização da web na qual o usuário pode inserir suas credenciais.

Para iniciar o fluxo de login, chame signInWithProvider :

auth.SignInWithProviderAsync(provider).ContinueOnMainThread(task => {
    if (task.IsCanceled) {
        Debug.LogError("SignInWithProviderAsync was canceled.");
        return;
    }
    if (task.IsFaulted) {
        Debug.LogError("SignInWithProviderAsync encountered an error: " +
          task.Exception);
        return;
    }

    Firebase.Auth.AuthResult authResult = task.Result;
    Firebase.Auth.FirebaseUser user = authResult.User;
    Debug.LogFormat("User signed in successfully: {0} ({1})",
        user.DisplayName, user.UserId);
});

O mesmo padrão pode ser usado com ReauthenticateWithProvider , que pode ser usado para recuperar novas credenciais para operações confidenciais que exigem login recente.

user.ReauthenticateWithProviderAsync(provider).ContinueOnMainThread(task => {
    if (task.IsCanceled) {
        Debug.LogError("ReauthenticateWithProviderAsync was canceled.");
        return;
    }
    if (task.IsFaulted) {
        Debug.LogError(
        "ReauthenticateWithProviderAsync encountered an error: " +
            task.Exception);
        return;
    }

    Firebase.Auth.AuthResult authResult = task.Result;
    Firebase.Auth.FirebaseUser user = authResult.User;
    Debug.LogFormat("User reauthenticated successfully: {0} ({1})",
        user.DisplayName, user.UserId);
});

E você pode usar LinkWithCredentialAsync() para vincular diferentes provedores de identidade a contas existentes.

Observe que a Apple exige que você obtenha o consentimento explícito dos usuários antes de vincular suas contas Apple a outros dados.

Por exemplo, para vincular uma conta do Facebook à conta atual do Firebase, use o token de acesso obtido ao fazer login do usuário no Facebook:

// Initialize a Facebook credential with a Facebook access token.

Firebase.Auth.Credential credential =
    Firebase.Auth.FacebookAuthProvider.GetCredential(facebook_token);

// Assuming the current user is an Apple user linking a Facebook provider.
user.LinkWithCredentialAsync(credential)
    .ContinueWithOnMainThread( task => {
      if (task.IsCanceled) {
          Debug.LogError("LinkWithCredentialAsync was canceled.");
          return;
      }
      if (task.IsFaulted) {
        Debug.LogError("LinkWithCredentialAsync encountered an error: "
                       + task.Exception);
          return;
      }

      Firebase.Auth.AuthResult result = task.Result;
      Firebase.Auth.FirebaseUser user = result.User;
      Debug.LogFormat("User linked successfully: {0} ({1})",
          user.DisplayName, user.UserId);
    });

Ao contrário de outros provedores suportados pelo Firebase Auth, a Apple não fornece um URL de foto.

Além disso, quando o usuário opta por não compartilhar seu e-mail com o aplicativo, a Apple fornece um endereço de e-mail exclusivo para esse usuário (no formato [email protected] ), que ele compartilha com seu aplicativo. Se você configurou o serviço de retransmissão de e-mail privado, a Apple encaminha os e-mails enviados para o endereço anônimo para o endereço de e-mail real do usuário.

A Apple só compartilha informações do usuário, como o nome de exibição, com os aplicativos na primeira vez que um usuário faz login. Normalmente, o Firebase armazena o nome de exibição na primeira vez que um usuário faz login na Apple, que você pode obter com auth.CurrentUser.DisplayName . No entanto, se você usou anteriormente a Apple para fazer login de um usuário no aplicativo sem usar o Firebase, a Apple não fornecerá ao Firebase o nome de exibição do usuário.

Próximos passos

Depois que um usuário faz login pela primeira vez, uma nova conta de usuário é criada e vinculada às credenciais (ou seja, nome de usuário e senha, número de telefone ou informações do provedor de autenticação) com as quais o usuário fez login. Essa nova conta é armazenada como parte do seu projeto do Firebase e pode ser usada para identificar um usuário em todos os aplicativos do seu projeto, independentemente de como o usuário faz login.

Nos seus aplicativos, você pode obter informações básicas do perfil do usuário no objeto Firebase.Auth.FirebaseUser. Consulte Gerenciar usuários .

Nas regras de segurança do Firebase Realtime Database e do Cloud Storage, você pode obter o ID de usuário exclusivo do usuário conectado na variável auth e usá-lo para controlar quais dados um usuário pode acessar.