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

App Flip pour Android

L'association de retour d'application basée sur OAuth insère votre application Android dans Flux d'association du compte Google. Un flux d'association de compte classique nécessite de saisir ses identifiants dans le navigateur. L'utilisation de App Flip retarde l'utilisateur à votre application Android, ce qui vous permet d'exploiter des autorisations. Si l'utilisateur est connecté à votre application, il n'a pas besoin de saisir à nouveau ses identifiants pour associer son compte. Un minimum de code vous devez apporter des modifications pour implémenter le retournement d'application dans votre application Android.

Ce document explique comment modifier votre application Android pour qu'elle prenne en charge Retournement d'application.

Essayer l'exemple

Application exemple de l'association de retour d'application illustre l'intégration de l'association de comptes compatible avec App Flip sur Android. Toi peut utiliser cette application pour vérifier comment répondre à un intent App Flip entrant depuis Applications mobiles Google

L'application exemple est préconfigurée pour s'intégrer à l'outil de test de retournement d'application pour Android que vous pouvez utiliser pour vérifier l'intégration de votre application Android à celle-ci Retournez la page avant de configurer l'association de votre compte à Google. Cette application simule d'intent déclenché par les applis mobiles Google lorsque App Flip est activé.

Fonctionnement

Pour effectuer une intégration App Flip, procédez comme suit:

L'appli Google vérifie si votre appli est installée sur l'appareil à l'aide de son nom du package.
L'appli Google utilise une vérification de signature de package pour confirmer que le est la bonne application.
L'appli Google crée un intent pour démarrer une activité désignée dans votre application. Cet intent inclut les données supplémentaires requises pour l'association. Elle vérifie également pour voir si votre application est compatible avec App Flip en résolvant cet intent via la Framework Android.
Votre application vérifie que la requête provient de l'appli Google. Pour ce faire, votre application vérifie la signature du package et l'ID client fourni.
Votre application demande un code d'autorisation à votre serveur OAuth 2.0. Au à la fin de ce flux, elle renvoie un code d'autorisation ou une erreur l'appli Google.
L'appli Google récupère le résultat et procède à l'association des comptes. Si qu'un code d'autorisation est fourni, l'échange de jetons a lieu de serveur à serveur, comme avec la liaison OAuth basée sur le navigateur le flux de travail.

Modifier votre application Android pour qu'elle prenne en charge App Flip

Pour prendre en charge App Flip, apportez les modifications de code suivantes à votre application Android:

Ajoutez un <intent-filter> à votre fichier AndroidManifest.xml avec une action chaîne correspondant à la valeur que vous avez saisie dans le champ App Flip Intent (Intent de retournement d'application).

<activity android:name="AuthActivity">
  <!-- Handle the app flip intent -->
  <intent-filter>
    <action android:name="INTENT_ACTION_FROM_CONSOLE"/>
    <category android:name="android.intent.category.DEFAULT"/>
  </intent-filter>
</activity>

Validez la signature de l'application appelante.

private fun verifyFingerprint(
        expectedPackage: String,
        expectedFingerprint: String,
        algorithm: String
): Boolean {

    callingActivity?.packageName?.let {
        if (expectedPackage == it) {
            val packageInfo =
                packageManager.getPackageInfo(it, PackageManager.GET_SIGNATURES)
            val signatures = packageInfo.signatures
            val input = ByteArrayInputStream(signatures[0].toByteArray())

            val certificateFactory = CertificateFactory.getInstance("X509")
            val certificate =
                certificateFactory.generateCertificate(input) as X509Certificate
            val md = MessageDigest.getInstance(algorithm)
            val publicKey = md.digest(certificate.encoded)
            val fingerprint = publicKey.joinToString(":") { "%02X".format(it) }

            return (expectedFingerprint == fingerprint)
        }
    }
    return false
}

Extrayez l'ID client des paramètres d'intent et vérifiez que le client L'ID correspond à la valeur attendue.

private const val EXPECTED_CLIENT = "<client-id-from-actions-console>"
private const val EXPECTED_PACKAGE = "<google-app-package-name>"
private const val EXPECTED_FINGERPRINT = "<google-app-signature>"
private const val ALGORITHM = "SHA-256"
...

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val clientId = intent.getStringExtra("CLIENT_ID")

    if (clientId == EXPECTED_CLIENT &&
        verifyFingerprint(EXPECTED_PACKAGE, EXPECTED_FINGERPRINT, ALGORITHM)) {

        // ...authorize the user...
    }
}

