Bazel ट्यूटोरियल: Android ऐप्लिकेशन बनाएं

इस ट्यूटोरियल में, Bazel का इस्तेमाल करके एक सामान्य Android ऐप्लिकेशन बनाने का तरीका बताया गया है.

Bazel, Android के नियमों का इस्तेमाल करके Android ऐप्लिकेशन बनाने की सुविधा देता है.

यह ट्यूटोरियल, Windows, macOS, और Linux का इस्तेमाल करने वाले लोगों के लिए है. इसके लिए, Bazel या Android ऐप्लिकेशन डेवलपमेंट का अनुभव होना ज़रूरी नहीं है. इस ट्यूटोरियल में, आपको कोई Android कोड लिखने की ज़रूरत नहीं है.

आपको क्या सीखने को मिलेगा

इस ट्यूटोरियल में, आपको इनके बारे में जानकारी मिलेगी:

• Bazel और Android Studio इंस्टॉल करके अपना एनवायरमेंट सेट अप करें. साथ ही, सैंपल प्रोजेक्ट डाउनलोड करें.
• Bazel वर्कस्पेस सेट अप करें. इसमें ऐप्लिकेशन का सोर्स कोड और WORKSPACE फ़ाइल होनी चाहिए. यह फ़ाइल, वर्कस्पेस डायरेक्ट्री के टॉप लेवल की पहचान करती है.
• WORKSPACE फ़ाइल को अपडेट करें, ताकि इसमें Android SDK जैसी ज़रूरी बाहरी डिपेंडेंसी के रेफ़रंस शामिल हों.
• BUILD फ़ाइल बनाएं.
• Bazel की मदद से ऐप्लिकेशन बनाएं.
• ऐप्लिकेशन को Android एम्युलेटर या फ़िज़िकल डिवाइस पर डिप्लॉय करें और चलाएं.

शुरू करने से पहले

Bazel इंस्टॉल करना

ट्यूटोरियल शुरू करने से पहले, यह सॉफ़्टवेयर इंस्टॉल करें:

• Bazel. इसे इंस्टॉल करने के लिए, इंस्टॉल करने के निर्देशों का पालन करें.
• Android Studio. इसे इंस्टॉल करने के लिए, Android Studio डाउनलोड करने का तरीका अपनाएं. एसडीके टूल डाउनलोड करने और अपने एनवायरमेंट को कॉन्फ़िगर करने के लिए, सेटअप विज़र्ड को एक्ज़ीक्यूट करें.
• (ज़रूरी नहीं) Git. Android ऐप्लिकेशन प्रोजेक्ट डाउनलोड करने के लिए, git का इस्तेमाल करें.

सैंपल प्रोजेक्ट पाना

सेंपल प्रोजेक्ट के लिए, Bazel के उदाहरणों के डेटा स्टोर करने की जगह में मौजूद, Android ऐप्लिकेशन का बेसिक प्रोजेक्ट इस्तेमाल करें.

इस ऐप्लिकेशन में एक बटन है. इस पर क्लिक करने पर, बधाई का मैसेज प्रिंट होता है:

पहली इमेज. Android ऐप्लिकेशन के बटन पर दिखने वाला अभिवादन.

git की मदद से रिपॉज़िटरी को क्लोन करें या ZIP फ़ाइल को सीधे तौर पर डाउनलोड करें:

git clone https://github.com/bazelbuild/examples

इस ट्यूटोरियल के लिए सैंपल प्रोजेक्ट, examples/android/tutorial में है. ट्यूटोरियल के बाकी हिस्सों के लिए, आपको इस डायरेक्ट्री में कमांड चलाने होंगे.

सोर्स फ़ाइलों की समीक्षा करना

ऐप्लिकेशन की सोर्स फ़ाइलें देखें.

.
├── README.md
└── src
    └── main
        ├── AndroidManifest.xml
        └── java
            └── com
                └── example
                    └── bazel
                        ├── AndroidManifest.xml
                        ├── Greeter.java
                        ├── MainActivity.java
                        └── res
                            ├── layout
                            │   └── activity_main.xml
                            └── values
                                ├── colors.xml
                                └── strings.xml

मुख्य फ़ाइलें और डायरेक्ट्री ये हैं:

Bazel की मदद से बनाना

वर्कस्पेस सेट अप करना

