Ich habe meine App in den Google Play Store gestellt. Es wurde von vielen Kunden meines Unternehmens installiert. Ich verstehe den Mechanismus, wie die App aktualisiert werden soll.

Die Benutzer sollten das Kontrollkästchen für die automatische Aktualisierung in der Playstore-App für jede App aktivieren, die sie automatisch aktualisieren möchten. Einige Benutzer haben es jedoch deaktiviert oder gar nicht aktiviert.

Die App, die ich geschrieben habe, ist für die Pflegeindustrie und wird von Pflegepersonen verwendet, um häusliche Pflege zu liefern. Einige unserer Kunden haben 1200 Betreuer. Sie müssten alle Betreuer ins Büro rufen, um die Telefone einzeln zu aktualisieren. Dies ist offensichtlich inakzeptabel.

Gibt es eine Möglichkeit, programmgesteuert zu überprüfen, ob es eine aktualisierte Version meiner App im Play Store gibt?

Könnte ich Code haben, der jedes Mal ausgeführt wird, wenn der Benutzer die App startet, die den Play Store überprüft? Wenn es eine aktualisierte Version gibt, kann der Benutzer zum Playstore geleitet werden. Dies bedeutet, dass die automatische Aktualisierung nicht unbedingt überprüft werden muss.

Danke im Voraus

Matt

Update 17. Oktober 2019

https://developer.android.com/guide/app-bundle/in-app-updates

Update 24. April 2019:

Android hat eine Funktion angekündigt, die dieses Problem wahrscheinlich beheben wird. Verwenden der In-App-Update-API: https://android-developers.googleblog.com/2018/11/unfolding-right-now-at-androiddevsummit.html

Original:

Soweit ich weiß, gibt es keine offizielle Google-API, die dies unterstützt.

Sie sollten in Betracht ziehen, eine Versionsnummer von einer API zu erhalten.

Anstatt eine Verbindung zu externen APIs oder Webseiten (wie dem Google Play Store) herzustellen. Es besteht das Risiko, dass sich etwas an der API oder der Webseite ändert. Überprüfen Sie daher, ob der Versionscode der aktuellen App unter der Versionsnummer liegt, die Sie von Ihrer eigenen API erhalten.

Denken Sie daran, wenn Sie Ihre App aktualisieren, müssen Sie die Version in Ihrer eigenen API mit der Versionsnummer der App ändern.

Ich würde empfehlen, dass Sie eine Datei auf Ihrer eigenen Website oder API mit der Versionsnummer erstellen. (Machen Sie eventuell einen Cronjob und machen Sie die Versionsaktualisierung automatisch und senden Sie eine Benachrichtigung, wenn etwas schief geht)

Sie müssen diesen Wert von Ihrer Google Play Store-Seite abrufen (wird in der Zwischenzeit geändert und funktioniert nicht mehr):

<div class="content" itemprop="softwareVersion"> x.x.x  </div>

Überprüfen Sie in Ihrer App, ob die auf dem Handy verwendete Version unter der Versionsnummer liegt, die auf Ihrer eigenen API angezeigt wird.

Zeigen Sie an, dass sie / er im Idealfall mit einer Benachrichtigung aktualisiert werden muss.

Dinge die du tun kannst

Versionsnummer mit Ihrer eigenen API

Vorteile:

• Sie müssen nicht den gesamten Code des Google Play Store laden (spart Daten / Bandbreite).

Nachteile:

• Der Benutzer kann offline sein, was die Überprüfung nutzlos macht, da auf die API nicht zugegriffen werden kann

Versionsnummer auf der Webseite Google Play Store

Vorteile:

• Sie benötigen keine API

Nachteile:

• Der Benutzer kann offline sein, was die Überprüfung nutzlos macht, da auf die API nicht zugegriffen werden kann
  • Die Verwendung dieser Methode kann Ihre Benutzer mehr Bandbreite / mobile Daten kosten
  • Die Webseite des Play Store kann sich ändern, sodass Ihre Version "Ripper" nicht mehr funktioniert.

