Wymuś aktualizację aplikacji na Androida, gdy dostępna jest nowa wersja

Mam aplikację w sklepie Google Play. Gdy dostępna jest wersja aktualizacyjna, starsza wersja stanie się bezużyteczna - to znaczy, jeśli użytkownicy nie zaktualizują aplikacji, nie wejdą do aplikacji. Jak zmusić użytkowników do zaktualizowania aplikacji, gdy pojawi się nowa wersja?

Zgadzam się z punktem Scotta Helme w innej odpowiedzi tutaj. Jednak w niektórych ekstremalnych sytuacjach (problemy z bezpieczeństwem, zmiany powodujące zerwanie interfejsu API ...), w których użytkownicy muszą koniecznie zaktualizować aplikację, aby nadal korzystać z aplikacji, można zapewnić prosty interfejs API do obsługi wersji. Interfejs API wyglądałby następująco:

versionCheck API:

Parametry żądania:

• int appVersion

Odpowiedź

1. boolean forceUpgrade
2. boolean recommendUpgrade

Po uruchomieniu aplikacji możesz wywołać ten interfejs API, który przekazuje bieżącą wersję aplikacji, i sprawdzić odpowiedź na wywołanie interfejsu API do obsługi wersji.

Jeśli forceUpgradetak true, pokaż wyskakujące okno dialogowe z opcjami umożliwiającymi użytkownikowi zamknięcie aplikacji lub przejdź do sklepu Google Play, aby zaktualizować aplikację.

W przeciwnym razie , jeśli recommendUpgradetak true, pokaż wyskakujące okno dialogowe z opcjami aktualizacji lub kontynuowania korzystania z aplikacji.

Nawet przy tej wymuszonej możliwości aktualizacji powinieneś nadal obsługiwać starsze wersje, chyba że jest to absolutnie konieczne.

spróbuj tego: Najpierw musisz wykonać żądanie połączenia z linkiem do sklepu playstore, pobrać stamtąd aktualną wersję, a następnie porównać ją z aktualną wersją.

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

Nie należy przerywać obsługi starszej wersji, gdy tylko pojawi się nowa wersja. Spowoduje to straszne wrażenia użytkownika. Nie znam żadnego dostawcy oprogramowania, który to robi, nie bez powodu.

Co się stanie, jeśli użytkownik nie może zaktualizować lub nie chce w tym czasie? Po prostu nie mogą korzystać z Twojej aplikacji, co jest złe.

Google nie zapewnia żadnej opcji śledzenia wersji, więc trzeba by było stworzyć własną. Prosta usługa internetowa zwracająca aktualną wersję na żywo, którą może sprawdzić Twoja aplikacja, byłaby wystarczająca. Następnie możesz zaktualizować wersję, a aplikacja będzie wiedzieć, że jest nieaktualna. Zalecam używanie tego tylko po to, aby poinformować użytkowników, że aktualizacja jest dostępna szybciej niż w przypadku Google Play. Tak naprawdę nie należy go używać do uniemożliwienia działania aplikacji, a jedynie do wezwania użytkownika do aktualizacji.

Rozwiązanie od zespołu Google

Począwszy od Androida 5.0, można to łatwo osiągnąć dzięki nowemu mechanizmowi aktualizacji Google Play w aplikacji. Wymagane jest posiadanie biblioteki Play Core w wersji 1.5.0+ i używanie idstribution pakietów aplikacji zamiast apek.

Biblioteka zapewnia 2 różne sposoby powiadamiania użytkowników o aktualizacji:

1. Elastyczny, gdy użytkownicy mogą nadal korzystać z aplikacji, gdy jest ona aktualizowana w tle.

2. Natychmiastowy - ekran blokujący, który nie pozwala użytkownikowi wejść do aplikacji, dopóki jej nie zaktualizują.

Istnieją kolejne kroki, aby to wdrożyć:

1. Sprawdź dostępność aktualizacji
2. Rozpocznij aktualizację
3. Uzyskaj oddzwonienie w celu uzyskania informacji o stanie aktualizacji
4. Obsługuj aktualizację

Wszystkie implementacje tych kroków są szczegółowo opisane na oficjalnej stronie: https://developer.android.com/guide/app-bundle/in-app-updates

Odpowiedzi Scotta i Michaela są poprawne. Hostuj usługę, która zapewnia minimalny obsługiwany numer wersji i porównaj go z wersją zainstalowaną. Miejmy nadzieję, że nigdy nie powinieneś tego używać, ale to ratuje życie, jeśli jest jakaś wersja, którą absolutnie musisz zabić z powodu poważnej usterki.

