Incrément automatique du code de version dans une application Android

Question

Est-ce qu'il y a un moyen d'auto-incrémenter le code de version chaque fois que vous construisez une application Android dans Eclipse?

According to http://developer.android.com/guide/publishing/versioning.html, vous devez augmenter manuellement votre code de version dans AndroidManifest.xml.

Je comprends, vous devez exécuter un script avant chaque construction qui pourrait, par exemple, analyser le fichier AndroidManifest.xml, trouver le numéro de version, l'incrémenter et enregistrer le fichier avant que la construction elle-même ne commence. Cependant, je n'ai pas pu découvrir comment et si Eclipse prend en charge l'exécution de scripts avant/après les constructions.

J'ai trouvé cet article sur la configuration du constructeur ant, mais il ne s'agit pas exactement d'Android et je crains que cela ne perturbe trop les étapes de construction prédéfinies pour Android?

Cela devrait être un problème courant, comment l'avez-vous résolu?

Eh bien, on peut le faire manuellement, mais dès que vous oubliez de faire cette corvée, vous obtenez des versions différentes avec le même numéro et toute la numérotation perd peu de sens.

Answer 1

J'ai accompli ça. Et voici comment je l'ai fait pour le prochain (en utilisant Eclipse) :

1) Créer un exécutable console externe qui va écrire un nouveau code de version dans AndroidManifest.xml : (le mien est en C#)

using System.IO;
using System.Text.RegularExpressions;

namespace AndroidAutoIncrementVersionCode
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                string FILE = @"AndroidManifest.xml";
                string text = File.ReadAllText(FILE);
                Regex regex = new Regex(@"(?android:versionCode="")(?\d+)(?"")", RegexOptions.IgnoreCase);
                Match match = regex.Match(text);
                int verCode = int.Parse(match.Groups["VER"].Value) + 1;
                string newText = regex.Replace(text, "${A}" + verCode + "${B}", 1);

                File.WriteAllText(FILE, newText);
            }
            catch { }
        }
    }
}

**

remarque : n'importe quel compilateur c-sharp peut construire cette application, vous n'avez pas besoin de Visual Studio ou même de Windows

****2. si vous ne l'avez pas déjà, installez le runtime .NET (Mono fonctionnera, lien) (lien vers le framework .NET 2.0 de Microsoft, 2.0 est le plus petit téléchargement, toute version >= 2.0 fonctionne)

3. copiez ce code dans un fichier *.cs (j'ai nommé le mien : AndroidAutoIncrementVersionCode.cs)
4. ouvrez un terminal et naviguez jusqu'à l'emplacement où vous avez créé votre fichier *.cs
5. construisez le fichier en utilisant cette commande (sur Windows, similaire pour Mono mais changez le chemin du compilateur) : c:\Windows\Microsoft.NET\Framework\v2.0.50727\csc AndroidAutoIncrementVersionCode.cs _(voir : .NET ou Mono pour plus d'informations)_

6. félicitations, vous venez de construire une application C# sans aucun outil, elle aurait dû générer AndroidAutoIncrementVersionCode.exe dans le même répertoire automatiquement

   **les résultats peuvent varier, les chemins peuvent être différents, aucun achat nécessaire, null là où c'est interdit, j'ai ajouté cela parce que C# est génial, et les gens pensent à tort qu'il est verrouillé par MS, vous pourriez tout aussi facilement traduire cela dans une autre langue (mais je ne vais pas le faire pour vous ;). au fait, n'importe quelle version de n'importe quel compilateur .NET fonctionnera, j'ai adapté le code pour le moins commun...*

fin de la remarque

2) Exécuter l'exécutable pendant le processus de construction : a) Aller aux propriétés du projet

b) Dans les propriétés, aller à "Builders" -> "Nouveau..."

c) Choisir "Programme"

d) Dans l'onglet "Principal", sélectionner l'emplacement du programme (j'ai également défini le répertoire de travail pour être sûr) et donnez-lui un nom si vous le souhaitez.

e) Dans l'onglet "Actualiser", sélectionner l'option "Actualiser les ressources à la fin" et "La ressource sélectionnée" - cela actualisera le manifeste après que nous l'ayons écrit.

f) Dans l'onglet "Options de construction", vous pouvez désactiver "Allouer une console" car vous n'avez pas d'entrée ni de sortie, puis sélectionner uniquement "Pendant les constructions manuelles" et "Pendant les constructions automatiques", désélectionner "Après un nettoyage" s'il est coché. Ensuite, sélectionnez "Spécifier un ensemble de ressources pertinentes" et cliquez sur le bouton "Spécifiez les ressources...". Dans la boîte de dialogue "Modifier l'ensemble de travail", localisez votre fichier "AndroidManifest.xml" dans la boîte de dialogue et cochez-le, puis cliquez sur "Terminer"

