Autenticar usando o GitHub em plataformas Apple

Permita que os usuários se autentiquem com o Firebase usando provedores OAuth, como o GitHub. Basta integrar o login genérico do OAuth ao seu app usando o SDK do Firebase para realizar o fluxo de login completo.

Antes de começar

Para fazer login de usuários usando contas do GitHub, primeiro ative o GitHub como provedor de login do seu projeto do Firebase:

Use o Swift Package Manager para instalar e gerenciar as dependências do Firebase.

1. No Xcode, com seu projeto do app aberto, navegue até File > Add Packages.
2. Quando solicitado, adicione o repositório do SDK do Firebase para as plataformas Apple:

  https://github.com/firebase/firebase-ios-sdk.git

3. Escolha a biblioteca Firebase Authentication.
4. Adicione a sinalização -ObjC à seção Outras sinalizações do vinculador das configurações de compilação do destino.
5. Quando terminar, o Xcode começará a resolver e fazer o download das dependências em segundo plano automaticamente.

Agora execute algumas etapas de configuração:

1. No console do Firebase, abra a seção Autenticação.
2. Na guia Método de login, ative o provedor GitHub.
3. Adicione o ID do cliente e a chave secreta do cliente do console de desenvolvimento do provedor à configuração correspondente:
   1. Registre o app como um aplicativo de desenvolvedor no GitHub e consiga o ID e a chave secreta do cliente do OAuth 2.0 do app.
   2. Em seguida, verifique se o URI de redirecionamento do OAuth do Firebase (por exemplo, my-app-12345.firebaseapp.com/__/auth/handler) está definido como o URL de callback de autorização na página de configurações do app no GitHub.
4. Clique em Salvar.

Processar o fluxo de login com o SDK do Firebase

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

1. Adicione esquemas de URL personalizado ao seu projeto do Xcode:

   1. Abra a configuração do seu projeto clicando duas vezes no nome dele na visualização em árvore à esquerda. Selecione seu app na seção DESTINOS. Em seguida, selecione a guia Informações e expanda a seção Tipos de URL.
   2. Clique no botão + e adicione o ID do app codificado como um esquema de URL. Encontre o ID codificado do app na página Configurações gerais do Console do Firebase na seção do seu app iOS. Deixe os outros campos em branco.

      Quando concluída, a configuração será semelhante à mostrada a seguir, mas com os valores específicos do seu app:

      

2. Crie uma instância de um OAuthProvider usando o código de provedor github.com.

   Swift

       var provider = OAuthProvider(providerID: "github.com")
       

   Objective-C

       FIROAuthProvider *provider = [FIROAuthProvider providerWithProviderID:@"github.com"];
       

3. Opcional: especifique os parâmetros OAuth personalizados que você quer enviar com a solicitação OAuth.

   Swift

       provider.customParameters = [
         "allow_signup": "false"
       ]
       

   Objective-C

       [provider setCustomParameters:@{@"allow_signup": @"false"}];
       

   Para saber quais parâmetros são aceitos pelo GitHub, consulte a documentação do GitHub para OAuth (em inglês). Não é possível transmitir os parâmetros exigidos pelo Firebase com setCustomParameters. Esses parâmetros são client_id, redirect_uri, response_type, scope e state.

4. Opcional: especifique os outros escopos de OAuth 2.0 além do perfil básico que você quer solicitar ao provedor de autenticação. Se o aplicativo exigir acesso a dados particulares dos usuários nas APIs do GitHub você precisará solicitar autorização para acessar esses dados em Permissões de APIs no console do desenvolvedor do GitHub. Os escopos de OAuth solicitados precisam corresponder exatamente àqueles pré-configurados nas permissões de APIs do app.

   Swift

       // Request read access to a user's email addresses.
       // This must be preconfigured in the app's API permissions.
       provider.scopes = ["user:email"]
       

   Objective-C

       // Request read access to a user's email addresses.
       // This must be preconfigured in the app's API permissions.
       [provider setScopes:@[@"user:email"]];
       

   Para saber mais, consulte a documentação dos escopos do GitHub.

5. Opcional: se você quiser personalizar a forma como o app apresenta o SFSafariViewController ou o UIWebView ao exibir o reCAPTCHA para o usuário, crie uma classe personalizada que esteja em conformidade com o protocolo AuthUIDelegate e transmita-a para credentialWithUIDelegate.

