android - saber - play store app descargar

¿Cómo obtener información sobre la versión del mercado de aplicaciones de google play store?

Question

¿Cómo puedo obtener la información de la versión de la aplicación de google play store para pedirle al usuario que solicite una actualización forzosa / recomendada cuando la aplicación de play store se actualiza, es decir, en caso de que el usuario esté utilizando la versión de la versión anterior? Ya he pasado por andorid-market-api que no es la forma oficial y también requiere una autenticación de inicio de sesión de google. También he realizado una consulta de Android que permite verificar la versión de la aplicación, pero no funciona en mi caso. Encontré las siguientes dos alternativas:

• Use la API del servidor que almacenará la información de la versión
• Use las etiquetas de Google y acceda a ella en la aplicación, que no es la mejor manera de hacerlo.

¿Hay alguna otra forma de hacerlo fácilmente?

Answer 1

Además de usar JSoup, también podemos hacer una comparación de patrones para obtener la versión de la aplicación desde playStore.

Para coincidir con el último patrón de google playstore, es decir <div class="BgcNfc">Current Version</div><span class="htlgb"><div><span class="htlgb">XXX</span></div> primero tenemos que coincidir con la secuencia del nodo anterior y luego, desde la secuencia anterior, obtener el valor de la versión. A continuación se muestra el fragmento de código para el mismo:

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

Conseguí esto resuelto a través de esto. Esto también resuelve los últimos cambios realizados por Google en PlayStore. Espero que ayude.

Answer 2

Aquí está la versión de jQuery para obtener el número de versión si alguien más lo necesita.

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

Answer 3

Código fuente completo para esta solución: https://.com/a/50479184/5740468

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

Uso:

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

}

Answer 4

Puede llamar al siguiente servicio web: http://carreto.pt/tools/android-store-version/?package=[YOUR_APP_PACKAGE_NAME]

Ejemplo de uso de volley:

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

Answer 5

Recomendaré usar ex. presione la notificación para notificar a su aplicación que hay una nueva actualización, O use su propio servidor para habilitar su versión de lectura de la aplicación desde allí.

Sí, es un trabajo adicional cada vez que actualice su aplicación, pero en este caso no depende de algunas cosas "no oficiales" o de terceros que pueden quedarse sin servicio.

¿En caso de que se haya perdido algo? ¿La discusión anterior sobre su tema consultó en Google Play Store la versión de una aplicación?

Answer 6

Recomiendo no usar una biblioteca solo crear una nueva clase

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

2. En tu actividad:

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

ESO ES TODO

Answer 7

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

Answer 8

Utilice este código que funciona perfectamente bien.

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

}

Answer 9

la forma más sencilla es usar el paquete firebase de google y usar notificaciones remotas o configuración en tiempo real con la nueva versión y el identificador enviado a los usuarios que se encuentran debajo del número de versión más arriba https://firebase.google.com/

Answer 10

Firebase Remote Config puede ayudar mejor aquí,

Consulte esta respuesta https://.com/a/45750132/2049384

Answer 11

Use la API del servidor que almacenará la información de la versión

Como usted dijo. Esta es una manera fácil de detectar una actualización. Pase la información de su versión con cada llamada a la API. Cuando se actualiza playstore, cambia la versión en el servidor. Una vez que la versión del servidor es más alta que la versión de la aplicación instalada, puede devolver un código / mensaje de estado en la respuesta de la API que se puede manejar y se puede mostrar un mensaje de actualización. También puedes impedir que los usuarios usen aplicaciones muy antiguas como WhatsApp si usas este método.

O puedes usar la notificación push, que es fácil de hacer ... También