Cette page a été traduite par l'API Cloud Translation.

S'authentifier avec Apple sur Android

Vous pouvez autoriser vos utilisateurs à s'authentifier avec Firebase à l'aide de leur identifiant Apple en utilisant le SDK Firebase pour effectuer le flux de connexion OAuth 2.0 de bout en bout.

Avant de commencer

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

Rejoindre le programme Apple Developer

Seuls les membres de l'équipe Apple Developer peuvent configurer la fonctionnalité Se connecter avec Apple de sécurité.

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

Associez votre site Web à votre application comme indiqué dans la première section. sur Configurer la fonctionnalité Se connecter avec Apple pour le Web Lorsque vous y êtes invité, enregistrez le l'URL suivante en tant qu'URL de renvoi:
```
https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler
```
Vous pouvez obtenir l'ID de votre projet Firebase sur la page des paramètres de la console Firebase.

Lorsque vous avez terminé, notez votre nouvel ID de service, dont vous aurez besoin dans la section suivante.
Créez une clé privée pour "Se connecter avec Apple". Vous aurez besoin de votre nouvelle clé privée et de votre nouvelle clé dans la section suivante.
Si vous utilisez l'une des fonctionnalités de Firebase Authentication qui envoient des e-mails aux utilisateurs, y compris la connexion via un lien e-mail, la validation d'adresse e-mail, la révocation de la modification de compte, etc., configurez le service de relais de messagerie privé d'Apple et enregistrez noreply@YOUR_FIREBASE_PROJECT_ID.firebaseapp.com (ou votre domaine de modèle d'e-mail personnalisé) afin qu'Apple puisse transférer les e-mails envoyés par Firebase Authentication vers des adresses e-mail Apple anonymisées.

Ajoutez Firebase à votre projet Android. Être enregistrez la signature SHA-1 de votre application lorsque vous la configurez dans le Console Firebase.
Dans la console Firebase, ouvrez la section Authentification. Dans l'onglet Mode de connexion, activez le fournisseur Apple. Spécifiez l'ID de service que vous avez créé dans la section précédente. Dans la section section de configuration du flux de code OAuth, spécifiez votre ID d'équipe Apple et la clé privée et l'ID de clé créés à la section précédente.

Respecter les exigences d'Apple concernant les données anonymisées

Se connecter avec Apple permet aux utilisateurs d'anonymiser leurs données, y compris leur adresse e-mail, lorsqu'ils se connectent. Les utilisateurs qui choisissent cette option disposent d'adresses e-mail avec le domaine privaterelay.appleid.com. Lorsque vous utilisez Se connecter avec Apple dans votre application, vous devez respecter le règlement pour les développeurs ou les conditions d'utilisation d'Apple concernant ces identifiants Apple anonymes.

Cela inclut l'obtention du consentement requis de l'utilisateur avant que associer des données permettant de vous identifier directement à une adresse e-mail anonyme ID. Lorsque vous utilisez Firebase Authentication, cela peut inclure les éléments suivants : actions:

Associer une adresse e-mail à un identifiant Apple anonyme, ou inversement
Associer un numéro de téléphone à un identifiant Apple anonyme, ou inversement
Associer un identifiant de réseau social non anonyme (Facebook, Google, etc.) à un identifiant Apple anonyme, ou inversement

La liste ci-dessus n'est pas exhaustive. Reportez-vous au Contrat de licence du programme Apple Developer dans la section "Souscription" de votre compte de développeur pour vous assurer que votre application respecte les exigences d'Apple.

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 Android Firebase, procédez comme suit :

Créez une instance d'un OAuthProvider à l'aide de son compilateur avec l'ID de fournisseur apple.com :

Kotlin+KTX

val provider = OAuthProvider.newBuilder("apple.com")

Java

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