वर्कस्पेस एक डायरेक्ट्री होती है. इसमें एक या उससे ज़्यादा सॉफ़्टवेयर प्रोजेक्ट के सोर्स फ़ाइलें होती हैं. साथ ही, इसके रूट में एक WORKSPACE फ़ाइल होती है.

WORKSPACE फ़ाइल खाली हो सकती है या इसमें आपके प्रोजेक्ट को बनाने के लिए ज़रूरी बाहरी डिपेंडेंसी के रेफ़रंस हो सकते हैं.

सबसे पहले, खाली WORKSPACE फ़ाइल बनाने के लिए, यह कमांड चलाएं:

Bazel का इस्तेमाल करना

अब इस कमांड का इस्तेमाल करके, यह देखा जा सकता है कि Bazel सही तरीके से काम कर रहा है या नहीं:

bazel info workspace

अगर Bazel, मौजूदा डायरेक्ट्री का पाथ प्रिंट करता है, तो इसका मतलब है कि सब कुछ ठीक है! अगर WORKSPACE फ़ाइल मौजूद नहीं है, तो आपको गड़बड़ी का यह मैसेज दिख सकता है:

ERROR: The 'info' command is only supported from within a workspace.

Android SDK के साथ इंटिग्रेट करना

ऐप्लिकेशन बनाने के लिए, Bazel को Android SDK के बिल्ड टूल चलाने की ज़रूरत होती है. इसका मतलब है कि आपको अपनी WORKSPACE फ़ाइल में कुछ जानकारी जोड़नी होगी, ताकि Bazel को पता चल सके कि उन्हें कहां ढूंढना है.

अपनी WORKSPACE फ़ाइल में यह लाइन जोड़ें:

android_sdk_repository(name = "androidsdk")

यह ANDROID_HOME एनवायरमेंट वैरिएबल से रेफ़र किए गए पाथ पर मौजूद Android SDK टूल का इस्तेमाल करेगा. साथ ही, यह उस जगह पर इंस्टॉल किए गए सबसे नए एपीआई लेवल और बिल्ड टूल के नए वर्शन का अपने-आप पता लगा लेगा.

ANDROID_HOME वैरिएबल को Android SDK की जगह पर सेट किया जा सकता है. Android Studio के एसडीके मैनेजर का इस्तेमाल करके, इंस्टॉल किए गए एसडीके का पाथ ढूंढें. अगर एसडीके को डिफ़ॉल्ट जगहों पर इंस्टॉल किया गया है, तो ANDROID_HOME वैरिएबल सेट करने के लिए, इन निर्देशों का इस्तेमाल किया जा सकता है:

ऊपर दी गई कमांड, वैरिएबल को सिर्फ़ मौजूदा शेल सेशन के लिए सेट करती हैं. इन्हें हमेशा के लिए लागू करने के लिए, ये कमांड चलाएं:

Android SDK का पूरा पाथ, एपीआई लेवल, और इस्तेमाल किए जाने वाले बिल्ड टूल का वर्शन भी साफ़ तौर पर बताया जा सकता है. इसके लिए, path, api_level, और build_tools_version एट्रिब्यूट शामिल करें. अगर api_level और build_tools_version नहीं दिए गए हैं, तो android_sdk_repository नियम, एसडीके में उपलब्ध संबंधित सबसे नए वर्शन का इस्तेमाल करेगा. एसडीके में मौजूद होने पर, इन एट्रिब्यूट के किसी भी कॉम्बिनेशन को तय किया जा सकता है. उदाहरण के लिए:

android_sdk_repository(
    name = "androidsdk",
    path = "/path/to/Android/sdk",
    api_level = 25,
    build_tools_version = "30.0.3"
)

Windows पर, ध्यान दें कि path एट्रिब्यूट में मिक्स्ड-स्टाइल पाथ का इस्तेमाल करना ज़रूरी है. इसका मतलब है कि फ़ॉरवर्ड स्लैश वाला Windows पाथ:

android_sdk_repository(
    name = "androidsdk",
    path = "c:/path/to/Android/sdk",
)

ज़रूरी नहीं: अगर आपको अपने Android ऐप्लिकेशन में नेटिव कोड कंपाइल करना है, तो आपको Android NDK भी डाउनलोड करना होगा. साथ ही, Bazel को यह बताना होगा कि उसे यह कहां मिलेगा. इसके लिए, अपनी WORKSPACE फ़ाइल में यह लाइन जोड़ें:

