Comment notifiy les utilisateurs d'une Application Android mise à jour?

Il appartient à chaque propriétaire de téléphone si elle veut être informé sur les nouvelles versions de google play, et c'est à chacun de téléphone du fabricant si c'est activé par défaut.

Si vous êtes dans une situation où vous avez "besoin" de l'utilisateur pour mettre à jour vers la nouvelle version pour être compatible avec une certaine forme de protocole ou si vous avez une semblable semblable cas où vous disposez d'un composant de serveur quelque part, vous souhaiterez peut-être avertir l'utilisateur d'un éventuel conflit de version de l'INTERFACE utilisateur basée sur des informations sur ce qui est la version la plus récente.

Cette information peut être extraite directrly à partir de google play, cependant, comme @Yahel a souligné dans cette question google play est un système fermé qui n'officielle de l'API, et vous pourriez avoir besoin de s'appuyer sur imprévisibles sans-papiers de l'API. Il y a un officieux de l'API de la bibliothèque ici.

Il ne reste qu'une option, qui est de conserver ces informations sur votre propre serveur. Si vous déjà avez un serverside cela pourrait être facile. Suffit de mettre la dernière version dans un fichier XML et récupérer ce, à intervalles réguliers, à partir de votre code. Si le code de version est obsolète, déclencher la notification dans votre INTERFACE utilisateur. Voici un exemple de mise en œuvre pour le faire.

J'espère que cela a été utile 🙂

Utiliser ceci : https://www.push-link.com/

Certaines personnes utilisent Android Cloud to Device de Messagerie (C2DM) pour informer leurs utilisateurs des mises à jour. Je ne pense pas que je me donnerais la peine, car je pense que Google Play fait un assez bon travail de la notification de mises à jour déjà, et la mise en œuvre de C2DM ajoute une toute nouvelle dimension à l'écriture d'une application (car il nécessite un composant de serveur). Mais peut-être que vous voulez offrir à vos utilisateurs un plus riche notification de mise à jour que vous obtenez à partir de Google Play.

Trouvé une belle solution pour votre problème:
Disons que vous voulez vérifier pour la version manuellement les mises à jour sur l'application de début et de prévenir les utilisateurs de la nouvelle mise à Jour.

Étape 1: Télécharger android-market-api (pas la .fichier jar, le projet complet!)

Étape 2: Après l'importer dans eclipse, écris-le dans votre activité le code suivant:

MarketService ms = new MarketService(activity);
ms.level(MarketService.REVISION).checkVersion();

maintenant, nous avons besoin de modifier MarketService.java car elle semble être rompu.

Étape 3: réécriture de la méthode de rappel et ajoutez les méthodes suivantes

protected void callback(String url, JSONObject jo, AjaxStatus status){      
if(jo == null) return;
String googlePlayversion = jo.optString("version", "0");
String smartphone_version = "";
PackageInfo pInfo;
try {
pInfo = act.getPackageManager().getPackageInfo(act.getPackageName(), 0);
smartphone_version = pInfo.versionName;
} catch (NameNotFoundException e) {}
boolean new_version_avaible = compare(smartphone_version, googlePlayversion);
if(new_version_avaible){
showUpdateDialog(jo);
}
}
private static boolean compare(String v1, String v2) {
String s1 = normalisedVersion(v1);
String s2 = normalisedVersion(v2);
int cmp = s1.compareTo(s2);
String cmpStr = cmp < 0 ? "<" : cmp > 0 ? ">" : "==";
System.out.printf("result: "+"'%s' %s '%s'%n", v1, cmpStr, v2);
if(cmpStr.contains("<")){
return true;
}
if(cmpStr.contains(">")||cmpStr.contains("==")){
return false;
}
return false;
}
public static String normalisedVersion(String version) {
return normalisedVersion(version, ".", 4);
}
public static String normalisedVersion(String version, String sep, int maxWidth) {
String[] split = Pattern.compile(sep, Pattern.LITERAL).split(version);
StringBuilder sb = new StringBuilder();
for (String s : split) {
sb.append(String.format("%" + maxWidth + 's', s));
}
return sb.toString();
}

