App Center Distribute – Mises à jour intégrées à l'application Android

App Center Distribute permet à vos utilisateurs d’installer une nouvelle version de l’application lorsque vous la distribuez via App Center. Avec une nouvelle version de l’application disponible, le Kit de développement logiciel (SDK) présente une boîte de dialogue de mise à jour aux utilisateurs pour télécharger ou reporter la nouvelle version. Une fois qu’ils choisissent de mettre à jour, le Kit de développement logiciel (SDK) commence à mettre à jour votre application.

Ajouter des mises à jour dans l’application à votre application

Suivez la section Prise en main si vous n’avez pas encore configuré et démarré le Kit de développement logiciel (SDK) dans votre application.

1. Ajouter le module De distribution App Center

Le Kit de développement logiciel (SDK) App Center est conçu avec une approche modulaire : un développeur doit uniquement intégrer les modules des services qui les intéressent.

1. Ouvrez le fichier build.gradle au niveau de l’application du projet (app/build.gradle) et ajoutez les lignes suivantes après apply plugin.

   dependencies {
      def appCenterSdkVersion = '5.0.6'
      implementation "com.microsoft.appcenter:appcenter-distribute:${appCenterSdkVersion}"
   }
   

   Remarque

   Si la version de votre plug-in Android Gradle est inférieure à 3.0.0, vous devez remplacer l’implémentation par la compilation.

2. Enregistrez votre fichier build.gradle et veillez à déclencher une synchronisation Gradle dans Android Studio.

3. DownloadManager est utilisé pour télécharger les mises à jour. Le Kit de développement logiciel (SDK) App Center applique TLS 1.2 pour améliorer la sécurité.

2. Démarrer « App Center Distribute »

Pour utiliser App Center, optez pour le ou les modules que vous souhaitez utiliser. Par défaut, aucun module n’est démarré et vous devez appeler explicitement chacun d’eux lors du démarrage du Kit de développement logiciel (SDK).

Ajoutez la classe Distribute à votre AppCenter.start() méthode pour démarrer le service De distribution App Center.

AppCenter.start(getApplication(), "{Your App Secret}", Distribute.class);

AppCenter.start(application, "{Your App Secret}", Distribute::class.java)

Vérifiez que vous avez remplacé {Your App Secret} dans l’exemple de code ci-dessus par votre secret d’application. Android Studio suggère automatiquement l’instruction import requise une fois que vous avez ajouté une référence à la classe à la Distributestart() méthode, mais si vous voyez une erreur indiquant que les noms de classes ne sont pas reconnus, ajoutez les lignes suivantes aux instructions d’importation dans votre classe d’activité :

import com.microsoft.appcenter.AppCenter;
import com.microsoft.appcenter.distribute.Distribute;

import com.microsoft.appcenter.AppCenter
import com.microsoft.appcenter.distribute.Distribute

Préparer votre build Google Play

Google Play considère le code de mise à jour dans l’application comme un comportement malveillant même s’il n’est pas utilisé lors de l’exécution. Utilisez une variante du Kit de développement logiciel (SDK) De distribution comme indiqué dans cette section ou supprimez complètement le Kit de développement logiciel (SDK) Distribuer qui contient du code de mise à jour dans l’application avant de soumettre votre application à Google Play. L’échec de cette opération peut entraîner la non-conformité et la suppression de l’application de Google Play. Pour faciliter la tâche, nous fournissons la version du Kit de développement logiciel (SDK) App Center Distribute avec des API simulées, de sorte que la seule modification pour vous est un échange de dépendances.

1. Ouvrez le fichier build.gradle au niveau de l’application du projet (app/build.gradle).

2. Configurez les variantes de build en ajoutant des saveurs de produit :

   android {
       flavorDimensions "distribute"
       productFlavors {
           appCenter {
               dimension "distribute"
           }
           googlePlay {
               dimension "distribute"
           }
       }
   }
   

3. Modifiez le bloc de dépendances pour consommer différentes dépendances en fonction de la saveur du produit :

   dependencies {
       def appCenterSdkVersion = "5.0.6"
       appCenterImplementation "com.microsoft.appcenter:appcenter-distribute:${appCenterSdkVersion}"
       googlePlayImplementation "com.microsoft.appcenter:appcenter-distribute-play:${appCenterSdkVersion}"
   }
   

4. Enregistrez votre fichier build.gradle et veillez à déclencher une synchronisation Gradle dans Android Studio.

5. Vous pouvez modifier la variante de build dans le menu déroulant Build Select Build > Variant ou Générer des variantes dans la barre de fenêtres d’outils.

Vous pouvez en savoir plus sur la configuration des variantes de build dans la documentation Android.

Utiliser un groupe de distribution privé

