121 | * IMPORTANT: there's no SUCCESS state because the app is reloaded when the install process 122 | * finishes, so there's no need to emit that specific state. 123 | *
124 | * The enums represent the following states: 125 | *
126 | * - UNKNOWN: the update state is not known 127 | * - DENIED: the update has been denied by the user. It will only happen in immediate installs. 128 | * - REQUIRES_UI_INTENT: needs an UI Intent 129 | * - UPDATE_ACCEPTED: the user pressed the "update" button in the in-app update prompt. 130 | * - PENDING: the update is pending 131 | * - DOWNLOADING: the update is currently downloading 132 | * - DOWNLOADED: the update is downloaded, the user can be prompted to install it in this case 133 | * - INSTALLING: the update is currently being installed 134 | * - INSTALLED: the update has been installed 135 | * - FAILED: the update failed 136 | * - CANCELED: the update has been canceled, but it can be resumed in another moment. 137 | */ 138 | public enum Status { 139 | UNKNOWN, 140 | DENIED, 141 | REQUIRES_UI_INTENT, 142 | UPDATE_ACCEPTED, 143 | PENDING, 144 | DOWNLOADING, 145 | DOWNLOADED, 146 | INSTALLING, 147 | INSTALLED, 148 | FAILED, 149 | CANCELED; 150 | 151 | static Status from(@NonNull InstallState state) { 152 | switch (state.installStatus()) { 153 | case InstallStatus.REQUIRES_UI_INTENT: 154 | return Status.REQUIRES_UI_INTENT; 155 | case InstallStatus.PENDING: 156 | return Status.PENDING; 157 | case InstallStatus.DOWNLOADING: 158 | return Status.DOWNLOADING; 159 | case InstallStatus.DOWNLOADED: 160 | return Status.DOWNLOADED; 161 | case InstallStatus.INSTALLING: 162 | return Status.INSTALLING; 163 | case InstallStatus.INSTALLED: 164 | return Status.INSTALLED; 165 | case InstallStatus.FAILED: 166 | return Status.FAILED; 167 | case InstallStatus.CANCELED: 168 | return Status.CANCELED; 169 | case InstallStatus.UNKNOWN: 170 | default: 171 | return Status.UNKNOWN; 172 | } 173 | } 174 | } 175 | 176 | /** 177 | * Specific enum related to an app install error code. It will always be present in {@link AppUpdateInstallState} 178 | * (even in non-error cases, then the value of this field will be NO_ERROR) 179 | *
180 | * The enums represent the following states: 181 | *
182 | * - NO_ERROR: No error occurred; all types of update flow are allowed. 183 | * - ERROR_UNKNOWN: An unknown error occurred. 184 | * - ERROR_API_NOT_AVAILABLE: The API is not available on this device (such as when the device is not supported). 185 | * - ERROR_INVALID_REQUEST: The request that was sent by the app is malformed. 186 | * - ERROR_INSTALL_UNAVAILABLE: The install is unavailable to this user or device. 187 | * - ERROR_INSTALL_NOT_ALLOWED: The download/install is not allowed, due to the current device state (e.g. low battery, low disk space…) 188 | * - ERROR_DOWNLOAD_NOT_PRESENT: The install/update has not been (fully) downloaded yet. 189 | * - ERROR_APP_NOT_OWNED: The user hasn't acquired the app via Play 190 | * - ERROR_PLAY_STORE_NOT_FOUND: The Play Store app is either not installed or not the official version. 191 | * - ERROR_INTERNAL_ERROR: An internal error happened in the Play Store. 192 | */ 193 | public enum ErrorCode { 194 | NO_ERROR, 195 | ERROR_UNKNOWN, 196 | ERROR_API_NOT_AVAILABLE, 197 | ERROR_INVALID_REQUEST, 198 | ERROR_INSTALL_UNAVAILABLE, 199 | ERROR_INSTALL_NOT_ALLOWED, 200 | ERROR_DOWNLOAD_NOT_PRESENT, 201 | ERROR_APP_NOT_OWNED, 202 | ERROR_PLAY_STORE_NOT_FOUND, 203 | ERROR_INTERNAL_ERROR; 204 | 205 | static ErrorCode from(InstallState state) { 206 | switch (state.installErrorCode()) { 207 | case InstallErrorCode.NO_ERROR: 208 | return ErrorCode.NO_ERROR; 209 | case InstallErrorCode.ERROR_API_NOT_AVAILABLE: 210 | return ErrorCode.ERROR_API_NOT_AVAILABLE; 211 | case InstallErrorCode.ERROR_INVALID_REQUEST: 212 | return ErrorCode.ERROR_INVALID_REQUEST; 213 | case InstallErrorCode.ERROR_INSTALL_UNAVAILABLE: 214 | return ErrorCode.ERROR_INSTALL_UNAVAILABLE; 215 | case InstallErrorCode.ERROR_INSTALL_NOT_ALLOWED: 216 | return ErrorCode.ERROR_INSTALL_NOT_ALLOWED; 217 | case InstallErrorCode.ERROR_DOWNLOAD_NOT_PRESENT: 218 | return ErrorCode.ERROR_DOWNLOAD_NOT_PRESENT; 219 | case InstallErrorCode.ERROR_APP_NOT_OWNED: 220 | return ErrorCode.ERROR_APP_NOT_OWNED; 221 | case InstallErrorCode.ERROR_PLAY_STORE_NOT_FOUND: 222 | return ErrorCode.ERROR_PLAY_STORE_NOT_FOUND; 223 | case InstallErrorCode.ERROR_INTERNAL_ERROR: 224 | return ErrorCode.ERROR_INTERNAL_ERROR; 225 | case InstallErrorCode.ERROR_UNKNOWN: 226 | //noinspection deprecation 227 | case InstallErrorCode.NO_ERROR_PARTIALLY_ALLOWED: 228 | default: 229 | return ErrorCode.ERROR_UNKNOWN; 230 | } 231 | } 232 | 233 | @InstallErrorCode 234 | int getValue() { 235 | switch (this) { 236 | case NO_ERROR: 237 | return InstallErrorCode.NO_ERROR; 238 | case ERROR_API_NOT_AVAILABLE: 239 | return InstallErrorCode.ERROR_API_NOT_AVAILABLE; 240 | case ERROR_INVALID_REQUEST: 241 | return InstallErrorCode.ERROR_INVALID_REQUEST; 242 | case ERROR_INSTALL_UNAVAILABLE: 243 | return InstallErrorCode.ERROR_INSTALL_UNAVAILABLE; 244 | case ERROR_INSTALL_NOT_ALLOWED: 245 | return InstallErrorCode.ERROR_INSTALL_NOT_ALLOWED; 246 | case ERROR_DOWNLOAD_NOT_PRESENT: 247 | return InstallErrorCode.ERROR_DOWNLOAD_NOT_PRESENT; 248 | case ERROR_APP_NOT_OWNED: 249 | return InstallErrorCode.ERROR_APP_NOT_OWNED; 250 | case ERROR_PLAY_STORE_NOT_FOUND: 251 | return InstallErrorCode.ERROR_PLAY_STORE_NOT_FOUND; 252 | case ERROR_INTERNAL_ERROR: 253 | return InstallErrorCode.ERROR_INTERNAL_ERROR; 254 | case ERROR_UNKNOWN: 255 | default: 256 | return InstallErrorCode.ERROR_UNKNOWN; 257 | } 258 | } 259 | } 260 | } 261 | -------------------------------------------------------------------------------- /lib/src/main/java/com/hyperdevs/appupdateshelper/AppUpdatesHelper.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2021 HyperDevs 3 | * 4 | * Copyright (C) 2019 BQ 5 | * 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 7 | * you may not use this file except in compliance with the License. 8 | * You may obtain a copy of the License at 9 | * 10 | * http://www.apache.org/licenses/LICENSE-2.0 11 | * 12 | * Unless required by applicable law or agreed to in writing, software 13 | * distributed under the License is distributed on an "AS IS" BASIS, 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 | * See the License for the specific language governing permissions and 16 | * limitations under the License. 17 | */ 18 | 19 | package com.hyperdevs.appupdateshelper; 20 | 21 | import android.app.Activity; 22 | import android.content.Context; 23 | import android.content.Intent; 24 | import android.content.IntentSender; 25 | import android.os.Bundle; 26 | import android.util.Log; 27 | import android.view.View; 28 | 29 | import com.google.android.gms.tasks.OnCompleteListener; 30 | import com.google.android.gms.tasks.Task; 31 | import com.google.android.play.core.appupdate.AppUpdateInfo; 32 | import com.google.android.play.core.appupdate.AppUpdateManager; 33 | import com.google.android.play.core.appupdate.AppUpdateManagerFactory; 34 | import com.google.android.play.core.install.InstallState; 35 | import com.google.android.play.core.install.InstallStateUpdatedListener; 36 | import com.google.android.play.core.install.model.AppUpdateType; 37 | 38 | import androidx.annotation.NonNull; 39 | import androidx.fragment.app.Fragment; 40 | 41 | import static android.app.Activity.RESULT_CANCELED; 42 | import static com.google.android.play.core.install.model.ActivityResult.RESULT_IN_APP_UPDATE_FAILED; 43 | 44 | /** 45 | * Helper class used to simplify the use of the In-App Updates library from Google. 46 | *
47 | * Its use is as follows: 48 | * - Register it using {@link #startListening(InstallStateListener)}, for example in {@link Activity#onCreate(Bundle)} or in {@link Fragment#onViewCreated(View, Bundle)}. 49 | * - Unregister it using {@link #stopListening()}, for example in {@link Activity#onDestroy()} or in {@link Fragment#onDestroyView()}. 50 | * - Call {@link #onUpdateStatusResult(int, int)} in your Activity's 51 | * {@link Activity#onActivityResult(int, int, Intent)} or your Fragment's {@link Fragment#onActivityResult(int, int, Intent)} so the helper can properly report status 52 | * updates. 53 | * - When you want to check if there are any updates, call {@link #getAppUpdateInfo(GetUpdateInfoListener)}. 54 | * - When you want to perform an update, call {@link #startImmediateUpdate(Activity)}/{@link #startImmediateUpdate(Fragment)} 55 | * or {@link #startFlexibleUpdate(Activity)}/{@link #startFlexibleUpdate(Fragment)} after successfully receiving an update via 56 | * {@link #getAppUpdateInfo(GetUpdateInfoListener)}. 57 | */ 58 | @SuppressWarnings("JavadocReference") 59 | public class AppUpdatesHelper { 60 | static final int IMMEDIATE_UPDATE_REQUEST_CODE = 13371; 61 | static final int FLEXIBLE_UPDATE_REQUEST_CODE = 13372; 62 | 63 | private static final String TAG = "AppUpdatesHelper"; 64 | 65 | private final AppUpdateManager manager; 66 | private InstallStateListener installStateListener; 67 | private boolean isListening = false; 68 | private AppUpdateInfo appUpdateInfo = null; 69 | private InstallStateUpdatedListener installStateUpdatedListener; 70 | 71 | /** 72 | * Creates a helper instance with a given context. 73 | * 74 | * @param context Context to use to build the helper. 75 | */ 76 | public AppUpdatesHelper(@NonNull Context context) { 77 | this(AppUpdateManagerFactory.create(context)); 78 | } 79 | 80 | /** 81 | * Creates a helper instance with a given app update manager. 82 | * 83 | * @param appUpdateManager app update manager to use. 84 | */ 85 | AppUpdatesHelper(@NonNull AppUpdateManager appUpdateManager) { 86 | this.manager = appUpdateManager; 87 | } 88 | 89 | /** 90 | * Starts listening for app updates and install changes. 91 | */ 92 | public void startListening(@NonNull final InstallStateListener installStateListener) { 93 | if (!isListening) { 94 | this.isListening = true; 95 | this.installStateListener = installStateListener; 96 | this.installStateUpdatedListener = new InstallStateUpdatedListener() { 97 | @Override 98 | public void onStateUpdate(InstallState installState) { 99 | AppUpdateInstallState state = new AppUpdateInstallState(installState); 100 | Log.d(TAG, "Update status result: " + state.toString()); 101 | 102 | installStateListener.onInstallStateUpdate(state); 103 | } 104 | }; 105 | this.manager.registerListener(installStateUpdatedListener); 106 | } 107 | } 108 | 109 | /** 110 | * Stops listening for app updates and install changes. 111 | */ 112 | public void stopListening() { 113 | isListening = false; 114 | manager.unregisterListener(installStateUpdatedListener); 115 | } 116 | 117 | /** 118 | * Starts an app update check. 119 | *
120 | * The method must only be called after calling {@link #startListening(InstallStateListener)}.
121 | *
122 | * @param getUpdateInfoListener Callback that will emit an {@link AppUpdateInfoResult} object after finishing
123 | * querying for possible updates.
124 | */
125 | public void getAppUpdateInfo(@NonNull final GetUpdateInfoListener getUpdateInfoListener) {
126 | if (!isListening)
127 | throw new IllegalStateException("You must call startListening() before requesting update info");
128 |
129 | final Task
153 | * The method must only be called after calling {@link #startListening(InstallStateListener)}.
154 | *
155 | * @param activity The {@link Activity} to link to the update.
156 | */
157 | public void startImmediateUpdate(@NonNull Activity activity) {
158 | if (!isListening)
159 | throw new IllegalStateException("You must call startListening() " +
160 | "before requesting an immediate update");
161 | if (appUpdateInfo == null)
162 | throw new IllegalStateException("You must call getAppUpdateInfo() " +
163 | "with a successful response before requesting an immediate update");
164 |
165 | try {
166 | manager.startUpdateFlowForResult(
167 | appUpdateInfo,
168 | AppUpdateType.IMMEDIATE,
169 | activity,
170 | IMMEDIATE_UPDATE_REQUEST_CODE);
171 | } catch (IntentSender.SendIntentException e) {
172 | e.printStackTrace();
173 | }
174 | }
175 |
176 | /**
177 | * Starts an immediate update.
178 | * It will receive callbacks in {@link InstallStateListener}.
179 | *
180 | * The method must only be called after calling {@link #startListening(InstallStateListener)}.
181 | *
182 | * @param activity The {@link Fragment} to link to the update.
183 | */
184 | public void startImmediateUpdate(@NonNull Fragment fragment) {
185 | if (!isListening)
186 | throw new IllegalStateException("You must call startListening() " +
187 | "before requesting an immediate update");
188 | if (appUpdateInfo == null)
189 | throw new IllegalStateException("You must call getAppUpdateInfo() " +
190 | "with a successful response before requesting an immediate update");
191 |
192 | try {
193 | manager.startUpdateFlowForResult(
194 | appUpdateInfo,
195 | AppUpdateType.IMMEDIATE,
196 | fragment::startIntentSenderForResult,
197 | IMMEDIATE_UPDATE_REQUEST_CODE);
198 | } catch (IntentSender.SendIntentException e) {
199 | e.printStackTrace();
200 | }
201 | }
202 |
203 | /**
204 | * Starts a flexible update.
205 | * It will receive callbacks in {@link InstallStateListener}.
206 | *
207 | * The method must only be called after calling {@link #startListening(InstallStateListener)}
208 | * and {@link #getAppUpdateInfo(GetUpdateInfoListener)}.
209 | *
210 | * @param activity The {@link Activity} to link to the update.
211 | */
212 | public void startFlexibleUpdate(@NonNull Activity activity) {
213 | if (!isListening)
214 | throw new IllegalStateException("You must call startListening() " +
215 | "before requesting a flexible update");
216 | if (appUpdateInfo == null)
217 | throw new IllegalStateException("You must call getAppUpdateInfo() " +
218 | "with a successful response before requesting a flexible update");
219 |
220 | try {
221 | manager.startUpdateFlowForResult(
222 | appUpdateInfo,
223 | AppUpdateType.FLEXIBLE,
224 | activity,
225 | FLEXIBLE_UPDATE_REQUEST_CODE);
226 | } catch (IntentSender.SendIntentException e) {
227 | e.printStackTrace();
228 | }
229 | }
230 |
231 | /**
232 | * Starts a flexible update.
233 | * It will receive callbacks in {@link InstallStateListener}.
234 | *
235 | * The method must only be called after calling {@link #startListening(InstallStateListener)}
236 | * and {@link #getAppUpdateInfo(GetUpdateInfoListener)}.
237 | *
238 | * @param activity The {@link Fragment} to link to the update.
239 | */
240 | public void startFlexibleUpdate(@NonNull Fragment fragment) {
241 | if (!isListening)
242 | throw new IllegalStateException("You must call startListening() " +
243 | "before requesting a flexible update");
244 | if (appUpdateInfo == null)
245 | throw new IllegalStateException("You must call getAppUpdateInfo() " +
246 | "with a successful response before requesting a flexible update");
247 |
248 | try {
249 | manager.startUpdateFlowForResult(
250 | appUpdateInfo,
251 | AppUpdateType.FLEXIBLE,
252 | fragment::startIntentSenderForResult,
253 | FLEXIBLE_UPDATE_REQUEST_CODE);
254 | } catch (IntentSender.SendIntentException e) {
255 | e.printStackTrace();
256 | }
257 | }
258 |
259 | /**
260 | * Called to process {@link Activity#onActivityResult(int, int, Intent)} results for the
261 | * in-app updates installStateListener.
262 | *
263 | * @param requestCode {@link Activity#onActivityResult(int, int, Intent)}'s request code
264 | * @param resultCode {@link Activity#onActivityResult(int, int, Intent)}'s result code
265 | */
266 | public void onUpdateStatusResult(int requestCode, int resultCode) {
267 | if (requestCode == IMMEDIATE_UPDATE_REQUEST_CODE || requestCode == FLEXIBLE_UPDATE_REQUEST_CODE) {
268 | AppUpdateInstallState state;
269 | switch (resultCode) {
270 | case RESULT_CANCELED:
271 | if (requestCode == IMMEDIATE_UPDATE_REQUEST_CODE)
272 | state = new AppUpdateInstallState(
273 | AppUpdateInstallState.Status.DENIED,
274 | AppUpdateInstallState.ErrorCode.ERROR_INSTALL_NOT_ALLOWED,
275 | AppUpdateInstallState.BYTES_UNKNOWN,
276 | AppUpdateInstallState.BYTES_UNKNOWN
277 | );
278 | else
279 | state = new AppUpdateInstallState(
280 | AppUpdateInstallState.Status.CANCELED,
281 | AppUpdateInstallState.ErrorCode.ERROR_INSTALL_NOT_ALLOWED,
282 | AppUpdateInstallState.BYTES_UNKNOWN,
283 | AppUpdateInstallState.BYTES_UNKNOWN);
284 | break;
285 | case RESULT_IN_APP_UPDATE_FAILED:
286 | // We don't know why the update failed, so return an unknown error
287 | state = new AppUpdateInstallState(
288 | AppUpdateInstallState.Status.FAILED,
289 | AppUpdateInstallState.ErrorCode.ERROR_UNKNOWN,
290 | AppUpdateInstallState.BYTES_UNKNOWN,
291 | AppUpdateInstallState.BYTES_UNKNOWN
292 | );
293 | break;
294 | default:
295 | // If everything goes well, do stuff
296 | state = new AppUpdateInstallState(
297 | AppUpdateInstallState.Status.UPDATE_ACCEPTED,
298 | AppUpdateInstallState.ErrorCode.NO_ERROR,
299 | AppUpdateInstallState.BYTES_UNKNOWN,
300 | AppUpdateInstallState.BYTES_UNKNOWN
301 | );
302 | break;
303 | }
304 |
305 | Log.d(TAG, "Update status result: " + state.toString());
306 |
307 | if (installStateListener != null) {
308 | installStateListener.onInstallStateUpdate(state);
309 | }
310 | }
311 | }
312 |
313 | /**
314 | * Completes an unfinished installation (for example, when finishing downloading a flexible
315 | * installation).
316 | *
317 | * The method must only be called after calling {@link #startListening(InstallStateListener)}
318 | * and {@link #getAppUpdateInfo(GetUpdateInfoListener)}.
319 | */
320 | public void completeUpdate() {
321 | if (!isListening)
322 | throw new IllegalStateException("You must call startListening() " +
323 | "before completing an update");
324 | if (appUpdateInfo == null)
325 | throw new IllegalStateException("You must call getAppUpdateInfo() " +
326 | "before completing an update");
327 |
328 | manager.completeUpdate();
329 | }
330 | }
331 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/hyperdevs/appupdateshelper/ContextUtils.java:
--------------------------------------------------------------------------------
1 | package com.hyperdevs.appupdateshelper;
2 |
3 | import android.content.Context;
4 | import android.os.Build;
5 |
6 | public class ContextUtils {
7 | /**
8 | * Constant to use in [registerReceiver] to declare that a registered receiver is not exported.
9 | *
10 | * This is needed as the constant does not exist in Android < 34
11 | */
12 | public static int getReceiverNotExported() {
13 | int value;
14 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
15 | value = Context.RECEIVER_NOT_EXPORTED;
16 | } else {
17 | value = 0;
18 | }
19 | return value;
20 | }
21 |
22 | /**
23 | * Constant to use in [registerReceiver] to declare that a registered receiver is exported.
24 | *
25 | * This is needed as the constant does not exist in Android < 34
26 | */
27 | public static int getReceiverExported() {
28 | int value;
29 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
30 | value = Context.RECEIVER_EXPORTED;
31 | } else {
32 | value = 0;
33 | }
34 | return value;
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/hyperdevs/appupdateshelper/FakeAppUpdatesHelper.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2021 HyperDevs
3 | *
4 | * Copyright (C) 2019 BQ
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | package com.hyperdevs.appupdateshelper;
20 |
21 | import android.content.Context;
22 |
23 | import com.google.android.play.core.appupdate.AppUpdateManager;
24 | import com.google.android.play.core.appupdate.testing.FakeAppUpdateManager;
25 |
26 | import androidx.annotation.NonNull;
27 | import androidx.annotation.Nullable;
28 |
29 | import static android.app.Activity.RESULT_CANCELED;
30 | import static android.app.Activity.RESULT_OK;
31 |
32 | /**
33 | * A fake implementation of the {@link AppUpdatesHelper}, backed by a {@link FakeAppUpdateManager}.
34 | *
35 | * This implementation is completely self-contained in the library and does not interact with the Play Store. For this reason no UI is
36 | * being shown and no update is really performed.
37 | *
38 | * The developer can simulate the most common user actions, download progress and failure scenarios.
39 | *
40 | * It is designed to be used for unit-tests and early development iterations. It is not meant for full stack integration tests:
41 | * the latter can be performed by uploading your app to Play and sideload an older version (modified so it can trigger an in-app update)
42 | * onto your test device.
43 | */
44 | @SuppressWarnings("JavadocReference")
45 | public class FakeAppUpdatesHelper extends AppUpdatesHelper {
46 | private final FakeAppUpdateManager fakeAppUpdateManager;
47 |
48 | public FakeAppUpdatesHelper(@NonNull Context context) {
49 | this(new FakeAppUpdateManager(context));
50 | }
51 |
52 | private FakeAppUpdatesHelper(@NonNull AppUpdateManager appUpdateManager) {
53 | super(appUpdateManager);
54 | fakeAppUpdateManager = (FakeAppUpdateManager) appUpdateManager;
55 | }
56 |
57 | /**
58 | * Declares that an update is available and provides its version code.
59 | *
60 | * @param availableVersionCode the available update's version code
61 | */
62 | public void setUpdateAvailable(int availableVersionCode) {
63 | fakeAppUpdateManager.setUpdateAvailable(availableVersionCode);
64 | }
65 |
66 | /**
67 | * Declares that no updates are available.
68 | */
69 | public void setUpdateNotAvailable() {
70 | fakeAppUpdateManager.setUpdateNotAvailable();
71 | }
72 |
73 | /**
74 | * Simulates user click on the positive button in the update confirmation dialog. The download is enqueued in
75 | * {@link AppUpdateInstallState.Status.PENDING PENDING} status.
76 | *
77 | * Works only if {@link #isConfirmationDialogVisible()} or {@link #isImmediateFlowVisible()} is true.
78 | *
79 | * In the real implementation a {@link android.app.Activity.RESULT_OK} would also be received by the calling activity's
80 | * {@link android.app.Activity#onActivityResult}.
81 | */
82 | public void userAcceptsUpdate() {
83 | // Since the fake updater does not trigger onActivityResult, we have to manually trigger the ACCEPTED callback.
84 | int requestCode = getRequestCode();
85 |
86 | fakeAppUpdateManager.userAcceptsUpdate();
87 | onUpdateStatusResult(requestCode, RESULT_OK);
88 | }
89 |
90 | /**
91 | * Returns which type of update is currently in progress or null if no update is in progress.
92 | */
93 | @Nullable
94 | public Integer getTypeForUpdateInProgress() {
95 | return fakeAppUpdateManager.getTypeForUpdateInProgress();
96 | }
97 |
98 | /**
99 | * Simulates user canceling the download via the Play UI.
100 | *
101 | * Works only if the download of an update is pending or downloading.
102 | */
103 | public void userCancelsDownload() {
104 | fakeAppUpdateManager.userCancelsDownload();
105 | }
106 |
107 | /**
108 | * Simulates user click on the negative button in the currently active update flow.
109 | *
110 | * Works only if {@link #isConfirmationDialogVisible()} or {@link #isImmediateFlowVisible()} is true.
111 | *
112 | * In the real implementation a {@link android.app.Activity.RESULT_CANCELED} would also be received by the calling activity's
113 | * {@link android.app.Activity#onActivityResult}.
114 | */
115 | public void userRejectsUpdate() {
116 | // Since the fake updater does not trigger onActivityResult, we first have to check which
117 | // view is being shown (immediate or flexible) and then trigger the onUpdateStatusResult
118 | // callback manually
119 | int requestCode = getRequestCode();
120 |
121 | fakeAppUpdateManager.userRejectsUpdate();
122 | onUpdateStatusResult(requestCode, RESULT_CANCELED);
123 | }
124 |
125 | /**
126 | * Simulates the download completing.
127 | *
128 | * Works only after {@link #userAcceptsUpdate()}.
129 | */
130 | public void downloadStarts() {
131 | fakeAppUpdateManager.downloadStarts();
132 | }
133 |
134 | /**
135 | * Simulates the download starting.
136 | *
137 | * Works only after {@link #downloadStarts()}.
138 | */
139 | public void downloadCompletes() {
140 | fakeAppUpdateManager.downloadCompletes();
141 | }
142 |
143 | /**
144 | * Simulates a download failure.
145 | *
146 | * Works only if the download of an update is pending or downloading.
147 | */
148 | public void downloadFails() {
149 | fakeAppUpdateManager.downloadFails();
150 | }
151 |
152 | /**
153 | * Simulates the download completing.
154 | *
155 | * Works only after {@link #completeUpdate()} has been triggered by the application.
156 | */
157 | public void installCompletes() {
158 | fakeAppUpdateManager.installCompletes();
159 | }
160 |
161 | /**
162 | * Simulates an install failure.
163 | *
164 | * Works only if the update is already installing (after a call to {@link #completeUpdate()}).
165 | */
166 | public void installFails() {
167 | fakeAppUpdateManager.installFails();
168 | }
169 |
170 | /**
171 | * Sets an error code which will be returned by the next API calls.
172 | *
173 | * The error code is being honored by {@link #getAppUpdateInfo()} and {@link #completeUpdate()}; the error code is not being honored
174 | * if a more severe workflow error happens, e.g. if {@link #completeUpdate()} is called when the update is not downloaded yet.
175 | *
176 | * The error code is persistent: to return to the default behaviour, you can reset the value by calling the same method with
177 | * {@link AppUpdateInstallState.ErrorCode.NO_ERROR}.
178 | *
179 | * @param installErrorCode the install error code
180 | */
181 | public void setInstallErrorCode(AppUpdateInstallState.ErrorCode installErrorCode) {
182 | fakeAppUpdateManager.setInstallErrorCode(installErrorCode.getValue());
183 | }
184 |
185 | /**
186 | * Returns whether the user confirmation screen of the immediate update is visible to the user.
187 | */
188 | public boolean isConfirmationDialogVisible() {
189 | return fakeAppUpdateManager.isConfirmationDialogVisible();
190 | }
191 |
192 | /**
193 | * Returns whether the user confirmation screen of the immediate update is visible to the user.
194 | */
195 | public boolean isImmediateFlowVisible() {
196 | return fakeAppUpdateManager.isImmediateFlowVisible();
197 | }
198 |
199 | /**
200 | * Returns whether the splash screen is visible to the user. This happens during update completion:
201 | * in the real implementation your app is reloaded with the new version.
202 | */
203 | public boolean isInstallSplashScreenVisible() {
204 | return fakeAppUpdateManager.isInstallSplashScreenVisible();
205 | }
206 |
207 | private int getRequestCode() {
208 | if (isImmediateFlowVisible()) {
209 | return IMMEDIATE_UPDATE_REQUEST_CODE;
210 | }
211 | if (isConfirmationDialogVisible()) {
212 | return FLEXIBLE_UPDATE_REQUEST_CODE;
213 | }
214 | return -1;
215 | }
216 |
217 | }
218 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/hyperdevs/appupdateshelper/GetUpdateInfoListener.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2021 HyperDevs
3 | *
4 | * Copyright (C) 2019 BQ
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | package com.hyperdevs.appupdateshelper;
20 |
21 | import androidx.annotation.NonNull;
22 |
23 | /**
24 | * Callback listener to obtain information about a finished update info request.
25 | */
26 | public interface GetUpdateInfoListener {
27 | /**
28 | * Triggered when an app info request has finished.
29 | *
30 | * @param result The result of the app info request whether is an error or not
31 | */
32 | void onGetUpdateInfoComplete(@NonNull AppUpdateInfoResult result);
33 | }
34 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/hyperdevs/appupdateshelper/InstallStateListener.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2021 HyperDevs
3 | *
4 | * Copyright (C) 2019 BQ
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | package com.hyperdevs.appupdateshelper;
20 |
21 | import androidx.annotation.NonNull;
22 |
23 | /**
24 | * Listener that emits changes when an app update installation event happens.
25 | */
26 | public interface InstallStateListener {
27 | /**
28 | * Triggered on an app update installation event is emitted.
29 | *
30 | * @param state App update installation event
31 | */
32 | void onInstallStateUpdate(@NonNull AppUpdateInstallState state);
33 | }
34 |
--------------------------------------------------------------------------------
/lib/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
18 |
19 |