स्वतः पूर्ण संस्करण अतिरिक्त गुण के साथ संस्करणकोड

121

मैं एक एंड्रॉइड ऐप बना रहा हूं जिसमें ग्रेडेल है। अब तक मैंने वर्जनकोड को बढ़ाने के लिए मेनिफेस्ट फाइल का इस्तेमाल किया था, लेकिन मैं एक एक्सटर्नल फाइल से वर्जनकोड पढ़ना चाहूंगा और यह निर्भर करता है कि यह रिलीज फ्लेवर है या डिबग फ्लेवर वर्जनकोड को बढ़ाता है। मैंने अतिरिक्त गुणों की कोशिश की, लेकिन आप उन्हें सहेज नहीं सकते, जिसका मतलब है कि अगली बार जब मैं इसे बनाऊंगा तो मुझे वही संस्करणकोड मिलेंगे। किसी भी मदद को बहुत, बहुत सराहा जाएगा!

project.ext{
    devVersionCode = 13
    releaseVersionCode = 1
}

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.6.+'
    }
}

apply plugin: 'android'

repositories {
    mavenCentral()
}

dependencies {
    compile project(':Cropper')
    compile "com.android.support:appcompat-v7:18.0.+"
    compile "com.android.support:support-v4:18.0.+"
    compile fileTree(dir: 'libs', include: '*.jar')
}

def getReleaseVersionCode() {
    def version = project.releaseVersionCode + 1
    project.releaseVersionCode = version
    println sprintf("Returning version %d", version)
    return version
}

def getDevVersionCode() {
    def version = project.devVersionCode + 1
    project.devVersionCode = version
    println sprintf("Returning version %d", version)
    return version
}


def getLastVersioName(versionCode) {
    return "0.0." + versionCode
}

android {
    compileSdkVersion 19
    buildToolsVersion "19.0.0"

    defaultConfig {
        minSdkVersion 9
        targetSdkVersion 19
    }

    sourceSets {
        main {
            manifest.srcFile 'AndroidManifest.xml'
            java.srcDirs = ['src']
            resources.srcDirs = ['src']
            aidl.srcDirs = ['src']
            renderscript.srcDirs = ['src']
            res.srcDirs = ['res']
            assets.srcDirs = ['assets']
        }
    }

    buildTypes {
        release {
            runProguard true
            proguardFile getDefaultProguardFile('proguard-android-optimize.txt')
            proguardFile 'proguard.cfg'
            debuggable false
            signingConfig null
            zipAlign false
        }
        debug {
            versionNameSuffix "-DEBUG"
        }
    }
    productFlavors {
        dev {
            packageName = 'com.swisscom.docsafe.debug'
            versionCode getDevVersionCode()
            versionName getLastVersioName(project.devVersionCode)
        }
        prod {
            packageName = 'com.swisscom.docsafe'
            versionCode getReleaseVersionCode()
            versionName getLastVersioName(project.releaseVersionCode)
        }
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = '1.8'
}
android  gradle  android-gradle-plugin  build.gradle 
— carvaq
स्रोत
मेरा जवाब यहां देखें: stackoverflow.com/a/33637600/348189
— TacB0sS
एक अन्य विकल्प (सेट-एंड-एप्रोच अप्रोच): medium.com/@passsy/…
— साइमन बी।
— ग्रैडल

जवाबों:

207

मैं एक बाहरी फ़ाइल से संस्करणकोड पढ़ना चाहूंगा

मुझे यकीन है कि किसी भी संभावित समाधान की संख्या है; यहाँ एक है:

android {
    compileSdkVersion 18
    buildToolsVersion "18.1.0"

    def versionPropsFile = file('version.properties')

    if (versionPropsFile.canRead()) {
        def Properties versionProps = new Properties()

        versionProps.load(new FileInputStream(versionPropsFile))

        def code = versionProps['VERSION_CODE'].toInteger() + 1

        versionProps['VERSION_CODE']=code.toString()
        versionProps.store(versionPropsFile.newWriter(), null)

        defaultConfig {
            versionCode code
            versionName "1.1"
            minSdkVersion 14
            targetSdkVersion 18
        }
    }
    else {
        throw new GradleException("Could not read version.properties!")
    }

    // rest of android block goes here
}

यह कोड एक मौजूदा version.propertiesफ़ाइल की अपेक्षा करता है , जिसे आप पहली बार बनाए जाने से पहले हाथ से बनाएंगे VERSION_CODE=8।

यह कोड बस प्रत्येक निर्माण पर संस्करण कोड को टक्कर देता है - आपको अपने प्रति-स्वाद संस्करण कोड को संभालने के लिए तकनीक का विस्तार करना होगा।

आप संस्करण कोड परियोजना देख सकते हैं जो इस कोड को प्रदर्शित करता है।

— CommonsWare
स्रोत
4
केवल रिलीज़ बिल्ड बनाते समय इस संस्करण को बढ़ाने में सक्षम कैसे करें?
— पियोट्र्स
@Piotr: यदि आपका मतलब है "रिलीज बिल्ड पर केवल संख्या बढ़ाना", तो यह संभव होना चाहिए, हालांकि मुझे विवरण नहीं पता है। व्यक्तिगत रूप से, चूंकि ~ 2 बिलियन संस्करण कोड उपलब्ध हैं, मुझे लगता है कि मैं बाहर नहीं चलाऊंगा। :-)
— कॉमन्सवेयर
3
@Pootr आप एक ऐसा कार्य बनाएंगे जो संस्करण कोड को assembleRelease.finalizedBy incrementVersionसमान रूप से बढ़ाता है और फिर कुछ ऐसा ही करता है। एक बार जब मैं इसे tidied कर लेता हूं तो मैं अपना कोड पोस्ट करूंगा।
— क्रिस। जेनकिंस
एक कस्टम कार्य का उपयोग करके आप कुछ ऐसा कर सकते हैं ./gradlew incrementVersionCode build। इस तरह से क्रमिक रूप से कॉल किए गए कार्य जैसे ही किसी भी कार्य में विफल हो जाएंगे, रुक जाएंगे।
— डोरी
3
@ Chris.jenkins के रूप में अभी भी अपने कोड tiding है: पी यहाँ कार्य और विधि के रूप में ऊपर है gist.github.com/doridori/544c24509be236c11fd5 जिसके साथ एंड्रॉयड डीएसएल के अंदर इस्तेमाल किया जा सकताversionCode getIncrementingVersionCode()
— डोरी
83

