com.google.android.play.core.appupdate.AppUpdateInfo Java Examples

private void checkUpdate() {
    // Checks that the platform will allow the specified type of update.
    Log.d(TAG, "Checking for updates");
    appUpdateInfoTask.addOnSuccessListener(new OnSuccessListener<AppUpdateInfo>() {
        @Override
        public void onSuccess(AppUpdateInfo appUpdateInfo) {
            if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE
                    && appUpdateInfo.isUpdateTypeAllowed(mode)) {
                // Request the update.
                Log.d(TAG, "Update available");
                startUpdate(appUpdateInfo);
            } else {
                Log.d(TAG, "No Update available");
            }
        }
    });
}
 

public void addUpdateInfoListener(final UpdateInfoListener updateInfoListener) {
    appUpdateInfoTask.addOnSuccessListener(new OnSuccessListener<AppUpdateInfo>() {
        @Override
        public void onSuccess(AppUpdateInfo appUpdateInfo) {
            if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE) {
                // Request the update.
                Log.d(TAG, "Update available");
                int availableVersionCode = appUpdateInfo.availableVersionCode();
                int stalenessDays = appUpdateInfo.clientVersionStalenessDays() != null ? appUpdateInfo
                        .clientVersionStalenessDays() : -1;
                updateInfoListener.onReceiveVersionCode(availableVersionCode);
                updateInfoListener.onReceiveStalenessDays(stalenessDays);
            } else {
                Log.d(TAG, "No Update available");
            }
        }
    });
}
 

private void startUpdate(AppUpdateInfo appUpdateInfo) {
    try {
        Log.d(TAG, "Starting update");
        appUpdateManager.startUpdateFlowForResult(
                appUpdateInfo,
                mode,
                getActivity(),
                UpdateManagerConstant.REQUEST_CODE);
    } catch (IntentSender.SendIntentException e) {
        Log.d(TAG, "" + e.getMessage());
    }
}
 

private void continueUpdateForFlexible() {
    instance.appUpdateManager
            .getAppUpdateInfo()
            .addOnSuccessListener(new OnSuccessListener<AppUpdateInfo>() {
                @Override
                public void onSuccess(AppUpdateInfo appUpdateInfo) {
                    // If the update is downloaded but not installed,
                    // notify the user to complete the update.
                    if (appUpdateInfo.installStatus() == InstallStatus.DOWNLOADED) {
                        Log.d(TAG, "An update has been downloaded");
                        instance.popupSnackbarForCompleteUpdate();
                    }
                }
            });
}
 

private void continueUpdateForImmediate() {
    instance.appUpdateManager
            .getAppUpdateInfo()
            .addOnSuccessListener(new OnSuccessListener<AppUpdateInfo>() {
                @Override
                public void onSuccess(AppUpdateInfo appUpdateInfo) {
                    if (appUpdateInfo.updateAvailability()
                            == UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS) {
                        // If an in-app update is already running, resume the update.
                        try {
                            instance.appUpdateManager.startUpdateFlowForResult(
                                    appUpdateInfo,
                                    instance.mode,
                                    getActivity(),
                                    UpdateManagerConstant.REQUEST_CODE);
                        } catch (IntentSender.SendIntentException e) {
                            Log.d(TAG, "" + e.getMessage());
                        }
                    }
                }
            });
}
 

/**
 * Check for update availability. If there will be an update available
 * will start the update process with the selected {@link UpdateMode}.
 */
private void checkForUpdate(final boolean startUpdate) {

    // 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(new OnSuccessListener<AppUpdateInfo>() {
        @Override
        public void onSuccess(AppUpdateInfo appUpdateInfo) {
            inAppUpdateStatus.setAppUpdateInfo(appUpdateInfo);

            if (startUpdate) {
                if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE) {
                    // Request the update.
                    if (mode == UpdateMode.FLEXIBLE && appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.FLEXIBLE)) {
                        // Start an update.
                        startAppUpdateFlexible(appUpdateInfo);
                    } else if (appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)) {
                        // Start an update.
                        startAppUpdateImmediate(appUpdateInfo);
                    }

                    Log.d(LOG_TAG, "checkForAppUpdate(): Update available. Version Code: " + appUpdateInfo.availableVersionCode());
                } else if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_NOT_AVAILABLE) {
                    Log.d(LOG_TAG, "checkForAppUpdate(): No Update available. Code: " + appUpdateInfo.updateAvailability());
                }
            }

            reportStatus();
        }
    });

}
 

