Dialogfelder zur Abhilfe

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

Nachdem ein Integritäts-Token angefordert wurde, kannst du dem Nutzer ein Google Play-Dialogfeld anzeigen lassen. Du kannst das Dialogfeld anzeigen lassen, wenn es ein oder mehrere Probleme mit dem Integritätsergebnis gibt oder wenn während einer Integrity API-Anfrage eine Ausnahme aufgetreten ist. Nachdem das Dialogfeld geschlossen wurde, kannst du mit einer weiteren Integritätstoken-Anfrage prüfen, ob das Problem behoben wurde. Wenn Sie Standardanfragen stellen, müssen Sie den Tokenanbieter noch einmal aufwärmen, um ein neues Urteil zu erhalten.

Hinweis: Alle Arten von Integritätsdialogen können Nutzern angezeigt werden, unabhängig vom Inhalt des Integritätstokens. Du solltest den Inhalt des Integritäts-Tokens auf deinem Server prüfen, um festzustellen, welches Dialogfeld angezeigt werden soll.

Integritätsdialogfeld anfordern, um ein Problem mit dem Ergebnis zu beheben

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

Hinweis: Wenn Sie Integritätsdialoge 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 und dem Dialogcode GET_LICENSED ein Dialogfeld zur Problembehebung anzeigen können. Weitere Dialogcodes, 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 klassische 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. Rufe in deiner App showDialog mit dem angeforderten Code auf, der von deinem 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 Urteil zu erhalten.

Integritätsdialogfeld anfordern, um eine clientseitige Ausnahme zu beheben

Wenn eine Integrity API-Anfrage mit StandardIntegrityException (Standard API) oder IntegrityServiceException (Classic API) fehlschlägt und die Ausnahme behebbar ist, können Sie den Fehler entweder über das Dialogfeld GET_INTEGRITY oder GET_STRONG_INTEGRITY beheben.

Hinweis: Für die Verwendung der neuen GET_INTEGRITY- oder GET_STRONG_INTEGRITY-Dialogfelder ist die Integrity API Android-Bibliothek ab Version 1.5.0 erforderlich. Dieses Update bietet Zugriff auf die neue Methode showDialog in IntegrityManager (Classic API) oder StandardIntegrityManager (Standard API) zum Beheben clientseitiger Ausnahmen.

In den folgenden Schritten wird beschrieben, wie Sie das Dialogfeld GET_INTEGRITY verwenden können, um einen behebbaren clientseitigen Fehler zu beheben, der von der Integrity API gemeldet wurde.

1. Prüfen Sie, ob die von einer Integrity API-Anfrage zurückgegebene Ausnahme behebbar ist.

   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 die Ausnahme behebbar ist, fordern Sie das Dialogfeld GET_INTEGRITY mit der zurückgegebenen Ausnahme 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 auf einen Erfolg hinweist, sollte die nächste Anfrage für ein Integritätstoken ohne Ausnahmen erfolgreich sein. Wenn Sie Standardanfragen stellen, müssen Sie den Tokenanbieter noch einmal aufwärmen, um ein neues Ergebnis zu erhalten.

Codes für Integritätsdialoge

GET_LICENSED (Typcode 1)

Problem mit der Einstufung

Dieses Dialogfeld ist für zwei Probleme geeignet:

• Unberechtigter Zugriff: appLicensingVerdict: "UNLICENSED". Das bedeutet, dass das Nutzerkonto keine Berechtigung für deine App hat. Das kann passieren, wenn der Nutzer die App per Sideload installiert oder in einem anderen App-Shop als Google Play erworben hat.
• Manipulierte App: appRecognitionVerdict: "UNRECOGNIZED_VERSION". Das bedeutet, dass das Binärprogramm deiner App geändert wurde oder keine von Google Play erkannte Version ist.

Hinweis: Das Dialogfeld GET_INTEGRITY behandelt dieselben Probleme wie GET_LICENSED sowie Probleme mit der Geräteintegrität und behebbare Fehlercodes.

Auflösung

Du kannst das Dialogfeld GET_LICENSED einblenden, um den Nutzer aufzufordern, die Original-App bei Google Play herunterzuladen. Dieses Dialogfeld deckt beide Szenarien ab:

• Nutzer ohne Lizenz erhalten eine Play-Lizenz. So kann der Nutzer App-Updates von Google Play erhalten.
• Nutzer mit einer manipulierten App-Version werden aufgefordert, die unveränderte App von Google Play zu installieren.

Wenn der Nutzer den Dialog abschließt, geben nachfolgende Integritätsprüfungen appLicensingVerdict: "LICENSED" und appRecognitionVerdict: "PLAY_RECOGNIZED" zurück.

Beispiel-UX

Abbildung 1. GET_LICENSED Play-Dialogfeld.

CLOSE_UNKNOWN_ACCESS_RISK (Typcode 2)

Problem mit der Einstufung

Wenn environmentDetails.appAccessRiskVerdict.appsDetected den Wert "UNKNOWN_CAPTURING" oder "UNKNOWN_CONTROLLING" enthält, bedeutet dies, dass auf dem Gerät andere Apps ausgeführt werden, die nicht über 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 einblenden, um den Nutzer aufzufordern, alle unbekannten Apps zu schließen, die möglicherweise den Bildschirm aufzeichnen oder das Gerät steuern. Wenn der Nutzer auf die Schaltfläche Close all tippt, werden alle diese Apps geschlossen.

