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


514

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

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

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

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

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

इसे हल करने के बारे में कोई सुझाव?



प्रवेश फ़ाइल से v1 (जार हस्ताक्षर) या v2 (पूर्ण एपीके हस्ताक्षर) संस्करण के साथ साइन इन करें? यहाँ समाधान: stackoverflow.com/questions/57943259/…
user1506104

जवाबों:


429

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

इसमे डाल दो ~/.gradle/gradle.properties

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

अपने को संशोधित करें app/build.gradle, और इसे android {कोड ब्लॉक के अंदर जोड़ें :

...    
signingConfigs {

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

       // Optional, specify signing versions used
       v1SigningEnabled true
       v2SigningEnabled true
   }
}

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

तब तुम दौड़ सकते हो gradle assembleRelease


signingConfigsग्रैडल डीएसएल के लिए संदर्भ भी देखें


12
सबसे अच्छा तरीका अगर आप मुझसे पूछें। मेरे प्रोजेक्ट फ़ोल्डर / SVN में कुछ भी नहीं बचा है और मैं कुंजियों के बारे में चिंता किए बिना अपनी परियोजनाओं के 10 संस्करणों की जांच कर सकता हूं।
फ्रैंक

8
यदि आप Windows पर gradlew का उपयोग कर रहे हैं, तो आपको यह सुनिश्चित करने की आवश्यकता है कि GRADLE_USER_HOME को इस कार्य को करने के लिए पर्यावरण चर के रूप में परिभाषित किया गया है। मैंने इसे अपने प्रोजेक्ट डायरेक्टरी के ऊपर एक डायरेक्टरी में सेट किया, और अपना कीस्टॉर वहाँ रखा। Gradle.properties में आपके कीस्टोर का रास्ता आगे के स्लैश (/) या डबल बैकस्लैश (\\) का उपयोग करना चाहिए, न कि विंडोज सिंगल बैकस्लैश का। विंडोज कमांड प्रॉम्प्ट से कीस्टोर बनाने के लिए, stackoverflow.com/questions/3997748/how-can-i-create-a-keystore
Anachronist

3
क्या पथ जहाँ build.gradle फ़ाइल स्थित है, या मशीनों रूट निर्देशिका के सापेक्ष है?
प्रेम

1
@Prem, file()हमेशा सापेक्ष पथ मानता है। उपयोग करें new File(path)यदि आप चाहते हैं कि इसे पूर्ण माना जाए।
ars-longa-vita-brevis

4
यह मेरे और सबसे सरल के लिए काम किया। Gradle.properties में अपने मॉड्यूल build के सापेक्ष storeFile को निर्दिष्ट करें। जैसे RELEASE_STORE_FILE = .. / mykeystore। अन्य उद्धरणों को
जोड़िए मत कहो

263

मैंने इस कोड को जोड़ने और इसे बनाने के लिए इसे हल करने में कामयाबी हासिल की gradle build:

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

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


33
क्या यह पासवर्ड के लिए मुझे संकेत करने का एक तरीका है? या मेरे git repos से पासवर्ड रखने के लिए अन्य सुझाव?
user672009

3
मैं आपकी तरह दिखने के लिए अपने बिल्ड.ग्रेड को संपादित करता हूं, लेकिन "निर्मित> निर्मित साइन इन एपीके" चला रहा हूं। फिर भी वह मेरा डायलॉग देता है ("अधिक जानकारी के लिए ग्रैगल यूजर गाइड देखें।" आदि) और कोई एपीके नहीं।
Semanticer

3
@ शेमिशर एक्सक्यूट gradle buildया gradlew buildटर्मिनल / प्रॉम्प्ट कमांड में
फिलिप कामिकेज़

12
@ user672009 आप एक प्रॉपर्टी फाइल में पासवर्ड डाल सकते हैं और इसे .ignignore के साथ रिपोज से बाहर कर सकते हैं। आप इस लिंक को देख सकते हैं। gist.github.com/gabrielemariotti/6856974
गैब्रिएल

