Google is committed to advancing racial equity for Black communities. See how.
Cette page a été traduite par l'API Cloud Translation.
Switch to English

S'authentifier avec Apple sur Android

Vous pouvez permettre à vos utilisateurs de s'authentifier auprès de Firebase à l'aide de leur identifiant Apple en utilisant le SDK Firebase pour exécuter le flux de connexion OAuth 2.0 de bout en bout.

Avant que tu commences

Pour connecter des utilisateurs à l'aide d'Apple, configurez d'abord la connexion avec Apple sur le site des développeurs d'Apple, puis activez Apple en tant que fournisseur de connexion pour votre projet Firebase.

Rejoignez le programme Apple Developer Program

La connexion avec Apple ne peut être configurée que par les membres du programme pour développeurs Apple .

Configurer la connexion avec Apple

Sur le site Apple Developer , procédez comme suit:

  1. Associez votre site Web à votre application comme décrit dans la première section de Configurer la connexion avec Apple pour le Web . Lorsque vous y êtes invité, enregistrez l'URL suivante en tant qu'URL de retour:

    https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler

    Vous pouvez obtenir votre ID de projet Firebase sur la page des paramètres de la console Firebase .

    Lorsque vous avez terminé, prenez note de votre nouvel identifiant de service, dont vous aurez besoin dans la section suivante.

  2. Créez une connexion avec la clé privée Apple . Vous aurez besoin de votre nouvelle clé privée et de votre ID de clé dans la section suivante.
  3. Si vous utilisez l'une des fonctionnalités de Firebase Authentication qui envoient des e-mails aux utilisateurs, y compris la connexion par lien de messagerie, la vérification de l'adresse e-mail, la révocation de changement de compte, etc., configurez le service de relais de messagerie privé Apple et inscrivez-vous à l' noreply@ YOUR_FIREBASE_PROJECT_ID .firebaseapp.com (ou votre domaine de modèle d'e-mail personnalisé) afin qu'Apple puisse relayer les e-mails envoyés par Firebase Authentication vers des adresses e-mail Apple anonymisées.

Activer Apple en tant que fournisseur de connexion

  1. Ajoutez Firebase à votre projet Android . Assurez-vous d'enregistrer la signature SHA-1 de votre application lorsque vous configurez votre application dans la console Firebase.
  2. Dans la console Firebase , ouvrez la section Auth . Dans l'onglet Méthode de connexion, activez le fournisseur Apple . Spécifiez l'ID de service que vous avez créé dans la section précédente. En outre, dans la section de configuration du flux de code OAuth , spécifiez votre identifiant d'équipe Apple ainsi que la clé privée et l'ID de clé que vous avez créés dans la section précédente.

Conformez-vous aux exigences d'Apple en matière de données anonymisées

Se connecter avec Apple donne aux utilisateurs la possibilité de rendre anonyme leurs données, y compris leur adresse e-mail, lors de la privaterelay.appleid.com . Les utilisateurs qui choisissent cette option ont des adresses e-mail avec le domaine privaterelay.appleid.com . Lorsque vous utilisez la connexion avec Apple dans votre application, vous devez vous conformer à toutes les politiques applicables aux développeurs ou aux conditions d'Apple concernant ces identifiants Apple anonymisés.

Cela comprend l'obtention du consentement de l'utilisateur requis avant d'associer toute information personnelle identifiant directement à un identifiant Apple anonymisé. Lorsque vous utilisez l'authentification Firebase, cela peut inclure les actions suivantes:

  • Associez une adresse e-mail à un identifiant Apple anonyme ou vice versa.
  • Lier un numéro de téléphone à un identifiant Apple anonyme ou vice versa
  • Liez un identifiant social non anonyme (Facebook, Google, etc.) à un identifiant Apple anonyme ou vice versa.

