दिलचस्प पोस्ट
मेवेन निर्भरता पर नोक्लेस डीफफाउंड एरर ब्राउज़र क्या है? प्रोटैक्टर में साइनऑन सिंक्रनाइज़ेशन? 'चुपके' वेब-क्रॉलर का पता लगा रहा है बड़ी फाइल की वजह से गीथहब को धक्का नहीं लगाया जा सकता है जो मैंने पहले से ही हटा दिया था क्या मैं जेडीबीसी कनेक्शन पूलिंग का उपयोग कर रहा हूं? एक WHERE ___ IN ___ कथन का उपयोग करना यादृच्छिक अल्फा-न्यूमेरिक स्ट्रिंग कैसे उत्पन्न करें? रूबी में यादृच्छिक संख्या कैसे प्राप्त करें आंतरिक वर्ग ऑब्जेक्ट से बाहरी कक्षा ऑब्जेक्ट को पकड़ना mysql_fetch_array () पैरामीटर 1 संसाधन समस्या होने की उम्मीद मुझे रूबी स्थानीय क्षेत्र को समझ में नहीं आता यूआईएलएबल पाठ आकार की गणना PHP / MySQL (प्रदर्शन) में भू-खोज (दूरी) क्या मैं .cpp में सभी। सीपीपी फाइलों को संकलित कर सकता हूँ / में ओ.ओ.एस. में है, तो बाइनरी में। / में लिंक है? व्यवसाय खाता से फेसबुक ऐप बनाना और प्रबंधित करना

Gradle का उपयोग कर एक रिलीज एपीके फाइल बनाने के लिए कैसे?

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

मुझे यकीन नहीं है कि कोड सही है या यदि मुझे एक पैरामीटर याद आ रही है, जो कि gradle build ?

यह मेरे gradle फ़ाइल में से कुछ कोड है:

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

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

यह कैसे हल करने पर कोई सुझाव?

वेब के समाधान से एकत्रित समाधान "Gradle का उपयोग कर एक रिलीज एपीके फाइल बनाने के लिए कैसे?"

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

इसे ~/.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 कर सकते हैं

मैं इसे इस कोड को जोड़ने का समाधान करने में कामयाब रहा, और बिल्डिंग के निर्माण के साथ:

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

यह एक हस्ताक्षरित रिलीज एपीके फ़ाइल उत्पन्न करता है

ध्यान दें कि @ एसडीकाली की स्क्रिप्ट (कम से कम ग्रेडअल 1.6 का उपयोग करते समय) पासवर्ड के लिए कभी भी पूछेगी जब आप किसी भी प्रकार की ढलाई का काम शुरू करेंगे। चूंकि आप केवल gradle assembleRelease करते समय इसकी आवश्यकता होती है (या समान), आप निम्न चाल का उपयोग कर सकते हैं:

 android { ... signingConfigs { release { // We can leave these in environment variables storeFile file(System.getenv("KEYSTORE")) keyAlias System.getenv("KEY_ALIAS") // 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" } } ... } task askForPasswords << { // Must create String because System.readPassword() returns char[] // (and assigning that below fails silently) def storePw = new String(System.console().readPassword("Keystore password: ")) def keyPw = new String(System.console().readPassword("Key password: ")) android.signingConfigs.release.storePassword = storePw android.signingConfigs.release.keyPassword = keyPw } tasks.whenTaskAdded { theTask -> if (theTask.name.equals("packageRelease")) { theTask.dependsOn "askForPasswords" } } 

ध्यान दें कि मुझे इसे काम करने के लिए निम्नलिखित (एंड्रॉइड के अंतर्गत) जोड़ना पड़ा:

 buildTypes { release { signingConfig signingConfigs.release } } 

यदि आप 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) इसे अपने build.gradle में इस तरह देखें:

  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/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 कर सकते हैं

(उपरोक्त उपयोगकर्ता 672009 के उत्तर में।)

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

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

फिर अपने build.gradle फ़ाइल में "प्लगइन लागू करें" के नीचे सही इस लाइन को शामिल करें: 'android' "

  apply from: 'signing.gradle' 

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

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

  ... productFlavors { flavor1 { ... signingConfig signingConfigs.flavor1 } flavor2 { ... signingConfig signingConfigs.flavor2 } } ... 

यह उपयोगकर्ता 672009 का उत्तर है और एसडीकाली के पद के अतिरिक्त है (उसका कोड IDE के "रन" बटन द्वारा डिबग संस्करण के निर्माण पर क्रैश करेगा):

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

 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 { } } } 

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

  1. File -> Project Structure

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

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

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

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

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

इमेजिस:

यहां छवि विवरण दर्ज करें

यहां छवि विवरण दर्ज करें

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

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

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

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

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

इसे अपने 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 करें

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

उसके बाद आप इस तरह के gradlew अंजाम gradlew हैं

 ./gradlew assembleRelease -PstoreFile="keystore.jks" -PstorePassword="password" -PkeyAlias="alias" -PkeyPassword="password" 
 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 } } } 

गिट का प्रयोग करते समय स्वचालित ऐप साइन इन करें

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


विवरण:

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

प्रारंभिक मान्यताओं:

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

यहां छवि विवरण दर्ज करें

मुसीबत

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

उपाय

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

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

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

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

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

 cd $HOME/projects/mydev/ 

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

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

 cd $HOME/projects/mydev/ 

keystore.properties संपादित करें। 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 {} ब्लॉक के बाहर और 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 में उपयोग किया जा सकता है।

