android - Gradle का उपयोग कर एक रिलीज हस्ताक्षरित एपीके फ़ाइल कैसे बनाएँ?




apk release android-gradle (22)

यदि आप build.gradle में अपने कीस्टोर और पासवर्ड को हार्डकोडिंग से बचाना चाहते हैं, तो आप यहां समझाए गए गुण फ़ाइल का उपयोग कर सकते हैं: ग्रैंडल के साथ कॉन्फ़िगर करना

मूल रूप से:

1) ऐसी सामग्री के साथ /home/[username]/.signing पर myproject.properties फ़ाइल बनाएं:

keystore=[path to]\release.keystore
keystore.password=*********
keyAlias=***********
keyPassword=********

2) सामग्री के साथ एक gradle.properties फ़ाइल (शायद अपनी परियोजना निर्देशिका की जड़ पर) बनाएँ:

MyProject.properties=/home/[username]/.signing/myproject.properties

3) इसे अपने निर्माण में देखें। इस तरह के:

    if(project.hasProperty("MyProject.properties")
        && new File(project.property("MyProject.properties")).exists()) {

    Properties props = new Properties()
    props.load(new FileInputStream(file(project.property("MyProject.properties"))))

    signingConfigs {
        release {
            storeFile file(props['keystore'])
            storePassword props['keystore.password']
            keyAlias props['keyAlias']
            keyPassword props['keyPassword']
        }
    }
}

मैं ग्रैडल का उपयोग कर एक रिलीज हस्ताक्षरित एपीके फ़ाइल बनाने के लिए अपना ग्रैडल बिल्ड करना चाहता हूं।

मुझे यकीन नहीं है कि कोड सही है या यदि मैं gradle build करते समय पैरामीटर खो रहा हूं?

यह मेरी ग्रेडल फ़ाइल में कुछ कोड है:

android {
    ...
    signingConfigs {
          release {
              storeFile file("release.keystore")
              storePassword "******"
              keyAlias "******"
              keyPassword "******"
         }
     }
}

धीरे-धीरे निर्माण सफल हो जाता है, और मेरे build/apk फ़ोल्डर में मैं केवल ...-release-unsigned.apk और ...-debug-unaligned.apk फ़ाइलें देखता हूं।

इसे हल करने के तरीके पर कोई सुझाव?


यदि आपके पास पहले से कीस्टोर फ़ाइल है, तो यह आपके निर्माण कमांड में कुछ पैरामीटर जोड़ने के समान सरल हो सकता है:

./gradlew assembleRelease \
 -Pandroid.injected.signing.store.file=$KEYFILE \
 -Pandroid.injected.signing.store.password=$STORE_PASSWORD \
 -Pandroid.injected.signing.key.alias=$KEY_ALIAS \
 -Pandroid.injected.signing.key.password=$KEY_PASSWORD

आपके एंड्रॉइड प्रोजेक्ट में कोई स्थायी बदलाव आवश्यक नहीं है।

स्रोत: http://www.tinmith.net/wayne/blog/2014/08/gradle-sign-command-line.htm


डेविड वावरा द्वारा जवाब का विस्तार, एक फ़ाइल ~ / .gradle / gradle.properties बनाएँ और जोड़ें

RELEASE_STORE_FILE=/path/to/.keystore
RELEASE_KEY_ALIAS=XXXXX
RELEASE_STORE_PASSWORD=XXXXXXXXX
RELEASE_KEY_PASSWORD=XXXXXXXXX

फिर build.gradle में

  signingConfigs {
    release {
    }
  }

  buildTypes {
    release {
      minifyEnabled true
      shrinkResources true

    }
  }

  // make this optional
  if ( project.hasProperty("RELEASE_KEY_ALIAS") ) {
    signingConfigs {
      release {
        storeFile file(RELEASE_STORE_FILE)
        storePassword RELEASE_STORE_PASSWORD
        keyAlias RELEASE_KEY_ALIAS
        keyPassword RELEASE_KEY_PASSWORD
      }
    }
    buildTypes {
      release {
        signingConfig signingConfigs.release
      }
    }
  }

@ डेस्टिल का जवाब अच्छा है अगर आप सभी परियोजनाओं में एक ही कॉन्फ़िगरेशन का पुन: उपयोग कर सकते हैं। वैकल्पिक रूप से, एंड्रॉइड स्टूडियो एक local.properties फ़ाइल के साथ आता है जिसका उपयोग शायद इसके बजाय किया जा सकता है, लेकिन यह माना जाता है कि आईडीई-जेनरेट किया गया है और मुझे इसे एंड्रॉइड स्टूडियो के भीतर से विस्तारित करने का कोई तरीका नहीं मिल रहा है।

यह @ जोन्बो के जवाब का एक बदलाव है। वह उत्तर परियोजना विशिष्ट सेटिंग्स की अनुमति देता है लेकिन यह डेवलपर ओवरहेड के साथ आता है। विशेष रूप से, signingConfigs परिभाषा को एक अलग फ़ाइल में स्थानांतरित करने के लिए महत्वपूर्ण बॉयलरप्लेट की आवश्यकता होती है - विशेष रूप से यदि आपको कई परियोजनाओं के लिए ऐसा करने की आवश्यकता है, जो Destil's पर इस समाधान को चुनने का मुख्य कारण है। यह लाइन सहित भी कुछ हद तक कम किया जा सकता है

