Gestion du code de version et compatibilité des mises à jour sur Google Play
1. Deux champs, deux rôles totalement différents. Le guide de gestion des versions de Google les définit séparément : versionCode est « un entier positif utilisé comme numéro de version interne. Ce numéro aide à déterminer si une version est plus récente qu'une autre, les nombres plus élevés indiquant des versions plus récentes. Ce n'est pas le numéro de version affiché aux utilisateurs ; ce numéro est défini par le paramètre versionName. Le système Android utilise la valeur versionCode pour se protéger contre les rétrogradations en empêchant les utilisateurs d'installer un APK dont le versionCode est inférieur à celui de la version actuellement installée sur leur appareil. » versionName est « une chaîne utilisée comme numéro de version affiché aux utilisateurs... Le versionName est la seule valeur affichée aux utilisateurs. » L'aide de la Play Console ajoute le détail opérationnel sur lequel les développeurs trébuchent en premier : versionCode est « un entier 32 bits qui augmente systématiquement à chaque nouvelle version » tandis que versionName est « une chaîne qui représente le numéro de version visible par l'utilisateur, par exemple "1.0.0", "1.1 Beta", "2.0". » Le marketing peut renommer 4.9 en 5.0 librement ; dès que l'entier ne progresse plus, l'envoi échoue. (§https://developer.android.com/studio/publish/versioning / §https://support.google.com/googleplay/android-developer/answer/17367361)
2. Le filtre d’envoi de Play repose sur une seule comparaison, et elle est strictement supérieure. La liste officielle des exigences de mise à jour énonce trois conditions impératives, dans cet ordre : « Le nom de package de l’app bundle Android mis à jour doit être identique à celui de la version actuelle. Le code de version doit être supérieur à celui de la version actuelle… L’app bundle mis à jour doit être signé avec la même signature que la version actuelle. » Il n’existe pas de voie « égalité acceptée si le binaire diffère », et il n’y a rien à argumenter lors de l’examen : le contrôle est mécanique et s’effectue avant qu’un humain ou un bot de politique ne voie la version. (§https://support.google.com/googleplay/android-developer/answer/9859350)
3. Un versionCode n'est jamais réutilisable, et le pool appartient à l'application, pas au canal. Le guide de versioning est sans ambiguïté : « Vous ne pouvez pas téléverser un APK sur le Play Store avec un versionCode déjà utilisé pour une version précédente. » Dans la console, cela se traduit par le rejet bien connu « Le code de version X a déjà été utilisé. » Comme le compteur est rattaché à l'application (le nom de package), le test interne, le test fermé, le test ouvert et la production puisent tous dans la même séquence ; pour placer le même build sur un second canal, vous l'ajoutez « depuis la bibliothèque » plutôt que de le téléverser à nouveau. Un nom de package distinct — une app de staging, une déclinaison en marque blanche avec son propre applicationId — dispose de sa propre séquence, et c'est précisément pourquoi une app de staging est l'endroit idéal pour consommer des codes pendant le débogage. (§https://developer.android.com/studio/publish/versioning)
4. Le plafond est de 2 100 000 000, et l’atteindre n’est pas un ticket d’assistance, c’est un état final. Les deux documents indiquent le même chiffre : « La valeur maximale autorisée par Google Play pour versionCode est 2100000000. » La page de la console précise la conséquence : « Si le versionCode de votre application atteint ou dépasse la limite maximale, vous ne pourrez plus téléverser de nouveaux APK ni app bundles sur Google Play pour cette application. Cela signifie plus de corrections de bugs, de nouvelles fonctionnalités ni de mises à jour de compatibilité pour vos utilisateurs. » Le seul recours mentionné par Google est que « Google Play pourra peut-être fournir une assistance » — un peut-être, pas un bouton de réinitialisation. Pour une entreprise qui tire ses revenus d’applications en ligne, ce nombre est donc un actif à durée de vie limitée, et il doit être dépensé comme tel. (§https://support.google.com/googleplay/android-developer/answer/17367361)
5. Trois habitudes de numérotation épuisent la plage plus vite que les développeurs ne l'imaginent. Les horodatages Unix en secondes dépassent déjà 1,79 milliard et grimpent à chaque build ; un compteur de CI global partagé entre branches, variantes et applications sœurs s'emballe à chaque pipeline en échec ; et « numéro de build = nombre de commits » explose dès qu'un historique de monorepo est réécrit. La liste de mesures d'atténuation de Play est la suivante : « Adoptez une stratégie durable pour le code de version : mettez en place une génération de code de version qui garantisse une progression graduelle et cohérente, et évite une consommation rapide de la plage disponible. Surveillez l'utilisation du code de version : suivez régulièrement la progression du code de version de votre application pour anticiper l'approche de la limite. Mettez en place des contrôles automatisés : intégrez des contrôles dans vos processus de build et de publication pour avertir ou empêcher l'utilisation de valeurs de code de version excessivement élevées. » (§https://support.google.com/googleplay/android-developer/answer/17367361)
6. Les codes sont consommés par l’envoi, pas par la publication. Envoyer vers le test interne, déposer un bundle dans la bibliothèque ou créer une version en brouillon ensuite abandonnée consomme le numéro dans tous les cas — « Ajouter depuis la bibliothèque » existe précisément parce que le même binaire peut être rattaché à une version ultérieure, mais jamais recréé. Quiconque « envoie un build sur la console pour voir s’il passe » paie un numéro de version par tentative ; sur une application à longue durée de vie avec un pipeline rapide, c’est ainsi qu’une marge confortable devient une crise des années plus tard.
7. L’arrêt n’est pas un retour arrière, car Android refuse les rétrogradations. La règle au niveau du système citée au point 1 (un appareil n’installera pas un versionCode inférieur à celui déjà installé) explique pourquoi aucun bouton de la console ne ramène les utilisateurs au build de la semaine dernière. Les recommandations de Google sur le déploiement progressif disent la même chose sur le plan opérationnel : « Si vous constatez un problème avec votre app bundle existant, créez et déployez une nouvelle version avec un app bundle corrigé. » La seule véritable récupération après un mauvais build de production est donc un nouveau bundle, avec un versionCode supérieur à celui du build défectueux, livré aussi vite que l’examen le permet — ce qui explique précisément pourquoi l’emplacement d’urgence de votre schéma de numérotation doit exister avant que vous en ayez besoin. (§https://support.google.com/googleplay/android-developer/answer/6346149)
8. Le déploiement progressif est un outil réservé aux mises à jour, et il n’avance jamais tout seul. « You can release an app update to production and test tracks using a staged rollout. With a staged rollout, your update reaches only a percentage of your users, which you can increase over time. Staged rollouts can only be used for app updates, not when publishing an app for the first time. » Et le piège qui laisse les versions bloquées à 5 % pendant une semaine : « your app's staged rollout percentage won't increase automatically. » Celui qui pilote la mise en ligne doit revenir relever le pourcentage ; rien du côté de Google ne le fera. Les utilisateurs ne sont pas non plus informés qu’ils ont reçu une mise à jour progressive — « Users won't be notified if they receive a version of your app in a staged rollout » — le retour d’expérience sur une version progressive doit donc être tiré des vitals et du support, pas des avis. (§https://support.google.com/googleplay/android-developer/answer/6346149)
9. Ce que change réellement l'interruption d'un déploiement progressif. « Si vous découvrez un problème, vous pouvez interrompre un déploiement progressif pour limiter le nombre d'utilisateurs touchés par le problème dans votre application. Lorsque vous interrompez un déploiement progressif, aucun utilisateur supplémentaire ne recevra la version de l'application concernée par le déploiement en cours. Les utilisateurs ayant déjà reçu cette version resteront sur celle-ci. » Deux conséquences échappent souvent : reprendre ne rebat pas les cartes de l'audience — « Lorsque vous interrompez puis reprenez le déploiement de votre version, vous toucherez le même ensemble d'utilisateurs » — et démarrer une nouvelle version avant la fin de la précédente réutilise cette même cohorte : « Lorsque vous effectuez un déploiement progressif d'une nouvelle version avant d'avoir terminé celui de la version précédente, la nouvelle version utilisera le même groupe d'utilisateurs que la précédente (selon le pourcentage du déploiement). » Votre correctif est validé par les mêmes 5 % malchanceux, pas par un nouvel échantillon. (§https://support.google.com/googleplay/android-developer/answer/6346149)
10. Interrompre une version entièrement déployée : ce que cela fait, et ce que cela ne fait pas. « Si vous découvrez un problème critique dans votre application, la fonction d'interruption du déploiement limite la gêne pour les utilisateurs en empêchant les nouveaux utilisateurs comme les utilisateurs existants d'installer ou de mettre à jour vers la version concernée de votre application. Lorsque vous interrompez un déploiement complet, la version précédente de votre application redevient disponible pour les nouveaux utilisateurs, ainsi que pour toute personne n'utilisant pas la version interrompue. » Il s'agit d'un changement de diffusion, pas d'une désinstallation : « La version interrompue ne sera plus diffusée aux utilisateurs », mais les appareils qui l'ont déjà reçue la conservent, là encore en raison de la protection contre les rétrogradations. Trois limites figurent sur la même page : cela fonctionne « sur n'importe quel canal, à l'exclusion des canaux de test interne » ; « Vous ne pouvez pas interrompre votre première version sur un canal » ; et « Si votre version précédente présente une violation de politique, elle ne peut pas être utilisée à la place de votre version interrompue. » Une reprise ultérieure peut viser n'importe quel pourcentage, ce qui est la bonne façon de réintroduire progressivement un build figé. (§https://support.google.com/googleplay/android-developer/answer/16285429)
11. Une seule version en cours par canal — et c’est ce qui bloque un correctif urgent au pire moment. « Vous ne pouvez pas créer une nouvelle version tant que des versions sont en cours. Déployez à 100 % les versions progressives, ou supprimez les modifications sur la page Vue d’ensemble de la publication et abandonnez les versions non publiées. » Un déploiement progressif abandonné à 20 %, une soumission à l’examen à moitié terminée ou un blocage de publication gérée laissé sur le canal de production se dresseront entre vous et le build d’urgence. L’habitude qui l’évite : après chaque version, bouclez le processus — déployez à 100 %, ou supprimez et abandonnez — et consignez l’état dans le journal des versions pour que la personne suivante (ou vous-même plus tard) ne débogue pas une console qui refuse d’ouvrir une nouvelle version. (§https://support.google.com/googleplay/android-developer/answer/9859348)
12. Un schéma de numérotation qui tient dix ans de versions. Réservez des plages à largeur fixe pour que l’arithmétique reste lisible et que le plafond reste lointain : versionCode = major * 100000 + minor * 1000 + patch * 10 + hotfix, ce qui autorise les majeures de 1 à 20999, mille mineures et dix emplacements patch/hotfix chacune. Gardez la plage de travail visiblement sous 2,1 milliards dans votre script de build et faites échouer le build (pas l’upload) lorsque la valeur calculée franchit un seuil souple que vous fixez, par exemple, à 1,5 milliard. Donnez à la CI l’autorité de n’incrémenter qu’à l’upload, jamais à chaque commit ; exécutez chaque build exploratoire sous l’applicationId de staging pour que ses codes soient consommés sur une autre séquence ; et consignez le versionCode livré dans les notes de version afin que le numéro soit auditable plutôt que relevant du savoir tribal.
13. Liste de vérification avant envoi qui couvre tout ce qui précède en une seule passe : (a) le versionCode est strictement supérieur à tous les codes jamais envoyés pour cette application, sur tous les canaux — pas seulement celui que vous ciblez ; (b) le versionName n'est qu'un texte d'affichage et peut se répéter ou sauter librement ; (c) le nom de package est inchangé et le bundle est signé avec la clé de signature active — changer la clé de signature de l'application signifie que « les utilisateurs des canaux interne et fermé qui ont déjà installé votre application ne recevront plus de mises à jour. Ces utilisateurs doivent désinstaller puis réinstaller l'application pour recevoir les mises à jour » ; (d) le chemin de mise à jour est testé sur un appareil qui a déjà la version précédente installée, car une installation propre ne prouve rien sur une mise à jour ; (e) le numéro est vérifié par rapport au plafond de 2 100 000 000 et à votre propre seuil d'alerte ; (f) aucune autre version n'est laissée en attente sur le canal cible ; et (g) un emplacement de code d'urgence est encore libre dans la bande actuelle. Chacun de ces points est un champ ou un état, pas une question de jugement — c'est pourquoi toute la liste peut vivre dans la CI et dans la liste de vérification de version plutôt que dans la mémoire de quelqu'un. (§https://support.google.com/googleplay/android-developer/answer/9859348)