Informer les testeurs des nouvelles compilations


Les SDK iOS et Android Firebase App Distribution facultatifs vous permettent d'afficher des alertes dans l'application à vos testeurs lorsque de nouvelles versions de votre application sont disponibles à l'installation. Ce guide explique comment utiliser les SDK App Distribution iOS et Android pour créer et personnaliser des alertes de compilation pour vos testeurs.

Avant de commencer

Si ce n'est pas encore fait, ajoutez Firebase à votre projet Android.

Étape 1 : Activez l'API App Distribution Tester

  1. Sélectionnez votre projet dans la console Google Cloud.

  2. Sous "API Firebase App Testers", cliquez sur Activer.

Étape 2 : Ajouter App Distribution à votre application

Le SDK Android App Distribution se compose de deux bibliothèques :

  • firebase-appdistribution-api : bibliothèque réservée aux API que vous pouvez inclure dans toutes les variantes de compilation.
  • firebase-appdistribution : implémentation complète du SDK (facultatif).

La bibliothèque d'API uniquement permet à votre code d'effectuer des appels au SDK. Les appels n'auront aucun effet si l'implémentation complète du SDK n'est pas présente.

Déclarez la dépendance pour le SDK Android App Distribution dans le fichier Gradle de votre module (au niveau de l'application) (généralement <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle). Pour éviter d'inclure la fonctionnalité de mise à jour automatique de l'implémentation complète du SDK dans vos compilations Play, ajoutez la dépendance de la bibliothèque API uniquement à toutes les variantes de compilation. N'ajoutez l'implémentation complète du SDK qu'aux variantes destinées exclusivement aux tests avant la publication.

dependencies {
    // ADD the API-only library to all variants
    implementation("com.google.firebase:firebase-appdistribution-api:16.0.0-beta16")

    // ADD the full SDK implementation to the "beta" variant only (example)
    betaImplementation("com.google.firebase:firebase-appdistribution:16.0.0-beta16")
}

Vous recherchez un module de bibliothèque spécifique à Kotlin ? À partir de la version d'octobre 2023, les développeurs Kotlin et Java peuvent s'appuyer sur le module de bibliothèque principal (pour en savoir plus, consultez les questions fréquentes sur cette initiative).

Étape 3 : Configurer les alertes dans l'application

Le SDK Android App Distribution propose les méthodes suivantes pour configurer des alertes de compilation dans l'application pour vos testeurs :

  • Configuration d'alerte de base fournie avec des boîtes de dialogue prédéfinies pour les mises à jour d'applications et la connexion à afficher aux testeurs.
  • Configuration d'alerte avancée qui vous permet de personnaliser votre propre interface utilisateur.

Si vous utilisez le SDK Android App Distribution pour la première fois, nous vous recommandons d'utiliser la configuration de base.

Configuration de base

Utilisez updateIfNewReleaseAvailable pour afficher une boîte de dialogue prédéfinie permettant d'activer les alertes pour les testeurs qui ne l'ont pas encore fait, puis vérifiez si une nouvelle version est disponible. Lorsqu'elle est appelée, la méthode effectue la séquence suivante :

  1. Vérifie si un testeur a activé les alertes. Si le testeur n'a pas encore activé les alertes, la méthode l'invite à se connecter à App Distribution avec son compte Google.

  2. Recherche les nouveaux builds disponibles que le testeur peut installer.

  3. Affiche une alerte prédéfinie invitant le testeur à effectuer une mise à jour.

  4. Si la nouvelle version est un Android App Bundle (AAB), le testeur est redirigé vers Google Play pour terminer le processus de mise à jour.

    Si la nouvelle version est un package d'application Android (APK), le SDK télécharge la nouvelle version en arrière-plan et invite le testeur à l'installer une fois le téléchargement terminé. Le SDK envoie des notifications de progression du téléchargement à l'utilisateur à l'aide de NotificationManager. Vous pouvez également ajouter votre propre indicateur de progression en associant un gestionnaire onProgressUpdate à la tâche updateIfNewReleaseAvailable.

Vous pouvez appeler updateIfNewReleaseAvailable à tout moment dans votre application. Par exemple, vous pouvez appeler updateIfNewReleaseAvailable pendant la méthode onResume de l'activité principale de l'application.

L'exemple suivant vérifie si le testeur a activé les alertes et a accès à une nouvelle version. Si ces conditions sont remplies, une boîte de dialogue s'affiche lorsque la version est disponible pour l'installation :

Kotlin 

// Copy and paste this into any part of your app - for example, in your main
// activity's onResume method.
val firebaseAppDistribution = FirebaseAppDistribution.getInstance()
firebaseAppDistribution.updateIfNewReleaseAvailable()
    .addOnProgressListener { updateProgress ->
      // (Optional) Implement custom progress updates in addition to
      // automatic NotificationManager updates.
    }
    .addOnFailureListener { e ->
      // (Optional) Handle errors.
      if (e is FirebaseAppDistributionException) {
        when (e.errorCode) {
          Status.NOT_IMPLEMENTED -> {
            // SDK did nothing. This is expected when building for Play.
          }
          else -> {
            // Handle other errors.
          }
        }
      }
    }

Java 

// Copy and paste this into any part of your app - for example, in your main
// activity's onResume method.
FirebaseAppDistribution firebaseAppDistribution = FirebaseAppDistribution.getInstance();
firebaseAppDistribution.updateIfNewReleaseAvailable()
    .addOnProgressListener(updateProgress -> {
      // (Optional) Implement custom progress updates in addition to
      // automatic NotificationManager updates.
    })
    .addOnFailureListener(e -> {
      // (Optional) Handle errors.
      if (e instanceof FirebaseAppDistributionException) {
        switch (((FirebaseAppDistributionException)e).getErrorCode()) {
          case NOT_IMPLEMENTED:
            // SDK did nothing. This is expected when building for Play.
            break;
          default:
            // Handle other errors.
            break;
        }
      }
    });

Configuration avancée

Configuration avancée de la connexion

Les méthodes signInTester et isTesterSignedIn vous offrent plus de flexibilité pour personnaliser l'expérience de connexion de vos testeurs, afin qu'elle corresponde mieux à l'apparence de votre application.

L'exemple suivant vérifie si le testeur s'est déjà connecté à son compte de testeur App Distribution. Cela vous permet de choisir d'afficher votre interface utilisateur de connexion uniquement aux testeurs qui ne se sont pas encore connectés. Une fois le testeur connecté, vous pouvez appeler updateIfNewReleaseAvailable pour vérifier s'il a accès à une nouvelle version.

Kotlin 

// Only show sign-in UI if this is the "beta" variant (example).
if (BuildConfig.BUILD_TYPE == "beta" && !firebaseAppDistribution.isTesterSignedIn) {
    // Start your sign-in UI here.
}

// Only check for updates if the tester is already signed in (do not prompt).
if (firebaseAppDistribution.isTesterSignedIn) {
    firebaseAppDistribution.updateIfNewReleaseAvailable().addOnFailureListener {
        // Handle failed update.
    }
}

Java 

// Only show sign-in UI if this is the "beta" variant (example).
if (BuildConfig.BUILD_TYPE == "beta" && !firebaseAppDistribution.isTesterSignedIn()) {
    // Start your sign-in UI here.
}

// Only check for updates if the tester is already signed in (do not prompt).
if (firebaseAppDistribution.isTesterSignedIn()) {
    firebaseAppDistribution.updateIfNewReleaseAvailable().addOnFailureListener( e -> {
        // Handle failed update.
    });
}

Dans l'UI de connexion, lorsque le testeur choisit de continuer, appelez signInTester() :

Kotlin 

firebaseAppDistribution.signInTester().addOnSuccessListener {
  // Handle successful sign-in.
}.addOnFailureListener {
  // Handle failed sign-in.
});

