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

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

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

  • Windows Command Shell पर:

    gradlew task-name
    
  • Mac, Linux या Windows PowerShell पर:

    ./gradlew task-name
    

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

gradlew tasks

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

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

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

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

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

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

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

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

डीबग APK बनाना

ऐप्लिकेशन की तुरंत जांच और डीबग करने के लिए, डीबग APK बनाया जा सकता है. डीबग APK को एसडीके टूल से मिली डीबग कुंजी से साइन किया जाता है. साथ ही, यह 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 वर्चुअल डिवाइस (एवीडी) बनाना होगा.

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

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

    emulator -avd <var>avd_name</var>
    

    अगर आपको एवीडी का नाम नहीं पता है, तो emulator -list-avds को एक्ज़ीक्यूट करें.

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

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

    adb install <var>path/to/your_app</var>.apk
    

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

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

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

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

यूएसबी का इस्तेमाल करके डिवाइस को सेट अप और कनेक्ट करने के बाद, ऐप्लिकेशन इंस्टॉल किया जा सकता है. इसके लिए, डीबग 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 डाउनलोड करें.

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

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

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

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

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

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

फ़ाइल या डायरेक्ट्री ब्यौरा
manifest/AndroidManifest.xml protobuf फ़ॉर्मैट में मॉड्यूल का मेनिफ़ेस्ट.
dex/... एक ऐसी डायरेक्ट्री जिसमें आपके ऐप्लिकेशन की कंपाइल की गई एक या उससे ज़्यादा DEX फ़ाइलें हों. इन फ़ाइलों के नाम इस तरह होने चाहिए: classes.dex, classes2.dex, classes3.dex वगैरह.
res/... इसमें सभी डिवाइस कॉन्फ़िगरेशन के लिए, protobuf फ़ॉर्मैट में मॉड्यूल के संसाधन शामिल होते हैं. सबडायरेक्ट्री और फ़ाइलों को किसी सामान्य APK की तरह ही व्यवस्थित किया जाना चाहिए.
root/..., assets/..., और lib/... ये डायरेक्ट्री, Android ऐप्लिकेशन बंडल फ़ॉर्मैट वाले सेक्शन में बताई गई डायरेक्ट्री जैसी ही होती हैं.
resources.pb protobuf फ़ॉर्मैट में आपके ऐप्लिकेशन की रिसॉर्स टेबल.

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

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

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

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

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

झंडा ब्यौरा
--modules=path-to-base.zip, path-to-module2.zip,path-to-module3.zip इससे मॉड्यूल की उन ZIP फ़ाइलों की सूची के बारे में जानकारी मिलती है जिनका इस्तेमाल bundletool को आपके ऐप्लिकेशन बंडल को बनाने के लिए करना चाहिए.
--output=path-to-output.aab आउटपुट *.aab फ़ाइल के लिए पाथ और फ़ाइल नाम तय करता है.
--config=path-to-BundleConfig.json यह विकल्प, कॉन्फ़िगरेशन फ़ाइल का पाथ तय करता है. इस फ़ाइल का इस्तेमाल करके, बिल्ड प्रोसेस को पसंद के मुताबिक बनाया जा सकता है. ज़्यादा जानने के लिए, डाउनस्ट्रीम APK जनरेशन को पसंद के मुताबिक बनाना सेक्शन देखें.
--metadata-file=target-bundle-path:local-file-path bundletool को आपके ऐप्लिकेशन बंडल में, वैकल्पिक मेटाडेटा फ़ाइल को पैकेज करने का निर्देश देता है. इस फ़ाइल का इस्तेमाल करके, ProGuard मैपिंग या अपने ऐप्लिकेशन की DEX फ़ाइलों की पूरी सूची जैसा डेटा शामिल किया जा सकता है. यह डेटा, आपके टूलचेन या ऐप स्टोर के अन्य चरणों के लिए काम का हो सकता है.

target-bundle-path, ऐप्लिकेशन बंडल के रूट के हिसाब से वह पाथ तय करता है जहां आपको मेटाडेटा फ़ाइल को पैकेज करना है. साथ ही, local-file-path, लोकल मेटाडेटा फ़ाइल का पाथ तय करता है.

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

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

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

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

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

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

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

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

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

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

अपने ऐप्लिकेशन पर हस्ताक्षर करने के लिए, आपको Android Studio की ज़रूरत नहीं है. आपके पास कमांड लाइन से अपने ऐप्लिकेशन पर हस्ताक्षर करने का विकल्प है. इसके लिए, APKs के लिए 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 में, View > Tool Windows > Terminal को चुनें—और उस डायरेक्ट्री पर जाएं जहां आपका बिना हस्ताक्षर वाला 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
    

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

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

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

    apksigner verify my-app-release.apk
    

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

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

Kotlin

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")
            ...
        }
    }
}

Groovy

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 पर ऐप्लिकेशन लॉन्च करने से जुड़ी चेकलिस्ट देखनी चाहिए.