Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

Play for On-device AI (बीटा वर्शन)

परिचय

Play for On-device AI, कस्टम एमएल मॉडल डिस्ट्रिब्यूशन के लिए, Android ऐप्लिकेशन बंडल और Google Play डिलीवरी के फ़ायदे उपलब्ध कराता है. इससे, डिवाइस के ईकोसिस्टम की जटिलता को कम करके, मॉडल की परफ़ॉर्मेंस को बेहतर बनाया जा सकता है. इसके लिए, आपको कोई अतिरिक्त शुल्क नहीं देना होगा. इसकी मदद से, Play पर एक ही आर्टफ़ैक्ट पब्लिश किया जा सकता है. इसमें आपका कोड, ऐसेट, और मशीन लर्निंग मॉडल शामिल होते हैं. साथ ही, डिलीवरी के कई मोड और टारगेटिंग के विकल्पों में से चुनने की सुविधा मिलती है.

फ़ायदे

Google Play पर एक ही पब्लिशिंग आर्टफ़ैक्ट अपलोड करें. इसके बाद, बिना किसी अतिरिक्त शुल्क के, होस्टिंग, डिलीवरी, अपडेट, और टारगेटिंग की ज़िम्मेदारी Play को सौंपें.
अपने मशीन लर्निंग मॉडल को इंस्टॉल के समय, फ़ास्ट-फ़ॉलो या मांग पर डिलीवर करें.
- इंस्टॉल के समय डिलीवरी की सुविधा से यह पक्का किया जा सकता है कि ऐप्लिकेशन खोले जाने पर, बहुत बड़ा मॉडल मौजूद हो. आपका मॉडल, APK के तौर पर इंस्टॉल हो जाएगा.
- ऐप्लिकेशन इंस्टॉल होने के बाद, फ़ास्ट-फ़ॉलो डिलीवरी बैकग्राउंड में अपने-आप होती है. ऐसा हो सकता है कि उपयोगकर्ता, मॉडल के पूरी तरह से डाउनलोड होने से पहले ही आपका ऐप्लिकेशन खोल लें. आपका मॉडल, आपके ऐप्लिकेशन के इंटरनल स्टोरेज में डाउनलोड हो जाएगा.
- मांग पर डिलीवरी की सुविधा से, रनटाइम के दौरान मॉडल का अनुरोध किया जा सकता है. यह सुविधा तब काम आती है, जब मॉडल की ज़रूरत सिर्फ़ कुछ यूज़र फ़्लो के लिए होती है. आपका मॉडल, आपके ऐप्लिकेशन के इंटरनल स्टोरेज में डाउनलोड हो जाएगा.
अपने एमएल मॉडल के ऐसे वैरिएंट उपलब्ध कराएं जो डिवाइस के मॉडल, सिस्टम प्रॉपर्टी या रैम के आधार पर खास डिवाइसों को टारगेट करते हैं.
Play की अपने-आप पैच करने की सुविधा की मदद से, ऐप्लिकेशन के अपडेट छोटे और ऑप्टिमाइज़ किए जा सकते हैं. इसका मतलब है कि सिर्फ़ फ़ाइलों में हुए बदलावों को डाउनलोड करना होगा.

ज़रूरी बातें

Play for On-device AI का इस्तेमाल करने का मतलब है कि आप Google Play डेवलपर डिस्ट्रिब्यूशन एग्रीमेंट और Play Core सॉफ़्टवेयर डेवलपमेंट किट की सेवा की शर्तों से सहमत हैं.
Play for उपयोगकर्ता के डिवाइस पर AI से डाउनलोड किए गए मॉडल, सिर्फ़ आपके ऐप्लिकेशन इस्तेमाल कर सकते हैं. मॉडल, अन्य ऐप्लिकेशन के लिए उपलब्ध नहीं होने चाहिए.
एआई पैक का साइज़ 1.5 जीबी तक हो सकता है. यह साइज़, कंप्रेस किए गए डाउनलोड साइज़ के आधार पर तय होता है. आपके ऐप्लिकेशन बंडल से जनरेट किए गए किसी भी वर्शन का कुल साइज़, ज़्यादा से ज़्यादा 4 जीबी हो सकता है.
जिन ऐप्लिकेशन का साइज़ 1 जीबी से ज़्यादा है उनके लिए, एसडीके का कम से कम लेवल 21 या इससे ज़्यादा पर सेट करना ज़रूरी है.

Play for उपयोगकर्ता के डिवाइस पर एआई का इस्तेमाल करने का तरीका

Google Play for उपयोगकर्ता के डिवाइस पर AI, एआई पैक का इस्तेमाल करता है. अपने ऐप्लिकेशन बंडल में, एआई पैक में डिस्ट्रिब्यूशन के लिए तैयार कस्टम मॉडल पैकेज किए जाते हैं. आपके पास यह चुनने का विकल्प होता है कि एआई पैक को इंस्टॉल के समय, फ़ास्ट-फ़ॉलो या मांग पर डिलीवर किया जाए.

अपने ऐप्लिकेशन बंडल के साथ एआई पैक को पैकेज करके, Play के सभी मौजूदा टेस्टिंग और रिलीज़ टूल इस्तेमाल किए जा सकते हैं. जैसे, टेस्ट ट्रैक और कुछ लोगों के लिए रिलीज़ करना. इससे, कस्टम मॉडल के साथ अपने ऐप्लिकेशन के डिस्ट्रिब्यूशन को मैनेज किया जा सकता है.

एआई पैक, ऐप्लिकेशन बाइनरी के साथ अपडेट किए जाते हैं. अगर आपके ऐप्लिकेशन की नई रिलीज़ में एआई पैक में कोई बदलाव नहीं किया गया है, तो Google Play की अपने-आप पैच करने की प्रोसेस यह पक्का करेगी कि उपयोगकर्ता को इसे फिर से डाउनलोड न करना पड़े. ऐप्लिकेशन को अपडेट करते समय, Play सिर्फ़ उन चीज़ों को डाउनलोड करेगा जिनमें बदलाव हुआ है.