यहाँ मेरे पिछले उत्तर का आधुनिकीकरण आता है जिसे नीचे देखा जा सकता है। यह ग्रैडल 4.4 और एंड्रॉइड स्टूडियो 3.1.1 के साथ चल रहा है ।

यह स्क्रिप्ट क्या करती है:

  • एक वर्जन बनाता है । यदि कोई मौजूद नहीं है, तो एक फाइल फाइल करें । (नीचे पॉल कैंटरेल के वोट का जवाब दें, जहां मुझे यह विचार पसंद आया।
  • प्रत्येक बिल्ड, डीबग रिलीज़ या किसी भी समय आप Android स्टूडियो में रन बटन दबाते हैं VERSION_BUILD संख्या बढ़ जाती है।
  • हर बार जब आप प्ले स्टोर में बढ़ोतरी के लिए अपना एंड्रॉइड वर्जनकोड जारी करते हैं और आपका पैच नंबर बढ़ जाता है।
  • बोनस: बिल्ड के पूरा projectDir/apkहो जाने के बाद इसे अधिक सुलभ बनाने के लिए आपकी एपीके को कॉपी किया जाता है ।

यह स्क्रिप्ट एक वर्जन नंबर बनाएगी, जो एपीकेनेम-v1.3.4.apk कीv1.3.4 (123) तरह दिखने वाली एक एपीके फाइल बनाएगी ।

Major version ⌄       ⌄ Build version
             v1.3.4 (123)
  Minor version ⌃|⌃ Patch version

प्रमुख संस्करण: बड़े परिवर्तनों के लिए मैन्युअल रूप से बदलना होगा।

मामूली संस्करण: थोड़ा कम बड़े परिवर्तनों के लिए मैन्युअल रूप से बदलना होगा।

पैच संस्करण: बढ़ते समय बढ़ता हैgradle assembleRelease

बिल्ड वर्जन: हर बिल्ड को बढ़ाता है

वर्जन नंबर: पैच वर्जन के समान , यह उस वर्जन कोड के लिए होता है जिसे प्ले स्टोर को प्रत्येक नए एपीके अपलोड के लिए बढ़ाना होगा।

नीचे दी गई टिप्पणियों में सामग्री को केवल 1 - 3 में बदलें और स्क्रिप्ट को बाकी काम करना चाहिए। :)

android {
    compileSdkVersion 27
    buildToolsVersion '27.0.3'

    def versionPropsFile = file('version.properties')
    def value = 0
    Properties versionProps = new Properties()
    if (!versionPropsFile.exists()) {
        versionProps['VERSION_PATCH'] = "0"
        versionProps['VERSION_NUMBER'] = "0"
        versionProps['VERSION_BUILD'] = "-1" // I set it to minus one so the first build is 0 which isn't super important. 
        versionProps.store(versionPropsFile.newWriter(), null)
    }

    def runTasks = gradle.startParameter.taskNames
    if ('assembleRelease' in runTasks) {
        value = 1
    }

    def mVersionName = ""
    def mFileName = ""

    if (versionPropsFile.canRead()) {
        versionProps.load(new FileInputStream(versionPropsFile))

        versionProps['VERSION_PATCH'] = (versionProps['VERSION_PATCH'].toInteger() + value).toString()
        versionProps['VERSION_NUMBER'] = (versionProps['VERSION_NUMBER'].toInteger() + value).toString()
        versionProps['VERSION_BUILD'] = (versionProps['VERSION_BUILD'].toInteger() + 1).toString()

        versionProps.store(versionPropsFile.newWriter(), null)

        // 1: change major and minor version here
        mVersionName = "v1.0.${versionProps['VERSION_PATCH']}"
        // 2: change AppName for your app name
        mFileName = "AppName-${mVersionName}.apk"

        defaultConfig {
            minSdkVersion 21
            targetSdkVersion 27
            applicationId "com.example.appname" // 3: change to your package name
            versionCode versionProps['VERSION_NUMBER'].toInteger()
            versionName "${mVersionName} Build: ${versionProps['VERSION_BUILD']}"
        }

    } else {
        throw new FileNotFoundException("Could not read version.properties!")
    }

    if ('assembleRelease' in runTasks) {
        applicationVariants.all { variant ->
            variant.outputs.all { output ->
                if (output.outputFile != null && output.outputFile.name.endsWith('.apk')) {
                    outputFileName = mFileName
                }
            }
        }
    }

    task copyApkFiles(type: Copy){
        from 'build/outputs/apk/release'
        into '../apk'
        include mFileName
    }

    afterEvaluate {
        assembleRelease.doLast {
            tasks.copyApkFiles.execute()
        }
    }

    signingConfigs {
        ...
    }

    buildTypes {
        ...
    }
}

