Forcer la mise à jour d'une application Android lorsqu'une nouvelle version est disponible

J'ai une application sur Google Play Store. Lorsqu'une version de mise à jour est disponible, l'ancienne version deviendra inutilisable - c'est-à-dire que si les utilisateurs ne mettent pas à jour l'application, ils n'entrent pas dans l'application. Comment puis-je forcer les utilisateurs à mettre à jour l'application lorsqu'une nouvelle version est disponible?

Je suis d'accord avec le point de Scott Helme dans une autre réponse ici. Mais dans certaines situations extrêmes (problèmes de sécurité, changements de rupture d'API ...) où vous avez absolument besoin que les utilisateurs se mettent à jour pour continuer à utiliser l'application, vous pouvez fournir une API de contrôle de version simple. L'API ressemblerait à ceci:

versionCheck API:

Paramètres de la demande:

• int appVersion

Réponse

1. boolean forceUpgrade
2. boolean recommendUpgrade

Lorsque votre application démarre, vous pouvez appeler cette API qui transmet la version actuelle de l'application et vérifier la réponse de l'appel d'API de contrôle de version.

Si tel forceUpgradeest le cas true, affichez une boîte de dialogue contextuelle avec des options permettant à l'utilisateur de quitter l'application ou d'accéder à Google Play Store pour mettre à niveau l'application.

Sinon , si recommendUpgradeest true, afficher la boîte de dialogue pop-up avec des options pour mettre à jour ou de continuer à utiliser l'application.

Même avec cette capacité de mise à niveau forcée en place, vous devez continuer à prendre en charge les anciennes versions, à moins que cela ne soit absolument nécessaire.

essayez ceci: vous devez d'abord effectuer une demande d'appel vers le lien Playstore, récupérer la version actuelle à partir de là, puis la comparer avec votre version actuelle.

String currentVersion, latestVersion;
Dialog dialog;
private void getCurrentVersion(){
 PackageManager pm = this.getPackageManager();
        PackageInfo pInfo = null;

        try {
            pInfo =  pm.getPackageInfo(this.getPackageName(),0);

        } catch (PackageManager.NameNotFoundException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        currentVersion = pInfo.versionName;

   new GetLatestVersion().execute();

}

private class GetLatestVersion extends AsyncTask<String, String, JSONObject> {

        private ProgressDialog progressDialog;

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        @Override
        protected JSONObject doInBackground(String... params) {
            try {
//It retrieves the latest version by scraping the content of current version from play store at runtime
                Document doc = Jsoup.connect(urlOfAppFromPlayStore).get();
                latestVersion = doc.getElementsByClass("htlgb").get(6).text();

            }catch (Exception e){
                e.printStackTrace();

            }

            return new JSONObject();
        }

        @Override
        protected void onPostExecute(JSONObject jsonObject) {
            if(latestVersion!=null) {
                if (!currentVersion.equalsIgnoreCase(latestVersion)){
                   if(!isFinishing()){ //This would help to prevent Error : BinderProxy@45d459c0 is not valid; is your activity running? error
                    showUpdateDialog();
                    }
                }
            }
            else
                background.start();
            super.onPostExecute(jsonObject);
        }
    }

private void showUpdateDialog(){
        final AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("A New Update is Available");
        builder.setPositiveButton("Update", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse
                        ("market://details?id=yourAppPackageName")));
                dialog.dismiss();
            }
        });

        builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                background.start();
            }
        });

        builder.setCancelable(false);
        dialog = builder.show();
    }

Vous ne devriez pas arrêter de prendre en charge une version plus ancienne dès qu'une nouvelle version sort. Cela se traduira par une expérience utilisateur terrible. Je ne connais aucun éditeur de logiciel qui fasse cela, pour une bonne raison.

Que se passe-t-il si l'utilisateur ne peut pas mettre à jour ou ne le souhaite pas à ce moment-là? Ils ne peuvent tout simplement pas utiliser votre application, ce qui est mauvais.

Google ne propose aucune option pour le suivi des versions de ce type, vous devrez donc lancer le vôtre. Un simple service Web pour renvoyer la version actuelle en direct que votre application peut vérifier serait suffisant. Vous pouvez ensuite mettre à jour la version et l'application saura qu'elle est obsolète. Je recommanderais uniquement de l'utiliser pour informer vos utilisateurs qu'il y a une mise à jour plus rapidement que selon Google Play. Il ne doit pas vraiment être utilisé pour empêcher l'application de fonctionner, juste pour inviter l'utilisateur à mettre à jour.

