Boîtes de dialogue de correction

Cette page explique comment gérer les problèmes liés aux évaluations de l'intégrité.

Lorsqu'un jeton d'intégrité est demandé, vous avez la possibilité d'afficher une boîte de dialogue Google Play. Vous pouvez afficher la boîte de dialogue en cas de problème lié à l'évaluation de l'intégrité ou si une exception s'est produite lors d'une requête de l'API Integrity. Une fois la boîte de dialogue fermée, vous pouvez vérifier que le problème est résolu en envoyant une autre requête de jeton d'intégrité. Si vous effectuez des requêtes standards, vous devez rafraîchir le fournisseur de jetons pour obtenir une nouvelle évaluation.

Remarque : Tous les types de boîtes de dialogue d'intégrité peuvent être présentés aux utilisateurs, quel que soit le contenu du jeton d'intégrité. Vous devez vérifier le contenu du jeton d'intégrité sur votre serveur pour déterminer la boîte de dialogue à afficher.

Demander une boîte de dialogue d'intégrité pour résoudre un problème d'évaluation

Lorsque le client demande un jeton d'intégrité, vous pouvez utiliser la méthode proposée dans StandardIntegrityToken (API standard) et IntegrityTokenResponse (API classique) : showDialog(Activity activity, int integrityDialogTypeCode).

Remarque : Pour utiliser les boîtes de dialogue d'intégrité, vous devez utiliser la version 1.3.0 ou ultérieure de la bibliothèque Android de l'API Integrity.

Pour afficher une boîte de dialogue de correction à l'aide de l'API Play Integrity et du code de boîte de dialogue GET_LICENSED, procédez comme suit : Les autres codes de boîte de dialogue que votre application peut demander sont listés après cette section.

1. Demandez un jeton d'intégrité à votre application et envoyez-le à votre serveur. Vous pouvez utiliser la requête standard ou classique.

   Kotlin

   // Request an integrity token
   val tokenResponse: StandardIntegrityToken = requestIntegrityToken()
   // Send token to app server and get response on what to do next
   val yourServerResponse: YourServerResponse = sendToServer(tokenResponse.token())
   

   Java

   // Request an integrity token
   StandardIntegrityToken tokenResponse = requestIntegrityToken();
   // Send token to app server and get response on what to do next
   YourServerResponse yourServerResponse = sendToServer(tokenResponse.token());
   

   Unity

   // Request an integrity token
   StandardIntegrityToken tokenResponse = RequestIntegrityToken();
   // Send token to app server and get response on what to do next
   YourServerResponse yourServerResponse = sendToServer(tokenResponse.Token);
   

   Unreal Engine

   // Request an integrity token
   StandardIntegrityToken* Response = RequestIntegrityToken();
   // Send token to app server and get response on what to do next
   YourServerResponse YourServerResponse = SendToServer(Response->Token);
   

   Natif

   /// Request an integrity token
   StandardIntegrityToken* response = requestIntegrityToken();
   /// Send token to app server and get response on what to do next
   YourServerResponse yourServerResponse = sendToServer(StandardIntegrityToken_getToken(response));
   

2. Sur votre serveur, déchiffrez le jeton d'intégrité et vérifiez le champ appLicensingVerdict. Voici ce que vous pourriez voir s'afficher :

   // Licensing issue
   {
       ...
       "accountDetails": {
           "appLicensingVerdict": "UNLICENSED"
       }
   }
   

