Autenticar usando credenciais Apple e Unity

Você pode usar o SDK do Firebase para permitir que os usuários façam a autenticação com o Firebase usando o ID Apple para realizar todo o fluxo de login do OAuth 2.0.

Antes de começar

Para fazer login de usuários usando a Apple, primeiro configure o recurso Iniciar sessão com a Apple no site do desenvolvedor da Apple e ative-a como um provedor de login para seu projeto do Firebase.

Participar do Programa para desenvolvedores da Apple

O recurso Iniciar sessão com a Apple só pode ser configurado por membros do Programa para desenvolvedores da Apple.

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

No Console do Firebase, abra a seção Auth. Na guia Método de login, ative o provedor Apple.
Defina as configurações do provedor de login da Apple:
1. Se você estiver implantando seu aplicativo apenas em plataformas Apple, deixe os campos "ID do serviço", "ID da equipe da Apple", "Chave privada" e "ID da chave" vazios.
2. Para suporte em dispositivos Android:
  1. Adicione o Firebase ao projeto do Android. Não esqueça de registrar a assinatura SHA-1 do seu aplicativo ao configurar o aplicativo no Console do Firebase.
  2. No Console do Firebase, abra a seção Auth. Na guia Método de login, ative 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 do OAuth, especifique o ID de equipe da Apple, a chave privada e o ID da chave que você criou na seção anterior.

Atender aos requisitos de dados anônimos da Apple

O recurso Iniciar sessão com a Apple permite que os usuários decidam se querem que seus dados fiquem anônimos, incluindo o endereço de e-mail, ao fazer login. Os usuários que escolhem essa opção têm endereços de e-mail com o domínio privaterelay.appleid.com. Ao usar o recurso Iniciar sessão com a Apple no seu aplicativo, você precisa estar em conformidade com todos os termos ou políticas do desenvolvedor aplicáveis da Apple relacionados a esses IDs anônimos da Apple.

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

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

Essa não é uma lista completa. Consulte o Contrato de licença do programa para desenvolvedores da Apple na seção de associação da sua conta de desenvolvedor para verificar se o aplicativo atende aos requisitos da Apple.

Acessar a classe `Firebase.Auth.FirebaseAuth`

A classe FirebaseAuth é o gateway para todas as chamadas de API. Ela pode ser acessada por meio do FirebaseAuth.DefaultInstance.

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

Processar o fluxo de login com o SDK do Firebase

O processo do recurso Iniciar sessão com a Apple varia entre plataformas Apple e Android.

Em plataformas Apple

Instale um plug-in de terceiros para processar a geração de tokens e o valor de uso único do login da Apple, como o Sign in with Apple Asset Storage Package da Unity. Talvez seja necessário mudar o código para extrair a string aleatória gerada com o valor de uso único no estado bruto da string para uso nas operações do Firebase (ou seja, armazenar uma cópia dela antes de a forma resumida SHA256 do valor de uso único ser criada).

Use a string de token resultante e o valor de uso único bruto para criar uma credencial do Firebase e fazer login na plataforma.

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

É possível usar o mesmo padrão com ReauthenticateAsync, que pode ser utilizado para recuperar credenciais novas de operações confidenciais que exigem um login recente. Para mais informações, consulte Gerenciar usuários.

Ao vincular usando o login da Apple em plataforma Apple, talvez você veja um erro informando que uma conta do Firebase já foi vinculada à conta da Apple. Quando isso acontecer, um Firebase.Auth.FirebaseAccountLinkException será gerado em vez do Firebase.FirebaseException padrão. Neste caso, AuthResult.AdditionalInfo inclui uma propriedade UserInfo.UpdatedCredential que, quando válida, pode ser usada para fazer login com o usuário vinculado à Apple por meio de FirebaseAuth.SignInAndRetrieveDataWithCredentialAsync. A credencial atualizada anula a necessidade de gerar um novo token de login da Apple com o valor de uso único da operação de login.

auth.CurrentUser.LinkWithCredentialAsync(
  Firebase.Auth.OAuthProvider.GetCredential("apple.com", idToken, rawNonce, null))
    .ContinueWithOnMainThread( task => {
      if (task.IsCompleted) {
        // 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 && task.Result.AdditionalUserInfo.UpdatedCredential.IsValid()) {
              // Attempt to sign in with the updated credential.
              auth.SignInAndRetrieveDataWithCredentialAsync(task.Result.AdditionalUserInfo.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 app usando o SDK do Firebase para realizar o fluxo de login completo.

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

Crie uma instância de um FederatedOAuthProviderData configurado com o ID do provedor apropriado para a 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ê quer solicitar ao provedor de autenticação.
```
providerData.Scopes = new List<string>();
providerData.Scopes.Add("email");
providerData.Scopes.Add("name");
```
Opcional: se você quiser exibir a tela de login da Apple em um idioma diferente do inglês, defina o parâmetro locale. Consulte os documentos sobre o recurso "Iniciar sessão com a Apple" para ver as localidades com suporte.
```
providerData.CustomParameters = new Dictionary<string,string>;

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

Depois de configurar os dados do provedor, 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 de provedor Auth. Ao contrário de outras operações do FirebaseAuth, isso assumirá o controle da IU exibindo uma visualização da Web na qual o usuário pode inserir as 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);
});

É possível usar o mesmo padrão com ReauthenticateWithProvider, que pode ser utilizado para recuperar credenciais novas de operações confidenciais que exigem um 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ê tenha consentimento explícito dos usuários antes de vincular as contas da Apple a outros dados.

Por exemplo, para vincular uma conta do Facebook à conta atual do Firebase, use o token de acesso de início de sessão 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);
    });

Diferentemente de outros provedores compatíveis com o Firebase Auth, a Apple não fornece um URL de foto.

Além disso, quando o usuário opta por não compartilhar e-mails com o app, a Apple fornece um endereço de e-mail exclusivo para esse usuário, no formato xyz@privaterelay.appleid.com, que compartilha com seu app. Se você tiver configurado o serviço de retransmissão de e-mail privado, os e-mails enviados ao endereço anônimo serão encaminhados pela Apple 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 apps 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 com a Apple. Ele pode ser obtido com auth.CurrentUser.DisplayName. No entanto, se você já usou a Apple para fazer login com um usuário no app sem usar o Firebase, a Apple não fornecerá o nome de exibição do usuário.

Próximas etapas

Depois que um usuário faz login pela primeira vez, uma nova conta é criada e vinculada às credenciais, que podem ser o número do telefone, o nome de usuário e a senha ou as informações do provedor de autenticação. Essa nova conta é armazenada como parte do projeto do Firebase e pode ser usada para identificar um usuário em todos os apps do projeto, seja qual for o método de login utilizado.

Nos seus apps, use o objeto Firebase.Auth.FirebaseUser para receber as informações básicas do perfil do usuário. Consulte Gerenciar usuários.

Nas Regras de segurança do Firebase Realtime Database e do Cloud Storage, é possível usar a variável auth para encontrar o ID exclusivo do usuário conectado. Utilize essa informação para controlar o acesso dele aos dados.