Verifique mediante programación Play Store para obtener actualizaciones de la aplicación


92

He puesto mi aplicación en Google Play Store. Ha sido instalado por muchos de los clientes de mi empresa. Entiendo el mecanismo de actualización de la aplicación.

Los usuarios deben marcar la casilla de verificación de actualización automática en la aplicación PlayStore para cada aplicación que deseen actualizar automáticamente. Sin embargo, algunos usuarios lo han desmarcado o no lo han marcado en primer lugar.

La aplicación que he escrito es para la industria del cuidado y los cuidadores la utilizan para brindar atención domiciliaria. Algunos de nuestros clientes pueden tener 1200 cuidadores. Tendrían que llamar a todos los cuidadores a la oficina para actualizar los teléfonos individualmente. Evidentemente, esto es inaceptable.

¿Existe alguna forma de comprobar mediante programación si hay una versión actualizada de mi aplicación en Play Store?

¿Podría tener un código que se ejecute cada vez que el usuario inicia la aplicación que verifica Play Store? Si hay una versión actualizada, el usuario puede ser dirigido a la tienda de juegos. Esto significará que no es esencial que se verifique la actualización automática.

Gracias por adelantado

Mate


¿Play Store no envía una notificación al usuario si hay una actualización disponible para una aplicación?
Nischaal Cooray

1
¿Su aplicación se conecta a la nube / Internet en una API que haya escrito? Como simplemente podría tener una variable de 'versión' que podría actualizar manualmente, al abrir la aplicación, verifique la versión local con la versión de la nube, si es que diferir, sugerir una actualización
gavlaaaaaaaa

Solía ​​usar jsoup para hacer esto, pero ahora uso una expresión regular para extraer el campo Versión actual .
Geezer McNubbins

Respuestas:


42

Actualización 17 de octubre de 2019

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

Actualización 24 de abril de 2019:

Android anunció una función que probablemente solucionará este problema. Usando la API de actualizaciones en la aplicación: https://android-developers.googleblog.com/2018/11/unfolding-right-now-at-androiddevsummit.html

Original:

Hasta donde yo sé, no existe una API oficial de Google que admita esto.

Debería considerar obtener un número de versión de una API.

En lugar de conectarse a API o páginas web externas (como Google Play Store). Existe el riesgo de que algo cambie en la API o en la página web, por lo que debe considerar verificar si el código de versión de la aplicación actual está por debajo del número de versión que obtiene de su propia API.

Solo recuerde que si actualiza su aplicación, debe cambiar la versión en su propia API con el número de versión de la aplicación.

Le recomendaría que cree un archivo en su propio sitio web o API, con el número de versión. (Eventualmente, haga un cronjob y haga que la versión se actualice automáticamente, y envíe una notificación cuando algo salga mal)

Debe obtener este valor de su página de Google Play Store (se cambia mientras tanto, ya no funciona):

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

Verifique en su aplicación si la versión utilizada en el móvil está por debajo del número de versión que se muestra en su propia API.

Muestra una indicación de que necesita actualizar con una notificación, idealmente.

Cosas que puedes hacer

Número de versión usando su propia API

Pros:

  • No es necesario cargar el código completo de Google Play Store (ahorra datos / ancho de banda)

Contras:

  • El usuario puede estar desconectado, lo que hace que la verificación sea inútil ya que no se puede acceder a la API

Número de versión en la página web Google Play Store

Pros:

  • No necesitas una API

Contras:

  • El usuario puede estar desconectado, lo que hace que la verificación sea inútil ya que no se puede acceder a la API
    • El uso de este método puede costar a sus usuarios más ancho de banda / datos móviles
    • La página web de Play Store podría cambiar, lo que hace que su versión 'ripper' ya no funcione.

El número de versión en la página web de Google Play Store ahora Current Versionaparece como Varies with deviceuna idea de cómo se puede resolver esto o si hay alguna otra alternativa disponible.
shadygoneinsane


En efecto. Llegué a esta pregunta porque ya no podemos acceder a la fuente html de nuestra propia página de Google Play cuando hacemos una búsqueda web. recibimos una FileNotFoundException.
Grisgram

Intentaría algo como buscar un div que contenga el texto. Versión actual / Huidige versie Encuentra el primer número y el dígito de los puntos en los siguientes divs. <div class = "hAyfc"> <div class = "BgcNfc"> Huidige versie </div> <div> <span class = "htlgb"> 1.0 </span> </div>
Richard Lindhout

El nombre de clase probablemente se cambiará en cada actualización de su sitio web.
Richard Lindhout

35

Incluya JSoup en el archivo build.gradle de su aplicación:

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

y obtenga la versión actual como:

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

Y ejecuta el siguiente hilo:

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

Para obtener más detalles, visite: http://revisitingandroid.blogspot.in/2016/12/programmatic-check-play-store-for.html


