Come arrivare app di mercato informazioni di versione di google play store?

Come è possibile ottenere le informazioni sulla versione dell’applicazione dal google play store per richiedere all’utente di forza/consigliato un aggiornamento dell’applicazione play store l’applicazione è aggiornata, cioè nel caso in cui l’utente utilizza vecchia versione di applicazione. Io sono già passati attraverso andorid-mercato-api che non è il modo ufficiale e richiede anche oauth login di autenticazione da parte di google. Ho anche passato attraverso android query
che fornisce in-app per il controllo della versione, ma non è che non funziona nel mio caso.
Ho trovato due alternative seguenti:

  • Utilizzare server API che consente la memorizzazione di informazioni di versione
  • Utilizzare google tag e l’accesso in-app, che non è un preferito modo di passare.

Ci sono altri modi per farlo facilmente?

InformationsquelleAutor ravidl | 2015-12-16

 

13 Replies
  1. 41

    Ho recomned non utilizzare una libreria di creare una nuova 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. Nella vostra attività:

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

    CHE È TUTTO

    • quale sarà l’output di questo? Io non sono sempre presente! È uscita la versione info? Se sì, in che formato?
    • si ottiene una stringa di versionName, è possibile trovare questa versione nome del file “build.gradle”.
    • Questo è un hack. Ma è veramente un bel hack che non richiede molto sforzo, soprattutto se si considera che Google rende difficile lavorare con le api. +1. 🙂
    • Bel trucco, ma non più necessario dal momento che questo: github.com/googlesamples/android-play-publisher-api/tree/master/…
    • Grazie…un hack, ma bella.
    • che metodo ufficiale di API verificare la versione app?
    • Ya non può fallire per una serie di motivi. ad esempio, 1. Google cambia i tasti che si utilizzano in select(“div[itemprop=softwareVersion]”). La cosa migliore da fare è quello di mantenere una API sul proprio server che offre il mercato attuale versione dell’app che si può confrontare con quella installata sul dispositivo utenti
    • Questo appena rotto. Se stai usando un’espressione regolare, invece, è possibile utilizzare <div[^>]*?>Current Version</div><div><span[^>]*?>(.*?)</span></div>
    • Vero, in questo modo è rotto. L’espressione che hai fornito, inoltre, non funziona @vincent
    • Sembrano essere con la modifica di bancomat. Vediamo cosa finisce per essere “stabile”.
    • La mia applicazione non risponde, si tho. Non bene @vincent
    • Ho ottenuto questo lavoro dopo aver fissato il modello con “\s” tra Versione Attuale: <div[^>]*?>Current\sVersion</div><div><span[^>]*?>(.*?)</span></div>
    • .select(“<div[^>]*?>Current\\sVersion</div><div><span[^>]*?>(.*?)</span></div>”produce questo errore di Metodo buttato ‘org.jsoup.selezionate.Selettore$SelectorParseException’ eccezione @Cesar
    • Per gli utenti android aggiungere questa dipendenza nel gradle file, compilare ‘org.jsoup:jsoup:1.11.3’
    • Seriamente uomo.. sto solo cercando cercando n provando da stamattina, infine, questo ha funzionato… Grazie mille…
    • Così, qualcuno ha provato android-play-editore-api per ottenere il numero di versione corrente? Ho sfogliato il codice ma non ho trovato un suggerimento che potrebbe essere utilizzato per questo.
    • Non c’è un modo ufficiale per fare questo. Voglio dire, basta leggere il codice html del sito web. Non la più bella strada.

  2. 8

    Qui è la versione jQuery per ottenere il numero di versione se qualcun altro ne ha bisogno.

        $.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());
        });
    • ho bisogno per ionici, ma quando sto usando quindi ottenere alcuni cors problema ,
    • Questo è il super fragile. Come faccio a sapere? Un’app ho ereditato questo e ha iniziato a schiantarsi hard oggi.
  3. 7

    Utilizzare questo codice perfettamente funzionante.

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

    A parte utilizzando JSoup, si può in alternativa fare il pattern matching per ottenere la versione app dal playStore.

    Per abbinare l’ultimo modello da google playstore ie
    <div class="BgcNfc">Current Version</div><span class="htlgb"><div><span class="htlgb">X.X.X</span></div>
    dobbiamo prima partita di cui sopra sequenza di nodi e poi da sopra sequenza di ottenere il valore di versione. Di seguito è lo snippet di codice stesso:

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

    Ho ottenuto questo risolto attraverso questo. Questo risolve anche le ultime modifiche apportate da Google PlayStore. Speranza che aiuta.

    • Funziona nel 2018, controllato. Grazie!
    • Vi posto il codice completo che utilizza AsynsTask con il vostro permesso
  5. 2

    Utilizzare server API che consente la memorizzazione di informazioni di versione

    Come hai detto tu.Questo è un modo semplice per rilevare un aggiornamento. Passare le informazioni di versione, con tutte le chiamate API. Quando playstore è aggiornato modificare la versione del server. Una volta che la versione del server è superiore a quello installato la versione app, è possibile restituire un codice di stato/messaggio in risposta API che possono essere trattati e di aggiornamento messaggio può essere mostrato. Si può anche bloccare l’accesso degli utenti a utilizzare il vecchio app come WhatsApp non se u non utilizzare questo metodo.

    O è possibile utilizzare le notifiche push, che è facile da fare…Anche

  6. 1

    Codice sorgente completo per questa soluzione: 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;
        }
    
    }

    Uso:

    new GooglePlayAppVersion(getPackageName(), version -> 
        Log.d("TAG", String.format("App version: %s", version)
    ).execute();
  7. 0

    Mi consiglia di utilizzare ex. notifiche push per notificare l’app che c’è un nuovo aggiornamento, O utilizzare il proprio server per attivare l’app per leggere la versione da lì.

    Sì, il suo lavoro aggiuntivo ogni volta che si aggiorna la tua app, ma in questo caso non dipendeva da alcuni “non ufficiale” o di terzi, cose che possono eseguire fuori servizio.

    Nel caso in cui hai perso qualcosa – precedente discussione l’argomento
    query di google play store per la versione di un’app?

  8. 0

    È possibile chiamare i seguenti WebService:
    http://carreto.pt/tools/android-store-version/?package=%5BYOUR_APP_PACKAGE_NAME%5D

    Esempio Di Utilizzo Di Volley:

    String packageName = "com.google.android.apps.plus";
    String url = "http://carreto.pt/tools/android-store-version/?package=";
    JsonObjectRequest jsObjRequest = new JsonObjectRequest
        (Request.Method.GET, url+packageName, null, new Response.Listener<JSONObject>() {
                        @Override
                        public void onResponse(JSONObject response) {
                            /*
                                    here you have access to:
    
                                    package_name, - the app package name
                                    status - success (true) of the request or not (false)
                                    author - the app author
                                    app_name - the app name on the store
                                    locale - the locale defined by default for the app
                                    publish_date - the date when the update was published
                                    version - the version on the store
                                    last_version_description - the update text description
                                 */
                            try{
                                if(response != null && response.has("status") && response.getBoolean("status") && response.has("version")){
                                    Toast.makeText(getApplicationContext(), response.getString("version").toString(), Toast.LENGTH_LONG).show();
                                }
                                else{
                                    //TODO handling error
                                }
                            }
                            catch (Exception e){
                                //TODO handling error
                            }
    
                        }
                    }, new Response.ErrorListener() {
                        @Override
                        public void onErrorResponse(VolleyError error) {
                            //TODO handling error
                        }
            });
  9. 0

    il modo più semplice è usare firebase pacchetto da google e utilizzando le notifiche remote o in tempo reale config con la nuova versione e inviato id per gli utenti sottostante e il numero di versione
    vedere più https://firebase.google.com/

  10. 0

    i benefici qui thay sarete in grado di controllare il numero di versione, invece del nome, che dovrebbe essere più comoda 🙂 Un’altra mano, si dovrebbe prendere cura di aggiornamento versione api/firebase ogni volta dopo il rilascio.

    • prendere la versione da google play pagina web. Ho implementato in questo modo, e funziona più che 1 anno, ma durante questo tempo ho per cambiare ‘matcher’ 3-4 volte, in quanto il contenuto della pagina web, sono stati modificati. Anche qualche mal di testa per controllare di volta in volta, perché non si può sapere dove può essere cambiato.
      ma se si desidera utilizzare in questo modo, qui è il mio kotlin codice basato su okHttp:

      private fun getVersion(onChecked: OnChecked, packageName: String) {
      
      Thread {
          try {
              val httpGet = HttpGet("https://play.google.com/store/apps/details?id="
                      + packageName + "&hl=it")
      
              val response: HttpResponse
              val httpParameters = BasicHttpParams()
              HttpConnectionParams.setConnectionTimeout(httpParameters, 10000)
              HttpConnectionParams.setSoTimeout(httpParameters, 10000)
              val httpclient = DefaultHttpClient(httpParameters)
              response = httpclient.execute(httpGet)
      
              val entity = response.entity
              val `is`: InputStream
              `is` = entity.content
              val reader: BufferedReader
              reader = BufferedReader(InputStreamReader(`is`, "iso-8859-1"), 8)
              val sb = StringBuilder()
              var line: String? = null
              while ({ line = reader.readLine(); line }() != null) {
                  sb.append(line).append("\n")
              }
      
              val resString = sb.toString()
              var index = resString.indexOf(MATCHER)
              index += MATCHER.length
              val ver = resString.substring(index, index + 6) //6 is version length
              `is`.close()
              onChecked.versionUpdated(ver)
              return@Thread
          } catch (ignore: Error) {
          } catch (ignore: Exception) {
          }
      
          onChecked.versionUpdated(null)
      }.start()
      }
  11. 0

    Ho il sospetto che la ragione principale per la richiesta di applicazione è la versione per chiedere conferma dell’utente per l’aggiornamento. Io non sono a favore di demolizione di risposta, perché questo è qualcosa che potrebbe rompere la funzionalità nelle versioni future.

    Se app minimo della versione 5.0, è possibile implementare in-app di aggiornamento in base alla documentazione https://developer.android.com/guide/app-bundle/in-app-updates

    Se il motivo della richiesta di apps versione è diversa, è comunque possibile utilizzare il appUpdateManager al fine di recuperare la versione e fare quello che si vuole (ad esempio, store in preferenze).

    Per esempio siamo in grado di modificare il frammento della documentazione a qualcosa di simile:

    //Creates instance of the manager.
    val appUpdateManager = AppUpdateManagerFactory.create(context)
    
    //Returns an intent object that you use to check for an update.
    val appUpdateInfoTask = appUpdateManager.appUpdateInfo
    
    //Checks that the platform will allow the specified type of update.
    appUpdateInfoTask.addOnSuccessListener { appUpdateInfo ->
        val version = appUpdateInfo.availableVersionCode()
        //do something with version. If there is not a newer version it returns an arbitary int
    }
  12. -2

    Utilizzando Jquery

    $.get("https://play.google.com/store/apps/details?id=--bundleID--", function(data){
            htmlContentsArray=$('<div/>').html(data).contents();
            htmlContents=htmlContentsArray['prevObject']['0']['childNodes']['141'].outerText;
            if(htmlContents == ''){
                htmlContents=htmlContentsArray['prevObject']['0']['childNodes']['144'].outerText;
            }
            latest_version_array=htmlContents.split('Current Version');
                var latest_version_string=latest_version_array['1'];
                var latest_version=latest_version_string.substr(0,5);
    });
    • Abbiamo bisogno di una soluzione per Android . Non in JQuery

Lascia un commento