3. Si le jeton contient appLicensingVerdict: "UNLICENSED", répondez au client de votre application en lui demandant d'afficher la boîte de dialogue d'attribution de licences :

   Kotlin

   private fun getDialogTypeCode(integrityToken: String): Int{
       // Get licensing verdict from decrypted and verified integritytoken
       val licensingVerdict: String = getLicensingVerdictFromDecryptedToken(integrityToken)
   
       return if (licensingVerdict == "UNLICENSED") {
               1 // GET_LICENSED
           } else 0
   }
   

   Java

   private int getDialogTypeCode(String integrityToken) {
       // Get licensing verdict from decrypted and verified integrityToken
       String licensingVerdict = getLicensingVerdictFromDecryptedToken(integrityToken);
   
       if (licensingVerdict.equals("UNLICENSED")) {
         return 1; // GET_LICENSED
       }
       return 0;
   }
   

   Unity

   private int GetDialogTypeCode(string IntegrityToken) {
       // Get licensing verdict from decrypted and verified integrityToken
       string licensingVerdict = GetLicensingVerdictFromDecryptedToken(IntegrityToken);
   
       if (licensingVerdict == "UNLICENSED") {
         return 1; // GET_LICENSED
       }
       return 0;
   }
   

   Unreal Engine

   private int GetDialogTypeCode(FString IntegrityToken) {
       // Get licensing verdict from decrypted and verified integrityToken
       FString LicensingVerdict = GetLicensingVerdictFromDecryptedToken(IntegrityToken);
   
       if (LicensingVerdict == "UNLICENSED") {
         return 1; // GET_LICENSED
       }
       return 0;
   }
   

   Natif

   private int getDialogTypeCode(string integrity_token) {
       /// Get licensing verdict from decrypted and verified integrityToken
       string licensing_verdict = getLicensingVerdictFromDecryptedToken(integrity_token);
   
       if (licensing_verdict == "UNLICENSED") {
         return 1; // GET_LICENSED
       }
       return 0;
   }
   

