इस पेज का अनुवाद Cloud Translation API से किया गया है.

ऐसेट डिलीवरी को इंटिग्रेट करना (Kotlin और Java)

अपने Java से, ऐप्लिकेशन के ऐसेट पैक ऐक्सेस करने के लिए, इस गाइड में दिया गया तरीका अपनाएं कोड.

Kotlin और Java के लिए बनाएं

अपने प्रोजेक्ट के Android में, 'Play ऐसेट डिलीवरी' की सुविधा बनाने के लिए, यह तरीका अपनाएं ऐप्लिकेशन बंडल. इन चरणों को पूरा करने के लिए, आपको Android Studio का इस्तेमाल करने की ज़रूरत नहीं है.

अपने प्रोजेक्ट के 'Android Gradle प्लग इन' का वर्शन अपडेट करें build.gradle फ़ाइल को 4.0.0 या उसके बाद के वर्शन पर अपलोड करें.
अपने प्रोजेक्ट की टॉप-लेवल की डायरेक्ट्री में, ऐसेट के लिए एक डायरेक्ट्री बनाएं पैक. डायरेक्ट्री के इस नाम का इस्तेमाल, ऐसेट पैक के नाम के तौर पर किया जाता है. ऐसेट पैक के नाम यह किसी अक्षर से शुरू होना चाहिए और इसमें सिर्फ़ अक्षर, अंक, और अंडरस्कोर.

ऐसेट पैक की डायरेक्ट्री में, build.gradle फ़ाइल बनाएं और . पक्का करें कि आपने ऐसेट पैक का नाम और सिर्फ़ एक नाम डाला हो डिलीवरी टाइप:

ग्रूवी

// In the asset pack's build.gradle file:
plugins {
  id 'com.android.asset-pack'
}

assetPack {
    packName = "asset-pack-name" // Directory name for the asset pack
    dynamicDelivery {
        deliveryType = "[ install-time | fast-follow | on-demand ]"
    }
}

Kotlin

// In the asset pack's build.gradle.kts file:
plugins {
  id("com.android.asset-pack")
}

assetPack {
  packName.set("asset-pack-name") // Directory name for the asset pack
  dynamicDelivery {
    deliveryType.set("[ install-time | fast-follow | on-demand ]")
  }
}

प्रोजेक्ट के ऐप्लिकेशन की build.gradle फ़ाइल में, हर ऐसेट पैक का नाम जोड़ें जोड़ें, जैसा कि नीचे दिखाया गया है:
ग्रूवी
```
// In the app build.gradle file:
android {
    ...
    assetPacks = [":asset-pack-name", ":asset-pack2-name"]
}
```
Kotlin
```
// In the app build.gradle.kts file:
android {
    ...
    assetPacks += listOf(":asset-pack-name", ":asset-pack2-name")
}
```
प्रोजेक्ट की settings.gradle फ़ाइल में, सभी ऐसेट पैक को प्रोजेक्ट देखें, जैसा कि नीचे दिखाया गया है:
ग्रूवी
```
// In the settings.gradle file:
include ':app'
include ':asset-pack-name'
include ':asset-pack2-name'
```
Kotlin
```
// In the settings.gradle.kts file:
include(":app")
include(":asset-pack-name")
include(":asset-pack2-name")
```
ऐसेट पैक की डायरेक्ट्री में, यह सबडायरेक्ट्री बनाएं: src/main/assets.
एसेट को src/main/assets डायरेक्ट्री में रखें. आप बना सकते हैं सबडायरेक्ट्री में भी शामिल होंगी. आपके ऐप्लिकेशन की डायरेक्ट्री का स्ट्रक्चर अब ऐसा दिखेगा:
- build.gradle
- settings.gradle
- app/
- asset-pack-name/build.gradle
- asset-pack-name/src/main/assets/your-asset-directories
Gradle की मदद से Android ऐप्लिकेशन बंडल बनाएं. जनरेट किए गए ऐप्लिकेशन बंडल में, रूट-लेवल की डायरेक्ट्री में अब फ़ॉलो किया जा रहा है:
- asset-pack-name/manifest/AndroidManifest.xml: ऐसेट पैक का आइडेंटिफ़ायर और डिलीवरी मोड कॉन्फ़िगर करती है
- asset-pack-name/assets/your-asset-directories: वह डायरेक्ट्री जिसमें ऐसेट पैक के हिस्से के तौर पर डिलीवर की गई सभी ऐसेट शामिल हैं
Gradle, हर ऐसेट पैक के लिए मेनिफ़ेस्ट जनरेट करता है और assets/ को जनरेट करता है डायरेक्ट्री मिलेगी.
(ज़रूरी नहीं) अगर आपको फ़ास्ट-फ़ॉलो और मांग पर डिलीवरी की सुविधा इस्तेमाल करनी है, तो Play ऐसेट डिलीवरी लाइब्रेरी को शामिल करें
ग्रूवी
```
implementation "com.google.android.play:asset-delivery:2.2.2"
// For Kotlin use asset-delivery-ktx
implementation "com.google.android.play:asset-delivery-ktx:2.2.2"
```
Kotlin
```
implementation("com.google.android.play:asset-delivery:2.2.2")
// For Kotlin use core-ktx
implementation("com.google.android.play:asset-delivery-ktx:2.2.2")
```
(ज़रूरी नहीं) अलग-अलग टेक्सचर के साथ काम करने के लिए, अपने ऐप्लिकेशन बंडल को कॉन्फ़िगर करें कंप्रेशन फ़ॉर्मैट में बनाए जा सकते हैं.