La liste ci-dessus n'est pas exhaustive. Reportez-vous au contrat de licence du programme Apple Developer Program dans la section Membership de votre compte développeur pour vous assurer que votre application répond aux exigences d'Apple.

Gérez le flux de connexion avec le SDK Firebase

Sur Android, le moyen le plus simple d'authentifier vos utilisateurs avec Firebase à l'aide de leurs comptes Apple consiste à gérer l'intégralité du flux de connexion avec le SDK Firebase Android.

Pour gérer le flux de connexion avec le SDK Firebase Android, procédez comme suit:

  1. Construisez une instance d'un OAuthProvider aide de son Builder avec l'ID de fournisseur apple.com :

    Java

    OAuthProvider.Builder provider = OAuthProvider.newBuilder("apple.com");
    

    Kotlin + KTX

    val provider = OAuthProvider.newBuilder("apple.com")
    
  2. Facultatif: spécifiez des étendues OAuth 2.0 supplémentaires au-delà de la valeur par défaut que vous souhaitez demander au fournisseur d'authentification.

    Java

    List<String> scopes =
        new ArrayList<String>() {
          {
            add("email");
            add("name");
          }
        };
    provider.setScopes(scopes);
    

    Kotlin + KTX

    provider.setScopes(arrayOf("email", "name"))
    

    Par défaut, lorsqu'un compte par adresse e-mail est activé, Firebase demande des portées d'e-mail et de nom. Si vous définissez ce paramètre sur Plusieurs comptes par adresse e-mail , Firebase ne demande aucune étendue à Apple, sauf si vous les spécifiez.

  3. Facultatif: si vous souhaitez afficher l'écran de connexion d'Apple dans une langue autre que l'anglais, définissez le locale paramètres locale . Consultez la documentation relative à la connexion avec Apple pour connaître les paramètres régionaux pris en charge.

    Java

    // Localize the Apple authentication screen in French.
    provider.addCustomParameter("locale", "fr");
    

    Kotlin + KTX

    // Localize the Apple authentication screen in French.
    provider.addCustomParameter("locale", "fr")
    
  4. Authentifiez-vous auprès de Firebase à l'aide de l'objet fournisseur OAuth. Notez que contrairement aux autres opérations FirebaseAuth , cela prendra le contrôle de votre interface utilisateur en ouvrant un onglet Chrome personnalisé. Par conséquent, ne référencez pas votre activité dans OnSuccessListener et OnFailureListener que vous attachez car ils se détacheront immédiatement lorsque l'opération démarre l'interface utilisateur.

    Vous devez d'abord vérifier si vous avez déjà reçu une réponse. La connexion avec cette méthode place votre activité en arrière-plan, ce qui signifie qu'elle peut être récupérée par le système pendant le flux de connexion. Afin de vous assurer de ne pas obliger l'utilisateur à réessayer si cela se produit, vous devez vérifier si un résultat est déjà présent.

    Pour vérifier s'il y a un résultat en attente, appelez getPendingAuthResult() :

    Java

    mAuth = FirebaseAuth.getInstance();
    Task<AuthResult> pending = mAuth.getPendingAuthResult();
    if (pending != null) {
        pending.addOnSuccessListener(new OnSuccessListener<AuthResult>() {
            @Override
            public void onSuccess(AuthResult authResult) {
                Log.d(TAG, "checkPending:onSuccess:" + authResult);
                // Get the user profile with authResult.getUser() and
                // authResult.getAdditionalUserInfo(), and the ID
                // token from Apple with authResult.getCredential().
            }
        }).addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                Log.w(TAG, "checkPending:onFailure", e);
            }
        });
    } else {
        Log.d(TAG, "pending: null");
    }
    

    Kotlin + KTX

    val pending = auth.pendingAuthResult
    if (pending != null) {
        pending.addOnSuccessListener { authResult ->
            Log.d(TAG, "checkPending:onSuccess:$authResult")
            // Get the user profile with authResult.getUser() and
            // authResult.getAdditionalUserInfo(), and the ID
            // token from Apple with authResult.getCredential().
        }.addOnFailureListener { e ->
            Log.w(TAG, "checkPending:onFailure", e)
        }
    } else {
        Log.d(TAG, "pending: null")
    }
    

    S'il n'y a pas de résultat en attente, démarrez le flux de connexion, en appelant startActivityForSignInWithProvider() :

    Java

    mAuth.startActivityForSignInWithProvider(this, provider.build())
            .addOnSuccessListener(
                    new OnSuccessListener<AuthResult>() {
                        @Override
                        public void onSuccess(AuthResult authResult) {
                            // Sign-in successful!
                            Log.d(TAG, "activitySignIn:onSuccess:" + authResult.getUser());
                            FirebaseUser user = authResult.getUser();
                            // ...
                        }
                    })
            .addOnFailureListener(
                    new OnFailureListener() {
                        @Override
                        public void onFailure(@NonNull Exception e) {
                            Log.w(TAG, "activitySignIn:onFailure", e);
                        }
                    });
    

    Kotlin + KTX

    auth.startActivityForSignInWithProvider(this, provider.build())
            .addOnSuccessListener { authResult ->
                // Sign-in successful!
                Log.d(TAG, "activitySignIn:onSuccess:${authResult.user}")
                val user = authResult.user
                // ...
            }
            .addOnFailureListener { e ->
                Log.w(TAG, "activitySignIn:onFailure", e)
            }
    

    Contrairement aux autres fournisseurs pris en charge par Firebase Auth, Apple ne fournit pas d'URL de photo.

    De plus, lorsque l'utilisateur choisit de ne pas partager son e-mail avec l'application, Apple xyz@privaterelay.appleid.com une adresse e-mail unique pour cet utilisateur (de la forme xyz@privaterelay.appleid.com ), qu'il partage avec votre application. Si vous avez configuré le service de relais de messagerie privé, Apple transfère les e-mails envoyés à l'adresse anonyme vers la véritable adresse e-mail de l'utilisateur.

    Apple partage uniquement les informations utilisateur telles que le nom d'affichage avec les applications la première fois qu'un utilisateur se getCurrentUser().getDisplayName() . Habituellement, Firebase stocke le nom d'affichage la première fois qu'un utilisateur se getCurrentUser().getDisplayName() avec Apple, ce que vous pouvez obtenir avec getCurrentUser().getDisplayName() . Cependant, si vous avez déjà utilisé Apple pour connecter un utilisateur à l'application sans utiliser Firebase, Apple ne fournira pas à Firebase le nom d'affichage de l'utilisateur.