6. Use o objeto de provedor do OAuth para a autenticação no Firebase.

   Swift

       provider.getCredentialWith(nil) { credential, error in
         if error != nil {
           // Handle error.
         }
         if credential != nil {
           Auth().signIn(with: credential) { authResult, error in
             if error != nil {
               // Handle error.
             }
             // User is signed in.
             // IdP data available in authResult.additionalUserInfo.profile.
   
             guard let oauthCredential = authResult.credential as? OAuthCredential else { return }
             // GitHub OAuth access token can also be retrieved by:
             // oauthCredential.accessToken
             // GitHub OAuth ID token can be retrieved by calling:
             // oauthCredential.idToken
           }
         }
       }
       

   Objective-C

       [provider getCredentialWithUIDelegate:nil
                                  completion:^(FIRAuthCredential *_Nullable credential,
                                               NSError *_Nullable error) {
         if (error) {
          // Handle error.
         }
         if (credential) {
           [[FIRAuth auth] signInWithCredential:credential
                                     completion:^(FIRAuthDataResult *_Nullable authResult,
                                               NSError *_Nullable error) {
             if (error) {
               // Handle error.
             }
             // User is signed in.
             // IdP data available in authResult.additionalUserInfo.profile.
   
             FIROAuthCredential *oauthCredential = (FIROAuthCredential *)authResult.credential;
             // GitHub OAuth access token can also be retrieved by:
             // oauthCredential.accessToken
             // GitHub OAuth ID token can be retrieved by calling:
             // oauthCredential.idToken
           }];
         }
       }];
       

   Com o token de acesso OAuth, é possível chamar a API GitHub.

   Por exemplo, para receber informações básicas de perfil, chame a API REST transmitindo o token de acesso no cabeçalho Authorization:

   https://api.github.com/user

7. Os exemplos acima se concentram nos fluxos de login, mas também é possível vincular um provedor do GitHub a um usuário atual. Por exemplo, vincule vários provedores ao mesmo usuário e permita o login com qualquer um deles.

   Swift

       Auth().currentUser.link(withCredential: credential) { authResult, error in
         if error != nil {
           // Handle error.
         }
         // GitHub credential is linked to the current user.
         // IdP data available in authResult.additionalUserInfo.profile.
         // GitHub OAuth access token can also be retrieved by:
         // (authResult.credential as? OAuthCredential)?.accessToken
         // GitHub OAuth ID token can be retrieved by calling:
         // (authResult.credential as? OAuthCredential)?.idToken
       }
       

   Objective-C

       [[FIRAuth auth].currentUser
           linkWithCredential:credential
                   completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
         if (error) {
           // Handle error.
         }
         // GitHub credential is linked to the current user.
         // IdP data available in authResult.additionalUserInfo.profile.
         // GitHub OAuth access token is can also be retrieved by:
         // ((FIROAuthCredential *)authResult.credential).accessToken
         // GitHub OAuth ID token can be retrieved by calling:
         // ((FIROAuthCredential *)authResult.credential).idToken
       }];
       