apply plugin: 'com.android.application'

क्रेडेंशियल्स फ़ाइल में, क्योंकि यह आईडीई पूरा करने की अनुमति देगा।

अंत में, यहां अधिकांश समाधान डीबग मोड में प्रोजेक्ट बनाने की अनुमति नहीं देते हैं - जो स्वचालित रूप से डीबग-हस्ताक्षर को संभालता है - बिना किसी सैद्धांतिक रूप से वैध signingConfigs परिभाषा को प्रदान किए बिना। यदि आपको किसी दिए गए मशीन से रिलीज बिल्ड बनाने की आवश्यकता नहीं है, तो यह अतिरिक्त कदम अनावश्यक बाधा के रूप में देखा जा सकता है। दूसरी तरफ, यह उत्पादन में डीबग बिल्ड चलाने वाले अज्ञानी या आलसी सहयोगियों के खिलाफ सहायता हो सकती है।

यह समाधान डिबग बिल्ड को क्रेडेंशियल्स के बारे में चिंता किए बिना बिल्ड करने की अनुमति देगा, लेकिन इसे रिलीज बिल्ड बनाने के लिए वैध प्रमाण-पत्रों की आवश्यकता होगी, और इसमें बहुत कम बॉयलरप्लेट लगता है। हालांकि, नकारात्मक रूप से यह दूसरों को वास्तविक प्रमाण - पत्रों के साथ डमी मूल्यों को प्रतिस्थापित करने के लिए प्रोत्साहित कर सकता है और इसके खिलाफ सुरक्षा करने का कोई तरीका नहीं है।

// app/build.gradle
// Define this structure in signing.gradle to enable release builds.
ext.signing = [
        storeFilePath : 'path/to/keystore',
        storePassword : 'keystore password',
        keyAlias      : 'key alias',
        keyPassword   : 'key password',
]

if (file('signing.gradle').exists()) {
    apply from: 'signing.gradle'
}

android {
    ...
    signingConfigs {
        release {
            storeFile file(project.signing.storeFilePath)
            storePassword project.signing.storePassword
            keyAlias project.signing.keyAlias
            keyPassword project.signing.keyPassword
        }
    }
    buildTypes {
        debug { ... }
        release {
            signingConfig signingConfigs.release
            ...
        }
    }
}

यह एक डमी संपत्ति बनाता है जो पूरी तरह से एक वाक्य रचनात्मक रूप से वैध निर्माण फ़ाइल बनाने के लिए कार्य करता है। ext.signing की गुणों को असाइन किए गए मान अप्रासंगिक हैं जहां तक ​​डीबग बनाता है। रिलीज बिल्ड को सक्षम करने के लिए, ext.signing में ext.signing प्रतिलिपि बनाएँ और डमी मानों को वैध क्रेडेंशियल के साथ प्रतिस्थापित करें।

// signing.gradle
ext.signing = [
        storeFilePath : 'real/keystore',
        storePassword : 'real keystore password',
        keyAlias : 'real key alias',
        keyPassword : 'real key password',
]

बेशक, signing.gradle को वीसीएस द्वारा अनदेखा किया जाना चाहिए।


android {
    compileSdkVersion 17
    buildToolsVersion "19.0.3"

    defaultConfig {
        minSdkVersion 9
        targetSdkVersion 18
    }

    File signFile = rootProject.file('sign/keystore.properties')
    if (signFile.exists()) {
        Properties properties = new Properties()
        properties.load(new FileInputStream(signFile))
        signingConfigs {
            release {
                storeFile rootProject.file(properties['keystore'])
                storePassword properties['storePassword']
                keyAlias properties['keyAlias']
                keyPassword properties['keyPassword']
            }
        }
    }

    buildTypes {
        release {
            runProguard true
            zipAlign true
            proguardFile rootProject.file('proguard-rules.cfg')
            signingConfig signingConfigs.release
        }
        debug {
            runProguard false
            zipAlign true
        }
    }
}

(उपरोक्त user672009 जवाब में।)

एक आसान समाधान, यदि आप अपने पासवर्ड को गिट भंडार से बाहर रखना चाहते हैं; फिर भी, इसमें अपना build.gradle शामिल करना चाहते हैं, यह उत्पाद स्वाद के साथ भी बहुत अच्छा काम करता है, एक अलग ग्रेडल फ़ाइल बनाना है। चलिए इसे 'sign.gradle' कहते हैं (इसे अपने .gitignore में शामिल करें)। जैसे कि यह आपकी build.gradle फ़ाइल कम से कम सब कुछ साइन इन करने से संबंधित नहीं था।