1
@GabrieleMariotti जो अभी भी एक अपूर्ण भंडार छोड़ता है। एक बेहतर तरीका यह होगा कि आप एक कंकाल साइन इन करें। अनुबंधों को जारी करने के बाद और "जीआईटी अपडेट-इंडेक्स -आसूम-अपरिवर्तित हस्ताक्षर.प्रदाय" जारी करने के बाद। हालांकि यह फ्यूचर एडिट को कमिट करने से रोकता है। पहले विकल्प की तरह कुछ sdqali भी बेहतर लगता है।
user672009

67

ध्यान दें कि @ sdqali की स्क्रिप्ट (कम से कम ग्रैडल 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"
    }
}

ध्यान दें कि मुझे इसे काम करने के लिए निम्नलिखित (android के तहत) जोड़ना था:

buildTypes {
    release {
        signingConfig signingConfigs.release
    }
}

इसे लागू करने के बाद, installReleaseकार्यों की सूची से गायब हो गया ... क्यों?
कारेल

1
@ कास्पासे काश मैंने आपकी टिप्पणी उस नकली "स्टोरपासवर्ड" और "कीपासवर्ड" के बारे में और गंभीरता से ली थी। इन गुणों को शुरू किए बिना (उदाहरण के लिए ") हस्ताक्षर किए गए * -release.apk नहीं बनाया गया है, कोई त्रुटि प्रदर्शित नहीं होती है और आपके PROJECT_NAME में केवल * -release-unsigned.apk के साथ पूरी तरह से हैरान रह जाते हैं / निर्माण / APK / निर्देशिका । आदमी ...: /
vizZ

BuildTypes -> रिलीज़ के तहत साइनिंग कॉनफिग जोड़ने के बारे में नोट के लिए धन्यवाद। यह मेरे लिए स्वचालित हस्ताक्षर को हल कर दिया!
mm2001

1
मैंने एक सरल प्रवण प्लगइन बनाया जो रिलीज़ एपीके का निर्माण करते समय पासवर्ड मांगता है (इस पोस्ट में वर्णित मैथोड का उपयोग करके, लेकिन आपको नकली स्टोरपासवर्ड और कीपासवर्ड को परिभाषित करने की आवश्यकता नहीं होगी)। यह मावेन सेंट्रल में भी उपलब्ध है। github.com/alexvasilkov/AndroidGradleSignPlugin
एलेक्स वासिलकोव

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

63

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

मूल रूप से:

1) एक myproject.properties फ़ाइल बनाएँ / home / Isusernameiding / .signing पर ऐसी सामग्री:

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']
        }
    }
}

1
बहुत अच्छा काम करता है! धन्यवाद। इस कोड को buildTypes {} अनुभाग से पहले जोड़ा जाना चाहिए और अनुभाग को साइनिंग कॉनफिग पर हस्ताक्षर करना चाहिए।
theceshopsensation

अंत में मुझे इस समस्या का हल मिल गया। केवल एक चीज जिसने वास्तव में मेरी मदद की! यह उत्तर स्वीकार किया जाना चाहिए ...
devnull69

39

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

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


विवरण:

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

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

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

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

मुसीबत

हम स्पष्ट रूप से हमारे हस्ताक्षर या पासवर्ड फ़ाइलों को जीआईटी नियंत्रित निर्देशिका में कहीं भी नहीं रखना चाहते हैं, भले ही हम बहुत अधिक उपयोग करने में सक्षम हों .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करें कि यह सामग्री है:

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 में किया जा सकता है।


UPDATE: 2019-04-02

के और हाल के संस्करण keytoolऔर कुछ आपको बता रहे हैं कि आपको मूल रूप से / डिफ़ॉल्ट के बजाय PKCS12 आधारित कीफाइल का उपयोग करना चाहिए जैसा कि मैं ऊपर उपयोग करता हूं। वे तब आपको बताएंगे कि आपको नए खुले PKCS12 प्रारूप में परिवर्तित होना चाहिए। हालाँकि, ऐसा लगता है कि एंड्रॉइड डेवलपमेंट टूल अभी तक इसके लिए तैयार नहीं हैं, क्योंकि यदि आप ऐसा करते हैं, तो आपको निम्नलिखित अजीब त्रुटियां मिलेंगी:

com.android.ide.common.signing.KeytoolException:कुंजी XXX को स्टोर "F: \ XXX \ XXX.jks" से पढ़ने में विफल रहा: कुंजी प्राप्त करना विफल रहा: अंतिम ब्लॉक को ठीक से गद्देदार नहीं दिया गया। यदि डिक्रिप्शन के दौरान खराब कुंजी का उपयोग किया जाता है तो ऐसे मुद्दे उत्पन्न हो सकते हैं।

तो एक परिवर्तित कुंजी का उपयोग न करें!


क्या SignConfigs को एपीके के अंदर सहेजा गया है और फिर पासवर्ड प्राप्त करने के लिए इसे किसी भी उपयोगकर्ता द्वारा विघटित किया जा सकता है या यह एपीके में दिखाई नहीं देगा?
JavierSegoviaCordoba

2
आकर्षण की तरह काम करता है। धन्यवाद-आपको यह स्वीकृत उत्तर होना चाहिए
pratham kesarkar

क्या होगा यदि आप केवल बिल्ड सर्वर पर कीस्टोर और पासवर्ड चाहते हैं? टीम में हर डेवलपर के ऊपर समाधान के साथ अपने स्थानीय मशीन पर कीस्टोर रखने की आवश्यकता होती है। अन्यथा ग्रैडल प्रोजेक्ट सिंक विफल हो जाएगा: keystore.properties (ऐसी कोई फ़ाइल या निर्देशिका नहीं)।
डायना फारिन

1
आप keystore.propertiesस्रोत नियंत्रण के लिए एक डमी फ़ाइल कर सकते हैं , इसलिए देव मशीनों पर काम का निर्माण करता है। मैंने यहां एक बिल्ड सर्वर सेटअप का वर्णन किया है
dskrvk

1
के बारे में अपनी अंतिम अद्यतन पर एक नोट keytoolएक PKCS12 कीस्टोर पैदा: आप पास कर सकते हैं -storetype JKSमें keytoolJKS जो एंड्रॉयड टूलींग के लिए आवश्यक है करने के लिए कीस्ट्रोक प्रकार सेट करने के आदेश।
ट्रेवर हैल्वर्सन

35

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

इसमे डाल दो ~/.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


खिड़कियों में पथ कैसे सेट करें: अपने
किस्टोर के

storeFile फ़ाइल ("C: \\ Users \\ xxxx \\ दस्तावेज़ \\ yyyy \\ mykey.jks") क्या यह सही है?
reza_khalafi

28

( ऊपर user672009 के जवाब में ।)

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

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

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

 apply from: 'signing.gradle'

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

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

  ...

  productFlavors {

      flavor1 {
          ...
          signingConfig signingConfigs.flavor1
      }

      flavor2 {
          ...
          signingConfig signingConfigs.flavor2
      }
  }

  ...

क्या आप थोड़ा और स्पष्ट कर सकते हैं। मैं इसे नहीं चला सकता: "प्रतीक साइनकॉन्ग को हल नहीं कर सकता"।
Amio.io

अगर मैं build.gradle में grad साइनिंग.गर्ल ’को शामिल करता हूं - मुझे गिट रिपॉजिटरी में एक होने के लिए मजबूर किया जाता है (अन्यथा मुझे त्रुटि मिलती है 'साइनिंग ।ग्रेड का कोई अस्तित्व नहीं है)। और अगर मैं 'साइनिंग .ग्रेड' को जीआईटी में डालता हूं, तो यह उद्देश्य को हरा देता है। मैं साइन इन करने का विकल्प कैसे बना सकता हूं। वैकल्पिक वैकल्पिक?
जगुआर

21

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

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

आपके Android प्रोजेक्ट के लिए कोई स्थायी परिवर्तन आवश्यक नहीं है।

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


18

यह user672009 और sdqali की पोस्ट के अलावा एक उत्तर है (उसका कोड 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 {

        }
    }

}

