Cómo auto-incrementar el número de compilación del proyecto de Android en Eclipse (prefiero la solución portátil)

¿Has intentado 'Maven-ise' construir tu proyecto android?

Si utiliza el plugin "maven-android-plugin" , puede realizar un seguimiento de la construcción del proyecto con la etiqueta "version" de pom.xml.

En pom.xml puede incrementar la versión de compilación usando "versions-maven-plugin"

Para reflejar el número de compilación incrementado en AndroidManifest.xml, puede utilizar la técnica de sincronización de versión en su archivo pom.

De esta manera, puede incrementar automáticamente el número de compilación del proyecto android ejecutando el programa "versions-maven-plugin" cada vez que se genere la aplicación. La solución también es portátil de la misma manera que la solución Ant.

Espero que esto también puede resolver el problema que ha mencionado (y lo que he entendido). Por favor, corrija si algo falta.

En el cuadro de diálogo de propiedades del proyecto, bajo Constructores, puede configurar un script para ejecutarse antes de crear su apk.

En el cuadro de diálogo de propiedades, seleccione Constructores en la lista de la izquierda. Haga clic en Nuevo para agregar un nuevo script. En el cuadro de diálogo que aparece, seleccione Programa. En el cuadro de diálogo siguiente, llame a su programa Builder lo que quiera en el campo Nombre. Coloque la ruta del script en el campo Ubicación. Dale un directorio de trabajo en el campo Directorio de trabajo. Tenga en cuenta que puede especificar variables en estos campos (por ejemplo, usamos ${build_project:/libs/update_version.sh} para hacer referencia a un script en el directorio lib del proyecto).

Desea que esto se ejecute antes que cualquiera de los otros constructores, así que muévalo a la parte superior de la lista usando el botón Arriba.

En la pestaña Opciones de construcción del cuadro de diálogo (está justo debajo del campo Nombre hacia la parte superior), puede seleccionar opciones para cuando desea que se ejecute este programa.

Estoy asumiendo algo como Linux, Unix o MacOS aquí. En esos sistemas puede usar grep o sus variantes para obtener el versionCode actual, incrementarlo y luego awk o similar para modificar el archivo en consecuencia. O bien, podría escribir un script Ruby, Python, Perl, etc. para reemplazar el versionCode en el archivo AndroidManifest.xml. Supongo que hay herramientas equivalentes en Windows, pero no estoy muy familiarizado con ese entorno.

Aquí hay una solución que utiliza Ant. Tengo que admitir que conseguir la configuración de la hormiga era un pedacito, pero parece ser un adjunto extensamente utilizado y de gran alcance a Eclipse, así que creo que resultará ser valioso para mí de otras maneras.

Ant es la solución preferida para crear aplicaciones Android SDK sin Eclipse (como se describe aquí ), pero no forma parte del ADT, por lo que probablemente no lo tendrá si acaba de utilizar Eclipse.

Por lo tanto, el primer paso es descargar e instalar Ant desde aquí .

A continuación, agregue Ant a su ruta y asegúrese de que su ruta también apunta al JDK (en lugar del JRE). En Windows descubrí que también tenía que crear JAVA_HOME y apuntarlo a la raíz del JDK.

Sólo necesitamos Ant para el paso de auto incremento – la intención no es reemplazar a Eclipse y usarlo para toda la compilación – pero es útil hacer algunos pasos en esa dirección para asegurarse de que Ant está funcionando. Por lo tanto, vaya a la raíz de su proyecto y escriba

 > android update project --path . 

Esto crea un build.xml para su proyecto. Una vez que lo hice, pude hacer

 > ant release 

Y Ant construyó mi proyecto. Si desea seguir adelante en esa dirección me pareció útil este artículo .

A continuación, edité el nuevo build.xml de mi proyecto y añadí la siguiente tarea (puede ir a cualquier lugar, no en medio de otra tarea / destino)

  <target name="update.buildnum"> <buildnumber/> <!-- this task creates (and increments) Ant property 'build.number' which I use below --> <echo>Current build number:${build.number}</echo> <echoxml file="res/values/buildnum.xml"> <resources> <string name="buildnum">${build.number}</string> </resources> </echoxml> </target> 

La tarea utilizada anteriormente incrementa automáticamente un número de compilación en un archivo (que creará) llamado 'build.number' en la raíz de su proyecto. El resto de la tarea anterior coloca el número de compilación actual en una cadena de recursos para que la aplicación pueda recuperarla con este código:

 String build = context.getString( com.your.app.R.string. buildnum ); int appBuild = ( int ) Integer.parseInt( build ); 