android {
    signingConfigs { 
        flavor1 {
            storeFile file("..")
            storePassword ".."
            keyAlias ".."
            keyPassword ".."
        }
        flavor2 {
            storeFile file("..")
            storePassword ".."
            keyAlias ".."
            keyPassword ".."
        }
    }
}

फिर आपके build.gradle फ़ाइल में "प्लगइन लागू करें" के नीचे इस पंक्ति को शामिल करें: एंड्रॉइड ''

 apply from: 'signing.gradle'

यदि आपके पास एकाधिक स्वाद नहीं हैं या उनका उपयोग नहीं है, तो "स्वाद 1" का नाम ऊपर "रिलीज़" करने के लिए करें, और आपको समाप्त होना चाहिए। यदि आप स्वाद का उपयोग कर रहे हैं जारी रखें।

अंत में अपने स्वाद को अपने सही हस्ताक्षर पर लिंक करें अपनी build.gradle फ़ाइल में कॉन्फ़िगर करें और आपको समाप्त होना चाहिए।

  ...

  productFlavors {

      flavor1 {
          ...
          signingConfig signingConfigs.flavor1
      }

      flavor2 {
          ...
          signingConfig signingConfigs.flavor2
      }
  }

  ...

गिट का उपयोग करते समय स्वचालित ऐप ग्रिडल के साथ हस्ताक्षर करना

यह आश्चर्यजनक है कि ऐसा करने के लिए कितने ठोस तरीके हैं। यहां मेरा अपना तरीका है, जहां मैं गूगल्स की अपनी recommendation का पालन करने की कोशिश करता हूं। हालांकि, उनकी व्याख्या पूरी तरह से स्पष्ट नहीं है, इसलिए मैं विस्तार से लिनक्स की प्रक्रिया का वर्णन करूंगा।

विवरण:

बिल्ड के दौरान स्वचालित रूप से किसी ऐप पर हस्ताक्षर करने के लिए डिफ़ॉल्ट recommendation , आपके ऐप डेवलपमेंट (जीआईटी) पथ में पासवर्ड और हस्ताक्षर फ़ाइलों को रखे बिना, अस्पष्ट है। यहां स्पष्ट कदम-दर-चरण निर्देश दिए गए हैं कि ऐसा कैसे करें।

आरंभिक धारणाएं:

आपके पास निम्न पथ द्वारा दी गई निर्देशिका में "MyApp" नामक एक ऐप है: $HOME/projects/mydev/MyApp । हालांकि, MyApp निर्देशिका का उपयोग जीआईटी के साथ किया जाता है और नियंत्रित किया जाता है।

मुसीबत

हम स्पष्ट रूप से जीआईटी नियंत्रित निर्देशिका में कहीं भी हमारे हस्ताक्षर या पासवर्ड फ़ाइलों को नहीं चाहते हैं, भले ही हम .gitignore आदि का उपयोग करने में सक्षम हैं, फिर भी यह बहुत जोखिम भरा और गलती करने में आसान है। तो हम बाहर हमारे कीस्टोर और हस्ताक्षर फाइलों चाहते हैं।

उपाय

हमें तीन (3) चीजें करने की ज़रूरत है:

  1. Android स्टूडियो द्वारा उपयोग की जाने वाली पासवर्ड फ़ाइल बनाएं
  2. हस्ताक्षर कुंजी फ़ाइल बनाएँ
  3. (1) और (2) का उपयोग करने के लिए मॉड्यूल build.gradle फ़ाइल संपादित करें।

इस उदाहरण के लिए हम दो फाइलों का नाम देते हैं:

  1. keystore.properties
  2. MyApp-release-key.jks

हम इन दोनों फाइलों को यहां डाल सकते हैं:

cd $HOME/projects/mydev/

(1) कीस्टोर पासवर्ड फ़ाइल बनाएँ

पहली फ़ाइल में उपयोग किए गए स्पष्ट टेक्स्ट पासवर्ड होते हैं; और रिलीज-कुंजी फ़ाइल के पथ (2) में। इसे भरने के साथ शुरू करें, क्योंकि यह अगले चरण के लिए एक कॉपी पेस्ट ऑपरेशन आसान बना देगा।

cd $HOME/projects/mydev/

keystore.properties संपादित करें ताकि यह सामग्री हो:

storePassword=myStorePassword
keyPassword=mykeyPassword
keyAlias=myKeyAlias
storeFile=myStoreFileLocation

यहां एकमात्र मुश्किल हिस्सा है, myStoreFileLocation । बिल्ड के दौरान मॉड्यूल build.gradle फ़ाइल से देखा गया यह पथ है। इसका आमतौर पर एक रास्ता समान और सापेक्ष है: $HOME/projects/mydev/MyApp/app/build.gradle । तो MyApp-release-key.jks फ़ाइल को इंगित करने के लिए, हमें यहां क्या रखना है:

../../../MyApp-release-key.jks

यहां, हमने कुंजी के लिए "myapp" उपनाम भी चुना है। फिर अंतिम फ़ाइल को देखना चाहिए:

storePassword=myStorePassword
keyPassword=mykeyPassword
keyAlias=myapp
storeFile=../../../MyApp-release-key.jks