आप हस्ताक्षर करने में सहायता के लिए gradle का पी कमांड लाइन विकल्प भी उपयोग कर सकते हैं। अपने 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 

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

यह मूलतः डिस्टिल का समाधान है, लेकिन कमांड लाइन विकल्पों के साथ।

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

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

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

 apply plugin: 'com.android.application' 

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

अंत में, यहां अधिकांश समाधान डिबग मोड में प्रोजेक्ट को बनाने की अनुमति नहीं देते हैं – जो डिबग-हस्ताक्षर स्वचालित रूप से संभालता है – बिना शब्दावली प्रदान किए बिना, signingConfigs वैध signingConfigs किए बिना परिभाषा की 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 ... } } } 

यह एक डमी संपत्ति बनाता है जो विशुद्ध रूप से एक syntactically मान्य बिल्ड फ़ाइल का उत्पादन करती है। 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 VCS द्वारा अनदेखा किया जाना चाहिए।

लगभग सभी प्लेटफॉर्म्स अब कुछ प्रकार की कीरिंग प्रस्तुत करते हैं, इसलिए स्पष्ट पाठ पासवर्ड को छोड़ने का कोई कारण नहीं है।

मैं एक सरल समाधान का प्रस्ताव करता हूं जो पायथन कीरिंग मॉड्यूल (मुख्यतः साथी कंसोल स्क्रिप्ट keyring ) का उपयोग करता है और Groovy ['do', 'something'].execute() आसपास एक न्यूनतम आवरण ['do', 'something'].execute() सुविधा :

 def execOutput= { args -> def proc = args.execute() proc.waitFor() def stdout = proc.in.text return stdout.trim() } 

इस फ़ंक्शन का उपयोग करना, signingConfigs अनुभाग बन जाता है:

 signingConfigs { release { storeFile file("android.keystore") storePassword execOutput(["keyring", "get", "google-play", storeFile.name]) keyAlias "com.example.app" keyPassword execOutput(["keyring", "get", "google-play", keyAlias]) } } 

gradle assembleRelease चलाने से पहले gradle assembleRelease आपको अपने कीरिंग में पासवर्ड सेट करना होगा, केवल एक बार:

 $ keyring set google-play android.keystore # will be prompted for the passwords $ keyring set google-play com.example.app 

खुश रिलीज!

मैं इस एक बाहर लगाना बहुत मज़ेदार था यहाँ मेरा चलना है I

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

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

 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 क्षेत्रों में अपनी प्रमुख जानकारी दर्ज करें (अपने ऐप फ़ोल्डर के नीचे कीस्टॉयर पथ को सेट करना)।

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

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

 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 मेनू से निर्भरता कंटेनर बनाने के लिए, चुनें: फ़ाइल / परियोजना संरचना। वहां से फिर से facets चुनें और फिर एंड्रॉइड-ग्रेडल (एप)। आपको ऊपर बताए गए अनुसार 5 टैब दिखाई देंगे। 'निर्भरता' टैब का चयन करें और अपनी आवश्यकता की निर्भरता जोड़ें।

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

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

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

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

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

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

इस समस्या को ठीक करने के लिए फ़ाइल को अपनी प्रोजेक्ट में खोलें जो कि 'लिंट-रिलेशनशिप -एम्म्बल रिलेज-फेटाल-एचटीएमएल' फ़ाइल में सूचीबद्ध है और क्लास नाम के ठीक ऊपर जावा क्लास फ़ाइल में निम्न पंक्ति कोड दर्ज करें: @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' नाम दिया गया है और इसे 'ग्रेडियस होम डाइरेक्टरी' का रास्ता सेट करना चाहिए, कुछ 'सी: \ ग्रेडेल-1.12' जैसा कि आप 'एंड्रॉइड_एचओएमई' के लिए पर्यावरण चर सेट भी कर सकते हैं, इसे 'आपका- एसडीके-रूट \ एसडीके '

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

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

दाऊद वावरा के जवाब में विस्तार, एक फाइल ~ / .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 } } } 

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

 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 { ... } } 

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

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

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

यदि आप git का उपयोग करते हैं, तो आप एक टेक्स्ट फाइल बना सकते हैं, उदाहरण के लिए, सुरक्षित। प्रॉपर्टीज़ आपको इसे अपनी रिपॉजिटरी से बाहर करना सुनिश्चित करना चाहिए (यदि git का उपयोग करना, इसे .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') } ... } } 

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

हम इस दृष्टिकोण को पर्यावरण चर का उपयोग करने या यूजर इनपुट का अनुरोध करने से बेहतर पसंद करते हैं क्योंकि यह कमांड लाइन का उपयोग करने के बजाय, रीएलीज़ बिल्ड प्रकार पर स्विच करके और ऐप को चलाने के द्वारा आईडीई से किया जा सकता है

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

 ./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 

No permanent changes to your Android project necessary.

Source: http://www.tinmith.net/wayne/blog/2014/08/gradle-sign-command-line.htm

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.

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 { } } } 

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(); } 

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://stackoverflow.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.

if you don't want to see Cannot invoke method readLine() on null object. you need write in gradle.properties first.

 KEYSTORE_PASS=***** ALIAS_NAME=***** ALIAS_PASS=***** 

If you, like me, just want to be able to run the release on your device for testing purposes, consider creating a second keystore for signing, so you can simply put the passwords for it into your build.gradle without worrying for your market key store security.

You can create a new keystore by clicking Build/Generate Signed APK/Create new…