8. É possível usar o mesmo padrão com reauthenticateWithCredential, que pode ser utilizado para recuperar credenciais novas de operações confidenciais que exigem um login recente.

   Swift

       Auth().currentUser.reauthenticateWithCredential(withCredential: credential) { authResult, error in
         if error != nil {
           // Handle error.
         }
         // User is re-authenticated with fresh tokens minted and
         // should be able to perform sensitive operations like account
         // deletion and email or password update.
         // IdP data available in result.additionalUserInfo.profile.
         // Additional OAuth access token is can also be retrieved by:
         // (authResult.credential as? OAuthCredential)?.accessToken
         // GitHub OAuth ID token can be retrieved by calling:
         // (authResult.credential as? OAuthCredential)?.idToken
       }
       

   Objective-C

       [[FIRAuth auth].currentUser
           reauthenticateWithCredential:credential
                             completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
         if (error) {
           // Handle error.
         }
         // User is re-authenticated with fresh tokens minted and
         // should be able to perform sensitive operations like account
         // deletion and email or password update.
         // IdP data available in result.additionalUserInfo.profile.
         // Additional OAuth access token is can also be retrieved by:
         // ((FIROAuthCredential *)authResult.credential).accessToken
         // GitHub OAuth ID token can be retrieved by calling:
         // ((FIROAuthCredential *)authResult.credential).idToken
       }];
       

  // Sign-in with an OAuth credential.
  provider.getCredentialWith(nil) { credential, error in
    // An account with the same email already exists.
    if (error as NSError?)?.code == AuthErrorCode.accountExistsWithDifferentCredential.rawValue {
      // Get pending credential and email of existing account.
      let existingAcctEmail = (error! as NSError).userInfo[AuthErrorUserInfoEmailKey] as! String
      let pendingCred = (error! as NSError).userInfo[AuthErrorUserInfoUpdatedCredentialKey] as! AuthCredential
      // Lookup existing account identifier by the email.
      Auth.auth().fetchProviders(forEmail:existingAcctEmail) { providers, error in
        // Existing email/password account.
        if (providers?.contains(EmailAuthProviderID))! {
          // Existing password account for email. Ask user to provide the password of the
          // existing account.
          // Sign in with existing account.
          Auth.auth().signIn(withEmail:existingAcctEmail, password:password) { user, error in
            // Successfully signed in.
            if user != nil {
              // Link pending credential to account.
              Auth.auth().currentUser?.linkAndRetrieveData(with: pendingCred) { result, error in
                // ...
              }
            }
          }
        }
      }
      return
    }

    // Other errors.
    if error != nil {
      // handle the error.
      return
    }

    // Sign in with the credential.
    if credential != nil {
      Auth.auth().signInAndRetrieveData(with: credential!) { result, error in
        if error != nil {
          // handle the error.
          return
        }
      }
    }
  }

  

  // Sign-in with an OAuth credential.
  [provider getCredentialWithUIDelegate:nil
                             completion:^(FIRAuthCredential *_Nullable credential, NSError *_Nullable error) {
    // An account with the same email already exists.
    if (error.code == FIRAuthErrorCodeAccountExistsWithDifferentCredential) {
      // Get pending credential and email of existing account.
      NSString *existingAcctEmail = error.userInfo[FIRAuthErrorUserInfoEmailKey];
      FIRAuthCredential *pendingCred = error.userInfo[FIRAuthErrorUserInfoUpdatedCredentialKey];
      // Lookup existing account identifier by the email.
      [[FIRAuth auth] fetchProvidersForEmail:existingAcctEmail
                                 completion:^(NSArray<NSString *> *_Nullable providers,
                                              NSError *_Nullable error) {
        // Existing email/password account.
        if ( [providers containsObject:FIREmailAuthProviderID] ) {
          // Existing password account for email. Ask user to provide the password of the
          // existing account.

          // Sign in with existing account.
          [[FIRAuth auth] signInWithEmail:existingAcctEmail
                                 password:password
                               completion:^(FIRUser *user, NSError *error) {
            // Successfully signed in.
            if (user) {
              // Link pending credential to account.
              [[FIRAuth auth].currentUser linkWithCredential:pendingCred
                                                  completion:^(FIRUser *_Nullable user,
                                                               NSError *_Nullable error) {
                // ...
              }];
            }
          }];
        }
      }];
      return;
    }

    // Other errors.
    if (error) {
      // handle the error.
      return;
    }

    // Sign in with the credential.
    if (credential) {
      [[FIRAuth auth] signInAndRetrieveDataWithCredential:credential
          completion:^(FIRAuthDataResult *_Nullable authResult,
                       NSError *_Nullable error) {
        if (error) {
          // handle the error.
          return;
        }
      }];
    }
  }];
  

Próximas etapas

Depois que um usuário faz login pela primeira vez, uma nova conta de usuário é 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.

• É possível receber as informações básicas de perfil do usuário do objeto User nos seus apps. Consulte Gerenciar usuários.

• Nas Regras de segurança Firebase Realtime Database e Cloud Storage, você pode acessar o ID exclusivo do usuário conectado pela variável auth e usar essas informações para controlar quais dados um usuário pode acessar.

Os usuários podem fazer login no app usando vários provedores de autenticação. Basta vincular as credenciais desses provedores a uma conta de usuário.

Para desconectar um usuário, chame signOut:.

let firebaseAuth = Auth.auth()
do {
  try firebaseAuth.signOut()
} catch let signOutError as NSError {
  print("Error signing out: %@", signOutError)
}

NSError *signOutError;
BOOL status = [[FIRAuth auth] signOut:&signOutError];
if (!status) {
  NSLog(@"Error signing out: %@", signOutError);
  return;
}

Adicione também o código de tratamento de erros para todo o intervalo de erros de autenticação. Consulte Tratamento de erros.