android_ndk_repository(name = "androidndk")

android_sdk_repository की तरह, Android NDK का पाथ डिफ़ॉल्ट रूप से ANDROID_NDK_HOME एनवायरमेंट वैरिएबल से अनुमानित किया जाता है. android_ndk_repository पर path एट्रिब्यूट का इस्तेमाल करके, पाथ को साफ़ तौर पर भी बताया जा सकता है.

ज़्यादा जानकारी के लिए, Bazel के साथ Android Native Development Kit का इस्तेमाल करना लेख पढ़ें.

api_level, Android API का वह वर्शन है जिसे SDK और NDK टारगेट करते हैं. उदाहरण के लिए, Android 6.0 के लिए 23 और Android 7.1 के लिए 25. अगर इसे साफ़ तौर पर सेट नहीं किया जाता है, तो api_level, android_sdk_repository और android_ndk_repository के लिए उपलब्ध सबसे ज़्यादा एपीआई लेवल पर डिफ़ॉल्ट रूप से सेट होता है.

एसडीके और एनडीके के लिए, एपीआई लेवल को एक ही वैल्यू पर सेट करना ज़रूरी नहीं है. इस पेज पर, Android के वर्शन के हिसाब से NDK के साथ काम करने वाले एपीआई लेवल का मैप दिया गया है.

BUILD फ़ाइल बनाना

BUILD फ़ाइल, बिल्ड आउटपुट के सेट के बीच के संबंध के बारे में बताती है. जैसे, aapt से कंपाइल किए गए Android संसाधन या javac से क्लास फ़ाइलें और उनकी डिपेंडेंसी. ये डिपेंडेंसी, आपके वर्कस्पेस में मौजूद सोर्स फ़ाइलें (Java, C++) या अन्य बिल्ड आउटपुट हो सकती हैं. BUILD फ़ाइलें, Starlark नाम की भाषा में लिखी जाती हैं.

BUILD फ़ाइलें, Bazel में पैकेज हैरारकी के तौर पर जाने जाने वाले कॉन्सेप्ट का हिस्सा होती हैं. पैकेज का क्रम एक लॉजिकल स्ट्रक्चर होता है. यह आपके वर्कस्पेस में मौजूद डायरेक्ट्री स्ट्रक्चर पर आधारित होता है. हर पैकेज एक डायरेक्ट्री (और उसकी सबडायरेक्ट्री) होती है. इसमें सोर्स फ़ाइलों का एक सेट और एक BUILD फ़ाइल होती है. पैकेज में सभी सबडायरेक्ट्री भी शामिल होती हैं. हालांकि, इसमें वे सबडायरेक्ट्री शामिल नहीं होती हैं जिनमें अपनी BUILD फ़ाइल होती है. पैकेज का नाम, WORKSPACE के हिसाब से BUILD फ़ाइल का पाथ होता है.

ध्यान दें कि Bazel के पैकेज का क्रम, आपकी Android ऐप्लिकेशन डायरेक्ट्री के Java पैकेज के क्रम से अलग होता है. इस डायरेक्ट्री में BUILD फ़ाइल मौजूद होती है. हालांकि, डायरेक्ट्री को एक ही तरह से व्यवस्थित किया जा सकता है.

इस ट्यूटोरियल में दिए गए सामान्य Android ऐप्लिकेशन के लिए, सोर्स फ़ाइलें src/main/ एक Bazel पैकेज में शामिल होती हैं. ज़्यादा मुश्किल प्रोजेक्ट में कई नेस्ट किए गए पैकेज हो सकते हैं.

android_library नियम जोड़ना

BUILD फ़ाइल में, Bazel के लिए कई तरह के एलान होते हैं. सबसे अहम टाइप बिल्ड नियम है. इससे Bazel को यह पता चलता है कि सोर्स फ़ाइलों या अन्य डिपेंडेंसी के सेट से, इंटरमीडिएट या फ़ाइनल सॉफ़्टवेयर आउटपुट कैसे बनाया जाए. Bazel, Android ऐप्लिकेशन बनाने के लिए दो बिल्ड नियम उपलब्ध कराता है: android_library और android_binary.

