Dialogfelder zur Abhilfe

Auf dieser Seite wird beschrieben, wie Sie Probleme mit Integritätsergebnissen beheben.

Nachdem ein Integritäts-Token angefordert wurde, können Sie dem Nutzer ein Google Play-Dialogfeld anzeigen. Sie können das Dialogfeld anzeigen, wenn es ein oder mehrere Probleme mit dem Integritätsergebnis gibt oder wenn bei einer Integrity API-Anfrage ein Fehler aufgetreten ist. Sobald das Dialogfeld geschlossen ist, können Sie mit einer weiteren Integritäts-Token-Anfrage prüfen, ob das Problem behoben wurde. Wenn Sie Standardanfragen stellen, müssen Sie den Tokenanbieter noch einmal aufwärmen , um ein neues Ergebnis zu erhalten.

Hinweis: Alle Arten von Integritäts-Dialogfeldern können Nutzern angezeigt werden, unabhängig vom Inhalt des Integritäts-Tokens. Sie sollten den Inhalt des Integritäts-Tokens auf Ihrem Server prüfen, um zu ermitteln, welches Dialogfeld angezeigt werden soll.

Integritäts-Dialogfeld anfordern, um ein Problem mit dem Ergebnis zu beheben

Wenn der Client ein Integritäts-Token anfordert, können Sie die Methode verwenden, die in der StandardIntegrityToken (Standard API) und IntegrityTokenResponse (Classic API) angeboten wird: showDialog(Activity activity, int integrityDialogTypeCode).

**Hinweis**: Wenn Sie Integritäts-Dialogfelder verwenden möchten, müssen Sie die Android-Bibliothek der Integrity API ab Version 1.3.0 verwenden.

In den folgenden Schritten wird beschrieben, wie Sie mit der Play Integrity API ein Dialogfeld zur Fehlerbehebung mit dem GET_LICENSED Dialogfeldcode anzeigen. Andere Dialogfeldcodes, die Ihre App anfordern kann, sind nach diesem Abschnitt aufgeführt.

1. Fordern Sie ein Integritäts-Token von Ihrer App an und senden Sie es an Ihren Server. Sie können die Standard- oder die Classic-Anfrage verwenden.

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

   Nativ

   /// 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. Entschlüsseln Sie das Integritäts-Token auf Ihrem Server und prüfen Sie das Feld appLicensingVerdict. Die Ausgabe könnte in diesem Fall ungefähr so aussehen:

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

3. Wenn das Token appLicensingVerdict: "UNLICENSED" enthält, antworten Sie Ihrem App Client und fordern Sie ihn auf, das Lizenzierungsdialogfeld anzuzeigen:

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

   Nativ

   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. Rufen Sie in Ihrer App showDialog mit dem angeforderten Code auf, der von Ihrem Server abgerufen wurde:

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

   Nativ

   // 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. Das Dialogfeld wird über der angegebenen Aktivität angezeigt. Wenn der Nutzer das Dialogfeld geschlossen hat, wird die Aufgabe mit einem Antwortcode abgeschlossen.

6. (Optional) Fordern Sie ein weiteres Token an, um weitere Dialogfelder anzuzeigen. Wenn Sie Standardanfragen stellen, müssen Sie den Tokenanbieter noch einmal aufwärmen, um ein neues Ergebnis zu erhalten.

Integritäts-Dialogfeld anfordern, um einen clientseitigen Fehler zu beheben

Wenn eine Integrity API-Anfrage mit einer StandardIntegrityException (Standard API) oder IntegrityServiceException (Classic API) fehlschlägt und die Ausnahme behoben werden kann, können Sie entweder das Dialogfeld GET_INTEGRITY oder GET_STRONG_INTEGRITY verwenden, um den Fehler zu beheben.

Hinweis: Für die Verwendung der neuen Dialogfelder GET_INTEGRITY oder GET_STRONG_INTEGRITY ist die Android-Bibliothek der Integrity API ab Version 1.5.0 erforderlich. Mit diesem Update haben Sie Zugriff auf die neue showDialog Methode in IntegrityManager (Classic API) oder StandardIntegrityManager (Standard API), um clientseitige Fehler zu beheben.

