Zacznij korzystać ze Sprawdzania aplikacji od dostawcy niestandardowego na Androidzie

Z tej strony dowiesz się, jak włączyć Sprawdzanie aplikacji w aplikacji na Androida za pomocą niestandardowego dostawcy Sprawdzania aplikacji. Gdy włączysz Sprawdzanie aplikacji, masz pewność, że tylko Twoja aplikacja ma dostęp do zasobów Firebase projektu.

Jeśli chcesz używać Sprawdzania aplikacji z domyślnym dostawcą Play Integrity, przeczytaj artykuł na temat włączania Sprawdzania aplikacji za pomocą Play Integrity na Androidzie.

Zanim zaczniesz

1. Dodawanie biblioteki Sprawdzania aplikacji do aplikacji

W pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle) dodaj zależność z biblioteką Sprawdzania aplikacji na Androida. Do kontrolowania obsługi wersji biblioteki zalecamy używanie funkcji Firebase Android BoM. 

dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.1.1"))

    // Add the dependency for the App Check library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-appcheck")
}

Dzięki użyciu BoM Firebase Android BoM Twoja aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.

(Alternatywnie) Dodawanie zależności bibliotek Firebase bez korzystania z BM

Jeśli nie chcesz używać Firebase BoM, musisz określić każdą wersję biblioteki Firebase w wierszu zależności.

Pamiętaj, że jeśli w swojej aplikacji używasz wielu bibliotek Firebase, zdecydowanie zalecamy korzystanie z BoM do zarządzania wersjami bibliotek. Dzięki temu będziesz mieć pewność, że wszystkie wersje są zgodne. 

dependencies {
    // Add the dependency for the App Check library
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-appcheck:18.0.0")
}
Szukasz modułu biblioteki korzystającego z usługi Kotlin? Od października 2023 r. (Firebase BoM 32.5.0) zarówno deweloperzy aplikacji Kotlin, jak i języki Java mogą korzystać z modułu biblioteki głównej (więcej informacji znajdziesz w odpowiedziach na najczęstsze pytania o tę inicjatywę).

2. Wdrażanie interfejsów Sprawdzania aplikacji

Najpierw musisz utworzyć klasy, które implementują interfejsy AppCheckProvider i AppCheckProviderFactory.

Klasa AppCheckProvider musi zawierać metodę getToken(), która zbiera informacje wymagane przez niestandardowego dostawcę Sprawdzania aplikacji w celu potwierdzenia autentyczności i wysyła ją do usługi pozyskiwania tokenów w zamian za token Sprawdzania aplikacji. Pakiet SDK Sprawdzania aplikacji obsługuje zapisywanie tokenów w pamięci podręcznej, więc w swojej implementacji getToken() zawsze musisz uzyskać nowy token.

Kotlin+KTX 

class YourCustomAppCheckToken(
    private val token: String,
    private val expiration: Long,
) : AppCheckToken() {
    override fun getToken(): String = token
    override fun getExpireTimeMillis(): Long = expiration
}

class YourCustomAppCheckProvider(firebaseApp: FirebaseApp) : AppCheckProvider {
    override fun getToken(): Task<AppCheckToken> {
        // Logic to exchange proof of authenticity for an App Check token and
        //   expiration time.
        // ...

        // Refresh the token early to handle clock skew.
        val expMillis = expirationFromServer * 1000L - 60000L

        // Create AppCheckToken object.
        val appCheckToken: AppCheckToken = YourCustomAppCheckToken(tokenFromServer, expMillis)
        return Tasks.forResult(appCheckToken)
    }
}
CustomProvider.kt

Java 

public class YourCustomAppCheckToken extends AppCheckToken {
    private String token;
    private long expiration;

    YourCustomAppCheckToken(String token, long expiration) {
        this.token = token;
        this.expiration = expiration;
    }

    @NonNull
    @Override
    public String getToken() {
        return token;
    }

    @Override
    public long getExpireTimeMillis() {
        return expiration;
    }
}