Par défaut, Distribute utilise un groupe de distribution public. Si vous souhaitez utiliser un groupe de distribution privé, vous devez le définir explicitement via setUpdateTrack l’API.

Distribute.setUpdateTrack(UpdateTrack.PRIVATE);

Distribute.setUpdateTrack(UpdateTrack.PRIVATE)

Lorsque l’application est au premier plan (après Distribute.setUpdateTrack(UpdateTrack.PRIVATE); et AppCenter.start), une fenêtre de navigateur s’ouvre pour authentifier l’utilisateur. Toutes les vérifications de mises à jour suivantes obtiennent la dernière version sur le canal privé.

Si un utilisateur est sur la piste privée, cela signifie qu’après l’authentification réussie, il obtient la dernière version de tous les groupes de distribution privés dont il est membre. Si un utilisateur est sur la piste publique, cela signifie qu’il obtiendra la dernière version de n’importe quel groupe de distribution public.

Désactiver la vérification automatique de la mise à jour

Par défaut, le Kit de développement logiciel (SDK) recherche automatiquement les nouvelles versions :

• Au démarrage de l’application.
• Lorsque l’application passe au premier plan après avoir atteint l’arrière-plan.
• Lors de l’activation du module Distribuer s’il était précédemment désactivé.

Si vous souhaitez vérifier manuellement les nouvelles versions, vous pouvez désactiver la vérification automatique de la mise à jour. Pour ce faire, appelez la méthode suivante avant le démarrage du Kit de développement logiciel (SDK) :

Distribute.disableAutomaticCheckForUpdate();

Distribute.disableAutomaticCheckForUpdate()

Vous pouvez ensuite utiliser l’API checkForUpdate , qui est décrite dans la section suivante.

Rechercher manuellement la mise à jour

Distribute.checkForUpdate();

Distribute.checkForUpdate()

Cela envoie une demande à App Center et affiche une boîte de dialogue de mise à jour si une nouvelle version est disponible.

Personnaliser ou localiser la boîte de dialogue mise à jour dans l’application

1. Personnaliser ou localiser du texte

Vous pouvez facilement fournir vos propres chaînes de ressources si vous souhaitez modifier ou localiser le texte affiché dans la boîte de dialogue de mise à jour. Examinez les fichiers de chaîne dans ce fichier de ressources. Utilisez le même nom/clé de chaîne et spécifiez la valeur localisée à refléter dans la boîte de dialogue dans vos propres fichiers de ressources d’application.

2. Personnaliser la boîte de dialogue de mise à jour

Vous pouvez personnaliser l’apparence de la boîte de dialogue de mise à jour par défaut en implémentant l’interface DistributeListener . Vous devez inscrire l’écouteur avant d’appeler AppCenter.start comme indiqué dans l’exemple suivant :

Distribute.setListener(new MyDistributeListener());
AppCenter.start(...);

Distribute.setListener(MyDistributeListener())
AppCenter.start(...)

Voici un exemple d’implémentation de l’écouteur qui remplace la boîte de dialogue SDK par une boîte de dialogue personnalisée :

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.net.Uri;

import com.microsoft.appcenter.distribute.Distribute;
import com.microsoft.appcenter.distribute.DistributeListener;
import com.microsoft.appcenter.distribute.ReleaseDetails;
import com.microsoft.appcenter.distribute.UpdateAction;

public class MyDistributeListener implements DistributeListener {

    @Override
    public boolean onReleaseAvailable(Activity activity, ReleaseDetails releaseDetails) {

        // Look at releaseDetails public methods to get version information, release notes text or release notes URL
        String versionName = releaseDetails.getShortVersion();
        int versionCode = releaseDetails.getVersion();
        String releaseNotes = releaseDetails.getReleaseNotes();
        Uri releaseNotesUrl = releaseDetails.getReleaseNotesUrl();

        // Build our own dialog title and message
        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(activity);
        dialogBuilder.setTitle("Version " + versionName + " available!"); // you should use a string resource instead, this is just a simple example
        dialogBuilder.setMessage(releaseNotes);

        // Mimic default SDK buttons
        dialogBuilder.setPositiveButton(com.microsoft.appcenter.distribute.R.string.appcenter_distribute_update_dialog_download, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {

                // This method is used to tell the SDK what button was clicked
                Distribute.notifyUpdateAction(UpdateAction.UPDATE);
            }
        });

