Zacznij korzystać ze Sprawdzania aplikacji od dostawcy niestandardowego na Androidzie

Z tej strony dowiesz się, jak włączyć App Check w aplikacji na Androida za pomocą swojego niestandardowego dostawcy App Check. Gdy włączysz App Check, będziesz mieć pewność, że tylko Twoja aplikacja może uzyskiwać dostęp do zasobów Firebase w Twoim projekcie.

Jeśli chcesz używać App Check z domyślnym dostawcą Play Integrity, przeczytaj artykuł Włączanie App Check za pomocą Play Integrity na Androidzie.

Zanim zaczniesz

1. Dodaj do aplikacji bibliotekę App Check

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

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

    // 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")
}

Gdy korzystamy z Firebase Android BoM, aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.

(Alternatywnie)  Dodaj zależności biblioteki Firebase bez używania BoM

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

Pamiętaj, że jeśli w aplikacji używasz kilku bibliotek Firebase, zdecydowanie zalecamy używanie BoM do zarządzania wersjami bibliotek, co zapewnia zgodność wszystkich wersji. 

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:19.0.2")
}

2. Zaimplementuj interfejsy App Check

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

Klasa AppCheckProvider musi mieć metodę getToken(), która zbiera wszystkie informacje wymagane przez niestandardowego dostawcę App Check jako dowód autentyczności i wysyła je do usługi uzyskiwania tokenów w zamian za token App Check. Pakiet SDK App Check obsługuje buforowanie tokenów, dlatego w implementacji getToken() zawsze pobieraj nowy token.

Kotlin 

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

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

Zaimplementuj też klasę AppCheckProviderFactory, która tworzy instancje implementacji AppCheckProvider:

Kotlin 

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

Java 

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

3. Zainicjuj App Check

Dodaj do aplikacji ten kod inicjujący, aby był on wykonywany przed użyciem innych pakietów SDK Firebase:

Kotlin 

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

Java 

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

Dalsze kroki

Gdy biblioteka App Check zostanie zainstalowana w aplikacji, zacznij rozpowszechniać zaktualizowaną aplikację wśród użytkowników.

Zaktualizowana aplikacja kliencka zacznie wysyłać App Check tokeny wraz z każdym żądaniem wysyłanym do Firebase, ale usługi Firebase nie będą wymagać, aby tokeny były prawidłowe, dopóki nie włączysz egzekwowania w sekcji App Check w konsoli Firebase.

Monitoruj dane i włącz egzekwowanie

Zanim włączysz egzekwowanie, upewnij się, że nie zakłóci to działania dotychczasowych użytkowników. Z drugiej strony, jeśli zauważysz podejrzane użycie zasobów aplikacji, możesz włączyć egzekwowanie wcześniej.

Aby ułatwić podjęcie decyzji, możesz sprawdzić dane App Check dotyczące używanych usług:

Włącz egzekwowanie App Check

Gdy zrozumiesz, jak App Check wpłynie na użytkowników, i będziesz gotowy(-a) do kontynuowania, możesz włączyć egzekwowanie App Check:

Używaj App Check w środowiskach debugowania

Jeśli po zarejestrowaniu aplikacji w App Check chcesz uruchomić ją w środowisku, które App Check zwykle nie klasyfikuje jako prawidłowe, np. w emulatorze podczas programowania lub w trybie ciągłej integracji (CI), możesz utworzyć kompilację do debugowania aplikacji, która zamiast prawdziwego dostawcy atestów używa dostawcy debugowania App Check.

Więcej informacji znajdziesz w artykule Używanie App Check z dostawcą debugowania na Androidzie.