查看 2022 年 Google I/O 大会上介绍的 Firebase 新动态。了解详情

Identità federata e accesso social

L'autenticazione sociale è un flusso di autenticazione in più passaggi, che consente di accedere a un utente in un account o collegarlo a uno esistente.

Sia le piattaforme native che il Web supportano la creazione di credenziali che possono quindi essere passate ai metodi signInWithCredential o linkWithCredential . In alternativa sulle piattaforme web, puoi attivare il processo di autenticazione tramite un popup o reindirizzamento.

Google

La maggior parte della configurazione è già configurata quando si utilizza Google Sign-In con Firebase, tuttavia è necessario assicurarsi che la chiave SHA1 della macchina sia stata configurata per l'utilizzo con Android. Puoi vedere come generare la chiave nella documentazione di installazione .

Assicurati che il provider di accesso "Google" sia abilitato su Firebase Console .

Se il tuo utente effettua l'accesso con Google, dopo aver già registrato manualmente un account, il suo provider di autenticazione passerà automaticamente a Google, a causa del concetto Firebase Authentications di provider attendibili. Puoi saperne di più su questo qui .

iOS+ e Android

Sulle piattaforme native, è necessaria una libreria di terze parti per attivare il flusso di autenticazione.

Installa il plugin ufficiale di google_sign_in .

Una volta installato, attiva il flusso di accesso e crea una nuova credenziale:

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

ragnatela

Sul Web, Firebase SDK fornisce supporto per la gestione automatica del flusso di autenticazione utilizzando il tuo progetto Firebase. Per esempio:

Crea un provider di autenticazione Google, fornendo qualsiasi ambito di autorizzazione aggiuntivo che desideri ottenere dall'utente:

GoogleAuthProvider googleProvider = GoogleAuthProvider();

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

Fornisci le credenziali al metodo signInWithPopup . Ciò attiverà una nuova finestra che richiede all'utente di accedere al tuo progetto. In alternativa puoi utilizzare signInWithRedirect per mantenere il processo di autenticazione nella stessa finestra.

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

Prima di iniziare, configura la tua app per sviluppatori di Facebook e segui la procedura di configurazione per abilitare l'accesso a Facebook.

Assicurati che il provider di accesso "Facebook" sia abilitato sulla console Firebase . con l'ID app di Facebook e il set di segreti.

iOS+ e Android

Sulle piattaforme native, è necessaria una libreria di terze parti sia per installare l'SDK di Facebook che per attivare il flusso di autenticazione.

Installa il plugin flutter_facebook_auth .

Dovrai seguire i passaggi nella documentazione del plug-in per assicurarti che entrambi gli SDK di Facebook per Android e iOS siano stati inizializzati correttamente. Una volta completato, attiva il flusso di accesso, crea una credenziale Facebook e accedi all'utente:

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

ragnatela

Sul Web, Firebase SDK fornisce supporto per la gestione automatica del flusso di autenticazione utilizzando i dettagli dell'applicazione Facebook forniti sulla console Firebase. Per esempio:

Crea un provider Facebook, fornendo qualsiasi ambito di autorizzazione aggiuntivo che desideri ottenere dall'utente.

Assicurati che l'URI di reindirizzamento OAuth dalla console Firebase sia aggiunto come URI di reindirizzamento OAuth valido nella tua app Facebook.

FacebookAuthProvider facebookProvider = FacebookAuthProvider();

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

Fornisci le credenziali al metodo signInWithPopup . Ciò attiverà una nuova finestra che richiede all'utente di accedere alla tua applicazione 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);
}

Mela

iOS+ e Android

Prima di iniziare , configura Accedi con Apple e abilita Apple come provider di accesso .

Quindi, assicurati che le tue app Runner dispongano della funzionalità "Accedi con Apple".

Installa il plugin sign_in_with_apple , così come il pacchetto 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);
}

ragnatela

Prima di iniziare , configura Accedi con Apple e abilita Apple come provider di accesso .

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

Un'alternativa consiste nell'usare signInWithRedirect . In tal caso, il browser esce dall'app e devi utilizzare getRedirectResult per verificare i risultati dell'autenticazione durante l'avvio dell'app.

Twitter

Assicurati che il provider di accesso "Twitter" sia abilitato sulla console Firebase con una chiave API e un set di segreti API.

iOS+ e Android

Sulle piattaforme native, è necessaria una libreria di terze parti sia per installare l'SDK di Twitter che per attivare il flusso di autenticazione.

Installa il plugin twitter_login :

dependencies:
  twitter_login: ^4.0.1

Assicurati di seguire attentamente i passaggi di configurazione di twitter_login e di registrare un URL di richiamata sul Portale per sviluppatori Twitter con uno schema URL corrispondente

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

ragnatela

Sul Web, Twitter SDK fornisce supporto per la gestione automatica del flusso di autenticazione utilizzando i dettagli dell'applicazione Twitter forniti sulla console Firebase. Assicurati che l'URL di richiamata nella console Firebase sia aggiunto come URL di richiamata nella tua applicazione Twitter sulla loro console per sviluppatori.

Per esempio:

Crea un provider Twitter e fornisci le credenziali al metodo signInWithPopup . Ciò attiverà una nuova finestra che richiede all'utente di accedere alla tua applicazione 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);
}

GitHub

Assicurati di aver configurato un'app OAuth dalle impostazioni dello sviluppatore GitHub e che il provider di accesso "GitHub" sia abilitato sulla console Firebase con l'ID client e il segreto impostati, con l'URL di callback impostato nell'app GitHub.

iOS+ e Android

Per le piattaforme native, è necessario aggiungere google-services.json e GoogleService-Info.plist .

Per iOS, aggiungi lo schema URL personalizzato come descritto nel passaggio 1 della guida iOS .

import 'package:github_sign_in/github_sign_in.dart';

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

  return await _auth.signInWithAuthProvider(githubProvider);
}

ragnatela

Sul Web, GitHub SDK fornisce supporto per la gestione automatica del flusso di autenticazione utilizzando i dettagli dell'applicazione GitHub forniti sulla console Firebase. Assicurati che l'URL di richiamata nella console Firebase sia aggiunto come URL di richiamata nell'applicazione GitHub sulla console per sviluppatori.

Per esempio:

Crea un provider GitHub e fornisci le credenziali al metodo signInWithPopup . Ciò attiverà una nuova finestra che richiede all'utente di accedere alla tua applicazione 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);
}