public class YourCustomAppCheckProvider implements AppCheckProvider {
    public YourCustomAppCheckProvider(FirebaseApp firebaseApp) {
        // ...
    }

    @NonNull
    @Override
    public Task<AppCheckToken> getToken() {
        // Logic to exchange proof of authenticity for an App Check token and
        //   expiration time.
        // ...

        // Refresh the token early to handle clock skew.
        long expMillis = expirationFromServer * 1000L - 60000L;

        // Create AppCheckToken object.
        AppCheckToken appCheckToken =
                new YourCustomAppCheckToken(tokenFromServer, expMillis);

        return Tasks.forResult(appCheckToken);
    }
}
CustomProvider.java

Zaimplementuj też klasę AppCheckProviderFactory, która tworzy wystąpienia Twojej implementacji AppCheckProvider:

Kotlin+KTX 

class YourCustomAppCheckProviderFactory : AppCheckProviderFactory {
    override fun create(firebaseApp: FirebaseApp): AppCheckProvider {
        // Create and return an AppCheckProvider object.
        return YourCustomAppCheckProvider(firebaseApp)
    }
}
CustomProvider.kt

Java 

public class YourCustomAppCheckProviderFactory implements AppCheckProviderFactory {
    @NonNull
    @Override
    public AppCheckProvider create(@NonNull FirebaseApp firebaseApp) {
        // Create and return an AppCheckProvider object.
        return new YourCustomAppCheckProvider(firebaseApp);
    }
}
CustomProvider.java

3. Zainicjuj Sprawdzanie aplikacji

Dodaj do swojej aplikacji poniższy kod inicjowania, aby uruchamiała się przed użyciem innych pakietów SDK Firebase:

Kotlin+KTX 

Firebase.initialize(context)
Firebase.appCheck.installAppCheckProviderFactory(
    YourCustomAppCheckProviderFactory(),
)
CustomProvider.kt

Java 

FirebaseApp.initializeApp(/*context=*/ context);
FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance();
firebaseAppCheck.installAppCheckProviderFactory(
        new YourCustomAppCheckProviderFactory());
CustomProvider.java

Dalsze kroki

Gdy zainstalujesz w aplikacji bibliotekę Sprawdzanie aplikacji, zacznij rozpowszechniać zaktualizowaną aplikację wśród użytkowników.

Zaktualizowana aplikacja kliencka zacznie wysyłać tokeny Sprawdzania aplikacji wraz z każdym żądaniem do Firebase, ale usługi Firebase nie będą wymagały ważności tokenów, dopóki nie włączysz wymuszania w sekcji Sprawdzanie aplikacji w konsoli Firebase.

Monitorowanie wskaźników i włączanie wymuszania

Zanim jednak włączysz egzekwowanie, upewnij się, że nie zakłóci to działania istniejących prawidłowych użytkowników. Jeśli natomiast zauważysz podejrzane wykorzystanie zasobów aplikacji, możesz szybciej włączyć egzekwowanie.

Aby ułatwić sobie podjęcie tej decyzji, możesz przejrzeć wskaźniki Sprawdzania aplikacji dotyczące używanych przez Ciebie usług:

Włącz wymuszanie Sprawdzania aplikacji

Gdy zrozumiesz, jak Sprawdzanie aplikacji wpłynie na Twoich użytkowników, możesz włączyć wymuszanie Sprawdzania aplikacji:

Używanie Sprawdzania aplikacji w środowiskach debugowania

Jeśli po zarejestrowaniu aplikacji na potrzeby Sprawdzania aplikacji chcesz uruchamiać ją w środowisku, którego Sprawdzanie aplikacji zwykle nie klasyfikowałoby jako prawidłowe, np. w emulatorze podczas programowania lub w środowisku ciągłej integracji (CI), możesz utworzyć kompilację do debugowania aplikacji, która korzysta z dostawcy debugowania Sprawdzania aplikacji zamiast prawdziwego dostawcy atestu.

Zapoznaj się z artykułem na temat używania Sprawdzania aplikacji z dostawcą debugowania na Androidzie.