क्या कुछ डिफ़ॉल्ट मान रखने का एक तरीका है? मेरा कीस्टोर आमतौर पर एक ही है। StorePassword आमतौर पर KeyPassword और KeyAlias ​​के समान ही होता है, आमतौर पर प्रोजेक्ट का नाम लोअर केस में होता है।
1967 पर user672009

@ user672009 आप स्क्रिप्ट के अंदर हमेशा जावा कोड का उपयोग कर सकते हैं।
एसीपीएच

1
आप कुछ इस तरह का उपयोग करना चाह सकते हैं: keyPassword new String(console.readPassword("Enter key password: "))यह सुनिश्चित करने के लिए कि इनपुट के दौरान आपका पासवर्ड प्रदर्शित नहीं हुआ है
एलेक्स सेमेनीयुक

यह अब काम नहीं करता है, github.com/gradle/gradle/issues/1251
SqAR.org

16

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

  1. File -> Project Structure

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

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

  4. दाईं ओर डेटा भरें

  5. ओके और ग्रैडल फाइल अपने आप बन जाती है

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

इमेजिस:

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

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

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

(EDIT 12/15)

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

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


2
यह build.gradleफ़ाइल में आपके पासवर्ड को हार्डकोड करता है, हालांकि, यह नहीं है?
जोशुआ पिंटर

16

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

इसे अपने में जोड़ें 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 assembleRelease -PstoreFile="keystore.jks" -PstorePassword="password" -PkeyAlias="alias" -PkeyPassword="password"

कौन सा है build.gradle? ऊपरी स्तर? कृपया अधिक कोड जोड़ें
व्लाद

स्पष्ट करने के लिए, यह वह app/build.gradleफ़ाइल है जिसके बारे में मैं बात कर रहा हूँ।
ईजीस

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

Android Studio 0.5.1, Gradle 1.11 और Gradle plugin 0.9 का उपयोग करना।
जेपी वेंचुरा

1
डिमांड (उर्फ डायनेमिक प्रॉपर्टीज) पर प्रॉपर्टीज का निर्माण किया गया है और ग्रैडल 2.0 में हटा दिया जाना तय है
जेपी वेंचुरा

10

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

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 का उपयोग कर सकते हैं।

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

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


7

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

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

apply plugin: 'com.android.application'

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

अंत में, यहां अधिकांश समाधान डिबग मोड में प्रोजेक्ट के निर्माण की अनुमति नहीं देते हैं - जो डिबग-साइनिंग को स्वचालित रूप से संभालता है - यदि कोई शब्दबद्ध रूप से वैध नहीं है तो एक सिंटैक्टिक रूप से प्रदान किए बिना।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में signing.gradleऔर वैध पहचान के साथ डमी मूल्यों की जगह।

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

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


6

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

मैं एक सरल समाधान का प्रस्ताव करता हूं जो पायथन कीरिंग मॉड्यूल (मुख्य रूप से साथी कंसोल स्क्रिप्ट keyring) और ग्रूव ['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आपको केवल एक बार अपने कीरिंग में पासवर्ड सेट करना होगा:

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

हैप्पी रिलीज!


5

डेविड वावरा द्वारा उत्तर का विस्तार करते हुए, एक फ़ाइल बनाएं ~ / .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
      }
    }
  }

5

मुझे यह देखकर बहुत मज़ा आया। यहाँ मेरा चलना-फिरना है।

IntelliJ (v.13.1.4) में एक ग्रेड बिल्ड फ़ाइल बनाने के तरीके के बारे में A से Z वॉक-थ्रू यह वॉक-थ्रू मान लेता है कि आप जानते हैं कि कीस्टॉर फाइल कैसे बनाते हैं। इस ट्यूटोरियल को काम करने के लिए आपको अपने ऐप फ़ोल्डर में स्थित होने के लिए आपकी कीस्टोर फाइल की आवश्यकता होगी और आपको 'SDK-ROOT \ Tools' में स्थित होने के लिए आपकी zipalign.exe फ़ाइल की आवश्यकता होगी। यह फ़ाइल आमतौर पर '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 {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:support-v4:20.0.0'
    implementation 'com.android.support:appcompat-v7:20.0.0'
}

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

