Comece a usar o App Check com um provedor personalizado no Android

Esta página mostra como ativar o App Check em um aplicativo Android usando seu provedor personalizado do App Check . Ao ativar o App Check, você ajuda a garantir que apenas seu aplicativo possa acessar os recursos do Firebase do seu projeto.

Se você quiser usar o App Check com o provedor padrão do Play Integrity, consulte Habilitar o App Check com o Play Integrity no Android .

Antes de você começar

1. Adicione a biblioteca App Check ao seu aplicativo

No arquivo Gradle do módulo (nível do aplicativo) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle ), adicione a dependência para o App Check biblioteca para Android. Recomendamos usar o Firebase Android BoM para controlar o controle de versão da biblioteca.

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

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

Ao usar o Firebase Android BoM , seu aplicativo sempre usará versões compatíveis das bibliotecas do Firebase Android.

(Alternativa) Adicionar dependências da biblioteca Firebase sem usar o BoM

Se você optar por não usar o Firebase BoM, deverá especificar cada versão da biblioteca do Firebase em sua linha de dependência.

Observe que se você usa várias bibliotecas do Firebase no seu aplicativo, é altamente recomendável usar a BoM para gerenciar as versões da biblioteca, o que garante que todas as versões sejam compatíveis.

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:17.1.2")
}
Procurando um módulo de biblioteca específico para Kotlin? A partir de outubro de 2023 (Firebase BoM 32.5.0) , tanto os desenvolvedores Kotlin quanto os Java podem depender do módulo da biblioteca principal (para obter detalhes, consulte o FAQ sobre esta iniciativa ).

2. Implemente as interfaces do App Check

Primeiro, você precisa criar classes que implementem as interfaces AppCheckProvider e AppCheckProviderFactory .

Sua classe AppCheckProvider deve ter um método getToken() , que coleta todas as informações que seu provedor personalizado do App Check exige como prova de autenticidade e as envia para o seu serviço de aquisição de token em troca de um token do App Check. O App Check SDK lida com o cache de token, portanto, sempre obtenha um novo token em sua implementação de 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)
    }
}

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

Além disso, implemente uma classe AppCheckProviderFactory que crie instâncias de sua implementação AppCheckProvider :

Kotlin+KTX

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. Inicialize a verificação do aplicativo

Adicione o seguinte código de inicialização ao seu aplicativo para que ele seja executado antes de você usar qualquer outro SDK do Firebase:

Kotlin+KTX

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

Java

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

Próximos passos

Depois que a biblioteca do App Check estiver instalada em seu aplicativo, comece a distribuir o aplicativo atualizado para seus usuários.

O aplicativo cliente atualizado começará a enviar tokens do App Check junto com todas as solicitações feitas ao Firebase, mas os produtos do Firebase não exigirão que os tokens sejam válidos até que você ative a aplicação na seção App Check do console do Firebase.

Monitore métricas e habilite a aplicação

Antes de ativar a aplicação, no entanto, você deve certificar-se de que isso não interromperá seus usuários legítimos existentes. Por outro lado, se você perceber um uso suspeito dos recursos do seu aplicativo, convém ativar a aplicação mais cedo.

Para ajudar a tomar essa decisão, você pode observar as métricas do App Check para os serviços que você usa:

Ativar a aplicação do App Check

Quando você entender como o App Check afetará seus usuários e estiver pronto para prosseguir, poderá ativar a aplicação do App Check:

Use o App Check em ambientes de depuração

Se, depois de registrar seu aplicativo no App Check, você quiser executá-lo em um ambiente que o App Check normalmente não classificaria como válido, como um emulador durante o desenvolvimento ou em um ambiente de integração contínua (CI), você poderá crie uma compilação de depuração do seu aplicativo que use o provedor de depuração do App Check em vez de um provedor de atestado real.

Consulte Usar o App Check com o provedor de depuração no Android .