Une fois l'autorisation obtenue, renvoyez le code d'autorisation obtenu à Google.

// Successful result
val data = Intent().apply {
    putExtra("AUTHORIZATION_CODE", authCode)
}
setResult(Activity.RESULT_OK, data)
finish()

Si une erreur s'est produite, renvoyez un résultat d'erreur à la place.

Remarque :Ne gérez pas l'erreur directement dans votre application, renvoyez plutôt la Résultat d'erreur via setResult. Cela garantit que la méthode de remplacement appropriée est affiché si le flux d'association de l'application échoue.
```
// Error result
val error = Intent().apply {
    putExtra("ERROR_TYPE", 1)
    putExtra("ERROR_CODE", 1)
    putExtra("ERROR_DESCRIPTION", "Invalid Request")
}
setResult(-2, error)
finish()
```

Contenu de l'intention de lancement

L'intent Android qui lance votre application comprend les champs suivants:

CLIENT_ID (String): Google client_id enregistré sous votre appli.
SCOPE (String[]): liste des niveaux d'accès demandés.
REDIRECT_URI (String): URL de redirection.

Contenu des données de réponse

Les données renvoyées à l'appli Google sont définies dans votre application en appelant setResult(). Ces données incluent les éléments suivants:

AUTHORIZATION_CODE (String): valeur du code d'autorisation.
resultCode (int): communique la réussite ou l'échec du processus et accepte l'une des valeurs suivantes: <ph type="x-smartling-placeholder">
- Activity.RESULT_OK: indique la réussite de l'opération. un code d'autorisation est renvoyé.
- Activity.RESULT_CANCELLED: indique que l'utilisateur a annulé l'événement processus. Dans ce cas, l'appli Google tentera d'associer le compte à l'aide de votre URL d'autorisation.
- -2: indique qu'une erreur s'est produite. Différents types d'erreurs sont décrits ci-dessous.
ERROR_TYPE (int) : type d'erreur, qui accepte l'un des types d'erreurs suivants : : <ph type="x-smartling-placeholder">
- 1: erreur récupérable: l'appli Google tentera d'associer le compte à l'aide de l'URL d'autorisation.
- 2: erreur irrécupérable: l'appli Google annule l'association du compte.
- 3: paramètres de requête non valides ou manquants.
ERROR_CODE (int): entier représentant la nature de l'erreur. Pour voir la signification de chaque code d'erreur, consultez tableau des codes d'erreur.
ERROR_DESCRIPTION (String, facultatif): message d'état lisible par l'humain. décrivant l'erreur.

Remarque :Consultez la norme OAuth 2.0 pour en savoir plus sur erreurs possibles et le contenu facultatif du champ error_description.

Vous devez saisir une valeur pour AUTHORIZATION_CODE lorsque resultCode == Activity.RESULT_OK Dans tous les autres cas, la valeur de AUTHORIZATION_CODE doit être vide. Si la valeur est resultCode == -2, le La valeur ERROR_TYPE doit être renseignée.

Tableau des codes d'erreur

Le tableau ci-dessous présente les différents codes d'erreur et indique s'ils correspondent à des erreurs récupérables ou irrécupérables:

Code d'erreur	Signification	Restauration possible	Irrécupérable
`1`	`INVALID_REQUEST`	✔
`2`	`NO_INTERNET_CONNECTION`		✔
`3`	`OFFLINE_MODE_ACTIVE`	✔
`4`	`CONNECTION_TIMEOUT`	✔
`5`	`INTERNAL_ERROR`	✔
`6`	`AUTHENTICATION_SERVICE_UNAVAILABLE`		✔
`8`	`CLIENT_VERIFICATION_FAILED`	✔
`9`	`INVALID_CLIENT`	✔
`10`	`INVALID_APP_ID`	✔
`11`	`INVALID_REQUEST`	✔
`12`	`AUTHENTICATION_SERVICE_UNKNOWN_ERROR`		✔
`13`	`AUTHENTICATION_DENIED_BY_USER`		✔
`14`	`CANCELLED_BY_USER`		✔
`15`	`FAILURE_OTHER`		✔
`16`	`USER_AUTHENTICATION_FAILED`	✔

Pour tous les codes d'erreur, vous devez renvoyer le résultat d'erreur via setResult pour vous assurer que la création de remplacement appropriée est déclenchée.