R बिल्ड टाइप्स ’के तहत नाम फ़ील्ड में emble असेंबलरेज़’ मान दर्ज करें, Build डीबगेबल ’को गलत पर सेट किया जाना चाहिए, false जेनी डिबग बिल्ड’ को गलत होना चाहिए, Pro रन प्रोगार्ड ’को सही और Al जिप एलाइन’ को सही पर सेट करना चाहिए। यह बिल्ड फ़ाइल उत्पन्न करेगा, लेकिन जैसा कि ऊपर दर्शाया गया है, आपको बाद में बिल्ड फ़ाइल में कुछ चीजें जोड़नी होंगी। यहाँ ProGuard फ़ाइल स्थान को ग्रेड बिल्ड फ़ाइल में मैन्युअल रूप से सेट किया जाएगा। (जैसा कि ऊपर दर्शाया गया है)

आपके द्वारा बाद में जोड़े जाने वाले DSL कंटेनर इस प्रकार हैं:

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

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

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

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

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

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

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

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

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

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

इस समस्या को ठीक करने के लिए अपने प्रोजेक्ट में वह फ़ाइल खोलें जिसे 'lint-results-assembleRelease-fatal.html' फ़ाइल में सूचीबद्ध किया गया था और कक्षा के नाम के ठीक ऊपर Java क्लास फ़ाइल में कोड की निम्न पंक्ति दर्ज करें: @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' नाम दिया गया है और इसे ग्रेड होम निर्देशिका का मार्ग निर्धारित किया जाना चाहिए, जैसे 'C: \ gradle-1.12' कभी-कभी आप 'ANDROID_HOME' के लिए पर्यावरण चर भी सेट कर सकते हैं, इसे 'अपना-' एसडीके-रूट \ एसडीके '

इसके बाद ग्रैडल कार्य विंडो पर वापस लौटाया जाता है और assembleAssembleRelease पर डबल क्लिक करें।

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


प्रयास के लिए +1 और: 'lintOptions {abortOnError false}'
Raz Tourgman

4

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

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

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

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

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


1
ग्रैडल इसका उपयोग करने के लिए संकलित नहीं करता है: सहारा = नए गुण (); केवल-प्रॉपर्टी 'प्रॉप्स' के मूल्य को सेट नहीं कर सकते हैं
सेसर्ड

आप सही हैं @ m3n0R मैंने अपनी प्रतिक्रिया की एक पंक्ति संपादित की जिसे हमने अपने ऐप में पेश करने के लिए तय किया था ताकि यह अभी भी ग्रेडल के नवीनतम संस्करणों का उपयोग करके संकलित हो। मूल रूप से, प्रॉप्स को एक स्थानीय चर के रूप में घोषित किया जाना है।
argenkiwi

क्लाउड CI / CD टूल .... / पथ / से / keystore और /path/to/secure.props का उपयोग करके इसे कैसे अपनाया जा सकेगा, यह मुझे फेंक रहा है .... हालांकि इसके लिए धन्यवाद।
सरवॉन

4

Android Studio फ़ाइल में जाएं -> प्रोजेक्ट स्ट्रक्चर या Ctrl + Alt + Shift + S दबाएं

छवि देखें

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

ओके पर क्लिक करें

फिर आपके बिल्ड.ग्रेडल फ़ाइल पर साइनिंग कॉनफिग्स जेनरेट करेगा।

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


और यह वही है जो आप नहीं करना चाहते हैं। इस तरह से आपके सभी पासवर्ड स्पष्ट-पाठ और आपकी परियोजना के हिस्से में हैं , और गलती से आपके वितरित बिल्ड में भी शामिल करना बहुत आसान है।
Not2qubit

2

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

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

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


2