Facultatif:spécifiez des champs d'application OAuth 2.0 supplémentaires par défaut que vous souhaitez demander au fournisseur d'authentification.
Kotlin+KTX
```
provider.setScopes(arrayOf("email", "name"))
```
Java
```
List<String> scopes =
    new ArrayList<String>() {
      {
        add("email");
        add("name");
      }
    };
provider.setScopes(scopes);
```
Par défaut, lorsque l'option Un compte par adresse e-mail est activée, Firebase de requêtes par e-mail et par nom. Si vous définissez ce paramètre sur Plusieurs comptes par adresse e-mail, Firebase ne demande aucun champ d'application à Apple, sauf si vous les spécifiez.
Facultatif : Si vous souhaitez afficher l'écran de connexion d'Apple dans une autre langue que l'anglais, définissez le paramètre locale. Consultez le Se connecter avec Apple Docs pour les paramètres régionaux pris en charge.
Kotlin+KTX
```
// Localize the Apple authentication screen in French.
provider.addCustomParameter("locale", "fr")
```
Java
```
// Localize the Apple authentication screen in French.
provider.addCustomParameter("locale", "fr");
```

Authentifiez-vous auprès de Firebase à l'aide de l'objet du fournisseur OAuth. Notez que, contrairement aux autres opérations FirebaseAuth, cette opération prend le contrôle de votre UI en ouvrant un onglet Chrome personnalisé. Par conséquent, ne faites pas référence à votre activité dans Les OnSuccessListener et OnFailureListener que vous joignez, car ils sont immédiatement dissociées lorsque l'opération démarre l'UI.

Commencez par vérifier si vous avez déjà reçu une réponse. La connexion à l'aide de 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. Pour vous assurer de ne pas demander à l'utilisateur de réessayer si cela se produit, vous devez vérifier si un résultat est déjà présent.

Pour vérifier si un résultat est en attente, appelez getPendingAuthResult() :

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

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

S'il n'y a aucun résultat en attente, démarrez la procédure de connexion en appelant startActivityForSignInWithProvider():

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

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

Contrairement aux autres fournisseurs acceptés par Firebase Auth, Apple ne fournit pas d'URL de photo.

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

Apple ne partage des informations utilisateur, telles que le nom à afficher, qu'avec les applications la première fois qu'un utilisateur se connecte. En général, Firebase stocke le nom à afficher la première fois qu'un utilisateur se connecte avec Apple, getCurrentUser().getDisplayName() Toutefois, si vous avez déjà utilisé Apple pour connecter un utilisateur à l'application sans utiliser Firebase, Apple ne fournira pas à Firebase le nom à afficher de l'utilisateur.

Réauthentification et association de comptes

Le même schéma peut être utilisé avec startActivityForReauthenticateWithProvider(), que vous pouvez utiliser pour récupérer de nouvelles identifiants pour les opérations sensibles qui nécessitent une connexion récente :

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

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

Vous pouvez également utiliser linkWithCredential() pour associer 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 associer un compte Facebook au compte Firebase actuel, utilisez le jeton d'accès que vous avez obtenu en connectant l'utilisateur à 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.
        }
      });

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

Avancé : gérer manuellement le flux de connexion

Vous pouvez également vous authentifier avec Firebase à l'aide d'un compte Apple en gérant le flux de connexion à l'aide du SDK JavaScript Apple Sign-In, en créant manuellement le flux OAuth ou à l'aide d'une bibliothèque OAuth telle que AppAuth.

Pour chaque demande de connexion, générez une chaîne aléatoire : "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. Ce est importante pour empêcher les attaques par rejeu.

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

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

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

Obtenez ensuite le hachage SHA246 du nonce sous forme de chaîne hexadécimale:

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

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

Vous envoyez le hachage SHA256 du nonce avec votre requête de connexion, que Apple transmet dans la réponse sans la modifier. Firebase valide la réponse en hachant le nonce d'origine et en le comparant à la valeur transmise par Apple.

Lancez le flux de connexion d'Apple à l'aide de votre bibliothèque OAuth ou d'une autre méthode. Veillez à inclure le nonce haché en tant que paramètre dans votre requête.