(2) हस्ताक्षर फ़ाइल बनाएँ

जब आप हस्ताक्षर कुंजी बनाते हैं तो दूसरी फ़ाइल स्वचालित रूप से जेनरेट की जाती है। यदि आपके पास कोई अन्य ऐप नहीं है और यह आपका एकमात्र कीस्टोर है, तो फ़ाइल को इसके साथ बनाएं:

cd $HOME/projects/mydev/
keytool -genkeypair -v -keystore MyApp-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias myapp

यह आपको दो पासवर्ड और जानकारी का एक समूह के लिए पूछेगा। (एंड्रॉइड स्टूडियो में वही सामान।) अब अपने पहले चुने गए पासवर्ड कॉपी / पेस्ट करें।

(3) उपरोक्त उपयोग करने के लिए अपने मॉड्यूल gradle.build फ़ाइल संपादित करें

निम्नलिखित भागों को आपके ऐप / मॉड्यूल की ग्रैडल बिल्ड फ़ाइल में उपस्थित होने की आवश्यकता है। सबसे पहले, अपने android {} ब्लॉक के बाहर और पहले निम्न पंक्तियां जोड़ें।

//def keystorePropertiesFile = rootProject.file("$HOME/.android/keystore.properties")
def keystorePropertiesFile = rootProject.file("../../keystore.properties")
def keystoreProperties = new Properties()
keystoreProperties.load(new FileInputStream(keystorePropertiesFile))

फिर, android {} ब्लॉक के अंदर , जोड़ें:

android {
    ...
    defaultConfig { ... }
    signingConfigs {
            release {
                keyAlias keystoreProperties['keyAlias']
                keyPassword keystoreProperties['keyPassword']
                storeFile file(keystoreProperties['storeFile'])
                storePassword keystoreProperties['storePassword']
            }
        }
    // Tell Gradle to sign your APK
    buildTypes {
        release {
            signingConfig signingConfigs.release
            ...
        }
    }
}

अब खोल से, आप अपने ऐप को फिर से बना सकते हैं:

cd $HOME/projects/mydev/MyApp/app/
./gradlew clean build

यह एक उचित हस्ताक्षरित ऐप उत्पन्न करना चाहिए जिसका उपयोग Google Play में किया जा सकता है।


मुझे यह पता लगाने में बहुत मज़ा आया था। यहाँ मेरा चलना है।

IntelliJ (v.13.1.4) में एक ग्रेडल बिल्ड फ़ाइल बनाने के तरीके पर एक ज़ेड टॉक-थ्रू के माध्यम से यह चलने वाला यह मानता है कि एक कीस्टोर फ़ाइल कैसे बनाएं। काम करने के लिए इस ट्यूटोरियल के लिए आपको अपने ऐप फ़ोल्डर में स्थित होने के लिए अपनी कीस्टोर फ़ाइल की आवश्यकता होगी और आपको अपनी zipalign.exe फ़ाइल को 'एसडीके-रूट \ टूल्स' में स्थित होने की आवश्यकता होगी। यह फ़ाइल आमतौर पर 'एसडीके-रूट \ बिल्ड-टूल्स' में पाई जाती है और इस फ़ोल्डर के तहत यह उच्चतम एपीआई फ़ोल्डर (अल्फा या बीटा मैं अल्फा संस्करण की सिफारिश करता हूं) में होगी।

आप में से जो सीधे यहां कूदना चाहते हैं, वे हैंडल बिल्ड फ़ाइल है।

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

repositories {
    mavenCentral()
}
android {
    compileSdkVersion 19
    buildToolsVersion '20.0.0'
    defaultConfig {
        minSdkVersion 8
        targetSdkVersion 19
        versionCode 1
        versionName "1.0"
    }
    signingConfigs {
        playstore {
            keyAlias 'developers4u'
            keyPassword 'thisIsNotMyRealPassword'
            storeFile file('developers4u.keystore')
            storePassword 'realyItIsNot'
        }
    }
    buildTypes {
        assembleRelease {
            debuggable false
            jniDebugBuild false
            runProguard true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
            zipAlign true
            signingConfig signingConfigs.playstore
        }
    }
}

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

आप मेनू विकल्प से इस बिल्ड फ़ाइल (उपरोक्त) का हिस्सा बना सकते हैं: यहां से फ़ाइल / परियोजना संरचना का चयन करें और 'एंड्रॉइड-ग्रैडल (ऐप) पर क्लिक करें। यहां से आप टैब देखेंगे: इस प्रॉप-थ्रू के लिए 'गुण', 'साइनिंग', 'फ्लेवर्स', 'बिल्ड प्रकार' और 'निर्भरता' हम केवल 'साइनिंग' और 'बिल्ड प्रकार' का उपयोग करेंगे। 'बिल्ड प्रकार' के अंतर्गत (नाम सेक्शन में) कोई भी नाम दर्ज करें जिसे आप अपनी बिल्ड प्रकार कॉन्फ़िगरेशन की पहचान करना चाहते हैं और अन्य 4 फ़ील्ड में अपनी कीस्टोर जानकारी दर्ज करें (कीस्टोर पथ को अपने ऐप फ़ोल्डर के नीचे सेट करें)।

