Identidade federada e login social

A autenticação social é um fluxo de autenticação em várias etapas, permitindo que você registre um usuário em uma conta ou vincule-o a uma conta existente.

As plataformas nativas e a web suportam a criação de uma credencial que pode ser passada para os métodos signInWithCredential ou linkWithCredential . Alternativamente, em plataformas da web, você pode acionar o processo de autenticação por meio de um pop-up ou redirecionamento.

Google

A maioria das configurações já está configurada ao usar o Login do Google com Firebase, mas você precisa garantir que a chave SHA1 da sua máquina tenha sido configurada para uso com o Android. Você pode ver como gerar a chave na documentação de instalação .

Verifique se o provedor de login "Google" está ativado no Firebase Console .

Se seu usuário fizer login com o Google, depois de já ter registrado manualmente uma conta, o provedor de autenticação dele mudará automaticamente para o Google, devido ao conceito de provedores confiáveis ​​do Firebase Authentications. Você pode saber mais sobre isso aqui .

iOS+ e Android

Em plataformas nativas, é necessária uma biblioteca de terceiros para acionar o fluxo de autenticação.

Instale o plug-in oficial google_sign_in .

Uma vez instalado, acione o fluxo de login e crie uma nova credencial:

import 'package:google_sign_in/google_sign_in.dart';

Future<UserCredential> signInWithGoogle() async {
  // Trigger the authentication flow
  final GoogleSignInAccount? googleUser = await GoogleSignIn().signIn();

  // Obtain the auth details from the request
  final GoogleSignInAuthentication? googleAuth = await googleUser?.authentication;

  // Create a new credential
  final credential = GoogleAuthProvider.credential(
    accessToken: googleAuth?.accessToken,
    idToken: googleAuth?.idToken,
  );

  // Once signed in, return the UserCredential
  return await FirebaseAuth.instance.signInWithCredential(credential);
}

Rede

Na Web, o SDK do Firebase oferece suporte para lidar automaticamente com o fluxo de autenticação usando seu projeto do Firebase. Por exemplo:

Crie um provedor de autenticação do Google, fornecendo qualquer escopo de permissão adicional que você deseja obter do usuário:

GoogleAuthProvider googleProvider = GoogleAuthProvider();

googleProvider.addScope('https://www.googleapis.com/auth/contacts.readonly');
googleProvider.setCustomParameters({
  'login_hint': 'user@example.com'
});

Forneça a credencial para o método signInWithPopup . Isso acionará uma nova janela para aparecer solicitando que o usuário faça login no seu projeto. Alternativamente, você pode usar signInWithRedirect para manter o processo de autenticação na mesma janela.

Future<UserCredential> signInWithGoogle() async {
  // Create a new provider
  GoogleAuthProvider googleProvider = GoogleAuthProvider();

  googleProvider.addScope('https://www.googleapis.com/auth/contacts.readonly');
  googleProvider.setCustomParameters({
    'login_hint': 'user@example.com'
  });

  // Once signed in, return the UserCredential
  return await FirebaseAuth.instance.signInWithPopup(googleProvider);

  // Or use signInWithRedirect
  // return await FirebaseAuth.instance.signInWithRedirect(googleProvider);
}

Facebook

Antes de começar, configure seu aplicativo de desenvolvedor do Facebook e siga o processo de configuração para habilitar o login do Facebook.

Verifique se o provedor de login "Facebook" está ativado no Firebase Console . com o conjunto de ID e segredo do aplicativo do Facebook.

iOS+ e Android

Em plataformas nativas, é necessária uma biblioteca de terceiros para instalar o SDK do Facebook e acionar o fluxo de autenticação.

Instale o plugin flutter_facebook_auth .

Você precisará seguir as etapas na documentação do plug-in para garantir que os SDKs do Facebook para Android e iOS foram inicializados corretamente. Depois de concluído, acione o fluxo de login, crie uma credencial do Facebook e conecte o usuário:

import 'package:flutter_facebook_auth/flutter_facebook_auth.dart';

Future<UserCredential> signInWithFacebook() async {
  // Trigger the sign-in flow
  final LoginResult loginResult = await FacebookAuth.instance.login();

  // Create a credential from the access token
  final OAuthCredential facebookAuthCredential = FacebookAuthProvider.credential(loginResult.accessToken.token);

  // Once signed in, return the UserCredential
  return FirebaseAuth.instance.signInWithCredential(facebookAuthCredential);
}