Solution de l'équipe Google

À partir d'Android 5.0, cela est facilement réalisable grâce au nouveau mécanisme de mise à jour de Google Play In App. Les exigences sont d'avoir la bibliothèque Play Core de la version 1.5.0+ et d'utiliser l'idstribution App Bundles au lieu d'apks.

La bibliothèque vous propose 2 manières différentes d'informer les utilisateurs de la mise à jour:

1. Flexible, lorsque les utilisateurs peuvent continuer à utiliser l'application pendant qu'elle est mise à jour en arrière-plan.

2. Immédiat - écran de blocage qui ne permet pas à un utilisateur d'entrer dans l'application jusqu'à ce qu'il la mette à jour.

Il y a les prochaines étapes pour le mettre en œuvre:

1. Vérifier la disponibilité des mises à jour
2. Lancer une mise à jour
3. Obtenez un rappel pour l'état de la mise à jour
4. Gérez la mise à jour

Toutes ces étapes de mise en œuvre sont décrites en détail sur le site officiel: https://developer.android.com/guide/app-bundle/in-app-updates

Les réponses de Scott et Michael sont correctes. Hébergez un service qui fournit un numéro de version minimale que vous prenez en charge et comparez-le à la version installée. J'espère que vous ne devriez jamais avoir besoin de l'utiliser, mais c'est une bouée de sauvetage si une version existe, vous devez absolument tuer en raison d'un défaut grave.

Je voulais juste ajouter le code pour ce qu'il faut faire ensuite. Voici comment vous lancez ensuite Google Play Intent et les amenez à votre nouvelle version dans le magasin après avoir invité l'utilisateur à mettre à niveau.

public class UpgradeActivity extends Activity {
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_upgrade);
        final String appName = "com.appname";
        Button button = (Button) findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                    startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id="+appName)));

            }
        });
    }
}

Vous devriez reconsidérer votre conception si vous devez forcer les mises à niveau à chaque version.

Google a introduit la bibliothèque de mises à jour dans l'application, ( https://developer.android.com/guide/app-bundle/in-app-updates ), elle fonctionne sur Lollipop + et vous donne la possibilité de demander à l'utilisateur une mise à jour avec un joli dialogue (FLEXIBLE) ou avec un message plein écran obligatoire (IMMEDIATE).

Vous devez mettre en œuvre ce dernier. Voici à quoi cela ressemblera:

J'ai couvert tout le code dans cette réponse: https://stackoverflow.com/a/56808529/5502121

Je recommande vivement de vérifier la configuration à distance de Firebase pour cela.

Je l'ai implémenté en utilisant un paramètre - app_version_enabled - avec une condition "Versions Android désactivées" qui ressemble à ceci:

applies if App ID == com.example.myapp and App version regular expression ^(5.6.1|5.4.2) 

La valeur par défaut du paramètre est "true", mais les versions Android désactivées ont la valeur false. Dans mon regex pour les versions Android désactivées, vous pouvez ajouter plus de versions désactivées simplement avec un autre|{version name} intérieur de ces parenthèses.

Ensuite, je vérifie simplement si la configuration indique que la version est activée ou non - j'ai une activité que je lance qui oblige l'utilisateur à mettre à niveau. Je vérifie les deux seuls endroits où l'application peut être lancée de l'extérieur (mon activité de lanceur par défaut et une activité de gestion des intentions). Étant donné que Remote Config fonctionne sur la base du cache, il ne capturera pas immédiatement les versions «désactivées» de l'application si le temps requis ne s'est pas écoulé pour que le cache soit invalidé, mais c'est au plus 12 heures si vous passez leur valeur d'expiration de cache recommandée.

Officiellement, Google fournit une API Android pour cela.

L'API est actuellement testée avec une poignée de partenaires et sera bientôt disponible pour tous les développeurs.

L' API de mise à jour est maintenant disponible - https://developer.android.com/guide/app-bundle/in-app-updates

vérifier le code de version de l'apk local et play store