private void startAppUpdateImmediate(AppUpdateInfo appUpdateInfo) {
    try {
        appUpdateManager.startUpdateFlowForResult(
                appUpdateInfo,
                AppUpdateType.IMMEDIATE,
                // The current activity making the update request.
                activity,
                // Include a request code to later monitor this update request.
                requestCode);
    } catch (IntentSender.SendIntentException e) {
        Log.e(LOG_TAG, "error in startAppUpdateImmediate", e);
        reportUpdateError(Constants.UPDATE_ERROR_START_APP_UPDATE_IMMEDIATE, e);
    }
}
 

private void startAppUpdateFlexible(AppUpdateInfo appUpdateInfo) {
    try {
        appUpdateManager.startUpdateFlowForResult(
                appUpdateInfo,
                AppUpdateType.FLEXIBLE,
                // The current activity making the update request.
                activity,
                // Include a request code to later monitor this update request.
                requestCode);
    } catch (IntentSender.SendIntentException e) {
        Log.e(LOG_TAG, "error in startAppUpdateFlexible", e);
        reportUpdateError(Constants.UPDATE_ERROR_START_APP_UPDATE_FLEXIBLE, e);
    }
}
 

/**
 * Checks that the update is not stalled during 'onResume()'.
 * However, you should execute this check at all app entry points.
 */
private void checkNewAppVersionState() {

    appUpdateManager
            .getAppUpdateInfo()
            .addOnSuccessListener(new OnSuccessListener<AppUpdateInfo>() {
                @Override
                public void onSuccess(AppUpdateInfo appUpdateInfo) {

                    inAppUpdateStatus.setAppUpdateInfo(appUpdateInfo);

                    //FLEXIBLE:
                    // If the update is downloaded but not installed,
                    // notify the user to complete the update.
                    if (appUpdateInfo.installStatus() == InstallStatus.DOWNLOADED) {
                        popupSnackbarForUserConfirmation();
                        reportStatus();
                        Log.d(LOG_TAG, "checkNewAppVersionState(): resuming flexible update. Code: " + appUpdateInfo.updateAvailability());
                    }

                    //IMMEDIATE:
                    if (appUpdateInfo.updateAvailability() == UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS) {
                        // If an in-app update is already running, resume the update.
                        startAppUpdateImmediate(appUpdateInfo);

                        Log.d(LOG_TAG, "checkNewAppVersionState(): resuming immediate update. Code: " + appUpdateInfo.updateAvailability());

                    }
                }
            });

}
 

private void checkUpdate() {
    appUpdateInfoTask = appUpdateManager.getAppUpdateInfo();
    appUpdateInfoTask.addOnSuccessListener(new OnSuccessListener<AppUpdateInfo>() {
        @Override
        public void onSuccess(AppUpdateInfo appUpdateInfo) {
            showMessage("updateAvailability: " + appUpdateInfo.updateAvailability() +
                    " isUpdateTypeAllowed: " + appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE));
            if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE
                    && appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)) {
                requestUpdate(appUpdateInfo);
            }
        }
    });
}
 

private void requestUpdate(AppUpdateInfo appUpdateInfo) {
    try {
        appUpdateManager.startUpdateFlowForResult(
                appUpdateInfo,
                AppUpdateType.IMMEDIATE,
                MainActivity.this,
                REQUEST_CODE_FLEXIBLE_UPDATE);
    } catch (IntentSender.SendIntentException e) {
        showMessage("Request update error");
    }
}
 

@Override
protected void onResume() {
    super.onResume();
    appUpdateManager.getAppUpdateInfo().addOnSuccessListener(new OnSuccessListener<AppUpdateInfo>() {
        @Override
        public void onSuccess(AppUpdateInfo result) {
            if (result.installStatus() == InstallStatus.DOWNLOADED) {
                notifyUser();
            }
        }
    });
}
 

public void setAppUpdateInfo(AppUpdateInfo appUpdateInfo) {
    this.appUpdateInfo = appUpdateInfo;
}