Android应用程序中自动递增版本代码

Question

每次在 Eclipse 中构建 Android 应用程序时，有没有办法自动递增版本代码？

根据http://developer.android.com/guide/publishing/versioning.html，你有手动增加 AndroidManifest.xml 中的版本代码。

据我了解，您必须在每次构建之前运行一个脚本，例如解析 AndroidManifest.xml 文件、查找版本号、递增版本号并在构建本身开始之前保存文件。但是，我无法了解 Eclipse 如何以及是否支持在构建之前/之后运行脚本。

我找到了关于配置 ant builder 的 这篇文章，但这不是完全是关于 Android 的，我担心这会扰乱 Android 的预定义构建步骤？

应该是常见问题，请问你是怎么解决的？

好吧，人们可以手动执行此操作，但是一旦您忘记执行此操作，您就会得到具有相同编号的不同版本，并且整个版本控制就没有意义了。

Answer 1

我做到了这一点。以下是我为下一个人所做的事情（使用 Eclipse）：

1) 创建一个外部控制台可执行文件，它将向 AndroidManifest.xml 写入新版本代码：（我的是 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(@"(?<A>android:versionCode="")(?<VER>\d+)(?<B>"")", 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 { }
        }
    }
}

放在一边：任何 c-sharp 编译器都可以构建此应用程序，您不需要 Visual Studio 甚至 Windows（

1. 如果您还没有），请安装 .NET 运行时（Mono 可以工作，链接） (链接到MS的.NET Framework 2.0，2.0是最小的下载，任何版本>=2.0都是很好）
2. 将此代码复制到 *.cs 文件（我将其命名为：AndroidAutoIncrementVersionCode.cs）
3. 打开命令提示符并导航到您创建的位置*.cs 文件
4. 使用以下命令构建文件（在 Windows 上，与 Mono 类似，但更改编译器的路径）：
   c:\Windows\Microsoft.NET\Framework\v2.0.50727\csc AndroidAutoIncrementVersionCode.cs
   （请参阅：.NET 或 Mono 了解更多信息）

5. 恭喜，您刚刚构建了一个 C# 应用程序，没有任何工具，它应该已经生成AndroidAutoIncrementVersionCode.exe自动在同一目录

   **里程可能会有所不同，路径可能会有所不同，无需购买，在禁止的地方无效，我添加此内容是因为 C# 非常棒，人们错误地认为它具有 MS 锁定，您可以轻松地将其转换为另一个语言（但我不会为你这样做；）。顺便说一句，任何 .NET 编译器的任何版本都可以工作，我调整了最小公分母的代码...*

结束一边

2）在构建过程中运行可执行文件：
a) 转到项目属性

b) 在属性中，转到“Builders” -> “新建...”

c) 选择“程序”

d) 在“主”选项卡中选择程序位置（我还将工作目录设置为安全）并根据需要为其命名。

e) 在“刷新”选项卡中选择“完成后刷新资源”和“所选资源”选项 - 这将在我们编写清单后刷新清单。

f) 在“构建选项”选项卡中，您可以关闭“分配控制台”，因为您没有输入和输出，然后仅选择“手动构建期间”和“自动构建期间”，如果选中则取消选择“清理后”。然后选择“指定相关资源的工作集”并单击“指定资源...”按钮。在“编辑工作集”对话框中，找到“AndroidManifest.xml”文件并检查它，然后单击“完成”

f) 现在在“编辑配置对话框”中点击“确定”，然后在应用程序的属性中选择新创建的构建器，然后继续单击“向上”，直到它位于列表顶部，这样自动增量首先运行，并且不会触发意外的不同步状态或重建。一旦您创建的新构建器位于列表顶部，单击“确定”即可完成。

Answer 2

此 shell 脚本适用于 *nix 系统，将 versionCode 和 versionName 的最后一个组成部分设置为当前的 subversion 修订版。我将 Netbeans 与 NBAndroid 结合使用，并从 custom_rules.xml 中的目标预编译中调用此脚本。

将此脚本保存在与 AndroidManifest.xml 相同的目录中名为 incVersion 的文件中，使其可执行： 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

创建或编辑 custom_rules.xml 并添加以下内容：

<?xml version="1.0" encoding="UTF-8"?>
<project name="custom_rules">
    <xmlproperty file="AndroidManifest.xml" prefix="mymanifest" collapseAttributes="true"/>
    <target name="-pre-compile">
        <exec executable="./incVersion" failonerror="true"/>
    </target>