        // We can postpone the release only if the update isn't mandatory
        if (!releaseDetails.isMandatoryUpdate()) {
            dialogBuilder.setNegativeButton(com.microsoft.appcenter.distribute.R.string.appcenter_distribute_update_dialog_postpone, new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {

                    // This method is used to tell the SDK what button was clicked
                    Distribute.notifyUpdateAction(UpdateAction.POSTPONE);
                }
            });
        }
        dialogBuilder.setCancelable(false); // if it's cancelable you should map cancel to postpone, but only for optional updates
        dialogBuilder.create().show();

        // Return true if you're using your own dialog, false otherwise
        return true;
    }
    
    @Override
    public void onNoReleaseAvailable(Activity activity) {
        Toast.makeText(activity, activity.getString(R.string.no_updates_available), Toast.LENGTH_LONG).show();
    }
}

import android.app.Activity
import android.app.AlertDialog
import com.microsoft.appcenter.distribute.Distribute
import com.microsoft.appcenter.distribute.DistributeListener
import com.microsoft.appcenter.distribute.ReleaseDetails
import com.microsoft.appcenter.distribute.UpdateAction

class MyDistributeListener : DistributeListener {

    override fun onReleaseAvailable(activity: Activity, releaseDetails: ReleaseDetails): Boolean {

        // Look at releaseDetails public methods to get version information, release notes text or release notes URL
        val versionName = releaseDetails.shortVersion
        val versionCode = releaseDetails.version
        val releaseNotes = releaseDetails.releaseNotes
        val releaseNotesUrl = releaseDetails.releaseNotesUrl

        // Build our own dialog title and message
        val dialogBuilder = AlertDialog.Builder(activity)
        dialogBuilder.setTitle("Version $versionName available!") // you should use a string resource instead, this is just a simple example
        dialogBuilder.setMessage(releaseNotes)

        // Mimic default SDK buttons
        dialogBuilder.setPositiveButton(
            com.microsoft.appcenter.distribute.R.string.appcenter_distribute_update_dialog_download
        ) { dialog, which ->
            // This method is used to tell the SDK what button was clicked
            Distribute.notifyUpdateAction(UpdateAction.UPDATE)
        }

        // We can postpone the release only if the update isn't mandatory
        if (!releaseDetails.isMandatoryUpdate) {
            dialogBuilder.setNegativeButton(
                com.microsoft.appcenter.distribute.R.string.appcenter_distribute_update_dialog_postpone
            ) { dialog, which ->
                // This method is used to tell the SDK what button was clicked
                Distribute.notifyUpdateAction(UpdateAction.POSTPONE)
            }
        }
        dialogBuilder.setCancelable(false) // if it's cancelable you should map cancel to postpone, but only for optional updates
        dialogBuilder.create().show()

        // Return true if you're using your own dialog, false otherwise
        return true
    }

    override fun onNoReleaseAvailable(activity: Activity) {
        Toast.makeText(activity, activity.getString(R.string.no_updates_available), Toast.LENGTH_LONG).show()
    }
}

Comme illustré dans l’exemple, vous devez appeler Distribute.notifyUpdateAction(UpdateAction.UPDATE); ou Distribute.notifyUpdateAction(UpdateAction.POSTPONE); si votre écouteur retourne true.

Si vous n’appelez pas notifyUpdateAction , le rappel se répète à chaque changement d’activité.

L’écouteur peut être appelé à nouveau avec la même version si l’activité change avant que l’action de l’utilisateur soit avertie du Kit de développement logiciel (SDK).

Ce comportement est nécessaire pour couvrir les scénarios suivants :

• Votre application est envoyée à l’arrière-plan (par exemple, en appuyant sur HOME), puis reprise dans une activité différente.
• Votre activité est couverte par une autre sans quitter l’application (par exemple, cliquer sur certaines notifications).
• Autres scénarios similaires.

Dans ce cas, l’activité qui héberge la boîte de dialogue peut être remplacée sans interaction utilisateur. Par conséquent, le Kit de développement logiciel (SDK) appelle à nouveau l’écouteur pour pouvoir restaurer la boîte de dialogue personnalisée.

Dans les cas où le SDK recherche des mises à jour et ne trouve aucune mise à jour disponible plus récente que celle actuellement utilisée, un rappel d’interface onNoReleaseAvailableDistributeListener est appelé. Cela vous permet d’exécuter du code personnalisé dans de tels scénarios. L’exemple ci-dessus montre comment afficher le message toast lorsqu’aucune mise à jour n’est trouvée.

Activer ou désactiver App Center Distribute au moment de l’exécution

Vous pouvez activer et désactiver App Center Distribute au moment de l’exécution. Si vous le désactivez, le Kit de développement logiciel (SDK) ne fournit aucune fonctionnalité de mise à jour dans l’application, mais vous pouvez toujours utiliser le service Distribuer dans le portail App Center.

Distribute.setEnabled(false);

Distribute.setEnabled(false)

Pour réactiver App Center Distribute, utilisez la même API, mais passez true en tant que paramètre.

Distribute.setEnabled(true);

Distribute.setEnabled(true)

