कमांड लाइन से अपना ऐप्लिकेशन बनाना

Gradle wrapper कमांड लाइन टूल का इस्तेमाल करके, अपने Android प्रोजेक्ट के लिए उपलब्ध सभी बिल्ड टास्क पूरे किए जा सकते हैं. यह Windows (gradlew.bat) के लिए बैच फ़ाइल और Linux और Mac (gradlew.sh) के लिए शेल स्क्रिप्ट के तौर पर उपलब्ध है. साथ ही, Android Studio से बनाए गए हर प्रोजेक्ट के रूट से इसे ऐक्सेस किया जा सकता है.

रैपर की मदद से कोई टास्क चलाने के लिए, टर्मिनल विंडो में इनमें से किसी एक निर्देश का इस्तेमाल करें. इसके लिए, Android Studio में व्यू > टूल विंडो > टर्मिनल चुनें:

• Windows Command Shell पर:

  gradlew task-name

• Mac, Linux या Windows PowerShell पर:

  ./gradlew task-name

अपने प्रोजेक्ट के लिए उपलब्ध सभी बिल्ड टास्क की सूची देखने के लिए, tasksकोड डालें:

gradlew tasks

इस पेज के बाकी हिस्से में, Gradle रैपर की मदद से ऐप्लिकेशन बनाने और उसे चलाने के बारे में बुनियादी जानकारी दी गई है. Android बाइल्ड को सेट अप करने के तरीके के बारे में ज़्यादा जानने के लिए, अपना बाइल्ड कॉन्फ़िगर करना लेख पढ़ें.

अगर आपको कमांड लाइन टूल के बजाय, Android Studio टूल इस्तेमाल करने हैं, तो अपना ऐप्लिकेशन बनाएं और चलाएं लेख पढ़ें.

बिल्ड टाइप के बारे में जानकारी

डिफ़ॉल्ट रूप से, हर Android ऐप्लिकेशन के लिए दो तरह के बिल्ड उपलब्ध होते हैं: पहला, आपके ऐप्लिकेशन को डीबग करने के लिए—डीबग बिल्ड और दूसरा, उपयोगकर्ताओं के लिए आपके ऐप्लिकेशन को रिलीज़ करने के लिए—रिलीज़ बिल्ड. अपने ऐप्लिकेशन को किसी डिवाइस पर डिप्लॉय करने से पहले, हर बिल्ड के आउटपुट पर सर्टिफ़िकेट से हस्ताक्षर करना ज़रूरी है. डीबग बिल्ड को SDK टूल से मिली डीबग पासकोड से अपने-आप साइन किया जाता है. यह पासकोड असुरक्षित होता है और इसका इस्तेमाल करके, Google Play Store पर ऐप्लिकेशन पब्लिश नहीं किया जा सकता. साथ ही, रिलीज़ बिल्ड को अपनी निजी पासकोड से साइन किया जाना चाहिए.

अगर आपको रिलीज़ के लिए अपना ऐप्लिकेशन बनाना है, तो यह ज़रूरी है कि आप सही साइनिंग पासकोड का इस्तेमाल करके, अपने ऐप्लिकेशन पर साइन करें. अगर आपने अभी-अभी शुरुआत की है, तो डीबग APK बनाकर, एम्युलेटर या कनेक्ट किए गए डिवाइस पर अपने ऐप्लिकेशन तुरंत चलाए जा सकते हैं.

अपनी build.gradle.kts फ़ाइल में कस्टम बिल्ड टाइप भी तय किया जा सकता है. साथ ही, debuggable true को शामिल करके, इसे डीबग बिल्ड के तौर पर साइन करने के लिए कॉन्फ़िगर किया जा सकता है. ज़्यादा जानकारी के लिए, बिल्ड वैरिएंट कॉन्फ़िगर करना लेख पढ़ें.

APK बनाना और उसे डिप्लॉय करना

