web-dev-qa-db-fra.com

Comment obtenir des informations sur la version du marché des applications sur Google Play Store?

Comment puis-je obtenir les informations sur la version de l'application sur Google Play Store pour demander à l'utilisateur de forcer/recommander une mise à jour de l'application lorsque l'application Play Store est mise à jour, c'est-à-dire si l'utilisateur utilise une ancienne version? J'ai déjà parcouru andorid-market-api qui n'est pas la méthode officielle et qui requiert également oauth login authentication de Google. J'ai également consulté la requête Android Qui fournit une vérification de la version dans l'application, mais cela ne fonctionne pas dans mon cas . J'ai trouvé les deux alternatives suivantes:

  • Utiliser l'API du serveur qui stockera les informations de version
  • Utilisez les balises google et accédez-y via l'application, ce qui n'est pas la méthode préférée.

Y a-t-il d'autres moyens de le faire facilement?

androidversion-controlgoogle-playgoogle-apps-marketplacegoogle-play-developer-api
31
ravidl

Je recommande de ne pas utiliser une bibliothèque mais de créer une nouvelle classe

1.

public 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=" + "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.hAyfc:nth-child(4) > span:nth-child(2) > div:nth-child(1) > span:nth-child(1)")
                .first()
                .ownText();
    } catch (IOException e) {
        e.printStackTrace();
    }

    return newVersion;
}

  1. QUE IS TOUT

        VersionChecker versionChecker = new VersionChecker();
    String latestVersion = versionChecker.execute().get();

THAT IS ALL

36
Horacio Solorio

Voici la version de jQuery pour obtenir le numéro de version si quelqu'un d'autre en a besoin.

    $.get("https://play.google.com/store/apps/details?id=" + packageName + "&hl=en", function(data){
        console.log($('<div/>').html(data).contents().find('div[itemprop="softwareVersion"]').text().trim());
    });
9
Firze

Utilisez ce code pour que cela fonctionne parfaitement.

public void forceUpdate(){
    PackageManager packageManager = this.getPackageManager();
    PackageInfo packageInfo = null;
    try {
        packageInfo =packageManager.getPackageInfo(getPackageName(),0);
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }
    String currentVersion = packageInfo.versionName;
    new ForceUpdateAsync(currentVersion,TodayWork.this).execute();
}

public class ForceUpdateAsync extends AsyncTask<String, String, JSONObject> {

    private String latestVersion;
    private String currentVersion;
    private Context context;
    public ForceUpdateAsync(String currentVersion, Context context){
        this.currentVersion = currentVersion;
        this.context = context;
    }

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

        try {
            latestVersion = Jsoup.connect("https://play.google.com/store/apps/details?id=" + context.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()
                    .select("div.hAyfc:nth-child(3) > span:nth-child(2) > div:nth-child(1) > span:nth-child(1)")
                    .first()
                    .ownText();
            Log.e("latestversion","---"+latestVersion);

        } catch (IOException e) {
            e.printStackTrace();
        }
        return new JSONObject();
    }

    @Override
    protected void onPostExecute(JSONObject jsonObject) {
        if(latestVersion!=null){
            if(!currentVersion.equalsIgnoreCase(latestVersion)){
                // Toast.makeText(context,"update is available.",Toast.LENGTH_LONG).show();
                if(!(context instanceof SplashActivity)) {
                    if(!((Activity)context).isFinishing()){
                        showForceUpdateDialog();
                    }
                }
            }
        }
        super.onPostExecute(jsonObject);
    }