यह 2019 है और मुझे V1 (जार सिग्नेचर) या V2 (फुल एपीके सिग्नेचर) के साथ एपीके साइन करना होगा। मैंने "साइन इन एपीके ग्रेड" उत्पन्न किया और यह मुझे यहां लाया। इसलिए मैं यहां अपना मूल समाधान जोड़ रहा हूं।

signingConfigs {
    release {
        ...
        v1SigningEnabled true
        v2SigningEnabled true
    }
}

मेरा मूल प्रश्न: build.gradle फ़ाइल से V1 (जार हस्ताक्षर) या V2 (पूर्ण एपीके हस्ताक्षर) का उपयोग कैसे करें


अर्ध-कॉलनों की आवश्यकता नहीं; यह आपको एक त्रुटि देगा।
ताकेशी कागा

यह सही है। धन्यवाद। मैंने उत्तर संपादित किया।
user1506104

1

अन्य उत्तरों को पूरक करने के लिए, आप अपनी gradle.properties फ़ाइल को अपने स्वयं के मॉड्यूल फ़ोल्डर में, build.gradle के साथ रख सकते हैं, यदि आपका कीस्टोर एक परियोजना के लिए विशिष्ट है।


1

मैं Ubuntu14.04 में काम कर रहा हूँ। vim ~ /।

और फिर build.gradle सेट में।

    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 {

        }
    }

}

IMHO जो सबसे अच्छा समाधान लगता है, लेकिन दुर्भाग्य से इसने ग्रेडल के नए संस्करणों पर काम करना बंद कर दिया : System.console()रिटर्न null
एंटोनियो विनीसियस मेनेजी

1

एक विकल्प एक कार्य को परिभाषित करना है जो केवल रिलीज बिल्ड पर चलता है।

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

निम्नलिखित मेरे लिए बेहतर लगता है: stackoverflow.com/a/19130098/3664487 दो दृष्टिकोणों की तुलना कैसे करते हैं?
1927 पर user2768

1

आप कमांड लाइन से पासवर्ड का अनुरोध कर सकते हैं:

...

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
  }

  ...
}

...

if-then-elseब्लॉक पासवर्ड के अनुरोध को रोकता है जब आप एक रिलीज बना रहे हैं। यद्यपि यह elseशाखा उपलब्ध नहीं है, लेकिन यह ग्रैडल को एक install...Releaseकार्य बनाने के लिए प्रेरित करती है ।

बैकस्टोरी । जैसा कि https://stackoverflow.com/a/19130098/3664487 द्वारा उल्लेख किया गया है , " ग्रैडल स्क्रिप्ट सिस्टम इनपुट का उपयोग करके उपयोगकर्ता इनपुट के लिए संकेत दे सकता है। (पढ़ेंविधि पढ़ें ।" दुर्भाग्य से, ग्रेड हमेशा डिबग रिलीज़ का निर्माण करते हुए भी एक पासवर्ड का अनुरोध करेगा (cf. ग्रैडल का उपयोग करके एक रिलीज़ हस्ताक्षरित एपीके फ़ाइल कैसे बनाएं? )। सौभाग्य से, इसे दूर किया जा सकता है, जैसा कि मैंने ऊपर दिखाया है।


मेरे पहले के जवाब stackoverflow.com/questions/33897802/… के कारण समस्याओं में भाग गया । मैंने इस समस्या को खत्म करने के लिए अपने जवाब को संशोधित किया है।
user2768

@ हेरॉन, इसने 24 नवंबर 15 तक काम किया। समुदाय शायद आपकी समस्या के साथ मदद कर सकता है, लेकिन आपको अधिक विवरण प्रदान करने की आवश्यकता होगी।
user2768

मुझे यह समाधान पसंद है क्योंकि यह एक पाठ फ़ाइल में स्पष्ट पाठ में पासवर्ड डालने से बचता है लेकिन System.console ()। इस कष्टप्रद मुद्दे के कारण readLine ग्रेड में काम नहीं करता है ।
मॉर्फियस

