Informer les testeurs des nouvelles compilations

iOS+ Android

Les SDK iOS et Android Firebase App Distribution sont des versions bêta. Cela signifie que la fonctionnalité peut faire l'objet de modifications susceptibles d'affecter la rétrocompatibilité. Une version bêta n'est soumise à aucun contrat de niveau de service ni à aucun règlement d'obsolescence. Elle peut bénéficier d'une assistance limitée ou aucune.

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 iOS et Android App Distribution pour créer et personnaliser de nouvelles alertes de compilation pour vos testeurs.

Avant de commencer

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

Remarque :Si votre projet Firebase contient plusieurs applications, assurez-vous que l'application que vous souhaitez distribuer avec App Distribution dispose de son propre fichier de configuration google-services.json. Pour en savoir plus, consultez la section Prendre en charge plusieurs environnements.

É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).

Attention :L'implémentation complète du SDK Android App Distribution contient une fonctionnalité d'auto-mise à jour qui peut être considérée comme une violation du Règlement Google Play, même si ce code n'est pas exécuté au moment de l'exécution. Si vous envoyez votre application à Google Play sans supprimer le SDK, elle risque d'être supprimée de Google Play.

La bibliothèque 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é d'auto-mise à jour de l'implémentation complète du SDK dans vos builds 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 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 ? À partir de 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 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 de mise à jour et de connexion prédéfinies à 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 aux 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 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.

   Remarque :L'activation des alertes est un processus ponctuel sur l'appareil de test et persiste lors des mises à jour de votre application. Les alertes restent activées sur l'appareil de test jusqu'à ce que l'application soit désinstallée ou qu'elle appelle la méthode signOutTester.

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 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 s'il a accès à une nouvelle version. 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 de testeur App Distribution. Vous pouvez ainsi choisir d'afficher votre interface utilisateur (UI) 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+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 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 d'é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+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 choisit de procéder à la mise à jour à partir de votre UI 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 distribuant le build aux testeurs à l'aide de la console Firebase.

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

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