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


12 Answers

मैं इसे हल करने में कामयाब रहा, और gradle build साथ gradle build :

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

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

Question

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

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

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

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

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

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




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

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

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




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

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

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

मुबारक रिलीज!




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.




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

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 पर जा सकते हैं और अपनी तैनाती एपीके फ़ाइल ढूंढ सकते हैं।




यदि आप, मेरे जैसे, परीक्षण उद्देश्यों के लिए बस अपने डिवाइस पर रिलीज चलाने में सक्षम होना चाहते हैं , तो हस्ताक्षर करने के लिए दूसरा कीस्टोर बनाने पर विचार करें , ताकि आप अपने ब्रांड की कुंजी के लिए चिंता किए बिना पासवर्ड को अपने build.gradle में डाल सकें। स्टोर सुरक्षा।

आप बिल्ड / जनरेट किए गए एपीके जेनरेट / नए बनाएं पर क्लिक करके एक नया कीस्टोर बना सकते हैं ...




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

  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 करना होगा और उपनाम कुंजी का नाम देखेंगे।




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

यह आश्चर्यजनक है कि ऐसा करने के लिए कितने ठोस तरीके हैं। यहां मेरा अपना तरीका है, जहां मैं गूगल्स की अपनी 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 में किया जा सकता है।




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.




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 में अपने कीस्टोर और पासवर्ड को हार्डकोडिंग से बचाना चाहते हैं, तो आप यहां समझाए गए गुण फ़ाइल का उपयोग कर सकते हैं: ग्रैंडल के साथ कॉन्फ़िगर करना

मूल रूप से:

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



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

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




(उपरोक्त 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
      }
  }

  ...



Related