Exceptions that can be returned through the ParcelableException on the callback's
* {@code onError} method:
*
callback) {
Objects.requireNonNull(executor);
Objects.requireNonNull(callback);
try {
mService.isDeviceLocked(
new IIsDeviceLockedCallback.Stub() {
@Override
public void onIsDeviceLocked(boolean locked) {
executor.execute(() -> callback.onResult(locked));
}
@Override
public void onError(ParcelableException parcelableException) {
executor.execute(() ->
callback.onError(parcelableException.getException()));
}
});
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Clear device restrictions.
*
* After a device determines that it's part of a program (e.g. financing) by checking in with
* the device lock backend, it will go though a provisioning flow and install a kiosk app.
*
*
At this point, the device is "restricted" and the creditor kiosk app is able to lock
* the device. For example, a creditor kiosk app in a financing use case may lock the device
* (using {@link #lockDevice}) if payments are missed and unlock (using {@link #unlockDevice}))
* once they are resumed.
*
*
The Device Lock solution will also put in place some additional restrictions when a device
* is enrolled in the program, namely:
*
*
* - Disable debugging features
* ({@link android.os.UserManager#DISALLOW_DEBUGGING_FEATURES})
*
- Disable installing from unknown sources
* ({@link android.os.UserManager#DISALLOW_INSTALL_UNKNOWN_SOURCES},
* when configured in the backend)
*
- Disable outgoing calls
* ({@link android.os.UserManager#DISALLOW_OUTGOING_CALLS},
* when configured in the backend and the device is locked)
*
*
* Once the program is completed (e.g. the device has been fully paid off), the kiosk app
* can use the {@link #clearDeviceRestrictions} API to lift the above restrictions.
*
*
At this point, the kiosk app has relinquished its ability to lock the device.
*
*
Exceptions that can be returned through the ParcelableException on the callback's
* {@code onError} method:
*
* - {@link SecurityException} if the caller is missing the
* {@link android.android.Manifest.permission.MANAGE_DEVICE_LOCK_STATE} permission.
*
- {@link IllegalStateException} if the device has already been cleared or if
* policies could not be enforced for the clear state.
*
- {@link java.util.concurrent.TimeoutException} if the response from the
* underlying binder call is not received within the specified duration
* (10 seconds).
*
*
* @param executor the {@link Executor} on which to invoke the callback.
* @param callback this returns either success or an exception.
* @throws RuntimeException if there are binder communications errors
*/
@RequiresPermission(permission.MANAGE_DEVICE_LOCK_STATE)
@FlaggedApi(FLAG_CLEAR_DEVICE_RESTRICTIONS)
public void clearDeviceRestrictions(@NonNull @CallbackExecutor Executor executor,
@NonNull OutcomeReceiver callback) {
Objects.requireNonNull(executor);
Objects.requireNonNull(callback);
try {
mService.clearDeviceRestrictions(
new IVoidResultCallback.Stub() {
@Override
public void onSuccess() {
executor.execute(() -> callback.onResult(/* result= */ null));
}
@Override
public void onError(ParcelableException parcelableException) {
callback.onError(parcelableException.getException());
}
}
);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Gets the device id.
*
* Exceptions that can be returned through the ParcelableException on the callback's
* {@code onError} method:
*
* - {@link SecurityException} if the caller is missing the
* {@link android.android.Manifest.permission.MANAGE_DEVICE_LOCK_STATE} permission.
*
- {@link IllegalStateException} if no registered Device ID is found.
*
- {@link java.util.concurrent.TimeoutException} if the response from the
* underlying binder call is not received within the specified duration
* (10 seconds).
*
*
* @param executor the {@link Executor} on which to invoke the callback.
* @param callback this returns either the {@link DeviceId} or an exception.
* @throws RuntimeException if there are binder communications errors
*/
@RequiresPermission(permission.MANAGE_DEVICE_LOCK_STATE)
public void getDeviceId(@NonNull @CallbackExecutor Executor executor,
@NonNull OutcomeReceiver callback) {
Objects.requireNonNull(executor);
Objects.requireNonNull(callback);
try {
mService.getDeviceId(
new IGetDeviceIdCallback.Stub() {
@Override
public void onDeviceIdReceived(int type, String id) {
if (TextUtils.isEmpty(id)) {
executor.execute(() -> {
callback.onError(new Exception("Cannot get device id (empty)"));
});
} else {
executor.execute(() -> {
callback.onResult(new DeviceId(type, id));
});
}
}
@Override
public void onError(ParcelableException parcelableException) {
callback.onError(parcelableException.getException());
}
}
);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Get the kiosk app roles and packages.
*
* @param executor the {@link Executor} on which to invoke the callback.
* @param callback this returns either a {@link Map} of device roles/package names,
* or an exception. The Integer in the map represent the device lock role
* (at this moment, the only supported role is
* {@value #DEVICE_LOCK_ROLE_FINANCING}. The String represents the package
* name of the kiosk app for that role.
* @throws RuntimeException if there are binder communications errors
*/
@RequiresNoPermission
public void getKioskApps(@NonNull @CallbackExecutor Executor executor,
@NonNull OutcomeReceiver, Exception> callback) {
Objects.requireNonNull(executor);
Objects.requireNonNull(callback);
try {
mService.getKioskApps(
new IGetKioskAppsCallback.Stub() {
@Override
public void onKioskAppsReceived(Map kioskApps) {
executor.execute(() -> callback.onResult(kioskApps));
}
@Override
public void onError(ParcelableException parcelableException) {
callback.onError(parcelableException.getException());
}
}
);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Get the device lock solution enrollment type.
*
* The enrollment type is returned asynchronously by the callback as an integer whose
* value can be one of {@link ENROLLMENT_TYPE_NONE}, {@link ENROLLMENT_TYPE_FINANCE},
* {@link ENROLLMENT_TYPE_SUBSIDY}.
*
*
Exceptions that can be returned through the ParcelableException on the callback's
* {@code onError} method:
*
* - {@link SecurityException} if the caller is missing the
* {@link android.android.Manifest.permission.GET_DEVICE_LOCK_ENROLLMENT_TYPE} permission.
*
- {@link java.util.concurrent.TimeoutException} if the response from the
* underlying binder call is not received within the specified duration
* (10 seconds).
*
*
* @param executor the {@link Executor} on which to invoke the callback.
* @param callback returns either the enrollment type or an exception.
* @throws RuntimeException if there are binder communications errors
*
* @hide
*/
@SystemApi
@FlaggedApi(FLAG_GET_ENROLLMENT_TYPE)
@RequiresPermission(permission.GET_DEVICE_LOCK_ENROLLMENT_TYPE)
public void getEnrollmentType(
@NonNull @CallbackExecutor Executor executor,
@NonNull OutcomeReceiver<@EnrollmentType Integer, Exception> callback) {
Objects.requireNonNull(executor);
Objects.requireNonNull(callback);
try {
mService.getEnrollmentType(
new IGetEnrollmentTypeCallback.Stub() {
@Override
public void onEnrollmentTypeReceived(@EnrollmentType int enrollmentType) {
executor.execute(() -> callback.onResult(enrollmentType));
}
@Override
public void onError(ParcelableException parcelableException) {
callback.onError(parcelableException.getException());
}
}
);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Notifies DLC that kiosk set-up has finished and we no longer need to
* lock to the set-up activity.
*
* This will close the set-up activity as specified through a callback and
* then respect the current device lock state. If the device has never been
* locked or unlocked by the kiosk, it will unlock the device. Invoking
* {@link #lockDevice} or {@link #unlockDevice} will also result in the
* device provision state moving from kiosk_provisioned to
* provision_success.
*
* Exceptions that can be returned through the ParcelableException on the callback's
* {@code onError} method:
*
* - {@link SecurityException} if the caller is missing the
* {@link android.android.Manifest.permission.MANAGE_DEVICE_LOCK_STATE} permission.
*
- {@link IllegalStateException} if the device has already been cleared or if
* policies could not be enforced for the lock or unlock state.
*
- {@link java.util.concurrent.TimeoutException} if the response from the
* underlying binder call is not received within the specified duration
* (10 seconds).
*
*
* @param executor the {@link Executor} on which to invoke the callback.
* @param callback this returns either success or an exception.
* @throws RuntimeException if there are binder communications errors
*/
@RequiresPermission(permission.MANAGE_DEVICE_LOCK_STATE)
@FlaggedApi(FLAG_NOTIFY_KIOSK_SETUP_FINISHED)
public void notifyKioskSetupFinished(
@NonNull @CallbackExecutor Executor executor,
@NonNull OutcomeReceiver callback){
Objects.requireNonNull(executor);
Objects.requireNonNull(callback);
try {
mService.notifyKioskSetupFinished(
new IVoidResultCallback.Stub() {
@Override
public void onSuccess() {
executor.execute(() -> callback.onResult(/* result= */ null));
}
@Override
public void onError(ParcelableException parcelableException) {
callback.onError(parcelableException.getException());
}
}
);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}