O SDK opcional do Firebase App Distribution permite que você exiba alertas no app para seus testadores quando novos builds do seu app estiverem disponíveis para instalação. Este guia explica como usar o SDK do App Distribution para criar e personalizar alertas de novos builds para seus testadores.
Antes de começar
Adicione o Firebase ao seu projeto para Android, caso ainda não tenha feito isso.
Etapa 1: ativar a API App Distribution Tester
Selecione o projeto no Console do Google Cloud.
Em API Firebase App Testers, clique em Ativar.
Etapa 2: adicionar o App Distribution ao seu app
No arquivo do Gradle no módulo no nível do app, que geralmente é app/build.gradle
, declare uma dependência no SDK do App Distribution para Android:
Java
dependencies {
// ADD this line
implementation 'com.google.firebase:firebase-appdistribution:16.0.0-beta02'
}
Kotlin+KTX
dependencies {
// ADD this line
implementation 'com.google.firebase:firebase-appdistribution-ktx:16.0.0-beta02'
}
Etapa 3: configurar alertas no app
O SDK do App Distribution oferece as seguintes maneiras de configurar alertas de build no app para os testadores:
- Uma configuração básica de alerta que vem com caixas de diálogo pré-criadas de atualização e login do app para exibição aos testadores.
- Uma configuração de alerta avançada que permite personalizar a própria interface do usuário.
Caso você esteja usando o SDK do App Distribution pela primeira vez, recomendamos usar a configuração de alerta básica.
Configuração básica
Use updateIfNewReleaseAvailable
para exibir uma caixa de diálogo "Ativar alertas" pré-criada para
testadores que ainda não ativaram os alertas e, em seguida, verificar se há um novo build
disponível. Quando chamado, o método gera a seguinte sequência:
Verifica se um testador ativou alertas. Caso ele não tenha feito isso, o método solicitará que faça login no App Distribution com a Conta do Google.
Verifica se há builds recém-disponibilizados para a instalação do testador.
Exibe um alerta predefinido solicitando que o testador faça a atualização.
Se o novo build for um Android App Bundle (AAB), o testador será redirecionado para o Google Play para concluir o processo de atualização.
Se o novo build for um pacote de aplicativo Android (APK), o SDK fará o download dele em segundo plano e solicitará que o testador faça a instalação quando o download for concluído. O SDK envia notificações de progresso de download ao usuário usando
NotificationManager
. Também é possível adicionar seu próprio indicador de progresso anexando um gerenciadoronProgressUpdate
à tarefaupdateIfNewReleaseAvailable
.
Você pode chamar updateIfNewReleaseAvailable()
a qualquer momento. Por
exemplo, você pode chamar updateIfNewReleaseAvailable()
durante o método onResume()
da MainActivity.
O exemplo a seguir verifica se o testador ativou alertas e tem acesso a um novo build. Se essas condições forem atendidas, uma caixa de diálogo será exibida quando o build estiver disponível para instalação:
Java
public class MainActivity extends AppCompatActivity {
FirebaseAppDistribution firebaseAppDistribution =
FirebaseAppDistribution.getInstance();
@Override
public void onResume() {
super.onResume();
firebaseAppDistribution.updateIfNewReleaseAvailable()
.addOnProgressListener(updateProgress -> {
// (Optional) Implement custom progress updates in addition to
// automatic NotificationManager updates.
})
.addOnFailureListener(e -> {
if (e instanceof FirebaseAppDistributionException) {
// Handle exception.
}
});
}
}
Kotlin+KTX
class MainActivity : AppCompatActivity() {
var firebaseAppDistribution = FirebaseAppDistribution.getInstance()
override fun onResume() {
super.onResume()
firebaseAppDistribution.updateIfNewReleaseAvailable()
.addOnProgressListener { updateProgress ->
// (Optional) Implement custom progress updates in addition to
// automatic NotificationManager updates.
}
.addOnFailureListener { e ->
if (e is FirebaseAppDistributionException) {
// Handle exception.
}
}
}
}
Configuração avançada
Configuração avançada de login
Os métodos signInTester
e isTesterSignedIn
oferecem mais flexibilidade para
personalizar a experiência de login do testador. Assim, a experiência pode ser
melhor para a aparência do app.
O exemplo a seguir verifica se o testador já fez login na
conta de testador do App Distribution. Isso permite que você opte por exibir a
interface de usuário (IU) de login apenas para testadores que ainda não fizeram login. Depois
que o testador fizer login, você poderá chamar updateIfNewReleaseAvailable
para
verificar se ele tem acesso a um novo build.
Java
if (!firebaseAppDistribution.isTesterSignedIn()) {
// Start your sign in UI here.
//
// When the tester chooses to proceed with the update,
// call signInTester():
//
// firebaseAppDistribution.signInTester().addOnSuccessListener( unused -> {
// // Handle successful sign in.
// }).addOnFailureListener(e -> {
// // Handle failed sign in.
// });
}
// Only check for updates if the tester is already signed in (do not prompt).
if (firebaseAppDistribution.isTesterSignedIn()) {
firebaseAppDistribution.updateIfNewReleaseAvailable().addOnFailureListener( e -> {
// Handle failed update.
});
}
Kotlin+KTX
if (!firebaseAppDistribution.isTesterSignedIn) {
// Start your sign in UI here.
//
// When the tester chooses to proceed with the update,
// call signInTester():
//
// firebaseAppDistribution.signInTester().addOnSuccessListener {
// // Handle successful sign in.
// }.addOnFailureListener {
// // Handle failed sign in.
// });
}
// Only check for updates if the tester is already signed in (do not prompt).
if (firebaseAppDistribution.isTesterSignedIn) {
firebaseAppDistribution.updateIfNewReleaseAvailable().addOnFailureListener {
// Handle failed update.
}
}
Configuração avançada de atualização
Os métodos checkForNewRelease
e updateApp
oferecem mais flexibilidade para
personalizar quando o testador é solicitado a atualizar. Você também pode personalizar a
caixa de diálogo de atualização pré-criada e o indicador de progresso de download para que eles possam
melhorar a aparência do seu app.
Observe que updateApp
não fornece indicação de progresso de download. Isso significa
que você precisa implementar sua própria indicação de progresso usando
NotificationManager
, algum tipo de exibição de status no app ou outra
abordagem.
O exemplo a seguir verifica se uma nova versão está disponível e, em seguida,
exibe uma IU personalizada. Antes de chamar checkForNewRelease
e updateApp
, verifique se
o testador fez login usando a
configuração avançada de login.
Java
firebaseAppDistribution.checkForNewRelease().addOnSuccessListener(release -> {
if (release != null) { // New release available.
// Start your update UI here.
//
// When the tester chooses to proceed with the update, call updateApp():
//
// firebaseAppDistribution.updateApp()
// .addOnProgressListener(updateState -> {
// // Use updateState to show update progress.
// });
}
}).addOnFailureListener(e -> {
// Handle failed check for new release.
});
Kotlin+KTX
firebaseAppDistribution.checkForNewRelease().addOnSuccessListener { release ->
if (release != null) { // New release available.
// Start your update UI here.
//
// When the tester chooses to proceed with the update, call updateApp():
//
// firebaseAppDistribution.updateApp()
// .addOnProgressListener { updateState ->
// // Use updateState to show update progress.
// }
}
}.addOnFailureListener {
// Handle failed check for new release.
}
Etapa 4: antes de enviar, isole o App Distribution nos seus builds de pré-lançamento.
O SDK do Android para App Distribution não foi feito para ser incluído em apps de produção. O SDK contém o recurso de autoatualização, que pode ser considerado uma violação da política do Google Play, mesmo que esse código não seja executado no ambiente de execução.
Para garantir que você não inclua o código do SDK do Android em apps de produção, recomendamos que use o SDK de uma classe implementada no conjunto de origem da variante de build de pré-lançamento, mas não no seu conjunto de origem de produção. Essa classe precisa expor a funcionalidade necessária para o restante do app.
Por exemplo, se você usar a configuração avançada de login acima, implemente uma classe na variante de pré-lançamento com um método que use o SDK para fazer login do testador e atualizar o app:
Java
// src/{pre-release variant}/java/com/example/AppDistributionWrapper.java
class AppDistributionWrapper {
FirebaseAppDistribution firebaseAppDistribution =
FirebaseAppDistribution.getInstance();
void signInAndUpdate() {
// Use the App Distribution SDK to sign in the tester and update the app.
}
}
Kotlin+KTX
// src/{pre-release variant}/java/com/example/AppDistributionWrapper.kt
class AppDistributionWrapper {
val firebaseAppDistribution = FirebaseAppDistribution.getInstance()
fun signInAndUpdate() {
// Use the App Distribution SDK to sign in the tester and update the app.
}
}
Implemente uma versão da mesma classe na sua fonte de variantes de produção que não use o SDK:
Java
// src/{production variant}/java/com/example/AppDistributionWrapper.java
class AppDistributionWrapper {
void signInAndUpdate() {
// In production, do nothing.
}
}
Kotlin+KTX
// src/{production variant}/java/com/example/AppDistributionWrapper.kt
class AppDistributionWrapper {
fun signInAndUpdate() {
// In production, do nothing.
}
}
Chame o método wrapper pelo código do app. Por exemplo, no onResume()
da
atividade principal:
Java
// src/main/java/com/example/MainActivity.java
public class MainActivity extends AppCompatActivity {
AppDistributionWrapper appDistributionWrapper =
new AppDistributionWrapper();
@Override
public void onResume() {
super.onResume();
appDistributionWrapper.signInAndUpdate();
}
}
Kotlin+KTX
// src/main/java/com/example/MainActivity.kt
class MainActivity : AppCompatActivity() {
var appDistributionWrapper = AppDistributionWrapper()
override fun onResume() {
super.onResume()
appDistributionWrapper.signInAndUpdate()
}
}
No arquivo do Gradle no módulo no nível do app, que geralmente é app/build.gradle
, atualize a
dependência do SDK do App Distribution para Android para incluir apenas as
variantes de build de pré-lançamento:
Java
dependencies {
// UPDATE the dependency to include the "beta" variant only (example)
betaImplementation 'com.google.firebase:firebase-appdistribution:16.0.0-beta02'
}
Kotlin+KTX
dependencies {
// UPDATE the dependency to include the "beta" variant only (example)
betaImplementation 'com.google.firebase:firebase-appdistribution-ktx:16.0.0-beta02'
}
Etapa 5: criar e testar a implementação
Por fim, crie o app e teste a implementação distribuindo o build para os testadores usando o Console do Firebase.
Acesse o Guia de solução de problemas do App Distribution para mais informações sobre questões comuns, por exemplo:
- O testador não recebe alertas no app.
- O testador precisa fazer login no Google mais de uma vez.
- Testador com loop de login