Informer les testeurs des nouvelles compilations


Les SDK Firebase App Distribution et Android facultatifs vous permettent d'afficher des alertes intégrées à vos testeurs lorsque de nouvelles versions de votre application sont disponibles ; l'installation. Ce guide explique comment utiliser les SDK App Distribution pour 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 : Ajoutez 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 orientée API permet à votre code d'appeler le 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 votre module (au niveau de l'application) fichier Gradle (généralement <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle). Pour éviter d'inclure le SDK complet la fonctionnalité de mise à jour automatique de votre implémentation dans vos builds Play, ajouter la dépendance de bibliothèque d'API uniquement variantes de compilation. N'ajoutez l'implémentation complète du SDK qu'aux variantes destinées exclusivement aux tests en version préliminaire.

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

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

Vous recherchez un module de bibliothèque spécifique à Kotlin ? En commençant par Version d'octobre 2023, Les développeurs Kotlin et Java peuvent dépendre du module de la bibliothèque principale Pour en savoir plus, consultez les questions fréquentes sur cette initiative).

Étape 3: Configurez des alertes dans l'application

Le SDK Android App Distribution fournit 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 de mise à jour et de connexion prédéfinies à afficher aux testeurs.
  • Une configuration d'alerte avancée qui vous permet de personnaliser votre propre compte utilisateur de commande.

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

Utiliser updateIfNewReleaseAvailable pour afficher des alertes d'activation prédéfinies aux testeurs qui n'ont pas encore activé les alertes, puis vérifiez si 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é des alertes, la méthode invite le testeur à se connecter à App Distribution avec leur compte Google.

  2. Recherche les nouveaux builds 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 le nouveau build est un APK (Android PacKage), le SDK télécharge la nouvelle compilation 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. Pour Par exemple, vous pouvez appeler updateIfNewReleaseAvailable pendant la 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 compilation. Si ces conditions sont remplies, une boîte de dialogue s'affiche lorsque la compilation est disponible à l'installation :

Kotlin+KTX 

// 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 permettent de personnaliser plus facilement l'expérience de connexion des 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 App Distribution compte de testeur. Vous pouvez ainsi choisir d'afficher votre interface utilisateur (UI) de connexion uniquement aux testeurs qui ne se sont pas encore connectés. Après le testeur se connecte, vous pouvez ensuite appeler updateIfNewReleaseAvailable pour vérifier si le testeur a accès à une nouvelle compilation.

Kotlin+KTX 

// 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+KTX 

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 de mise à jour avancée

Les méthodes checkForNewRelease et updateApp vous permettent de personnaliser plus facilement le moment où votre testeur est invité à effectuer la 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 ne fournit pas d'indication de la progression du téléchargement. Cela signifie que vous devez implémenter votre propre indication de progression NotificationManager, un type d'affichage de l'état dans l'application ou 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+KTX 

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 décide de procéder à la mise à jour à partir de votre interface utilisateur de mise à jour, appelez updateApp():

Kotlin+KTX 

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 distribuer la compilation aux testeurs à l'aide de la console Firebase.

Consultez le App Distribution Guide de dépannage pour obtenir de l'aide concernant des problèmes courants, par exemple:

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