Java 

firebaseAppDistribution.signInTester().addOnSuccessListener( unused -> {
  // Handle successful sign-in.
}).addOnFailureListener(e -> {
  // Handle failed sign-in.
});

Configuration avancée des mises à jour

Les méthodes checkForNewRelease et updateApp vous offrent plus de flexibilité pour personnaliser le moment où votre testeur est invité à effectuer une mise à jour. Vous pouvez également personnaliser la boîte de dialogue de mise à jour prédéfinie et l'indicateur de progression du téléchargement pour qu'ils correspondent mieux à l'apparence de votre application.

Notez que updateApp n'indique pas la progression du téléchargement. Cela signifie que vous devez implémenter votre propre indication de progression à l'aide de NotificationManager, d'un affichage de l'état dans l'application ou d'une autre approche.

L'exemple suivant vérifie si une nouvelle version est disponible, puis affiche une UI personnalisée. Avant d'appeler checkForNewRelease et updateApp, assurez-vous que le testeur est connecté à l'aide de la configuration de connexion avancée.

Kotlin 

firebaseAppDistribution.checkForNewRelease().addOnSuccessListener { release ->
    if (release != null) {
        // New release available. Start your update UI here.
    }
}.addOnFailureListener {
    // Handle failed check for new release. Fails with Status#NOT_IMPLEMENTED
    // if built for Play.
}

Java 

firebaseAppDistribution.checkForNewRelease().addOnSuccessListener(release -> {
    if (release != null) {
        // New release available. Start your update UI here.
    }
}).addOnFailureListener(e -> {
    // Handle failed check for new release. Fails with Status#NOT_IMPLEMENTED
    // if built for Play.
});

Lorsque le testeur choisit de procéder à la mise à jour à partir de votre UI de mise à jour, appelez updateApp() :

Kotlin 

firebaseAppDistribution.updateApp()
    .addOnProgressListener { updateState ->
      // Use updateState to show update progress.
    }

Java 

firebaseAppDistribution.updateApp()
    .addOnProgressListener(updateState -> {
      // Use updateState to show update progress.
    });

Étape 4 : Créez et testez votre implémentation

Créez votre application et testez votre implémentation en distribuant la version aux testeurs à l'aide de la console Firebase.

Consultez le App Distribution guide de dépannage pour obtenir de l'aide sur les problèmes courants, comme :

  • Le testeur ne reçoit pas d'alertes dans l'application
  • Le testeur est invité à se connecter à Google plusieurs fois