4. Dans votre application, appelez showDialog avec le code demandé récupéré à partir de votre serveur :

   Kotlin

   // Show dialog as indicated by the server
   val showDialogType: Int? = yourServerResponse.integrityDialogTypeCode()
   if (showDialogType == null) {
        return
   }
   
   // Create dialog request
   val dialogRequest = StandardIntegrityDialogRequest.builder()
             .setActivity(activity)
             .setTypeCode(showDialogType)
             .setStandardIntegrityResponse(StandardIntegrityResponse.TokenResponse(token))
             .build()
   
   // Call showDialog, the dialog will be shown on top of the provided activity
   // and the task will complete when the dialog is closed.
   val result: Task<Int> = standardIntegrityManager.showDialog(dialogRequest)
   
   // Handle response code, call the Integrity API again to confirm that the
   // verdict issue has been resolved.
   

   Java

   // Show dialog as indicated by the server
   @Nullable Integer showDialogType = yourServerResponse.integrityDialogTypeCode();
   if (showDialogType == null) {
        return;
   }
   
   // Create dialog request
   StandardIntegrityDialogRequest dialogRequest =
         StandardIntegrityDialogRequest.builder()
             .setActivity(getActivity())
             .setTypeCode(showDialogTypeCode)
             .setStandardIntegrityResponse(new StandardIntegrityResponse.TokenResponse(token))
             .build();
   
   // Call showDialog, the dialog will be shown on top of the provided activity
   // and the task will complete when the dialog is closed.
   Task<Integer> result = standardIntegrityManager.showDialog(dialogRequest);
   
   // Handle response code, call the Integrity API again to confirm that the
   // verdict issue has been resolved.
   

   Unity

   // Initialize the V2 manager. Requires Play Integrity Unity Plugin v2.0.0 or
   // higher.
   var standardIntegrityManager = new StandardIntegrityManagerV2();
   IEnumerator ShowDialogCoroutine() {
       int showDialogType = yourServerResponse.IntegrityDialogTypeCode();
   
       PlayAsyncOperation<IntegrityDialogResponseCode, StandardIntegrityError> showDialogTask;
   
       using (var activity = UnityPlayerHelper.GetCurrentActivity())
       {
           // Create a dialog request
           var dialogRequest = new StandardIntegrityDialogRequest(tokenResponse, activity, showDialogType);
   
           // Call showDialog with the request, the dialog will be shown on top of the
           // provided activity and complete when the dialog is closed.
           showDialogTask = standardIntegrityManager.ShowDialog(dialogRequest);
       }
   
       // Wait for PlayAsyncOperation to complete.
       yield return showDialogTask;
   
       // Handle response code, call the Integrity API again to confirm that the
       // verdict issue been resolved.
   }
   

   Unreal Engine

   // .h
   void MyClass::OnShowDialogCompleted(
       EStandardIntegrityErrorCode Error,
       EIntegrityDialogResponseCode Response)
   {
       // Handle response code, call the Integrity API again to confirm that the
       // verdict issue has been resolved.
   }
   
   // .cpp
   void MyClass::RequestIntegrityToken()
   {
       UStandardIntegrityToken* Response = ...
       int TypeCode = YourServerResponse.integrityDialogTypeCode();
   
       // Create a delegate to bind the callback function.
       FShowDialogStandardOperationCompletedDelegate Delegate;
   
       // Bind the completion handler (OnShowDialogCompleted) to the delegate.
       Delegate.BindDynamic(this, &MyClass::OnShowDialogCompleted);
   
       // Call ShowDialog with TypeCode which completes when the dialog is closed.
       Response->ShowDialog(TypeCode, Delegate);
   }
   

   Natif

   // Show dialog as indicated by the server
   int show_dialog_type = yourServerResponse.integrityDialogTypeCode();
   if(show_dialog_type == 0){
     return;
   }
   
   /// Create dialog request
   StandardIntegrityDialogRequest* dialog_request;
   StandardIntegrityDialogRequest_create(&dialog_request);
   StandardIntegrityDialogRequest_setTypeCode(dialog_request, show_dialog_type);
   StandardIntegrityDialogRequest_setActivity(dialog_request, activity);
   StandardIntegrityDialogRequest_setStandardIntegrityToken(dialog_request,
                                                   token_response);
   
   /// Call showDialog with the dialog request. The dialog will be shown on top
   /// of the provided activity and complete when the dialog is closed by the
   /// user.
   StandardIntegrityDialogResponse* dialog_response;
   StandardIntegrityErrorCode error_code =
       StandardIntegrityManager_showDialog(dialog_request, &dialog_response);
   
   /// Use polling to wait for the async operation to complete. Note, the polling
   /// shouldn't block the thread where the StandardIntegrityManager is running.
   IntegrityDialogResponseCode response_code = INTEGRITY_DIALOG_RESPONSE_UNKNOWN;
   while (error_code == STANDARD_INTEGRITY_NO_ERROR) {
       error_code = StandardIntegrityDialogResponse_getResponseCode(dialog_response, &response_code);
       if(response_code != INTEGRITY_DIALOG_RESPONSE_UNKNOWN){
         break;
       }
   }
   
   /// Free memory
   StandardIntegrityDialogRequest_destroy(dialog_request);
   StandardIntegrityDialogResponse_destroy(dialog_response);
   
   /// Handle response code, call the Integrity API again to confirm that the
   /// verdict issues have been resolved.
   

5. La boîte de dialogue s'affiche au-dessus de l'activité fournie. Lorsque l'utilisateur a fermé la boîte de dialogue, la tâche se termine avec un code de réponse.

6. (Facultatif) Demandez un autre jeton pour afficher d'autres boîtes de dialogue. Si vous effectuez des requêtes standards, vous devez rafraîchir le fournisseur de jetons pour obtenir une nouvelle évaluation.

Demander une boîte de dialogue d'intégrité pour corriger une exception côté client

Si une requête de l'API Integrity échoue avec une exception StandardIntegrityException (API standard) ou IntegrityServiceException (API classique) et que l'exception peut être corrigée, vous pouvez utiliser les boîtes de dialogue GET_INTEGRITY ou GET_STRONG_INTEGRITY pour corriger l'erreur.

