android manifeste numéro de build

Question

Je me demandais s'il est possible d'avoir Eclipse incrémenter automatiquement le numéro de version de construction à l'intérieur du Manifest chaque fois que je construis ou exécute une application Android.

Est-ce que quelqu'un a déjà fait quelque chose comme ça?

Answer 1

Je ne pense pas que Eclipse lui-même puisse le faire, mais j'imagine que vous pourriez écrire un script qui analyse le fichier manifeste et met à jour le numéro. Vous pouvez définir cela comme une étape de pré-construction, donc à chaque fois qu'Eclipse compile votre code, il change le nombre. Mon seul souci avec cela serait que vous puissiez atteindre de très gros nombres, en fonction de la façon dont votre processus de développement est itératif. En outre, cela vous met à risque d'oublier de mettre à jour la chaîne de version, et les utilisateurs seront invités à passer de la version 1.0 à la version 1.0.

Answer 2

Voici mon presque application générique Java pour mettre à jour code de version et le nom de la version

presque générique, parce que l'analyse syntaxique du fichier est garantie à 100% (fonctionne très bien avec manifeste XML bien formaté et devrait être OK dans la plupart cas)

choix/condition:

• versionName est censé être major.minor.point (comme conseillé par Android doc)
• versionNom peut être conservé, réinitialisé à 1.0.0, ou incrémenté (une partie de celui-ci et la partie finale est/sont mis à 0)
• versionCode sera remplacé par Unix temps

code:

package com.mycompany.tools; 

import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.File; 
import java.io.FileReader; 
import java.io.FileWriter; 
import java.util.regex.Matcher; 
import java.util.regex.Pattern; 

public class IncrementVersion 
{ 
    enum INCREMENT 
    { 
     MAJOR, // increment 1rst component of version Code (i.e. 'major') add trailing '.0.0' 
     MINOR, // preserve major, increment 2nd component of version Code (i.e. 'minor'), add trailing '.0' 
     POINT, // preserver major, minor, increment 3rd component of version Code (i.e. 'point') 
     NONE, // do not change versionName, only change version code (to current Unix times) 
     RESET // RESET -> reset verseionNAme to 1.0.0 
    } 


    // update this to select which version name part to update 
    static final INCREMENT increment = INCREMENT.NONE; 

    static final String projectName = "com.mycompany.myproject"; 
    // OR static final String projectName = "com.mycompany"; -> match all my projects :-) 

    public static void main(String[] args) 
    { 
     File directory = new File(""); 

     for (File projectDirecotry : directory.listFiles()) 
     { 
      if (projectDirecotry.getName().startsWith(projectName)) 
      { 
       exec(projectDirecotry); 
      } 
     } 
    } 

    private static void exec(File projectDirectory) 
    { 
     File androidManifestFile = new File(projectDirectory, "AndroidManifest.xml"); 
     if (androidManifestFile.exists()) 
     { 
      writeFile(androidManifestFile, readFile(androidManifestFile)); 
     } 
    } 

    private static void writeFile(File androidManifestFile, String newContent) 
    { 
     BufferedWriter bw = null; 
     try 
     { 
      bw = new BufferedWriter(new FileWriter(androidManifestFile)); 
      bw.write(newContent); 
     } catch (Throwable th) 
     { 
      th.printStackTrace(); 
     } finally 
     { 
      if (bw != null) 
      { 
       try 
       { 
        bw.close(); 
       } catch (Throwable th) 
       { 
       } 
      } 
     } 
    } 

    private static String readFile(File androidManifestFile) 
    { 
     StringBuilder sb = new StringBuilder(); 
     BufferedReader br = null; 
     try 
     { 
      br = new BufferedReader(new FileReader(androidManifestFile)); 
      String line; 
      while ((line = br.readLine()) != null) 
      { 
       sb.append(parse(line)).append('\n'); 
       //    System.out.println(line); 
      } 
     } catch (Throwable th) 
     { 
      th.printStackTrace(); 
     } finally 
     { 
      if (br != null) 
      { 
       try 
       { 
        br.close(); 
       } catch (Throwable th) 
       { 
       } 
      } 
     } 
     return sb.toString(); 
    } 

    // public static final DateFormat dateTimeFormat = new SimpleDateFormat("yyyyMMddHHmm", Locale.ROOT); 

    public static long getUnixTime() 
    { 
     return System.currentTimeMillis()/1000L; 
    } 

    private static String parse(String line) 
    { 
     { 
      //  android:versionCode="1" 
      // use 201408221404 instead 
      String versionCodePrefix = "android:versionCode=\""; 

      int indexOfVersionCodePrefix = line.indexOf(versionCodePrefix); 
      if (indexOfVersionCodePrefix != -1) 
      { 
       indexOfVersionCodePrefix += versionCodePrefix.length(); 
       versionCodePrefix = line.substring(0, indexOfVersionCodePrefix); 
       String versionCode = line.substring(indexOfVersionCodePrefix, line.length()); 

       int indexOfVersionCodeSuffix = versionCode.indexOf('"'); 
       if (indexOfVersionCodeSuffix != -1) 
       { 
        String versionCodeSuffix = versionCode.substring(indexOfVersionCodeSuffix); 
        //     versionCode = versionCode.substring(0, indexOfVersionCodeSuffix); 
        //     return versionCodePrefix + (Integer.parseInt(versionCode) + 1) + versionCodeSuffix; 
        // 1409302337 
        return versionCodePrefix + getUnixTime() + versionCodeSuffix; 
       } 
      } 
     } 

     { 
      if (increment != INCREMENT.NONE) 
      { 
       //  android:versionName="1.0.0" > 

       String versionNamePrefix = "android:versionName=\""; 

       int indexOfVersionNamePrefix = line.indexOf(versionNamePrefix); 
       if (indexOfVersionNamePrefix != -1) 
       { 
        indexOfVersionNamePrefix += versionNamePrefix.length(); 
        versionNamePrefix = line.substring(0, indexOfVersionNamePrefix); 
        String versionName = line.substring(indexOfVersionNamePrefix, line.length()); 

        int indexOfVersionCodeSuffix = versionName.indexOf('"'); 
        if (indexOfVersionCodeSuffix != -1) 
        { 
         String versionNameSuffix = versionName.substring(indexOfVersionCodeSuffix); 
         versionName = versionName.substring(0, indexOfVersionCodeSuffix); 

         Pattern pattern = Pattern.compile("([^\\.])*\\.([^\\.])*\\.([^\\.])*"); 
         Matcher m = pattern.matcher(versionName); 
         if (m.matches()) 
         { 
          int major = Integer.parseInt(m.group(1)); 
          int minor = Integer.parseInt(m.group(2)); 
          int point = Integer.parseInt(m.group(3)); 

          switch (increment) 
          { 
          case MAJOR: 
           major += 1; 
           minor = 0; 
           point = 0; 
           break; 
          case MINOR: 
           minor += 1; 
           point = 0; 
           break; 
          case POINT: 
           point += 1; 
           break; 
          case RESET: 
           major = 1; 
           minor = 0; 
           point = 0; 
           break; 
          default: 
           break; 
          } 

          return versionNamePrefix + major + '.' + minor + '.' + point + versionNameSuffix; 
         } 
        } 
       } 
      } 
     } 

     return line; 
    } 
}