Rede

Na Web, o SDK do Firebase oferece suporte para lidar automaticamente com o fluxo de autenticação usando os detalhes do aplicativo do Facebook fornecidos no console do Firebase. Por exemplo:

Crie um provedor do Facebook, fornecendo qualquer escopo de permissão adicional que você deseja obter do usuário.

Certifique-se de que o URI de redirecionamento OAuth do console do Firebase seja adicionado como um URI de redirecionamento OAuth válido em seu aplicativo do Facebook.

FacebookAuthProvider facebookProvider = FacebookAuthProvider();

facebookProvider.addScope('email');
facebookProvider.setCustomParameters({
  'display': 'popup',
});

Forneça a credencial para o método signInWithPopup . Isso acionará uma nova janela para aparecer solicitando que o usuário faça login no seu aplicativo do Facebook:

Future<UserCredential> signInWithFacebook() async {
  // Create a new provider
  FacebookAuthProvider facebookProvider = FacebookAuthProvider();

  facebookProvider.addScope('email');
  facebookProvider.setCustomParameters({
    'display': 'popup',
  });

  // Once signed in, return the UserCredential
  return await FirebaseAuth.instance.signInWithPopup(facebookProvider);

  // Or use signInWithRedirect
  // return await FirebaseAuth.instance.signInWithRedirect(facebookProvider);
}

Maçã

iOS+ e Android

Antes de começar , configure o Login com a Apple e habilite a Apple como provedor de login .

Em seguida, certifique-se de que seus aplicativos Runner tenham o recurso "Entrar com a Apple".

Instale o plugin sign_in_with_apple , bem como o pacote crypto :

dependencies:
  sign_in_with_apple: ^3.0.0
  crypto: ^3.0.1
import 'dart:convert';
import 'dart:math';

import 'package:crypto/crypto.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:sign_in_with_apple/sign_in_with_apple.dart';

/// Generates a cryptographically secure random nonce, to be included in a
/// credential request.
String generateNonce([int length = 32]) {
  const charset =
      '0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyz-._';
  final random = Random.secure();
  return List.generate(length, (_) => charset[random.nextInt(charset.length)])
      .join();
}

/// Returns the sha256 hash of [input] in hex notation.
String sha256ofString(String input) {
  final bytes = utf8.encode(input);
  final digest = sha256.convert(bytes);
  return digest.toString();
}

Future<UserCredential> signInWithApple() async {
  // To prevent replay attacks with the credential returned from Apple, we
  // include a nonce in the credential request. When signing in with
  // Firebase, the nonce in the id token returned by Apple, is expected to
  // match the sha256 hash of `rawNonce`.
  final rawNonce = generateNonce();
  final nonce = sha256ofString(rawNonce);

  // Request credential for the currently signed in Apple account.
  final appleCredential = await SignInWithApple.getAppleIDCredential(
    scopes: [
      AppleIDAuthorizationScopes.email,
      AppleIDAuthorizationScopes.fullName,
    ],
    nonce: nonce,
  );

  // Create an `OAuthCredential` from the credential returned by Apple.
  final oauthCredential = OAuthProvider("apple.com").credential(
    idToken: appleCredential.identityToken,
    rawNonce: rawNonce,
  );

  // Sign in the user with Firebase. If the nonce we generated earlier does
  // not match the nonce in `appleCredential.identityToken`, sign in will fail.
  return await FirebaseAuth.instance.signInWithCredential(oauthCredential);
}

Rede

Antes de começar , configure o Login com a Apple e habilite a Apple como provedor de login .

import 'package:firebase_auth/firebase_auth.dart';

Future<UserCredential> signInWithApple() async {
  // Create and configure an OAuthProvider for Sign In with Apple.
  final provider = OAuthProvider("apple.com")
    ..addScope('email')
    ..addScope('name');

  // Sign in the user with Firebase.
  return await FirebaseAuth.instance.signInWithPopup(provider);
}

Uma alternativa é usar signInWithRedirect . Nesse caso, o navegador navegará para fora do seu aplicativo e você precisará usar getRedirectResult para verificar os resultados da autenticação durante a inicialização do aplicativo.

Twitter

Verifique se o provedor de login "Twitter" está ativado no Firebase Console com um conjunto de chave de API e segredo de API.

iOS+ e Android

Em plataformas nativas, é necessária uma biblioteca de terceiros para instalar o SDK do Twitter e acionar o fluxo de autenticação.

