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

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

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

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

Groovy

// 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 से अपडेट की सूचना मिलने के बाद से कितना समय बीत चुका है. इससे आपको यह तय करने में मदद मिल सकती है कि आपको ज़रूरत के हिसाब से अपडेट करना है या तुरंत अपडेट करना है. उदाहरण के लिए, उपयोगकर्ता को किसी अपडेट के बारे में सूचना देने से पहले, कुछ दिन इंतज़ार किया जा सकता है. इसके बाद, कुछ दिन बाद ही उसे तुरंत अपडेट करने के लिए कहा जा सकता है.

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

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 सबसे ज़्यादा प्राथमिकता वाली वैल्यू होती है. किसी अपडेट की प्राथमिकता सेट करने के लिए, Google Play Developer API में Edits.tracks.releases में मौजूद inAppUpdatePriority फ़ील्ड का इस्तेमाल करें. रिलीज़ में जोड़े गए सभी नए वर्शन को, रिलीज़ के बराबर प्राथमिकता दी जाती है. प्राथमिकता सिर्फ़ नई रिलीज़ को रोल आउट करते समय सेट की जा सकती है और इसे बाद में बदला नहीं जा सकता.

Play Developer API के दस्तावेज़ में बताए गए तरीके से, Google Play Developer API का इस्तेमाल करके प्राथमिकता सेट करें. इन-ऐप्लिकेशन अपडेट की प्राथमिकता, Edit.tracks: update तरीके में पास किए गए Edit.tracks संसाधन में बताई जानी चाहिए. यहां दिए गए उदाहरण में, वर्शन कोड 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 पर सेट होता है. हालांकि, इसे true पर सेट करने के लिए, setAllowAssetPackDeletion() के तरीके का इस्तेमाल किया जा सकता है:

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());

चेतावनी: AllowAssetPackDeletion API विकल्प का इस्तेमाल सावधानी से करें, ताकि गलती से ऐसेट न मिट जाएं. इस विकल्प को true पर सेट करने से पहले, देखें कि false पर सेट करने पर, अपडेट करने की अनुमति है या नहीं.

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

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

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() callback से आपको कई वैल्यू मिल सकती हैं:

• 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, ऐप्लिकेशन को रीस्टार्ट करने की सुविधा को अपने-आप ट्रिगर नहीं करता. ऐसा इसलिए होता है, क्योंकि ज़रूरत के हिसाब से किए जाने वाले अपडेट के दौरान, उपयोगकर्ता को ऐप्लिकेशन के साथ तब तक इंटरैक्ट करते रहना होगा, जब तक वह अपडेट को इंस्टॉल करने का फ़ैसला नहीं ले लेता.

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

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

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());
            }
          });
}

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

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

अगले चरण

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