एआई पैक में सिर्फ़ मॉडल होते हैं. Java/Kotlin और नेटिव लाइब्रेरी इस्तेमाल करने की अनुमति नहीं है. अगर आपको अपने एमएल मॉडल को चलाने के लिए लाइब्रेरी या कोड को शिप करना है, तो उसे बेस मॉड्यूल या फ़ीचर मॉड्यूल में ले जाएं. अपने फ़ीचर मॉड्यूल को कॉन्फ़िगर किया जा सकता है, ताकि उसमें एआई पैक की तरह ही डाउनलोड और टारगेटिंग की सेटिंग हों.

एआई पैक के साथ LiteRT और MediaPipe का इस्तेमाल करना

एआई पैक के साथ LiteRT और MediaPipe का इस्तेमाल किया जा सकता है. अपने मॉडल को एआई पैक में पैकेज करें. इसके बाद, इंस्टॉल के समय डाउनलोड होने वाले पैक या फ़ास्ट-फ़ॉलो और मांग पर डाउनलोड होने वाले पैक के लिए दिए गए निर्देशों का इस्तेमाल करके, इसे ऐक्सेस करें.

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

LiteRT का इस्तेमाल शुरू करना
- सैंपल के तौर पर मिले ऐप्लिकेशन से पता चलता है कि एआई पैक में LiteRT मॉडल को कैसे पैकेज किया जा सकता है और उसे रनटाइम के दौरान कैसे लोड किया जा सकता है.
- एआई पैक में इस्तेमाल करने के लिए, पहले से ट्रेन किए गए कई LiteRT मॉडल उपलब्ध हैं.
MediaPipe का इस्तेमाल शुरू करना
- फ़ास्ट-फ़ॉलो और मांग पर पैक के लिए, अपनी ऐसेट लोड करने के लिए AssetCache.java का इस्तेमाल किया जा सकता है. उदाहरण के लिए, .binarypb फ़ाइलें) को उनके फ़ाइल पाथ के हिसाब से इंपोर्ट किया जा सकता है.
- इंस्टॉल के समय डाउनलोड होने वाले ऐसेट पैक के लिए, AndroidAssetUtil.java का इस्तेमाल किया जा सकता है.

एआई पैक का इस्तेमाल शुरू करना

Play for उपयोगकर्ता के डिवाइस पर AI का इस्तेमाल शुरू करने का तरीका यहां बताया गया है:

अपने मॉडल को एआई पैक में पैकेज करें और उन्हें Android ऐप्लिकेशन बंडल में शामिल करें. साथ ही, यह बताएं कि एआई पैक कैसे डिलीवर किए जाने चाहिए.
[ज़रूरी नहीं] अगर आपको अलग-अलग डिवाइसों पर अलग-अलग मॉडल उपलब्ध कराने हैं, तो अपने एआई पैक के लिए डिवाइस टारगेटिंग को कॉन्फ़िगर किया जा सकता है. उदाहरण के लिए, किसी खास डिवाइस मॉडल पर एआई पैक A और कम से कम 6 जीबी रैम वाले डिवाइसों पर एआई पैक B डिलीवर किया जा सकता है. साथ ही, अन्य सभी डिवाइसों पर कोई मॉडल डिलीवर नहीं किया जा सकता.
[ज़रूरी नहीं] अगर ऑन-डिमांड या फ़ास्ट-फ़ॉलो डिलीवरी का इस्तेमाल किया जा रहा है, तो अपने ऐप्लिकेशन में Play एआई डिलीवरी लाइब्रेरी को इंटिग्रेट करें. इससे ज़रूरत के हिसाब से एआई पैक डाउनलोड किए जा सकेंगे.
अपने ऐप्लिकेशन बंडल को टेस्ट करें और Google Play पर रिलीज़ करें.

Android Gradle प्लगिन का वर्शन देखना

एआई पैक इस्तेमाल करने के लिए, पक्का करें कि आपके Android Gradle प्लगिन (AGP) का वर्शन कम से कम 8.8 हो. यह वर्शन, Android Studio Ladybug 2 के साथ पैकेज किया गया है.

अपने मॉडल को एआई पैक में एक्सट्रैक्ट करना

यहां बताए गए तरीके के लिए, Android Studio की ज़रूरत नहीं है.

अपने प्रोजेक्ट की टॉप-लेवल डायरेक्ट्री में, एआई पैक के लिए एक डायरेक्ट्री बनाएं. इस डायरेक्ट्री के नाम का इस्तेमाल, एआई पैक के नाम के तौर पर किया जाता है. एआई पैक के नाम किसी अक्षर से शुरू होने चाहिए. इनमें सिर्फ़ अक्षर, संख्याएं, और अंडरस्कोर शामिल हो सकते हैं.
एआई पैक डायरेक्ट्री में, build.gradle फ़ाइल बनाएं और यह कोड जोड़ें. एआई पैक का नाम और सिर्फ़ एक डिलीवरी टाइप बताना न भूलें:
```
// In the AI pack's build.gradle file:
plugins {
  id 'com.android.ai-pack'
}

aiPack {
    packName = "ai-pack-name" // Directory name for the AI pack
    dynamicDelivery {
        deliveryType = "[ install-time | fast-follow | on-demand ]"
    }
}
```
प्रोजेक्ट की ऐप्लिकेशन build.gradle फ़ाइल में, अपने प्रोजेक्ट में मौजूद हर एआई पैक का नाम जोड़ें. इसके लिए, यहां दिया गया तरीका अपनाएं:
```
// In the app build.gradle file:
android {
    ...
    assetPacks = [":ai-pack-name", ":ai-pack2-name"]
}
```
प्रोजेक्ट की settings.gradle फ़ाइल में, अपने प्रोजेक्ट के सभी एआई पैक शामिल करें. इसके लिए, यहां दिया गया तरीका अपनाएं:
```
// In the settings.gradle file:
include ':app'
include ':ai-pack-name'
include ':ai-pack2-name'
```
अपने एआई पैक में, src/main/assets/ डायरेक्ट्री बनाएं.
अपने मॉडल को src/main/assets डायरेक्ट्री में रखें. यहां सबडायरेक्ट्री भी बनाई जा सकती हैं. आपके ऐप्लिकेशन की डायरेक्ट्री का स्ट्रक्चर अब ऐसा दिखना चाहिए:
- build.gradle
- settings.gradle
- app/
- ai-pack-name/build.gradle
- ai-pack-name/src/main/assets/your-model-directories
अपने मॉडल लोड करने और चलाने के लिए कोड जोड़ें. यह इस बात पर निर्भर करेगा कि एआई पैक की डिलीवरी किस मोड में की जा रही है. इंस्टॉल के समय और फ़ास्ट-फ़ॉलो/मांग पर ऐसेट पैक डिलीवर करने के निर्देश नीचे देखें.
[ज़रूरी नहीं] अलग-अलग डिवाइसों पर अलग-अलग मॉडल डिलीवर करने के लिए, डिवाइस टारगेटिंग को कॉन्फ़िगर करें.
Gradle की मदद से Android ऐप्लिकेशन बंडल बनाना. जनरेट किए गए ऐप्लिकेशन बंडल में, रूट-लेवल डायरेक्ट्री में अब ये चीज़ें शामिल हैं:
- ai-pack-name/manifest/AndroidManifest.xml: एआई पैक के आइडेंटिफ़ायर और डिलीवरी मोड को कॉन्फ़िगर करता है
- ai-pack-name/assets/your-model-directories: वह डायरेक्ट्री जिसमें एआई पैक के तौर पर डिलीवर की गई सभी ऐसेट शामिल हैं
Gradle, हर एआई पैक के लिए मेनिफ़ेस्ट जनरेट करता है और आपके लिए assets/ डायरेक्ट्री को आउटपुट करता है.