Algunas personas prefieren una solución que escribe el número de compilación en el código de la aplicación en AndroidManifest.xml. Esta es una respuesta que incluye una tarea para hacer eso, pero requiere una tarea de Ant de terceros (xmltask), y estoy un poco dudosa de tener una tarea de terceros que modifica mi manifiesto (que ahora es bastante grande) en cada build . Si decide utilizar esa tarea, el código correspondiente de Android para obtener el número de compilación sería:

 String packageName = ctx.getPackageName(); PackageInfo pInfo = ctx.getPackageManager().getPackageInfo( packageName, 0); int appVer = pInfo.versionCode; 

Por último, es necesario que Eclipse ejecute esta tarea Ant cada vez que realice una compilación.

Vaya a las propiedades de su proyecto, busque los constructores y haga clic en el botón para agregar un nuevo constructor. Hay un montón de opciones aquí, pero sólo es necesario especificar algunos.

• Asigne un nombre al constructor estableciendo el campo Nombre : .
• Seleccione el archivo de compilación:. Utilicé la opción 'examinar el espacio de trabajo' para seleccionarlo y luego llené el campo con "$ {workspace_loc: /appname/build.xml}"
• Seleccione los objetivos de una lista en la pestaña de objetivos. En mi caso tuve que eliminar la tarea 'help' (la tarea por defecto en build.mxl generada anteriormente), y luego agregar la tarea 'build.number'. Sugiero que sólo establezca una meta para la compilación manual:.

Moví el nuevo Generador para que fuera el primer paso de construcción.

Un problema con esta solución es que cada vez que obtiene Eclipse para desplegar (ejecutar) su aplicación se considera una nueva construcción manual, incluso si el proyecto no ha cambiado. Por lo tanto, si implementa la aplicación en varios dispositivos, cada dispositivo tendrá una compilación diferente con su propio número de compilación. Una cosa que mejorará este problema un poco es que Google dice que un futuro ADT permitirá múltiples despliegues en una sola operación.

Esto (arriba) fue probado con Ant 1.8.4, Eclipse Indigo SR2 (3.7.2), ADT 20 preview 2 y SDK Tools 20, en Win7 32bit.

Mi solución se basa en el uso de Ant (sin XMLTask)

 <property name="version.file" value="version.properties"/> <property name="manifest.file" value="AndroidManifest.xml"/> <!--build.slot: 0.1.2.3.4.5--> <property name="build.slot" value="2"/> <target name="all"> <antcall target="increment.build"/> <antcall target="update.manifest"/> </target> <target name="increment.build"> <propertyfile file="${version.file}"> <entry key="build.no" type="int" default="0" operation="+" value="1" /> </propertyfile> </target> <scriptdef name="setBuildNo" language="javascript"> <attribute name="verName" /> <attribute name="buildNo" /> <attribute name="buildSlot" /> <attribute name="property" /> <![CDATA[ var verNums = attributes.get("vername").split("."); var buildNo = attributes.get("buildno"); var buildSlot = attributes.get("buildslot"); if (!(buildSlot > 1 && buildSlot < 10)) buildSlot = 2; var newVer = ""; for (var i = 0; i < Math.min(verNums.length, buildSlot); i++) newVer += (verNums[i].trim() || "0") + "."; for (var i = verNums.length; i < buildSlot; i++) newVer += "0" + "."; project.setProperty(attributes.get("property"), newVer + buildNo); ]]> </scriptdef> <target name="debug"> <setBuildNo verName="1" buildNo="999" property="a"/> <setBuildNo verName="2." buildNo="999" property="b"/> <setBuildNo verName="3.3" buildNo="999" property="c"/> <setBuildNo verName="4.4." buildNo="999" property="d"/> <setBuildNo verName="5.5.5" buildNo="999" property="e"/> <setBuildNo verName="6.6.6." buildNo="999" property="f"/> <setBuildNo verName="7.7.7.7" buildNo="999" property="g"/> <echo>1 =&gt; ${a}</echo> <echo>2. =&gt; ${b}</echo> <echo>3.3 =&gt; ${c}</echo> <echo>4.4. =&gt; ${d}</echo> <echo>5.5.5 =&gt; ${e}</echo> <echo>6.6.6. =&gt; ${f}</echo> <echo>7.7.7.7 =&gt; ${g}</echo> </target> <target name="update.manifest"> <fail message="File not found: &quot;${manifest.file}&quot;" status="1"> <condition> <not> <available file="${manifest.file}" /> </not> </condition> </fail> <!-- Reads build version --> <loadproperties srcfile="${version.file}"> <filterchain> <linecontains> <contains value="build.no="/> </linecontains> </filterchain> </loadproperties> <!-- Reads versionName from AndroidManifest --> <xmlproperty file="${manifest.file}" collapseAttributes="true"/> <fail unless="manifest.android:versionName" message="Attribute &quot;android:versionName&quot; undefined into &quot;${manifest.file}&quot;" status="1"/> <property name="version.name" value="${manifest.android:versionName}"/> <!-- Create a new version --> <setBuildNo verName="${version.name}" buildNo="${build.no}" buildSlot="${build.slot}" property="new.version.name"/> <!-- Replaces using regexp --> <replaceregexp file="${manifest.file}" match="android:versionName.*=.*&quot;.*${version.name}.*&quot;" replace="android:versionName=&quot;${new.version.name}&quot;"/> <!-- Replaces for check and generates a exception (if not found version) --> <replace file="${manifest.file}" token="android:versionName=&quot;${new.version.name}&quot;" value="android:versionName=&quot;${new.version.name}&quot;" failOnNoReplacements="true"/> <!--<echo>${version.file}</echo> <echo>${manifest.file}</echo>--> <echo>Auto Increment Build: ${version.name} =&gt; ${new.version.name}</echo> </target> 