इस ट्यूटोरियल के लिए, सबसे पहले android_library नियम का इस्तेमाल करके Bazel को यह निर्देश दिया जाएगा कि वह ऐप्लिकेशन के सोर्स कोड और संसाधन फ़ाइलों से, Android लाइब्रेरी मॉड्यूल बनाए. इसके बाद, Android ऐप्लिकेशन पैकेज बनाने का तरीका Bazel को बताने के लिए, android_binary नियम का इस्तेमाल करें.

src/main/java/com/example/bazel डायरेक्ट्री में एक नई BUILD फ़ाइल बनाएं. इसके बाद, एक नया android_library टारगेट बनाएं:

src/main/java/com/example/bazel/BUILD:

package(
    default_visibility = ["//src:__subpackages__"],
)

android_library(
    name = "greeter_activity",
    srcs = [
        "Greeter.java",
        "MainActivity.java",
    ],
    manifest = "AndroidManifest.xml",
    resource_files = glob(["res/**"]),
)

android_library बिल्ड रूल में एट्रिब्यूट का एक सेट होता है. यह सेट, ऐसी जानकारी देता है जिसकी ज़रूरत Bazel को सोर्स फ़ाइलों से लाइब्रेरी मॉड्यूल बनाने के लिए होती है. यह भी ध्यान दें कि नियम का नाम greeter_activity है. इस नाम का इस्तेमाल करके, android_binary नियम में डिपेंडेंसी के तौर पर नियम का रेफ़रंस दिया जाएगा.

android_binary नियम जोड़ना

android_binary नियम, आपके ऐप्लिकेशन के लिए Android ऐप्लिकेशन पैकेज (.apk फ़ाइल) बनाता है.

src/main/ डायरेक्ट्री में एक नई BUILD फ़ाइल बनाएं. इसके बाद, एक नया android_binary टारगेट बनाएं:

src/main/BUILD:

android_binary(
    name = "app",
    manifest = "AndroidManifest.xml",
    deps = ["//src/main/java/com/example/bazel:greeter_activity"],
)

यहां, deps एट्रिब्यूट, greeter_activity नियम के आउटपुट को रेफ़रंस देता है. यह नियम आपने ऊपर दी गई BUILD फ़ाइल में जोड़ा था. इसका मतलब है कि जब Bazel इस नियम का आउटपुट बनाता है, तो वह सबसे पहले यह देखता है कि greeter_activity लाइब्रेरी के नियम का आउटपुट बनाया गया है या नहीं और वह अप-टू-डेट है या नहीं. अगर ऐसा नहीं है, तो Bazel इसे बनाता है. इसके बाद, ऐप्लिकेशन पैकेज फ़ाइल बनाने के लिए उस आउटपुट का इस्तेमाल करता है.

अब फ़ाइल को सेव करें और बंद करें.

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

ऐप्लिकेशन बनाकर देखें! android_binary टारगेट बनाने के लिए, यह कमांड चलाएं:

bazel build //src/main:app

build सबकमांड, Bazel को इसके बाद दिए गए टारगेट को बनाने का निर्देश देती है. टारगेट को BUILD फ़ाइल में मौजूद बिल्ड नियम के नाम के तौर पर तय किया जाता है. साथ ही, इसमें आपकी वर्कस्पेस डायरेक्ट्री के हिसाब से पैकेज का पाथ भी शामिल होता है. इस उदाहरण के लिए, टारगेट app है और पैकेज का पाथ //src/main/ है.

ध्यान दें कि कमांड लाइन पर मौजूद आपकी मौजूदा वर्किंग डायरेक्ट्री और टारगेट के नाम के आधार पर, कभी-कभी पैकेज पाथ या टारगेट का नाम हटाया जा सकता है. टारगेट लेबल और पाथ के बारे में ज़्यादा जानकारी के लिए, लेबल देखें.

Bazel, सैंपल ऐप्लिकेशन बनाना शुरू कर देगा. बिल्ड प्रोसेस के दौरान, इसका आउटपुट यहां दिए गए आउटपुट की तरह दिखेगा:

INFO: Analysed target //src/main:app (0 packages loaded, 0 targets configured).
INFO: Found 1 target...
Target //src/main:app up-to-date:
  bazel-bin/src/main/app_deploy.jar
  bazel-bin/src/main/app_unsigned.apk
  bazel-bin/src/main/app.apk

बिल्ड आउटपुट ढूंढना

