Okna działań naprawczych

Na tej stronie opisano, jak rozwiązywać problemy z wynikami weryfikacji integralności.

Gdy zostanie wysłane żądanie tokena integralności, możesz wyświetlić użytkownikowi okno Google Play. Możesz wyświetlić okno dialogowe, jeśli wystąpi co najmniej 1 problem z osądem dotyczącym integralności. Okno z informacjami wyświetla się u góry aplikacji i zachęca użytkowników do rozwiązania problemu. Po zamknięciu okna możesz sprawdzić, czy problem został rozwiązany, wysyłając kolejną prośbę do interfejsu Integrity API.

Uwaga: użytkownikom mogą się wyświetlać wszystkie typy okien integralności niezależnie od zawartości tokenu integralności. Aby określić, który dialog powinien się wyświetlić, sprawdź zawartość tokena integralności na serwerze.

Prośba o okno integralności

Gdy klient żąda tokena integralności, możesz użyć metody oferowanej w StandardIntegrityToken (interfejs Standard API) i IntegrityTokenResponse (interfejs Classic API): showDialog(Activity activity, int integrityDialogTypeCode).

Uwaga: aby używać okien dialogowych z informacjami o zgodności, musisz używać biblioteki Integrity API na Androida w wersji 1.3.0 lub nowszej.

W następujących krokach opisujemy, jak za pomocą interfejsu Play Integrity API wyświetlić okno na temat działań naprawczych, używając kodu okna GET_LICENSED. Inne kody dialogowe, których może używać Twoja aplikacja, są wymienione po tej sekcji.

1. Poproś o token integralności z aplikacji i wyślij go na serwer. Możesz użyć żądania standardowego lub klasycznego.

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

   Rodzimy użytkownik

   /// 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. Na serwerze odszyfruj token integralności i sprawdź pole appLicensingVerdict. Może to wyglądać mniej więcej tak:

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

3. Jeśli token zawiera appLicensingVerdict: "UNLICENSED", odpowiedz klientowi aplikacji, prosząc o wyświetlenie okna licencjonowania:

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

   Rodzimy użytkownik

   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. W aplikacji wywołaj funkcję showDialog, podając żądany kod pobrany z serwera:

   Kotlin

   // Show dialog as indicated by the server
   val showDialogType: Int? = yourServerResponse.integrityDialogTypeCode()
   if (showDialogType != null) {
     // Call showDialog with type code, the dialog will be shown on top of the
     // provided activity and complete when the dialog is closed.
     val integrityDialogResponseCode: Task<Int> =
     tokenResponse.showDialog(activity, showDialogType)
     // Handle response code, call the Integrity API again to confirm that
     // verdicts have been resolved.
   } 

   Java

   // Show dialog as indicated by the server
   @Nullable Integer showDialogType = yourServerResponse.integrityDialogTypeCode();
   if (showDialogType != null) {
     // Call showDialog with type code, the dialog will be shown on top of the
     // provided activity and complete when the dialog is closed.
     Task<Integer> integrityDialogResponseCode =
         tokenResponse.showDialog(activity, showDialogType);
     // Handle response code, call the Integrity API again to confirm that
     // verdicts have been resolved.
   }

   Unity

   IEnumerator ShowDialogCoroutine() {
     int showDialogType = yourServerResponse.IntegrityDialogTypeCode();
   
     // Call showDialog with type code, the dialog will be shown on top of the
     // provided activity and complete when the dialog is closed.
     var showDialogTask = tokenResponse.ShowDialog(showDialogType);
   
     // Wait for PlayAsyncOperation to complete.
     yield return showDialogTask;
   
     // Handle response code, call the Integrity API again to confirm that
     // verdicts have been resolved.
   } 

   Unreal Engine

   // .h
   void MyClass::OnShowDialogCompleted(
     EStandardIntegrityErrorCode Error,
     EIntegrityDialogResponseCode Response)
   {
     // Handle response code, call the Integrity API again to confirm that
     // verdicts have 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);
   }

   Rodzimy użytkownik

   // Show dialog as indicated by the server
   int show_dialog_type = yourServerResponse.integrityDialogTypeCode();
   if (show_dialog_type != 0) {
     /// Call showDialog with type code, the dialog will be shown on top of the
     /// provided activity and complete when the dialog is closed.
     StandardIntegrityErrorCode error_code =
         IntegrityTokenResponse_showDialog(response, activity, show_dialog_type);
   
     /// Proceed to polling iff error_code == STANDARD_INTEGRITY_NO_ERROR
     if (error_code != STANDARD_INTEGRITY_NO_ERROR)
     {
         /// Remember to call the *_destroy() functions.
         return;
     }
   
     /// Use polling to wait for the async operation to complete.
     /// Note, the polling shouldn't block the thread where the IntegrityManager
     /// is running.
   
     IntegrityDialogResponseCode* response_code;
     error_code = StandardIntegrityToken_getDialogResponseCode(response, response_code);
   
     if (error_code != STANDARD_INTEGRITY_NO_ERROR)
     {
         /// Remember to call the *_destroy() functions.
         return;
     }
   
     /// Handle response code, call the Integrity API again to confirm that
     /// verdicts have been resolved.
   }