Utilizando

 Ant [-Dmanifest.file = <archivo>] [-Dversion.file = <archivo>] [-Dbuild.slot = <número>]
     -Dmanifest.file - ruta de acceso y nombre de archivo AndroidManifest.xml.  Predeterminado: AndroidManifest.xml en una carpeta con build.xml
     -Dversion.file - ruta y nombre del archivo en el que se almacena el número Build version.  Predeterminado: carpeta version.properties con build.xml
     -Dbuild.slot - posición del número de compilación en la matriz de versiones.  Valor predeterminado: 2, es decir, XXbuild.

Creación de Incremento Automático en Eclipse

 Proyecto |  Propiedades |  Constructores |  Nuevo |  Ant Build
     Principal
         Crear archivo
             <Path> /build.xml
         Argumentos
             -Dmanifest.file = $ {workspace_loc: //AndroidManifest.xml} -Dversion.file = $ {workspace_loc: //version.properties}
     Refrescar
         [X] Actualizar recursos al finalizar
         (*) Especificar los recursos
             [Especificar recursos] 
                 <Proyecto>
                     [X] AndroidManifest.xml
     Opciones de creación
         [X] Especificar el conjunto de recursos relevantes
             [Especificar recursos] 
                 <Proyecto>
                     [X] res
                     [X] src
                     [X] AndroidManifest.xml

Mi solución utiliza parte del código encontrado en otras respuestas, XMLTask y Groovy para incrementar automáticamente el número de compilación. También incluí una regla para hacer un git commit y una etiqueta para vincular el número de compilación a un punto específico en el control de versiones, útil para el seguimiento de errores.

  <taskdef name="xmltask" classname="com.oopsconsultancy.xmltask.ant.XmlTask"/> <path id="groovy.classpath"> <fileset dir="/Users/deepwinter1/.gvm/groovy/current/lib/"> <include name="*.jar"/> </fileset> </path> <taskdef name="groovy" classname="org.codehaus.groovy.ant.Groovy"> <classpath refid="groovy.classpath"/> </taskdef> <target name="update.build.number"> <xmltask source="AndroidManifest.xml"> <copy path="manifest/@android:versionCode" property="buildNum"/> </xmltask> <groovy> buildNum = Integer.valueOf(properties["buildNum"]) properties["buildNum"] = buildNum + 1 </groovy> <xmltask source="AndroidManifest.xml" dest="AndroidManifest.xml"> <replace path="manifest/@android:versionCode" withText="${buildNum}"/> </xmltask> <antcall target="commit.and.tag.build"> <param name="buildNum" value="${buildNum}"/> </antcall> </target> <target name="commit.and.tag.build"> <exec executable="git"> <arg value="commit"/> <arg value="-a"/> <arg value="-m"/> <arg value="Build Number ${buildNum}"/> </exec> <exec executable="git"> <arg value="tag"/> <arg value="b${buildNum}"/> </exec> </target> 

Un "bit" solución mejor solución que puede encontrar aquí … https://stackoverflow.com/a/8156809/304270

Tiny c # herramienta que se ejecutará antes everynew nueva construcción y aumentar el valor adecuado en archivo de manifiesto ..