Beispiel-UX

Abbildung 2. Dialogfeld zum Schließen des Risikos „Unbekannter Zugriff“.

CLOSE_ALL_ACCESS_RISK (Typcode 3)

Problem mit der Einstufung

Wenn environmentDetails.appAccessRiskVerdict.appsDetected einen der Werte "KNOWN_CAPTURING", "KNOWN_CONTROLLING", "UNKNOWN_CAPTURING" oder "UNKNOWN_CONTROLLING" enthält, bedeutet dies, dass auf dem Gerät Apps ausgeführt werden, die möglicherweise den Bildschirm aufnehmen oder das Gerät steuern.

Auflösung

Du kannst das Dialogfeld CLOSE_ALL_ACCESS_RISK einblenden, 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 tippt, werden alle diese Apps auf dem Gerät geschlossen.

Beispiel-UX

Abbildung 3. Dialogfeld zum Schließen aller Zugriffsrisiken.

GET_INTEGRITY (Typcode 4)

Problem mit der Einstufung

Dieses Dialogfeld ist für die folgenden Probleme geeignet:

• Schwache 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.

• Unberechtigter Zugriff: appLicensingVerdict: "UNLICENSED". Das bedeutet, dass das Nutzerkonto keine Berechtigung für deine App hat. Das kann passieren, wenn der Nutzer die App per Sideload installiert oder in einem anderen App-Shop als Google Play erworben hat.

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

• Clientseitige Ausnahmen: Wenn während einer Integrity API-Anfrage eine behebbare Ausnahme auftritt. Behebbare Ausnahmen sind Integrity API-Ausnahmen 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 eine Ausnahme über das Dialogfeld behoben werden kann.

Auflösung

Das Dialogfeld GET_INTEGRITY soll die Nutzererfahrung optimieren, indem mehrere Schritte zur Fehlerbehebung in einem einzigen, kontinuierlichen Ablauf ausgeführt 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 relevanten Probleme mit dem Urteil vorliegen, und es werden die entsprechenden Schritte zur Behebung angezeigt. Das bedeutet, dass eine einzelne Dialoganfrage mehrere Probleme gleichzeitig beheben kann, 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, um die Anforderungen für ein MEETS_DEVICE_INTEGRITY-Ergebnis zu erfüllen.
• App-Integrität: Wenn Probleme wie unbefugter Zugriff oder Manipulationen an der App erkannt werden, werden Nutzer im Dialogfeld aufgefordert, die App im Google Play Store herunterzuladen, um die Probleme zu beheben.

Hinweis: Im Dialogfeld GET_INTEGRITY werden mehrere Probleme mit dem Urteil automatisch erkannt und auf Anfrage behoben. Wenn Sie nur Probleme mit der Kontolizenzierung oder App-Integrität beheben möchten, empfehlen wir die Verwendung des Dialogfelds GET_LICENSED.

• Clientseitige Ausnahmen: Im Dialogfeld wird nach zugrunde liegenden Problemen gesucht, die eine Integrity API-Ausnahme verursacht haben, und es wird versucht, diese zu beheben. Beispielsweise kann der Nutzer aufgefordert werden, eine veraltete Version der Google Play-Dienste zu aktualisieren.

Beispiel-UX

Abbildung 4. Ablauf zur Behebung von Netzwerkfehlern im GET_INTEGRITY-Dialogfeld

GET_STRONG_INTEGRITY (Typcode 5)

Problem mit der Einstufung

Dieses Dialogfeld ist dafür gedacht, alle Probleme zu beheben, die auch mit GET_INTEGRITY behoben werden können. Außerdem können damit Probleme behoben werden, die verhindern, dass ein Gerät ein MEETS_STRONG_INTEGRITY-Ergebnis erhält, sowie Probleme mit dem Play Protect-Ergebnis.

Hinweis: MEETS_STRONG_INTEGRITY und playProtectVerdict sind optionale Ergebnisse, die Sie nur prüfen sollten, wenn Sie zusätzliche Labels aktiviert haben.

Auflösung

GET_STRONG_INTEGRITY wurde entwickelt, um die Nutzererfahrung zu optimieren, indem mehrere Schritte zur Fehlerbehebung in einem einzigen, kontinuierlichen Ablauf ausgeführt werden. Im Dialogfeld wird automatisch nach Integritätsproblemen gesucht, die für eine Adresse relevant sind, 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, um die Anforderungen für ein MEETS_STRONG_INTEGRITY-Ergebnis zu erfüllen.

• Play Protect-Status: Wenn das playProtectVerdict auf ein Problem hinweist, wird der Nutzer im Dialogfeld durch die Schritte zur Behebung geführt:

  • 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 (playProtectVerdict == MEDIUM_RISK oder HIGH_RISK) erkannt werden, wird der Nutzer im Dialogfeld aufgefordert, sie über Google Play Protect zu deinstallieren.

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

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

Beispiel-UX

Abbildung 5. GET_STRONG_INTEGRITY-Dialogfeld zum Aktualisieren der Play-Dienste.