Chciałem tylko dodać kod, co dalej. Oto sposób, w jaki możesz następnie uruchomić zamiar Google Play i przenieść je do nowej wersji w sklepie po monitowaniu użytkownika, że ​​musi dokonać aktualizacji.

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

            }
        });
    }
}

Powinieneś ponownie rozważyć swój projekt, jeśli musisz wymusić aktualizacje w każdym wydaniu.

Google wprowadził bibliotekę aktualizacji w aplikacji ( https://developer.android.com/guide/app-bundle/in-app-updates ), działa na Lollipop + i daje możliwość poproszenia użytkownika o aktualizację z ładnym dialog (ELASTYCZNY) lub z obowiązkowym komunikatem pełnoekranowym (NATYCHMIAST).

Musisz wdrożyć to drugie. Oto jak to będzie wyglądać:

Omówiłem cały kod w tej odpowiedzi: https://stackoverflow.com/a/56808529/5502121

Oficjalnie Google zapewnia w tym celu interfejs API systemu Android.

API jest obecnie testowane przez garstkę partnerów i wkrótce będzie dostępne dla wszystkich programistów.

Update API jest już dostępny - https://developer.android.com/guide/app-bundle/in-app-updates

W tym celu zdecydowanie polecam sprawdzenie funkcji Zdalnej konfiguracji Firebase .

Zaimplementowałem to za pomocą parametru - app_version_enabled - z warunkiem „Disabled Android Versions”, który wygląda następująco:

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

Wartość domyślna parametru to „prawda”, ale wyłączone wersje systemu Android mają wartość fałsz. W moim wyrażeniu regularnym dla wyłączonych wersji Androida możesz dodać więcej wyłączonych wersji po prostu z inną |{version name}w tych nawiasach.

Następnie sprawdzam tylko, czy konfiguracja mówi, że wersja jest włączona, czy nie - uruchamiam działanie, które zmusza użytkownika do aktualizacji. Sprawdzam tylko dwa miejsca, z których można uruchomić aplikację zewnętrznie (moja domyślna aktywność programu uruchamiającego i aktywność związana z obsługą intencji). Ponieważ Remote Config działa na zasadzie pamięci podręcznej, nie przechwytuje natychmiast „wyłączonych” wersji aplikacji, jeśli nie upłynął wymagany czas na unieważnienie pamięci podręcznej, ale jest to maksymalnie 12 godzin, jeśli zamierzasz ich zalecana wartość wygaśnięcia pamięci podręcznej.

sprawdź kod wersji lokalnego i 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();
    }

implementacja klasy do sprawdzania wersji

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

okno dialogowe do aktualizacji

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

układ okna dialogowego

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

Lepiej jest zdefiniować nasz własny proces aktualizacji.

1. Utwórz usługę sieciową, która udostępnia najnowszą wersję aplikacji (ios, android) z naszego serwera.
2. Lub Każda usługa sieciowa używana w aplikacji (np. Login) zwróci najnowszą wersję aplikacji z serwera.
3. Gdy aplikacja uzyska wersję od nr 1 lub 2. Aplikacja sprawdzi ją krzyżowo z wersją lokalną / cuurent. jeśli jest różnica, możemy pokazać ostrzeżenie w następujący sposób,

Android i iOS: jeśli dostępna jest najnowsza wersja aplikacji, pojawi się komunikat „Najnowsza dostępna wersja z większą liczbą funkcji. Aby zaktualizować, kliknij przycisk aktualizacji” (Powiadomienie z przyciskiem „Upgarde” i „Nie, dziękuję”). Następnie aplikacja przekieruje do playstore / Appstore i otworzy najnowszą wersję.

 --- we can do upgrade compulsory or optionally.

Przed aktualizacją upewnij się, że przeprowadziłeś prawidłowy proces migracji bazy danych, jeśli nastąpiła zmiana schematu bazy danych.

Aby zmusić użytkownika aplikacji do aktualizacji, jeśli aktualizacja jest dostępna na rynku, należy najpierw sprawdzić wersję aplikacji na rynku i porównać ją z wersją aplikacji na urządzeniu. Jeśli są różne, może to być aktualizacja. W tym poście spisałem kod do pobrania aktualnej wersji marketu i aktualnej wersji na urządzenie i porównałem je razem. Pokazałem również, jak wyświetlić okno aktualizacji i przekierować użytkownika na stronę aktualizacji. Odwiedź ten link: https://stackoverflow.com/a/33925032/5475941 Po prostu upewnij się, że w oknie dialogowym jest wyświetlany tylko przycisk aktualizacji użytkownika i nie pokazuj mu przycisku anulowania. W takim przypadku będzie zmuszony do aktualizacji, zanim będzie mógł korzystać z aplikacji.

