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

किसी समस्या की शिकायत करें सोर्स देखें Nightly · 8.0 . 7.4 . 7.3 · 7.2 · 7.1 · 7.0 · 6.5

इस ट्यूटोरियल में, 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 डाउनलोड करने का तरीका अपनाएं. SDK टूल डाउनलोड करने और अपने एनवायरमेंट को कॉन्फ़िगर करने के लिए, सेटअप विज़र्ड को चलाएं.
  • (ज़रूरी नहीं) 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

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

नाम जगह
Android मेनिफ़ेस्ट फ़ाइलें src/main/AndroidManifest.xml और src/main/java/com/example/bazel/AndroidManifest.xml
Android सोर्स फ़ाइलें src/main/java/com/example/bazel/MainActivity.java और Greeter.java
रिसॉर्स फ़ाइल डायरेक्ट्री src/main/java/com/example/bazel/res/

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

फ़ाइल फ़ोल्डर सेट अप करना

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

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

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

ओएस कमांड
Linux, macOS touch WORKSPACE
Windows (Command Prompt) type nul > WORKSPACE
Windows (PowerShell) New-Item WORKSPACE -ItemType file

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 के SDK मैनेजर का इस्तेमाल करके, इंस्टॉल किए गए SDK टूल का पाथ ढूंढें. अगर SDK टूल डिफ़ॉल्ट जगहों पर इंस्टॉल है, तो ANDROID_HOME वैरिएबल को सेट करने के लिए, इन निर्देशों का इस्तेमाल किया जा सकता है:

ओएस कमांड
Linux export ANDROID_HOME=$HOME/Android/Sdk/
macOS export ANDROID_HOME=$HOME/Library/Android/sdk
Windows (Command Prompt) set ANDROID_HOME=%LOCALAPPDATA%\Android\Sdk
Windows (PowerShell) $env:ANDROID_HOME="$env:LOCALAPPDATA\Android\Sdk"

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

ओएस कमांड
Linux echo "export ANDROID_HOME=$HOME/Android/Sdk/" >> ~/.bashrc
macOS echo "export ANDROID_HOME=$HOME/Library/Android/Sdk/" >> ~/.bashrc
Windows (Command Prompt) setx ANDROID_HOME "%LOCALAPPDATA%\Android\Sdk"
Windows (PowerShell) [System.Environment]::SetEnvironmentVariable('ANDROID_HOME', "$env:LOCALAPPDATA\Android\Sdk", [System.EnvironmentVariableTarget]::User)

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

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 भी डाउनलोड करना होगा. साथ ही, अपनी WORKSPACE फ़ाइल में यह लाइन जोड़कर, Bazel को यह बताना होगा कि उसे यह कोड कहां मिलेगा:

android_ndk_repository(name = "androidndk")

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

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

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

SDK टूल और NDK के लिए, एपीआई लेवल को एक ही वैल्यू पर सेट करना ज़रूरी नहीं है. इस पेज पर, 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_library और android_binary होते हैं. इनका इस्तेमाल, Android ऐप्लिकेशन बनाने के लिए किया जा सकता है.

इस ट्यूटोरियल में, आपको सबसे पहले android_library नियम का इस्तेमाल करके, Bazel को ऐप्लिकेशन के सोर्स कोड और रिसॉर्स फ़ाइलों से Android लाइब्रेरी मॉड्यूल बनाने के लिए कहना होगा. इसके बाद, आपको 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

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 फ़ाइल ढूंढें:

ओएस कमांड
Linux, macOS ls bazel-bin/src/main
Windows (Command Prompt) dir bazel-bin\src\main
Windows (PowerShell) ls bazel-bin\src\main

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

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

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

bazel mobile-install //src/main:app

इसके बाद, "Bazel ट्यूटोरियल ऐप्लिकेशन" ढूंढें और उसे लॉन्च करें:

Bazel ट्यूटोरियल ऐप्लिकेशन

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

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

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

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

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

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

मज़े से बनाएं!