L’état est conservé dans le stockage de l’appareil dans les lancements d’application.

Cette API est asynchrone, vous pouvez en savoir plus sur cela dans notre guide des API asynchrones App Center .

Vérifier si App Center Distribute est activé

Vous pouvez également vérifier si App Center Distribute est activé ou non :

Distribute.isEnabled();

Distribute.isEnabled()

Cette API est asynchrone, vous pouvez en savoir plus sur cela dans notre guide des API asynchrones App Center .

Activer les mises à jour dans l’application pour les builds de débogage

Par défaut, App Center active les mises à jour dans l’application uniquement pour les builds de mise en production.

Pour activer les mises à jour in-app dans les builds de débogage, appelez la méthode suivante avant AppCenter.start:

Distribute.setEnabledForDebuggableBuild(true);

Distribute.setEnabledForDebuggableBuild(true)

Comment fonctionnent les mises à jour dans l’application ?

La fonctionnalité de mise à jour dans l’application fonctionne comme suit :

1. Cette fonctionnalité fonctionne uniquement avec les builds RELEASE (par défaut) distribuées à l’aide du service Distribution App Center .

2. Une fois que vous avez intégré le Kit de développement logiciel (SDK), générez la version de votre application et chargez-la dans App Center, les utilisateurs de ce groupe de distribution seront avertis de la nouvelle version par e-mail.

3. Lorsque chaque utilisateur ouvre le lien dans son e-mail, l’application est installée sur son appareil. Il est important qu’ils utilisent le lien de l'email pour installer - nous ne prenons pas en charge l'installation manuelle. Lorsqu’une application est téléchargée à partir du lien, le Kit de développement logiciel (SDK) enregistre des informations importantes à partir des cookies pour rechercher les mises à jour ultérieurement ; sinon, le SDK n’a pas ces informations clés.

4. Si l’application définit la piste sur privée, un navigateur s’ouvre pour authentifier l’utilisateur et activer les mises à jour dans l’application. Le navigateur ne s’ouvre plus tant que les informations d’authentification restent valides même lorsque vous revenez au suivi public et revenez à privé ultérieurement. Si l’authentification du navigateur réussit, l’utilisateur est redirigé automatiquement vers l’application. Si la piste est publique (qui est la valeur par défaut), l’étape suivante se produit directement.

5. Une nouvelle version de l’application affiche la boîte de dialogue de mise à jour dans l’application demandant aux utilisateurs de mettre à jour votre application s’il s’agit des éléments suivants :

   • une valeur supérieure de versionCode ou
   • une valeur égale de versionCode mais une valeur différente de versionName.

Comment tester les mises à jour dans l’application ?

Vous devez charger des builds de mise en production (qui utilisent le module Distribuer du Kit de développement logiciel (SDK) App Center vers le portail App Center pour tester les mises à jour dans l’application, en augmentant les numéros de version à chaque fois.

1. Créez votre application dans le portail App Center si ce n’est pas déjà fait.
2. Créez un nouveau groupe de distribution et nommez-le pour vous permettre de reconnaître qu’il est destiné à tester la fonctionnalité de mise à jour dans l’application.
3. Ajoutez-vous (ou toutes les personnes que vous souhaitez inclure sur votre test de la fonctionnalité de mise à jour dans l’application). Utilisez une adresse e-mail nouvelle ou levée pour cela, qui n’a pas été utilisée pour cette application sur App Center. Cela garantit que votre expérience est proche de l’expérience de vos testeurs réels.
4. Créez une nouvelle build de votre application qui inclut App Center Distribute et contient la logique d’installation, comme décrit ci-dessus. Si le groupe est privé, n’oubliez pas de définir la piste de mise à jour privée dans l’application avant de commencer à utiliser l’API setUpdateTrack.
5. Cliquez sur le bouton Distribuer une nouvelle version dans le portail et chargez votre build de l’application.
6. Une fois le chargement terminé, cliquez sur Suivant et sélectionnez le groupe de distribution que vous avez créé comme destination de la distribution de cette application.
7. Passez en revue la distribution et distribuez la build à votre groupe de test dans l’application.
8. Les personnes de ce groupe recevront une invitation à être testeurs de l’application. Une fois l’invitation acceptée, il peut télécharger l’application à partir du portail App Center à partir de son appareil mobile. Une fois les mises à jour dans l’application installées, vous êtes prêt à tester les mises à jour dans l’application.
9. Augmentez la visibilité de votre application avec versionCode.
10. Générez la version finale de votre application et téléchargez une nouvelle compilation de votre application comme vous l’avez fait à l’étape précédente, et distribuez-la au groupe de distribution que vous avez créé précédemment. Les membres du groupe de distribution seront invités à mettre à jour vers une nouvelle version lors du prochain démarrage de l'application.