Remarque : Pour utiliser les nouvelles boîtes de dialogue GET_INTEGRITY ou GET_STRONG_INTEGRITY, vous devez utiliser la version 1.5.0 ou ultérieure de la bibliothèque Android de l'API Integrity. Cette mise à jour permet d'accéder à la nouvelle méthode showDialog dans IntegrityManager (API classique) ou StandardIntegrityManager (API standard) pour résoudre les exceptions côté client.

Les étapes suivantes décrivent comment utiliser la boîte de dialogue GET_INTEGRITY pour corriger une erreur côté client signalée par l'API Integrity.

1. Vérifiez que l'exception renvoyée par une requête de l'API Integrity peut être corrigée.

   Kotlin

   private fun isExceptionRemediable(exception: ExecutionException): Boolean {
       val cause = exception.cause
       if (cause is StandardIntegrityException && cause.isRemediable) {
           return true
       }
       return false
   }
   

   Java

   private boolean isExceptionRemediable(ExecutionException exception) {
       Throwable cause = exception.getCause();
       if (cause instanceof StandardIntegrityException integrityException
   && integrityException.isRemediable()) {
           return true;
       }
       return false;
   }
   

   Unity

   private bool IsExceptionRemediable(StandardIntegrityError error) {
       // Check if the operation resulted in a remediable error
       if (error != null && error.ErrorCode != StandardIntegrityErrorCode.NoError && error.IsRemediable) {
           return true;
       }
       return false;
   }
   

   Natif

   bool IsErrorRemediable(StandardIntegrityToken* token) {
       /// Check if the error associated with the token is remediable
       bool isRemediable = false;
       if(StandardIntegrityToken_getIsRemediable(response, &isRemediable) == STANDARD_INTEGRITY_NO_ERROR){
         return isRemediable;
       }
       return false;
   }
   

2. Si l'exception peut être corrigée, demandez la boîte de dialogue GET_INTEGRITY à l'aide de l'exception renvoyée. La boîte de dialogue s'affiche au-dessus de l'activité fournie, et la tâche renvoyée se termine avec un code de réponse une fois que l'utilisateur a fermé la boîte de dialogue.

   Kotlin

     private fun showDialog(exception: StandardIntegrityException) {
         // Create a dialog request
         val standardIntegrityDialogRequest =
             StandardIntegrityDialogRequest.builder()
                 .setActivity(activity)
                 .setType(IntegrityDialogTypeCode.GET_INTEGRITY)
                 .setStandardIntegrityResponse(ExceptionDetails(exception))
                 .build()
   
         // Request dialog
         val responseCode: Task<Int> =
               standardIntegrityManager.showDialog(standardIntegrityDialogRequest)
   }
   

   Java

     private void showDialog(StandardIntegrityException exception) {
         // Create a dialog request
         StandardIntegrityDialogRequest standardIntegrityDialogRequest =
             StandardIntegrityDialogRequest.builder()
                 .setActivity(this.activity)
                 .setType(IntegrityDialogTypeCode.GET_INTEGRITY)
                 .setStandardIntegrityResponse(new ExceptionDetails(exception))
                 .build();
   
         // Request dialog
         Task<Integer> responseCode =
               standardIntegrityManager.showDialog(standardIntegrityDialogRequest);
   }
   

   Unity

   // Initialize the V2 manager. Requires Play Integrity Unity Plugin v2.0.0 or
   // higher.
   var standardIntegrityManager = new StandardIntegrityManagerV2();
   IEnumerator ShowDialogToFixError(StandardIntegrityError error) {
       PlayAsyncOperation<IntegrityDialogResponseCode, StandardIntegrityError> showDialogTask;
   
       using (var activity = UnityPlayerHelper.GetCurrentActivity())
       {
           // Create a dialog request using the error
           var dialogRequest = new StandardIntegrityDialogRequest(error, activity, GET_INTEGRITY_DIALOG);
   
           // Request dialog
           showDialogTask = standardIntegrityManager.ShowDialog(dialogRequest);
       }
   
       // Wait for PlayAsyncOperation to complete.
       yield return showDialogTask;
   }
   

   Natif

   private void showDialogToFixError(StandardIntegrityToken* token) {
       /// If the token request failed, and the underlying error is not fixable
       /// then return early
       if(isErrorRemediable(token)) {
         return;
       }
   
       /// Create dialog request
       StandardIntegrityDialogRequest* dialog_request;
       StandardIntegrityDialogRequest_create(&dialog_request);
       StandardIntegrityDialogRequest_setTypeCode(dialog_request,
                                          kGetIntegrityDialogTypeCode);
       StandardIntegrityDialogRequest_setActivity(dialog_request, activity);
       StandardIntegrityDialogRequest_setStandardIntegrityToken(dialog_request,
                                                       token_response);
   
       /// Call showDialog with the dialog request. The dialog will be shown on
       /// top of the provided activity and complete when the dialog is closed by
       /// the user.
       StandardIntegrityDialogResponse* dialog_response;
       StandardIntegrityErrorCode error_code =
           StandardIntegrityManager_showDialog(dialog_request, &dialog_response);
   
       /// Use polling to wait for the async operation to complete.
       /// Note, the polling shouldn't block the thread where the
       /// StandardIntegrityManager is running.
       IntegrityDialogResponseCode response_code = INTEGRITY_DIALOG_RESPONSE_UNKNOWN;
       while (error_code == STANDARD_INTEGRITY_NO_ERROR) {
           error_code = StandardIntegrityDialogResponse_getResponseCode(response, &response_code);
           if(response_code != INTEGRITY_DIALOG_RESPONSE_UNKNOWN){
             break;
           }
       }
   
       /// Free memory
       StandardIntegrityDialogRequest_destroy(dialog_request);
       StandardIntegrityDialogResponse_destroy(dialog_response);
   
   }
   

