Erzwingen Sie die Aktualisierung einer Android-App, wenn eine neue Version verfügbar ist

Ich habe eine App im Google Play Store. Wenn eine Update-Version verfügbar ist, wird die ältere Version unbrauchbar. Wenn Benutzer die App nicht aktualisieren, treten sie nicht in die App ein. Wie kann ich Benutzer zwingen, die App zu aktualisieren, wenn eine neue Version verfügbar wird?

Ich stimme dem Punkt von Scott Helme in einer anderen Antwort hier zu. In einigen extremen Situationen (Sicherheitsprobleme, Änderungen an der API ...), in denen die Benutzer unbedingt aktualisiert werden müssen, um die App weiterhin verwenden zu können, können Sie eine einfache Versions-API bereitstellen. Die API würde folgendermaßen aussehen:

versionCheck API:

Parameter anfordern:

• int appVersion

Antwort

1. boolean forceUpgrade
2. boolean recommendUpgrade

Wenn Ihre App gestartet wird, können Sie diese API aufrufen, die in der aktuellen App-Version übergeben wird, und die Antwort des Versions-API-Aufrufs überprüfen.

Wenn dies der Fall forceUpgradeist true, zeigen Sie ein Popup-Dialogfeld mit Optionen an, mit denen Benutzer die App beenden können, oder rufen Sie den Google Play Store auf, um die App zu aktualisieren.

Andernfalls recommendUpgradewird truedas Popup-Dialogfeld mit Optionen zum Aktualisieren oder zur weiteren Verwendung der App angezeigt.

Selbst mit dieser erzwungenen Upgrade-Funktion sollten Sie weiterhin ältere Versionen unterstützen, sofern dies nicht unbedingt erforderlich ist.

Versuchen Sie Folgendes: Zuerst müssen Sie den Playstore-Link anfordern, die aktuelle Version von dort abrufen und dann mit Ihrer aktuellen Version vergleichen.

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

Sie sollten nicht aufhören, eine ältere Version zu unterstützen, sobald eine neue Version herauskommt. Dies führt zu einer schrecklichen Benutzererfahrung. Ich kenne keinen Softwareanbieter, der dies aus gutem Grund tut.

Was passiert, wenn der Benutzer zu diesem Zeitpunkt keine Aktualisierung durchführen kann oder möchte? Sie können Ihre App einfach nicht verwenden, was schlecht ist.

Google bietet keine Option für eine solche Versionsverfolgung, sodass Sie Ihre eigene rollen müssten. Ein einfacher Webdienst zur Rückgabe der aktuellen Live-Version, die Ihre App überprüfen kann, ist ausreichend. Sie können die Version dann aktualisieren und die App erkennt, dass sie veraltet ist. Ich würde nur empfehlen, dies zu verwenden, um Ihre Nutzer schneller als abhängig von Google Play über ein Update zu informieren. Es sollte nicht wirklich verwendet werden, um die Funktion der App zu verhindern, sondern nur, um den Benutzer zum Aktualisieren aufzufordern.

Lösung vom Google-Team

Ab Android 5.0 ist dies mit dem neuen Update-Mechanismus für Google Play In App leicht zu erreichen. Voraussetzung ist, dass Sie über die Play Core-Bibliothek der Version 1.5.0+ verfügen und anstelle von apks die ID-Verteilung der App-Bundles verwenden.

Die Bibliothek bietet Ihnen zwei verschiedene Möglichkeiten, um die Benutzer über das Update zu informieren:

1. Flexibel, wenn Benutzer die App weiterhin verwenden können, während sie im Hintergrund aktualisiert wird.

2. Sofortiger Blockierungsbildschirm, auf dem ein Benutzer die App erst betreten kann, wenn er sie aktualisiert.

Es gibt die nächsten Schritte, um es zu implementieren:

1. Überprüfen Sie die Verfügbarkeit von Updates
2. Starten Sie ein Update
3. Erhalten Sie einen Rückruf für den Aktualisierungsstatus
4. Behandeln Sie das Update

Alle diese Schrittimplementierungen werden auf der offiziellen Website ausführlich beschrieben: https://developer.android.com/guide/app-bundle/in-app-updates

Die Antworten von Scott und Michael sind richtig. Hosten Sie einen Dienst, der eine von Ihnen unterstützte Mindestversionsnummer bereitstellt, und vergleichen Sie diese mit der installierten Version. Sie sollten dies hoffentlich nie brauchen, aber es ist ein Lebensretter, wenn eine Version da draußen ist, müssen Sie unbedingt wegen eines schwerwiegenden Fehlers töten.

