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

इन-ऐप्लिकेशन अपडेट के साथ काम करता है (Kotlin या Java)

इस गाइड में ऐप्लिकेशन के अंदर की सुविधा को इस्तेमाल करने का तरीका बताया गया है Kotlin का इस्तेमाल करके या आपके ऐप्लिकेशन में किए जाने वाले अपडेट Java. ऐसे मामलों में अलग-अलग गाइड उपलब्ध हैं, जहां आपके लागू किए जाने पर नेटिव कोड का इस्तेमाल किया जाता है (C/C++) और ऐसे मामले जहां आपका लागू करने की प्रोसेस में, Unity का इस्तेमाल किया जाता है.

अपना डेवलपमेंट एनवायरमेंट सेट अप करें

Play की इन-ऐप्लिकेशन अपडेट लाइब्रेरी, Google Play Core लाइब्रेरी का हिस्सा है. Play इन-ऐप्लिकेशन को इंटिग्रेट करने के लिए, कृपया इस Gradle डिपेंडेंसी को शामिल करें लाइब्रेरी अपडेट करें.

ग्रूवी

// In your app’s build.gradle file:
...
dependencies {
    // This dependency is downloaded from the Google’s Maven repository.
    // So, make sure you also include that repository in your project's build.gradle file.
    implementation 'com.google.android.play:app-update:2.1.0'

    // For Kotlin users also add the Kotlin extensions library for Play In-App Update:
    implementation 'com.google.android.play:app-update-ktx:2.1.0'
    ...
}

Kotlin

// In your app’s build.gradle.kts file:
...
dependencies {
    // This dependency is downloaded from the Google’s Maven repository.
    // So, make sure you also include that repository in your project's build.gradle file.
    implementation("com.google.android.play:app-update:2.1.0")

    // For Kotlin users also import the Kotlin extensions library for Play In-App Update:
    implementation("com.google.android.play:app-update-ktx:2.1.0")
    ...
}

देखें कि अपडेट उपलब्ध है या नहीं

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

Kotlin

val appUpdateManager = AppUpdateManagerFactory.create(context)

// Returns an intent object that you use to check for an update.
val appUpdateInfoTask = appUpdateManager.appUpdateInfo

// Checks that the platform will allow the specified type of update.
appUpdateInfoTask.addOnSuccessListener { appUpdateInfo ->
    if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE
        // This example applies an immediate update. To apply a flexible update
        // instead, pass in AppUpdateType.FLEXIBLE
        && appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)
    ) {
        // Request the update.
    }
}

Java

AppUpdateManager appUpdateManager = AppUpdateManagerFactory.create(context);

// Returns an intent object that you use to check for an update.
Task<AppUpdateInfo> appUpdateInfoTask = appUpdateManager.getAppUpdateInfo();

// Checks that the platform will allow the specified type of update.
appUpdateInfoTask.addOnSuccessListener(appUpdateInfo -> {
    if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE
          // This example applies an immediate update. To apply a flexible update
          // instead, pass in AppUpdateType.FLEXIBLE
          && appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)) {
              // Request the update.
    }
});

रिटर्न AppUpdateInfo इंस्टेंस में, अपडेट के उपलब्ध होने की स्थिति मौजूद हो. स्थिति के आधार पर अपडेट के बाद, इंस्टेंस में ये भी शामिल होते हैं:

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

अपडेट की पुरानी जानकारी देखें

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

इस्तेमाल की जाने वाली चीज़ें clientVersionStalenessDays() Play Store पर अपडेट उपलब्ध होने के बाद से दिनों की संख्या देखने के लिए:

Kotlin

val appUpdateManager = AppUpdateManagerFactory.create(context)

// Returns an intent object that you use to check for an update.
val appUpdateInfoTask = appUpdateManager.appUpdateInfo

// Checks whether the platform allows the specified type of update,
// and current version staleness.
appUpdateInfoTask.addOnSuccessListener { appUpdateInfo ->
    if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE
          && (appUpdateInfo.clientVersionStalenessDays() ?: -1) >= DAYS_FOR_FLEXIBLE_UPDATE
          && appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.FLEXIBLE)) {
              // Request the update.
    }
}

Java

AppUpdateManager appUpdateManager = AppUpdateManagerFactory.create(context);

// Returns an intent object that you use to check for an update.
Task<AppUpdateInfo> appUpdateInfoTask = appUpdateManager.getAppUpdateInfo();