'बिल्ड प्रकार' के तहत नाम फ़ील्ड में मूल्य 'इकट्ठा करें' दर्ज करें, 'डिबग्रेबल' को गलत पर सेट किया जाना चाहिए, 'जेनी डीबग बिल्ड' को झूठा होना चाहिए, 'प्रोग्रार्ड रन' को सत्य और 'ज़िप संरेखण' को सही पर सेट करना चाहिए। यह बिल्ड फ़ाइल उत्पन्न करेगा, लेकिन उपरोक्त चित्रित नहीं है, आपको बाद में बिल्ड फ़ाइल में कुछ चीज़ें जोड़नी होंगी। यहां ProGuard फ़ाइल स्थान को धीरे-धीरे निर्माण फ़ाइल में सेट किया जाएगा। (ऊपर वर्णित के रूप में)

डीएसएल कंटेनर आपको बाद में जोड़ना होगा:

android {
    ....
    compileSdkVersion 19
    buildToolsVersion '20.0.0'
    defaultConfig {
        minSdkVersion 8
        targetSdkVersion 19
        versionCode 1
        versionName "1.0"
    }
    ....
}

आपको यह भी जोड़ना होगा:

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

ध्यान दें कि ऊपर इस डीएसएल कंटेनर ('निर्भरता') कॉन्फ़िगरेशन फ़ाइल के नीचे होना चाहिए लेकिन एंड्रॉइड डीएसएल कंटेनर के अंदर नहीं होना चाहिए। IntelliJ मेनू से निर्भरता कंटेनर बनाने के लिए, चुनें: फ़ाइल / परियोजना संरचना। वहां से फिर से और फिर एंड्रॉइड-ग्रैडल (ऐप) का चयन करें। जैसा कि ऊपर वर्णित है, आपको वही 5 टैब दिखाई देंगे। 'निर्भरता' टैब का चयन करें और अपनी आवश्यक निर्भरताओं को जोड़ें।

यह सब करने के बाद आपको इस वॉड-थ्रू के शीर्ष पर फ़ाइल के समान ग्रैडल बिल्ड फ़ाइल देखना चाहिए। अपने हस्ताक्षरित ज़िप संरेखित रिलीज को बनाने के लिए आपको ग्रैडल कार्यों को खोलने की आवश्यकता होगी। आप व्यू / टूल विंडोज / ग्रैडल चुनकर इस विंडो में जा सकते हैं। यहां से आप 'इकट्ठा एस्सेबल रिलेज' पर क्लिक कर सकते हैं। यह आपके तैनाती एपीके उत्पन्न करना चाहिए।

आपकी रिलीज को संकलित करते समय होने वाली संभावित समस्याएं हैं (लेकिन इस तक सीमित नहीं हैं): आपकी ग्रैडल बिल्ड फ़ाइल गलत जगह पर है। दो ग्रैडल बिल्ड फाइलें हैं; एप्लिकेशन रूट के तहत ऐप फ़ोल्डर में आपके एप्लिकेशन रूट फ़ोल्डर में से एक और दूसरा। आपको बाद वाले उपयोगकर्ता को अवश्य ही करना चाहिए।

आपको लिंट की समस्या भी हो सकती है। (नोट: एंड्रॉइड डेवलपर स्टूडियो इंटेलिजे की तुलना में लिंट समस्याओं को ढूंढने में काफी बेहतर है, आप मेन्यू विकल्पों से हस्ताक्षरित एपीके उत्पन्न करने का प्रयास करते समय इसे नोटिस करेंगे)

आसपास की लिंट समस्याओं के लिए आपको एंड्रॉइड कंटेनर (शीर्ष पर) के अंदर निम्नलिखित डीएसएल कंटेनर डालना होगा:

android {
        ....
    lintOptions {
        abortOnError false
    }
    ....
}

इसे अपने एंड्रॉइड डीएसएल कंटेनर के अंदर डालने से बिल्ड फ़ोल्डर में सीधे त्रुटि फ़ाइल उत्पन्न हो जाएगी (सीधे आपके ऐप फ़ोल्डर के तहत) फ़ाइल का नाम 'लिंट-परिणाम-रिलीज-fatal.html' जैसा होना चाहिए यह फ़ाइल आपको बताएगी वह वर्ग जहां त्रुटि हुई। उत्पन्न की जाने वाली एक और फ़ाइल एक एक्सएमएल फ़ाइल है जिसमें लिंट त्रुटि से जुड़ी 'समस्या आईडी' होती है। फ़ाइल नाम 'lint-results-release-fatal.xml' जैसा होना चाहिए। फ़ाइल के शीर्ष के पास कहीं भी आपको एक नोड 'मुद्दा' दिखाई देगा जिसके अंदर आप 'id = "IDOfYourLintProblem" के समान कुछ देखेंगे।