f) Maintenant appuyez sur "OK" à l'intérieur de la "Boîte de dialogue de modification de la configuration" et dans les propriétés de votre application, sélectionnez le constructeur nouvellement créé, et continuez à cliquer sur "Haut" jusqu'à ce qu'il soit en haut de la liste, de cette façon l'auto-incrément se lance en premier, et ne déclenche pas d'états désynchronisés ou de reconstructions accidentelles. Une fois que le nouveau constructeur que vous avez créé est en haut de la liste, cliquez sur "OK" et vous avez terminé.

**

Answer 2

Ce script shell, adapté aux systèmes *nix, définit le versionCode et la dernière composante de versionName à la révision actuelle de Subversion. J'utilise Netbeans avec NBAndroid et j'appelle ce script depuis la cible -pre-compile de custom_rules.xml.

Enregistrez ce script dans un fichier appelé incVersion dans le même répertoire qu'AndroidManifest.xml, rendez-le exécutable : chmod +x incVersion

manf=AndroidManifest.xml
newverfull=`svnversion`
newvers=`echo $newverfull | sed 's/[^0-9].*$//'`
vers=`sed -n '/versionCode=/s/.*"\([0-9][0-9]*\)".*/\1/p' $manf`
vername=`sed -n '/versionName=/s/.*"\([^"]*\)".*/\1/p' $manf`
verbase=`echo $vername | sed 's/\(.*\.\)\([0-9][0-9]*\).*$/\1/'`
newvername=$verbase$newverfull
sed /versionCode=/s/'"'$vers'"'/'"'$newvers'"'/ $manf | sed /versionName=/s/'"'$vername'"'/'"'$newvername'"'/  >new$manf && cp new$manf $manf && rm -f new$manf
echo versionCode=$newvers versionName=$newvername

Créez ou modifiez custom_rules.xml et ajoutez ceci :

Ainsi, si ma révision SVN actuelle est 82, j'obtiens ceci dans AndroidManifest.xml :

android:versionCode="82"
android:versionName="2.1.82">

Quand je veux publier une nouvelle version, j'actualiserai généralement les premières parties de versionName, mais même si j'oublie, la dernière partie de versionName (qui est affichée dans mon activité À propos) me dira toujours à partir de quelle révision SVN elle a été construite. De plus, si je n'ai pas vérifié des modifications, le numéro de révision sera 82M et versionName sera quelque chose comme 2.1.82M.

L'avantage par rapport à simplement incrémenter le numéro de version à chaque fois qu'une compilation est effectuée est que le numéro reste sous contrôle et peut être directement lié à une révision SVN spécifique. Très utile lors de l'investigation de bugs autres que dans la dernière version publiée.

Answer 3

Pour ce que ça vaut, j'ai pu mettre à jour la valeur de la version de build en six lignes de python :

#!/bin/env python
import os
from xml.dom.minidom import parse
dom1 = parse("AndroidManifest.xml")
dom1.documentElement.setAttribute("android:versionName","%build.number%")
f = os.open("AndroidManifest.xml", os.O_RDWR)
os.write( f, dom1.toxml() )

Answer 4

En s'appuyant sur la réponse de Charles, les lignes suivantes incrémentent la version de construction existante :

#!/usr/bin/python
from xml.dom.minidom import parse

dom1 = parse("AndroidManifest.xml")
oldVersion = dom1.documentElement.getAttribute("android:versionName")
versionNumbers = oldVersion.split('.')

versionNumbers[-1] = unicode(int(versionNumbers[-1]) + 1)
dom1.documentElement.setAttribute("android:versionName", u'.'.join(versionNumbers))

with open("AndroidManifest.xml", 'wb') as f:
    for line in dom1.toxml("utf-8"):
        f.write(line)

Answer 5

Alors, je le vois comme ça:

En fonction de l'article que vous présentez, utilisez ant pour ces tâches (cibles?).

1. analyser le manifeste (analyser XML)
2. obtenir l'ancienne version du manifeste et l'augmenter/obtenir la version du référentiel
3. stocker la nouvelle version dans le manifeste
4. construire l'application Android.

Mais dans mon cas, je remplis généralement ce champ par une valeur basée sur la révision de la tag lorsque je déploie ou distribue l'application.