अपने ऐप्लिकेशन को पैकेज करने और उसे Play Console पर अपलोड करने का सबसे अच्छा तरीका, ऐप्लिकेशन बंडल बनाना है. हालांकि, जब आपको डीबग बाइल्ड की तुरंत जांच करनी हो या अपने ऐप्लिकेशन को डिप्लॉय किए जा सकने वाले आर्टफ़ैक्ट के तौर पर दूसरों के साथ शेयर करना हो, तो APK बनाना बेहतर होता है.

डीबग APK बनाना

ऐप्लिकेशन की तुरंत जांच और डीबग करने के लिए, डीबग APK बनाया जा सकता है. डीबग APK को, SDK टूल से मिली डीबग पासकोड से साइन किया जाता है. साथ ही, adb की मदद से डीबग करने की सुविधा देता है.

डीबग APK बनाने के लिए, कमांड-लाइन खोलें और अपनी प्रोजेक्ट डायरेक्ट्री के रूट पर जाएं. डीबग बिल्ड शुरू करने के लिए, assembleDebug टास्क को इनवोक करें:

gradlew assembleDebug

इससे project_name/module_name/build/outputs/apk/ में module_name-debug.apk नाम का APK बन जाता है. फ़ाइल पर पहले से ही डीबग पासकोड से हस्ताक्षर किया गया है और इसे zipalign के साथ अलाइन किया गया है. इसलिए, इसे तुरंत किसी डिवाइस पर इंस्टॉल किया जा सकता है.

इसके अलावा, APK बनाने और उसे किसी एम्युलेटर या कनेक्ट किए गए डिवाइस पर तुरंत इंस्टॉल करने के लिए, installDebug को इनवोक करें:

gradlew installDebug

ऊपर दिए गए टास्क के नामों में "डीबग" वाला हिस्सा, बिल्ड वैरिएंट के नाम का सिर्फ़ कैमल-केस वर्शन है. इसलिए, इसे उस बिल्ड टाइप या वैरिएंट से बदला जा सकता है जिसे आपको असेंबल या इंस्टॉल करना है. उदाहरण के लिए, अगर आपके पास "डेमो" प्रॉडक्ट फ़्लेवर है, तो assembleDemoDebug टास्क की मदद से डीबग वर्शन बनाया जा सकता है.

हर वैरिएंट के लिए उपलब्ध सभी बिल्ड और इंस्टॉल टास्क देखने के लिए, tasks टास्क चलाएं. इनमें, अनइंस्टॉल करने के टास्क भी शामिल हैं.

एम्युलेटर पर ऐप्लिकेशन चलाने और किसी डिवाइस पर ऐप्लिकेशन चलाने का तरीका बताने वाला सेक्शन भी देखें.

रिलीज़ बंडल या APK बनाना

अपने ऐप्लिकेशन को रिलीज़ करने और डिस्ट्रिब्यूट करने के लिए, आपको रिलीज़ बंडल या APK बनाना होगा. साथ ही, उस पर अपने निजी पासकोड से हस्ताक्षर करना होगा. ज़्यादा जानकारी के लिए, कमांड लाइन से अपने ऐप्लिकेशन पर हस्ताक्षर करने के तरीके के बारे में बताने वाले सेक्शन पर जाएं.

एम्युलेटर पर अपना ऐप्लिकेशन डिप्लॉय करना

Android Emulator का इस्तेमाल करने के लिए, आपको Android Studio का इस्तेमाल करके Android वर्चुअल डिवाइस (AVD) बनाना होगा.

AVD बनाने के बाद, Android Emulator को शुरू करें और अपना ऐप्लिकेशन इस तरह इंस्टॉल करें:

1. कमांड लाइन में, android_sdk/tools/ पर जाएं और अपने AVD की जानकारी देकर एम्युलेटर शुरू करें:

   emulator -avd avd_name

   अगर आपको AVD का नाम नहीं पता है, तो emulator -list-avds को चलाएं.