@ मैंफोरियस, मुझे कभी कोई समस्या नहीं हुई। ऊपर मेरे लिए काम कर रहा है।
13:27 पर user2768

मुझे लगता है कि आप एक आईडीई के भीतर से स्क्रिप्ट चलाते हैं। यदि स्क्रिप्ट को टर्मिनल से चलाया जाता है तो आपको त्रुटि दिखाई देगी। लेकिन इस उत्तर के लिए धन्यवाद। यह वही है जिसे मैं देख रहा था।
मॉर्फियस

0

प्रतिक्रिया-मूल -विन्यास पैकेज का उपयोग करके इसे रिएक्ट-नेटिव में करने का मेरा तरीका जोड़ना ।
.Env फ़ाइल बनाएँ:

RELEASE_STORE_PASSWORD=[YOUR_PASSWORD]
RELEASE_KEY_PASSWORD=[YOUR_PASSWORD]

ध्यान दें कि यह संस्करण नियंत्रण का हिस्सा नहीं होना चाहिए।

अपने में build.gradle:

signingConfigs {
        debug {
            ...
        }
        release {
            storeFile file(RELEASE_STORE_FILE)
            storePassword project.env.get('RELEASE_STORE_PASSWORD')
            keyAlias RELEASE_KEY_ALIAS
            keyPassword project.env.get('RELEASE_KEY_PASSWORD')
        }
    }

0

मेरे मामले में, मैं गलत एपीके अपलोड कर रहा था, दूसरे ऐप के रिलीज़ के लिए।


0

ग्रूवी के लिए (build.gradle)

आपको अपनी साइनिंग क्रेडेंशियल सीधे बिल्ड.ग्रेड फ़ाइल में नहीं डालनी चाहिए । इसके बजाय क्रेडेंशियल्स को संस्करण नियंत्रण के तहत नहीं फ़ाइल से आना चाहिए।

एक फ़ाइल रखो signing.properties जहां मॉड्यूल विशिष्ट build.gradle पाया जाता है। इसे अपनी .gitignore फ़ाइल में जोड़ना न भूलें !

signing.properties

storeFilePath=/home/willi/example.keystore
storePassword=secret
keyPassword=secret
keyAlias=myReleaseSigningKey

build.gradle

android {
    // ...
    signingConfigs{
        release {
            def props = new Properties()

            def fileInputStream = new FileInputStream(file('../signing.properties'))
            props.load(fileInputStream)
            fileInputStream.close()

            storeFile = file(props['storeFilePath'])
            storePassword = props['storePassword']
            keyAlias = props['keyAlias']
            keyPassword = props['keyPassword']
        }
    }

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

0

कोटलिन स्क्रिप्ट के लिए (build.gradle.kts)

आपको अपनी साइनिंग क्रेडेंशियल सीधे build.gradle.kts में नहीं डालनी चाहिए फ़ाइल । इसके बजाय क्रेडेंशियल्स को संस्करण नियंत्रण के तहत नहीं फ़ाइल से आना चाहिए।

एक फ़ाइल रखो signing.properties जहां मॉड्यूल विशिष्ट build.gradle.kts पाया जाता है। इसे अपनी .gitignore फ़ाइल में जोड़ना न भूलें !

signing.properties

storeFilePath=/home/willi/example.keystore
storePassword=secret
keyPassword=secret
keyAlias=myReleaseSigningKey

build.gradle.kts

android {
    // ...
    signingConfigs {
        create("release") {
            val properties = Properties().apply {
                load(File("signing.properties").reader())
            }
            storeFile = File(properties.getProperty("storeFilePath"))
            storePassword = properties.getProperty("storePassword")
            keyPassword = properties.getProperty("keyPassword")
            keyAlias = "release"
        }
    }

    buildTypes {
        getByName("release") {
            signingConfig = signingConfigs.getByName("release")
            // ...
        }
    }
}

-1

यदि आप null ऑब्जेक्ट पर विधि readLine () नहीं लगा सकते हैं। आपको पहले gradle.properties में लिखने की आवश्यकता है ।

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