Descubre las novedades de Firebase en Google I/O 2022. Más información

Configura alertas de compilación nuevas en la app con el SDK de Android para App Distribution

El SDK opcional de Firebase App Distribution te permite mostrar alertas en la app a tus verificadores cuando se encuentran nuevas compilaciones de tu app disponibles para instalar. En esta guía, se explica cómo usar el SDK de App Distribution a fin de crear y personalizar alertas de compilaciones nuevas para tus verificadores.

Antes de comenzar

Si aún no lo hiciste, agrega Firebase a tu proyecto de Android.

Paso 1: Habilita la API de App Distribution Tester

Selecciona tu proyecto en Google Cloud Console.
En API de Firebase App Testers, haz clic en Habilitar.

Paso 2: Agrega App Distribution a tu app

En el archivo Gradle (generalmente app/build.gradle) de tu módulo a nivel de la app, declara una dependencia en el SDK de Android de App Distribution:

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

Paso 3: Configura alertas en la app

El SDK de App Distribution dispone de las siguientes formas de configurar las alertas de compilación en la app para los verificadores:

Una configuración básica de alertas, que incluye actualizaciones de apps compiladas previamente y diálogos de acceso que se mostrarán a los verificadores
Una configuración avanzada de alertas, que te permite personalizar la interfaz de usuario

Si usarás el SDK de App Distribution por primera vez, te recomendamos elegir la configuración básica de alertas.

Configuración básica

Usa updateIfNewReleaseAvailable para mostrar un diálogo de alerta de habilitación compilado previamente a los verificadores que aún no activaron las alertas y, luego, comprueba si hay compilaciones nuevas disponibles. Cuando se llama al método, este invoca la siguiente secuencia:

Comprueba si un verificador habilitó las alertas. Si aún no lo ha hecho, el método le pedirá al verificador que acceda a App Distribution con su Cuenta de Google.

Nota: La habilitación de alertas es un proceso único en el dispositivo de prueba y persiste en todas las actualizaciones de tu app. Las alertas permanecen habilitadas en el dispositivo de prueba hasta que se desinstale la app o llame al método signOutTester.
Busca compilaciones disponibles recientemente para que las instale el verificador.
Muestra una alerta compilada previamente que le solicita al verificador una actualización.
Si la nueva compilación es un Android App Bundle (AAB), redirecciona al verificador a Google Play para completar el proceso de actualización.

Si la nueva compilación es un Paquete de aplicación para Android (APK), el SDK descarga la nueva compilación en segundo plano y le pide al verificador que la instale cuando se complete la descarga. El SDK envía notificaciones del progreso de descarga al usuario mediante NotificationManager. También puedes agregar tu propio indicador de progreso. Para ello, adjunta un controlador onProgressUpdate a la tarea updateIfNewReleaseAvailable.

Puedes llamar a updateIfNewReleaseAvailable() en tu app en cualquier momento. Por ejemplo, puedes llamar a updateIfNewReleaseAvailable() durante el método onResume() de MainActivity.

En el siguiente ejemplo, se comprueba si el verificador habilitó las alertas y si tiene acceso a una compilación nueva. Si se cumplen estas condiciones, se mostrará un diálogo cuando la compilación esté disponible para su instalación:

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

Configuración avanzada

Los métodos signInTester y isTesterSignedIn te ofrecen más flexibilidad para personalizar la experiencia de acceso de los verificadores a fin de que coincida mejor con el estilo de tu app.

En el siguiente ejemplo, se comprueba si el verificador ya accedió a su cuenta de App Distribution. Esto te permite mostrar la interfaz de usuario (IU) de acceso solo a los verificadores que aún no accedieron. Después de que el verificador haya accedido, puedes llamar a updateIfNewReleaseAvailable para comprobar si tiene acceso a una compilación nueva.

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

Configuración de actualización avanzada

Los métodos checkForNewRelease y updateApp te ofrecen más flexibilidad para personalizar el momento en que se solicita que se actualice tu verificador. También puedes personalizar el diálogo de actualización compilado previamente y el indicador de progreso de descarga a fin de que coincidan mejor con el estilo de tu app.

Ten en cuenta que updateApp no proporciona un indicador de progreso de descarga. Por lo tanto, debes implementarlo tú mediante NotificationManager, algún tipo de visualización de estado en la app o con un enfoque diferente.

En el siguiente ejemplo, se verifica si hay una versión nueva disponible y, luego, se muestra una IU personalizada. Antes de llamar a checkForNewRelease y updateApp, asegúrate de que el verificador haya accedido mediante la configuración de acceso avanzada.

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

Paso 4: Antes de realizar el envío, aísla App Distribution para tus compilaciones previas al lanzamiento

El SDK de Android para App Distribution no se diseñó con el fin de incluirlo en las apps de producción. El SDK contiene una funcionalidad de actualización automática que se puede considerar una infracción de la política de Google Play, incluso si el código no se aplica en el entorno de ejecución.

Para asegurarte de no incluir código del SDK de Android en apps de producción, te recomendamos usar el SDK de una clase que se haya implementado en el conjunto de orígenes de la variante de compilación previa al lanzamiento, pero no en el conjunto de orígenes de producción. Esa clase debe exponer la funcionalidad necesaria para el resto de la app.

Por ejemplo, si usas la configuración de acceso avanzada que se señaló anteriormente, implementa una clase en tu variante previa al lanzamiento con un método que use el SDK para acceder al verificador y actualizar la 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.
    }
}

Implementa una versión de la misma clase en tu fuente de variantes de producción que no use el 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.
    }
}

Llama al método wrapper desde el código de tu app, por ejemplo, en el onResume() de tu actividad 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()
    }
}

En el archivo Gradle (generalmente app/build.gradle) de tu módulo de nivel de la app, actualiza la dependencia del SDK de Android para App Distribution a fin de que incluya solo tus variantes de compilación previas al lanzamiento:

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

Paso 5: Compila y prueba tu implementación

Por último, distribuye la compilación a los verificadores con Firebase console para compilar la app y probar la implementación.

Visita la guía de solución de problemas de App Distribution para obtener ayuda sobre problemas comunes, como los siguientes:

El verificador no recibe alertas en la app.
Al verificador se le solicita que acceda a Google más de una vez.
El verificador tiene un bucle de acceso.

Configura alertas de compilación nuevas en la app con el SDK de Android para App Distribution

Antes de comenzar

Paso 1: Habilita la API de App Distribution Tester

Paso 2: Agrega App Distribution a tu app

Java

Kotlin+KTX

Paso 3: Configura alertas en la app

Configuración básica

Java

Kotlin+KTX

Configuración avanzada

Configuración de acceso avanzada

Java

Kotlin+KTX

Configuración de actualización avanzada

Java

Kotlin+KTX

Paso 4: Antes de realizar el envío, aísla App Distribution para tus compilaciones previas al lanzamiento

Java

Kotlin+KTX

Java

Kotlin+KTX

Java

Kotlin+KTX

Java

Kotlin+KTX

Paso 5: Compila y prueba tu implementación