ध्यान दें: इन कामों के लिए आपको अपने ऐप्लिकेशन को स्टैंडअलोन APK के बजाय, ऐप्लिकेशन बंडल के तौर पर चलाना होगा बंडल की गई ऐसेट ऐक्सेस करने में मदद मिलेगी. इसके अलावा, आपके पास डिफ़ॉल्ट रन/डीबग कॉन्फ़िगरेशन में बदलाव करने का विकल्प भी है का इस्तेमाल करें. यहां जाएं: अपना 'Android ऐप्लिकेशन बंडल' बनाएं और उसकी जांच करें.

Play ऐसेट डिलीवरी एपीआई के साथ इंटिग्रेट करना

Play ऐसेट डिलीवरी Java API यह AssetPackManager यह कैटगरी, ऐसेट पैक का अनुरोध करने, डाउनलोड मैनेज करने, और ऐसेट ऐक्सेस करने के लिए है. सबसे पहले, अपने प्रोजेक्ट में Play ऐसेट डिलीवरी लाइब्रेरी जोड़ें.

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

Java प्रोग्रामिंग लैंग्वेज के लिए, ऐसेट पैक फ़्लो का डायग्राम

पहला डायग्राम. ऐसेट पैक ऐक्सेस करने का फ़्लो डायग्राम

ऐप्लिकेशन इंस्टॉल करते समय डिलीवरी पाएं

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

Kotlin

import android.content.res.AssetManager
...
val context: Context = createPackageContext("com.example.app", 0)
val assetManager: AssetManager = context.assets
val stream: InputStream = assetManager.open("asset-name")

Java

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

तेज़ी से फ़ॉलो करें और मांग पर डिलीवरी पाएं

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

स्थिति देखें

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

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

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

ऐसेट को फ़ेच करने से पहले, ऐप्लिकेशन को डाउनलोड का साइज़ ज़ाहिर करना होगा पैक. इसका इस्तेमाल करें requestPackStates() या getPackStates() इसका पता लगाने का तरीका कि डाउनलोड का साइज़ क्या है और पैक पहले से है या नहीं डाउनलोड हो रहा है.

Kotlin

suspend fun requestPackStates(packNames: List<String>): AssetPackStates

Java

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

requestPackStates() एक निलंबन फ़ंक्शन है, जो AssetPackStates ऑब्जेक्ट है, जबकि getPackStates() एक एसिंक्रोनस तरीका है जो Task<AssetPackStates> दिखाता है. कॉन्टेंट बनाने packStates() AssetPackStates ऑब्जेक्ट वाला तरीका Map<String, AssetPackState> नतीजे के तौर पर दिखाता है. इस मैप में, अनुरोध की गई हर ऐसेट की स्थिति है पैक, इसके नाम से जुड़ा होता है:

Kotlin

AssetPackStates#packStates(): Map<String, AssetPackState>

Java

Map<String, AssetPackState> AssetPackStates#packStates()

आखिरी अनुरोध को इसमें शामिल किया जाता है:

Kotlin

const val assetPackName = "assetPackName"
coroutineScope.launch {
  try {
    val assetPackStates: AssetPackStates =
      manager.requestPackStates(listOf(assetPackName))
    val assetPackState: AssetPackState =
      assetPackStates.packStates()[assetPackName]
  } catch (e: RuntimeExecutionException) {
    Log.d("MainActivity", e.message)
  }
}

Java

final String assetPackName = "myasset";

