Informer les testeurs des nouvelles versions

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

Avant que tu commences

Si vous ne l'avez pas déjà fait, ajoutez Firebase à votre projet Android .

Étape 1 : Activer l'API App Distribution Tester

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

  2. Sous l'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 - La bibliothèque API uniquement, que vous pouvez inclure dans toutes les variantes de build .
  • firebase-appdistribution - L'implémentation complète du SDK (facultatif).

La bibliothèque API uniquement 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 du 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 bibliothèque API uniquement à toutes les variantes de build . Ajoutez uniquement l’implémentation complète du SDK 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-beta12")

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

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 plus de détails, 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 fournie avec des boîtes de dialogue de mise à jour d'application et de connexion prédéfinies à afficher pour les 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 d'activation des alertes prédéfinie aux testeurs qui n'ont pas encore activé les alertes, 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. Vérifie les versions nouvellement disponibles que le testeur doit installer.

  3. Affiche une alerte prédéfinie invitant le testeur à mettre à 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 une application Android 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 attachant 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 build est disponible pour 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 de connexion avancée

Les méthodes signInTester et isTesterSignedIn vous offrent plus de flexibilité pour personnaliser l'expérience de connexion de votre testeur, afin que l'expérience du testeur puisse mieux correspondre à 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 (UI) de connexion uniquement aux testeurs qui ne sont pas encore connectés. Une fois le testeur connecté, vous pouvez appeler updateIfNewReleaseAvailable pour vérifier si le testeur a accès à une nouvelle build.

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

Depuis votre interface utilisateur 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 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 ne fournit pas d'indication de progression du téléchargement. Cela signifie que vous devez implémenter votre propre indication de progression à l'aide de NotificationManager , une sorte 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 interface utilisateur 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 depuis 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 distribuant la version aux testeurs à l'aide de la console Firebase.

Consultez le guide de dépannage de la distribution d’applications 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 plusieurs fois