// Checks whether the platform allows the specified type of update,
// and current version staleness.
appUpdateInfoTask.addOnSuccessListener(appUpdateInfo -> {
    if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE
          && appUpdateInfo.clientVersionStalenessDays() != null
          && appUpdateInfo.clientVersionStalenessDays() >= DAYS_FOR_FLEXIBLE_UPDATE
          && appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.FLEXIBLE)) {
              // Request the update.
    }
});

अपडेट की प्राथमिकता देखें

Google Play Developer API की मदद से, हर अपडेट की प्राथमिकता सेट की जा सकती है. इससे आपके ऐप्लिकेशन को यह तय करने में मदद मिलती है कि उपयोगकर्ता को अपडेट का सुझाव किस तरह देना है. उदाहरण के लिए, अपडेट प्राथमिकता सेट करने के लिए यह रणनीति देखें:

यूज़र इंटरफ़ेस (यूआई) में छोटे-मोटे सुधार: कम प्राथमिकता वाला अपडेट; अनुरोध के मुताबिक, महीने के हिसाब से और न ही तुरंत अपडेट होता है. सिर्फ़ तब अपडेट करें, जब उपयोगकर्ता इंटरैक्ट न कर रहा हो को कैसे ट्रैक करें.
परफ़ॉर्मेंस में सुधार: सामान्य प्राथमिकता वाला अपडेट; महीने के हिसाब से अपडेट.
सुरक्षा से जुड़ा गंभीर अपडेट: ज़्यादा प्राथमिकता वाला अपडेट; तुरंत अनुरोध करें अपडेट.

प्राथमिकता तय करने के लिए Google Play, 0 से 5 के बीच की कोई वैल्यू इस्तेमाल करता है. वैल्यू के तौर पर 0 की वैल्यू दी जाती है का मतलब है, डिफ़ॉल्ट और 5 का मतलब सबसे ज़्यादा प्राथमिकता. किसी अपडेट करने के लिए, Edits.tracks.releases के अंतर्गत inAppUpdatePriority फ़ील्ड का उपयोग करें Google Play डेवलपर एपीआई. रिलीज़ में जोड़े गए सभी नए वर्शन को रिलीज़ की समान प्राथमिकता माना जाता है. प्राथमिकता सिर्फ़ तब सेट की जा सकती है, जब नई रिलीज़ रोल आउट कर रहे हों और बाद में इसे बदला नहीं जा सकता.

Play में बताए गए तरीके से, Google Play Developer API का इस्तेमाल करके प्राथमिकता सेट करें डेवलपर एपीआई दस्तावेज़ में दिया गया है. इन-ऐप्लिकेशन अपडेट की प्राथमिकता इसमें दी जानी चाहिए: Edit.tracks संसाधन को इसमें पास किया गया Edit.tracks: update तरीका. इस उदाहरण में, वर्शन कोड 88 के साथ ऐप्लिकेशन रिलीज़ करने के बारे में बताया गया है और inAppUpdatePriority 5:

{
  "releases": [{
      "versionCodes": ["88"],
      "inAppUpdatePriority": 5,
      "status": "completed"
  }]
}

अपने ऐप्लिकेशन के कोड में, दिए गए अपडेट का प्राथमिकता लेवल देखा जा सकता है. इसके लिए, updatePriority(). वापस की गई प्राथमिकता, सभी ऐप्लिकेशन के लिए inAppUpdatePriority को ध्यान में रखती है इंस्टॉल किए गए वर्शन और सबसे नए उपलब्ध वर्शन के बीच के वर्शन कोड, चाहे रिलीज़ ट्रैक से जुड़ा हो. उदाहरण के लिए, यहां दिया गया उदाहरण देखें:

आपने वर्शन 1 को बिना प्राथमिकता के प्रोडक्शन ट्रैक पर रिलीज़ किया हो.
आपने वर्शन 2 को प्राथमिकता 5 वाले इंटरनल टेस्ट ट्रैक पर रिलीज़ किया है.
आपने बिना प्राथमिकता के वर्शन 3 को प्रोडक्शन ट्रैक पर रिलीज़ किया हो.

जब प्रोडक्शन ट्रैक का इस्तेमाल करने वाले उपयोगकर्ता, वर्शन 1 से वर्शन 3 में अपडेट करते हैं, तो उन्हें प्राथमिकता दी जाएगी 5 को रिलीज़ किया गया था, भले ही वर्शन 2 किसी दूसरे ट्रैक पर पब्लिश किया गया हो.

Kotlin

val appUpdateManager = AppUpdateManagerFactory.create(context)

// Returns an intent object that you use to check for an update.
val appUpdateInfoTask = appUpdateManager.appUpdateInfo