en @Override protected void onPostExecute (String onlineVersion) {} si la condición para la versión de verificación no debe estar en valor Float. Porque puede arrojar un error como este Invalid java.lang.NumberFormatException: Invalid float: "1.0.6". Entonces usa esto. if (! currentVersion.equalsIgnoreCase (onlineVersion)) {....}
Dharmishtha

1
¿Alguna idea de cómo hacerlo sin Jsoup?
Hitesh Sahu

Estimado @HiteshSahu, tendrá que presionar la URL de PlayStore " play.google.com/store/apps/details?id=com.whatsapp&hl=en ". Esta URL de página abierta. Haga clic derecho en la página y haga clic en la opción "Ver código fuente de la página". En el html de la página puede ver un atributo: "<div class =" content "itemprop =" softwareVersion "> 1.2 </div>". Tienes que analizar el html y obtener este indicador manualmente.
Tarun

2
getPackageManager().getPackageInfo(getPackageName(), 0).versionNamePodrías usar BuildConfig.VERSION_NAME:)
Enoobong

1
Es claramente un nombre de clase generado que se puede cambiar en cualquier momento. No deberías hacer esto.
Richard Lindhout

24

Firebase Remote Config podría ser una solución posible y confiable por ahora, ya que Google no expuso ninguna API.

Ver la documentación de Firebase Remote Config

Pasos 1.Cree un proyecto de base de fuego y agregue google_play_service.json a su proyecto

2.Crear claves como "android_latest_version_code" y "android_latest_version_name" en firebase console-> Remote Config

3. Código de 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);
}

Obtener el nombre y el código de la versión actual

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. Y mantenga la base de fuego "android_latest_version_code" y "android_latest_version_name" actualizados con el nombre y el código de su versión de producción actual.

La configuración remota de Firebase funciona tanto en Android como en iPhone.


1
Consulte firebasetutorials.com/… para crear parámetros en Firebase.
CoolMind

Creo que, esta solución puede conducir a un error de compilación: Caused by: com.android.tools.r8.utils.AbortException: Error: null, Cannot fit requested classes in a single dex file (# methods: 68703 > 65536). En este caso, debe agregar MultiDex a su aplicación.
CoolMind

17

Puede obtener actual playstore Versión utilizando JSoupcon algunas modificaciones, como a continuación:

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

La respuesta de @Tarun ya no funciona.


Este es un compañero de trabajo, pero ¿puedo confiar en esto para siempre o cambiará en un futuro cercano?
Avinash Roy

1
No se recomienda confiar en esto porque no es una solución oficial.
Nikunj

@Nikunj Creo una clase GetVersionCode que extiende AsyncTask y cuando escribo su código dentro de esa clase, getPackageName () muestra un error. Intenté esto, GetVersionCode.this pero nada funciona.
Aashish

1
El uso de .select (". HAyfc .htlgb"). Get (7) no es robusto frente a los cambios. Vi otra solución usando el índice 5 en su lugar. Para seleccionar el correcto, utilizo una consulta extendida .select (". HAyfc .BgcNfc: containsOwn (versión actual) + .htlgb.htlgb"). First () .text ()
HarryS

8

La respuesta de @Tarun funcionaba perfectamente. Pero ahora no, debido a los cambios recientes de Google en el sitio web de Google Play.

Simplemente cambie estos de la respuesta de @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);

    }
}

y no olvide agregar la biblioteca JSoup

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

y en 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();

}

eso es todo .. Gracias a este enlace


8

ingrese la descripción de la imagen aquí

Google ha introducido la API de actualizaciones en la aplicación

Actualmente, la API admite dos flujos:

  • El flujo "inmediato" es una experiencia de usuario de pantalla completa que guía al usuario desde la descarga hasta la actualización antes de que pueda usar su aplicación.
  • El "flujo flexible" permite a los usuarios descargar la actualización mientras continúan usando su aplicación.

¡¡¡La mejor respuesta!!! Gracias
Artem Beziazychnyi

7

Hay una biblioteca AppUpdater . Cómo incluir:

  1. Agregue el repositorio a su proyecto build.gradle :
allprojects {
    repositories {
        jcenter()
        maven {
            url "https://jitpack.io"
        }
    }
}
  1. Agregue la biblioteca a su módulo build.gradle :
dependencies {
    compile 'com.github.javiersantos:AppUpdater:2.6.4'
}
  1. Agregue los permisos INTERNET y ACCESS_NETWORK_STATE al manifiesto de su aplicación:
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
  1. Agregue esto a su actividad:
AppUpdater appUpdater = new AppUpdater(this); 
appUpdater.start();

No funciona de todos modos. Usando el siguiente código, dígame qué estoy haciendo mal.
Anurag Srivastava

Hola, creo que hay un error. Consulte esta discusión github.com/javiersantos/AppUpdater/issues/132
stenlytw