Réauthentification et liaison de compte

Le même modèle peut être utilisé avec startActivityForReauthenticateWithProvider() que vous pouvez utiliser pour récupérer une nouvelle information d'identification pour les opérations sensibles qui nécessitent une connexion récente:

Java

// The user is already signed-in.
FirebaseUser firebaseUser = mAuth.getCurrentUser();

firebaseUser
    .startActivityForReauthenticateWithProvider(/* activity= */ this, provider.build())
    .addOnSuccessListener(
        new OnSuccessListener<AuthResult>() {
          @Override
          public void onSuccess(AuthResult authResult) {
            // User is re-authenticated with fresh tokens and
            // should be able to perform sensitive operations
            // like account deletion and email or password
            // update.
          }
        })
    .addOnFailureListener(
        new OnFailureListener() {
          @Override
          public void onFailure(@NonNull Exception e) {
            // Handle failure.
          }
        });

Kotlin + KTX

// The user is already signed-in.
val firebaseUser = auth.getCurrentUser()

firebaseUser
    .startActivityForReauthenticateWithProvider(/* activity= */ this, provider.build())
    .addOnSuccessListener( authResult -> {
        // User is re-authenticated with fresh tokens and
        // should be able to perform sensitive operations
        // like account deletion and email or password
        // update.
    })
    .addOnFailureListener( e -> {
        // Handle failure.
    })