2. अब आपके पास, डीबग APK बनाने के तरीके के बारे में बताए गए सेक्शन में बताए गए, Gradle इंस्टॉल टास्क में से किसी एक का इस्तेमाल करके, अपना ऐप्लिकेशन इंस्टॉल करने का विकल्प है. इसके अलावा, adb टूल का इस्तेमाल करके भी ऐप्लिकेशन इंस्टॉल किया जा सकता है.

   अगर APK को डेवलपर प्रीव्यू SDK टूल का इस्तेमाल करके बनाया गया है (अगर targetSdkVersion, संख्या के बजाय कोई अक्षर है), तो आपको टेस्ट APK इंस्टॉल करने के लिए, install कमांड के साथ -t विकल्प शामिल करना होगा.

   adb install path/to/your_app.apk
   

   आपके बनाए गए सभी APK, project_name/module_name/build/outputs/apk/ में सेव होते हैं.

ज़्यादा जानकारी के लिए, Android एमुलेटर पर ऐप्लिकेशन चलाना लेख पढ़ें.

अपने ऐप्लिकेशन को किसी फ़िज़िकल डिवाइस पर डिप्लॉय करना

किसी डिवाइस पर अपना ऐप्लिकेशन चलाने से पहले, आपको अपने डिवाइस पर यूएसबी डीबगिंग की सुविधा चालू करनी होगी. आपको यह विकल्प, सेटिंग > डेवलपर के लिए सेटिंग और टूल में दिखेगा.

ध्यान दें: Android 4.2 और उसके बाद के वर्शन में, डेवलपर के लिए सेटिंग और टूल डिफ़ॉल्ट रूप से छिपे होते हैं. इसे उपलब्ध कराने के लिए, सेटिंग > फ़ोन के बारे में जानकारी पर जाएं और बिल्ड नंबर पर सात बार टैप करें. डेवलपर के लिए सेटिंग और टूल ढूंढने के लिए, पिछली स्क्रीन पर वापस जाएं.

डिवाइस को सेट अप करने और यूएसबी से कनेक्ट करने के बाद, डीबग APK बनाने के तरीके वाले सेक्शन में बताए गए Gradle इंस्टॉल टास्क या adb टूल का इस्तेमाल करके, अपना ऐप्लिकेशन इंस्टॉल किया जा सकता है:

adb -d install path/to/your_app.apk

आपके बनाए गए सभी APK, project_name/module_name/build/outputs/apk/ में सेव होते हैं.

ज़्यादा जानकारी के लिए, हार्डवेयर डिवाइस पर ऐप्लिकेशन चलाना लेख पढ़ें.

ऐप्लिकेशन बंडल बनाना

Android ऐप्लिकेशन बंडल में आपके ऐप्लिकेशन का इकट्ठा किया गया सारा कोड और रिसॉर्स शामिल होता है. हालांकि, APK जनरेट करने और उसे साइन करने की प्रोसेस, Google Play पर पूरी की जाती है. APK के उलट, ऐप्लिकेशन बंडल को सीधे किसी डिवाइस पर डिप्लॉय नहीं किया जा सकता. इसलिए, अगर आपको किसी दूसरे व्यक्ति के साथ तुरंत APK शेयर करना है या उसकी जांच करनी है, तो आपको APK बनाना चाहिए.

Android Studio का इस्तेमाल करके, ऐप्लिकेशन बंडल बनाने का सबसे आसान तरीका है. हालांकि, अगर आपको कमांड लाइन से ऐप्लिकेशन बंडल बनाना है, तो Gradle या bundletool का इस्तेमाल करें. इसके बारे में यहां बताया गया है.

Gradle की मदद से ऐप्लिकेशन बंडल बनाना

अगर आपको कमांड लाइन से ऐप्लिकेशन बंडल जनरेट करना है, तो अपने ऐप्लिकेशन के बेस मॉड्यूल पर bundleVariant Gradle टास्क चलाएं. उदाहरण के लिए, यह कमांड बेस मॉड्यूल के डीबग वर्शन के लिए ऐप्लिकेशन बंडल बनाता है:

./gradlew :base:bundleDebug

अगर आपको Play Console में अपलोड करने के लिए, हस्ताक्षर वाला बंडल बनाना है, तो आपको सबसे पहले अपने ऐप्लिकेशन के हस्ताक्षर करने की जानकारी के साथ, बेस मॉड्यूल की build.gradle.kts फ़ाइल को कॉन्फ़िगर करना होगा. ज़्यादा जानने के लिए, अपने ऐप्लिकेशन पर हस्ताक्षर करने के लिए Gradle को कॉन्फ़िगर करने के तरीके के बारे में बताने वाले सेक्शन पर जाएं. उदाहरण के लिए, इसके बाद अपने ऐप्लिकेशन का रिलीज़ वर्शन बनाया जा सकता है. Gradle, अपने-आप एक ऐप्लिकेशन बंडल जनरेट करता है और उस पर हस्ताक्षर करता है. इसके लिए, वह build.gradle.kts फ़ाइल में दी गई हस्ताक्षर करने की जानकारी का इस्तेमाल करता है.

अगर आपको ऐप्लिकेशन बंडल पर हस्ताक्षर करने के लिए, अलग से कोई चरण जोड़ना है, तो कमांड लाइन से अपने ऐप्लिकेशन बंडल पर हस्ताक्षर करने के लिए, jarsigner का इस्तेमाल किया जा सकता है. ऐप्लिकेशन बंडल बनाने के लिए, यह निर्देश इस्तेमाल करें:

jarsigner -keystore pathToKeystore app-release.aab keyAlias

bundletool का इस्तेमाल करके ऐप्लिकेशन बंडल बनाना

bundletool एक कमांड-लाइन टूल है. इसका इस्तेमाल Android Studio, Android Gradle प्लग इन, और Google Play करते हैं. इनका मकसद आपके ऐप्लिकेशन के कंपाइल किए गए कोड और संसाधनों को ऐप्लिकेशन बंडल में बदलना है. साथ ही, उन बंडल से डिप्लॉय किए जा सकने वाले APK जनरेट करना है.

इसलिए, bundletool की मदद से ऐप्लिकेशन बंडल की जांच करना और Google Play के APK जनरेट करने के तरीके को स्थानीय तौर पर फिर से बनाना फ़ायदेमंद है. हालांकि, आम तौर पर आपको ऐप्लिकेशन बंडल बनाने के लिए, bundletool को लागू करने की ज़रूरत नहीं होगी. इसके बजाय, आपको पिछले सेक्शन में बताए गए तरीके से Android Studio या Gradle टास्क का इस्तेमाल करना चाहिए.

हालांकि, अगर आपको बंडल बनाने के लिए Android Studio या Gradle टास्क का इस्तेमाल नहीं करना है, तो पहले से संकलित कोड और संसाधनों से ऐप्लिकेशन बंडल बनाने के लिए, कमांड लाइन से bundletool का इस्तेमाल किया जा सकता है. उदाहरण के लिए, अगर कस्टम बिल्ड टूलचेन का इस्तेमाल किया जाता है. अगर आपने पहले से ऐसा नहीं किया है, तो GitHub डेटा स्टोर करने की जगह से, bundletool डाउनलोड करें.

इस सेक्शन में, अपने ऐप्लिकेशन के कंपाइल किए गए कोड और रिसॉर्स को पैकेज करने का तरीका बताया गया है. साथ ही, कमांड लाइन से bundletool का इस्तेमाल करके, उन्हें Android ऐप्लिकेशन बंडल में बदलने का तरीका भी बताया गया है.

मेनिफ़ेस्ट और रिसॉर्स को प्रोटो फ़ॉर्मैट में जनरेट करना