Si vous voulez le tester, modifier googlePlayversion chaîne à une version plus récente de votre local.

La source de comparaison de la méthode que j'ai utilisé est de Comment comparer deux Chaînes de version de Java?

Ne sais pas si vous voulez marcher miles supplémentaires. Vous pouvez essayer google appengine, qui servent numéro de version de votre application et laissez-vous android app vérifier l'appengine pour voir si il y a une nouvelle version quand l'application est lancée. De cette façon, il n'a pas d'importance si votre application dans le google play store, ni amazon app store, ni si elle est installée sur le téléphone sans ces deux via sideloading. Il n'est pas très difficile à configurer appengine juste pour servir la version de votre application en json. Remplacer "Hello World" de la chaîne avec votre version de l'application nom de ...

Il y a deux modèles qui sont utilisés essentiellement pour s'attaquer à la question.

Pull Based
Push Based

Sa dépend de l'architecture ou de conception de système particulier qui détermine si vous tirez ou poussez le mécanisme utilisé.

Pour la traction en fonction du modèle que vous venez de faire une requête http au serveur concerné au sujet de la nouvelle version de l'application. L'actuelle version de l'application ne peuvent être enregistrés dans SQLLite dans l'application android. Cela peut être donné au serveur et à la nouvelle version peut être vérifié par rapport au serveur.

Pour pousser le mécanisme vous pouvez utiliser C2DM service de notification push.. dont les détails sont donnés à http://code.google.com/android/c2dm/

je pense que c'est trop tard, mais il peut être en aider quelques un

public enum AppVersionUpgradeNotifier {
INSTANCE;
private static final String TAG = "AppVersionUpdateManager";
private static final String PREFERENCES_APP_VERSION = "pref_app_version_upgrade";
private static final String KEY_LAST_VERSION = "last_version";
private SharedPreferences sharedPreferences;
private VersionUpdateListener versionUpdateListener;
private boolean isInitialized;
public static synchronized void init(Context context, VersionUpdateListener versionUpdateListener) {
if (context == null || versionUpdateListener == null) {
throw new IllegalArgumentException(TAG + " : Context or VersionUpdateListener is null");
}
if (!INSTANCE.isInitialized) {
INSTANCE.initInternal(context, versionUpdateListener);
} else {
Log.w(TAG, "Init called twice, ignoring...");
}
}
private void initInternal(Context context, VersionUpdateListener versionUpdateListener) {
this.sharedPreferences = context.getSharedPreferences(PREFERENCES_APP_VERSION, Context.MODE_PRIVATE);
this.versionUpdateListener = versionUpdateListener;
this.isInitialized = true;
checkVersionUpdate();
}
private void checkVersionUpdate() {
int lastVersion = getLastVersion();
int currentVersion = getCurrentVersion();
if (lastVersion < currentVersion) {
if (versionUpdateListener.onVersionUpdate(currentVersion, lastVersion)) {
upgradeLastVersionToCurrent();
}
}
}
private int getLastVersion() {
return sharedPreferences.getInt(KEY_LAST_VERSION, 0);
}
private int getCurrentVersion() {
return BuildConfig.VERSION_CODE;
}
public void upgradeLastVersionToCurrent() {
sharedPreferences.edit().putInt(KEY_LAST_VERSION, getCurrentVersion()).apply();
}
public interface VersionUpdateListener {
boolean onVersionUpdate(int newVersion, int oldVersion);
}

}

l'utiliser sur

public class MyApplication extends Application implements AppVersionUpgradeNotifier.VersionUpdateListener {
@Override
public void onCreate() {
super.onCreate();
AppVersionUpgradeNotifier.init(this,this);
}
@Override
public boolean onVersionUpdate(int newVersion, int oldVersion) {
//do what you want
return true;
}

}