Et, vous pouvez utiliser linkWithCredential() pour lier différents fournisseurs d'identité à des comptes existants.

Notez qu'Apple vous demande d'obtenir le consentement explicite des utilisateurs avant de lier leurs comptes Apple à d'autres données.

Par exemple, pour lier un compte Facebook au compte Firebase actuel, utilisez le jeton d'accès que vous avez obtenu en vous connectant à Facebook:

Java

// Initialize a Facebook credential with a Facebook access token.
AuthCredential credential = FacebookAuthProvider.getCredential(token.getToken());

// Assuming the current user is an Apple user linking a Facebook provider.
mAuth.getCurrentUser().linkWithCredential(credential)
    .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
      @Override
      public void onComplete(@NonNull Task<AuthResult> task) {
        if (task.isSuccessful()) {
          // Facebook credential is linked to the current Apple user.
          // The user can now sign in to the same account
          // with either Apple or Facebook.
        }
      }
    });

Kotlin + KTX

// Initialize a Facebook credential with a Facebook access token.
val credential = FacebookAuthProvider.getCredential(token.getToken())

// Assuming the current user is an Apple user linking a Facebook provider.
mAuth.getCurrentUser().linkWithCredential(credential)
    .addOnCompleteListener(this, task -> {
        if (task.isSuccessful()) {
          // Facebook credential is linked to the current Apple user.
          // The user can now sign in to the same account
          // with either Apple or Facebook.
        }
      });

Avancé: gérer le flux de connexion manuellement