Zdecydowanie należy tutaj wspomnieć o wkrótce udostępnionym interfejsie API aktualizacji w aplikacji .

Będziesz mieć dwie opcje z tym interfejsem API; pierwszy to pełnoekranowe środowisko aktualizacji krytycznych, gdy użytkownik oczekuje na natychmiastowe zastosowanie aktualizacji. Druga opcja to elastyczna aktualizacja, co oznacza, że ​​użytkownik może nadal korzystać z aplikacji podczas pobierania aktualizacji. Możesz całkowicie dostosować przepływ aktualizacji, aby wyglądał jak część Twojej aplikacji.

Dobrym pomysłem jest użycie zdalnej konfiguracji dla wersji aplikacji i zawsze sprawdzaj podczas uruchamiania, czy aktualna wersja aplikacji jest taka sama jak wersja zdalna, czy nie, jeśli nie wymuszono aktualizacji ze sklepu z aplikacjami.

Prosta logika szczęśliwego kodowania.

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

Aby temu zaradzić, możesz skorzystać z aktualizacji Play Core Library w aplikacji. Możesz sprawdzić dostępność aktualizacji i bezproblemowo je zainstalować.

Aktualizacje w aplikacji nie są zgodne z aplikacjami, które używają plików rozszerzeń APK (plików .obb). Możesz wybrać elastyczne pobieranie lub natychmiastowe aktualizacje, które Google Play zajmie się pobieraniem i instalowaniem aktualizacji.

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

Skorzystaj z tej odpowiedzi https://stackoverflow.com/a/58212818/7579041

możesz to zrobić, porównując numer wersji przechowywany w aplikacji w zmiennej i podobnie aktualna wersja aplikacji jest przechowywana po stronie serwera i za każdym razem, gdy użytkownik otwiera aplikację, należy wysłać pierwsze żądanie, aby sprawdzić, czy się znajdzie dopasowywanie nic nie robi, po prostu pozwól użytkownikowi korzystać z Twojej aplikacji w inny sposób wywołać zamiar w sklepie Google Play lub otwórz okno widoku internetowego Twojej aplikacji (window.open („ https://play.google.com/store/apps/details?id= nazwa_pakietu ", '_system', 'location = yes');) i tam automatycznie pojawią się przycisk z prośbą o aktualizację, to właśnie robi Google Playstore, jeśli nie masz włączonych automatycznych aktualizacji.

Możesz powiadomić użytkowników, że dostępna jest nowa wersja bieżącej aplikacji do aktualizacji. Ponadto, jeśli ten warunek jest prawdziwy, możesz zablokować logowanie w aplikacji.

Sprawdź, czy to zapewnia rozwiązanie.

Cóż, może być wiele rozwiązań tego problemu, takich jak zeskrobanie kodu wersji ze strony aplikacji (strona aplikacji Google Play) itp.

Ale pokażę wam ostateczne rozwiązanie, które nie kosztuje ani grosza i będzie działać jak magia.

1. Po prostu zapisz kod najnowszej wersji swojej aplikacji w
   panelu Firebase Remote Config
2. Pobierz tę wartość kodu wersji przy każdym otwarciu aplikacji

3. Porównaj go z aktualnym kodem wersji aplikacji, który można uzyskać za pomocą poniższego kodu

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

   }

Jeśli pobrany kod wersji jest większy niż bieżąca wersja, pokaż AlertDialog z prośbą o zaktualizowanie aplikacji. W przeciwnym razie aplikacja jest już zaktualizowana.

Dlatego za każdym razem, gdy wprowadzasz nową wersję, musisz umieścić kod nowej wersji w panelu konfiguracji Firebase Remote

Możesz przeczytać cały samouczek o tym, jak zmusić użytkowników do zaktualizowania aplikacji za pomocą Firebase Remote Config

Firma Google udostępniła aktualizacje w aplikacji dla biblioteki Play Core.

Zaimplementowałem lekką bibliotekę, aby łatwo wdrażać aktualizacje w aplikacji. W poniższym linku można znaleźć przykład dotyczący wymuszenia na użytkowniku wykonania aktualizacji.

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

var activeVersion = "3.9.2";

var currentVersion = "3.9.1";

var activeVersionArr = activeVersion.split ("."); var currentVersionArr = currentVersion.split (".");

var compareArray = JSON.stringify (activeVersionArr) == JSON.stringify (currentVersionArr);

if (compareArray) {return false; }

if (! compareArray) {for (var i = 0; i <activeVersionArr.length; i ++) {
if (activeVersionArr [i]! == currentVersionArr [i]) {
if (activeVersionArr [i]> currentVersionArr [i]) { powrót prawda; } else {return false; }
}}}