App Flip pour Android

La liaison App Flip basée sur OAuth (App Flip) insère votre application Android dans le flux de liaison de compte Google. Un flux de liaison de compte traditionnel nécessite que l'utilisateur entre ses informations d'identification dans le navigateur. L'utilisation d'App Flip diffère la connexion de l'utilisateur à votre application Android, ce qui vous permet de tirer parti des autorisations existantes. Si l'utilisateur est connecté à votre application, il n'a pas besoin de ressaisir ses informations d'identification pour lier son compte. Une quantité minimale de modifications de code est requise pour implémenter App Flip sur votre application Android.

Dans ce document, vous apprendrez à modifier votre application Android pour prendre en charge App Flip.

Essayez l'échantillon

Flip App reliant l' application échantillon montre un compte Flip compatible App reliant l' intégration sur Android. Vous pouvez utiliser cette application pour vérifier comment répondre à une intention App Flip entrante à partir des applications mobiles Google.

L'application échantillon est préconfiguré pour intégrer l' App Retournez outil de test pour Android , que vous pouvez utiliser pour vérifier votre intégration avec application Android App flip avant votre compte configurer la liaison avec Google. Cette application simule l'intention déclenchée par les applications mobiles Google lorsque App Flip est activé.

Comment ça fonctionne

Les étapes suivantes sont nécessaires pour effectuer une intégration App Flip :

1. Les contrôles de l' application Google si votre application est installée sur l'appareil en utilisant son nom de package.
2. L'application Google utilise une vérification de signature de package pour valider que l'application installée est la bonne application.
3. L'application Google crée une intention de démarrer une activité désignée dans votre application. Cette intention inclut des données supplémentaires requises pour l'association. Il vérifie également si votre application prend en charge App Flip en résolvant cette intention via le framework Android.
4. Votre application valide que la demande provient de l'application Google. Pour ce faire, votre application vérifie la signature du package et l'ID client fourni.
5. Votre application demande un code d'autorisation à votre serveur OAuth 2.0. A la fin de ce flux, il renvoie soit un code d'autorisation, soit une erreur à l'appli Google.
6. L'application Google récupère le résultat et poursuit la liaison de compte. Si un code d'autorisation est fourni, l'échange de jetons se produit de serveur à serveur, de la même manière qu'il le fait dans le flux de liaison OAuth basé sur un navigateur.

Modifiez votre application Android pour prendre en charge App Flip

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

1. Ajouter un <intent-filter> à votre AndroidManifest.xml fichier avec une chaîne d'action qui correspond à la valeur que vous avez entré dans le champ App Retourner intention.

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

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

3. Extrayez l'ID client des paramètres d'intention et vérifiez que l'ID client 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...
       }
   }
   

4. Une fois l'autorisation réussie, renvoyez le code d'autorisation obtenu à Google.

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

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

   // 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 application.
• SCOPE D' String[] SCOPE ( String[] ): Une liste des champs demandés.
• REDIRECT_URI ( String ): L'URL de redirection.

Contenu des données de réponse

Les données renvoyées à l'application Google est installé dans votre application en appelant setResult() . Ces données comprennent les éléments suivants :

• AUTHORIZATION_CODE ( String ): La valeur du code d'autorisation.
• resultCode ( int ): Communique le succès ou l' échec du processus et prend l' une des valeurs suivantes:
  • Activity.RESULT_OK : Indique le succès; un code d'autorisation est renvoyé.
  • Activity.RESULT_CANCELLED : Les signaux que l'utilisateur a annulé le processus. Dans ce cas, l'appli Google tentera d'associer votre compte à l'aide de votre URL d'autorisation.
  • -2 : indique qu'une erreur est survenue. Différents types d'erreurs sont décrits ci-dessous.
• ERROR_TYPE ( int ): Le type d'erreur, qui prend l' une des valeurs suivantes:
  • 1 : erreur Recouvrable: L'application Google compte tenter lien avec l'URL d'autorisation.
  • 2 : Erreur irrécupérable: Google App Abandonne compte de liaison.
  • 3 : paramètres de la requête manquante ou non valide.
• ERROR_CODE ( int ): un nombre entier représentant la nature de l'erreur. Pour voir ce que chaque moyen de code d'erreur, reportez - vous à la table des codes d'erreur .

• ERROR_DESCRIPTION ( String , facultatif): message d'état lisible par l' homme décrivant l'erreur.

Une valeur pour le AUTHORIZATION_CODE devrait quand resultCode == Activity.RESULT_OK . Dans tous les autres cas, la valeur AUTHORIZATION_CODE doit être vide. Si resultCode == -2 , alors la ERROR_TYPE valeur devrait être peuplée.

Tableau des codes d'erreur

Le tableau ci-dessous montre les différents codes d'erreur et si chacun est une erreur récupérable ou irrécupérable :

Pour tous les codes d'erreur, vous devez retourner le résultat d'erreur via setResult pour assurer la fallback appropriée est trigerred.