bundletool के लिए, आपके ऐप्लिकेशन प्रोजेक्ट की कुछ जानकारी Google के प्रोटोकॉल बफ़र फ़ॉर्मैट में होनी चाहिए. जैसे, ऐप्लिकेशन का मेनिफ़ेस्ट और संसाधन. इसे "protobuf" भी कहा जाता है और यह *.pb फ़ाइल एक्सटेंशन का इस्तेमाल करता है. प्रोटोबफ़र, स्ट्रक्चर्ड डेटा को क्रम में लगाने के लिए, भाषा और प्लैटफ़ॉर्म-न्यूट्रल मैकेनिज़्म उपलब्ध कराते हैं. यह एक्सएमएल की तरह ही होता है, लेकिन यह छोटा, तेज़, और आसान होता है.

AAPT2 डाउनलोड करना

Google Maven repository से AAPT2 के नए वर्शन का इस्तेमाल करके, अपने ऐप्लिकेशन की मेनिफ़ेस्ट फ़ाइल और रिसॉर्स टेबल को प्रोटोबबल फ़ॉर्मैट में जनरेट किया जा सकता है.

Google के Maven रिपॉज़िटरी से AAPT2 डाउनलोड करने के लिए, यह तरीका अपनाएं:

1. रिपॉज़िटरी इंडेक्स में, com.android.tools.build > aapt2 पर जाएं.
2. AAPT2 के नए वर्शन का नाम कॉपी करें.

3. आपने जिस वर्शन का नाम कॉपी किया है उसे यहां दिए गए यूआरएल में डालें और अपने टारगेट ऑपरेटिंग सिस्टम की जानकारी दें: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/aapt2-version/aapt2-aapt2-version-[windows | linux | osx].jar

   उदाहरण के लिए, Windows के लिए 3.2.0-alpha18-4804415 वर्शन डाउनलोड करने के लिए, आपको यह यूआरएल इस्तेमाल करना होगा: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/3.2.0-alpha18-4804415/aapt2-3.2.0-alpha18-4804415-windows.jar

4. ब्राउज़र में यूआरएल पर जाएं—AAPT2 कुछ ही समय में डाउनलोड होना शुरू हो जाएगा.

5. अभी डाउनलोड की गई JAR फ़ाइल को अनपैक करें.

अपने ऐप्लिकेशन के संसाधनों को कंपाइल और लिंक करना

अपने ऐप्लिकेशन के संसाधनों को कंपाइल करने के लिए, AAPT2 का इस्तेमाल करें. इसके लिए, यह कमांड इस्तेमाल करें:

aapt2 compile \
project_root/module_root/src/main/res/drawable/Image1.png \
project_root/module_root/src/main/res/drawable/Image2.png \
-o compiled_resources/

लिंक करने के दौरान, AAPT2 आपके अलग-अलग कंपाइल किए गए रिसॉर्स को एक ही APK में लिंक करता है. इस दौरान, AAPT2 को निर्देश दें कि वह आपके ऐप्लिकेशन के मेनिफ़ेस्ट और कंपाइल किए गए रिसॉर्स को --proto-format फ़्लैग को शामिल करके, प्रोटोबस फ़ॉर्मैट में बदले. इसके लिए, नीचे दिया गया तरीका अपनाएं:

aapt2 link --proto-format -o output.apk \
-I android_sdk/platforms/android_version/android.jar \
--manifest project_root/module_root/src/main/AndroidManifest.xml \
-R compiled_resources/*.flat \
--auto-add-overlay

इसके बाद, आउटपुट APK से कॉन्टेंट निकाला जा सकता है. जैसे, आपके ऐप्लिकेशन की AndroidManifest.xml, resources.pb, और अन्य संसाधन फ़ाइलें, जो अब protobuf फ़ॉर्मैट में हैं. इन फ़ाइलों की ज़रूरत तब होती है, जब इनपुट तैयार करते समय bundletool को आपका ऐप्लिकेशन बंडल बनाने की ज़रूरत होती है. इस बारे में यहां दिए गए सेक्शन में बताया गया है.

पहले से कंपाइल किए गए कोड और संसाधनों को पैकेज करना

अपने ऐप्लिकेशन के लिए ऐप्लिकेशन बंडल जनरेट करने के लिए, bundletool का इस्तेमाल करने से पहले, आपको पहले ऐसी ZIP फ़ाइलें देनी होंगी जिनमें किसी ऐप्लिकेशन मॉड्यूल के लिए, कॉम्पाइल किया गया कोड और संसाधन शामिल हों. हर मॉड्यूल की ZIP फ़ाइल का कॉन्टेंट और व्यवस्थित करने का तरीका, Android ऐप्लिकेशन बंडल फ़ॉर्मैट से काफ़ी मिलता-जुलता है. उदाहरण के लिए, आपको अपने ऐप्लिकेशन के बेस मॉड्यूल के लिए base.zip फ़ाइल बनानी चाहिए और इसके कॉन्टेंट को इस तरह व्यवस्थित करना चाहिए:

अपने ऐप्लिकेशन के हर मॉड्यूल के लिए ZIP फ़ाइल तैयार करने के बाद, उन्हें bundletool पर भेजा जा सकता है, ताकि आपका ऐप्लिकेशन बंडल बनाया जा सके. इसके बारे में नीचे दिए गए सेक्शन में बताया गया है.

bundletool का इस्तेमाल करके अपना ऐप्लिकेशन बंडल बनाना

ऐप्लिकेशन बंडल बनाने के लिए, bundletool build-bundle कमांड का इस्तेमाल करें, जैसा कि यहां दिखाया गया है:

bundletool build-bundle --modules=base.zip --output=mybundle.aab

नीचे दी गई टेबल में, build-bundle कमांड के फ़्लैग के बारे में ज़्यादा जानकारी दी गई है:

डाउनस्ट्रीम APK जनरेशन को पसंद के मुताबिक बनाना

ऐप्लिकेशन बंडल में एक BundleConfig.pb फ़ाइल होती है. इसमें वह मेटाडेटा होता है जो Google Play जैसे ऐप्लिकेशन स्टोर को बंडल से APK जनरेट करते समय ज़रूरत होती है. bundletool यह फ़ाइल आपके लिए बनाता है. हालांकि, BundleConfig.json फ़ाइल में मेटाडेटा के कुछ पहलुओं को कॉन्फ़िगर किया जा सकता है और इसे bundletool build-bundle कमांड को पास किया जा सकता है. इसके बाद, bundletool इस फ़ाइल को हर ऐप्लिकेशन बंडल में शामिल protobuf वर्शन में बदल देता है और मर्ज कर देता है.

उदाहरण के लिए, यह कंट्रोल किया जा सकता है कि कॉन्फ़िगरेशन APK की कौनसी कैटगरी चालू या बंद करनी है. BundleConfig.json फ़ाइल के इस उदाहरण में, ऐसे कॉन्फ़िगरेशन APK बंद किए गए हैं जो हर एक अलग भाषा को टारगेट करते हैं. इसका मतलब है कि सभी भाषाओं के रिसॉर्स, उनके बेस या फ़ीचर APK में शामिल किए गए हैं:

{
  "optimizations": {
    "splitsConfig": {
      "splitDimension": [{
        "value": "LANGUAGE",
        "negate": true
      }]
    }
  }
}

अपनी BundleConfig.json फ़ाइल में, यह भी बताया जा सकता है कि glob पैटर्न का इस्तेमाल करके APK पैकेज करते समय, किन फ़ाइल टाइप को कंप्रेस नहीं करना है. इसके लिए, यह तरीका अपनाएं:

{
  "compression": {
    "uncompressedGlob": ["res/raw/**", "assets/**.uncompressed"]
  }
}

ध्यान रखें कि डिफ़ॉल्ट रूप से, bundletool आपके ऐप्लिकेशन की नेटिव लाइब्रेरी (Android 6.0 या उसके बाद के वर्शन पर) और रिसॉर्स टेबल (resources.arsc) को कंप्रेस नहीं करता. BundleConfig.json में क्या कॉन्फ़िगर किया जा सकता है, इसकी पूरी जानकारी के लिए bundletool config.proto फ़ाइल देखें. इसे Proto3 सिंटैक्स का इस्तेमाल करके लिखा गया है.

ऐप्लिकेशन बंडल से अपना ऐप्लिकेशन डिप्लॉय करना

अगर आपने कोई ऐप्लिकेशन बंडल बनाया है और उस पर हस्ताक्षर किया है, तो APK जनरेट करने और उन्हें किसी डिवाइस पर डिप्लॉय करने के लिए, bundletool का इस्तेमाल करें.

कमांड लाइन से अपने ऐप्लिकेशन को साइन करना

अपने ऐप्लिकेशन को साइन करने के लिए, आपको Android Studio की ज़रूरत नहीं है. APK के लिए apksigner या ऐप्लिकेशन बंडल के लिए jarsigner का इस्तेमाल करके, कमांड लाइन से अपने ऐप्लिकेशन को साइन किया जा सकता है. इसके अलावा, Gradle को कॉन्फ़िगर करके, उसे बिल्ड के दौरान अपने-आप साइन करने के लिए कहा जा सकता है. दोनों ही मामलों में, आपको सबसे पहले keytool का इस्तेमाल करके, निजी कुंजी जनरेट करनी होगी, जैसा कि यहां दिखाया गया है:

keytool -genkey -v -keystore my-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias my-alias

ऊपर दिए गए उदाहरण में, आपको पासवर्ड डालने के लिए कहा गया है. ये पासवर्ड, पासकोड और पासकोड के लिए होते हैं. साथ ही, आपकी पासकोड के लिए "डिस्टिंग्विश्ड नेम" फ़ील्ड के लिए भी पासवर्ड डालने होते हैं. इसके बाद, यह my-release-key.jks नाम की फ़ाइल के तौर पर पासकोड जनरेट करता है और उसे मौजूदा डायरेक्ट्री में सेव करता है. इसे अपनी पसंद के मुताबिक कहीं भी ले जाया जा सकता है. पासकोड में एक ऐसी कुंजी होती है जो 10,000 दिनों तक मान्य होती है.

अब अपने APK या ऐप्लिकेशन बंडल पर मैन्युअल तरीके से हस्ताक्षर किया जा सकता है. इसके अलावा, बिल्ड प्रोसेस के दौरान अपने ऐप्लिकेशन पर हस्ताक्षर करने के लिए, Gradle को कॉन्फ़िगर किया जा सकता है. इसके बारे में यहां दिए गए सेक्शन में बताया गया है.

कमांड लाइन से अपने ऐप्लिकेशन को मैन्युअल तरीके से साइन करना

अगर आपको कमांड लाइन से किसी ऐप्लिकेशन बंडल को साइन करना है, तो jarsigner का इस्तेमाल करें. अगर आपको किसी APK पर हस्ताक्षर करना है, तो आपको यहां बताए गए तरीके के हिसाब से zipalign और apksigner का इस्तेमाल करना होगा.

1. कमांड-लाइन खोलें—Android Studio में, व्यू > टूल विंडो > टर्मिनल चुनें—और उस डायरेक्ट्री पर जाएं जहां आपका बिना हस्ताक्षर वाला APK मौजूद है.

2. zipalign का इस्तेमाल करके, बिना हस्ताक्षर वाला APK अलाइन करें:

   zipalign -v -p 4 my-app-unsigned.apk my-app-unsigned-aligned.apk
   

   zipalign यह पक्का करता है कि बिना कंप्रेस किया गया सारा डेटा, फ़ाइल की शुरुआत के हिसाब से किसी खास बाइट अलाइनमेंट से शुरू होता है. इससे, ऐप्लिकेशन के लिए इस्तेमाल होने वाली रैम की मात्रा कम हो सकती है.

3. apksigner का इस्तेमाल करके, अपने APK पर निजी पासकोड से हस्ताक्षर करें:

   apksigner sign --ks my-release-key.jks --out my-app-release.apk my-app-unsigned-aligned.apk
   

   इस उदाहरण में, my-app-release.apk पर साइन किए गए APK को आउटपुट किया गया है. इसके लिए, निजी पासकोड और सर्टिफ़िकेट का इस्तेमाल किया गया है. ये दोनों एक ही कीस्टोर फ़ाइल: my-release-key.jks में सेव किए गए हैं.

   apksigner टूल, साइन करने के अन्य विकल्पों के साथ काम करता है. इनमें, अलग-अलग निजी कुंजी और सर्टिफ़िकेट फ़ाइलों का इस्तेमाल करके APK फ़ाइल को साइन करना और एक से ज़्यादा साइनर का इस्तेमाल करके APK को साइन करना शामिल है. ज़्यादा जानकारी के लिए, apksigner रेफ़रंस देखें.

   ध्यान दें: apksigner टूल का इस्तेमाल करने के लिए, आपके पास Android SDK बिल्ड टूल का 24.0.3 या इसके बाद का वर्शन इंस्टॉल होना चाहिए. SDK मैनेजर का इस्तेमाल करके, इस पैकेज को अपडेट किया जा सकता है.

4. पुष्टि करें कि आपके APK पर हस्ताक्षर किया गया है:

   apksigner verify my-app-release.apk
   

अपने ऐप्लिकेशन को साइन करने के लिए, Gradle को कॉन्फ़िगर करना

मॉड्यूल-लेवल की build.gradle.kts फ़ाइल खोलें और storeFile, storePassword, keyAlias, और keyPassword के लिए एंट्री के साथ signingConfigs {} ब्लॉक जोड़ें. इसके बाद, उस ऑब्जेक्ट को अपने बिल्ड टाइप में signingConfig प्रॉपर्टी में पास करें. उदाहरण के लिए:

android {
    ...
    defaultConfig { ... }
    signingConfigs {
        create("release") {
            // You need to specify either an absolute path or include the
            // keystore file in the same directory as the build.gradle file.
            storeFile = file("my-release-key.jks")
            storePassword = "password"
            keyAlias = "my-alias"
            keyPassword = "password"
        }
    }
    buildTypes {
        getByName("release") {
            signingConfig = signingConfigs.getByName("release")
            ...
        }
    }
}

android {
    ...
    defaultConfig { ... }
    signingConfigs {
        release {
            // You need to specify either an absolute path or include the
            // keystore file in the same directory as the build.gradle file.
            storeFile file("my-release-key.jks")
            storePassword "password"
            keyAlias "my-alias"
            keyPassword "password"
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
            ...
        }
    }
}

अब, Gradle टास्क को शुरू करके ऐप्लिकेशन बनाने पर, Gradle आपके ऐप्लिकेशन पर हस्ताक्षर करता है और zipalign चलाता है.

इसके अलावा, आपने रिलीज़ बिल्ड को साइनिंग पासकोड की मदद से कॉन्फ़िगर किया है, इसलिए उस बिल्ड टाइप के लिए "इंस्टॉल करें" टास्क उपलब्ध है. इसलिए, installRelease टास्क की मदद से, रिलीज़ APK को एमुलेटर या डिवाइस पर बनाया, अलाइन, साइन, और इंस्टॉल किया जा सकता है.

आपकी निजी कुंजी से साइन किया गया ऐप्लिकेशन, डिस्ट्रिब्यूशन के लिए तैयार है. हालांकि, आपको पहले अपना ऐप्लिकेशन पब्लिश करने के तरीके के बारे में ज़्यादा पढ़ना चाहिए. साथ ही, Google Play पर ऐप्लिकेशन लॉन्च करने से जुड़ी चेकलिस्ट देखनी चाहिए.