3. Si le code de réponse renvoyé indique une réussite, la prochaine requête de jeton d'intégrité devrait aboutir sans exception. Si vous effectuez des requêtes standards, vous devez rafraîchir le fournisseur de jetons pour obtenir une nouvelle évaluation.

Codes de boîte de dialogue d'intégrité

GET_LICENSED (code de type 1)

Problème d'évaluation

Cette boîte de dialogue est adaptée à deux problèmes :

• Accès non autorisé : appLicensingVerdict: "UNLICENSED". Cela signifie que le compte utilisateur ne dispose pas d'un droit d'accès à votre application, ce qui peut se produire si l'utilisateur l'a téléchargée indépendamment ou l'a acquise sur un autre magasin d'applications que Google Play.
• Application falsifiée : appRecognitionVerdict: "UNRECOGNIZED_VERSION". Cela signifie que le binaire de votre application a été modifié ou qu'il ne s'agit pas d'une version reconnue par Google Play.

Remarque : La boîte de dialogue GET_INTEGRITY résout les mêmes problèmes que GET_LICENSED, en plus de résoudre les problèmes d'intégrité de l'appareil et les codes d'erreur corrigibles.

Correction

Vous pouvez afficher la boîte de dialogue GET_LICENSED pour inviter l'utilisateur à télécharger l'application authentique depuis Google Play. Cette boîte de dialogue unique s'applique aux deux scénarios :

• Pour un utilisateur sans licence, elle lui accorde une licence Play. Cela permet à l'utilisateur de recevoir les mises à jour d'application depuis Google Play.
• Pour un utilisateur disposant d'une version frelatée de l'application, elle l'invite à installer la version non modifiée depuis Google Play.

Lorsque l'utilisateur ferme la boîte de dialogue, les vérifications de l'intégrité suivantes renvoient appLicensingVerdict: "LICENSED" et appRecognitionVerdict: "PLAY_RECOGNIZED".

Exemple d'expérience utilisateur

Figure 1 : Boîte de dialogue Google Play GET_LICENSED.

CLOSE_UNKNOWN_ACCESS_RISK (code de type 2)