================================================== ==

संपादकीय जवाब:

मैं चाहता हूं कि वर्जननाम अपने आप ही बढ़ जाए। तो यह कॉमन्सवेयर के जवाब का एक जोड़ है जो मेरे लिए पूरी तरह से काम करता है। मेरे लिए यही काम करता है

defaultConfig {
    versionCode code
    versionName "1.1." + code
    minSdkVersion 14
    targetSdkVersion 18
}

संपादित करें:

जैसा कि मैं थोड़ा आलसी हूं मैं चाहता हूं कि मेरी वर्जनिंग अपने आप ही काम करे। मैं चाहता हूं कि एक बिल्ड संस्करण हो, जो प्रत्येक बिल्ड के साथ बढ़ता है, जबकि संस्करण संख्या और संस्करण का नाम केवल तब बढ़ता है जब मैं एक रिलीज बिल्ड बनाता हूं।

यह वह है जो मैं पिछले एक साल से उपयोग कर रहा हूं, मूल बातें कॉमन्सवेयर के उत्तर और मेरे पिछले उत्तर, और कुछ और हैं। यह निम्नलिखित संस्करण में परिणाम देता है:

संस्करण का नाम: 1.0.5 (123) -> मेजर.माइनर.पच (बिल्ड), मेजर और माइनर मैन्युअल रूप से बदले जाते हैं।

बिल्ड.ग्रेड में:

...
android {
    compileSdkVersion 23
    buildToolsVersion '23.0.1'
    def versionPropsFile = file('version.properties')
    if (versionPropsFile.canRead()) {
        def Properties versionProps = new Properties()

        versionProps.load(new FileInputStream(versionPropsFile))

        def value = 0

        def runTasks = gradle.startParameter.taskNames
        if ('assemble' in runTasks || 'assembleRelease' in runTasks || 'aR' in runTasks) {
            value = 1;
        }

        def versionMajor = 1
        def versionMinor = 0
        def versionPatch = versionProps['VERSION_PATCH'].toInteger() + value
        def versionBuild = versionProps['VERSION_BUILD'].toInteger() + 1
        def versionNumber = versionProps['VERSION_NUMBER'].toInteger() + value

        versionProps['VERSION_PATCH'] = versionPatch.toString()
        versionProps['VERSION_BUILD'] = versionBuild.toString()
        versionProps['VERSION_NUMBER'] = versionNumber.toString()

        versionProps.store(versionPropsFile.newWriter(), null)

        defaultConfig {
            versionCode versionNumber
            versionName "${versionMajor}.${versionMinor}.${versionPatch} (${versionBuild}) Release"
            minSdkVersion 14
            targetSdkVersion 23
        }

        applicationVariants.all { variant ->
            variant.outputs.each { output ->
                def fileNaming = "apk/RELEASES"
                variant.outputs.each { output ->
                    def outputFile = output.outputFile
                    if (outputFile != null && outputFile.name.endsWith('.apk')) {
                        output.outputFile = new File(getProject().getRootDir(), "${fileNaming}-${versionMajor}.${versionMinor}.${versionPatch}-${outputFile.name}")
                    }
                }
            }
        }

    } else {
        throw new GradleException("Could not read version.properties!")
    }

    ...
}

...

पैच और versionCode यदि आप के साथ टर्मिनल के माध्यम से अपनी परियोजना को इकट्ठा बढ़ जाती है 'इकट्ठा' , 'assembleRelease' या 'एआर' जो अपनी परियोजना जड़ apk बुलाया / विज्ञप्ति में एक नया फ़ोल्डर बनाता है तो आप का निर्माण / आउटपुट के माध्यम से देखने के लिए की जरूरत नहीं है / / अधिक / अधिक / अपने APK को खोजने के लिए।

आपके संस्करण गुणों को इस तरह देखना होगा:

VERSION_NUMBER=1
VERSION_BUILD=645
VERSION_PATCH=1

जाहिर है 0. के साथ शुरू :)

— just_user
स्रोत
2
दूसरा 'variant.outputs.each {आउटपुट ->' को संबंधित '}' के साथ हटाया जा सकता है।
— redocoder
यह मेरे सभी
— निर्माणों
@ मुझे यह संदेह है कि ग्रेडेल कोड का यह कारण है। एक नया प्रश्न पूछें और अपने ग्रेड कोड को साझा करें और हम यह पता लगाने की कोशिश कर सकते हैं कि क्या गलत है। :)
— just_user
1
मैं अब पुष्टि कर सकता हूं कि यह मूल कारण नहीं था। मैं क्षमाप्रार्थी हूं।
— चिस्को
1
@AlexanderGavriliuk इसके स्टोर कोड का उपयोग प्ले स्टोर द्वारा किया जाता है जिसे लगातार हर अपलोड के लिए बढ़ाना पड़ता है। यदि आप प्रमुख या लघु संस्करण बढ़ाते हैं तो पैच नंबर शायद रीसेट हो जाएगा। यदि आप ऐप को एक ही पैकेज के नाम के साथ प्ले स्टोर पर अपलोड करते हैं तो संस्करण संख्या को कभी भी रीसेट नहीं किया जाना चाहिए।
— just_user
40

यदि यह मौजूद नहीं है, तो कॉमन्सवेयर के उत्कृष्ट जवाब का थोड़ा कड़ा संस्करण संस्करण फ़ाइल बनाता है:

def Properties versionProps = new Properties()
def versionPropsFile = file('version.properties')
if(versionPropsFile.exists())
    versionProps.load(new FileInputStream(versionPropsFile))