// Checks whether the platform allows the specified type of update,
// and checks the update priority.
appUpdateInfoTask.addOnSuccessListener { appUpdateInfo ->
    if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE
          && appUpdateInfo.updatePriority() >= 4 /* high priority */
          && appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)) {
              // Request an immediate update.
    }
}

Java

AppUpdateManager appUpdateManager = AppUpdateManagerFactory.create(context);

// Returns an intent object that you use to check for an update.
Task<AppUpdateInfo> appUpdateInfoTask = appUpdateManager.getAppUpdateInfo();

// Checks whether the platform allows the specified type of update,
// and checks the update priority.
appUpdateInfoTask.addOnSuccessListener(appUpdateInfo -> {
    if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE
          && appUpdateInfo.updatePriority() >= 4 /* high priority */
          && appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)) {
              // Request an immediate update.
    }
});

अपडेट शुरू करें

अपडेट उपलब्ध होने की पुष्टि करने के बाद, अपडेट का अनुरोध करने के लिए: AppUpdateManager.startUpdateFlowForResult():

Kotlin

appUpdateManager.startUpdateFlowForResult(
    // Pass the intent that is returned by 'getAppUpdateInfo()'.
    appUpdateInfo,
    // an activity result launcher registered via registerForActivityResult
    activityResultLauncher,
    // Or pass 'AppUpdateType.FLEXIBLE' to newBuilder() for
    // flexible updates.
    AppUpdateOptions.newBuilder(AppUpdateType.IMMEDIATE).build())

Java

appUpdateManager.startUpdateFlowForResult(
    // Pass the intent that is returned by 'getAppUpdateInfo()'.
    appUpdateInfo,
    // an activity result launcher registered via registerForActivityResult
    activityResultLauncher,
    // Or pass 'AppUpdateType.FLEXIBLE' to newBuilder() for
    // flexible updates.
    AppUpdateOptions.newBuilder(AppUpdateType.IMMEDIATE).build());

हर AppUpdateInfo इंस्टेंस का इस्तेमाल, अपडेट शुरू करने के लिए सिर्फ़ एक बार किया जा सकता है. फिर से कोशिश करने के लिए अगर अपडेट नहीं हो पाता है, तो नए AppUpdateInfo का अनुरोध करें और फिर से देखें कि अपडेट उपलब्ध है और अनुमति है.

गतिविधि के नतीजे दिखाने वाले लॉन्चर को रजिस्टर करने के लिए, पहले से मौजूद टूल का इस्तेमाल किया जा सकता है ActivityResultContracts.StartIntentSenderForResult कानूनी समझौता. सेक्शन को यहां देखें अपडेट के स्टेटस के लिए कॉलबैक पाना.

अगले चरण इस बात पर निर्भर करते हैं कि क्या आपने सुविधाजनक अपडेट या तुरंत अपडेट करें.

AppUpdateOptions के साथ अपडेट कॉन्फ़िगर करें

AppUpdateOptions इसमें AllowAssetPackDeletion फ़ील्ड होता है, जो तय करता है कि अपडेट की मामलों में ऐसेट पैक हटाने की अनुमति है डिवाइस में सीमित स्टोरेज. डिफ़ॉल्ट रूप से, यह फ़ील्ड false पर सेट होता है. हालांकि, इसका इस्तेमाल किया जा सकता है setAllowAssetPackDeletion() इसके बजाय इसे true पर सेट करें:

Kotlin

appUpdateManager.startUpdateFlowForResult(
    // Pass the intent that is returned by 'getAppUpdateInfo()'.
    appUpdateInfo,
    // an activity result launcher registered via registerForActivityResult
    activityResultLauncher,
    // Or pass 'AppUpdateType.FLEXIBLE' to newBuilder() for
    // flexible updates.
    AppUpdateOptions.newBuilder(AppUpdateType.IMMEDIATE)
        .setAllowAssetPackDeletion(true)
        .build())

Java

appUpdateManager.startUpdateFlowForResult(
    // Pass the intent that is returned by 'getAppUpdateInfo()'.
    appUpdateInfo,
    // an activity result launcher registered via registerForActivityResult
    activityResultLauncher,
    // Or pass 'AppUpdateType.FLEXIBLE' to newBuilder() for
    // flexible updates.
    AppUpdateOptions.newBuilder(AppUpdateType.IMMEDIATE)
        .setAllowAssetPackDeletion(true)
        .build());

अपडेट के स्टेटस के लिए कॉलबैक पाएं