try {
        versionChecker VersionChecker = new versionChecker();
        String versionUpdated = VersionChecker.execute().get().toString();
        Log.i("version code is", versionUpdated);


        PackageInfo packageInfo = null;
        try {
            packageInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        int version_code = packageInfo.versionCode;
        String version_name = packageInfo.versionName;
        Log.i("updated version code", String.valueOf(version_code) + "  " + version_name);
        if (version_name != versionUpdated) {
            String packageName = getApplicationContext().getPackageName();//
            UpdateMeeDialog updateMeeDialog = new UpdateMeeDialog();
            updateMeeDialog.showDialogAddRoute(MainActivity.this, packageName);
            Toast.makeText(getApplicationContext(), "please updated", Toast.LENGTH_LONG).show();
        }
    } catch (Exception e) {
        e.getStackTrace();
    }

classe d'implémentation pour la vérification de version

class versionChecker extends AsyncTask<String, String, String> {
String newVersion;

@Override
protected String doInBackground(String... params) {

    try {
        newVersion = Jsoup.connect("https://play.google.com/store/apps/details?id=+YOR_PACKAGE_NAME+&hl=en")
                .timeout(30000)
                .userAgent("Mozilla/5.0 (Windows; U; WindowsNT 5.1; en-US; rv1.8.1.6) Gecko/20070725 Firefox/2.0.0.6")
                .referrer("http://www.google.com")
                .get()
                .select("div[itemprop=softwareVersion]")
                .first()
                .ownText();
    } catch (IOException e) {
        e.printStackTrace();
    }

    return newVersion;
}
}

boîte de dialogue pour la mise à jour

public class UpdateMeeDialog {

ActivityManager am;
TextView rootName;
Context context;
Dialog dialog;
String key1,schoolId;
public void showDialogAddRoute(Activity activity, final String packageName){
    context=activity;
    dialog = new Dialog(context);

    dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
    dialog.setCancelable(false);
    dialog.setContentView(R.layout.dialog_update);
    am = (ActivityManager)activity.getSystemService(Context.ACTIVITY_SERVICE);

    Button cancelDialogue=(Button)dialog.findViewById(R.id.buttonUpdate);
    Log.i("package name",packageName);
    cancelDialogue.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            Intent intent=new Intent(Intent.ACTION_VIEW);                
    intent.setData(Uri.parse("https://play.google.com/store/apps/details?
    id="+packageName+"&hl=en"));
            context.startActivity(intent);
        }
    });
    dialog.show();
}
}

présentation de la boîte de dialogue

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#d4e9f2">


<TextView
    android:layout_width="match_parent"
    android:layout_height="40dp"

    android:text="Please Update First..!!"
    android:textSize="20dp"
    android:textColor="#46a5df"
    android:textAlignment="center"
    android:layout_marginTop="50dp"
    android:id="@+id/textMessage"
    />
<LinearLayout
    android:layout_width="match_parent"
    android:orientation="horizontal"
    android:weightSum="1"
    android:layout_marginTop="50dp"
    android:layout_below="@+id/textMessage"
    android:layout_height="50dp">

    <Button
        android:id="@+id/buttonUpdate"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="Update"
        android:background="#67C6F1"
        android:textAlignment="center" />
</LinearLayout>

Il est préférable de définir notre propre processus pour la mise à niveau.

1. Créez un service Web qui donne la dernière version de l'application (iOS, Android) à partir de notre serveur.
2. Ou Tout service Web que vous avez utilisé dans l'application (par exemple, Connexion) renverra la dernière version de l'application à partir du serveur.
3. Une fois que l'application obtiendra la version n ° 1 ou 2. L'application la vérifiera avec l'application locale / actuelle. s'il y a une différence, nous pouvons afficher l'alerte comme suit,

Android et iOS: si la dernière version de l'application est disponible, l'alerte sera affichée sous la forme "Dernière version disponible avec plus de fonctionnalités, pour mettre à niveau, cliquez sur le bouton de mise à niveau" (Alerte avec le bouton "Upgarde" et "Non. Merci".) Ensuite, l'application sera redirigée vers playstore / Appstore et il ouvrira la dernière version.

 --- we can do upgrade compulsory or optionally.

Avant le processus de mise à niveau, veuillez vous assurer que vous avez géré le processus de migration de base de données approprié en cas de changement de schéma de base de données.

Pour forcer l'utilisateur de l'application à se mettre à jour si une mise à jour est disponible sur le marché, vous devez d'abord vérifier la version de l'application sur le marché et la comparer avec la version de l'application sur l'appareil. S'ils sont différents, il peut s'agir d'une mise à jour disponible. Dans cet article, j'ai écrit le code pour obtenir la version actuelle du marché et la version actuelle sur l'appareil et les comparer ensemble. J'ai également montré comment afficher la boîte de dialogue de mise à jour et rediriger l'utilisateur vers la page de mise à jour. Veuillez visiter ce lien: https://stackoverflow.com/a/33925032/5475941 Assurez-vous simplement que dans la boîte de dialogue vous n'affichez que le bouton de mise à jour de l'utilisateur et ne lui montrez pas le bouton d'annulation. Dans ce cas, il sera obligé de se mettre à jour avant de pouvoir utiliser l'application.