def code = (versionProps['VERSION_CODE'] ?: "0").toInteger() + 1
versionProps['VERSION_CODE'] = code.toString()
versionProps.store(versionPropsFile.newWriter(), null)

defaultConfig {
    versionCode code
    versionName "1.1"
    minSdkVersion 14
    targetSdkVersion 18
}
— पॉल कैंटरेल
स्रोत
यदि यह मौजूद नहीं है तो संस्करण फ़ाइल बनाने के बारे में कहाँ है?
— portfoliobuilder
4
if(versionPropsFile.exists())यह सुनिश्चित करता है कि अगर फ़ाइल नहीं है तो यह विस्फोट न हो। versionProps.store(versionPropsFile.newWriter(), null) यह पहले से मौजूद है या नहीं इसकी परवाह किए बिना फ़ाइल को ओवरराइट करता है।
— पॉल कैंटरेल
जाँच करना ?:था कि ग्रूवी में क्या मतलब है। एल्विस ऑपरेटर त्रिगुट ऑपरेटर का एक छोटा है।
— डैनियल
30

मैंने ऐसा करने के लिए कुछ विकल्पों पर ध्यान दिया, और अंततः निर्णय लिया कि वर्जनकोड के लिए वर्तमान समय का उपयोग करना सरल था, बजाय इसके कि वर्जनकोड को स्वचालित रूप से बढ़ाने की कोशिश की जाए और इसे मेरे संशोधन नियंत्रण प्रणाली में जांचा जाए।

निम्नलिखित को अपने में जोड़ें build.gradle:

/**
 * Use the number of seconds/10 since Jan 1 2016 as the versionCode.
 * This lets us upload a new build at most every 10 seconds for the
 * next 680 years.
 */
def vcode = (int)(((new Date().getTime()/1000) - 1451606400) / 10)

android {
    defaultConfig {
        ...
        versionCode vcode
    }
}

हालांकि, यदि आप वर्ष 2696 से परे बिल्ड अपलोड करने की उम्मीद करते हैं, तो आप एक अलग समाधान का उपयोग करना चाह सकते हैं।

— emmby
स्रोत
2
यदि आप इसे अभी पढ़ रहे हैं, और एक नए ऐप के साथ शुरू कर रहे हैं, तो आप इसे 1510351294
— हटा
मैं यह नहीं मिलता !! क्या आप एनालिटिक्स या क्रैशलीटिक्स या किसी अन्य सेवा का उपयोग नहीं करते हैं जो संस्करण कोड और नामों के साथ डेटा देता है? और आप आसानी से इन के साथ खेल रहे हैं?
— अमीर ज़ियारती
यदि आपके पास उचित संस्करण नाम हैं, तो मुझे लगता है कि यह ठीक है। Crashlytics संस्करण का नाम भी प्रदान करता है।
— netcyrax
@emmby आपको '1451606400' नंबर कहां से मिलेगा? या #Entreco से '1510351294' मैं व्यर्थ गणना करने की कोशिश कर रहा हूं!
— जोसेफ वम्बुरा
18

versionCodeस्वचालित रूप से प्राप्त करने का दूसरा तरीका versionCodeचेक आउट gitशाखा में कमिट की संख्या के लिए सेट है । यह निम्नलिखित उद्देश्यों को पूरा करता है:

  1. versionCodeस्वचालित रूप से और लगातार किसी भी मशीन (एक Continuous Integrationऔर / या Continuous Deploymentसर्वर सहित ) पर उत्पन्न होता है ।
  2. इसके साथ ऐप versionCodeGooglePlay के लिए सबम्यूटेबल है।
  3. रेपो के बाहर किसी भी फाइल पर निर्भर नहीं है।
  4. रेपो के लिए कुछ भी धक्का नहीं है
  5. जरूरत पड़ने पर मैन्युअल रूप से ओवरराइड किया जा सकता है

उपरोक्त उद्देश्यों को पूरा करने के लिए ग्रेडल-गिट लाइब्रेरी का उपयोग करना। अपनी build.gradleफ़ाइल /appनिर्देशिका के नीचे कोड जोड़ें :

import org.ajoberstar.grgit.Grgit

repositories {
    mavenCentral()
}

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath 'org.ajoberstar:grgit:1.5.0'
    }
}

android {
/*
    if you need a build with a custom version, just add it here, but don't commit to repo,
    unless you'd like to disable versionCode to be the number of commits in the current branch.

    ex. project.ext.set("versionCodeManualOverride", 123)
*/
    project.ext.set("versionCodeManualOverride", null)

    defaultConfig {
        versionCode getCustomVersionCode()
    }
}

def getCustomVersionCode() {

    if (project.versionCodeManualOverride != null) {
        return project.versionCodeManualOverride
    }

    // current dir is <your proj>/app, so it's likely that all your git repo files are in the dir
    // above.
    ext.repo = Grgit.open(project.file('..'))

    // should result in the same value as running
    // git rev-list <checked out branch name> | wc -l
    def numOfCommits = ext.repo.log().size()
    return numOfCommits
}

नोट: इस विधि को काम करने के लिए, केवल Google Play Store पर एक ही शाखा (उदा। master) से परिनियोजित करना सबसे अच्छा है ।

