इस ट्यूटोरियल में, Bazel का इस्तेमाल करके एक आसान Android ऐप्लिकेशन बनाने का तरीका बताया गया है.
Bazel Android के नियमों का इस्तेमाल करके, Android ऐप्लिकेशन बनाने में मदद करता है.
यह ट्यूटोरियल Windows, macOS, और Linux का इस्तेमाल करने वालों के लिए बनाया गया है. इसके लिए Bazel या Android ऐप्लिकेशन बनाने का अनुभव ज़रूरी नहीं है. इस ट्यूटोरियल में आपको कोई भी Android कोड लिखने की ज़रूरत नहीं है.
आप इन चीज़ों के बारे में जानेंगे
इस ट्यूटोरियल में, ये काम करने के तरीके बताए गए हैं:
- Bazel और Android Studio इंस्टॉल करके, सैंपल प्रोजेक्ट डाउनलोड करके अपना एनवायरमेंट सेट अप करें.
- ऐसा Bazel वर्कस्पेस सेट अप करें जिसमें ऐप्लिकेशन का सोर्स कोड शामिल हो. साथ ही, इसमें एक
WORKSPACE
फ़ाइल शामिल हो, जिससे वर्कस्पेस की डायरेक्ट्री के टॉप लेवल की पहचान की जा सके. - Android SDK जैसी ज़रूरी बाहरी डिपेंडेंसी के रेफ़रंस शामिल करने के लिए,
WORKSPACE
फ़ाइल को अपडेट करें. BUILD
फ़ाइल बनाएं.- Bazel की मदद से ऐप्लिकेशन बनाएं.
- इस ऐप्लिकेशन को Android एम्युलेटर या फ़िज़िकल डिवाइस पर डिप्लॉय करें और चलाएं.
शुरू करने से पहले
Bazel इंस्टॉल करें
ट्यूटोरियल शुरू करने से पहले, यह सॉफ़्टवेयर इंस्टॉल करें:
- Bazel. इंस्टॉल करने के लिए, इंस्टॉल करने के निर्देशों का पालन करें.
- Android Studio. इंस्टॉल करने के लिए, Android Studio डाउनलोड करने का तरीका अपनाएं. SDK टूल डाउनलोड करने और अपना एनवायरमेंट कॉन्फ़िगर करने के लिए, सेटअप विज़र्ड चलाएं.
- (ज़रूरी नहीं) गिट. 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 (कमांड प्रॉम्प्ट) | type nul > WORKSPACE |
Windows (PowerShell) | New-Item WORKSPACE -ItemType file |
रनिंग बैजल
अब आप देख सकते हैं कि 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 (कमांड प्रॉम्प्ट) | 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 (कमांड प्रॉम्प्ट) | setx ANDROID_HOME "%LOCALAPPDATA%\Android\Sdk" |
Windows (PowerShell) | [System.Environment]::SetEnvironmentVariable('ANDROID_HOME', "$env:LOCALAPPDATA\Android\Sdk", [System.EnvironmentVariableTarget]::User) |
आपके पास Android SDK के ऐब्सलूट पाथ, एपीआई लेवल, और बिल्ड टूल के वर्शन की जानकारी भी देने का विकल्प होता है. इसके लिए, path
,
api_level
, और build_tools_version
एट्रिब्यूट शामिल करें. अगर api_level
और
build_tools_version
के बारे में नहीं बताया गया है, तो android_sdk_repository
नियम
SDK टूल में मौजूद सबसे नए वर्शन का इस्तेमाल करेगा. इन एट्रिब्यूट के किसी भी कॉम्बिनेशन के बारे में बताया जा सकता है. हालांकि, इसके लिए ज़रूरी है कि वे 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 एपीआई का ऐसा वर्शन है जिसे SDK टूल और एनडीके
टारगेट करते हैं - उदाहरण के लिए, Android 6.0 के लिए 23 और Android 7.1 के लिए 25. अगर यह नीति पहले से सेट नहीं है, तो android_sdk_repository
और android_ndk_repository
के लिए, api_level
डिफ़ॉल्ट रूप से सबसे ज़्यादा एपीआई लेवल सेट करता है.
SDK टूल और एनडीके के लिए, एपीआई लेवल को एक ही वैल्यू पर सेट करना ज़रूरी नहीं है. इस पेज पर, Android रिलीज़ से लेकर एनडीके के साथ काम करने वाले एपीआई लेवल तक का मैप मौजूद है.
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
सबकमांड, बैजल को उसके बाद वाला टारगेट बनाने का निर्देश देता है. टारगेट को आपकी फ़ाइल फ़ोल्डर डायरेक्ट्री से जुड़े पैकेज पाथ के साथ, 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 (कमांड प्रॉम्प्ट) | dir bazel-bin\src\main |
Windows (PowerShell) | ls bazel-bin\src\main |
ऐप्लिकेशन चलाएं
अब bazel
mobile-install
कमांड का इस्तेमाल करके, कमांड लाइन से ऐप्लिकेशन को कनेक्ट किए गए Android डिवाइस या एम्युलेटर पर डिप्लॉय किया जा सकता है. यह निर्देश, डिवाइस से
कम्यूनिकेशन करने के लिए Android डीबग ब्रिज (adb
) का इस्तेमाल करता है. adb
का इस्तेमाल करने के लिए, आपको डिवाइस को Android डीबग ब्रिज में दिए गए निर्देशों का पालन करके,
डिप्लॉयमेंट से पहले सेट अप करना होगा. आपके पास Android Studio में मौजूद Android एम्युलेटर पर भी ऐप्लिकेशन को इंस्टॉल करने का
विकल्प है. नीचे दिए गए निर्देश को लागू करने से पहले, पक्का करें कि एम्युलेटर चल रहा है.
नीचे दी गई चीज़ें डालें:
bazel mobile-install //src/main:app
इसके बाद, "Bazel ट्यूटोरियल ऐप्लिकेशन" खोजें और लॉन्च करें:
दूसरी इमेज. Bazel ट्यूटोरियल ऐप्लिकेशन.
बधाई हो! आपने हाल ही में, Bazel का बनाया हुआ अपना पहला Android ऐप्लिकेशन इंस्टॉल किया है.
ध्यान दें कि mobile-install
सबकमांड,
--incremental
फ़्लैग के साथ भी काम करता है. इसका इस्तेमाल, ऐप्लिकेशन के सिर्फ़ उन हिस्सों को डिप्लॉय करने के लिए किया जा सकता है जिनमें पिछले डिप्लॉयमेंट के बाद बदलाव हुआ है.
साथ ही, यह ऐप्लिकेशन को इंस्टॉल करने के तुरंत बाद शुरू करने के लिए, --start_app
फ़्लैग के साथ काम करता है.
इसके बारे में और पढ़ें
ज़्यादा जानकारी के लिए, ये पेज देखें:
- GitHub पर समस्याएं खोलें
- मोबाइल-इंस्टॉल के बारे में ज़्यादा जानकारी
- rules_jvm_external की मदद से, Maven रिपॉज़िटरी से AppCompat, Guava, और JUnit जैसी बाहरी डिपेंडेंसी इंटिग्रेट करें
- robolectric-bazel इंटिग्रेशन की मदद से Robolectric टेस्ट करें.
- Android इंस्ट्रुमेंटेशन टेस्ट की मदद से अपने ऐप्लिकेशन की जांच करना
- आपके Android ऐप्लिकेशन में C और C++ कोड को NDK के साथ इंटिग्रेट किया जा रहा है
- Bazel के और उदाहरण प्रोजेक्ट देखें:
इमारत बनाने के लिए शुभकामनाएं!