Problème d'évaluation

Lorsque environmentDetails.appAccessRiskVerdict.appsDetected contient "UNKNOWN_CAPTURING" ou "UNKNOWN_CONTROLLING", cela signifie que d'autres applications (non installées par Google Play ou préchargées sur la partition du système par le fabricant de l'appareil) s'exécutent sur l'appareil et peuvent capturer l'écran ou contrôler l'appareil.

Correction

Vous pouvez afficher la boîte de dialogue CLOSE_UNKNOWN_ACCESS_RISK pour inviter l'utilisateur à fermer toutes les applications inconnues susceptibles de capturer l'écran ou de contrôler l'appareil. Si l'utilisateur appuie sur le bouton Close all, toutes ces applications sont fermées.

Exemple d'expérience utilisateur

Figure 2 : Boîte de dialogue pour fermer le risque d'accès inconnu.

CLOSE_ALL_ACCESS_RISK (code de type 3)

Problème d'évaluation

Lorsque environmentDetails.appAccessRiskVerdict.appsDetected contient "KNOWN_CAPTURING", "KNOWN_CONTROLLING","UNKNOWN_CAPTURING" ou "UNKNOWN_CONTROLLING", cela signifie que des applications s'exécutent sur l'appareil et peuvent capturer l'écran ou contrôler l'appareil.

Correction

Vous pouvez afficher la boîte de dialogue CLOSE_ALL_ACCESS_RISK pour inviter l'utilisateur à fermer toutes les applications susceptibles de capturer l'écran ou de contrôler l'appareil. Si l'utilisateur appuie sur le bouton Close all, toutes ces applications sont fermées sur l'appareil.

Exemple d'expérience utilisateur

Figure 3 : Boîte de dialogue pour fermer tous les risques d'accès.

GET_INTEGRITY (code de type 4)

Problème d'évaluation

Cette boîte de dialogue est appropriée pour l'un des problèmes suivants :

• Intégrité de l'appareil faible : lorsque deviceRecognitionVerdict ne contient pas MEETS_DEVICE_INTEGRITY, il est possible que l'appareil ne soit pas un appareil Android authentique et certifié. Cela peut se produire, par exemple, si le bootloader de l'appareil est déverrouillé ou si l'OS Android chargé n'est pas une image de fabricant certifiée.

• Accès non autorisé : appLicensingVerdict: "UNLICENSED". Cela signifie que le compte utilisateur ne dispose pas d'un droit d'accès à votre application, ce qui peut se produire si l'utilisateur l'a téléchargée indépendamment ou l'a acquise sur un autre magasin d'applications que Google Play.

• Application falsifiée : appRecognitionVerdict: "UNRECOGNIZED_VERSION". Cela signifie que le binaire de votre application a été modifié ou qu'il ne s'agit pas d'une version reconnue par Google Play.

• Exceptions côté client : lorsqu'une exception remédiable se produit lors d'une requête de l'API Integrity. Les exceptions pouvant être corrigées sont des exceptions de l'API Integrity avec des codes d'erreur tels que PLAY_SERVICES_VERSION_OUTDATED, NETWORK_ERROR, PLAY_SERVICES_NOT_FOUND, etc. Vous pouvez utiliser la méthode exception.isRemediable() pour vérifier si une exception peut être corrigée par la boîte de dialogue.

Correction

La boîte de dialogue GET_INTEGRITY est conçue pour simplifier l'expérience utilisateur en gérant plusieurs étapes de correction dans un seul flux continu. Cela évite à l'utilisateur d'avoir à interagir avec plusieurs boîtes de dialogue distinctes pour résoudre différents problèmes.

Lorsque vous demandez la boîte de dialogue, elle détecte automatiquement les problèmes de verdict ciblés présents et fournit les étapes de correction appropriées. Cela signifie qu'une seule requête de boîte de dialogue peut résoudre plusieurs problèmes à la fois, y compris :