Fügen Sie JSoup in die Datei build.gradle Ihrer Apps ein:

dependencies {
    compile 'org.jsoup:jsoup:1.8.3'
}

und aktuelle Version erhalten wie:

currentVersion = getPackageManager().getPackageInfo(getPackageName(), 0).versionName;

Und führen Sie folgenden Thread aus:

private class GetVersionCode extends AsyncTask<Void, String, String> {
    @Override
    protected String doInBackground(Void... voids) {

    String newVersion = null;
    try {
        newVersion = Jsoup.connect("https://play.google.com/store/apps/details?id=" + MainActivity.this.getPackageName() + "&hl=it")
                .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(".hAyfc .htlgb")
                .get(7)
                .ownText();
        return newVersion;
    } catch (Exception e) {
        return newVersion;
    }
    }

    @Override
    protected void onPostExecute(String onlineVersion) {
        super.onPostExecute(onlineVersion);
        Log.d("update", "Current version " + currentVersion + "playstore version " + onlineVersion);
        if (onlineVersion != null && !onlineVersion.isEmpty()) {
            if (Float.valueOf(currentVersion) < Float.valueOf(onlineVersion)) {
                //show dialog
            }
        }
    }

Weitere Informationen finden Sie unter: http://revisitingandroid.blogspot.in/2016/12/programmatisch-check-play-store-for.html

Firebase Remote Config könnte vorerst eine mögliche und zuverlässige Lösung sein, da Google keine API dafür verfügbar gemacht hat.

Überprüfen Sie die Firebase Remote Config Docs

Schritte 1.Erstellen Sie ein Firebase-Projekt und fügen Sie Ihrem Projekt google_play_service.json hinzu

2.Erstellen Sie Schlüssel wie "android_latest_version_code" und "android_latest_version_name" in der Firebase-Konsole-> Remote-Konfiguration

3. Android Code

    public void initializeFirebase() {
        if (FirebaseApp.getApps(mContext).isEmpty()) {
            FirebaseApp.initializeApp(mContext, FirebaseOptions.fromResource(mContext));
        }
        final FirebaseRemoteConfig config = FirebaseRemoteConfig.getInstance();
        FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
                                                              .setDeveloperModeEnabled(BuildConfig.DEBUG)
                                                              .build();
        config.setConfigSettings(configSettings);
}

Holen Sie sich den aktuellen Versionsnamen und Code

int playStoreVersionCode = FirebaseRemoteConfig.getInstance().getString(
                "android_latest_version_code");
PackageInfo pInfo = this.getPackageManager().getPackageInfo(getPackageName(), 0);
int currentAppVersionCode = pInfo.versionCode; 
if(playStoreVersionCode>currentAppVersionCode){
//Show update popup or whatever best for you
}

4. Halten Sie die Firebase "android_latest_version_code" und "android_latest_version_name" mit Ihrem aktuellen Namen und Code der Produktionsversion auf dem neuesten Stand.

Die Firebase-Fernkonfiguration funktioniert sowohl auf Android als auch auf IPhone.

Sie können Strom erhalten Plays Version mit JSoupwie unten mit einigen Änderungen:

@Override
protected String doInBackground(Void... voids) {

    String newVersion = null;
    try {
        newVersion = Jsoup.connect("https://play.google.com/store/apps/details?id=" + MainActivity.this.getPackageName() + "&hl=it")
                .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(".hAyfc .htlgb")
                .get(7)
                .ownText();
        return newVersion;
    } catch (Exception e) {
        return newVersion;
    }
}

@Override
protected void onPostExecute(String onlineVersion) {
    super.onPostExecute(onlineVersion);

    Log.d("update", "playstore version " + onlineVersion);
}

Antwort von @Tarun funktioniert nicht mehr.

Es gibt eine AppUpdater- Bibliothek. So schließen Sie ein:

1. Fügen Sie das Repository zu Ihrem Projekt build.gradle hinzu :

allprojects {
    repositories {
        jcenter()
        maven {
            url "https://jitpack.io"
        }
    }
}

2. Fügen Sie die Bibliothek Ihrem Modul build.gradle hinzu :

dependencies {
    compile 'com.github.javiersantos:AppUpdater:2.6.4'
}

3. Fügen Sie dem Manifest Ihrer App die Berechtigungen INTERNET und ACCESS_NETWORK_STATE hinzu:

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

4. Fügen Sie dies Ihrer Aktivität hinzu:

AppUpdater appUpdater = new AppUpdater(this); 
appUpdater.start();

Die Antwort von @Tarun funktionierte einwandfrei. Aufgrund der jüngsten Änderungen von Google auf der Google Play-Website ist dies jedoch nicht der Fall.

Ändern Sie diese einfach von @Tarun Antwort ..

class GetVersionCode extends AsyncTask<Void, String, String> {