Ich wollte nur den Code für die nächsten Schritte hinzufügen. So starten Sie dann Google Play Intent und bringen sie zu Ihrer neuen Version im Store, nachdem Sie den Nutzer aufgefordert haben, ein Upgrade durchzuführen.

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

            }
        });
    }
}

Sie sollten Ihr Design überdenken, wenn Sie Upgrades für jede Version erzwingen müssen.

Google hat die In-App-Updates lib eingeführt ( https://developer.android.com/guide/app-bundle/in-app-updates ). Es funktioniert auf Lollipop + und bietet Ihnen die Möglichkeit, den Benutzer nach einem Update mit einem netten zu fragen Dialog (FLEXIBLE) oder mit obligatorischer Vollbildmeldung (IMMEDIATE).

Letzteres müssen Sie implementieren. So wird es aussehen:

Ich habe den gesamten Code in dieser Antwort behandelt: https://stackoverflow.com/a/56808529/5502121

Ich empfehle dringend, die Remote Config- Funktionalität von Firebase zu überprüfen .

Ich habe es mit einem Parameter implementiert - app_version_enabled - mit der Bedingung "Disabled Android Versions", die folgendermaßen aussieht:

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

Die Standardeinstellung für den Parameter ist "true", deaktivierte Android-Versionen haben jedoch den Wert false. In meinem regulären Ausdruck für deaktivierte Android-Versionen können Sie weitere deaktivierte Versionen einfach mit einer anderen |{version name}in diesen Klammern hinzufügen .

Dann überprüfe ich einfach, ob in der Konfiguration angegeben ist, dass die Version aktiviert ist oder nicht. Ich starte eine Aktivität, die den Benutzer zum Upgrade zwingt. Ich überprüfe nur die zwei Stellen, an denen die App extern gestartet werden kann (meine Standard-Launcher-Aktivität und eine Intent-Handling-Aktivität). Da Remote Config auf Cache-Basis arbeitet, werden "deaktivierte" Versionen der App nicht sofort erfasst, wenn die erforderliche Zeit für die Ungültigmachung des Caches nicht verstrichen ist. Dies sind jedoch höchstens 12 Stunden, wenn Sie vorbeikommen den empfohlenen Cache-Ablaufwert.

Offiziell bietet Google hierfür eine Android-API an.

Die API wird derzeit mit einer Handvoll Partnern getestet und wird bald allen Entwicklern zur Verfügung stehen.

Die Update- API ist ab sofort verfügbar - https://developer.android.com/guide/app-bundle/in-app-updates

überprüfe den Versionscode von local und play store apk

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

Klasse für Versionsprüfung implementieren

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

Dialob-Box zum Update

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

Dialoglayout

<?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>

Es ist besser, unseren eigenen Prozess für das Upgrade zu definieren.

1. Erstellen Sie einen Webdienst, der die neueste Version für die App (ios, android) von unserem Server bereitstellt.
2. Oder Jeder Webdienst, den Sie in der App verwendet haben (z. B. Login), gibt die neueste App-Version vom Server zurück.
3. Sobald die App die Version von # 1 oder 2 erhält, überprüft die App sie mit der lokalen / aktuellen Appversion. Wenn es einen Unterschied gibt, können wir die Warnung wie folgt anzeigen:

Android & iOS: Wenn die neueste App-Version verfügbar ist, wird die Warnung als "Neueste verfügbare Version mit mehr Funktionen" angezeigt. Um ein Upgrade durchzuführen, klicken Sie auf die Schaltfläche "Upgrade" (Warnung mit "Upgarde" und "Nein, danke"). Die App leitet dann weiter Playstore / Appstore und es wird die neueste Version geöffnet.

 --- we can do upgrade compulsory or optionally.

Stellen Sie vor dem Upgrade sicher, dass Sie den ordnungsgemäßen Datenbankmigrationsprozess durchgeführt haben, wenn sich das Datenbankschema ändert.

Um den App-Benutzer zum Aktualisieren zu zwingen, wenn ein Update auf dem Markt verfügbar ist, sollten Sie zuerst die App-Version auf dem Markt überprüfen und mit der Version der App auf dem Gerät vergleichen. Wenn sie unterschiedlich sind, ist möglicherweise ein Update verfügbar. In diesem Beitrag habe ich den Code zum Abrufen der aktuellen Marktversion und der aktuellen Version auf dem Gerät aufgeschrieben und miteinander verglichen. Ich habe auch gezeigt, wie der Aktualisierungsdialog angezeigt und der Benutzer zur Aktualisierungsseite umgeleitet wird. Bitte besuchen Sie diesen Link: https://stackoverflow.com/a/33925032/5475941 Stellen Sie einfach sicher, dass im Dialogfeld nur die Schaltfläche zum Aktualisieren des Benutzers und nicht die Schaltfläche zum Abbrechen angezeigt wird. In diesem Fall muss er ein Update durchführen, bevor er die App verwenden kann.

Was hier unbedingt erwähnt werden sollte, ist die in Kürze veröffentlichte In-App-Update-API .

Mit dieser API haben Sie zwei Möglichkeiten. Das erste ist eine Vollbild-Erfahrung für kritische Updates, wenn Sie erwarten, dass der Benutzer darauf wartet, dass das Update sofort angewendet wird. Die zweite Option ist ein flexibles Update. Dies bedeutet, dass der Benutzer die App weiterhin verwenden kann, während das Update heruntergeladen wird. Sie können den Update-Ablauf vollständig anpassen, sodass er sich als Teil Ihrer App anfühlt.

Es ist eine gute Idee, die Remote-Konfiguration für die App-Version zu verwenden und die Startaktivität immer zu überprüfen, ob die aktuelle App-Version mit der Remote-Version identisch ist oder nicht, wenn keine Aktualisierung aus dem App Store erzwungen wird.

Einfache Logik Happy Coding ..

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

Sie können die In-App-Updates der Play Core Library verwenden, um dies zu beheben. Sie können die Verfügbarkeit von Updates überprüfen und diese installieren, falls sie nahtlos verfügbar sind.

In-App-Updates sind nicht mit Apps kompatibel, die APK-Erweiterungsdateien (OBB-Dateien) verwenden. Sie können entweder flexible Downloads oder sofortige Updates durchführen, die Google Play für Sie herunterlädt und installiert.

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

Verweisen Sie auf diese Antwort https://stackoverflow.com/a/58212818/7579041

Sie können dies tun, indem Sie eine Übereinstimmung zwischen einer Versionsnummer herstellen, die in einer Variablen in der App gespeichert ist, und in ähnlicher Weise die aktuelle App-Version auf der Serverseite. Jedes Mal, wenn der Benutzer die App öffnet, sollte die erste Anforderung gesendet werden, um zu überprüfen, ob sie gefunden wurde Beim Matching kann der Benutzer Ihre App nicht verwenden, da er sonst eine Absicht für den Google Playstore auslöst oder ein Webansichtsfenster für Ihre App öffnet (window.open (" https://play.google.com/store/apps/details?id= ") package_name ", '_system', 'location = yes');) und dort wird automatisch die Schaltfläche angezeigt, die nach Updates fragt. Dies ist, was Google Playstore für Sie tut, wenn Sie keine automatischen Updates haben.

Sie können Ihre Benutzer benachrichtigen, dass eine neue Version der aktuellen App zum Aktualisieren verfügbar ist. Wenn diese Bedingung erfüllt ist, können Sie die Anmeldung in der App blockieren.

Bitte prüfen Sie, ob dies die Lösung für Sie darstellt.

Nun, es könnte viele Lösungen für dieses Problem geben, wie das Abkratzen des Versionscodes von der App-Seite (Google Play App-Seite) usw.

Aber ich werde Ihnen die ultimative Lösung zeigen, die keinen Cent kostet und wie Magie funktioniert.

1. Speichern Sie einfach den neuesten Versionscode Ihrer App im Firebase Remote
   Config-Bereich
2. Rufen Sie diesen Versionscode ab, wenn die App geöffnet wird

3. Vergleichen Sie es mit dem aktuellen Versionscode der App, den Sie mit dem folgenden Code erhalten

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

   }}

Wenn der abgerufene Versionscode größer als die aktuelle Version ist, zeigen Sie einen AlertDialog an, in dem Sie aufgefordert werden, die App zu aktualisieren. Ansonsten ist die App bereits aktualisiert.

Wenn Sie die neue Version einführen, müssen Sie diesen neuen Versionscode in das Firebase Remote-Konfigurationsfenster einfügen

Sie können das gesamte Tutorial lesen, wie Benutzer gezwungen werden, die App mit Firebase Remote Config zu aktualisieren

Google hat In-App-Updates für die Play Core-Bibliothek veröffentlicht.

Ich habe eine einfache Bibliothek implementiert, um In-App-Updates einfach zu implementieren. Unter dem folgenden Link finden Sie ein Beispiel, wie Sie den Benutzer zwingen können, das Update durchzuführen.

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