Après avoir reçu la réponse d'Apple, récupérez le jeton d'ID dans la réponse, puis utilisez-le et le nonce non haché pour créer un AuthCredential:

Kotlin+KTX

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

Java

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

Authentifiez-vous avec Firebase à l'aide des identifiants Firebase :

Kotlin+KTX

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

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

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

Révocation de jetons

Apple exige que les applications permettant de créer un compte doivent permettre aux utilisateurs de lancer la suppression de leur compte dans l'application, comme décrit dans les Consignes d'examen de l'App Store.

En outre, les applications compatibles avec Se connecter avec Apple doivent utiliser l'API REST Se connecter avec Apple pour révoquer les jetons utilisateur.

Pour répondre à cette exigence, procédez comme suit :

Utilisez la méthode startActivityForSignInWithProvider() pour vous connecter avec Apple et obtenir AuthResult.

Obtenez le jeton d'accès pour le fournisseur Apple.

Kotlin+KTX

val oauthCredential: OAuthCredential =  authResult.credential
val accessToken = oauthCredential.accessToken

Java

OAuthCredential oauthCredential = (OAuthCredential) authResult.getCredential();
String accessToken = oauthCredential.getAccessToken();

Révoquez le jeton à l'aide de l'API revokeAccessToken.

Kotlin+KTX

mAuth.revokeAccessToken(accessToken)
  .addOnCompleteListener(this) { task ->
    if (task.isSuccessful) {
      // Access token successfully revoked
      // for the user ...
    }
}

Java

mAuth.revokeAccessToken(accessToken)
    .addOnCompleteListener(this, new OnCompleteListener<Void>() {
        @Override
        public void onComplete(@NonNull Task<Void> task) {
          if (task.isSuccessful()) {
            // Access token successfully revoked
            // for the user ...
          }
        }
  });

Enfin, supprimez le compte utilisateur (et toutes les données associées).
Étapes suivantes

Lorsqu'un utilisateur se connecte pour la première fois, un compte utilisateur est créé et associés aux identifiants, c'est-à-dire au nom d'utilisateur et au mot de passe, ou des informations sur le fournisseur d'authentification, c'est-à-dire l'utilisateur avec lequel il s'est connecté. Ce nouveau compte est stocké dans votre projet Firebase et peut être utilisé pour identifier un utilisateur dans toutes les applications de votre projet, quelle que soit la manière dont il se connecte.
- Dans vos applications, vous pouvez obtenir les informations de profil de base de l'utilisateur à partir de l'objet FirebaseUser. Voir <ph type="x-smartling-placeholder"></ph> Gérer les utilisateurs.
- Dans votre Firebase Realtime Database et votre Cloud Storage Règles de sécurité, vous pouvez obtenez 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 associant les identifiants du fournisseur d'authentification à un compte utilisateur existant.

Pour déconnecter un utilisateur, appelez . signOut:
Kotlin+KTX
```
Firebase.auth.signOut()MainActivity.kt
```
Java
```
FirebaseAuth.getInstance().signOut();MainActivity.java
```

S'authentifier avec Apple sur Android

Avant de commencer

Rejoindre le programme Apple Developer

Configurer la connexion avec Apple

Activer Apple en tant que fournisseur de connexion

Respecter les exigences d'Apple concernant les données anonymisées

Gérer le flux de connexion avec le SDK Firebase

Kotlin+KTX

Java

Kotlin+KTX

Java

Kotlin+KTX

Java

Kotlin+KTX

Java

Kotlin+KTX

Java

Réauthentification et association de comptes

Kotlin+KTX

Java

Kotlin+KTX

Java

Avancé : gérer manuellement le flux de connexion

Kotlin+KTX

Java

Kotlin+KTX

Java

Kotlin+KTX

Java

Kotlin+KTX

Java

Révocation de jetons

Kotlin+KTX

Java

Kotlin+KTX

Java

Étapes suivantes

Kotlin+KTX

Java