</project>

因此，如果我当前的 svn 修订版是 82 ，我最终在 AndroidManifest.xml 中得到了这样的结果：

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

当我想发布新版本时，我通常会更新 versionName 的第一部分，但即使我忘记了，versionName 的最后一部分（公开的）在我的“关于”活动中）总是会告诉我它是从哪个 svn 版本构建的。另外，如果我没有签入更改，则修订号将为 82M，版本名称将类似于 2.1.82M。

与每次构建完成时简单地增加版本号相比，其优点是版本号始终处于控制之下，并且可以直接与特定的 svn 修订版相关。在调查最新版本以外的错误时非常有用。

Answer 3

FWIW，我能够用六行 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

在 Charles 的回答的基础上，以下内容增加了现有的构建版本：

#!/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

所以，我是这样看的：

根据您提出的文章，使用 ant 来完成此任务（目标？）。

1. 解析清单（解析XML）
2. 从清单中获取旧版本并增加它/从存储
3. 库获取版本在清单构建Android应用程序中存储新版本
4. 。

但就我而言，当我部署或分发应用程序时，我通常会根据标签的修订版按值填充此字段。

Answer 6

收据：

要在每次运行构建时自动将 AndroidManifest.xml 中的清单元素的 android:versionCode 属性设置为当前时间（以秒为单位的纪元，从 unix shell 获取），请将其添加到您的-custom_rules.xml Android 文件中的预构建目标。

<target name="-pre-build">
  <exec executable="date" outputproperty="CURRENT_TIMESTAMP">
    <arg value="+%s"/>
  </exec>
  <replaceregex file="AndroidMainfest.xml" match="android:versionCode=.*"
    replace='android:versionCode="${CURRENT_TIMESTAMP}"' />
</target>

确认测试：

使用 Android 项目目录中的以下 shell 命令获取生成的 apk 文件的 versionCode 属性：

$ANDROID_SDK/build-tools/20.0.0/aapt dump badging bin/<YourProjectName>.apk | grep versionCode

并将其与 shell 命令返回的当前日期进行比较：date +% s
差异应等于上述两个确认步骤之间的时间段（以秒为单位）。

这种方法的优点：

1. 无论构建是从命令行还是从 Eclipse 启动，都会更新 versionCode。
2. versionCode 保证是唯一的，并且每次构建都会增加
3. 如果需要的话，versionCode 可以被逆向工程为近似的构建时间
4. 上面的脚本替换了 versionCode 的任何当前值，甚至是 0，并且不需要宏占位符（例如-build_id-)。
5. 由于该值在 AndroidManifest.xml 文件中更新，因此您可以将其签入版本控制，它将保留实际值，而不是某些宏（例如 -build_id-）。

Answer 7

建立在 Rocky 的答案 的基础上，我稍微增强了 python 脚本以增加 versionCode，在 Eclipse 上适用于我（按照 < a href="https://stackoverflow.com/a/8156809/823934">ckozl 很棒的教程） Mac OSX

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

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

versionNumbers[-1] = unicode(int(versionNumbers[-1]) + 1)
dom1.documentElement.setAttribute("android:versionName", u'.'.join(versionNumbers))
dom1.documentElement.setAttribute("android:versionCode", str(int(oldVersionCode)+1))
with open("AndroidManifest.xml", 'wb') as f:
    for line in dom1.toxml("utf-8"):
        f.write(line)

也不要忘记 chmod +x autoincrement.py 并确保第一行有正确的 python 路径（取决于您的环境），如 sulai 指出

Answer 8

我已经做了类似的事情，但将其编写为桌面 AIR 应用程序，而不是一些外部 C#（不觉得安装另一个构建系统）。构建此 Flex/ActionScript 应用程序并更改文件的路径，将其构建为独立的桌面应用程序。它会重写文件的 1.2.3 部分。

    <?xml version="1.0" encoding="utf-8"?>