Vous pouvez également vous authentifier auprès de Firebase à l'aide d'un compte Apple en gérant le flux de connexion à l'aide du SDK JS de connexion Apple, en créant manuellement le flux OAuth ou en utilisant une bibliothèque OAuth telle qu'AppAuth .

  1. Pour chaque demande de connexion, générez une chaîne aléatoire (un "nonce") que vous utiliserez pour vous assurer que le jeton d'ID que vous obtenez a été accordé spécifiquement en réponse à la demande d'authentification de votre application. Cette étape est importante pour empêcher les attaques de relecture.

    Vous pouvez générer un nonce cryptographiquement sécurisé sur Android avec SecureRandom , comme dans l'exemple suivant:

    Java

    private String generateNonce(int length) {
        SecureRandom generator = new SecureRandom();
    
        CharsetDecoder charsetDecoder = StandardCharsets.US_ASCII.newDecoder();
        charsetDecoder.onUnmappableCharacter(CodingErrorAction.IGNORE);
        charsetDecoder.onMalformedInput(CodingErrorAction.IGNORE);
    
        byte[] bytes = new byte[length];
        ByteBuffer inBuffer = ByteBuffer.wrap(bytes);
        CharBuffer outBuffer = CharBuffer.allocate(length);
        while (outBuffer.hasRemaining()) {
            generator.nextBytes(bytes);
            inBuffer.rewind();
            charsetDecoder.reset();
            charsetDecoder.decode(inBuffer, outBuffer, false);
        }
        outBuffer.flip();
        return outBuffer.toString();
    }
    

    Kotlin + KTX

    private fun generateNonce(length: Int): String {
        val generator = SecureRandom()
    
        val charsetDecoder = StandardCharsets.US_ASCII.newDecoder()
        charsetDecoder.onUnmappableCharacter(CodingErrorAction.IGNORE)
        charsetDecoder.onMalformedInput(CodingErrorAction.IGNORE)
    
        val bytes = ByteArray(length)
        val inBuffer = ByteBuffer.wrap(bytes)
        val outBuffer = CharBuffer.allocate(length)
        while (outBuffer.hasRemaining()) {
            generator.nextBytes(bytes)
            inBuffer.rewind()
            charsetDecoder.reset()
            charsetDecoder.decode(inBuffer, outBuffer, false)
        }
        outBuffer.flip()
        return outBuffer.toString()
    }
    

    Ensuite, récupérez le hachage SHA246 du nonce sous forme de chaîne hexadécimale:

    Java

    private String sha256(String s) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] digest = md.digest(s.getBytes());
        StringBuilder hash = new StringBuilder();
        for (byte c: digest) {
            hash.append(String.format("%02x", c));
        }
        return hash.toString();
    }
    

    Kotlin + KTX

    private fun sha256(s: String): String {
        val md = MessageDigest.getInstance("SHA-256")
        val digest = md.digest(s.toByteArray())
        val hash = StringBuilder()
        for (c in digest) {
            hash.append(String.format("%02x", c))
        }
        return hash.toString()
    }
    

    Vous enverrez le hachage SHA256 du nonce avec votre demande de connexion, qu'Apple transmettra inchangé dans la réponse. Firebase valide la réponse en hachant le nonce d'origine et en le comparant à la valeur transmise par Apple.

  2. Lancez le flux de connexion d'Apple à l'aide de votre bibliothèque OAuth ou d'une autre méthode. Assurez-vous d'inclure le nonce haché en tant que paramètre dans votre demande.

  3. Après avoir reçu la réponse d'Apple, récupérez le jeton d'identification de la réponse et utilisez-le ainsi que le nonce non haché pour créer un AuthCredential :

    Java

    AuthCredential credential =  OAuthProvider.newCredentialBuilder("apple.com")
        .setIdTokenWithRawNonce(appleIdToken, rawUnhashedNonce)
        .build();
    

    Kotlin + KTX

    val credential =  OAuthProvider.newCredentialBuilder("apple.com")
        .setIdTokenWithRawNonce(appleIdToken, rawUnhashedNonce)
        .build()
    
  4. Authentifiez-vous avec Firebase à l'aide des informations d'identification Firebase:

    Java

    mAuth.signInWithCredential(credential)
        .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
          @Override
          public void onComplete(@NonNull Task<AuthResult> task) {
            if (task.isSuccessful()) {
              // User successfully signed in with Apple ID token.
              // ...
            }
          }
        });
    

    Kotlin + KTX

    auth.signInWithCredential(credential)
          .addOnCompleteListener(this) { task ->
              if (task.isSuccessful) {
                // User successfully signed in with Apple ID token.
                // ...
              }
          }
    

Si l'appel à signInWithCredential réussit, vous pouvez utiliser la méthode getCurrentUser pour obtenir les données de compte de l'utilisateur.

Prochaines étapes

Lorsqu'un utilisateur se connecte pour la première fois, un nouveau compte utilisateur est créé et lié aux informations d'identification (c'est-à-dire le nom d'utilisateur et le mot de passe, le numéro de téléphone ou les informations du fournisseur d'authentification) avec lesquels l'utilisateur s'est connecté. Ce nouveau compte est stocké dans le cadre de votre projet Firebase et peut être utilisé pour identifier un utilisateur dans chaque application de votre projet, quelle que soit la manière dont l'utilisateur se connecte.

  • Dans vos applications, vous pouvez obtenir les informations de profil de base de l'utilisateur à partir de l'objet FirebaseUser . Voir Gérer les utilisateurs .

  • Dans vos règles de sécurité Firebase Realtime Database et Cloud Storage, vous pouvez obtenir l'ID utilisateur unique de l'utilisateur connecté à partir de la variable auth et l'utiliser pour contrôler les données auxquelles un utilisateur peut accéder.

Vous pouvez autoriser les utilisateurs à se connecter à votre application à l'aide de plusieurs fournisseurs d'authentification en liant les informations d'identification du fournisseur d'authentification à un compte d'utilisateur existant.

Pour déconnecter un utilisateur, appelez l' signOut

Java

FirebaseAuth.getInstance().signOut();

Kotlin + KTX

Firebase.auth.signOut()