इंस्टॉल के समय डिलीवरी की सुविधा कॉन्फ़िगर करना

इंस्टॉल-टाइम के तौर पर कॉन्फ़िगर किए गए एआई पैक, ऐप्लिकेशन लॉन्च होने पर तुरंत उपलब्ध हो जाते हैं. इस मोड में उपलब्ध एआई पैक को ऐक्सेस करने के लिए, Java AssetManager API का इस्तेमाल करें:

import android.content.res.AssetManager;
...
Context context = createPackageContext("com.example.app", 0);
AssetManager assetManager = context.getAssets();
InputStream is = assetManager.open("model-name");

फ़ास्ट-फ़ॉलो और मांग पर डिलीवरी की सुविधा कॉन्फ़िगर करना

फ़ास्ट-फ़ॉलो या मांग पर डिलीवरी की सुविधा के साथ एआई पैक डाउनलोड करने के लिए, Play AI Delivery Library का इस्तेमाल करें.

Play AI Delivery Library पर डिपेंडेंसी का एलान करना

अपने ऐप्लिकेशन की build.gradle फ़ाइल में, Play AI Delivery लाइब्रेरी पर डिपेंडेंसी का एलान करें:

dependencies {
  ...
  implementation "com.google.android.play:ai-delivery:0.1.1-alpha01"
}

स्टेटस देखें

हर एआई पैक, ऐप्लिकेशन के इंटरनल स्टोरेज में एक अलग फ़ोल्डर में सेव होता है. किसी एआई पैक के रूट फ़ोल्डर का पता लगाने के लिए, getPackLocation() तरीके का इस्तेमाल करें. इस तरीके से ये वैल्यू मिलती हैं:

रिटर्न वैल्यू	स्थिति
एक मान्य `AiPackLocation` ऑब्जेक्ट	एआई पैक का रूट फ़ोल्डर, `assetsPath()` पर तुरंत ऐक्सेस करने के लिए तैयार है
`null`	एआई पैक के बारे में जानकारी नहीं है या एआई पैक उपलब्ध नहीं हैं

एआई पैक डाउनलोड करने के बारे में जानकारी पाना

getPackStates() तरीके का इस्तेमाल करके, डाउनलोड किए जाने वाले पैक का साइज़ पता करें. साथ ही, यह भी देखें कि पैक पहले से डाउनलोड हो रहा है या नहीं.

Task<AiPackStates> getPackStates(List<String> packNames)

getPackStates() एक एसिंक्रोनस तरीका है, जो Task<AiPackStates> दिखाता है. AiPackStates ऑब्जेक्ट का packStates() तरीका, Map<String, AiPackState> दिखाता है. इस मैप में, अनुरोध किए गए हर एआई पैक की स्थिति की जानकारी होती है. इसे पैक के नाम के हिसाब से व्यवस्थित किया जाता है:

Map<String, AiPackState> AiPackStates#packStates()

फ़ाइनल अनुरोध यहां दिखाया गया है:

final String aiPackName = "myAiPackName";