Ce qu'il faut absolument mentionner ici, c'est l' API de mises à jour in-app qui sera bientôt disponible .

Vous aurez deux options avec cette API; la première est une expérience en plein écran pour les mises à jour critiques lorsque vous vous attendez à ce que l'utilisateur attende que la mise à jour soit appliquée immédiatement. La deuxième option est une mise à jour flexible, ce qui signifie que l'utilisateur peut continuer à utiliser l'application pendant le téléchargement de la mise à jour. Vous pouvez personnaliser complètement le flux de mise à jour pour qu'il fasse partie de votre application.

Il est judicieux d'utiliser la configuration à distance pour la version de l'application et de toujours vérifier l'activité de lancement si la version actuelle de l'application est la même que la version distante ou non si ce n'est pas forcer la mise à jour depuis l'App Store.

Logique simple codage heureux.

https://firebase.google.com/docs/remote-config/android

Vous pouvez utiliser les mises à jour de l'application Play Core Library pour résoudre ce problème. Vous pouvez vérifier la disponibilité des mises à jour et les installer si elles sont disponibles de manière transparente.

Les mises à jour intégrées aux applications ne sont pas compatibles avec les applications qui utilisent des fichiers d'extension APK (fichiers .obb). Vous pouvez opter pour des téléchargements flexibles ou des mises à jour immédiates que Google Play se charge de télécharger et d'installer la mise à jour pour vous.

dependencies {
    implementation 'com.google.android.play:core:1.5.0'
    ...
}

Référez-vous à cette réponse https://stackoverflow.com/a/58212818/7579041

vous pouvez le faire en faisant une correspondance entre un numéro de version qui est conservé sur l'application dans une variable et de même la version actuelle de l'application est conservée côté serveur et chaque fois que l'utilisateur ouvre l'application, la première demande doit être envoyée pour vérifier que si elle trouve correspondant ne rien faire, laissez simplement l'utilisateur utiliser votre application, sinon déclenchez une intention sur le Google Playstore ou ouvrez une fenêtre d'affichage Web sur votre application (window.open (" https://play.google.com/store/apps/details?id= package_name ", '_system', 'location = yes');) et là, ils auront automatiquement le bouton demandant la mise à jour, c'est ce que google playstore fait pour vous si vous n'avez pas de mises à jour automatiques.

Vous pouvez informer vos utilisateurs qu'une nouvelle version de l'application actuelle est disponible pour mise à jour. De plus, si cette condition est vraie, vous pouvez bloquer la connexion dans l'application.

Veuillez voir si cela vous fournit la solution.

Eh bien, il pourrait y avoir de nombreuses solutions à ce problème, telles que la récupération du code de version de la page de l'application (page de l'application Google Play), etc.

Mais je vais vous montrer la solution ultime qui ne coûtera pas un centime et fonctionnera comme par magie.

1. Enregistrez simplement le dernier code de version de votre application sur Firebase Remote
   panneau Config
2. Récupérer cette valeur de code de version chaque fois que l'application est ouverte

3. Comparez-le avec le code de la version actuelle de l'application, que vous pouvez obtenir par le code suivant

   private int getCurrentVersionCode() {
   try {
       return getPackageManager().getPackageInfo(getPackageName(), 0).versionCode;
   } catch (NameNotFoundException e) {
       e.printStackTrace();
   }
   return -1;

   }

Si le code de version récupéré est supérieur à la version actuelle, affichez un AlertDialog demandant de mettre à jour l'application. Sinon, l'application est déjà mise à jour.

Ainsi, chaque fois que vous déployez la nouvelle version, vous devez mettre ce nouveau code de version dans le panneau de configuration de Firebase Remote.

Vous pouvez lire l'intégralité du didacticiel sur la façon de forcer les utilisateurs à mettre à jour l'application à l'aide de Firebase Remote Config

Google a publié des mises à jour intégrées à l'application pour la bibliothèque Play Core.

J'ai implémenté une bibliothèque légère pour implémenter facilement les mises à jour dans l'application. Vous pouvez trouver sur le lien suivant un exemple sur la façon de forcer l'utilisateur à effectuer la mise à jour.

https://github.com/dnKaratzas/android-inapp-update#forced-updates