6

Procedente de una aplicación híbrida POV. Este es un ejemplo de javascript, tengo un pie de página de Actualización disponible en mi menú principal. Si hay una actualización disponible (es decir, mi número de versión dentro del archivo de configuración es menor que la versión recuperada, mostrar el pie de página) Esto dirigirá al usuario a la aplicación / tienda de juegos, donde el usuario puede hacer clic en el botón actualizar.

También obtengo los datos nuevos (es decir, notas de la versión) y los muestro en un modal al iniciar sesión si es la primera vez en esta versión.

En dispositivo listo, configure la URL de su tienda

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

El método Actualización disponible se puede ejecutar con la frecuencia que desee. El mío se ejecuta cada vez que el usuario navega a la pantalla de inicio.

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

Devolución de llamada de iOS: Apple tiene una API, por lo que es muy fácil de obtener

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('&nbsp;');
        // Release Notes
        settings.updateReleaseNotes('v' + storeVersion, releaseNotes);
    }
}

Devolución de llamada de Android: PlayStore tiene que raspar, como puede ver, la versión es relativamente fácil de agarrar y, lo que es nuevo, tomo el html en lugar del texto, ya que de esta manera puedo usar su formato (es decir, nuevas líneas, etc.)

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('&nbsp;');
        // Release Notes
        settings.updateReleaseNotes('v' + storeVersion, releaseNotes);
    }
}

La lógica de la tienda abierta es sencilla, pero para completar

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

Asegúrese de que Play Store y App Store estén en la lista blanca:

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

Recibo el error "Error al analizar la respuesta ajax: SyntaxError: Token inesperado <". cuando se llama ajax get. ¿Puedes arrojar algo de luz sobre esto? ¿Qué salió mal?
Kapilrc

ios o android? ¿Tu URL es correcta? te lleva a la página correcta en el navegador?
tyler_mitchell

5

Firebase Remote Config es mejor.

  • Actualice rápida y fácilmente nuestras aplicaciones sin la necesidad de publicar una nueva compilación en la aplicación.

Implementar Remote Config en Android

Agregar la dependencia de Remote Config

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

Una vez hecho esto, podemos acceder a la instancia de FirebaseRemoteConfig en toda nuestra aplicación cuando sea necesario:

FirebaseRemoteConfig firebaseRemoteConfig = FirebaseRemoteConfig.getInstance();

Recuperando valores de Remote Config

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

Obtener valores del lado del servidor

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

Ahora, una vez cargada la nueva versión en Play Store, tenemos que actualizar el número de versión dentro de Firebase. Ahora, si es una nueva versión, se mostrará el cuadro de diálogo de actualización.


5

Dentro del método OnCreate, escriba el código a continuación.

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

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

esto le da la versión de Play Store de la aplicación.

entonces tienes que verificar la versión de la aplicación como se muestra a continuación

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

después de eso, puede compararlo con la versión de la tienda y configurar sus propias pantallas de actualización

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

    }

Y agregue VersionChecker.class como se muestra a continuación

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


3

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

Para hacer coincidir el último patrón de Google Play Store, es decir <div class="BgcNfc">Current Version</div><span class="htlgb"><div><span class="htlgb">X.X.X</span></div> , primero tenemos que hacer coincidir la secuencia de nodo anterior y luego de 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;
    }

Lo resolví a través de esto, ya que esto también funciona para los últimos cambios de Google Play Store. Espero que ayude.


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

Proporcione información sobre cómo y para qué funcionará este código
DarkSuniuM


2

Puedes probar el siguiente código usando Jsoup

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

2

ingrese la descripción de la imagen aquíGoogle introdujo la API de actualización en la aplicación. Usando eso, podemos pedirle al usuario que actualice la aplicación dentro de la aplicación. Si el usuario acepta, podemos descargar directamente la última aplicación e instalarla sin redirigir a Play Store. para obtener más detalles, consulte el siguiente enlace

enlace1 enlace2


Me gusta el GIF que hiciste :)
Hunter

1

confirmó solo que el método funciona ahora:

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

1

Google introdujo la función de actualizaciones en la aplicación , ( https://developer.android.com/guide/app-bundle/in-app-updates ) funciona en Lollipop + y le brinda la posibilidad de solicitar al usuario una actualización con un buen diálogo (FLEXIBLE) o con mensaje obligatorio en pantalla completa (INMEDIATO).

Así es como se verá la actualización flexible : ingrese la descripción de la imagen aquí

y aquí está el flujo de actualización inmediato : ingrese la descripción de la imagen aquí

Puede consultar mi respuesta aquí https://stackoverflow.com/a/56808529/5502121 para obtener el código de muestra completo de implementación de flujos de actualización flexibles e inmediatos . ¡Espero eso ayude!

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.