Bazel, इंटरमीडिएट और फ़ाइनल, दोनों तरह की बिल्ड कार्रवाइयों के आउटपुट को हर उपयोगकर्ता और हर वर्कस्पेस के हिसाब से आउटपुट डायरेक्ट्री के सेट में रखता है. ये डायरेक्ट्री, प्रोजेक्ट डायरेक्ट्री के टॉप-लेवल पर मौजूद इन जगहों से सिमलंक की गई हैं. यहां WORKSPACE मौजूद है:

• bazel-bin में बाइनरी एक्ज़ीक्यूटेबल और अन्य रन करने लायक बिल्ड आउटपुट सेव होते हैं
• bazel-genfiles, Bazel के नियमों के हिसाब से जनरेट की गई इंटरमीडियरी सोर्स फ़ाइलें सेव करता है
• bazel-out में अन्य तरह के बिल्ड आउटपुट सेव किए जाते हैं

Bazel, android_binary नियम का इस्तेमाल करके जनरेट की गई Android .apk फ़ाइल को bazel-bin/src/main डायरेक्ट्री में सेव करता है. यहां सबडायरेक्ट्री का नाम src/main, Bazel पैकेज के नाम से लिया जाता है.

कमांड प्रॉम्प्ट पर, इस डायरेक्ट्री का कॉन्टेंट दिखाएं और app.apk फ़ाइल ढूंढें:

ऐप्लिकेशन चलाएं

अब bazel mobile-install कमांड का इस्तेमाल करके, कनेक्ट किए गए Android डिवाइस या एम्युलेटर पर कमांड लाइन से ऐप्लिकेशन को डिप्लॉय किया जा सकता है. यह कमांड, डिवाइस से कम्यूनिकेट करने के लिए Android डीबग ब्रिज (adb) का इस्तेमाल करती है. डिप्लॉयमेंट से पहले, आपको adb का इस्तेमाल करने के लिए अपने डिवाइस को सेट अप करना होगा. इसके लिए, Android Debug Bridge में दिए गए निर्देशों का पालन करें. आपके पास Android Studio में शामिल Android एम्युलेटर पर ऐप्लिकेशन इंस्टॉल करने का विकल्प भी होता है. नीचे दिए गए निर्देश को चलाने से पहले, पक्का करें कि एम्युलेटर चल रहा हो.

नीचे दी गई चीज़ें डालें:

bazel mobile-install //src/main:app

इसके बाद, "Bazel Tutorial App" ढूंढें और उसे लॉन्च करें:

दूसरी इमेज. Bazel ट्यूटोरियल ऐप्लिकेशन.

बधाई हो! आपने अभी-अभी Bazel से बनाया गया अपना पहला Android ऐप्लिकेशन इंस्टॉल किया है.

ध्यान दें कि mobile-install सब-कमांड, --incremental फ़्लैग के साथ भी काम करती है. इसका इस्तेमाल, ऐप्लिकेशन के सिर्फ़ उन हिस्सों को डिप्लॉय करने के लिए किया जा सकता है जिनमें पिछली डिप्लॉयमेंट के बाद बदलाव किया गया है.

यह --start_app फ़्लैग का भी इस्तेमाल करता है, ताकि ऐप्लिकेशन इंस्टॉल होने के तुरंत बाद शुरू हो जाए.

इस बारे में और पढ़ें

ज़्यादा जानकारी के लिए, ये पेज देखें:

• GitHub पर ओपन किए गए मामले
• mobile-install के बारे में ज़्यादा जानकारी
• rules_jvm_external का इस्तेमाल करके, Maven रिपॉज़िटरी से AppCompat, Guava, और JUnit जैसी बाहरी डिपेंडेंसी इंटिग्रेट करें
• robolectric-bazel इंटिग्रेशन का इस्तेमाल करके, Robolectric टेस्ट चलाएं.
• Android इंस्ट्रूमेंटेशन टेस्ट की मदद से अपने ऐप्लिकेशन की जांच करना
• NDK की मदद से, अपने Android ऐप्लिकेशन में C और C++ कोड इंटिग्रेट करना
• Bazel के अन्य उदाहरण प्रोजेक्ट देखें:
  • Kotlin ऐप्लिकेशन
  • Robolectric टेस्टिंग
  • Espresso टेस्टिंग

ऐप बनाने का आनंद लें!