    public void showForceUpdateDialog(){

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

}
6
Vikram Kaldoke

Outre l'utilisation de JSoup, nous pouvons également effectuer une recherche de motif pour obtenir la version de l'application à partir de playStore. 

Pour faire correspondre le dernier modèle de Google PlayStore, à savoir <div class="BgcNfc">Current Version</div><span class="htlgb"><div><span class="htlgb">X.X.X</span></div> nous devons d'abord faire correspondre la séquence de nœud ci-dessus, puis à partir de la séquence ci-dessus, obtenir la valeur de la version. Ci-dessous l'extrait de code pour la même chose:

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

J'ai résolu ceci à travers cela. Cela résout également les dernières modifications apportées par Google sur PlayStore. J'espère que cela pourra aider.

4
DRK

La configuration distante de Firebase peut aider au mieux ici,

Veuillez vous référer à cette réponse https://stackoverflow.com/a/45750132/2049384

4
Sreedhu Madhu

Utiliser l'API du serveur qui stockera les informations de version

Comme vous l'avez dit. C'est un moyen facile de détecter une mise à jour. Transmettez vos informations de version avec chaque appel d'API. Lorsque le Playstore est mis à jour, changez la version sur le serveur. Une fois que la version du serveur est supérieure à la version de l'application installée, vous pouvez renvoyer un code d'état/message dans la réponse de l'API pouvant être traité et un message de mise à jour affiché. Vous pouvez également empêcher les utilisateurs d'utiliser une très vieille application telle que WhatsApp si vous utilisez cette méthode.

Ou vous pouvez utiliser la notification Push, ce qui est facile à faire ... Aussi

1
shijin

Code source complet pour cette solution: https://stackoverflow.com/a/50479184/5740468

import Android.os.AsyncTask;
import Android.support.annotation.Nullable;

import Java.io.BufferedReader;
import Java.io.IOException;
import Java.io.InputStreamReader;
import Java.net.URL;
import Java.net.URLConnection;
import Java.util.regex.Matcher;
import Java.util.regex.Pattern;
import Java.util.regex.PatternSyntaxException;

public class GooglePlayAppVersion extends AsyncTask<String, Void, String> {

    private final String packageName;
    private final Listener listener;
    public interface Listener {
        void result(String version);
    }

    public GooglePlayAppVersion(String packageName, Listener listener) {
        this.packageName = packageName;
        this.listener = listener;
    }

    @Override
    protected String doInBackground(String... params) {
        return getPlayStoreAppVersion(String.format("https://play.google.com/store/apps/details?id=%s", packageName));
    }

    @Override
    protected void onPostExecute(String version) {
        listener.result(version);
    }

    @Nullable
    private static String getPlayStoreAppVersion(String appUrlString) {
        String
              currentVersion_PatternSeq = "<div[^>]*?>Current\\sVersion</div><span[^>]*?>(.*?)><div[^>]*?>(.*?)><span[^>]*?>(.*?)</span>",
              appVersion_PatternSeq = "htlgb\">([^<]*)</s";
        try {
            URLConnection connection = new URL(appUrlString).openConnection();
            connection.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows; U; WindowsNT 5.1; en-US; rv1.8.1.6) Gecko/20070725 Firefox/2.0.0.6");
            try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
                StringBuilder sourceCode = new StringBuilder();
                String line;
                while ((line = br.readLine()) != null) sourceCode.append(line);

                // Get the current version pattern sequence
                String versionString = getAppVersion(currentVersion_PatternSeq, sourceCode.toString());
                if (versionString == null) return null;

                // get version from "htlgb">X.X.X</span>
                return getAppVersion(appVersion_PatternSeq, versionString);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Nullable
    private static String getAppVersion(String patternString, String input) {
        try {
            Pattern pattern = Pattern.compile(patternString);
            if (pattern == null) return null;
            Matcher matcher = pattern.matcher(input);
            if (matcher.find()) return matcher.group(1);
        } catch (PatternSyntaxException e) {
            e.printStackTrace();
        }
        return null;
    }

}

Usage:

new GooglePlayAppVersion(getPackageName(), version -> 
    Log.d("TAG", String.format("App version: %s", version)
).execute();
1
Сергей

Je vais recommander d'utiliser ex. Envoyer une notification pour signaler à votre application qu'une nouvelle mise à jour est disponible. OR utilisez votre propre serveur pour activer la version de lecture de votre application à partir de là. 

Oui, cela représente un travail supplémentaire chaque fois que vous mettez à jour votre application, mais dans ce cas, vous ne dépendez pas de choses "non officielles" ou de tierces parties susceptibles de manquer de service.

Juste au cas où vous auriez manqué quelque chose - discussion précédente de votre sujet interroger le Google Play Store pour obtenir la version d'une application?

0
lganzzzo

le moyen le plus simple consiste à utiliser le paquet firebase de Google et à utiliser des notifications à distance ou une configuration en temps réel avec la nouvelle version et un identifiant envoyé aux utilisateurs sous le numéro de version voir plus https://firebase.google.com/

0
alacoo