我已将我的应用程序放在Google Play商店中。它已由我公司的许多客户安装。我了解该应用程序打算如何升级的机制。

用户应为他们要自动更新的每个应用选中Playstore应用中的“自动更新”复选框。但是，有些用户首先未选中它或未选中它。

我编写的应用程序是用于护理行业的，护理人员可用来提供家庭护理。我们的一些客户有1200名照顾者。他们将不得不召集所有护理人员到办公室来分别更新电话。这显然是不能接受的。

是否可以通过程序检查Play商店中是否有我的应用程序的更新版本？

用户每次启动检查Play商店的应用时，我能否运行代码？如果有更新版本，则可以将用户定向到Playstore。这意味着不必检查自动更新。

提前致谢

马特

更新2019年10月17日

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

2019年4月24日更新：

Android宣布了一项可能会解决此问题的功能。使用应用内更新API：https： //android-developers.googleblog.com/2018/11/unfolding-right-now-at-androiddevsum​​mit.html

原版的：

据我所知，尚无官方的Google API支持此功能。

您应该考虑从API获取版本号。

而不是连接到外部API或网页（例如Google Play商店）。API或网页可能会发生某些变化，因此您应该考虑检查当前应用程序的版本代码是否低于您从自己的API获得的版本号。

请记住，如果您更新应用程序，则需要使用应用程序版本号在自己的API中更改版本。

我建议您在自己的网站或API中使用版本号创建文件。（最终进行cronjob并自动更新版本，并在出现问题时发送通知）

您必须从Google Play商店页面获取此值（同时已更改，无法再使用）：

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

在您的应用中签入手机上使用的版本是否低于您自己的API上显示的版本号。

理想情况下，显示需要更新通知的指示。

你可以做的事

使用您自己的API的版本号

优点：

• 无需加载Google Play商店的完整代码（节省数据/带宽）

缺点：

• 用户可以离线，这使得检查无用，因为无法访问API

Google Play商店网页上的版本号

优点：

• 您不需要API

缺点：

• 用户可以离线，这使得检查无用，因为无法访问API
  • 使用此方法可能会使您的用户花费更多带宽/移动数据
  • Play商店网页可能会更改，这会使您的版本“ ripper”不再起作用。

在您的应用程序build.gradle文件中包含JSoup：

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

并获得当前版本，例如：

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

并执行以下线程：

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

有关更多详细信息，请访问：http : //revisitingandroid.blogspot.in/2016/12/programmatically-check-play-store-for.html

Firebase远程配置由于Google并未向其公开任何api，因此可能是目前可行且可靠的解决方案。

检查一下 Firebase远程配置文档

脚步 创建一个Firebase项目，并将google_play_service.json添加到您的项目

2.在Firebase控制台中创建“ android_latest_version_code”和“ android_latest_version_name”之类的键->远程配置

3. Android代码

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

获取当前版本名称和代码

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.并保持Firebase“ android_latest_version_code”和“ android_latest_version_name”为最新，并带有您当前的生产版本名称和代码。

Firebase远程配置可在Android和iPhone上使用。

您可以通过以下修改获得当前的Playstore版本JSoup：

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

@Tarun的答案不再起作用。

@Tarun答案运行正常。但由于Google在Google Play网站上所做的最新更改，因此现在无法使用了。

只需从@Tarun答案中更改这些即可。

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

    }
}

并且不要忘记添加JSoup库

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

并在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();

}

就是这样..感谢这个链接

有AppUpdater库。如何包括：

1. 将存储库添加到您的项目 build.gradle中：

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

2. 将库添加到模块 build.gradle中：

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

3. 将INTERNET和ACCESS_NETWORK_STATE权限添加到您应用的清单中：

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

4. 将此添加到您的活动中：

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

Google引入了应用内更新API

该API当前支持两种流程：

• “立即”流程是一种全屏用户体验，可指导用户从下载到更新，然后再使用您的应用程序。
• “灵活的流程”允许用户在继续使用您的应用的同时下载更新。

来自混合应用程序POV。这是一个JavaScript示例，我的主菜单上有一个Update Available页脚。如果有可用更新（即，我的配置文件中的版本号小于检索到的版本，请显示页脚），这将把用户定向到应用程序/播放商店，然后用户可以单击更新按钮。

我还获得了最新的数据（即发行说明），并在登录时以模态形式显示了这些数据（如果是此版本上的第一次）。

在设备就绪状态下，设置商店网址

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

可以根据需要多次运行“可用更新”方法。每次用户导航到主屏幕时，都会运行Mine。

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回调：Apple具有API，因此非常容易获得

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，因为您可以看到该版本相对容易抓取，并且我采用HTML而不是文本作为新内容，因此可以使用其格式（例如换行等）

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

公开存储逻辑很简单，但出于完整性考虑

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')
}

确保Play商店和App Store已列入白名单：

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

Firebase远程配置更好。

• 快速，轻松地更新我们的应用程序，而无需向该应用程序发布新版本

在Android上实现远程配置

添加远程配置依赖性

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

完成后，我们可以根据需要在整个应用程序中访问FirebaseRemoteConfig实例：

FirebaseRemoteConfig firebaseRemoteConfig = FirebaseRemoteConfig.getInstance();

检索远程配置值

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

获取服务器端值

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

现在，将新版本上传到Playstore后，我们必须在Firebase中更新版本号。现在，如果是新版本，将显示更新对话框

在OnCreate方法内部，编写以下代码。

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

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

这使您可以播放商店版本的应用程序。

那么您必须检查以下应用程序版本

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

之后，您可以将其与商店版本进行比较，并设置自己的更新屏幕

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

    }

并添加如下所示的VersionChecker.class

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

设置服务器以显示报告最新版本的HTTP URL，然后使用AlarmManager调用该URL，并查看设备上的版本是否与最新版本相同。如果不是，则会弹出消息或通知，然后将其发送到市场进行升级。

有一些代码示例：如何允许用户从应用程序内部检查最新的应用程序版本？

除了使用JSoup，我们还可以进行模式匹配，以从playStore获取应用程序版本。

为了匹配来自Google Playstore的最新模式，即 <div class="BgcNfc">Current Version</div><span class="htlgb"><div><span class="htlgb">X.X.X</span></div> 我们首先必须匹配上述节点序列，然后从上述序列中获取版本值。以下是相同的代码段：

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

我通过它解决了问题，因为它也适用于最新的Google Playstore更改。希望能有所帮助。

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

没有官方的GooglePlay API可以执行此操作。

但是您可以使用这个非官方的库来获取应用程序版本数据。

而且，如果以上方法都不适合您，则可以始终http连接到应用程序的页面（例如https://play.google.com/store/apps/details?id=com.shots.android&hl=zh_CN），解析“当前版本”字段。

您可以尝试使用Jsoup遵循以下代码

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

Google引入了应用内更新API。使用它，我们可以要求用户在应用程序内部更新应用程序。如果用户接受，我们可以直接下载最新的应用并安装，而无需重定向到playstore。有关更多详细信息，请参考以下链接

链接1链接2

确认仅该方法现在有效：

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引入了应用内更新功能，（https://developer.android.com/guide/app-bundle/in-app-updates），该功能可在Lollipop +上运行，并让您可以向用户要求更新的功能对话框（FLEXIBLE）或带有强制性全屏消息（IMMEDIATE）。

下面是如何灵活的更新将是这样的：

这是即时更新流程：

您可以在这里https://stackoverflow.com/a/56808529/5502121检查我的答案，以获取实现灵活更新和立即更新流的完整示例代码。希望能帮助到你！