In den folgenden Schritten wird beschrieben, wie Sie mit dem GET_INTEGRITY Dialogfeld einen behebbaren clientseitigen Fehler beheben, der von der Integrity API gemeldet wurde.

1. Prüfen Sie, ob der von einer Integrity API-Anfrage zurückgegebene Fehler behoben werden kann.

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

   Nativ

   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. Wenn der Fehler behoben werden kann, fordern Sie das Dialogfeld GET_INTEGRITY mit dem zurückgegebenen Fehler an. Das Dialogfeld wird über der angegebenen Aktivität angezeigt und die zurückgegebene Aufgabe wird mit einem Antwortcode abgeschlossen, nachdem der Nutzer das Dialogfeld geschlossen hat.

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

   Nativ

   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. Wenn der zurückgegebene Antwortcode einen Erfolg anzeigt, sollte die nächste Anfrage für ein Integritäts-Token ohne Fehler erfolgreich sein. Wenn Sie Standardanfragen stellen, müssen Sie den Tokenanbieter noch einmal aufwärmen, um ein neues Ergebnis zu erhalten.

Integritäts-Dialogfeldcodes

GET_LICENSED (Typcode 1)

Problem mit dem Ergebnis

Dieses Dialogfeld ist für zwei Probleme geeignet:

• Unbefugter Zugriff: appLicensingVerdict: "UNLICENSED". Das bedeutet, dass das Nutzerkonto keine Berechtigung für Ihre App hat. Das kann passieren, wenn der Nutzer sie per Sideloading installiert oder in einem anderen App-Store als Google Play erworben hat.
• Manipulierte App: appRecognitionVerdict: "UNRECOGNIZED_VERSION". Das bedeutet, dass die Binärdatei Ihrer App geändert wurde oder keine von Google Play erkannte Version ist.

Hinweis: Das Dialogfeld GET_INTEGRITY behebt dieselben Probleme wie GET_LICENSED und zusätzlich Probleme mit der Geräteintegrität und behebbare Fehlercodes.

Auflösung

Sie können das Dialogfeld GET_LICENSED anzeigen, um den Nutzer aufzufordern, die Original-App bei Google Play zu erwerben. Dieses einzelne Dialogfeld deckt beide Szenarien ab:

• Für einen nicht lizenzierten Nutzer wird eine Play-Lizenz gewährt. So kann der Nutzer App-Updates von Google Play erhalten.
• Für einen Nutzer mit einer manipulierten App-Version wird die Installation der unveränderten App von Google Play empfohlen.

Wenn der Nutzer das Dialogfeld schließt, geben nachfolgende Integritätsprüfungen appLicensingVerdict: "LICENSED" und appRecognitionVerdict: "PLAY_RECOGNIZED" zurück.

Beispiel für die Benutzeroberfläche

Abbildung 1 Play-Dialogfeld „GET_LICENSED“

CLOSE_UNKNOWN_ACCESS_RISK (Typcode 2)

Problem mit dem Ergebnis

Wenn environmentDetails.appAccessRiskVerdict.appsDetected "UNKNOWN_CAPTURING" oder "UNKNOWN_CONTROLLING" enthält, bedeutet das, dass auf dem Gerät andere Apps ausgeführt werden , die nicht von Google Play installiert oder vom Gerätehersteller auf der Systempartition vorinstalliert wurden und die den Bildschirm aufzeichnen oder das Gerät steuern könnten.

Auflösung

Sie können das Dialogfeld CLOSE_UNKNOWN_ACCESS_RISK anzeigen, um den Nutzer aufzufordern, alle unbekannten Apps zu schließen, die den Bildschirm aufzeichnen oder das Gerät steuern könnten. Wenn der Nutzer auf die Schaltfläche Close all (Alle schließen) tippt, werden alle diese Apps geschlossen.

