नियम
- android_binary
- aar_import
- android_library
- android_platformation_test
- android_local_test
- android_device
- android_ndk_repository
- android_sdk_repository
Android_बाइनरी
नियम का सोर्स देखेंandroid_binary(name, deps, srcs, assets, assets_dir, compatible_with, crunch_png, custom_package, debug_key, debug_signing_keys, debug_signing_lineage_file, densities, deprecation, dex_shards, dexopts, distribs, enable_data_binding, exec_compatible_with, exec_properties, features, incremental_dexing, instruments, javacopts, key_rotation_min_sdk, licenses, main_dex_list, main_dex_list_opts, main_dex_proguard_specs, manifest, manifest_values, multidex, nocompress_extensions, package_id, plugins, proguard_apply_dictionary, proguard_apply_mapping, proguard_generate_mapping, proguard_specs, resource_configuration_filters, resource_files, restricted_to, shrink_resources, tags, target_compatible_with, testonly, visibility)
इससे Android ऐप्लिकेशन पैकेज फ़ाइलें (.apk) बनती हैं.
इंप्लिसिट आउटपुट टारगेट
name.apk
: Android ऐप्लिकेशन पैकेज फ़ाइल, जिसे डीबग कुंजियों और zipaligned से साइन किया गया है, उसका इस्तेमाल आपके ऐप्लिकेशन को डेवलप और डीबग करने के लिए किया जा सकता है. डीबग कुंजियों के साथ साइन इन करने पर, आप अपना ऐप्लिकेशन रिलीज़ नहीं कर सकते.name_unsigned.apk
: फ़ाइल का बिना हस्ताक्षर वाला ऐसा वर्शन जिसे सार्वजनिक तौर पर रिलीज़ करने से पहले, रिलीज़ कुंजियों से साइन किया जा सकता है.name_deploy.jar
: एक Java संग्रह जिसमें इस टारगेट को स्थायी तौर पर बंद किया जाता है.डिप्लॉयमेंट जार में वे सभी क्लास होती हैं जो किसी क्लासलोडर से मिलती हैं. इस क्लासलोडर ने शुरू से आखिर तक, इस टारगेट के रनटाइम क्लासपाथ को खोजा है.
name_proguard.jar
, एक Java संग्रह है जिसमेंname_deploy.jar
पर ProGuard चलाने का नतीजा है. यह आउटपुट सिर्फ़ तब बनाया जाता है, जब proGuard_specs एट्रिब्यूट को बताया गया हो.name_proguard.map
:name_deploy.jar
पर ProGuard चलाने का नतीजा. यह आउटपुट सिर्फ़ तब बनाया जाता है, जब proGuard_specs एट्रिब्यूट के बारे में बताया गया हो और proGuard_generate_mapping या shrink_resources को सेट किया गया हो.
उदाहरण
Android के नियमों के उदाहरण, बेज़ल सोर्स ट्री
की examples/android
डायरेक्ट्री में देखे जा सकते हैं.
तर्क
विशेषताएं | |
---|---|
name |
इस टारगेट के लिए यूनीक नाम. |
deps
|
android_library ,
java_library की android कंस्ट्रेंट के साथ और
cc_library टारगेट शीट के लिए, cc_library नेटिव लाइब्रेरी को रैप या प्रोड्यूस किया जा रहा है.
|
srcs
|
|
assets
|
assets डायरेक्ट्री में मौजूद सभी फ़ाइलों का glob होता है. आपके पास दूसरे नियमों का भी इस्तेमाल करने का विकल्प है. जैसे, कोई फ़ाइल
बनाने के लिए इस्तेमाल किए जाने वाले नियम या अन्य पैकेज में मौजूद फ़ाइलें. हालांकि, ऐसा तब ही हो सकता है, जब उन सभी फ़ाइलों को
उससे जुड़े पैकेज की assets_dir डायरेक्ट्री में देखा जा सकता हो.
|
assets_dir
|
assets में मौजूद फ़ाइलों का पाथ बताती है.
जोड़ी गई assets और assets_dir जोड़ी गई एसेट, पैकेज की गई एसेट के बारे में बताती हैं. दोनों एसेट के बारे में बताया जाना चाहिए या इनमें से कोई नहीं.
|
crunch_png
|
|
custom_package
|
|
debug_key
|
चेतावनी: अपनी प्रोडक्शन कुंजियों का इस्तेमाल न करें, उन्हें पूरी तरह से सुरक्षित रखना चाहिए और उन्हें आपके सोर्स ट्री में नहीं रखना चाहिए. |
debug_signing_keys
|
चेतावनी: अपनी प्रोडक्शन कुंजियों का इस्तेमाल न करें, उन्हें पूरी तरह से सुरक्षित रखना चाहिए और उन्हें आपके सोर्स ट्री में नहीं रखना चाहिए. |
debug_signing_lineage_file
|
चेतावनी: अपनी प्रोडक्शन कुंजियों का इस्तेमाल न करें, उन्हें पूरी तरह से सुरक्षित रखना चाहिए और उन्हें आपके सोर्स ट्री में नहीं रखना चाहिए. |
densities
|
|
dex_shards
|
ध्यान दें कि फ़ाइनल ऐप्लिकेशन में हर शार्ड को कम से कम एक डेक्स मिलेगा. इस वजह से, रिलीज़ बाइनरी के लिए इसे 1 से ज़्यादा पर सेट करने का सुझाव नहीं दिया जाता. |
dexopts
|
|
enable_data_binding
|
डेटा बाइंडिंग वाला Android ऐप्लिकेशन बनाने के लिए, आपको ये काम भी करने होंगे:
|
incremental_dexing
|
|
instruments
|
अगर यह एट्रिब्यूट सेट किया जाता है, तो इस |
javacopts
|
यह कंपाइलर विकल्प, ग्लोबल कंपाइलर विकल्पों के बाद javac में पास कर दिए जाते हैं. |
key_rotation_min_sdk
|
|
main_dex_list
|
android/support/multidex/MultiDex$V19.class android/support/multidex/MultiDex.class android/support/multidex/MultiDexApplication.class com/google/common/base/Objects.class multidex="manual_main_dex" के साथ इस्तेमाल किया जाना चाहिए.
|
main_dex_list_opts
|
|
main_dex_proguard_specs
|
multidex एट्रिब्यूट legacy पर सेट हो.
|
manifest
|
AndroidManifest.xml .
अगर रिसॉर्स_फ़ाइल या एसेट की जानकारी दी गई है, तो वे तय होनी चाहिए.
|
manifest_values
|
|
multidex
|
जितने तरह के प्लेसमेंट हो सकते हैं उनकी जानकारी यहां दी गई है:
|
nocompress_extensions
|
|
package_id
|
ज़्यादा जानकारी के लिए, AAPT2 का |
plugins
|
java_plugin को चलाया जाएगा. प्लग इन से
जनरेट हुए रिसॉर्स को टारगेट के
नतीजे के जार में शामिल किया जाएगा.
|
proguard_apply_dictionary
|
|
proguard_apply_mapping
|
proguard_generate_mapping से जनरेट की गई मैपिंग फ़ाइल.
|
proguard_generate_mapping
|
proguard_specs जनरेट होने पर ही जनरेट होगी. इस फ़ाइल में मूल और अस्पष्ट क्लास, तरीके, और फ़ील्ड के नामों के बीच मैपिंग की सूची होगी.
चेतावनी: अगर इस एट्रिब्यूट का इस्तेमाल किया जाता है, तो ProGuard की खास बातों में |
proguard_specs
|
|
resource_configuration_filters
|
en_XA और/या ar_XB सूडो-लोकेशन शामिल करें.
|
resource_files
|
res डायरेक्ट्री में मौजूद सभी फ़ाइलों का glob होता है.
जनरेट की गई फ़ाइलों (जेनर से) को यहां लेबल से भी रेफ़र किया जा सकता है. सिर्फ़ एक पाबंदी यह है कि जनरेट किए गए आउटपुट उसी " res " डायरेक्ट्री में शामिल होने चाहिए जो किसी दूसरी रिसॉर्स फ़ाइल में शामिल हैं.
|
shrink_resources
|
manifest और resource_files एट्रिब्यूट) का इस्तेमाल करने वाले नियमों के लिए है. साथ ही, इनके लिए ProGuard की ज़रूरत होती है.
यह ज़्यादातर Gradle संसाधन श्रेंडरर (https://developer.android.com/studio/build/shrink-code.html#shrink-resources) की तरह ही काम करता है.
ध्यान देने लायक अंतर:
name_files/resource_shrinker.log भी जनरेट किया जाएगा.
जितनी तरह के साइटमैप हो सकते हैं उनकी जानकारी यहां दी गई है:
|
aar_import
नियम का सोर्स देखेंaar_import(name, deps, data, aar, compatible_with, deprecation, distribs, exec_compatible_with, exec_properties, exports, features, licenses, restricted_to, srcjar, tags, target_compatible_with, testonly, visibility)
इस नियम में, android_library
और android_binary
नियमों के लिए, .aar
फ़ाइलों को लाइब्रेरी के तौर पर इस्तेमाल करने की अनुमति है.
उदाहरण
aar_import( name = "google-vr-sdk", aar = "gvr-android-sdk/libraries/sdk-common-1.10.0.aar", ) android_binary( name = "app", manifest = "AndroidManifest.xml", srcs = glob(["**.java"]), deps = [":google-vr-sdk"], )
तर्क
विशेषताएं | |
---|---|
name |
इस टारगेट के लिए यूनीक नाम. |
aar
|
.aar फ़ाइल, जिसे इस टारगेट पर निर्भर Android टारगेट को उपलब्ध कराना है.
|
exports
|
|
srcjar
|
|
Android लाइब्रेरी
नियम का सोर्स देखेंandroid_library(name, deps, srcs, data, assets, assets_dir, compatible_with, custom_package, deprecation, distribs, enable_data_binding, exec_compatible_with, exec_properties, exported_plugins, exports, exports_manifest, features, idl_import_root, idl_parcelables, idl_preprocessed, idl_srcs, javacopts, licenses, manifest, neverlink, plugins, proguard_specs, resource_files, restricted_to, tags, target_compatible_with, testonly, visibility)
यह नियम अपने स्रोतों को .jar
फ़ाइल में कंपाइल और संग्रहित करता है.
Android रनटाइम लाइब्रेरी android.jar
को सीधे तौर पर
कंपाइलेशन क्लास पाथ पर डाला गया है.
इंप्लिसिट आउटपुट टारगेट
libname.jar
: Java संग्रह.libname-src.jar
(स्रोत जार) वाला संग्रह.name.aar
: एक 'aar' बंडल जिसमें java संग्रह और इस टारगेट के संसाधन हैं. इसमें परिवहन के बंद होने की जानकारी शामिल नहीं होती है.
उदाहरण
Android के नियमों के उदाहरण, बेज़ल सोर्स ट्री
की examples/android
डायरेक्ट्री में देखे जा सकते हैं.
इस उदाहरण में idl_import_root
को सेट करने का तरीका बताया गया है.
//java/bazel/helloandroid/BUILD
में शामिल होने दें:
android_library( name = "parcelable", srcs = ["MyParcelable.java"], # bazel.helloandroid.MyParcelable # MyParcelable.aidl will be used as import for other .aidl # files that depend on it, but will not be compiled. idl_parcelables = ["MyParcelable.aidl"] # bazel.helloandroid.MyParcelable # We don't need to specify idl_import_root since the aidl file # which declares bazel.helloandroid.MyParcelable # is present at java/bazel/helloandroid/MyParcelable.aidl # underneath a java root (java/). ) android_library( name = "foreign_parcelable", srcs = ["src/android/helloandroid/OtherParcelable.java"], # android.helloandroid.OtherParcelable idl_parcelables = [ "src/android/helloandroid/OtherParcelable.aidl" # android.helloandroid.OtherParcelable ], # We need to specify idl_import_root because the aidl file which # declares android.helloandroid.OtherParcelable is not positioned # at android/helloandroid/OtherParcelable.aidl under a normal java root. # Setting idl_import_root to "src" in //java/bazel/helloandroid # adds java/bazel/helloandroid/src to the list of roots # the aidl compiler will search for imported types. idl_import_root = "src", ) # Here, OtherInterface.aidl has an "import android.helloandroid.CallbackInterface;" statement. android_library( name = "foreign_interface", idl_srcs = [ "src/android/helloandroid/OtherInterface.aidl" # android.helloandroid.OtherInterface "src/android/helloandroid/CallbackInterface.aidl" # android.helloandroid.CallbackInterface ], # As above, idl_srcs which are not correctly positioned under a java root # must have idl_import_root set. Otherwise, OtherInterface (or any other # interface in a library which depends on this one) will not be able # to find CallbackInterface when it is imported. idl_import_root = "src", ) # MyParcelable.aidl is imported by MyInterface.aidl, so the generated # MyInterface.java requires MyParcelable.class at compile time. # Depending on :parcelable ensures that aidl compilation of MyInterface.aidl # specifies the correct import roots and can access MyParcelable.aidl, and # makes MyParcelable.class available to Java compilation of MyInterface.java # as usual. android_library( name = "idl", idl_srcs = ["MyInterface.aidl"], deps = [":parcelable"], ) # Here, ServiceParcelable uses and thus depends on ParcelableService, # when it's compiled, but ParcelableService also uses ServiceParcelable, # which creates a circular dependency. # As a result, these files must be compiled together, in the same android_library. android_library( name = "circular_dependencies", srcs = ["ServiceParcelable.java"], idl_srcs = ["ParcelableService.aidl"], idl_parcelables = ["ServiceParcelable.aidl"], )
तर्क
विशेषताएं | |
---|---|
name |
इस टारगेट के लिए यूनीक नाम. |
deps
|
android_library ,
java_library की android कंस्ट्रेंट के साथ और
cc_library टारगेट शीट के लिए, .so नेटिव लाइब्रेरी को रैप या प्रोड्यूस किया जा रहा है.
|
srcs
|
.java या .srcjar फ़ाइलों की सूची
जिन्हें टारगेट बनाने के लिए प्रोसेस किया जाता है.
अगर |
assets
|
assets डायरेक्ट्री में मौजूद सभी फ़ाइलों का glob होता है. आपके पास दूसरे नियमों का भी इस्तेमाल करने का विकल्प है. जैसे, कोई फ़ाइल
बनाने के लिए इस्तेमाल किए जाने वाले नियम या अन्य पैकेज में मौजूद फ़ाइलें. हालांकि, ऐसा तब ही हो सकता है, जब उन सभी फ़ाइलों को
उससे जुड़े पैकेज की assets_dir डायरेक्ट्री में देखा जा सकता हो.
|
assets_dir
|
assets में मौजूद फ़ाइलों का पाथ बताती है.
जोड़ी गई assets और assets_dir जोड़ी गई एसेट, पैकेज की गई एसेट के बारे में बताती हैं. दोनों एसेट के बारे में बताया जाना चाहिए या इनमें से कोई नहीं.
|
custom_package
|
|
enable_data_binding
|
डेटा बाइंडिंग वाला Android ऐप्लिकेशन बनाने के लिए, आपको ये काम भी करने होंगे:
|
exported_plugins
|
java_plugin की सूची (उदाहरण के लिए, एनोटेशन प्रोसेसर) जो सीधे इस लाइब्रेरी पर निर्भर करती हैं.
|
exports
|
exports एट्रिब्यूट से जिन नियमों को बंद किया गया है वे सीधे तौर पर exports टारगेट पर निर्भर किसी भी नियम की डिपेंडेंसी माने जाते हैं.
|
exports_manifest
|
android_binary टारगेट में
मेनिफ़ेस्ट एंट्री एक्सपोर्ट करनी हैं या नहीं. uses-permissions एट्रिब्यूट कभी भी एक्सपोर्ट नहीं किए जाते.
|
idl_import_root
|
इस पाथ का इस्तेमाल, इंपोर्ट किए गए रूट के तौर पर किया जाएगा. हालांकि, इसका इस्तेमाल इस लाइब्रेरी पर निर्भर idl स्रोतों को प्रोसेस करते समय किया जाएगा. जब उदाहरण देखें. |
idl_parcelables
|
android_library टारगेट के लिए इंपोर्ट के तौर पर उपलब्ध कराई जाएंगी जो इस लाइब्रेरी पर निर्भर करता है.
इसके अलावा, इन्हें सीधे तौर पर या सीधे तौर पर बंद करने की सुविधा से भी एक्सपोर्ट किया जा सकता है. हालांकि, न तो इन्हें
न ही Java या कंपाइल किया जा सकता है.
सिर्फ़ वे सहायक कंपाइलर उन्हें ढूंढ सकें, इसके लिए उन्हें सही ढंग से रखना चाहिए. इसका मतलब जानने के लिए, idl_import_root का ब्यौरा देखें. |
idl_preprocessed
|
android_library टारगेट के लिए इंपोर्ट के तौर पर उपलब्ध कराई जाएंगी जो इस लाइब्रेरी पर निर्भर करता है.
इसके अलावा, इन्हें सीधे तौर पर या सीधे तौर पर बंद करने की सुविधा से भी एक्सपोर्ट किया जा सकता है. हालांकि, न तो इन्हें
न ही Java या कंपाइल किया जा सकता है.
पहले से प्रोसेस की गई ऐसी |
idl_srcs
|
srcs के कॉन्टेंट के साथ कंपाइल किया जाएगा.
ये फ़ाइलें, ऐसे सहायक कंपाइलर उन्हें ढूंढ सकें, इसके लिए उन्हें सही ढंग से रखना चाहिए. इसका मतलब जानने के लिए, idl_import_root का ब्यौरा देखें. |
javacopts
|
यह कंपाइलर विकल्प, ग्लोबल कंपाइलर विकल्पों के बाद javac में पास कर दिए जाते हैं. |
manifest
|
AndroidManifest.xml .
अगर रिसॉर्स_फ़ाइल या एसेट की जानकारी दी गई है, तो वे तय होनी चाहिए.
|
neverlink
|
neverlink के तौर पर मार्क किए गए नियम के आउटपुट का इस्तेमाल .apk बनाने के लिए नहीं किया जाएगा. अगर लाइब्रेरी एक्ज़ीक्यूशन के दौरान रनटाइम एनवायरमेंट से उपलब्ध कराई जाए, तो
यह काम का है.
|
plugins
|
java_plugin को चलाया जाएगा. प्लग इन से
जनरेट हुए रिसॉर्स को टारगेट के
नतीजे के जार में शामिल किया जाएगा.
|
proguard_specs
|
android_binary टारगेट में जोड़ा जाएगा.
यहां शामिल फ़ाइलों में समान नियम, जैसे -dontnote, -dontwardn,
माना जाने वाले असर, और -keep से शुरू होने वाले नियम होने चाहिए. अन्य विकल्प, सिर्फ़
android_binary की ProGuard_specs में दिख सकते हैं, ताकि यह पक्का किया जा सके कि बिना मर्ज वाले वाहनों को मर्ज किया जा सके.
|
resource_files
|
res डायरेक्ट्री में मौजूद सभी फ़ाइलों का glob होता है.
जनरेट की गई फ़ाइलों (जेनर से) को यहां लेबल से भी रेफ़र किया जा सकता है. सिर्फ़ एक पाबंदी यह है कि जनरेट किए गए आउटपुट उसी " res " डायरेक्ट्री में शामिल होने चाहिए जो किसी दूसरी रिसॉर्स फ़ाइल में शामिल हैं.
|
Android_platform_test
नियम का सोर्स देखेंandroid_instrumentation_test(name, data, args, compatible_with, deprecation, distribs, env, env_inherit, exec_compatible_with, exec_properties, features, flaky, licenses, local, restricted_to, shard_count, size, support_apks, tags, target_compatible_with, target_device, test_app, testonly, timeout, toolchains, visibility)
android_instrumentation_test
नियम Android के इंस्ट्रूमेंटेशन टेस्ट चलाता है. यह एक एम्युलेटर को शुरू करेगा, जिस ऐप्लिकेशन की जांच की जा रही है, टेस्ट ऐप्लिकेशन, और कोई भी दूसरा ज़रूरी ऐप्लिकेशन इंस्टॉल करेगा और
टेस्ट पैकेज में बताए गए टेस्ट चलाएगा.
test_app एट्रिब्यूट,
android_binary
की जानकारी देता है, जिसमें टेस्ट शामिल होता है. ऐसा करने पर, android_binary
इंस्टेंस एट्रिब्यूट की मदद से, android_binary
ऐप्लिकेशन की जांच में शामिल हो रहा है.
उदाहरण
# java/com/samples/hello_world/BUILD android_library( name = "hello_world_lib", srcs = ["Lib.java"], manifest = "LibraryManifest.xml", resource_files = glob(["res/**"]), ) # The app under test android_binary( name = "hello_world_app", manifest = "AndroidManifest.xml", deps = [":hello_world_lib"], )
# javatests/com/samples/hello_world/BUILD android_library( name = "hello_world_test_lib", srcs = ["Tests.java"], deps = [ "//java/com/samples/hello_world:hello_world_lib", ... # test dependencies such as Espresso and Mockito ], ) # The test app android_binary( name = "hello_world_test_app", instruments = "//java/com/samples/hello_world:hello_world_app", manifest = "AndroidManifest.xml", deps = [":hello_world_test_lib"], ) android_instrumentation_test( name = "hello_world_uiinstrumentation_tests", target_device = ":some_target_device", test_app = ":hello_world_test_app", )
तर्क
विशेषताएं | |
---|---|
name |
इस टारगेट के लिए यूनीक नाम. |
support_apks
|
|
target_device
|
वह android_device जिस पर टेस्ट चलाया जाना चाहिए. पहले से चल रहे या किसी फ़िज़िकल डिवाइस पर एम्युलेटर पर टेस्ट चलाने के लिए, इन तर्कों का इस्तेमाल करें:
|
test_app
|
android_binary टारगेट को यह बताना होगा कि वह अपनी instruments विशेषता के ज़रिए किस टारगेट की जांच कर रहा है.
|
Android_टेस्ट करें
नियम का सोर्स देखेंandroid_local_test(name, deps, srcs, data, args, compatible_with, custom_package, densities, deprecation, enable_data_binding, env, env_inherit, exec_compatible_with, exec_properties, features, flaky, javacopts, jvm_flags, licenses, local, manifest, manifest_values, nocompress_extensions, plugins, resource_configuration_filters, resource_jars, resource_strip_prefix, restricted_to, runtime_deps, shard_count, size, stamp, tags, target_compatible_with, test_class, testonly, timeout, toolchains, use_launcher, visibility)
यह नियम, डिवाइस पर लागू होने वाले नियमों के बजाय, android_library
नियमों को लागू करने के लिए है.
यह Android Robolectric के टेस्ट फ़्रेमवर्क के साथ काम करता है.
Robolectric के टेस्ट लिखने के बारे में विवरण के लिए Android Robolectric साइट
देखें.
इंप्लिसिट आउटपुट टारगेट
name.jar
: टेस्ट का Java संग्रह.name-src.jar
(स्रोत जार) वाला संग्रह.name_deploy.jar
डिप्लॉयमेंट के लिए सही Java डिप्लॉयमेंट को संग्रहित किया गया है (सिर्फ़ तब बनाया गया, जब साफ़ तौर पर अनुरोध किया गया हो).
उदाहरण
android_local_test
के साथ Robolectric का इस्तेमाल करने के लिए, अपनी WORKSPACE
फ़ाइल में Robolectric का डेटा स्टोर करने की जगह जोड़ें:
http_archive( name = "robolectric", urls = ["https://github.com/robolectric/robolectric-bazel/archive/<COMMIT>.tar.gz"], strip_prefix = "robolectric-bazel-<COMMIT>", sha256 = "<HASH>", ) load("@robolectric//bazel:robolectric.bzl", "robolectric_repositories") robolectric_repositories()इससे Robolectric के लिए ज़रूरी
maven_jar
नियम लागू हो जाते हैं.
इसलिए, हर android_local_test
नियम
@robolectric//bazel:robolectric
पर निर्भर होना चाहिए. नीचे उदाहरण देखें।
android_local_test( name = "SampleTest", srcs = [ "SampleTest.java", ], manifest = "LibManifest.xml", deps = [ ":sample_test_lib", "@robolectric//bazel:android-all", ], ) android_library( name = "sample_test_lib", srcs = [ "Lib.java", ], resource_files = glob(["res/**"]), manifest = "AndroidManifest.xml", )
तर्क
विशेषताएं | |
---|---|
name |
इस टारगेट के लिए यूनीक नाम. |
deps
|
|
srcs
|
बाकी सभी फ़ाइलों को तब तक अनदेखा किया जाता है, जब तक ऊपर बताई गई फ़ाइल टाइप की कम से कम एक फ़ाइल मौजूद हो. ऐसा न करने पर, गड़बड़ी के बारे में बताया जाता है.
अगर |
custom_package
|
test_class का भी इस्तेमाल करना पड़ सकता है.
|
densities
|
|
enable_data_binding
|
|
javacopts
|
यह कंपाइलर विकल्प, ग्लोबल कंपाइलर विकल्पों के बाद javac में पास कर दिए जाते हैं. |
jvm_flags
|
Java बाइनरी के लिए रैपर स्क्रिप्ट में एक classPATH परिभाषा (सभी निर्भर जार ढूंढने के लिए) शामिल होती है और सही Java इंटरप्रेटर को शुरू करती है.
रैपर स्क्रिप्ट से जनरेट होने वाली कमांड लाइन में मुख्य क्लास का नाम शामिल होता है और उसके बाद ध्यान दें कि इस एट्रिब्यूट का |
manifest
|
AndroidManifest.xml .
अगर संसाधन_फ़ाइलें या एसेट तय किए गए हैं या उनकी जांच में शामिल लाइब्रेरी के किसी भी मेनिफ़ेस्ट में minSdkVersion टैग मौजूद है, तो उनकी जानकारी दी जाएगी.
|
manifest_values
|
applicationId , versionCode , versionName ,
minSdkVersion , targetSdkVersion , और maxSdkVersion , मेनिफ़ेस्ट के भी एट्रिब्यूट को बदल देंगे. साथ ही,
sdk टैग का इस्तेमाल करेंगे. packageName को नज़रअंदाज़ कर दिया जाएगा. साथ ही, मेनिफ़ेस्ट में पैकेज के बारे में बताए जाने पर, उसे applicationId से सेट कर दिया जाएगा.
मेनिफ़ेस्ट_वैल्यू का इस्तेमाल करने के लिए, नियम पर मेनिफ़ेस्ट ज़रूरी नहीं है.
|
nocompress_extensions
|
|
plugins
|
java_plugin चलेगा. लाइब्रेरी, exported_plugins का इस्तेमाल करने वाली डिपेंडेंसी से भी प्लग इन इनहेरिट कर सकती है. प्लग इन से
जनरेट हुए रिसॉर्स, इस नियम के नतीजे वाले जार में शामिल हो जाएंगे.
|
resource_configuration_filters
|
|
resource_jars
|
|
resource_strip_prefix
|
अगर बताया गया हो, तो इस पाथ प्रीफ़िक्स को |
runtime_deps
|
deps की तरह, ये रनटाइम क्लास पाथ पर दिखेंगे. हालांकि, इनकी तरह कंपाइल होने के समय वाले क्लास पाथ पर ये नहीं दिखेंगे. यहां रनटाइम के हिसाब से सभी डिपेंडेंसी यहां दी जानी चाहिए. डिपेंडेंसी-विश्लेषण टूल को runtime_deps और deps , दोनों में दिखने वाले टारगेट को अनदेखा करना चाहिए.
|
stamp
|
स्टैंप वाली बाइनरी को तब तक नहीं बनाया जाता, जब तक उनकी डिपेंडेंसी बदल जाती हैं. |
test_class
|
यह एट्रिब्यूट, उस Java क्लास का नाम बताता है जिसे जांच के लिए चलाया जाना है. इसे सेट करना बहुत कम होता है. अगर यह आर्ग्युमेंट मिटाया जाता है, तो उस |
use_launcher
|
अगर इस एट्रिब्यूट को 'गलत है' पर सेट किया जाता है, तो
लॉन्चर एट्रिब्यूट और इससे जुड़े
|
Android डिवाइस
नियम का सोर्स देखेंandroid_device(name, cache, compatible_with, default_properties, deprecation, distribs, exec_compatible_with, exec_properties, features, horizontal_resolution, licenses, platform_apks, ram, restricted_to, screen_density, system_image, tags, target_compatible_with, testonly, vertical_resolution, visibility, vm_heap)
यह नियम, दिए गए निर्देशों के मुताबिक कॉन्फ़िगर किया गया Android एम्युलेटर बनाता है. इस एम्युलेटर को बेज़ल रन कमांड से या जनरेट की गई स्क्रिप्ट को सीधे लागू करके शुरू किया जा सकता है. हमारी सलाह है कि आप अपने डिवाइस के नियमों के बजाय, मौजूदा android_device के नियमों का इस्तेमाल करें.
यह नियम बेज़ल टेस्ट और ब्लेज़ रन के लिए --run_under फ़्लैग के लिए सही टारगेट है. यह एक एम्युलेटर शुरू करता है, टेस्ट किए जा रहे/एम्युलेटर को चलाए जा रहे टारगेट को कॉपी करता है और इसकी जांच करता है या इसे सही तरीके से चलाता है.
अगर दिया गया
system_image X86 आधारित है और इसे ज़्यादातर
I686 सीपीयू आर्किटेक्चर के लिए ऑप्टिमाइज़ किया गया है, तो android_device
केवीएम इमेज बनाने में मदद करता है. केवीएम का इस्तेमाल करने के लिए, android_device
नियम में tags = ['requires-kvm']
जोड़ें.
इंप्लिसिट आउटपुट टारगेट
name_images/userdata.dat
: एम्युलेटर को शुरू करने के लिए, इमेज फ़ाइलें और स्नैपशॉट शामिल हैंname_images/emulator-meta-data.pb
: इसमें सीरियल नंबर को एम्युलेटर को पास करने के लिए ज़रूरी जानकारी शामिल होती है.
उदाहरण
नीचे दिए गए उदाहरण में, android_device को इस्तेमाल करने का तरीका बताया गया है.
//java/android/helloandroid/BUILD
में शामिल है
android_device( name = "nexus_s", cache = 32, default_properties = "nexus_s.properties", horizontal_resolution = 480, ram = 512, screen_density = 233, system_image = ":emulator_images_android_16_x86", vertical_resolution = 800, vm_heap = 32, ) filegroup( name = "emulator_images_android_16_x86", srcs = glob(["androidsdk/system-images/android-16/**"]), )
//java/android/helloandroid/nexus_s.properties
में शामिल है:
ro.product.brand=google ro.product.device=crespo ro.product.manufacturer=samsung ro.product.model=Nexus S ro.product.name=soju
इस नियम से इमेज और एक स्टार्ट स्क्रिप्ट जनरेट होगी. bazel यहां लागू करके एम्युलेटर शुरू कर सकते हैं :nexus_s -- --action=start. स्क्रिप्ट में ये फ़्लैग दिखते हैं:
- --adb_port: adb जिस पर दिखाना है. अगर आप एम्युलेटर को adb निर्देश देना चाहते हैं, तो आप इस पोर्ट से adb कनेक्ट करेंगे.
- --emulator_port: एम्युलेटर का टेलनेट मैनेजमेंट कंसोल चालू करने वाला पोर्ट.
- --enable_display: सही होने पर एम्युलेटर को डिसप्ले से शुरू करता है (डिफ़ॉल्ट तौर पर गलत).
- --action: शुरू करें या बंद करें.
- --apks_to_install: एम्युलेटर पर इंस्टॉल किए जाने वाले apk की सूची.
तर्क
विशेषताएं | |
---|---|
name |
इस टारगेट के लिए यूनीक नाम. |
cache
|
|
default_properties
|
|
horizontal_resolution
|
|
platform_apks
|
|
ram
|
|
screen_density
|
|
system_image
|
|
vertical_resolution
|
|
vm_heap
|
|
android_ndk_repository
नियम का सोर्स देखेंandroid_ndk_repository(name, api_level, path, repo_mapping)
Bazel को नेटिव कोड के साथ Android टारगेट बनाने के लिए, Android NDK का इस्तेमाल करने के लिए कॉन्फ़िगर करता है.
ध्यान दें कि android_ndk_repository
को लागू करने की जगह Starlark पर लागू की जा रही है. NDK के भविष्य के वर्शन 25 और उसके बाद वाले वर्शन के लिए सहायता
को android_ndk_repository
के Starlark वर्शन में लागू किया जाएगा. Starlark
वर्शन के लिए
rule_android_ndk देखें.
ध्यान रखें कि Android के लिए बिल्डिंग बनाने के लिए, आपकी WORKSPACE
फ़ाइल में android_sdk_repository
का नियम होना भी ज़रूरी है.
ज़्यादा जानकारी के लिए, Bzel के साथ Android NDK का इस्तेमाल करने के बारे में पूरा दस्तावेज़ पढ़ें.
उदाहरण
android_ndk_repository( name = "androidndk", )
ऊपर दिया गया उदाहरण, $ANDROID_NDK_HOME
से आपके Android NDK का पता लगाएगा. साथ ही, यह इसमें काम करने वाले सबसे
एपीआई लेवल का भी पता लगाएगा.
android_ndk_repository( name = "androidndk", path = "./android-ndk-r20", api_level = 24, )
ऊपर दिया गया उदाहरण, ./android-ndk-r20
में आपके फ़ाइल फ़ोल्डर में मौजूद Android एनडीके का इस्तेमाल करेगा. आपका JNI कोड कंपाइल करते समय, यह एपीआई लेवल 24 लाइब्रेरी
का इस्तेमाल करेगा.
सीपीयू की सुविधाएं
Android NDK में, cpufeatures लाइब्रेरी की सुविधा होती है. इसका इस्तेमाल रनटाइम के दौरान, डिवाइस के सीपीयू का पता लगाने के लिए किया जा सकता है. नीचे दिए गए उदाहरण में Bazel के साथ सीपीयू की सुविधाओं को इस्तेमाल करने का तरीका बताया गया है.
# jni.cc #include "ndk/sources/android/cpufeatures/cpu-features.h" ...
# BUILD cc_library( name = "jni", srcs = ["jni.cc"], deps = ["@androidndk//:cpufeatures"], )
तर्क
विशेषताएं | |
---|---|
name |
इस टारगेट के लिए यूनीक नाम. |
api_level
|
|
path
|
$ANDROID_NDK_HOME एनवायरमेंट वैरिएबल सेट करना ज़रूरी है.
Android एनडीके को Android डेवलपर साइट से डाउनलोड किया जा सकता है. |
repo_mapping
|
उदाहरण के लिए, एंट्री |
Android_sdk_Repository
नियम का सोर्स देखेंandroid_sdk_repository(name, api_level, build_tools_version, path, repo_mapping)
Android टारगेट को बनाने में मदद करने के लिए, स्थानीय Android SDK का इस्तेमाल करने के लिए, Bazel को कॉन्फ़िगर करता है.
उदाहरण
Bazel के लिए Android SDK टूल सेट अप करने के लिए, सबसे ज़रूरी यह है कि आपWORKSPACE
फ़ाइल में "androidsdk" नाम का android_sdk_repository
नियम रखें और $ANDROID_HOME
परिवेश वैरिएबल को अपने Android SDK टूल के पाथ पर सेट करें. Bazel सबसे ऊंचे Android API लेवल का
उपयोग करेगा और डिफ़ॉल्ट रूप से Android SDK में इंस्टॉल किए गए टूल वर्शन का उपयोग करेगा.
android_sdk_repository( name = "androidsdk", )
फिर से जनरेट किए जा सकने वाले बिल्ड को पक्का करने के लिए, path
, api_level
, और
build_tools_version
एट्रिब्यूट को खास वैल्यू पर सेट किया जा सकता है. अगर Android SDK टूल में, एपीआई लेवल या बिल्ड टूल का वर्शन इंस्टॉल नहीं किया गया है, तो यह वर्शन काम नहीं करेगा.
android_sdk_repository( name = "androidsdk", path = "./sdk", api_level = 19, build_tools_version = "25.0.0", )
ऊपर दिया गया उदाहरण, Android SDK के फ़ाइल फ़ोल्डर से जुड़े पाथ का इस्तेमाल करने के बारे में भी बताता है. अगर Android SDK टूल, आपके Bazel Workspace का हिस्सा है, तो यह तरीका आपके काम का होता है. उदाहरण के लिए, अगर SDK टूल को वर्शन कंट्रोल में चुना गया है.
लाइब्रेरी की मदद करें
सहायता लाइब्रेरी, Android SDK Manager में "Android Support Repository" के तौर पर उपलब्ध हैं.
यह Android की सामान्य लाइब्रेरी का वर्शन है, जैसे कि Support और AppCompat लाइब्रेरी.
इसे स्थानीय Maven के डेटा स्टोर करने की जगह के तौर पर पैक किया जाता है. android_sdk_repository
, इनमें से हर लाइब्रेरी के लिए Bazel टारगेट जनरेट करता है. इनका इस्तेमाल android_binary
और android_library
टारगेट की डिपेंडेंसी में किया जा सकता है.
जनरेट किए गए टारगेट के नाम Android सहायता डेटा संग्रह स्थान में लाइब्रेरी के Maven निर्देशांकों से लिए जाते हैं और इन्हें @androidsdk//${group}:${artifact}-${version}
के रूप में फ़ॉर्मैट किया जाता है.
नीचे दिए गए उदाहरण में बताया गया है कि android_library
, वर्शन सात वर्शन वाली Appcompat लाइब्रेरी के 25.0.0 वर्शन के आधार पर कैसे काम कर सकता है.
android_library( name = "lib", srcs = glob(["*.java"]), manifest = "AndroidManifest.xml", resource_files = glob(["res/**"]), deps = ["@androidsdk//com.android.support:appcompat-v7-25.0.0"], )
तर्क
विशेषताएं | |
---|---|
name |
इस टारगेट के लिए यूनीक नाम. |
api_level
|
दिए गए बिल्ड के लिए इस्तेमाल किए गए एपीआई लेवल को
|
build_tools_version
|
Bazel में बिल्ड टूल का 30.0.0 या इसके बाद का वर्शन होना ज़रूरी है. |
path
|
$ANDROID_HOME एनवायरमेंट वैरिएबल सेट करना ज़रूरी है.
Android SDK टूल, Android डेवलपर साइट से डाउनलोड किया जा सकता है. |
repo_mapping
|
उदाहरण के लिए, एंट्री |