android - tinder - Consulta programáticamente Play Store para conocer las actualizaciones de la aplicación
apps para ligar 2018 (13)
He puesto mi aplicación en Google Play Store. Ha sido instalado por muchos de los clientes de mi empresa. Entiendo el mecanismo de cómo se pretende actualizar 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 comprobado en primer lugar.
La aplicación que he escrito es para la industria del cuidado y la usan los cuidadores para brindar atención domiciliaria. Algunos de nuestros clientes tienen 1200 cuidadores. Tendrían que llamar a todos los cuidadores a la oficina para actualizar los teléfonos de forma individual. Esto es obviamente inaceptable.
¿Hay alguna forma de verificar programáticamente 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 inicie la aplicación que visita Play Store? Si hay una versión actualizada, el usuario podría ser dirigido a la tienda de juegos. Esto significa que no es esencial que se verifique la actualización automática.
Gracias por adelantado
Mate
AFAIK, no hay una API oficial de Google que admita esto.
Debes considerar obtener un número de versión de una API.
En lugar de conectarse a API externas o páginas web (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 la 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 actualización de la versión sea automática, y envíe una notificación cuando algo salga mal)
Debes obtener este valor de tu página de Google Play Store:
<div class="content" itemprop="softwareVersion"> x.x.x </div>
Compruebe en su aplicación si la versión utilizada en el dispositivo móvil está por debajo del número de versión mostrado en su propia API.
Muestra una indicación de que él / ella necesita actualizar con una notificación, idealmente.
Cosas que puedes hacer
Número de versión con su propia API
Pros:
- No es necesario cargar todo el código de Google Play Store (guarda en datos / ancho de banda)
Contras:
- El usuario puede estar fuera de línea, lo que hace que el chequeo 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 fuera de línea, lo que hace que el chequeo sea inútil ya que no se puede acceder a la API
- El uso de este método puede costarles 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.
Además de usar JSoup, alternativamente podemos hacer una coincidencia de patrones para obtener la versión de la aplicación desde PlayStore.
Para que coincida con el último patrón de Google playstore, por ejemplo, <div class="BgcNfc">Current Version</div><span class="htlgb"><div><span class="htlgb">XXX</span></div> primero tenemos que hacer coincidir 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;
}
Lo solucioné a través de esto, ya que esto también funciona para los últimos cambios en Google playstore. Espero que ayude.
Configure un servidor que exponga una url HTTP que informe la última versión, luego use un AlarmManager para llamar a esa URL y ver si la versión en el dispositivo es la misma que la última versión. Si no aparece un mensaje o notificación, envíelos al mercado para actualizar.
Hay algunos ejemplos de código: ¿cómo permitir que los usuarios verifiquen la última versión de la aplicación desde el interior de la aplicación?
Este Uno Funciona .. Probado ..
@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(5)
.ownText();
return newVersion;
} catch (Exception e) {
return newVersion;
}
}
@Override
protected void onPostExecute(String onlineVersion) {
super.onPostExecute(onlineVersion);
Log.d("update", "playstore version " + onlineVersion);
}
Consulta programáticamente Play Store para conocer las actualizaciones de la aplicación
Hay una biblioteca AppUpdater . Cómo incluir:
- Agregue el repositorio a su proyecto build.gradle :
allprojects { repositories { jcenter() maven { url "https://jitpack.io" } } }
- Agregue la biblioteca a su módulo build.gradle :
dependencies { compile ''com.github.javiersantos:AppUpdater:2.6.4'' }
- Agregue permisos de 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"/>
- Agregue esto a su actividad:
AppUpdater appUpdater = new AppUpdater(this); appUpdater.start();
Incluye JSoup en tu archivo build.gradle de aplicaciones:
dependencies {
compile ''org.jsoup:jsoup:1.8.3''
}
y obtener una 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("div[itemprop=softwareVersion]")
.first()
.ownText();
return newVersion;
} catch (Exception e) {
return newVersion;
}
}
@Override
protected void onPostExecute(String onlineVersion) {
super.onPostExecute(onlineVersion);
if (onlineVersion != null && !onlineVersion.isEmpty()) {
if (Float.valueOf(currentVersion) < Float.valueOf(onlineVersion)) {
//show dialog
}
}
Log.d("update", "Current version " + currentVersion + "playstore version " + onlineVersion);
}
Para obtener más información, visite: http://revisitingandroid.blogspot.in/2016/12/programmatically-check-play-store-for.html
La respuesta @Tarun funcionaba perfectamente. Pero ahora no, debido a los cambios recientes de Google en el sitio web de google play.
Simplemente cámbielos de @Tarun answer ..
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 te olvides de 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
No hay una API oficial de GooglePlay para hacerlo.
Pero puede usar esta biblioteca no oficial para obtener datos de la versión de la aplicación.
Y, si lo anterior no funciona para usted, siempre puede conectarse http a la página de su aplicación (por ejemplo, https://play.google.com/store/apps/details?id=com.shots.android&hl=en ) y analizar el campo "Versión actual".
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, visualice el pie de página). Esto dirigirá al usuario a la aplicación / play store, donde el usuario puede hacer clic en el botón de actualización.
También recibo los datos nuevos (es decir, las Notas de la versión) y los visualizo en un modal al iniciar sesión si es la primera vez que aparece en esta versión.
En el 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 de actualización disponible se puede ejecutar tantas veces como 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 conseguir
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);
}
}
Devolución de llamada de Android: PlayStore debe raspar, ya que puede ver que la versión es relativamente fácil de capturar y lo nuevo es tomar el html en lugar del texto, de esta forma puedo usar su formateo (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('' '');
// Release Notes
settings.updateReleaseNotes(''v'' + storeVersion, releaseNotes);
}
}
La lógica de la tienda abierta es directa, 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 hayan sido incluidos en la lista blanca:
<access origin="https://itunes.apple.com"/>
<access origin="https://play.google.com"/>
Puede intentar seguir el código usando Jsoup
String latestVersion = doc.getElementsContainingOwnText("Current Version").parents().first().getAllElements().last().text();
Puede obtener la versión Playstore actual utilizando JSoup con 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.
confirmó que solo ese 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();
La configuración remota de Firebase podría ser una solución posible y confiable por el momento, ya que Google no le mostró ninguna API.
Comprobar los documentos de Firebase Remote Config
Pasos 1.Crea un proyecto de firebase y agrega google_play_service.json a tu proyecto
2. Cree claves como "android_latest_version_code" y "android_latest_version_name" en la consola de Firebase-> 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 firebase "android_latest_version_code" y "android_latest_version_name" actualizados con su nombre y código de versión de producción actuales.
La configuración remota de Firebase funciona tanto en Android como en iPhone.