Beispiel für die Benutzeroberfläche

Abbildung 2 Dialogfeld zum Schließen von unbekannten Zugriffsrisiken

CLOSE_ALL_ACCESS_RISK (Typcode 3)

Problem mit dem Ergebnis

Wenn environmentDetails.appAccessRiskVerdict.appsDetected einen der folgenden Werte enthält: "KNOWN_CAPTURING", "KNOWN_CONTROLLING","UNKNOWN_CAPTURING" oder "UNKNOWN_CONTROLLING", bedeutet das, dass auf dem Gerät Apps ausgeführt werden, die den Bildschirm aufzeichnen oder das Gerät steuern könnten.

Auflösung

Sie können das Dialogfeld CLOSE_ALL_ACCESS_RISK anzeigen, um den Nutzer aufzufordern, alle Apps zu schließen, die den Bildschirm aufzeichnen oder das Gerät steuern könnten. Wenn der Nutzer auf die Schaltfläche Close all (Alle schließen) tippt, werden alle diese Apps auf dem Gerät geschlossen.

Beispiel für die Benutzeroberfläche

Abbildung 3 Dialogfeld zum Schließen aller Zugriffsrisiken

GET_INTEGRITY (Typcode 4)

Problem mit dem Ergebnis

Dieses Dialogfeld ist für alle folgenden Probleme geeignet:

• Geringe Geräteintegrität: Wenn deviceRecognitionVerdict nicht MEETS_DEVICE_INTEGRITY enthält, ist das Gerät möglicherweise kein echtes und zertifiziertes Android-Gerät. Das kann beispielsweise passieren, wenn der Bootloader des Geräts entsperrt ist oder das geladene Android-Betriebssystem kein zertifiziertes Hersteller-Image ist.

• Unbefugter Zugriff: appLicensingVerdict: "UNLICENSED". Das bedeutet, dass das Nutzerkonto keine Berechtigung für Ihre App hat. Das kann passieren, wenn der Nutzer sie per Sideloading installiert oder in einem anderen App-Store als Google Play erworben hat.

• Manipulierte App: appRecognitionVerdict: "UNRECOGNIZED_VERSION". Das bedeutet, dass die Binärdatei Ihrer App geändert wurde oder keine von Google Play erkannte Version ist.

• Clientseitige Fehler: Wenn bei einer Integrity API-Anfrage ein behebarer Fehler auftritt. Behebbare Fehler sind Integrity API-Fehler mit Fehlercodes wie PLAY_SERVICES_VERSION_OUTDATED, NETWORK_ERROR, PLAY_SERVICES_NOT_FOUND, usw. Mit der Methode exception.isRemediable() können Sie prüfen, ob ein Fehler durch das Dialogfeld behoben werden kann.

Auflösung

Das Dialogfeld GET_INTEGRITY soll die Nutzerfreundlichkeit verbessern, indem mehrere Schritte zur Fehlerbehebung in einem einzigen, kontinuierlichen Ablauf zusammengefasst werden. So muss der Nutzer nicht mit mehreren separaten Dialogfeldern interagieren, um verschiedene Probleme zu beheben.

Wenn Sie das Dialogfeld anfordern, wird automatisch erkannt, welche der Zielprobleme mit dem Ergebnis vorliegen, und die entsprechenden Schritte zur Fehlerbehebung werden angezeigt. Das bedeutet, dass mit einer einzigen Dialogfeldanfrage mehrere Probleme gleichzeitig behoben werden können, darunter:

• Geräteintegrität: Wenn ein Problem mit der Geräteintegrität erkannt wird, wird der Nutzer im Dialogfeld aufgefordert, den Sicherheitsstatus des Geräts zu verbessern, damit die Anforderungen für ein MEETS_DEVICE_INTEGRITY Ergebnis erfüllt werden.
• App-Integrität: Wenn Probleme wie unbefugter Zugriff oder App-Manipulationen erkannt werden, werden Nutzer im Dialogfeld aufgefordert, die App im Google Play Store zu erwerben, um die Probleme zu beheben.