Instale o plugin twitter_login :

dependencies:
  twitter_login: ^4.0.1

Certifique-se de seguir cuidadosamente as etapas de configuração do twitter_login e registrar um URL de retorno de chamada no Twitter Developer Portal com um esquema de URL correspondente

import 'package:twitter_login/twitter_login.dart';

Future<UserCredential> signInWithTwitter() async {
  // Create a TwitterLogin instance
  final twitterLogin = new TwitterLogin(
    apiKey: '<your consumer key>',
    apiSecretKey:' <your consumer secret>',
    redirectURI: '<your_scheme>://'
  );

  // Trigger the sign-in flow
  final authResult = await twitterLogin.login();

  // Create a credential from the access token
  final twitterAuthCredential = TwitterAuthProvider.credential(
    accessToken: authResult.authToken!,
    secret: authResult.authTokenSecret!,
  );

  // Once signed in, return the UserCredential
  return await FirebaseAuth.instance.signInWithCredential(twitterAuthCredential);
}

Rede

Na Web, o SDK do Twitter oferece suporte para lidar automaticamente com o fluxo de autenticação usando os detalhes do aplicativo do Twitter fornecidos no console do Firebase. Certifique-se de que o URL de retorno no console do Firebase seja adicionado como um URL de retorno em seu aplicativo do Twitter no console do desenvolvedor.

Por exemplo:

Crie um provedor do Twitter e forneça a credencial para o método signInWithPopup . Isso fará com que uma nova janela apareça solicitando que o usuário faça login no seu aplicativo do Twitter:

Future<UserCredential> signInWithTwitter() async {
  // Create a new provider
  TwitterAuthProvider twitterProvider = TwitterAuthProvider();

  // Once signed in, return the UserCredential
  return await FirebaseAuth.instance.signInWithPopup(twitterProvider);

  // Or use signInWithRedirect
  // return await FirebaseAuth.instance.signInWithRedirect(twitterProvider);
}

GitHubGenericName

Verifique se você configurou um aplicativo OAuth nas configurações do desenvolvedor do GitHub e se o provedor de login "GitHub" está ativado no Firebase Console com o ID do cliente e o segredo definidos, com o URL de retorno de chamada definido no aplicativo GitHub.

iOS+ e Android

Em plataformas nativas, é necessária uma biblioteca de terceiros para instalar o SDK do GitHub e acionar o fluxo de autenticação.

Instale o plugin github_sign_in :

dependencies:
  github_sign_in: ^0.0.5-dev.4

Você precisará preencher a instância do GitHubSignIn com seu ID de cliente do GitHub, Segredo do cliente do GitHub e também um URL de redirecionamento (url de retorno de chamada do Firebase). Depois de concluído, acione o fluxo de login, crie uma credencial do GitHub e conecte o usuário:

import 'package:github_sign_in/github_sign_in.dart';

Future<UserCredential> signInWithGitHub() async {
  // Create a GitHubSignIn instance
      final GitHubSignIn gitHubSignIn = GitHubSignIn(
          clientId: clientId,
          clientSecret: clientSecret,
          redirectUrl: 'https://my-project.firebaseapp.com/__/auth/handler');

  // Trigger the sign-in flow
  final result = await gitHubSignIn.signIn(context);

  // Create a credential from the access token
  final githubAuthCredential = GithubAuthProvider.credential(result.token);

  // Once signed in, return the UserCredential
  return await FirebaseAuth.instance.signInWithCredential(githubAuthCredential);
}

Rede

Na Web, o SDK do GitHub oferece suporte para lidar automaticamente com o fluxo de autenticação usando os detalhes do aplicativo GitHub fornecidos no console do Firebase. Certifique-se de que o URL de retorno de chamada no console do Firebase seja adicionado como um URL de retorno de chamada em seu aplicativo GitHub no console do desenvolvedor.

Por exemplo:

Crie um provedor GitHub e forneça a credencial para o método signInWithPopup . Isso acionará uma nova janela para aparecer solicitando que o usuário faça login no seu aplicativo GitHub:

Future<UserCredential> signInWithGitHub() async {
  // Create a new provider
  GithubAuthProvider githubProvider = GithubAuthProvider();

  // Once signed in, return the UserCredential
  return await FirebaseAuth.instance.signInWithPopup(githubProvider);

  // Or use signInWithRedirect
  // return await FirebaseAuth.instance.signInWithRedirect(githubProvider);
}