Iniziare a utilizzare App Check con un provider personalizzato su Android

Questa pagina mostra come attivare App Check in un'app per Android utilizzando il tuo provider App Check personalizzato. Se abiliti App Check, contribuisci a garantire che solo la tua app possa accedere alle risorse Firebase del progetto.

Se vuoi utilizzare App Check con il provider Play Integrity predefinito, consulta Attivare App Check con Play Integrity su Android.

Prima di iniziare

1. Aggiungi la raccolta App Check alla tua app

Nel file Gradle del modulo (a livello di app) (di solito <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), aggiungi la dipendenza per la libreria App Check per Android. Ti consigliamo di utilizzare Firebase Android BoM per controllare il controllo delle versioni delle librerie. 

dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.5.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")
}

Se utilizzi Firebase Android BoM, la tua app utilizzerà sempre versioni compatibili delle librerie Firebase Android.

(Alternativa) Aggiungi dipendenze della libreria Firebase senza utilizzare BoM

Se scegli di non utilizzare Firebase BoM, devi specificare ogni versione della libreria Firebase nella relativa riga di dipendenza.

Tieni presente che se nella tua app utilizzi più librerie Firebase, ti consigliamo vivamente di utilizzare BoM per gestire le versioni della libreria, in modo che tutte le versioni siano compatibili. 

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")
}
 Cerchi un modulo della libreria specifico per Kotlin? A partire da ottobre 2023 (Firebase BoM 32.5.0), gli sviluppatori Kotlin e Java possono dipendere dal modulo della libreria principale (per maggiori dettagli, consulta le Domande frequenti su questa iniziativa).

2. Implementa le interfacce App Check

Innanzitutto, devi creare classi che implementino le interfacce AppCheckProvider e AppCheckProviderFactory.

La tua classe AppCheckProvider deve avere un metodo getToken(), che raccoglie tutte le informazioni richieste dal provider App Check personalizzato come prova di autenticità e le invia al tuo servizio di acquisizione token in cambio di un token App Check. L'SDK App Check gestisce la memorizzazione nella cache dei token, quindi ricevi sempre un nuovo token nell'implementazione di getToken().

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

Implementa anche una classe AppCheckProviderFactory che crei istanze della tua implementazione 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. Inizializza App Check

Aggiungi il seguente codice di inizializzazione alla tua app in modo che venga eseguito prima di utilizzare qualsiasi altro 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

Passaggi successivi

Dopo aver installato la libreria App Check nella tua app, inizia a distribuire l'app aggiornata ai tuoi utenti.

L'app client aggiornata inizierà a inviare token App Check con ogni richiesta inviata a Firebase, ma i prodotti Firebase non richiederanno che i token siano validi finché non attivi l'applicazione forzata nella sezione App Check della Console Firebase.

Monitorare le metriche e abilitare l'applicazione delle norme

Tuttavia, prima di abilitare l'applicazione forzata, devi assicurarti che questa operazione non danneggi gli utenti legittimi esistenti. D'altra parte, se noti un uso sospetto delle risorse della tua app, ti consigliamo di attivare l'applicazione delle norme in precedenza.

Per prendere questa decisione, puoi consultare le metriche di App Check relative ai servizi che utilizzi:

Attiva l'applicazione forzata di App Check

Quando avrai compreso in che modo App Check influirà sui tuoi utenti e sarai pronto a procedere, puoi attivare l'applicazione forzata di App Check:

Utilizza App Check negli ambienti di debug

Se, dopo aver registrato la tua app per App Check, vuoi eseguire l'app in un ambiente che App Check normalmente non classificherebbe come valido, ad esempio un emulatore durante lo sviluppo o da un ambiente di integrazione continua (CI), puoi creare una build di debug della tua app che utilizza il provider di debug App Check anziché un provider di attestazione reale.

Vedi Utilizzare App Check con il provider di debug su Android.