— C0D3LIC1OU5
स्रोत
संक्षेप में एक ग्यारह समाधान के दौरान, मैं कल्पना कर सकता हूं कि यह निर्माण समय को काफी धीमा कर देगा, यह निर्भर करता है कि वास्तव में 2 गिट लाइनों में क्या हो रहा है। उस पर कोई अनुभव?
— उम्मीद है कि
1
यदि यह चरण अक्षम है तो मुझे कोई प्रदर्शन सुधार नहीं दिखता है। एक साल से अधिक समय से स्थानीय स्तर पर और हमारी बिल्ड मशीनों पर उपयोग किया जा रहा है और प्रदर्शन कोई मुद्दा नहीं रहा है। यदि आप किसी भी प्रदर्शन के मुद्दों को नोटिस करते हैं, तो मुझे बताएं!
— C0D3LIC1OU5
जबकि आपका समाधान सुरुचिपूर्ण है, यह कुछ बुरा अप्रत्याशित आश्चर्य दे सकता है। यह महत्वपूर्ण है कि वर्जनकोड हमेशा पिछले रिलीज की तुलना में बड़ा होता है। क्या होगा यदि आपके पास 50 कमिट्स के साथ एक शाखा है, और फिर आप एक और शाखा बनाते हैं जो नई है लेकिन केवल 40 कमिट्स हैं, शायद कुछ मर्ज किए गए फीचर से कई कमिट स्क्वैश करने के कारण। मैं बहुत सारे कारण देख सकता हूं कि आपका प्रतिबद्ध इतिहास हमेशा वृद्धिशील आवागमन की एक रैखिक धारा नहीं होगा।
— जेएचएच
@ जेएचएच वे परिणाम अप्रत्याशित नहीं हैं। जैसा कि मैंने एक नोट में उल्लेख किया है, यह विधि एक ही शाखा से तैनाती करते समय सबसे अच्छा काम करती है।
— C0D3LIC1OU5
13

हाल ही में मैं एंड्रॉइड के लिए एक ग्रेड प्लगइन पर काम कर रहा था जो कि वर्जनकोड और वर्जननाम को स्वचालित रूप से जेनरेट करता है । बहुत सारे अनुकूलन हैं। यहाँ आप इसके बारे में अधिक जानकारी पा सकते हैं https://github.com/moallemi/gradle-advanced-build-version

— moallemi
स्रोत
यह एक महान प्लगइन है! साझा करने के लिए धन्यवाद for
— कोरी रॉबिन्सन
10

एक और विकल्प, वेतन वृद्धि versionCodeऔर के लिएversionName एक टाइमस्टैम्प का उपयोग कर रहा है।

defaultConfig {
   versionName "${getVersionNameTimestamp()}"
   versionCode getVersionCodeTimestamp()
}


def getVersionNameTimestamp() {
    return new Date().format('yy.MM.ddHHmm')
}

def getVersionCodeTimestamp() {
    def date = new Date()
    def formattedDate = date.format('yyMMddHHmm')
    def code = formattedDate.toInteger()
    println sprintf("VersionCode: %d", code)
    return code
}

जनवरी से शुरू हो रहा है, 1 2022 स्वरूपित डेट = तारीख। सुधार ('yMMddHHmm') इंटिजर्स की क्षमता से अधिक है

— carvaq
स्रोत
1
व्यक्ति चाहता था कि ऑटो-इंक्रीमेंट बिल्ड नंबर
— peter_pilgrim
6
@peter_pilgrim कारो ओपी है।
— मैथ्यू पढ़ें
मुझे लगता है कि यह एक सुंदर समाधान है, यह उन फाइलों पर भरोसा नहीं करता है जो गायब हो सकते हैं या नहीं या जो लगातार गिट में दिखाई देंगे। यह आपको अगले दर्जनों 22 वर्षों के लिए प्रत्येक बिल्ड को विशिष्ट रूप से पहचानने में भी मदद करता है।
— उम्मीद है कि
developer.android.com :"Warning के हवाले से: Google Play के वर्जनकोड की सबसे बड़ी कीमत 2100000000 है। "तो, कटऑफ वास्तव में 2021 है।
— ths
अंतर सीमा के लिए ठीक करें: मिनटों को छोड़ दें और दिनांक स्वरूप 'yyMMddHH' का उपयोग करें, संस्करण कोड में कम से कम घंटे होंगे।
— पॉइंटर नल
10

वर्जन को बढ़ाने के लिए केवल रिलीज वर्जन में कोडकोड करें:

android {
    compileSdkVersion 21
    buildToolsVersion "21.1.2"

    def versionPropsFile = file('version.properties')
    def code = 1;
    if (versionPropsFile.canRead()) {
        def Properties versionProps = new Properties()

        versionProps.load(new FileInputStream(versionPropsFile))
        List<String> runTasks = gradle.startParameter.getTaskNames();
        def value = 0
        for (String item : runTasks)
        if ( item.contains("assembleRelease")) {
            value = 1;
        }
        code = Integer.parseInt(versionProps['VERSION_CODE']).intValue() + value
        versionProps['VERSION_CODE']=code.toString()
        versionProps.store(versionPropsFile.newWriter(), null)
    }
    else {
        throw new GradleException("Could not read version.properties!")
    }

    defaultConfig {
        applicationId "com.pack"
        minSdkVersion 14
        targetSdkVersion 21
        versionName "1.0."+ code
        versionCode code
    }

एक मौजूदा c://YourProject/app/version.propertiesफ़ाइल की अपेक्षा करता है , जिसे आप पहली बार बनाए जाने से पहले हाथ से बनाएंगेVERSION_CODE=8

फ़ाइल version.properties:

VERSION_CODE=8

— NickUnuchek
स्रोत
इसके बजाय इसे किसी कार्य के अंदर रखें और जनरेट करें ।ReleaseBuildConfig उस कार्य पर निर्भर करता है।
— लागोस
versionName "1.0।" + getSvnRevision () एक त्रुटि का कारण बनता है। GetSvnRevision () विधि का संदर्भ कहां है? क्या आप सुनिश्चित हैं कि इसे संस्करण "1.0" नहीं होना चाहिए। + कोड (आपके संस्करण कोड के साथ संस्करण का नाम बढ़ जाएगा)?
— portfoliobuilder
1
@portfoliobuilder, getSvnRevision () को कोड में बदलें
— निकुंचेख
4

फ़ाइल बनाएँ version.properties 

MAJOR=1
MINOR=3
PATCH=6
VERSION_CODE=1

बदलें build.gradle:

android {
def _versionCode=0
def _major=0
def _minor=0
def _patch=0

def _applicationId = "com.example.test"

def versionPropsFile = file('version.properties')

if (versionPropsFile.canRead()) {
    def Properties versionProps = new Properties()

    versionProps.load(new FileInputStream(versionPropsFile))

    _patch = versionProps['PATCH'].toInteger() + 1
    _major = versionProps['MAJOR'].toInteger()
    _minor = versionProps['MINOR'].toInteger() 
    _versionCode= versionProps['VERSION_CODE'].toInteger()+1
    if(_patch==99)
    {
        _patch=0
        _minor=_minor+1
    }
    if(_major==99){
        _major=0
        _major=_major+1
    }

    versionProps['MAJOR']=_major.toString()
    versionProps['MINOR']=_minor.toString()
    versionProps['PATCH']=_patch.toString()
    versionProps['VERSION_CODE']=_versionCode.toString()
    versionProps.store(versionPropsFile.newWriter(), null)
}
else {
    throw new GradleException("Could not read version.properties!")
}
def _versionName = "${_major}.${_versionCode}.${_minor}.${_patch}"


compileSdkVersion 23
buildToolsVersion "23.0.3"

defaultConfig {
    applicationId _applicationId
    minSdkVersion 11
    targetSdkVersion 23
    versionCode _versionCode
    versionName _versionName
}

}

आउटपुट: 1.1.3.6

— अहमद आगजादेह
स्रोत
धन्यवाद। और आपने वर्जननाम में वर्जनकोड क्यों डाला है? दूसरे स्थान पर भी।
— CoolMind
लेकिन यह उदाहरण के लिए 1.71.3.76 जैसा दिखेगा। मुझे लगता है, बेहतर है कि 1.3.76, इसे संस्करण कोड से अलग करना।
— CoolMind
हाँ । आप "$ {_ प्रमुख} .. $ {
— _बड़े
if (_major == 99) होना चाहिए अगर (_minor == 99) ??
— अनिरुद्ध बागरी
2

में संस्करणनाम को परिभाषित करेंAndroidManifest.xml

android:versionName="5.1.5"

एप्लिकेशन स्तर के अंदर android{...}ब्लॉक build.gradle:

defaultConfig {
        applicationId "com.example.autoincrement"
        minSdkVersion 18
        targetSdkVersion 23
        multiDexEnabled true
        def version = getIncrementationVersionName()
        versionName version
}

एप्लिकेशन स्तर के बाहर android{...}ब्लॉक build.gradle:

def getIncrementedVersionName() {
    List<String> runTasks = gradle.startParameter.getTaskNames();

    //find version name in manifest
    def manifestFile = file('src/main/AndroidManifest.xml')
    def matcher = Pattern.compile('versionName=\"(\\d+)\\.(\\d+)\\.(\\d+)\"').matcher(manifestFile.getText())
    matcher.find()

    //extract versionName parts
    def firstPart = Integer.parseInt(matcher.group(1))
    def secondPart = Integer.parseInt(matcher.group(2))
    def thirdPart = Integer.parseInt(matcher.group(3))

    //check is runTask release or not
    // if release - increment version
    for (String item : runTasks) {
        if (item.contains("assemble") && item.contains("Release")) {
            thirdPart++
            if (thirdPart == 10) {
                thirdPart = 0;
                secondPart++
                if (secondPart == 10) {
                    secondPart = 0;
                    firstPart++
                }
            }
        }
    }

    def versionName = firstPart + "." + secondPart + "." + thirdPart

    // update manifest
    def manifestContent = matcher.replaceAll('versionName=\"' + versionName + '\"')
    manifestFile.write(manifestContent)

    println "incrementVersionName = " + versionName

    return versionName
}

गाये जाने के बाद APK:

android:versionName="5.1.6"

नोट: यदि आपका संस्करण मेरे से भिन्न है, तो आपको परिवर्तन regex और भागों तर्क निकालने की आवश्यकता है ।

— सर्गेई शस्टिकोव
स्रोत
1

ऊपर दिखाए गए उदाहरण विभिन्न कारणों से काम नहीं करते हैं

इस लेख के विचारों के आधार पर मेरा रेडी-टू-यूज़ वैरिएंट है:

android {
    compileSdkVersion 28

    // /programming/21405457

    def propsFile = file("version.properties")
    // Default values would be used if no file exist or no value defined
    def customAlias = "Alpha"
    def customMajor = "0"
    def customMinor = "1"
    def customBuild = "1" // To be incremented on release

    Properties props = new Properties()
    if (propsFile .exists())
        props.load(new FileInputStream(propsFile ))

    if (props['ALIAS'] == null) props['ALIAS'] = customAlias else customAlias = props['ALIAS']
    if (props['MAJOR'] == null) props['MAJOR'] = customMajor else customMajor = props['MAJOR']
    if (props['MINOR'] == null) props['MINOR'] = customMinor else customMinor = props['MINOR']
    if (props['BUILD'] == null) props['BUILD'] = customBuild else customBuild = props['BUILD']

    if (gradle.startParameter.taskNames.join(",").contains('assembleRelease')) {
        customBuild = "${customBuild.toInteger() + 1}"
        props['BUILD'] = "" + customBuild

        applicationVariants.all { variant ->
            variant.outputs.all { output ->
                if (output.outputFile != null && (output.outputFile.name == "app-release.apk"))
                    outputFileName = "app-${customMajor}-${customMinor}-${customBuild}.apk"
            }
        }
    }

    props.store(propsFile.newWriter(), "Incremental Build Version")

    defaultConfig {
        applicationId "org.example.app"
        minSdkVersion 21
        targetSdkVersion 28
        versionCode customBuild.toInteger()
        versionName "$customAlias $customMajor.$customMinor ($customBuild)"

        ...
    }
...
}
— अलेक्जेंडर गवरिलुक
स्रोत
0

क्रेडिट्स कॉमन्सवेयर (स्वीकृत उत्तर) पॉल कैंटरेल (यदि यह मौजूद नहीं है तो फ़ाइल बनाएं) अहमद आगज़ादेह (संस्करण नाम और कोड)

इसलिए मैंने उनके सभी विचारों को एक साथ जोड़ दिया और इसके साथ आया। यह ड्रैग एंड ड्रॉप सॉल्यूशन है जो पहले पोस्ट ने पूछा था।

यह स्वचालित रूप से संस्करण स्थिति और संस्करणनाम को अद्यतन स्थिति के अनुसार अपडेट करेगा। बेशक आप अपनी आवश्यकताओं के अनुरूप चर को स्थानांतरित कर सकते हैं।

def _versionCode=0
def versionPropsFile = file('version.properties')
def Properties versionProps = new Properties()
if(versionPropsFile.exists())
    versionProps.load(new FileInputStream(versionPropsFile))
    def _patch = (versionProps['PATCH'] ?: "0").toInteger() + 1
    def _major = (versionProps['MAJOR'] ?: "0").toInteger()
    def _minor = (versionProps['MINOR'] ?: "0").toInteger()
    List<String> runTasks = gradle.startParameter.getTaskNames();
    def value = 0
    for (String item : runTasks)
        if ( item.contains("assembleRelease")) {
            value = 1;
        }
    _versionCode = (versionProps['VERSION_CODE'] ?: "0").toInteger() + value
    if(_patch==99)
    {
        _patch=0
        _minor=_minor+1
    }
    if(_major==99){
        _major=0
        _major=_major+1
    }

versionProps['MAJOR']=_major.toString()
versionProps['MINOR']=_minor.toString()
versionProps['PATCH']=_patch.toString()
versionProps['VERSION_CODE']=_versionCode.toString()
versionProps.store(versionPropsFile.newWriter(), null)
def _versionName = "${_major}.${_versionCode}.${_minor}.${_patch}"

compileSdkVersion 24
buildToolsVersion "24.0.0"

defaultConfig {
    applicationId "com.yourhost.yourapp"
    minSdkVersion 16
    targetSdkVersion 24
    versionCode _versionCode
    versionName _versionName
}
— Thunderstick
स्रोत
0

ग्रेड टास्क ग्राफ का उपयोग करके हम बिल्ड प्रकार की जांच / स्विच कर सकते हैं ।

मूल विचार प्रत्येक बिल्ड पर वर्जनकोड को बढ़ाना है । प्रत्येक पर version.properties फ़ाइल में संग्रहीत काउंटर बनाएँ। इसे हर नए एपीके बिल्ड पर अपडेट रखा जाएगा और वर्जन.ग्रेड फाइल को बिल्ड में बदल दें। इस वर्धित काउंटर वैल्यू के साथ।

apply plugin: 'com.android.application'

android {
compileSdkVersion 25
buildToolsVersion '25.0.2'

def versionPropsFile = file('version.properties')
def versionBuild

/*Setting default value for versionBuild which is the last incremented value stored in the file */
if (versionPropsFile.canRead()) {
    def Properties versionProps = new Properties()
    versionProps.load(new FileInputStream(versionPropsFile))
    versionBuild = versionProps['VERSION_BUILD'].toInteger()
} else {
    throw new FileNotFoundException("Could not read version.properties!")
}


/*Wrapping inside a method avoids auto incrementing on every gradle task run. Now it runs only when we build apk*/
ext.autoIncrementBuildNumber = {

    if (versionPropsFile.canRead()) {
        def Properties versionProps = new Properties()
        versionProps.load(new FileInputStream(versionPropsFile))
        versionBuild = versionProps['VERSION_BUILD'].toInteger() + 1
        versionProps['VERSION_BUILD'] = versionBuild.toString()
        versionProps.store(versionPropsFile.nminSdkVersion 14
        targetSdkVersion 21
        versionCode 1ewWriter(), null)
    } else {
        throw new FileNotFoundException("Could not read version.properties!")
    }
}


defaultConfig {
    minSdkVersion 16
    targetSdkVersion 21
    versionCode 1
    versionName "1.0.0." + versionBuild
}

buildTypes {
    release {
        minifyEnabled false
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
}

// Hook to check if the release/debug task is among the tasks to be executed.
//Let's make use of it
gradle.taskGraph.whenReady {taskGraph ->
    if (taskGraph.hasTask(assembleDebug)) {  /* when run debug task */
        autoIncrementBuildNumber()
    } else if (taskGraph.hasTask(assembleRelease)) { /* when run release task */
        autoIncrementBuildNumber()
    }
  }
}

dependencies {
  compile fileTree(dir: 'libs', include: ['*.jar'])
  compile 'com.android.support:appcompat-v7:25.3.1'
}

मुख्य मॉड्यूल के अपने build.gradle फ़ाइल के अंदर उपरोक्त स्क्रिप्ट रखें।

संदर्भ वेबसाइट: http://devdeeds.com/auto-increment-build-number-using-gradle-in-android/

सादर धन्यवाद!

— Jayakrishnan
स्रोत
0

पहला टिप्पणी कोड प्रत्येक "पुन: निर्माण परियोजना" के दौरान संख्या में वृद्धि करेगा और "संस्करण संपत्ति" फ़ाइल में मान को बचाएगा।

दूसरा टिप्पणी कोड एपीके फ़ाइल का नया संस्करण नाम उत्पन्न करेगा, जबकि "बिल्ड एपीके"।

android {
    compileSdkVersion 28
    buildToolsVersion "29.0.0"
    //==========================START==================================
    def Properties versionProps = new Properties()
    def versionPropsFile = file('version.properties')
    if(versionPropsFile.exists())
        versionProps.load(new FileInputStream(versionPropsFile))
    def code = (versionProps['VERSION_CODE'] ?: "0").toInteger() + 1
    versionProps['VERSION_CODE'] = code.toString()
    versionProps.store(versionPropsFile.newWriter(), null)
    //===========================END===================================
    defaultConfig {
        applicationId "com.example.myapp"
        minSdkVersion 15
        targetSdkVersion 28
        versionCode 1
        versionName "0.19"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
            //=======================================START===============================================
            android.applicationVariants.all { variant ->
                variant.outputs.all {
                    def appName = "MyAppSampleName"
                    outputFileName = appName+"_v${variant.versionName}.${versionProps['VERSION_CODE']}.apk"
                }
            }
            //=======================================END===============================================
        }
    }
}
— राधा कृष्ण ईदुलकांति
स्रोत
कृपया कुछ पाठ जोड़ें जो आपने बदला है। और क्यों
— मैथ्यू केरियन
0

मैक ive पर ग्रैडल 5.1.1 संस्करण में बदल गया कि कैसे कार्य नामों को पुनर्प्राप्त किया गया, मैंने निर्माण से स्वाद / प्रकार प्राप्त करने की कोशिश की, लेकिन कार्य नाम को विभाजित करने के लिए आलसी था:

def versionPropsFile = file('version.properties')
if (versionPropsFile.canRead()) {
    def Properties versionProps = new Properties()

    versionProps.load(new FileInputStream(versionPropsFile))

    def value = 0

    def runTasks = gradle.getStartParameter().getTaskRequests().toString()

    if (runTasks.contains('assemble') || runTasks.contains('assembleRelease') || runTasks.contains('aR')) {
        value = 1
    }

    def versionMajor = 1
    def versionMinor = 0
    def versionPatch = versionProps['VERSION_PATCH'].toInteger() + value
    def versionBuild = versionProps['VERSION_BUILD'].toInteger() + 1
    def versionNumber = versionProps['VERSION_NUMBER'].toInteger() + value

    versionProps['VERSION_PATCH'] = versionPatch.toString()
    versionProps['VERSION_BUILD'] = versionBuild.toString()
    versionProps['VERSION_NUMBER'] = versionNumber.toString()

    versionProps.store(versionPropsFile.newWriter(), null)

    defaultConfig {
        applicationId "de.evomotion.ms10"
        minSdkVersion 21
        targetSdkVersion 28
        versionCode versionNumber
        versionName "${versionMajor}.${versionMinor}.${versionPatch} (${versionBuild})"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        signingConfig signingConfigs.debug
    }

} else {
    throw new GradleException("Could not read version.properties!")
}

कोड @just_user से है

— Basur
स्रोत
0

वहाँ दो समाधान मैं वास्तव में पसंद कर रहे हैं। पहला Play Store पर निर्भर करता है और दूसरा Git पर निर्भर करता है।

Play Store का उपयोग करके, आप उच्चतम उपलब्ध अपलोड किए गए संस्करण कोड को देखकर संस्करण कोड बढ़ा सकते हैं । इस समाधान का लाभ यह है कि एक एपीके अपलोड कभी भी विफल नहीं होगा क्योंकि आपका संस्करण कोड हमेशा प्ले स्टोर पर जो कुछ भी है, उससे अधिक है। नकारात्मक पक्ष यह है कि प्ले स्टोर के बाहर अपने एपीके को वितरित करना अधिक कठिन हो जाता है। आप Quickstart गाइड का पालन ​​करके और संस्करण कोड को स्वचालित रूप से हल करने के लिए प्लगइन बताकर ग्रेड प्ले प्रकाशक का उपयोग करके इसे सेट कर सकते हैं :

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

android {
    ...
}

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

Git का उपयोग करके, आप उस वर्जन कोड को बढ़ा सकते हैं जो आपके रिपॉजिटरी में कितने कमिट और टैग हैं। यहाँ लाभ यह है कि आपका आउटपुट प्रतिलिपि प्रस्तुत करने योग्य है और आपके रेपो के बाहर किसी भी चीज़ पर निर्भर नहीं करता है। नकारात्मक पक्ष यह है कि आपको अपने संस्करण कोड को टक्कर देने के लिए एक नई प्रतिबद्धता या टैग बनाना होगा। आप संस्करण मास्टर ग्रेड प्लगइन जोड़कर इसे सेट कर सकते हैं :

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

android {
    ...
}
— SUPERCILEX
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.