aiPackManager
    .getPackStates(Collections.singletonList(aiPackName))
    .addOnCompleteListener(new OnCompleteListener<AiPackStates>() {
        @Override
        public void onComplete(Task<AiPackStates> task) {
            AiPackStates aiPackStates;
            try {
                aiPackStates = task.getResult();
                AiPackState aiPackState =
                    aiPackStates.packStates().get(aiPackName);
            } catch (RuntimeExecutionException e) {
                Log.d("MainActivity", e.getMessage());
                return;
            });

यहां दिए गए AiPackState तरीकों से, एआई पैक का साइज़, अब तक डाउनलोड किए गए डेटा की जानकारी (अगर अनुरोध किया गया हो), और ऐप्लिकेशन में पहले से ट्रांसफ़र किए गए डेटा की जानकारी मिलती है:

किसी एआई पैक का स्टेटस जानने के लिए, status() तरीके का इस्तेमाल करें. यह स्टेटस को एक पूर्णांक के तौर पर दिखाता है, जो AiPackStatus क्लास में मौजूद कॉन्स्टेंट फ़ील्ड से जुड़ा होता है. जिस एआई पैक को अब तक इंस्टॉल नहीं किया गया है उसकी स्थिति AiPackStatus.NOT_INSTALLED होती है.

अगर कोई अनुरोध पूरा नहीं हो पाता है, तो errorCode() तरीके का इस्तेमाल करें. इसकी रिटर्न वैल्यू, AiPackErrorCode क्लास में मौजूद कॉन्स्टेंट फ़ील्ड से मेल खाती है.

इंस्टॉल करें

पहली बार एआई पैक डाउनलोड करने या एआई पैक के अपडेट को पूरा करने के लिए, fetch() तरीके का इस्तेमाल करें:

Task<AiPackStates> fetch(List<String> packNames)

यह तरीका, AiPackStates ऑब्जेक्ट दिखाता है. इसमें पैक की सूची के साथ-साथ, उनके शुरुआती डाउनलोड की स्थितियों और साइज़ की जानकारी होती है. अगर fetch() के ज़रिए अनुरोध किया गया एआई पैक पहले से डाउनलोड हो रहा है, तो डाउनलोड की स्थिति दिखती है. साथ ही, कोई और डाउनलोड शुरू नहीं होता.

डाउनलोड की स्थिति पर नज़र रखना

एआई पैक के इंस्टॉल होने की प्रोग्रेस को ट्रैक करने के लिए, आपको AiPackStateUpdateListener लागू करना चाहिए. स्टेटस अपडेट को हर पैक के हिसाब से बांटा जाता है, ताकि अलग-अलग एआई पैक के स्टेटस को ट्रैक किया जा सके. अनुरोध किए गए सभी एआई पैक डाउनलोड होने से पहले, उपलब्ध एआई पैक का इस्तेमाल शुरू किया जा सकता है.

void registerListener(AiPackStateUpdateListener listener)
void unregisterListener(AiPackStateUpdateListener listener)

ध्यान दें: उपयोगकर्ता के ऐप्लिकेशन इंस्टॉल या अपडेट करने के बाद, Play Store अपने-आप किसी भी fast-follow पैक को डाउनलोड करना शुरू कर देता है. हालांकि, हो सकता है कि ये पैक तुरंत इस्तेमाल करने के लिए तैयार न हों. आपको हर बार ऐप्लिकेशन लॉन्च करते समय, fast-follow पैक की स्थिति देखनी होगी. अगर डाउनलोड जारी है, तो लिसनर की मदद से इसे मॉनिटर करें. अगर डाउनलोड रद्द या रोक दिया जाता है, तो fetch() तरीके का इस्तेमाल करके इसे फिर से शुरू किया जा सकता है. इसके बारे में इंस्टॉल करें सेक्शन में बताया गया है.

ज़्यादा स्टोरेज वाले डाउनलोड

अगर डाउनलोड किए जाने वाले डेटा का साइज़ 200 एमबी से ज़्यादा है और उपयोगकर्ता वाई-फ़ाई से कनेक्ट नहीं है, तो डाउनलोड तब तक शुरू नहीं होता, जब तक उपयोगकर्ता मोबाइल डेटा कनेक्शन का इस्तेमाल करके डाउनलोड करने की साफ़ तौर पर सहमति नहीं देता. इसी तरह, अगर डाउनलोड की जाने वाली फ़ाइल का साइज़ बड़ा है और उपयोगकर्ता का वाई-फ़ाई कनेक्शन बंद हो जाता है, तो डाउनलोड की प्रोसेस रुक जाती है. मोबाइल डेटा कनेक्शन का इस्तेमाल करके डाउनलोड की प्रोसेस जारी रखने के लिए, उपयोगकर्ता की साफ़ तौर पर सहमति ज़रूरी है. रोके गए पैक की स्थिति WAITING_FOR_WIFI होती है. उपयोगकर्ता से सहमति लेने के लिए यूज़र इंटरफ़ेस (यूआई) फ़्लो को ट्रिगर करने के लिए, showConfirmationDialog() तरीके का इस्तेमाल करें.

ध्यान दें कि अगर ऐप्लिकेशन इस तरीके को कॉल नहीं करता है, तो डाउनलोड रोक दिया जाता है. यह सिर्फ़ तब अपने-आप फिर से शुरू होगा, जब उपयोगकर्ता वाई-फ़ाई कनेक्शन पर वापस आएगा.

उपयोगकर्ता की सहमति ज़रूरी है

अगर किसी पैक का स्टेटस REQUIRES_USER_CONFIRMATION है, तो डाउनलोड तब तक शुरू नहीं होगा, जब तक उपयोगकर्ता showConfirmationDialog() के साथ दिखाए गए डायलॉग बॉक्स को स्वीकार नहीं करता. यह स्टेटस तब दिख सकता है, जब Google Play ऐप्लिकेशन की पहचान न कर पाए. उदाहरण के लिए, अगर ऐप्लिकेशन को अनजान सोर्स से इंस्टॉल किया गया हो. ध्यान दें कि इस मामले में showConfirmationDialog() को कॉल करने पर, ऐप्लिकेशन अपडेट हो जाएगा. अपडेट के बाद, आपको एआई पैक के लिए फिर से अनुरोध करना होगा.

यहां लिसनर को लागू करने का एक उदाहरण दिया गया है:

AiPackStateUpdateListener aiPackStateUpdateListener = new AiPackStateUpdateListener() {
    private final ActivityResultLauncher<IntentSenderRequest> activityResultLauncher =
      registerForActivityResult(
          new ActivityResultContracts.StartIntentSenderForResult(),
          new ActivityResultCallback<ActivityResult>() {
            @Override
            public void onActivityResult(ActivityResult result) {
              if (result.getResultCode() == RESULT_OK) {
                Log.d(TAG, "Confirmation dialog has been accepted.");
              } else if (result.getResultCode() == RESULT_CANCELED) {
                Log.d(TAG, "Confirmation dialog has been denied by the user.");
              }
            }
          });

    @Override
    public void onStateUpdate(AiPackState aiPackState) {
      switch (aiPackState.status()) {
        case AiPackStatus.PENDING:
          Log.i(TAG, "Pending");
          break;

        case AiPackStatus.DOWNLOADING:
          long downloaded = aiPackState.bytesDownloaded();
          long totalSize = aiPackState.totalBytesToDownload();
          double percent = 100.0 * downloaded / totalSize;

          Log.i(TAG, "PercentDone=" + String.format("%.2f", percent));
          break;

        case AiPackStatus.TRANSFERRING:
          // 100% downloaded and assets are being transferred.
          // Notify user to wait until transfer is complete.
          break;

        case AiPackStatus.COMPLETED:
          // AI pack is ready to use. Run the model.
          break;

        case AiPackStatus.FAILED:
          // Request failed. Notify user.
          Log.e(TAG, aiPackState.errorCode());
          break;

        case AiPackStatus.CANCELED:
          // Request canceled. Notify user.
          break;

        case AiPackStatus.WAITING_FOR_WIFI:
        case AiPackStatus.REQUIRES_USER_CONFIRMATION:
          if (!confirmationDialogShown) {
            aiPackManager.showConfirmationDialog(activityResultLauncher);
            confirmationDialogShown = true;
          }
          break;

        case AiPackStatus.NOT_INSTALLED:
          // AI pack is not downloaded yet.
          break;
        case AiPackStatus.UNKNOWN:
          Log.wtf(TAG, "AI pack status unknown")
          break;
      }
    }
}

इसके अलावा, मौजूदा डाउनलोड की स्थिति जानने के लिए, getPackStates() तरीके का इस्तेमाल किया जा सकता है. AiPackStates में डाउनलोड की प्रोग्रेस, डाउनलोड की स्थिति, और डाउनलोड न होने पर गड़बड़ी के कोड शामिल होते हैं.

एआई पैक ऐक्सेस करना

डाउनलोड करने का अनुरोध COMPLETED स्थिति में पहुंचने के बाद, फ़ाइल सिस्टम कॉल का इस्तेमाल करके एआई पैक को ऐक्सेस किया जा सकता है. एआई पैक का रूट फ़ोल्डर पाने के लिए, getPackLocation() तरीके का इस्तेमाल करें.

एआई पैक, एआई पैक की रूट डायरेक्ट्री में मौजूद assets डायरेक्ट्री में सेव किए जाते हैं. assetsPath() तरीके का इस्तेमाल करके, assets डायरेक्ट्री का पाथ पाया जा सकता है. किसी खास ऐसेट का पाथ पाने के लिए, यह तरीका अपनाएं:

private String getAbsoluteAiAssetPath(String aiPack, String relativeAiAssetPath) {
    AiPackLocation aiPackPath = aiPackManager.getPackLocation(aiPack);

    if (aiPackPath == null) {
        // AI pack is not ready
        return null;
    }

    String aiAssetsFolderPath = aiPackPath.assetsPath();
    // equivalent to: FilenameUtils.concat(aiPackPath.path(), "assets");
    String aiAssetPath = FilenameUtils.concat(aiAssetsFolderPath, relativeAiAssetPath);
    return aiAssetPath;
}

डिवाइस टारगेटिंग को कॉन्फ़िगर करना

डिवाइस टारगेटिंग के निर्देशों का पालन करके, उन डिवाइसों या डिवाइसों के ग्रुप की जानकारी दी जा सकती है जिन पर आपके एआई पैक इंस्टॉल किए जाने चाहिए.

Play AI Delivery API के अन्य तरीके

यहां एपीआई के कुछ अन्य तरीके दिए गए हैं, जिन्हें अपने ऐप्लिकेशन में इस्तेमाल किया जा सकता है.

अनुरोध रद्द करें

एआई पैक के किसी चालू अनुरोध को रद्द करने के लिए, cancel() का इस्तेमाल करें. ध्यान दें कि यह अनुरोध, सबसे सही तरीके से की जाने वाली कार्रवाई है.

कोई एआई पैक हटाना

किसी एआई पैक को हटाने का शेड्यूल तय करने के लिए, removePack() का इस्तेमाल करें.

एक से ज़्यादा एआई पैक की जगह की जानकारी पाना

एक साथ कई एआई पैक की स्थिति के बारे में क्वेरी करने के लिए, getPackLocations() का इस्तेमाल करें. इससे एआई पैक और उनकी जगहों का मैप मिलता है. getPackLocations() से मिले मैप में, फ़िलहाल डाउनलोड किए गए और अप-टू-डेट हर पैक की एंट्री होती है.

डिवाइस टारगेटिंग

डिवाइस टारगेटिंग की मदद से, आपको इस बात पर बेहतर कंट्रोल मिलता है कि आपके ऐप्लिकेशन बंडल के कौनसे हिस्से, खास डिवाइसों पर डिलीवर किए जाएं. उदाहरण के लिए, यह पक्का किया जा सकता है कि कोई बड़ा मॉडल सिर्फ़ ज़्यादा रैम वाले डिवाइसों पर डिलीवर किया जाए. इसके अलावा, किसी मॉडल के अलग-अलग वर्शन, अलग-अलग डिवाइसों पर डिलीवर किए जा सकते हैं.

डिवाइस की इन प्रॉपर्टी को टारगेट किया जा सकता है:

चिप पर सिस्टम
डिवाइस का मॉडल
डिवाइस की रैम
सिस्टम की सुविधाएं

ज़रूरी चरणों के बारे में खास जानकारी

डिवाइस टारगेटिंग की सुविधा चालू करने के लिए, यह तरीका अपनाएं:

एक्सएमएल फ़ाइल में अपने डिवाइस ग्रुप तय करें.
यह तय करें कि आपके बंडल के कौनसे हिस्से, किस डिवाइस ग्रुप में जाने चाहिए.
[ज़रूरी नहीं] अपने कॉन्फ़िगरेशन को स्थानीय तौर पर टेस्ट करें.
अपने बंडल (जिसमें एक्सएमएल फ़ाइल शामिल है) को Google Play पर अपलोड करें.

Android Gradle प्लगिन का वर्शन देखना

डिवाइस टारगेटिंग का इस्तेमाल करने के लिए, पक्का करें कि आपके Android Gradle प्लगिन (एजीपी) का वर्शन कम से कम 8.10.0 हो. यह Android Studio (Meerkat 2 और इसके बाद के वर्शन) के साथ पैकेज किया गया है. Android Studio का सबसे नया स्टेबल वर्शन डाउनलोड करें.

Android Gradle प्लगिन में इस सुविधा को चालू करना

डिवाइस टारगेटिंग को आपकी gradle.properties फ़ाइल में साफ़ तौर पर चालू किया जाना चाहिए:

android.experimental.enableDeviceTargetingConfigApi=true

डिवाइस टारगेटिंग कॉन्फ़िगरेशन की एक्सएमएल फ़ाइल बनाना

डिवाइस टारगेटिंग की कॉन्फ़िगरेशन फ़ाइल, एक एक्सएमएल फ़ाइल होती है. इसमें, पसंद के मुताबिक बनाए गए डिवाइस ग्रुप तय किए जाते हैं. उदाहरण के लिए, qti_v79 नाम का एक डिवाइस ग्रुप तय किया जा सकता है. इसमें Qualcomm SM8750 चिप पर सिस्टम (SoC) वाले सभी डिवाइस शामिल हों:

<config:device-targeting-config
    xmlns:config="http://schemas.android.com/apk/config">

    <config:device-group name="qti_v79">
        <config:device-selector>
            <config:system-on-chip manufacturer="QTI" model="SM8750"/>
        </config:device-selector>
    </config:device-group>

</config:device-targeting-config>

डिवाइस ग्रुप में ज़्यादा से ज़्यादा पांच डिवाइस सिलेक्टर हो सकते हैं. अगर कोई डिवाइस, डिवाइस चुनने वाले किसी भी टूल की शर्तों को पूरा करता है, तो उसे डिवाइस ग्रुप में शामिल किया जाता है.

डिवाइस सिलेक्टर में एक या उससे ज़्यादा डिवाइस प्रॉपर्टी हो सकती हैं. किसी डिवाइस को तब चुना जाता है, जब वह सिलेक्टर की सभी डिवाइस प्रॉपर्टी से मैच करता हो.

अगर कोई डिवाइस एक से ज़्यादा ग्रुप से मैच करता है, तो उसे उस ग्रुप का कॉन्टेंट दिखाया जाएगा जिसे एक्सएमएल फ़ाइल में सबसे पहले तय किया गया है. एक्सएमएल फ़ाइल में ग्रुप तय करने का क्रम ही आपकी प्राथमिकता का क्रम होता है.

अगर कोई डिवाइस किसी भी ग्रुप से मैच नहीं होता है, तो उसे डिफ़ॉल्ट रूप से "अन्य" ग्रुप में शामिल किया जाएगा. यह ग्रुप अपने-आप जनरेट होता है. इसलिए, इसे अलग से तय करने की ज़रूरत नहीं है.

डिवाइस की उपलब्ध प्रॉपर्टी

device_ram: डिवाइस की रैम से जुड़ी ज़रूरी शर्तें
- min_bytes (शामिल है): ज़रूरी रैम (बाइट में)
- max_bytes (exclusive): ज़्यादा से ज़्यादा ज़रूरी रैम (बाइट में)
included_device_ids: इस सिलेक्टर में शामिल किए जाने वाले डिवाइस मॉडल (हर ग्रुप में ज़्यादा से ज़्यादा 10,000 device_ids). अगर डिवाइस, सूची में मौजूद किसी भी device_id से मैच करता है, तो यह प्रॉपर्टी पूरी हो जाती है.
- build_brand: डिवाइस मैन्युफ़ैक्चरर
- build_device: डिवाइस के मॉडल का कोड
excluded_device_ids: इस सिलेक्टर में शामिल नहीं किए जाने वाले डिवाइस मॉडल (हर ग्रुप में ज़्यादा से ज़्यादा 10,000 device_ids). यह प्रॉपर्टी तब पूरी होती है, जब डिवाइस का आईडी, सूची में मौजूद किसी भी device_id से मैच न हो.
- build_brand: डिवाइस मैन्युफ़ैक्चरर
- build_device: डिवाइस के मॉडल का कोड
required_system_features: ऐसी सुविधाएं जो किसी डिवाइस में होनी चाहिए, ताकि उसे इस सिलेक्टर में शामिल किया जा सके (हर ग्रुप में ज़्यादा से ज़्यादा 100 सुविधाएं). इस प्रॉपर्टी को पूरा करने के लिए, डिवाइस में इस सूची में मौजूद सभी सिस्टम सुविधाएं होनी चाहिए.

सिस्टम की सुविधाओं का रेफ़रंस
- name: सिस्टम की कोई सुविधा
forbidden_system_features: ऐसी सुविधाएं जो इस सिलेक्टर में शामिल होने के लिए, डिवाइस में नहीं होनी चाहिए (हर ग्रुप में ज़्यादा से ज़्यादा 100 सुविधाएं). अगर किसी डिवाइस में इस सूची में मौजूद कोई भी सिस्टम सुविधा है, तो वह इस प्रॉपर्टी को पूरा नहीं करता.

सिस्टम की सुविधाओं का रेफ़रंस
- name: सिस्टम की कोई सुविधा
system-on-chip: इस सिलेक्टर में शामिल किए जाने वाले चिप पर सिस्टम (SoC). इस प्रॉपर्टी को पूरा करने के लिए, डिवाइस में इस सूची में मौजूद कोई भी चिप होनी चाहिए.
- manufacturer: चिप पर सिस्टम (SoC) मैन्युफ़ैक्चरर
- model: चिप पर सिस्टम का मॉडल

सलाह: एक ही सिलेक्टर में कई प्रॉपर्टी शामिल करने से, लॉजिकल AND बनता है. उदाहरण के लिए:

    <config:device-selector ram-min-bytes="7000000000">
        <config:included-device-id brand="google" device="flame"/>
    </config:device-selector>

इससे उन सभी डिवाइसों के लिए शर्त बन जाएगी जिनकी रैम 7 जीबी से ज़्यादा है और जो Pixel 4 हैं. इसे इस तरह भी लिखा जा सकता है:

अगर आपको OR शर्त चाहिए, तो एक ही डिवाइस ग्रुप में अलग-अलग सिलेक्टर बनाएं. उदाहरण के लिए:

    <config:device-selector ram-min-bytes="7000000000"/>
    <config:device-selector>
          <config:included-device-id brand="google" device="flame"/>
    </config:device-selector>

इससे, 7 जीबी से ज़्यादा रैम वाले सभी डिवाइसों या Pixel 4 के लिए शर्त बन जाएगी. इसे इस तरह भी लिखा जा सकता है:

यहां एक उदाहरण दिया गया है, जिसमें डिवाइस की सभी संभावित प्रॉपर्टी दिखाई गई हैं:

<config:device-targeting-config
    xmlns:config="http://schemas.android.com/apk/config">

    <config:device-group name="myCustomGroup1">
      <config:device-selector ram-min-bytes="8000000000">
        <config:included-device-id brand="google" device="redfin"/>
        <config:included-device-id brand="google" device="sailfish"/>
        <config:included-device-id brand="good-brand"/>
        <config:excluded-device-id brand="google" device="caiman"/>
        <config:system-on-chip manufacturer="Sinclair" model="ZX80"/>
        <config:system-on-chip manufacturer="Commodore" model="C64"/>
      </config:device-selector>
      <config:device-selector ram-min-bytes="16000000000"/>
    </config:device-group>

    <config:device-group name="myCustomGroup2">
      <config:device-selector ram-min-bytes="4000000000" ram-max-bytes="8000000000">
        <config:required-system-feature name="android.hardware.bluetooth"/>
        <config:required-system-feature name="android.hardware.location"/>
        <config:forbidden-system-feature name="android.hardware.camera"/>
        <config:forbidden-system-feature name="mindcontrol.laser"/>
      </config:device-selector>
    </config:device-group>

</config:device-targeting-config>

डिवाइस बनाने वाली कंपनी और डिवाइस के मॉडल के आधिकारिक कोड

डिवाइस के मैन्युफ़ैक्चरर और मॉडल कोड के लिए सही फ़ॉर्मैट का पता लगाया जा सकता है. इसके लिए, Google Play Console पर डिवाइस सूची का इस्तेमाल करें. इसके लिए, इनमें से कोई एक तरीका अपनाएं:

डिवाइस सूची का इस्तेमाल करके, अलग-अलग डिवाइसों की जांच करना. साथ ही, नीचे दिए गए उदाहरण में दिखाई गई जगहों पर, मैन्युफ़ैक्चरर और मॉडल कोड ढूंढना. उदाहरण के लिए, Google Pixel 4a के लिए, मैन्युफ़ैक्चरर "Google" है और मॉडल कोड "sunfish" है'
इस्तेमाल किए जा सकने वाले डिवाइसों की CSV फ़ाइल डाउनलोड करें. इसके बाद, build_brand और build_device फ़ील्ड के लिए, क्रमशः मैन्युफ़ैक्चरर और मॉडल कोड का इस्तेमाल करें.

अपने ऐप्लिकेशन बंडल में, डिवाइस टारगेटिंग की कॉन्फ़िगरेशन फ़ाइल शामिल करना

अपने मुख्य मॉड्यूल की build.gradle फ़ाइल में ये चीज़ें जोड़ें:

android {
  ...
  bundle {
    deviceTargetingConfig = file('device_targeting_config.xml')
    deviceGroup {
      enableSplit = true   // split bundle by #group
      defaultGroup = "other"  // group used for standalone APKs
    }
  }
  ...
}

device_targeting_config.xml, मुख्य मॉड्यूल के हिसाब से आपकी कॉन्फ़िगरेशन फ़ाइल का पाथ है. इससे यह पक्का होता है कि आपकी कॉन्फ़िगरेशन फ़ाइल, आपके ऐप्लिकेशन बंडल के साथ पैकेज की गई है.

deviceGroup क्लॉज़ यह पक्का करता है कि आपके बंडल से जनरेट किए गए APK, डिवाइस ग्रुप के हिसाब से अलग-अलग हों.

अपने एआई पैक के लिए डिवाइस टारगेटिंग का इस्तेमाल करना

डिवाइसों पर ऐप्लिकेशन के साइज़ को ऑप्टिमाइज़ किया जा सकता है. इसके लिए, बड़े साइज़ वाले मॉडल सिर्फ़ उन डिवाइसों पर डिलीवर करें जिन पर वे काम कर सकते हैं.

पिछले चरण में बनाई गई मौजूदा एआई पैक डायरेक्ट्री का इस्तेमाल करके, एआई पैक को डिवाइस ग्रुप के हिसाब से सब-डिवाइड करें. इसके बाद, सही फ़ोल्डर के आखिर में #group_myCustomGroup1, #group_myCustomGroup2 वगैरह जोड़ें. इसके बारे में नीचे बताया गया है. अपने ऐप्लिकेशन में एआई पैक का इस्तेमाल करते समय, आपको फ़ोल्डर के आखिर में कुछ जोड़ने की ज़रूरत नहीं होगी. दूसरे शब्दों में, बिल्ड प्रोसेस के दौरान, आखिर में जोड़े गए शब्द अपने-आप हट जाते हैं.

पिछले चरण के बाद, यह कुछ ऐसा दिख सकता है:

...
.../ai-pack-name/src/main/assets/image-classifier#group_myCustomGroup1/
.../ai-pack-name/src/main/assets/image-classifier#group_myCustomGroup2/
...

इस उदाहरण में, आपको बिना किसी पोस्टफ़िक्स के ai-pack-name/assets/image-classifier/ का रेफ़रंस देना होगा.

myCustomGroup1 में मौजूद डिवाइसों को image-classifier#group_myCustomGroup1/ में मौजूद सभी ऐसेट मिलेंगी. वहीं, myCustomGroup2 में मौजूद डिवाइसों को image-classifier#group_myCustomGroup2/ में मौजूद सभी ऐसेट मिलेंगी.

myCustomGroup1 या myCustomGroup2 से लिंक न किए गए डिवाइसों को ai-pack-name का खाली पैक मिलेगा.

ऐसा इसलिए होता है, क्योंकि जिन डिवाइसों की जानकारी किसी भी डिवाइस ग्रुप से मैच नहीं होती उन्हें आपके एआई पैक का डिफ़ॉल्ट वैरिएंट मिलेगा. इसमें ऐसी कोई भी चीज़ शामिल है जो #group_suffix वाली डायरेक्ट्री में मौजूद नहीं है.

एआई पैक डाउनलोड करने के बाद, यह देखा जा सकता है कि आपका मॉडल मौजूद है या नहीं. इसके लिए, इंस्टॉल के समय डाउनलोड होने वाले पैक के लिए AssetManager का इस्तेमाल करें. इसके अलावा, फ़ास्ट-फ़ॉलो और मांग पर डाउनलोड होने वाले पैक के लिए AiPackManager का इस्तेमाल करें. सैंपल के तौर पर मिले ऐप्लिकेशन में, डिलीवरी के सभी मोड के लिए ऐसा करने के उदाहरण दिखाए गए हैं.

अपने फ़ीचर मॉड्यूल के लिए डिवाइस टारगेटिंग का इस्तेमाल करना

फ़ीचर मॉड्यूल के लिए, डिवाइस टारगेटिंग का भी इस्तेमाल किया जा सकता है. डिवाइस ग्रुप के हिसाब से फ़ीचर मॉड्यूल को अलग-अलग हिस्सों में बांटने के बजाय, यह तय किया जाता है कि पूरा मॉड्यूल, डिवाइस ग्रुप की सदस्यता के आधार पर डिलीवर किया जाना चाहिए या नहीं.

myCustomGroup1 या myCustomGroup2 वाले डिवाइसों पर फ़ीचर मॉड्यूल डिलीवर करने के लिए, उसके AndroidManifest.xml में बदलाव करें:

<manifest ...>
  ...
  <dist:module dist:title="...">
    <dist:delivery>
      <dist:install-time>
        <dist:conditions>
          <dist:device-groups>
            <dist:device-group dist:name="myCustomGroup1"/>
            <dist:device-group dist:name="myCustomGroup2"/>
          </dist:device-groups>
          ...
        </dist:conditions>
      </dist:install-time>
    </dist:delivery>
  </dist:module>
  ...
</manifest>

लोकल लेवल पर टेस्ट करना

अपने नए बंडल के लिए रिलीज़ बनाने से पहले, संगठन में काम करने वालों के साथ ऐप्लिकेशन शेयर करने की सुविधा या Bundletool का इस्तेमाल करके, डिवाइस पर टेस्ट किया जा सकता है.

अंदरूनी तौर पर ऐप्लिकेशन शेयर करना

संगठन में काम करने वालों के साथ ऐप्लिकेशन शेयर करने की सुविधा की मदद से, ऐप्लिकेशन बंडल का इस्तेमाल करके तुरंत एक यूआरएल जनरेट किया जा सकता है. इस यूआरएल पर टैप करके, किसी डिवाइस पर ठीक वही ऐप्लिकेशन इंस्टॉल किया जा सकता है जो Google Play उस डिवाइस के लिए इंस्टॉल करता. ऐसा तब होता, जब ऐप्लिकेशन का वह वर्शन किसी टेस्ट या प्रोडक्शन ट्रैक में लाइव होता.

संगठन में काम करने वालों के साथ ऐप्लिकेशन शेयर करने की सुविधा के निर्देश देखें.

Bundletool

इसके अलावा, bundletool (1.18.0 या इसके बाद के वर्शन) का इस्तेमाल करके APK जनरेट किए जा सकते हैं और उन्हें अपने डिवाइस पर अनजान सोर्स से इंस्टॉल किया जा सकता है. bundletool का इस्तेमाल करके, अपने ऐप्लिकेशन को स्थानीय तौर पर टेस्ट करने के लिए, यह तरीका अपनाएं:

Android Studio या bundletool की मदद से अपना ऐप्लिकेशन बंडल बनाएं.

--local-testing फ़्लैग के साथ APK जनरेट करें:

java -jar bundletool-all.jar build-apks --bundle=path/to/your/bundle.aab \
  --output=output.apks --local-testing

किसी डिवाइस को कनेक्ट करें और APKs को अनजान सोर्स से इंस्टॉल करने के लिए, bundletool चलाएं:

# Example without Device Targeting Configuration
java -jar bundletool.jar install-apks --apks=output.apks

# Example with Device Targeting Configuration (you must specify which groups the connected device belongs to)
java -jar bundletool.jar install-apks --apks=output.apks --device-groups=myCustomGroup1,myCustomGroup2

bundletool की मदद से, स्थानीय तौर पर टेस्टिंग करने की सीमाएं

bundletool की मदद से, स्थानीय तौर पर टेस्टिंग करने की ये सीमाएं हैं:

fast-follow पैक, on-demand पैक की तरह काम करते हैं. इसका मतलब है कि अनजान सोर्स से ऐप्लिकेशन इंस्टॉल करने पर, ये ऐसेट अपने-आप फ़ेच नहीं होंगी. ऐप्लिकेशन शुरू होने पर, डेवलपर को मैन्युअल तरीके से इनकी अनुमति मांगनी होगी. इसके लिए, आपके ऐप्लिकेशन के कोड में कोई बदलाव करने की ज़रूरत नहीं है.
पैक, Google Play के बजाय बाहरी स्टोरेज से फ़ेच किए जाते हैं. इसलिए, यह जांच नहीं की जा सकती कि नेटवर्क की गड़बड़ियों के मामले में आपका कोड कैसा व्यवहार करता है.
लोकल टेस्टिंग में, वाई-फ़ाई के लिए इंतज़ार करने की स्थिति शामिल नहीं होती है.
अपडेट नहीं किया जा सकता. अपने बिल्ड का नया वर्शन इंस्टॉल करने से पहले, पिछले वर्शन को मैन्युअल तरीके से अनइंस्टॉल करें.

पुष्टि करना कि सही APK इंस्टॉल किए जा रहे हैं

यह तरीका अपनाकर पक्का करें कि डिवाइस पर सिर्फ़ सही APK इंस्टॉल किए गए हों

adb shell pm path {packageName}

आपको इस तरह की विंडो दिखेगी:

package:{...}/base.apk
package:{...}/split_config.en.apk
package:{...}/split_config.xxhdpi.apk
package:{...}/split_main_ai-pack-name.apk
package:{...}/split_main_ai-pack-name.config.group_myCustomGroup1.apk

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

Google Play पर ऐप्लिकेशन की जांच करना और उसे रिलीज़ करना

हमारा सुझाव है कि आप ऐप्लिकेशन के इंटरनल टेस्ट ट्रैक की मदद से, Google Play पर अपने ऐप्लिकेशन की पूरी जांच करें.

ऐसा करने के बाद, कुछ लोगों के लिए रिलीज़ करने की सुविधा का इस्तेमाल करके, ऐप्लिकेशन के अपडेट को प्रोडक्शन के लिए धीरे-धीरे रिलीज़ किया जा सकता है.

Play for On-device AI का इस्तेमाल करने वाला सैंपल ऐप्लिकेशन

सैंपल के तौर पर मिला ऐप्लिकेशन डाउनलोड करें.

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

मिलता-जुलता कॉन्टेंट

Android ऐप्लिकेशन बंडल के बारे में ज़्यादा जानें. साथ ही, एआई डिलीवरी एसडीके के बारे में रेफ़रंस पढ़ें.