Autenticar usando o GitHub em plataformas da Apple

Você pode permitir que seus usuários se autentiquem no Firebase usando provedores OAuth, como o GitHub, integrando o login OAuth genérico ao seu aplicativo usando o SDK do Firebase para realizar o fluxo de login de ponta a ponta.

Antes de você começar

Para fazer login de usuários usando contas do GitHub, primeiro você deve ativar o GitHub como um provedor de login para seu projeto do Firebase:

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

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

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

3. Escolha a biblioteca do Firebase Authentication.
4. Quando terminar, o Xcode começará automaticamente a resolver e baixar suas dependências em segundo plano.

Agora, execute algumas etapas de configuração:

1. No console do Firebase , abra a seção Auth .
2. Na guia Método de login , habilite o provedor GitHub .
3. Adicione o ID do cliente e o segredo do cliente do console do desenvolvedor desse provedor à configuração do provedor:
   1. Registre seu aplicativo como um aplicativo de desenvolvedor no GitHub e obtenha o ID do cliente OAuth 2.0 e o segredo do cliente do seu aplicativo.
   2. Verifique se o URI de redirecionamento do Firebase OAuth (por exemplo my-app-12345.firebaseapp.com/__/auth/handler ) está definido como seu URL de retorno de chamada de autorização na página de configurações do aplicativo no config do aplicativo GitHub .
4. Clique em Salvar .

Gerencie o fluxo de login com o SDK do Firebase

Para lidar com o fluxo de login com o SDK das plataformas Firebase Apple, siga estas etapas:

1. Adicione esquemas de URL personalizados ao seu projeto Xcode:

   1. Abra a configuração do seu projeto: clique duas vezes no nome do projeto na visualização em árvore à esquerda. Selecione seu aplicativo na seção TARGETS , selecione a guia Info e expanda a seção URL Types .
   2. Clique no botão + e adicione um esquema de URL para seu ID de cliente revertido. Para encontrar esse valor, abra o arquivo de configuração GoogleService-Info.plist e procure a chave REVERSED_CLIENT_ID . Copie o valor dessa chave e cole-o na caixa Esquemas de URL na página de configuração. Deixe os outros campos em branco.

      Quando concluído, sua configuração deve ser semelhante ao seguinte (mas com seus valores específicos do aplicativo):

      

2. Crie uma instância de um OAuthProvider usando o ID do provedor github.com .

   Rápido

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

   Objetivo-C

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

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

   Rápido

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

   Objetivo-C

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

   Para os parâmetros compatíveis com o GitHub, consulte a documentação do GitHub OAuth . Observe que você não pode passar parâmetros obrigatórios do Firebase com setCustomParameters . Esses parâmetros são client_id , redirect_uri , response_type , scope e state .

4. Opcional : especifique escopos adicionais do OAuth 2.0 além do perfil básico que você deseja solicitar ao provedor de autenticação. Se seu aplicativo exigir acesso a dados de usuários privados de APIs do GitHub, você precisará solicitar permissões para acessar as APIs do GitHub em Permissões de API no console do desenvolvedor do GitHub. Os escopos OAuth solicitados devem corresponder exatamente aos pré-configurados nas permissões da API do aplicativo.

   Rápido

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

   Objetivo-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 de escopos do GitHub .

5. Opcional : se você quiser personalizar a maneira como seu aplicativo apresenta o SFSafariViewController ou UIWebView ao exibir o reCAPTCHA para o usuário, crie uma classe personalizada que esteja em conformidade com o protocolo FIRAuthUIDelegate e passe-a para getCredentialWithUIDelegate:completion: .

6. Autentique-se com o Firebase usando o objeto do provedor OAuth.

   Rápido

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

   Objetivo-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
           }];
         }
       }];
       

   Usando o token de acesso OAuth, você pode chamar a API do GitHub .

   Por exemplo, para obter informações básicas de perfil, você pode chamar a API REST, passando o token de acesso no cabeçalho Authorization :

   https://api.github.com/user
   

7. Embora os exemplos acima se concentrem em fluxos de entrada, você também pode vincular um provedor do GitHub a um usuário existente. Por exemplo, você pode vincular vários provedores ao mesmo usuário, permitindo que eles entrem com qualquer um deles.

   Rápido

       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
       }
       

   Objetivo-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. O mesmo padrão pode ser usado com reauthenticateWithCredential , que pode ser usado para recuperar novas credenciais para operações confidenciais que exigem login recente.

   Rápido

       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
       }
       

   Objetivo-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óximos passos

Depois que um usuário entra pela primeira vez, uma nova conta de usuário é criada e vinculada às credenciais, ou seja, o nome de usuário e a senha, o número de telefone ou as 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 projeto, independentemente de como o usuário faça login.

• Em seus aplicativos, você pode obter as informações básicas do perfil do usuário do objeto FIRUser . 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 a partir da variável de auth e usá-lo para controlar quais dados um usuário pode acessar.

Você pode permitir que os usuários façam login no seu aplicativo usando vários provedores de autenticação vinculando as credenciais do provedor de autenticação a uma conta de usuário existente.

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

Você também pode adicionar código de tratamento de erros para toda a gama de erros de autenticação. Consulte Manipular Erros .