Hinweis: GET_INTEGRITY Dialogfeld erkennt und behebt automatisch mehrere Probleme mit dem Ergebnis, wenn es angefordert wird. Wenn Sie nur Probleme mit der Kontolizenzierung oder der App-Integrität beheben möchten, empfehlen wir das GET_LICENSED Dialogfeld.

• Clientseitige Fehler: Das Dialogfeld prüft auf zugrunde liegende Probleme, die einen Integrity API-Fehler verursacht haben, und versucht, diese zu beheben. Beispielsweise kann der Nutzer aufgefordert werden, eine veraltete Version der Google Play-Dienste zu aktualisieren.

Beispiel für die Benutzeroberfläche

Abbildung 4 Ablauf zur Behebung von Netzwerkfehlern im Dialogfeld „GET_INTEGRITY“

GET_STRONG_INTEGRITY (Typcode 5)

Problem mit dem Ergebnis

Dieses Dialogfeld wurde entwickelt, um alle Probleme zu beheben, die auch mit GET_INTEGRITY behoben werden können. Zusätzlich können damit Probleme behoben werden, die verhindern, dass ein Gerät ein MEETS_STRONG_INTEGRITY Ergebnis erhält, und Probleme mit dem Play Protect Ergebnis.

**Hinweis**: „MEETS_STRONG_INTEGRITY“ und „playProtectVerdict“ sind optionale Ergebnisse. Sie sollten sie nur prüfen, wenn Sie sich für den Erhalt zusätzlicher Labels entschieden haben.

Auflösung

GET_STRONG_INTEGRITY soll die Nutzerfreundlichkeit verbessern, indem mehrere Schritte zur Fehlerbehebung in einem einzigen, kontinuierlichen Ablauf zusammengefasst werden. Das Dialogfeld prüft automatisch auf anwendbare Integritätsprobleme und behebt sie, darunter:

• Geräteintegrität: Wenn ein Problem mit der Geräteintegrität erkannt wird, wird der Nutzer im Dialogfeld aufgefordert, den Sicherheitsstatus des Geräts zu verbessern, damit die Anforderungen für ein MEETS_STRONG_INTEGRITY-Ergebnis erfüllt werden.

• Play Protect-Status: Wenn playProtectVerdict ein Problem anzeigt, wird der Nutzer im Dialogfeld aufgefordert, es zu beheben:

  • Wenn Play Protect deaktiviert ist (playProtectVerdict == POSSIBLE_RISK), wird der Nutzer im Dialogfeld aufgefordert, es zu aktivieren und alle Apps auf dem Gerät zu scannen.
  • Wenn schädliche Apps erkannt werden (playProtectVerdict == MEDIUM_RISK oder HIGH_RISK), wird der Nutzer im Dialogfeld aufgefordert, sie mit Google Play Protect zu deinstallieren.

• App-Integrität: Wenn Probleme wie unbefugter Zugriff oder App-Manipulationen erkannt werden, wird der Nutzer im Dialogfeld aufgefordert, die App im Google Play Store zu erwerben, um das Problem zu beheben.

• Clientseitige Fehler: Das Dialogfeld versucht auch, zugrunde liegende Probleme zu beheben, die einen Integrity API-Fehler verursacht haben. Beispielsweise kann der Nutzer aufgefordert werden, die Google Play-Dienste zu aktivieren, wenn sie deaktiviert sind. Behebbare Fehler sind Integrity API-Fehler mit Fehlercodes wie PLAY_SERVICES_VERSION_OUTDATED, NETWORK_ERROR oder PLAY_SERVICES_NOT_FOUND. Mit der exception.isRemediable()-Methode können Sie prüfen, ob ein Fehler durch das Dialogfeld behoben werden kann.

Beispiel für die Benutzeroberfläche

Abbildung 5 Dialogfeld „GET_STRONG_INTEGRITY“ zum Aktualisieren der Play-Dienste