• Intégrité de l'appareil : si un problème d'intégrité de l'appareil est détecté, la boîte de dialogue guide l'utilisateur pour améliorer l'état de sécurité de l'appareil afin de répondre aux exigences d'un verdict MEETS_DEVICE_INTEGRITY.
• Intégrité de l'application : si des problèmes tels qu'un accès non autorisé ou une altération de l'application sont détectés, la boîte de dialogue redirige les utilisateurs vers le Play Store pour qu'ils téléchargent l'application afin de les résoudre.

Remarque : La boîte de dialogue GET_INTEGRITY détecte et tente de résoudre automatiquement plusieurs problèmes de verdict sur demande. Pour résoudre uniquement les problèmes liés aux licences de compte ou à l'intégrité des applications, nous vous recommandons d'utiliser la boîte de dialogue GET_LICENSED.

• Exceptions côté client : la boîte de dialogue recherche et tente de résoudre les problèmes sous-jacents qui ont provoqué une exception de l'API Integrity. Par exemple, elle peut inviter l'utilisateur à mettre à jour une version obsolète des services Google Play.

Exemple d'expérience utilisateur

Figure 4 : Flux de correction des erreurs réseau de la boîte de dialogue GET_INTEGRITY

GET_STRONG_INTEGRITY (code de type 5)

Problème d'évaluation

Cette boîte de dialogue est conçue pour résoudre tous les problèmes traités par GET_INTEGRITY, avec la possibilité supplémentaire de résoudre les problèmes qui empêchent un appareil de recevoir un verdict MEETS_STRONG_INTEGRITY et de résoudre les problèmes de verdict Play Protect.

Remarque : MEETS_STRONG_INTEGRITY et playProtectVerdict sont des verdicts facultatifs. Vous ne devez les vérifier que si vous avez choisi de recevoir des libellés supplémentaires.

Correction

GET_STRONG_INTEGRITY est conçu pour simplifier l'expérience utilisateur en gérant plusieurs étapes de correction dans un seul flux continu. La boîte de dialogue vérifie automatiquement les problèmes d'intégrité applicables à une adresse, y compris :

• Intégrité de l'appareil : si un problème d'intégrité de l'appareil est détecté, la boîte de dialogue guide l'utilisateur pour améliorer l'état de sécurité de l'appareil afin de répondre aux exigences d'un verdict MEETS_STRONG_INTEGRITY.

• État de Play Protect : si l'playProtectVerdict indique un problème, la boîte de dialogue guide l'utilisateur pour le résoudre :

  • Si Play Protect est désactivé (playProtectVerdict == POSSIBLE_RISK), la boîte de dialogue invite l'utilisateur à l'activer et à analyser toutes les applications de l'appareil.
  • Si des applications nuisibles sont détectées (playProtectVerdict == MEDIUM_RISK ou HIGH_RISK), la boîte de dialogue invite l'utilisateur à les désinstaller à l'aide de Google Play Protect.

• Intégrité de l'application : si des problèmes tels qu'un accès non autorisé ou une altération de l'application sont détectés, la boîte de dialogue invite l'utilisateur à télécharger l'application depuis le Play Store pour résoudre le problème.

• Exceptions côté client : la boîte de dialogue tente également de résoudre les problèmes sous-jacents qui ont provoqué une exception de l'API Integrity. Par exemple, ele peut inviter l'utilisateur à activer les services Google Play s'ils sont désactivés. Les exceptions pouvant être corrigées sont des exceptions de l'API Integrity avec des codes d'erreur tels que PLAY_SERVICES_VERSION_OUTDATED, NETWORK_ERROR ou PLAY_SERVICES_NOT_FOUND. Vous pouvez utiliser la méthode exception.isRemediable() pour vérifier si une erreur peut être corrigée par la boîte de dialogue.

Exemple d'expérience utilisateur

Figure 5 : Boîte de dialogue GET_STRONG_INTEGRITY mettant à jour les services Play.