Informer les testeurs des nouvelles compilations


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

Avant de commencer

Si ce n'est pas déjà fait, ajoutez Firebase à votre projet Android.

Étape 1 : Activer l'API App Distribution Tester

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

  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 à l'API, que vous pouvez inclure dans toutes les variantes de compilation.
  • firebase-appdistribution : implémentation complète du SDK (facultative).

La bibliothèque réservée à l'API 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 builds Play, ajoutez la dépendance de la bibliothèque réservée à l'API à toutes les variantes de compilation. N'ajoutez l'implémentation complète du SDK qu'aux variantes destinées exclusivement aux tests préliminaires.

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

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

Vous recherchez un module de bibliothèque spécifique à Kotlin ? Depuis la version d'octobre 2023, les développeurs Kotlin et Java peuvent dépendre du module de bibliothèque principal (pour en savoir plus, consultez la FAQ sur cette initiative).

Étape 3 : Configurer les alertes dans l'application

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

  • Une configuration d'alerte de base qui inclut des boîtes de dialogue prédéfinies de mise à jour de l'application et de connexion à afficher aux testeurs.
  • Une 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 les ont pas encore activées, puis vérifiez si une nouvelle version est disponible. Lorsqu'elle est appelée, la méthode exécute 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 nouvelles versions disponibles que le testeur peut installer.

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

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

    Si la nouvelle version est un Android application PacKage (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 votre testeur, afin qu'elle corresponde mieux à l'apparence de votre application.

L'exemple suivant vérifie si le testeur s'est déjà connecté à son App Distribution compte de testeur. 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 que le testeur s'est 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 votre interface utilisateur 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 de la mise à 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 afin 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 type d'affichage d'état dans l'application ou d'une autre approche.

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

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 poursuivre la mise à jour à partir de votre interface utilisateur 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éer et tester votre implémentation

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

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

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