    @Override

    protected String doInBackground(Void... voids) {

        String newVersion = null;

        try {
            Document document = Jsoup.connect("https://play.google.com/store/apps/details?id=" + MainActivity.this.getPackageName()  + "&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();
            if (document != null) {
                Elements element = document.getElementsContainingOwnText("Current Version");
                for (Element ele : element) {
                    if (ele.siblingElements() != null) {
                        Elements sibElemets = ele.siblingElements();
                        for (Element sibElemet : sibElemets) {
                            newVersion = sibElemet.text();
                        }
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return newVersion;

    }


    @Override

    protected void onPostExecute(String onlineVersion) {

        super.onPostExecute(onlineVersion);

        if (onlineVersion != null && !onlineVersion.isEmpty()) {

            if (Float.valueOf(currentVersion) < Float.valueOf(onlineVersion)) {
                //show anything
            }

        }

        Log.d("update", "Current version " + currentVersion + "playstore version " + onlineVersion);

    }
}

und vergessen Sie nicht, die JSoup-Bibliothek hinzuzufügen

dependencies {
compile 'org.jsoup:jsoup:1.8.3'}

und auf Oncreate ()

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);


    String currentVersion;
    try {
        currentVersion = getPackageManager().getPackageInfo(getPackageName(), 0).versionName;
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }

    new GetVersionCode().execute();

}

das war's .. Dank diesem Link

Google hat die API für In-App-Updates eingeführt

Die API unterstützt derzeit zwei Flows:

• Der "sofortige" Ablauf ist eine Vollbild-Benutzererfahrung, die den Benutzer vom Download bis zur Aktualisierung führt, bevor er Ihre App verwenden kann.
• Der „flexible Ablauf“ ermöglicht es Benutzern, das Update herunterzuladen, während Sie Ihre App weiterhin verwenden.

Firebase Remote Config ist besser.

• Aktualisieren Sie unsere Anwendungen schnell und einfach, ohne einen neuen Build für die App veröffentlichen zu müssen

Implementieren von Remote Config unter Android

Hinzufügen der Remote-Konfigurationsabhängigkeit

compile 'com.google.firebase:firebase-config:9.6.0'

Sobald dies erledigt ist, können wir bei Bedarf in unserer gesamten Anwendung auf die FirebaseRemoteConfig-Instanz zugreifen:

FirebaseRemoteConfig firebaseRemoteConfig = FirebaseRemoteConfig.getInstance();

Remote Config-Werte abrufen

boolean someBoolean = firebaseRemoteConfig.getBoolean("some_boolean");
byte[] someArray = firebaseRemoteConfig.getByteArray("some_array");
double someDouble = firebaseRemoteConfig.getDouble("some_double");
long someLong = firebaseRemoteConfig.getLong("some_long");
String appVersion = firebaseRemoteConfig.getString("appVersion");

Abrufen von serverseitigen Werten

firebaseRemoteConfig.fetch(cacheExpiration)
            .addOnCompleteListener(new OnCompleteListener<Void>() {
                @Override
                public void onComplete(@NonNull Task<Void> task) {
                    if (task.isSuccessful()) {
                        mFirebaseRemoteConfig.activateFetched();
                        // We got our config, let's do something with it!
                        if(appVersion < CurrentVersion){
                           //show update dialog
                        }
                    } else {
                        // Looks like there was a problem getting the config...
                    }
                }
            });

Nachdem wir die neue Version in den Playstore hochgeladen haben, müssen wir die Versionsnummer in Firebase aktualisieren. Wenn es sich nun um eine neue Version handelt, wird der Aktualisierungsdialog angezeigt

Innerhalb der OnCreate-Methode schreiben Sie den folgenden Code.

VersionChecker versionChecker = new VersionChecker();
    try {
        latestVersion = versionChecker.execute().get();
        Toast.makeText(getBaseContext(), latestVersion , Toast.LENGTH_SHORT).show();

    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }

Dies gibt Ihnen Play Store-Version der App ..

Dann müssen Sie die App-Version wie unten überprüfen

PackageManager manager = getPackageManager();
    PackageInfo info = null;
    try {
        info = manager.getPackageInfo(getPackageName(), 0);
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }
    assert info != null;
    version = info.versionName;

Danach können Sie es mit der Store-Version vergleichen und Ihre eigenen Update-Bildschirme einrichten

if(version.equals(latestVersion)){
        Toast.makeText(getBaseContext(), "No Update" , Toast.LENGTH_SHORT).show();
    }else {
        Toast.makeText(getBaseContext(), "Update" , Toast.LENGTH_SHORT).show();

    }

Und fügen Sie VersionChecker.class wie folgt hinzu

public class VersionChecker extends AsyncTask<String, String, String> {

    private String newVersion;

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

        try {
            newVersion = Jsoup.connect("https://play.google.com/store/apps/details?id=" + "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(".hAyfc .htlgb")
                    .get(7)
                    .ownText();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return newVersion;
    }
}

Aus einer Hybridanwendung POV. Dies ist ein Javascript-Beispiel. Ich habe eine Fußzeile "Update verfügbar" in meinem Hauptmenü. Wenn ein Update verfügbar ist (dh meine Versionsnummer in der Konfigurationsdatei ist kleiner als die abgerufene Version, zeigen Sie die Fußzeile an). Dadurch wird der Benutzer zum App / Play Store weitergeleitet, wo der Benutzer auf die Schaltfläche "Update" klicken kann.

Ich erhalte auch die neuen Daten (z. B. Versionshinweise) und zeige diese beim Anmelden modal an, wenn es das erste Mal in dieser Version ist.

Legen Sie auf Gerätebereit Ihre Geschäfts-URL fest

        if (device.platform == 'iOS')
           storeURL = 'https://itunes.apple.com/lookup?bundleId=BUNDLEID';
        else
           storeURL = 'https://play.google.com/store/apps/details?id=BUNDLEID';

Die Methode Update Available kann beliebig oft ausgeführt werden. Meins wird jedes Mal ausgeführt, wenn der Benutzer zum Startbildschirm navigiert.

function isUpdateAvailable() {
    if (device.platform == 'iOS') {
        $.ajax(storeURL, {
            type: "GET",
            cache: false,
            dataType: 'json'
        }).done(function (data) {
            isUpdateAvailable_iOS(data.results[0]);
        }).fail(function (jqXHR, textStatus, errorThrown) {
            commsErrorHandler(jqXHR, textStatus, false);
        });
    } else {
        $.ajax(storeURL, {
            type: "GET",
            cache: false
        }).done(function (data) {
            isUpdateAvailable_Android(data);
        }).fail(function (jqXHR, textStatus, errorThrown) {
            commsErrorHandler(jqXHR, textStatus, false);
        });
    }
}

iOS-Rückruf: Apple hat eine API, die sehr einfach zu bekommen ist

function isUpdateAvailable_iOS (data) {
    var storeVersion = data.version;
    var releaseNotes = data.releaseNotes;
    // Check store Version Against My App Version ('1.14.3' -> 1143)
    var _storeV = parseInt(storeVersion.replace(/\./g, ''));
    var _appV = parseInt(appVersion.substring(1).replace(/\./g, ''));
    $('#ft-main-menu-btn').off();
    if (_storeV > _appV) {
        // Update Available
        $('#ft-main-menu-btn').text('Update Available');
        $('#ft-main-menu-btn').click(function () {
            openStore();
        });

    } else {
        $('#ft-main-menu-btn').html(' ');
        // Release Notes
        settings.updateReleaseNotes('v' + storeVersion, releaseNotes);
    }
}

Android Callback: PlayStore muss man kratzen, da man sieht, dass die Version relativ einfach zu greifen ist und was neu ist, nehme ich das HTML anstelle des Textes, da ich auf diese Weise ihre Formatierung verwenden kann (dh neue Zeilen usw.)

function isUpdateAvailable_Android(data) {
    var html = $(data);
    var storeVersion = html.find('div[itemprop=softwareVersion]').text().trim();
    var releaseNotes = html.find('.whatsnew')[0].innerHTML;
    // Check store Version Against My App Version ('1.14.3' -> 1143)
    var _storeV = parseInt(storeVersion.replace(/\./g, ''));
    var _appV = parseInt(appVersion.substring(1).replace(/\./g, ''));
    $('#ft-main-menu-btn').off();
    if (_storeV > _appV) {
        // Update Available
        $('#ft-main-menu-btn').text('Update Available');
        $('#ft-main-menu-btn').click(function () {
            openStore();
        });

    } else {
        $('#ft-main-menu-btn').html(' ');
        // Release Notes
        settings.updateReleaseNotes('v' + storeVersion, releaseNotes);
    }
}

Die Open-Store-Logik ist einfach, aber der Vollständigkeit halber

function openStore() {
    var url = 'https://itunes.apple.com/us/app/appname/idUniqueID';
    if (device.platform != 'iOS')
       url = 'https://play.google.com/store/apps/details?id=appid'
   window.open(url, '_system')
}

Stellen Sie sicher, dass Play Store und App Store auf die Whitelist gesetzt wurden:

  <access origin="https://itunes.apple.com"/>
  <access origin="https://play.google.com"/>

Richten Sie einen Server ein, der eine HTTP-URL bereitstellt, die die neueste Version meldet, und verwenden Sie dann einen AlarmManager, um diese URL aufzurufen und festzustellen, ob die Version auf dem Gerät mit der neuesten Version übereinstimmt. Wenn dies nicht der Fall ist, wird eine Nachricht oder Benachrichtigung angezeigt und zum Upgrade an den Markt gesendet.

Es gibt einige Codebeispiele: Wie können Benutzer in der App nach der neuesten App-Version suchen?

Abgesehen von der Verwendung von JSoup können wir alternativ einen Mustervergleich durchführen, um die App-Version aus dem PlayStore zu erhalten.

Um das neueste Muster aus dem Google Playstore abzugleichen, müssen <div class="BgcNfc">Current Version</div><span class="htlgb"><div><span class="htlgb">X.X.X</span></div> wir zuerst die obige Knotensequenz abgleichen und dann aus der obigen Sequenz den Versionswert abrufen. Unten ist das Code-Snippet für dasselbe:

    private String getAppVersion(String patternString, String inputString) {
        try{
            //Create a pattern
            Pattern pattern = Pattern.compile(patternString);
            if (null == pattern) {
                return null;
            }

            //Match the pattern string in provided string
            Matcher matcher = pattern.matcher(inputString);
            if (null != matcher && matcher.find()) {
                return matcher.group(1);
            }

        }catch (PatternSyntaxException ex) {

            ex.printStackTrace();
        }

        return null;
    }


    private String getPlayStoreAppVersion(String appUrlString) {
        final String currentVersion_PatternSeq = "<div[^>]*?>Current\\sVersion</div><span[^>]*?>(.*?)><div[^>]*?>(.*?)><span[^>]*?>(.*?)</span>";
        final String appVersion_PatternSeq = "htlgb\">([^<]*)</s";
        String playStoreAppVersion = null;

        BufferedReader inReader = null;
        URLConnection uc = null;
        StringBuilder urlData = new StringBuilder();

        final URL url = new URL(appUrlString);
        uc = url.openConnection();
        if(uc == null) {
           return null;
        }
        uc.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows; U; WindowsNT 5.1; en-US; rv1.8.1.6) Gecko/20070725 Firefox/2.0.0.6");
        inReader = new BufferedReader(new InputStreamReader(uc.getInputStream()));
        if (null != inReader) {
            String str = "";
            while ((str = inReader.readLine()) != null) {
                           urlData.append(str);
            }
        }

        // Get the current version pattern sequence 
        String versionString = getAppVersion (currentVersion_PatternSeq, urlData.toString());
        if(null == versionString){ 
            return null;
        }else{
            // get version from "htlgb">X.X.X</span>
            playStoreAppVersion = getAppVersion (appVersion_PatternSeq, versionString);
        }

        return playStoreAppVersion;
    }

Ich habe es dadurch gelöst, da dies auch für die neuesten Änderungen im Google Playstore funktioniert. Hoffentlich hilft das.

private void CheckUPdate() {
    VersionChecker versionChecker = new VersionChecker();
    try
    {   String appVersionName = BuildConfig.VERSION_NAME;
        String mLatestVersionName = versionChecker.execute().get();
        if(!appVersionName.equals(mLatestVersionName)){
            AlertDialog.Builder alertDialog = new AlertDialog.Builder(Activity.this);
            alertDialog.setTitle("Please update your app");
            alertDialog.setMessage("This app version is no longer supported. Please update your app from the Play Store.");
            alertDialog.setPositiveButton("UPDATE NOW", new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                    final String appPackageName = getPackageName();
                    try {
                        startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=" + appPackageName)));
                    } catch (android.content.ActivityNotFoundException anfe) {
                        startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("https://play.google.com/store/apps/details?id=" + appPackageName)));
                    }
                }
            });
            alertDialog.show();
        }

    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
}

@SuppressLint("StaticFieldLeak")
public class VersionChecker extends AsyncTask<String, String, String> {
    private String newVersion;
    @Override
    protected String doInBackground(String... params) {

        try {
            newVersion = Jsoup.connect("https://play.google.com/store/apps/details?id="+getPackageName())
                    .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(".hAyfc .htlgb")
                    .get(7)
                    .ownText();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return newVersion;
    }
}

Es gibt keine offizielle GooglePlay-API dafür.

Sie können diese inoffizielle Bibliothek jedoch verwenden , um App-Versionsdaten abzurufen.

Und wenn das oben genannte für Sie nicht funktioniert, können Sie jederzeit eine http-Verbindung zur Seite Ihrer App herstellen (z. B. https://play.google.com/store/apps/details?id=com.shots.android&hl=de ) und Analysieren Sie das Feld "Aktuelle Version".

Sie können versuchen, den folgenden Code mit Jsoup zu verwenden

String latestVersion = doc.getElementsContainingOwnText("Current Version").parents().first().getAllElements().last().text();

bestätigte nur, dass diese Methode jetzt funktioniert:

newVersion = Jsoup.connect("https://play.google.com/store/apps/details?id=" + AcMainPage.this.getPackageName() + "&hl=it")
                        .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(".hAyfc .htlgb")
                        .get(5)
                        .ownText();

Google hat die In-App-Update-API eingeführt. Auf diese Weise können wir den Benutzer bitten, die App innerhalb der Anwendung zu aktualisieren. Wenn der Benutzer dies akzeptiert, können wir die neueste App direkt herunterladen und ohne Weiterleitung zum Playstore installieren. Weitere Details finden Sie unter dem folgenden Link

link1 link2

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

So wird das flexible Update aussehen:

und hier ist der sofortige Update-Ablauf:

Sie können meine Antwort hier unter https://stackoverflow.com/a/56808529/5502121 überprüfen , um den vollständigen Beispielcode für die Implementierung von flexiblen und sofortigen Aktualisierungsabläufen zu erhalten. Ich hoffe es hilft!