इस समस्या को ठीक करने के लिए अपनी प्रोजेक्ट में फ़ाइल खोलें जो 'लिंट-नतीजे-इकट्ठा रिलेज़-fatal.html' फ़ाइल में सूचीबद्ध थी और क्लास नाम के ऊपर जावा क्लास फ़ाइल में कोड की निम्न पंक्ति दर्ज करें: @SuppressLint ("IDOfYourLintProblem ")। आपको 'android.annotation.SuppressLint' आयात करना पड़ सकता है;

तो आपकी जावा क्लास फ़ाइल इस तरह दिखनी चाहिए:

package com.WarwickWestonWright.developers4u.app.CandidateArea;

import android.annotation.SuppressLint;
... other imports

@SuppressLint("IDOfYourLintProblem")
public class SearchForJobsFragment extends Fragment {... rest of your class definition}

ध्यान दें कि लिंट त्रुटियों को दबाने से हमेशा सबसे अच्छा आईडीईए नहीं होता है, जो आपके कोड को बदलने के लिए बेहतर हो सकता है जिससे लिंट त्रुटियां होती हैं।

संभावित रूप से ऐसा होने वाली एक और समस्या यह है कि यदि आपने ग्राउंड होम पर्यावरण चर के लिए पर्यावरण चर सेट नहीं किया है। इस चर को 'GRADLE_HOME' नाम दिया गया है और इसे 'सी: \ gradle-1.12' जैसे कुछ ग्रेडल होम निर्देशिका का पथ सेट किया जाना चाहिए, कभी-कभी आप 'ANDROID_HOME' के लिए पर्यावरण चर सेट करना भी चाहते हैं, इसे ' एसडीके-रूट \ एसडीके '

ऐसा करने के बाद ग्रैडल कार्य विंडो पर वापस लौटें और इकट्ठा करें एस्सेबल रिलेज पर डबल क्लिक करें।

यदि सब सफल हैं तो आप फ़ोल्डर ऐप \ build \ apk पर जा सकते हैं और अपनी तैनाती एपीके फ़ाइल ढूंढ सकते हैं।


पिछले उत्तरों की तुलना में आसान तरीका:

इसे ~/.gradle/gradle.properties

RELEASE_STORE_FILE={path to your keystore}
RELEASE_STORE_PASSWORD=*****
RELEASE_KEY_ALIAS=*****
RELEASE_KEY_PASSWORD=*****

इस तरह अपने build.gradle संशोधित करें:

...    
signingConfigs {

   release {
       storeFile file(RELEASE_STORE_FILE)
       storePassword RELEASE_STORE_PASSWORD
       keyAlias RELEASE_KEY_ALIAS
       keyPassword RELEASE_KEY_PASSWORD
   }
}

buildTypes {
        release {
            signingConfig signingConfigs.release
        }
}
....

फिर आप gradle assembleRelease कर सकते हैं


@ डेस्टिल की तरह कहा लेकिन उन लोगों को अनुमति दें जिनके पास निर्माण करने की कुंजी नहीं है: पिछले उत्तरों की तुलना में आसान तरीका:

इसे ~/.gradle/gradle.properties

RELEASE_STORE_FILE={path to your keystore}
RELEASE_STORE_PASSWORD=*****
RELEASE_KEY_ALIAS=*****
RELEASE_KEY_PASSWORD=*****

इस तरह अपने build.gradle संशोधित करें:

...    
if(project.hasProperty("RELEASE_STORE_FILE")) {
    signingConfigs {    
       release {
           storeFile file(RELEASE_STORE_FILE)
           storePassword RELEASE_STORE_PASSWORD
           keyAlias RELEASE_KEY_ALIAS
           keyPassword RELEASE_KEY_PASSWORD
       }
    }
}

buildTypes {
    if(project.hasProperty("RELEASE_STORE_FILE")) {
        release {
            signingConfig signingConfigs.release
        }
    }
}
....

फिर आप gradle assembleRelease कर सकते हैं या gradle build gradle assembleRelease सकते हैं


Android Studio Go to File -> Project Structure or press Ctrl+Alt+Shift+S

See The Image

Click Ok

Then the signingConfigs will generate on your build.gradle file.


To complement the other answers, you can also place your gradle.properties file in your own module folder, together with build.gradle, just in case your keystore is specific to one project.


नए एंड्रॉइड स्टूडियो में, एक जीयूआई तरीका है जो बहुत आसान है और यह ग्रैडल फ़ाइल को भी पॉप्युलेट करता है।

  1. File -> Project Structure

  2. Module -> मुख्य मॉड्यूल ('ऐप' या अन्य कस्टम नाम चुनें)

  3. Signing टैब -> प्लस छवि नई कॉन्फ़िगरेशन जोड़ने के लिए

  4. दाईं तरफ डेटा भरें

  5. ठीक है और ग्रैडल फ़ाइल स्वचालित रूप से बनाई गई है

  6. आपको मैन्युअल रूप से एक लाइन signingConfig signingConfigs.NameOfYourConfig जोड़ना signingConfig signingConfigs.NameOfYourConfig builtTypes{release{}} अंदर builtTypes{release{}}

