Confira as novidades do Firebase anunciadas no Google I/O 2022. Saiba mais

Configurar novos alertas de build no app com o SDK do Android para App Distribution

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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

  1. Selecione o projeto no Console do Google Cloud.

  2. 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:

  1. 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.

  2. Verifica se há builds recém-disponibilizados para a instalação do testador.

  3. Exibe um alerta predefinido solicitando que o testador faça a atualização.

  4. 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 gerenciador onProgressUpdate à tarefa updateIfNewReleaseAvailable.

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