assetPackManager
    .getPackStates(Collections.singletonList(assetPackName))
    .addOnCompleteListener(new OnCompleteListener<AssetPackStates>() {
        @Override
        public void onComplete(Task<AssetPackStates> task) {
            AssetPackStates assetPackStates;
            try {
                assetPackStates = task.getResult();
                AssetPackState assetPackState =
                    assetPackStates.packStates().get(assetPackName);
            } catch (RuntimeExecutionException e) {
                Log.d("MainActivity", e.getMessage());
                return;
            })

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

ऐसेट पैक की स्थिति पाने के लिए, इसका इस्तेमाल करें status() तरीका, जो कॉन्स्टेंट से मेल खाने वाले पूर्णांक के रूप में स्टेटस दिखाता है फ़ील्ड में AssetPackStatus क्लास. अभी तक इंस्टॉल नहीं हुए एसेट पैक की स्थिति AssetPackStatus.NOT_INSTALLED.

अगर कोई अनुरोध पूरा नहीं होता है, तो errorCode() तरीका, जिसका रिटर्न वैल्यू AssetPackErrorCode क्लास.

इंस्टॉल करें

requestFetch() का इस्तेमाल करें या fetch() किसी ऐसेट पैक को पहली बार डाउनलोड करने या किसी ऐसेट की परफ़ॉर्मेंस को अपडेट करने के लिए कॉल करने का तरीका ऐसेट पैक को पूरा करना होगा:

Kotlin

suspend fun AssetPackManager.requestFetch(packs: List<String>): AssetPackStates

Java

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

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

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

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

Kotlin

fun registerListener(listener: AssetPackStateUpdatedListener)
fun unregisterListener(listener: AssetPackStateUpdatedListener)

Java

void registerListener(AssetPackStateUpdatedListener listener)
void unregisterListener(AssetPackStateUpdatedListener listener)

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

बड़े डाउनलोड

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

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

उपयोगकर्ता की पुष्टि करना ज़रूरी है

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

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

Kotlin

private val activityResultLauncher = registerForActivityResult(
    ActivityResultContracts.StartIntentSenderForResult()
) { result ->
    if (result.resultCode == RESULT_OK) {
        Log.d(TAG, "Confirmation dialog has been accepted.")
    } else if (result.resultCode == RESULT_CANCELED) {
        Log.d(TAG, "Confirmation dialog has been denied by the user.")
    }
}

assetPackManager.registerListener { assetPackState ->
  when(assetPackState.status()) {
    AssetPackStatus.PENDING -> {
      Log.i(TAG, "Pending")
    }
    AssetPackStatus.DOWNLOADING -> {
      val downloaded = assetPackState.bytesDownloaded()
      val totalSize = assetPackState.totalBytesToDownload()
      val percent = 100.0 * downloaded / totalSize

      Log.i(TAG, "PercentDone=" + String.format("%.2f", percent))
    }
    AssetPackStatus.TRANSFERRING -> {
      // 100% downloaded and assets are being transferred.
      // Notify user to wait until transfer is complete.
    }
    AssetPackStatus.COMPLETED -> {
      // Asset pack is ready to use. Start the game.
    }
    AssetPackStatus.FAILED -> {
      // Request failed. Notify user.
      Log.e(TAG, assetPackState.errorCode())
    }
    AssetPackStatus.CANCELED -> {
      // Request canceled. Notify user.
    }
    AssetPackStatus.WAITING_FOR_WIFI,
    AssetPackStatus.REQUIRES_USER_CONFIRMATION -> {
      if (!confirmationDialogShown) {
        assetPackManager.showConfirmationDialog(activityResultLauncher);
        confirmationDialogShown = true
      }
    }
    AssetPackStatus.NOT_INSTALLED -> {
      // Asset pack is not downloaded yet.
    }
    AssetPackStatus.UNKNOWN -> {
      Log.wtf(TAG, "Asset pack status unknown")
    }
  }
}

Java

assetPackStateUpdateListener = new AssetPackStateUpdateListener() {
    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(AssetPackState assetPackState) {
      switch (assetPackState.status()) {
        case AssetPackStatus.PENDING:
          Log.i(TAG, "Pending");
          break;

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

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

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

        case AssetPackStatus.COMPLETED:
          // Asset pack is ready to use. Start the game.
          break;

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

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

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

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

वैकल्पिक रूप से, आप getPackStates() का इस्तेमाल कर सकते हैं. AssetPackStates डाउनलोड की स्थिति, डाउनलोड की स्थिति, और गड़बड़ी के कोड से जुड़ी जानकारी शामिल होती है.

एसेट पैक ऐक्सेस करें

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

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

Kotlin

private fun getAbsoluteAssetPath(assetPack: String, relativeAssetPath: String): String? {
    val assetPackPath: AssetPackLocation =
      assetPackManager.getPackLocation(assetPack)
      // asset pack is not ready
      ?: return null

    val assetsFolderPath = assetPackPath.assetsPath()
    // equivalent to: FilenameUtils.concat(assetPackPath.path(), "assets")
    return FilenameUtils.concat(assetsFolderPath, relativeAssetPath)
}

Java

private String getAbsoluteAssetPath(String assetPack, String relativeAssetPath) {
    AssetPackLocation assetPackPath = assetPackManager.getPackLocation(assetPack);

    if (assetPackPath == null) {
        // asset pack is not ready
        return null;
    }

    String assetsFolderPath = assetPackPath.assetsPath();
    // equivalent to: FilenameUtils.concat(assetPackPath.path(), "assets");
    String assetPath = FilenameUtils.concat(assetsFolderPath, relativeAssetPath);
    return assetPath;
}

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

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

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

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

ऐसेट पैक हटाना

इस्तेमाल की जाने वाली चीज़ें requestRemovePack() या removePack() शेड्यूल करने के लिए इसका इस्तेमाल किया जा सकता है.

एक से ज़्यादा ऐसेट पैक की जगहों की जानकारी पाना

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

अगला चरण

अपने देश/इलाके में और स्टोर पर जाकर, Play ऐसेट डिलीवरी की जांच करना Google Play से डाउनलोड करें.