इमेजिस:

दो महत्वपूर्ण (!) नोट्स:

(12/15 संपादित करें)

  1. हस्ताक्षरित एपीके बनाने के लिए, आपको एंड्रॉइड स्टूडियो (मुख्य इंटरफ़ेस के नीचे) का टर्मिनल टैब खोलना होगा और एक कमांड जारी करना होगा ./gradlew assembleRelease

  2. यदि आप keyAlias (अक्सर मेरे साथ क्या होता है) भूल keyAlias , तो आपको प्रक्रिया शुरू करने के लिए Build -> Generate Signed APK गए keyAlias Build -> Generate Signed APK करना होगा और उपनाम कुंजी का नाम देखेंगे।


यह user672009 उत्तर है और sdqali के पोस्ट के अलावा (उसका कोड आईडीई के "रन" बटन द्वारा डीबग संस्करण बनाने पर दुर्घटनाग्रस्त हो जाएगा):

आप निम्न कोड का उपयोग कर सकते हैं:

final Console console = System.console();
if (console != null) {

    // Building from console 
    signingConfigs {
        release {
            storeFile file(console.readLine("Enter keystore path: "))
            storePassword console.readLine("Enter keystore password: ")
            keyAlias console.readLine("Enter alias key: ")
            keyPassword console.readLine("Enter key password: ")
        }
    }

} else {

    // Building from IDE's "Run" button
    signingConfigs {
        release {

        }
    }

}

You can request passwords from the command line:

...

signingConfigs {
  if (gradle.startParameter.taskNames.any {it.contains('Release') }) {
    release {
      storeFile file("your.keystore")
      storePassword new String(System.console().readPassword("\n\$ Enter keystore password: "))
      keyAlias "key-alias"
      keyPassword new String(System.console().readPassword("\n\$ Enter keys password: "))
    } 
  } else {
    //Here be dragons: unreachable else-branch forces Gradle to create
    //install...Release tasks.
    release {
      keyAlias 'dummy'
      keyPassword 'dummy'
      storeFile file('dummy')
      storePassword 'dummy'
    } 
  }
}

...

buildTypes {
  release {

    ...

    signingConfig signingConfigs.release
  }

  ...
}

...

The if-then-else block prevents requests for passwords when you're building a release. Although the else branch is unreachable, it tricks Gradle into creating an install...Release task.

Backstory . As noted by https://.com/a/19130098/3664487 , " Gradle scripts can prompt for user input using the System.console().readLine method ." Unfortunately, Gradle will always request a password, even when you're building a debug release (cf. How to create a release signed apk file using Gradle? ). Fortunately, this can be overcome, as I have shown above.


यदि आप मेरे जैसे कमांड लाइन के माध्यम से एपीके बनाते हैं तो आप तर्क कॉन्फ़िगरेशन को तर्क के रूप में प्रदान कर सकते हैं।

इसे अपने build.gradle जोड़ें

def getStore = { ->
    def result = project.hasProperty('storeFile') ? storeFile : "null"
    return result
}

def getStorePassword = { ->
    def result = project.hasProperty('storePassword') ? storePassword : ""
    return result
}

def getKeyAlias = { ->
    def result = project.hasProperty('keyAlias') ? keyAlias : ""
    return result
}

def getKeyPassword = { ->
    def result = project.hasProperty('keyPassword') ? keyPassword : ""
    return result
}

इस तरह अपने signingConfigs करें

signingConfigs {
    release {
        storeFile file(getStore())
        storePassword getStorePassword()
        keyAlias getKeyAlias()
        keyPassword getKeyPassword()
    }
}

फिर आप इस तरह gradlew निष्पादित gradlew हैं

./gradlew assembleRelease -PstoreFile="keystore.jks" -PstorePassword="password" -PkeyAlias="alias" -PkeyPassword="password"

फिर भी एक ही समस्या के लिए एक और दृष्टिकोण। चूंकि स्रोत कोड के भीतर किसी भी तरह के क्रेडेंशियल को स्टोर करने की अनुशंसा नहीं की जाती है, इसलिए हमने कुंजी स्टोर और कुंजी उपनाम के लिए पासवर्ड अलग-अलग गुण फ़ाइल में सेट करने का निर्णय लिया है:

key.store.password=[STORE PASSWORD]
key.alias.password=[KEY PASSWORD]

यदि आप गिट का उपयोग करते हैं, तो आप एक टेक्स्ट फ़ाइल बना सकते हैं, उदाहरण के लिए, safe.properties। आपको इसे अपने भंडार से बाहर करना सुनिश्चित करना चाहिए (यदि गिट का उपयोग करना है, तो इसे .gitignore फ़ाइल में जोड़ना)। फिर, आपको एक अन्य कॉन्फ़िगरेशन कॉन्फ़िगरेशन बनाना होगा, जैसे कि कुछ अन्य उत्तरों इंगित करते हैं। केवल अंतर यह है कि आप क्रेडेंशियल कैसे लोड करेंगे:

android {
    ...
    signingConfigs {
        ...
        release {
            storeFile file('[PATH TO]/your_keystore_file.jks')
            keyAlias "your_key_alias"

            File propsFile = file("[PATH TO]/secure.properties");
            if (propsFile.exists()) {
                Properties props = new Properties();
                props.load(new FileInputStream(propsFile))
                storePassword props.getProperty('key.store.password')
                keyPassword props.getProperty('key.alias.password')
            }
        }
        ...
    }

    buildTypes {
        ...
        release {
            signingConfig signingConfigs.release
            runProguard true
            proguardFile file('proguard-rules.txt')
        }
        ...
    }
}

Never forget to assign the signingConfig to the release build type manually (for some reason I sometimes assume it will be used automatically). Also, it is not mandatory to enable proguard, but it is recommendable.

We like this approach better than using environment variables or requesting user input because it can be done from the IDE, by switching to the realease build type and running the app, rather than having to use the command line.


An alternative is to define a task that runs only on release builds.

android {
  ...
  signingConfigs {
     release {
        // We can leave these in environment variables
        storeFile file('nameOfKeystore.keystore')
        keyAlias 'nameOfKeyAlias'

        // These two lines make gradle believe that the signingConfigs
        // section is complete. Without them, tasks like installRelease
        // will not be available!
        storePassword "notYourRealPassword"
        keyPassword "notYourRealPassword"

     }
  }
  buildTypes {
     ...
     release {
        signingConfig signingConfigs.release
        ...
     }
  }
  ...
}

task setupKeystore << {
final Console console = System.console();
if (console != null) {
    //def keyFile = console.readLine(“\nProject: “ + project.name + “Enter keystore path: "))
    //def keyAlias = console.readLine(“Project: “ + project.name + “Enter key alias: ")
        def storePw = new String(console.readPassword(“Project: “ + project.name + “. Enter keystore password: "))
        def keyPw  = new String(console.readPassword(“Project: “ + project.name + “.Enter keystore password: "))

    //android.signingConfigs.release.storeFile = file(keyFile);
    //android.signingConfigs.release.keyAlias = keyAlias
        android.signingConfigs.release.storePassword = storePw
        android.signingConfigs.release.keyPassword = keyPw
}
}

//Validate t
def isReleaseConfig = gradle.startParameter.taskNames.any {it.contains('Release') }
if (isReleaseConfig) {
    setupKeystore.execute();
}

आप हस्ताक्षर करने में सहायता के लिए ग्रेडल के -पी कमांड लाइन विकल्प का भी उपयोग कर सकते हैं। अपने build.gradle में, गायन जोड़ें इस तरह कॉनफिग:

signingConfigs {
   release {
       storeFile file("path/to/your/keystore")
       storePassword RELEASE_STORE_PASSWORD
       keyAlias "your.key.alias"
       keyPassword RELEASE_KEY_PASSWORD
   }
}

फिर इस तरह के निर्माण का निर्माण करें:

gradle -PRELEASE_KEYSTORE_PASSWORD=******* -PRELEASE_KEY_PASSWORD=****** build

यदि आप चाहें तो स्टोरफाइल और कीअलीस सेट करने के लिए आप -P का उपयोग कर सकते हैं।

यह मूल रूप से Destil का समाधान है लेकिन कमांड लाइन विकल्प के साथ।

ग्रेडल गुणों के बारे में अधिक जानकारी के लिए, ग्रेडल उपयोगकर्ता मार्गदर्शिका की जांच करें


i am work in Ubuntu14.04. vim ~/.bashrc and add export ANDROID_KEYSTORE= export ANDROID_KEYALIAS=

and then in build.gradle set.

    final Console console = System.console();
if (console != null) {

    // Building from console
    signingConfigs {
        release {
            storeFile file(System.getenv("KEYSTORE"))
            storePassword new String(System.console().readPassword("\n\$ Enter keystore password: "))
            keyAlias System.getenv("KEY_ALIAS")
            keyPassword new String(System.console().readPassword("\n\$ Enter key password: "))
        }
    }

} else {

    // Building from IDE's "Run" button
    signingConfigs {
        release {

        }
    }

}

मेरे पास कई मुद्दे थे जो मैंने निम्नलिखित पंक्ति को गलत जगह पर रखा था:

signingConfigs {
    release {
        // We can leave these in environment variables
        storeFile file("d:\\Fejlesztés\\******.keystore")
        keyAlias "mykey"

        // These two lines make gradle believe that the signingConfigs
        // section is complete. Without them, tasks like installRelease
        // will not be available!
        storePassword "*****"
        keyPassword "******"
    }
}

सुनिश्चित करें कि आपने एंड्रॉइड अनुभाग के अंदर हस्ताक्षर कॉन्फ़िगर भागों को रखा है:

android
{
    ....
    signingConfigs {
        release {
          ...
        }
    }
}

के बजाय

android
{
    ....
}

signingConfigs {
   release {
        ...
   }
}

यह गलती करना आसान है।


मुझे लगता है कि सबसे सरल समाधान होगा:

mProgressBar.setScaleY(3f);




android gradle apk release android-gradle