<s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009"
                       xmlns:s="library://ns.adobe.com/flex/spark"
                       xmlns:mx="library://ns.adobe.com/flex/mx"
                       width="371" height="255" applicationComplete="Init();">
    <fx:Declarations>
        <!-- Place non-visual elements (e.g., services, value objects) here -->
    </fx:Declarations>

    <fx:Script>
        <![CDATA[

            public function Init():void
            {
                import flash.filesystem.File;
                import flash.filesystem.FileMode;
                import flash.filesystem.FileStream;

                var myFile:File = new File("D:\\Dropbox\\Projects\\My App\\src\\Main-app.xml");

                var fileStream:FileStream = new FileStream();
                fileStream.open(myFile, FileMode.READ);

                var fileContents:String = fileStream.readUTFBytes(fileStream.bytesAvailable);

                var startIndex:Number = fileContents.indexOf("<versionNumber>");
                var numberIndex:Number = startIndex + 15;
                var endIndex:Number = fileContents.indexOf("</versionNumber>");

                if (startIndex == -1 || endIndex == -1)
                    return;

                var versionNumber:String = fileContents.substr(numberIndex, endIndex - numberIndex);
                var versionArr:Array = versionNumber.split(".");
                var newSub:Number = Number(versionArr[2]);
                newSub++;
                versionArr[2] = newSub.toString();
                versionNumber = versionArr.join(".");

                var newContents:String = fileContents.substr(0, startIndex) + "<versionNumber>" + versionNumber + "</versionNumber>" +
                                fileContents.substr(endIndex + 16);
                fileStream.close(); 


                fileStream = new FileStream();
                fileStream.open(myFile, FileMode.WRITE);
                fileStream.writeUTFBytes(newContents);
                fileStream.close(); 

                close();
            }
        ]]>
    </fx:Script>
    <s:Label x="10" y="116" width="351" height="20" fontSize="17"
             text="Updating My App Version Number" textAlign="center"/>

</s:WindowedApplication>

Answer 9

我能够根据所提供的信息制定出自己的解决方案。如果它对某人有用，这里是我的 bash 脚本，用于在 Linux 上使用 GIT VCS 时更新 versionCode 和 versionName 属性。

我编辑 AndroidManifest.xml 文件的脚本如下所示：

#/bin/bash

CODE=`git tag | grep -c ^v`
NAME=`git describe --dirty`
COMMITS=`echo ${NAME} | sed -e 's/v[0-9\.]*//'`

if [ "x${COMMITS}x" = "xx" ] ; then
    VERSION="${NAME}"
else
    BRANCH=" (`git branch | grep "^\*" | sed -e 's/^..//'`)"
    VERSION="${NAME}${BRANCH}"
fi

cat AndroidManifest.template.xml \\
    | sed -e "s/__CODE__/${CODE}/" \\
          -e   "s/__VERSION__/${VERSION}/" > AndroidManifest.xml

exit 0

它解析模板文件 (AndroidManifest.template.xml) 并用更合适的值替换字符串“__VERSION__”和“__CODE__”：

• “__CODE__”被替换为计数Git 存储库中的标签数量，以单个小写 V 开头，后跟一系列数字和点。这看起来像大多数版本字符串，例如：“v0.5”、“v1.1.4”等。
• “__VERSION__”被替换为“gitdescribe”命令的输出的组合，如果不是“干净”的构建，则替换为构建它的分支。

我所说的“干净”构建是指所有组件都处于版本控制之下并且它们的最新提交都被标记的构建。 “git describe --dirty”将根据当前分支上最新提交中最后一个可到达的带注释的标签来报告版本号。如果自该标记以来存在提交，则会报告这些提交的计数，就像上次提交的缩写对象名称一样。如果版本控制下的任何文件被修改，“--dirty”选项将在上述信息中附加“-dirty”。

因此 AndroidManifest.xml 不应再受版本控制，您应该只编辑 AndroidManifest.template.xml 文件。 AndroidManifest.template.xml 文件的开头看起来像这样：

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.packagename"
    android:versionCode="__CODE__"
    android:versionName="__VERSION__" >

希望这对某人有用

Answer 10

所有功劳都归功于 ckoz，但我用 C# 编写了自己的实现。我认为它更快一点并且不会出错，因为如果出现问题，可能是配置错误，我应该知道它。

namespace AndroidVersionCodeAutoIncrement
{
    using System.IO;
    using System.Text.RegularExpressions;

    public class Program
    {
        private static readonly Regex VersionCodeRegex = new Regex("android:versionCode=\"(?<version>.*)\"", RegexOptions.Compiled);

