Comment informer les utilisateurs de la mise à jour d'une application Android?
J'ai construit une application Android qui est maintenant sur Play Market. De temps en temps, je le mets à jour et je tiens à informer les utilisateurs qu'une nouvelle version est disponible.
Comment puis-je envoyer une mise à jour de notification aux utilisateurs de l'application?
Vous n'avez rien à faire pour cela. Puisque vous avez indiqué que vous utilisez Google Play, la notification de mise à jour est prise en charge par Google Play.
Il vous suffit de mettre à jour APK avec une versionCode supérieure et Google Play devrait faire le reste.
Il appartient à chaque propriétaire de téléphone si elle souhaite être informé des nouvelles versions par Google Play, et au fabricant de chaque téléphone de l'activer par défaut.
Toutefois, si vous "obligez" l'utilisateur à mettre à jour sa nouvelle version pour qu'il soit compatible avec une forme de protocole ou si vous avez un cas d'utilisation similaire où vous avez un composant serveur quelque part, vous pouvez en informer le utilisateur d'un conflit de version potentiel dans l'interface utilisateur en fonction d'informations sur la version la plus récente.
Ces informations peuvent être récupérées directement à partir de Google Play. Cependant, comme @Yahel l’a souligné dans cette question , Google Play est un système fermé ne disposant pas d’API officielle et vous devrez peut-être vous fier à des API non documentées imprévisibles. Il existe une bibliothèque d'API non officielle ici .
Cela ne laisse qu'une option, qui consiste à conserver ces informations sur votre propre serveur. Si vous avez déjà un serveur, cela peut être trivial. Il suffit de placer la dernière version dans un fichier XML et de le récupérer à intervalles réguliers dans votre code. Si le code de version est obsolète, déclenchez la notification dans votre interface utilisateur. Voici une implémentation de example pour le faire.
J'espère que cela a été utile :-)
Vous pouvez le faire de différentes manières, en fonction du moment où vous souhaitez que l'utilisateur puisse voir qu'une mise à jour est disponible.
Si vous souhaitez que l'utilisateur connaisse la mise à jour au démarrage de l'application, créez simplement une méthode utilitaire (dans la méthode onCreate de votre activité principale/première) qui vérifie si une version plus récente est disponible dans Google Play. Dans ce cas, affichez une boîte de dialogue d'alerte avec un message pertinent et une intention qui ouvre votre application dans Google Play lorsque l'utilisateur clique sur le bouton positif de la boîte de dialogue d'alerte . Si vous mettez à jour l'application régulièrement, l'utilisateur conservera obtenir cette boîte de dialogue d'alerte chaque fois que l'application est lancée et peut donc être irrité. Ainsi, ce n'est pas la meilleure approche.
Si vous souhaitez que l'utilisateur reçoive une notification sur le téléphone (et non au démarrage de l'application), vous pouvez utiliser la classe AlarmManager pour planifier un service en arrière-plan qui recherche une mise à jour à intervalles réguliers. Si le service constate qu'une mise à niveau est réellement disponible, publiez une notification avec une intention qui ouvre votre application dans Google Play.
Bien sûr, une autre approche consiste à laisser le système d'exploitation lui-même. Si l'utilisateur n'a pas défini la préférence "Mettre à jour automatiquement" pour votre application, il recevra régulièrement une notification à propos d'une mise à jour disponible pour votre application, ainsi que pour toute autre application . , donc ce n’est pas complètement fiable.
Au final, vous devez respecter les préférences de l'utilisateur. Si l'utilisateur ne souhaite pas mettre à jour automatiquement l'application ou ne souhaite pas voir une boîte de dialogue harcelante à chaque démarrage de votre application, n'en avertissez pas l'utilisateur de la mise à jour.
À mon avis, vous devriez créer une PreferenceActivity ayant une préférence du type "Vérifier les mises à jour régulièrement", qui peut être définie à partir de votre application. Si elle est définie, faites le nécessaire dans votre propre service. Peut-être même donner à l'utilisateur une option pour sélectionner la période après laquelle le service vérifiera une mise à jour.
J'espère que ça aide!
Utilisez ceci: https://www.Push-link.com/
Google Play informera vos utilisateurs que l'application contient une mise à jour via la barre de notification.
Si vous configurez vous-même un système de notification, le résultat probable sera que, bien que l'utilisateur soit averti plus tôt d'une mise à jour, il ne sera pas disponible lors de son installation sur Google Play. En effet, il y a un décalage entre le moment où vous "publiez" une application/mise à jour et le temps nécessaire pour qu'il apparaisse en lecture. Dire à vos utilisateurs qu'il existe une mise à jour lorsque la mise à jour est indisponible n'entraînera que confusion et frustration.
Mon conseil: respectez le système de notification des mises à jour de Google et ne craignez pas d'essayer de mettre les utilisateurs à jour 15 minutes plus tôt.
Il existe également une très bonne approche pour vérifier la version et donner une notification à l'utilisateur dans l'application ou lorsque vous souhaitez mettre à jour de force l'application si vous pouvez décider de la première connexion de votre application avec le serveur.En réponse à la première demande La version actuelle de l'application stockée sur votre serveur, puis celle du client, vous permettent de prendre les mesures appropriées . Avantages de cette approche -:
1-Pas de requête supplémentaire pour la version no .
2-Il est également applicable si vous téléchargez une application autre que Google PlayStore .
3-vous pouvez également utiliser cette idée si vous souhaitez vérifier la version lors du fonctionnement particulier de votre application ex-transaction (si vous ajoutez une nouvelle passerelle de paiement.)
La réponse de @ Davek804 ci-dessus est fausse. Android: versionCode est une valeur entière qui représente la version du code de l'application, par rapport aux autres versions. Par conséquent, l'utilisation de "1.5b" est incorrecte. Utilisez "15" (ou "150") à la place
Certaines personnes utilisent Android Messagerie Cloud-to-Device (C2DM) pour informer leurs utilisateurs des mises à jour. Je ne pense pas que cela me dérangerait, car je pense que Google Play m'en avertit déjà des mises à jour et que la mise en œuvre de C2DM ajoute une toute nouvelle dimension à l'écriture d'une application (car elle nécessite un composant serveur). Mais vous souhaitez peut-être offrir à vos utilisateurs une notification de mise à jour plus riche que celle fournie par Google Play.
Trouvez une solution intéressante à votre problème: Supposons que vous souhaitiez vérifier les mises à jour de version manuellement au démarrage de l’application et informer vos utilisateurs de la nouvelle mise à jour.
Étape 1: Téléchargez Android-market-api (pas le fichier .jar, le projet complet!)
Étape 2: après l’importation dans Eclipse, écrivez dans votre activité le code suivant:
MarketService ms = new MarketService(activity);
ms.level(MarketService.REVISION).checkVersion();
maintenant, nous devons modifier MarketService.Java, car il semble être cassé.
Étape 3: réécrire la méthode de rappel et ajouter 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 souhaitez le tester, modifiez la chaîne googlePlayversion en une version plus récente que la version locale.
La méthode de comparaison des sources que j’ai utilisée est de Comment comparez-vous deux chaînes de version en Java?
Cela peut être en utilisant un simple service web, c’est l’un des moyens d’atteindre.
c'est-à-dire que chaque fois que l'application lancera une requête sur ce service Web avec la version actuelle de l'application utilisateur et sur le serveur, vous devez vérifier si une nouvelle version est disponible ou non (vous devez conserver la version la plus récente de l'application) et envoyer la réponse correspondante à l'utilisateur. Si une version plus récente est disponible Demandez à l'utilisateur de télécharger la version la plus récente de l'application. Si aucune version plus récente n'est disponible, autorisez l'utilisateur à continuer.
J'espère qu'au moins quelque chose doit vous être utile.
Je ne sais pas si vous voulez parcourir des kilomètres supplémentaires. Vous pouvez essayer google appengine, qui sert le numéro de version de votre application et vous permet de vérifier si celui-ci est une nouvelle version au lancement de l'application. Ainsi, que votre application soit dans Google Play Market ou sur Amazon App Store, ni qu'elle soit installée sur le téléphone sans ces deux applications via le chargement latéral. Il n’est pas très difficile de configurer Appengine uniquement pour servir la version de votre application dans JSON. Remplacez la chaîne "Hello World" par le nom de version de votre application ...
Deux modèles sont essentiellement utilisés pour résoudre le problème.
Pull Based
Push Based
Cela dépend de l'architecture ou de la conception du système particulier qui détermine si le mécanisme de tirage ou push est utilisé.
Pour les modèles basés sur l'extraction, vous ne faites qu'une requête HTTP au serveur concerné concernant la nouvelle version de l'application. La version actuelle de l'application no peut être enregistrée dans SQLLite dans une application Android. Cela peut être donné au serveur et la nouvelle version peut être vérifiée par rapport au serveur.
Pour le mécanisme Push, vous pouvez utiliser le service de notification C2DM Push. Des informations détaillées sont disponibles à l'adresse http://code.google.com/Android/c2dm/
je pense que c'est trop tard, mais il peut être utile d'aider quelqu'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;
}
}
Généralement, lorsque vous téléchargez une nouvelle application sur Google Play, la plupart des utilisateurs reçoivent une notification relative à une mise à jour. Certains téléchargeront automatiquement l'application téléchargée sur leur appareil, en fonction de leurs paramètres. Si vous souhaitez sérieusement envoyer une notification à partir de votre pour leur demander de se mettre à jour (pour que tout le monde reçoive la notification, quels que soient leurs paramètres de jeu Google, vous devrez créer un service Web qui renverra le numéro de la version la plus récente. Vous pourrez ensuite comparer cela dans votre application et poster Vous pouvez utiliser Google App Engine ( https://developers.google.com/appengine/ ) car cela fonctionne avec Eclipse et Java, ce que vous avez probablement déjà . Je ne recommanderais pas cette approche car vous devez fournir quelque chose que la plupart des utilisateurs ont déjà.