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 वैरिएबल सेट करने के लिए, ये कमांड इस्तेमाल किए जा सकते हैं:

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

path, api_level, और build_tools_version एट्रिब्यूट शामिल करके, Android SDK, एपीआई लेवल, और इस्तेमाल किए जाने वाले बिल्ड टूल के वर्शन का ऐब्सलूट पाथ भी साफ़ तौर पर बताया जा सकता है. अगर 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 नेटिव डेवलपमेंट किट का इस्तेमाल करना लेख पढ़ें.

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

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

BUILD फ़ाइल बनाना

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

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

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

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

android_library नियम जोड़ना

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

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

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

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

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

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

bazel build //src/main:app

The 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 की .apk फ़ाइल को android_binary नियम का इस्तेमाल करके जनरेट करता है और उसे bazel-bin/src/main डायरेक्ट्री में सेव करता है. यहां सबडायरेक्ट्री का नाम src/main Bazel पैकेज के नाम से लिया गया है.

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

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

`bazel mobile-install` कमांड का इस्तेमाल करके, कमांड लाइन से कनेक्ट किए गए Android डिवाइस या एम्युलेटर पर ऐप्लिकेशन डिप्लॉय किया जा सकता है. यह कमांड, डिवाइस से कम्यूनिकेट करने के लिए, Android डीबग ब्रिज (adb) का इस्तेमाल करता है. डिप्लॉयमेंट से पहले, Android Debug Bridge में दिए गए निर्देशों के मुताबिक, आपको adb का इस्तेमाल करने के लिए अपना डिवाइस सेट अप करना होगा. आपके पास 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
• Bazel के उदाहरण के तौर पर, ये प्रोजेक्ट देखें:
  • Kotlin ऐप्लिकेशन
  • Robolectric टेस्टिंग
  • एस्प्रेसो टेस्टिंग

बिल्डिंग के लिए शुभकामनाएं!