        public static void Main()
        {
            using (var manifestFileStream = File.Open("AndroidManifest.xml", FileMode.Open, FileAccess.ReadWrite))
            using (var streamReader = new StreamReader(manifestFileStream))
            {
                var manifestFileText = streamReader.ReadToEnd();

                var firstMatch = VersionCodeRegex.Match(manifestFileText);
                if (firstMatch.Success)
                {
                    int versionCode;
                    var versionCodeValue = firstMatch.Groups["version"].Value;
                    if (int.TryParse(versionCodeValue, out versionCode))
                    {
                        manifestFileText = VersionCodeRegex.Replace(manifestFileText, "android:versionCode=\"" + (versionCode + 1) + "\"", 1);

                        using (var streamWriter = new StreamWriter(manifestFileStream))
                        {
                            manifestFileStream.Seek(0, SeekOrigin.Begin);
                            streamWriter.Write(manifestFileText);
                            manifestFileStream.SetLength(manifestFileText.Length);
                        }
                    }
                }
            }
        }
    }
}

Answer 11

对于那些在 OSX 上并且想要使用 Python，但又不想丢失 XML 格式的人，当 python XML 解析器完成解析时会发生这种情况，这里有一个 python 脚本，它将基于正则表达式进行增量，从而保留格式：

#!/usr/bin/python
import re

f = open('AndroidManifest.xml', 'r+')
text = f.read()

result = re.search(r'(?P<groupA>android:versionName=")(?P<version>.*)(?P<groupB>")',text)
version = str(float(result.group("version")) + 0.01)
newVersionString = result.group("groupA") + version + result.group("groupB")
newText = re.sub(r'android:versionName=".*"', newVersionString, text);
f.seek(0)
f.write(newText)
f.truncate()
f.close()

该代码基于 @ckozl 答案，只是用 python 完成的，因此您不需要为此创建可执行文件。
只需将脚本命名为autoincrement.py，将其与manifest.xml 文件放在同一文件夹中，然后执行ckozl 上面描述的步骤即可！

Answer 12

如果您想更新 AndroidManifest.xml 以使用特定版本号（可能来自构建系统），那么您可以使用我刚刚推送到 GitHub 的项目： https://github.com/bluebirdtech/AndroidManifestVersioner

这是一个基本的.NET命令行应用程序，用法：

AndroidManifestVersioner <path> <versionCode> <versionName>.

感谢其他发帖者提供的代码。

Answer 13

这是 Java 版本的价值所在。还处理多个清单。

String directory = "d:\\Android\\workspace\\";

String[] manifests = new String[] 
{
        "app-free\\AndroidManifest.xml",
        "app-donate\\AndroidManifest.xml",
};

public static void main(String[] args)
{
    new version_code().run();
}

public void run()
{
    int I = manifests.length;
    for(int i = 0; i < I; i++)
    {
        String path = directory + manifests[i];

        String content = readFile(path);
        Pattern         versionPattern = Pattern.compile( "(.*android:versionCode=\")([0-9]+)(\".*)", Pattern.DOTALL );
        Matcher m = versionPattern.matcher(content);

        if (m.matches())
        {
            int code = Integer.parseInt( m.group(2) ) + 1;

            System.out.println("Updating manifest " + path + " with versionCode=" + code);

            String newContent = m.replaceFirst("$1" + code + "$3");

            writeFile(path + ".original.txt", content);
            writeFile(path, newContent);
        }
        else
        {
            System.out.println("No match to update manifest " + path);
        }
    }
}

Answer 14

如果您使用 gradle，那么您可以在 build.gradle 中非常轻松地指定 versionName 和 versionCode。您可以使用 git commit count 作为递增的数字来识别构建。

您还可以使用此库：https://github.com/rockerhieu/Versionberg。

Answer 15

我非常喜欢两种解决方案。第一个取决于 Play 商店，另一个取决于 Git。

使用 Play 商店，您可以通过查看最高的可用上传版本代码来增加版本代码。此解决方案的好处是 APK 上传永远不会失败，因为您的版本代码始终比 Play 商店中的版本代码高 1。缺点是在 Play 商店之外分发 APK 变得更加困难。您可以按照 快速入门指南 并告诉插件自动解析版本代码 ：

plugins {
    id 'com.android.application'
    id 'com.github.triplet.play' version 'x.x.x'
}

android {
    ...
}

play {
    serviceAccountCredentials = file("your-credentials.json")
    resolutionStrategy = "auto"
}

使用 Git，您可以根据存储库拥有的提交和标签数量来增加版本代码。这样做的好处是您的输出是可重现的，并且不依赖于存储库之外的任何内容。缺点是您必须进行新的提交或标记才能更改版本代码。您可以通过添加 Version Master Gradle 插件：

plugins {
    id 'com.android.application'
    id 'com.supercilex.gradle.versions' version 'x.x.x'
}

android {
    ...
}