अपडेट शुरू करने के बाद, रजिस्टर की गई गतिविधि के नतीजे के लिए लॉन्चर कॉलबैक को पुष्टि करने वाले डायलॉग का नतीजा:

Kotlin

registerForActivityResult(StartIntentSenderForResult()) { result: ActivityResult ->
    // handle callback
    if (result.resultCode != RESULT_OK) {
        log("Update flow failed! Result code: " + result.resultCode);
        // If the update is canceled or fails,
        // you can request to start the update again.
    }
}

Java

registerForActivityResult(
    new ActivityResultContracts.StartIntentSenderForResult(),
    new ActivityResultCallback<ActivityResult>() {
        @Override
        public void onActivityResult(ActivityResult result) {
            // handle callback
            if (result.getResultCode() != RESULT_OK) {
                log("Update flow failed! Result code: " + result.getResultCode());
                // If the update is canceled or fails,
                // you can request to start the update again.
            }
        }
    });

आपको onActivityResult() से कई वैल्यू मिल सकती हैं कॉलबैक:

RESULT_OK: उपयोगकर्ता के पास ने अपडेट स्वीकार कर लिया. तुरंत अपडेट पाने के लिए, हो सकता है कि आपको यह न मिले कॉलबैक क्योंकि अपडेट समय नियंत्रण तक पहले ही पूरा हो जाना चाहिए ऐप्लिकेशन को वापस दिया गया है.
RESULT_CANCELED: उपयोगकर्ता ने अपडेट को अस्वीकार या रद्द कर दिया है.
ActivityResult.RESULT_IN_APP_UPDATE_FAILED: किसी अन्य गड़बड़ी की वजह से, उपयोगकर्ता ने सहमति नहीं दी या आगे बढ़ने से अपडेट करें.

ज़रूरत के हिसाब से अपडेट मैनेज करना

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

वैकल्पिक अपडेट की स्थिति पर नज़र रखना

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

आपके पास लिसनर रजिस्टर करके, अपडेट की स्थिति को मॉनिटर करने का विकल्प है इंस्टॉल करने की स्थिति के बारे में अपडेट. ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) में प्रोग्रेस बार भी दिया जा सकता है, ताकि उपयोगकर्ताओं को डाउनलोड की प्रोग्रेस के बारे में बताना.

Kotlin

// Create a listener to track request state updates.
val listener = InstallStateUpdatedListener { state ->
    // (Optional) Provide a download progress bar.
    if (state.installStatus() == InstallStatus.DOWNLOADING) {
      val bytesDownloaded = state.bytesDownloaded()
      val totalBytesToDownload = state.totalBytesToDownload()
      // Show update progress bar.
    }
    // Log state or install the update.
}

// Before starting an update, register a listener for updates.
appUpdateManager.registerListener(listener)

// Start an update.

// When status updates are no longer needed, unregister the listener.
appUpdateManager.unregisterListener(listener)

Java

// Create a listener to track request state updates.
InstallStateUpdatedListener listener = state -> {
  // (Optional) Provide a download progress bar.
  if (state.installStatus() == InstallStatus.DOWNLOADING) {
      long bytesDownloaded = state.bytesDownloaded();
      long totalBytesToDownload = state.totalBytesToDownload();
      // Implement progress bar.
  }
  // Log state or install the update.
};

// Before starting an update, register a listener for updates.
appUpdateManager.registerListener(listener);

// Start an update.

// When status updates are no longer needed, unregister the listener.
appUpdateManager.unregisterListener(listener);

ज़रूरत के मुताबिक अपडेट इंस्टॉल करना

InstallStatus.DOWNLOADED की स्थिति का पता चलने पर, आपको इसे फिर से शुरू करना होगा अपडेट इंस्टॉल करने के लिए ऐप्लिकेशन.

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

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

नीचे दिए गए उदाहरण में, किसी मटीरियल डिज़ाइन को लागू करने के बारे में बताया गया है स्नैकबार को ऐप्लिकेशन को रीस्टार्ट करने के लिए उपयोगकर्ता की पुष्टि:

Kotlin

val listener = { state ->
    if (state.installStatus() == InstallStatus.DOWNLOADED) {
        // After the update is downloaded, show a notification
        // and request user confirmation to restart the app.
        popupSnackbarForCompleteUpdate()
    }
    ...
}

// Displays the snackbar notification and call to action.
fun popupSnackbarForCompleteUpdate() {
    Snackbar.make(
        findViewById(R.id.activity_main_layout),
        "An update has just been downloaded.",
        Snackbar.LENGTH_INDEFINITE
    ).apply {
        setAction("RESTART") { appUpdateManager.completeUpdate() }
        setActionTextColor(resources.getColor(R.color.snackbar_action_text_color))
        show()
    }
}