5. Okno dialogowe wyświetla się u góry podanej aktywności. Gdy użytkownik zamknie okno dialogowe, zadanie zostanie ukończone z kodem odpowiedzi.

6. (Opcjonalnie) Poproś o nowy token, aby wyświetlić kolejne okna dialogowe. Jeśli wysyłasz standardowe żądania, musisz ponownie wstępnie zainicjować dostawcę tokenów, aby uzyskać nową opinię.

Kody dialogów integralności

GET_LICENSED (kod typu 1)

Problem z wynikiem

Gdy appLicensingVerdict == "UNLICENSED". Oznacza to, że konto użytkownika nie jest licencjonowane. Inaczej mówiąc: nie zainstalował ani nie kupił aplikacji w Google Play.

Działania naprawcze

Możesz wyświetlić okno GET_LICENSED, aby poprosić użytkownika o pobranie aplikacji z Google Play. Jeśli użytkownik zaakceptuje, jego konto uzyska licencję (appLicensingVerdict == "LICENSED"). Aplikacja zostanie dodana do biblioteki Google Play użytkownika, a Google Play będzie mógł dostarczać aktualizacje aplikacji w Twoim imieniu.

Przykład UX

CLOSE_UNKNOWN_ACCESS_RISK (kod typu 2)

Problem z wynikiem

Jeśli environmentDetails.appAccessRiskVerdict.appsDetected zawiera "UNKNOWN_CAPTURING" lub "UNKNOWN_CONTROLLING", oznacza to, że na urządzeniu są uruchomione nieznane aplikacje, które mogą rejestrować to, co widać na ekranie, lub kontrolować urządzenie.

Działania naprawcze

Możesz wyświetlić okno CLOSE_UNKNOWN_ACCESS_RISK, aby poprosić użytkownika o zamknięcie wszystkich nieznanych aplikacji, które mogą przechwytywać obraz z ekranu lub sterować urządzeniem. Jeśli użytkownik kliknie przycisk Close all, wszystkie takie aplikacje zostaną zamknięte.

Przykład UX

CLOSE_ALL_ACCESS_RISK (kod typu 3)

Problem z wynikiem

Jeśli environmentDetails.appAccessRiskVerdict.appsDetected zawiera dowolną z wartości "KNOWN_CAPTURING", "KNOWN_CONTROLLING", "UNKNOWN_CAPTURING" lub "UNKNOWN_CONTROLLING", oznacza to, że na urządzeniu są uruchomione aplikacje, które mogą przechwytywać ekran lub sterować urządzeniem.

Działania naprawcze

Możesz wyświetlić okno CLOSE_ALL_ACCESS_RISK, aby poprosić użytkownika o zamknięcie wszystkich aplikacji, które mogą przechwytywać ekran lub sterować urządzeniem. Gdy użytkownik kliknie przycisk Close all, wszystkie takie aplikacje zostaną zamknięte na urządzeniu.

Przykład UX