Java

InstallStateUpdatedListener listener = state -> {
    if (state.installStatus() == InstallStatus.DOWNLOADED) {
        // After the update is downloaded, show a notification
        // and request user confirmation to restart the app.
        popupSnackbarForCompleteUpdate();
    }
    ...
};

// Displays the snackbar notification and call to action.
private void popupSnackbarForCompleteUpdate() {
  Snackbar snackbar =
      Snackbar.make(
          findViewById(R.id.activity_main_layout),
          "An update has just been downloaded.",
          Snackbar.LENGTH_INDEFINITE);
  snackbar.setAction("RESTART", view -> appUpdateManager.completeUpdate());
  snackbar.setActionTextColor(
      getResources().getColor(R.color.snackbar_action_text_color));
  snackbar.show();
}

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

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

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

Kotlin

// Checks that the update is not stalled during 'onResume()'.
// However, you should execute this check at all app entry points.
override fun onResume() {
    super.onResume()

    appUpdateManager
        .appUpdateInfo
        .addOnSuccessListener { appUpdateInfo ->
            ...
            // If the update is downloaded but not installed,
            // notify the user to complete the update.
            if (appUpdateInfo.installStatus() == InstallStatus.DOWNLOADED) {
                popupSnackbarForCompleteUpdate()
            }
        }
}

Java

// Checks that the update is not stalled during 'onResume()'.
// However, you should execute this check at all app entry points.
@Override
protected void onResume() {
  super.onResume();

  appUpdateManager
      .getAppUpdateInfo()
      .addOnSuccessListener(appUpdateInfo -> {
              ...
              // If the update is downloaded but not installed,
              // notify the user to complete the update.
              if (appUpdateInfo.installStatus() == InstallStatus.DOWNLOADED) {
                  popupSnackbarForCompleteUpdate();
              }
          });
}

तुरंत अपडेट मैनेज करना

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

हालांकि, जब आपका ऐप्लिकेशन फ़ोरग्राउंड में वापस लौटता है, तो आपको इस बात की पुष्टि करनी चाहिए कि अपडेट रोका नहीं गया है, UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS राज्य. अगर इस स्थिति में अपडेट रुक जाता है, तो अपडेट को फिर से शुरू करें:

Kotlin

// Checks that the update is not stalled during 'onResume()'.
// However, you should execute this check at all entry points into the app.
override fun onResume() {
    super.onResume()

    appUpdateManager
        .appUpdateInfo
        .addOnSuccessListener { appUpdateInfo ->
            ...
            if (appUpdateInfo.updateAvailability()
                == UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS
            ) {
                // If an in-app update is already running, resume the update.
                appUpdateManager.startUpdateFlowForResult(
                  appUpdateInfo,
                  activityResultLauncher,
                  AppUpdateOptions.newBuilder(AppUpdateType.IMMEDIATE).build())
            }
        }
}

Java

// Checks that the update is not stalled during 'onResume()'.
// However, you should execute this check at all entry points into the app.
@Override
protected void onResume() {
  super.onResume();

  appUpdateManager
      .getAppUpdateInfo()
      .addOnSuccessListener(
          appUpdateInfo -> {
            ...
            if (appUpdateInfo.updateAvailability()
                == UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS) {
                // If an in-app update is already running, resume the update.
                appUpdateManager.startUpdateFlowForResult(
                  appUpdateInfo,
                  activityResultLauncher,
                  AppUpdateOptions.newBuilder(AppUpdateType.IMMEDIATE).build());
            }
          });
}

अपडेट फ़्लो, ऐसे नतीजे दिखाता है जो रेफ़रंस दस्तावेज़ में बताए गए हैं startUpdateFlowForresults() पर पुष्टि करें. खास तौर पर, आपके ऐप्लिकेशन को उन मामलों में मदद मिलनी चाहिए जहां कोई उपयोगकर्ता अपडेट या डाउनलोड को रद्द करता है. जब उपयोगकर्ता इनमें से कोई एक कार्रवाई करता है, Google Play का यूज़र इंटरफ़ेस (यूआई) बंद हो जाता है. आपके ऐप्लिकेशन को आगे बढ़ने का सबसे अच्छा तरीका तय करना चाहिए.

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

अगले चरण

पुष्टि करने के लिए, अपने ऐप्लिकेशन के इन-ऐप्लिकेशन अपडेट की जांच करना आपका इंटिग्रेशन ठीक से काम कर रहा है.