Java tutorial
/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.os; import android.Manifest; import android.accounts.AccountManager; import android.annotation.IntDef; import android.annotation.NonNull; import android.annotation.Nullable; import android.annotation.RequiresPermission; import android.annotation.SystemApi; import android.annotation.SystemService; import android.annotation.TestApi; import android.annotation.UnsupportedAppUsage; import android.annotation.UserIdInt; import android.annotation.WorkerThread; import android.app.Activity; import android.app.ActivityManager; import android.app.admin.DevicePolicyManager; import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.content.IntentSender; import android.content.pm.UserInfo; import android.content.res.Configuration; import android.content.res.Resources; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Rect; import android.graphics.drawable.Drawable; import android.provider.Settings; import android.telephony.TelephonyManager; import android.view.WindowManager.LayoutParams; import com.android.internal.R; import com.android.internal.os.RoSystemProperties; import java.io.IOException; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.util.ArrayList; import java.util.List; /** * Manages users and user details on a multi-user system. There are two major categories of * users: fully customizable users with their own login, and managed profiles that share a workspace * with a related user. * <p> * Users are different from accounts, which are managed by * {@link AccountManager}. Each user can have their own set of accounts. * <p> * See {@link DevicePolicyManager#ACTION_PROVISION_MANAGED_PROFILE} for more on managed profiles. */ @SystemService(Context.USER_SERVICE) public class UserManager { private static final String TAG = "UserManager"; @UnsupportedAppUsage private final IUserManager mService; private final Context mContext; private Boolean mIsManagedProfileCached; /** * @hide * No user restriction. */ @SystemApi public static final int RESTRICTION_NOT_SET = 0x0; /** * @hide * User restriction set by system/user. */ @SystemApi public static final int RESTRICTION_SOURCE_SYSTEM = 0x1; /** * @hide * User restriction set by a device owner. */ @SystemApi public static final int RESTRICTION_SOURCE_DEVICE_OWNER = 0x2; /** * @hide * User restriction set by a profile owner. */ @SystemApi public static final int RESTRICTION_SOURCE_PROFILE_OWNER = 0x4; /** @hide */ @Retention(RetentionPolicy.SOURCE) @IntDef(flag = true, prefix = { "RESTRICTION_" }, value = { RESTRICTION_NOT_SET, RESTRICTION_SOURCE_SYSTEM, RESTRICTION_SOURCE_DEVICE_OWNER, RESTRICTION_SOURCE_PROFILE_OWNER }) @SystemApi public @interface UserRestrictionSource { } /** * Specifies if a user is disallowed from adding and removing accounts, unless they are * {@link android.accounts.AccountManager#addAccountExplicitly programmatically} added by * Authenticator. * The default value is <code>false</code>. * * <p>From {@link android.os.Build.VERSION_CODES#N} a profile or device owner app can still * use {@link android.accounts.AccountManager} APIs to add or remove accounts when account * management is disallowed. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_MODIFY_ACCOUNTS = "no_modify_accounts"; /** * Specifies if a user is disallowed from changing Wi-Fi * access points. The default value is <code>false</code>. * <p>This restriction has no effect in a managed profile. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CONFIG_WIFI = "no_config_wifi"; /** * Specifies if a user is disallowed from changing the device * language. The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CONFIG_LOCALE = "no_config_locale"; /** * Specifies if a user is disallowed from installing applications. This user restriction also * prevents device owners and profile owners installing apps. The default value is * {@code false}. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_INSTALL_APPS = "no_install_apps"; /** * Specifies if a user is disallowed from uninstalling applications. * The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_UNINSTALL_APPS = "no_uninstall_apps"; /** * Specifies if a user is disallowed from turning on location sharing. * The default value is <code>false</code>. * <p>In a managed profile, location sharing always reflects the primary user's setting, but * can be overridden and forced off by setting this restriction to true in the managed profile. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_SHARE_LOCATION = "no_share_location"; /** * Specifies if airplane mode is disallowed on the device. * * <p> This restriction can only be set by the device owner and the profile owner on the * primary user and it applies globally - i.e. it disables airplane mode on the entire device. * <p>The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_AIRPLANE_MODE = "no_airplane_mode"; /** * Specifies if a user is disallowed from configuring brightness. When device owner sets it, * it'll only be applied on the target(system) user. * * <p>The default value is <code>false</code>. * * <p>This user restriction has no effect on managed profiles. * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CONFIG_BRIGHTNESS = "no_config_brightness"; /** * Specifies if ambient display is disallowed for the user. * * <p>The default value is <code>false</code>. * * <p>This user restriction has no effect on managed profiles. * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_AMBIENT_DISPLAY = "no_ambient_display"; /** * Specifies if a user is disallowed from changing screen off timeout. * * <p>The default value is <code>false</code>. * * <p>This user restriction has no effect on managed profiles. * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CONFIG_SCREEN_TIMEOUT = "no_config_screen_timeout"; /** * Specifies if a user is disallowed from enabling the * "Unknown Sources" setting, that allows installation of apps from unknown sources. * The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_INSTALL_UNKNOWN_SOURCES = "no_install_unknown_sources"; /** * Specifies if a user is disallowed from configuring bluetooth. * This does <em>not</em> restrict the user from turning bluetooth on or off. * The default value is <code>false</code>. * <p>This restriction doesn't prevent the user from using bluetooth. For disallowing usage of * bluetooth completely on the device, use {@link #DISALLOW_BLUETOOTH}. * <p>This restriction has no effect in a managed profile. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CONFIG_BLUETOOTH = "no_config_bluetooth"; /** * Specifies if bluetooth is disallowed on the device. * * <p> This restriction can only be set by the device owner and the profile owner on the * primary user and it applies globally - i.e. it disables bluetooth on the entire device. * <p>The default value is <code>false</code>. * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_BLUETOOTH = "no_bluetooth"; /** * Specifies if outgoing bluetooth sharing is disallowed on the device. Device owner and profile * owner can set this restriction. When it is set by device owner, all users on this device will * be affected. * * <p>Default is <code>true</code> for managed profiles and false for otherwise. When a device * upgrades to {@link android.os.Build.VERSION_CODES#O}, the system sets it for all existing * managed profiles. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_BLUETOOTH_SHARING = "no_bluetooth_sharing"; /** * Specifies if a user is disallowed from transferring files over * USB. This can only be set by device owners and profile owners on the primary user. * The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_USB_FILE_TRANSFER = "no_usb_file_transfer"; /** * Specifies if a user is disallowed from configuring user * credentials. The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CONFIG_CREDENTIALS = "no_config_credentials"; /** * When set on the primary user this specifies if the user can remove other users. * When set on a secondary user, this specifies if the user can remove itself. * This restriction has no effect on managed profiles. * The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_REMOVE_USER = "no_remove_user"; /** * Specifies if managed profiles of this user can be removed, other than by its profile owner. * The default value is <code>false</code>. * <p> * This restriction has no effect on managed profiles. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_REMOVE_MANAGED_PROFILE = "no_remove_managed_profile"; /** * Specifies if a user is disallowed from enabling or * accessing debugging features. The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_DEBUGGING_FEATURES = "no_debugging_features"; /** * Specifies if a user is disallowed from configuring a VPN. The default value is * <code>false</code>. This restriction has an effect when set by device owners and, in Android * 6.0 ({@linkplain android.os.Build.VERSION_CODES#M API level 23}) or higher, profile owners. * <p>This restriction also prevents VPNs from starting. However, in Android 7.0 * ({@linkplain android.os.Build.VERSION_CODES#N API level 24}) or higher, the system does * start always-on VPNs created by the device or profile owner. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CONFIG_VPN = "no_config_vpn"; /** * Specifies if a user is disallowed from enabling or disabling location providers. As a * result, user is disallowed from turning on or off location. Device owner and profile owners * can set this restriction and it only applies on the managed user. * * <p>In a managed profile, location sharing is forced off when it's off on primary user, so * user can still turn off location sharing on managed profile when the restriction is set by * profile owner on managed profile. * * <p>This user restriction is different from {@link #DISALLOW_SHARE_LOCATION}, * as the device owner or profile owner can still enable or disable location mode via * {@link DevicePolicyManager#setSecureSetting} when this restriction is on. * * <p>The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see android.location.LocationManager#isProviderEnabled(String) * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CONFIG_LOCATION = "no_config_location"; /** * Specifies if date, time and timezone configuring is disallowed. * * <p>When restriction is set by device owners, it applies globally - i.e., it disables date, * time and timezone setting on the entire device and all users will be affected. When it's set * by profile owners, it's only applied to the managed user. * <p>The default value is <code>false</code>. * * <p>This user restriction has no effect on managed profiles. * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CONFIG_DATE_TIME = "no_config_date_time"; /** * Specifies if a user is disallowed from configuring Tethering * & portable hotspots. This can only be set by device owners and profile owners on the * primary user. The default value is <code>false</code>. * <p>In Android 9.0 or higher, if tethering is enabled when this restriction is set, * tethering will be automatically turned off. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CONFIG_TETHERING = "no_config_tethering"; /** * Specifies if a user is disallowed from resetting network settings * from Settings. This can only be set by device owners and profile owners on the primary user. * The default value is <code>false</code>. * <p>This restriction has no effect on secondary users and managed profiles since only the * primary user can reset the network settings of the device. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_NETWORK_RESET = "no_network_reset"; /** * Specifies if a user is disallowed from factory resetting * from Settings. This can only be set by device owners and profile owners on the primary user. * The default value is <code>false</code>. * <p>This restriction has no effect on secondary users and managed profiles since only the * primary user can factory reset the device. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_FACTORY_RESET = "no_factory_reset"; /** * Specifies if a user is disallowed from adding new users. This can only be set by device * owners and profile owners on the primary user. * The default value is <code>false</code>. * <p>This restriction has no effect on secondary users and managed profiles since only the * primary user can add other users. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_ADD_USER = "no_add_user"; /** * Specifies if a user is disallowed from adding managed profiles. * <p>The default value for an unmanaged user is <code>false</code>. * For users with a device owner set, the default is <code>true</code>. * <p>This restriction has no effect on managed profiles. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_ADD_MANAGED_PROFILE = "no_add_managed_profile"; /** * Specifies if a user is disallowed from disabling application verification. The default * value is <code>false</code>. * * <p>In Android 8.0 ({@linkplain android.os.Build.VERSION_CODES#O API level 26}) and higher, * this is a global user restriction. If a device owner or profile owner sets this restriction, * the system enforces app verification across all users on the device. Running in earlier * Android versions, this restriction affects only the profile that sets it. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String ENSURE_VERIFY_APPS = "ensure_verify_apps"; /** * Specifies if a user is disallowed from configuring cell * broadcasts. This can only be set by device owners and profile owners on the primary user. * The default value is <code>false</code>. * <p>This restriction has no effect on secondary users and managed profiles since only the * primary user can configure cell broadcasts. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CONFIG_CELL_BROADCASTS = "no_config_cell_broadcasts"; /** * Specifies if a user is disallowed from configuring mobile * networks. This can only be set by device owners and profile owners on the primary user. * The default value is <code>false</code>. * <p>This restriction has no effect on secondary users and managed profiles since only the * primary user can configure mobile networks. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CONFIG_MOBILE_NETWORKS = "no_config_mobile_networks"; /** * Specifies if a user is disallowed from modifying * applications in Settings or launchers. The following actions will not be allowed when this * restriction is enabled: * <li>uninstalling apps</li> * <li>disabling apps</li> * <li>clearing app caches</li> * <li>clearing app data</li> * <li>force stopping apps</li> * <li>clearing app defaults</li> * <p> * The default value is <code>false</code>. * * <p><strong>Note:</strong> The user will still be able to perform those actions via other * means (such as adb). Third party apps will also be able to uninstall apps via the * {@link android.content.pm.PackageInstaller}. {@link #DISALLOW_UNINSTALL_APPS} or * {@link DevicePolicyManager#setUninstallBlocked(ComponentName, String, boolean)} should be * used to prevent the user from uninstalling apps completely, and * {@link DevicePolicyManager#addPersistentPreferredActivity(ComponentName, IntentFilter, ComponentName)} * to add a default intent handler for a given intent filter. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_APPS_CONTROL = "no_control_apps"; /** * Specifies if a user is disallowed from mounting * physical external media. This can only be set by device owners and profile owners on the * primary user. The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_MOUNT_PHYSICAL_MEDIA = "no_physical_media"; /** * Specifies if a user is disallowed from adjusting microphone volume. If set, the microphone * will be muted. This can be set by device owners and profile owners. The default value is * <code>false</code>. * * <p>This restriction has no effect on managed profiles. * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_UNMUTE_MICROPHONE = "no_unmute_microphone"; /** * Specifies if a user is disallowed from adjusting the master volume. If set, the master volume * will be muted. This can be set by device owners from API 21 and profile owners from API 24. * The default value is <code>false</code>. * * <p>When the restriction is set by profile owners, then it only applies to relevant * profiles. * * <p>This restriction has no effect on managed profiles. * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_ADJUST_VOLUME = "no_adjust_volume"; /** * Specifies that the user is not allowed to make outgoing * phone calls. Emergency calls are still permitted. * The default value is <code>false</code>. * <p>This restriction has no effect on managed profiles. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_OUTGOING_CALLS = "no_outgoing_calls"; /** * Specifies that the user is not allowed to send or receive * SMS messages. The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_SMS = "no_sms"; /** * Specifies if the user is not allowed to have fun. In some cases, the * device owner may wish to prevent the user from experiencing amusement or * joy while using the device. The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_FUN = "no_fun"; /** * Specifies that windows besides app windows should not be * created. This will block the creation of the following types of windows. * <li>{@link LayoutParams#TYPE_TOAST}</li> * <li>{@link LayoutParams#TYPE_PHONE}</li> * <li>{@link LayoutParams#TYPE_PRIORITY_PHONE}</li> * <li>{@link LayoutParams#TYPE_SYSTEM_ALERT}</li> * <li>{@link LayoutParams#TYPE_SYSTEM_ERROR}</li> * <li>{@link LayoutParams#TYPE_SYSTEM_OVERLAY}</li> * <li>{@link LayoutParams#TYPE_APPLICATION_OVERLAY}</li> * * <p>This can only be set by device owners and profile owners on the primary user. * The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CREATE_WINDOWS = "no_create_windows"; /** * Specifies that system error dialogs for crashed or unresponsive apps should not be shown. * In this case, the system will force-stop the app as if the user chooses the "close app" * option on the UI. A feedback report isn't collected as there is no way for the user to * provide explicit consent. The default value is <code>false</code>. * * <p>When this user restriction is set by device owners, it's applied to all users. When set by * the profile owner of the primary user or a secondary user, the restriction affects only the * calling user. This user restriction has no effect on managed profiles. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_SYSTEM_ERROR_DIALOGS = "no_system_error_dialogs"; /** * Specifies if what is copied in the clipboard of this profile can * be pasted in related profiles. Does not restrict if the clipboard of related profiles can be * pasted in this profile. * The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_CROSS_PROFILE_COPY_PASTE = "no_cross_profile_copy_paste"; /** * Specifies if the user is not allowed to use NFC to beam out data from apps. * The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_OUTGOING_BEAM = "no_outgoing_beam"; /** * Hidden user restriction to disallow access to wallpaper manager APIs. This restriction * generally means that wallpapers are not supported for the particular user. This user * restriction is always set for managed profiles, because such profiles don't have wallpapers. * @hide * @see #DISALLOW_SET_WALLPAPER * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_WALLPAPER = "no_wallpaper"; /** * User restriction to disallow setting a wallpaper. Profile owner and device owner * are able to set wallpaper regardless of this restriction. * The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_SET_WALLPAPER = "no_set_wallpaper"; /** * Specifies if the user is not allowed to reboot the device into safe boot mode. * This can only be set by device owners and profile owners on the primary user. * The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_SAFE_BOOT = "no_safe_boot"; /** * Specifies if a user is not allowed to record audio. This restriction is always enabled for * background users. The default value is <code>false</code>. * * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() * @hide */ @UnsupportedAppUsage public static final String DISALLOW_RECORD_AUDIO = "no_record_audio"; /** * Specifies if a user is not allowed to run in the background and should be stopped during * user switch. The default value is <code>false</code>. * * <p>This restriction can be set by device owners and profile owners. * * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() * @hide */ @SystemApi public static final String DISALLOW_RUN_IN_BACKGROUND = "no_run_in_background"; /** * Specifies if a user is not allowed to use the camera. * * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() * @hide */ public static final String DISALLOW_CAMERA = "no_camera"; /** * Specifies if a user is not allowed to unmute the device's master volume. * * @see DevicePolicyManager#setMasterVolumeMuted(ComponentName, boolean) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() * @hide */ public static final String DISALLOW_UNMUTE_DEVICE = "disallow_unmute_device"; /** * Specifies if a user is not allowed to use cellular data when roaming. This can only be set by * device owners. The default value is <code>false</code>. * * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_DATA_ROAMING = "no_data_roaming"; /** * Specifies if a user is not allowed to change their icon. Device owner and profile owner * can set this restriction. When it is set by device owner, only the target user will be * affected. The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_SET_USER_ICON = "no_set_user_icon"; /** * Specifies if a user is not allowed to enable the oem unlock setting. The default value is * <code>false</code>. Setting this restriction has no effect if the bootloader is already * unlocked. * * <p>Not for use by third-party applications. * * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() * @deprecated use {@link OemLockManager#setOemUnlockAllowedByCarrier(boolean, byte[])} instead. * @hide */ @Deprecated @SystemApi public static final String DISALLOW_OEM_UNLOCK = "no_oem_unlock"; /** * Specifies that the managed profile is not allowed to have unified lock screen challenge with * the primary user. * * <p><strong>Note:</strong> Setting this restriction alone doesn't automatically set a * separate challenge. Profile owner can ask the user to set a new password using * {@link DevicePolicyManager#ACTION_SET_NEW_PASSWORD} and verify it using * {@link DevicePolicyManager#isUsingUnifiedPassword(ComponentName)}. * * <p>Can be set by profile owners. It only has effect on managed profiles when set by managed * profile owner. Has no effect on non-managed profiles or users. * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_UNIFIED_PASSWORD = "no_unified_password"; /** * Allows apps in the parent profile to handle web links from the managed profile. * * This user restriction has an effect only in a managed profile. * If set: * Intent filters of activities in the parent profile with action * {@link android.content.Intent#ACTION_VIEW}, * category {@link android.content.Intent#CATEGORY_BROWSABLE}, scheme http or https, and which * define a host can handle intents from the managed profile. * The default value is <code>false</code>. * * <p>Key for user restrictions. * <p>Type: Boolean * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String ALLOW_PARENT_PROFILE_APP_LINKING = "allow_parent_profile_app_linking"; /** * Specifies if a user is not allowed to use Autofill Services. * * <p>Device owner and profile owner can set this restriction. When it is set by device owner, * only the target user will be affected. * * <p>The default value is <code>false</code>. * * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_AUTOFILL = "no_autofill"; /** * Specifies if user switching is blocked on the current user. * * <p> This restriction can only be set by the device owner, it will be applied to all users. * Device owner can still switch user via * {@link DevicePolicyManager#switchUser(ComponentName, UserHandle)} when this restriction is * set. * * <p>The default value is <code>false</code>. * * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_USER_SWITCH = "no_user_switch"; /** * Specifies whether the user can share file / picture / data from the primary user into the * managed profile, either by sending them from the primary side, or by picking up data within * an app in the managed profile. * <p> * When a managed profile is created, the system allows the user to send data from the primary * side to the profile by setting up certain default cross profile intent filters. If * this is undesired, this restriction can be set to disallow it. Note that this restriction * will not block any sharing allowed by explicit * {@link DevicePolicyManager#addCrossProfileIntentFilter} calls by the profile owner. * <p> * This restriction is only meaningful when set by profile owner. When it is set by device * owner, it does not have any effect. * <p> * The default value is <code>false</code>. * * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_SHARE_INTO_MANAGED_PROFILE = "no_sharing_into_profile"; /** * Specifies whether the user is allowed to print. * * This restriction can be set by device or profile owner. * * The default value is {@code false}. * * @see DevicePolicyManager#addUserRestriction(ComponentName, String) * @see DevicePolicyManager#clearUserRestriction(ComponentName, String) * @see #getUserRestrictions() */ public static final String DISALLOW_PRINTING = "no_printing"; /** * Application restriction key that is used to indicate the pending arrival * of real restrictions for the app. * * <p> * Applications that support restrictions should check for the presence of this key. * A <code>true</code> value indicates that restrictions may be applied in the near * future but are not available yet. It is the responsibility of any * management application that sets this flag to update it when the final * restrictions are enforced. * * <p>Key for application restrictions. * <p>Type: Boolean * @see android.app.admin.DevicePolicyManager#setApplicationRestrictions( * android.content.ComponentName, String, Bundle) * @see android.app.admin.DevicePolicyManager#getApplicationRestrictions( * android.content.ComponentName, String) */ public static final String KEY_RESTRICTIONS_PENDING = "restrictions_pending"; private static final String ACTION_CREATE_USER = "android.os.action.CREATE_USER"; /** * Extra containing a name for the user being created. Optional parameter passed to * ACTION_CREATE_USER activity. * @hide */ public static final String EXTRA_USER_NAME = "android.os.extra.USER_NAME"; /** * Extra containing account name for the user being created. Optional parameter passed to * ACTION_CREATE_USER activity. * @hide */ public static final String EXTRA_USER_ACCOUNT_NAME = "android.os.extra.USER_ACCOUNT_NAME"; /** * Extra containing account type for the user being created. Optional parameter passed to * ACTION_CREATE_USER activity. * @hide */ public static final String EXTRA_USER_ACCOUNT_TYPE = "android.os.extra.USER_ACCOUNT_TYPE"; /** * Extra containing account-specific data for the user being created. Optional parameter passed * to ACTION_CREATE_USER activity. * @hide */ public static final String EXTRA_USER_ACCOUNT_OPTIONS = "android.os.extra.USER_ACCOUNT_OPTIONS"; /** @hide */ public static final int PIN_VERIFICATION_FAILED_INCORRECT = -3; /** @hide */ public static final int PIN_VERIFICATION_FAILED_NOT_SET = -2; /** @hide */ public static final int PIN_VERIFICATION_SUCCESS = -1; /** * Sent when user restrictions have changed. * * @hide */ @SystemApi @TestApi // To allow seeing it from CTS. public static final String ACTION_USER_RESTRICTIONS_CHANGED = "android.os.action.USER_RESTRICTIONS_CHANGED"; /** * Error result indicating that this user is not allowed to add other users on this device. * This is a result code returned from the activity created by the intent * {@link #createUserCreationIntent(String, String, String, PersistableBundle)}. */ public static final int USER_CREATION_FAILED_NOT_PERMITTED = Activity.RESULT_FIRST_USER; /** * Error result indicating that no more users can be created on this device. * This is a result code returned from the activity created by the intent * {@link #createUserCreationIntent(String, String, String, PersistableBundle)}. */ public static final int USER_CREATION_FAILED_NO_MORE_USERS = Activity.RESULT_FIRST_USER + 1; /** * Indicates user operation is successful. */ public static final int USER_OPERATION_SUCCESS = 0; /** * Indicates user operation failed for unknown reason. */ public static final int USER_OPERATION_ERROR_UNKNOWN = 1; /** * Indicates user operation failed because target user is a managed profile. */ public static final int USER_OPERATION_ERROR_MANAGED_PROFILE = 2; /** * Indicates user operation failed because maximum running user limit has been reached. */ public static final int USER_OPERATION_ERROR_MAX_RUNNING_USERS = 3; /** * Indicates user operation failed because the target user is in the foreground. */ public static final int USER_OPERATION_ERROR_CURRENT_USER = 4; /** * Indicates user operation failed because device has low data storage. */ public static final int USER_OPERATION_ERROR_LOW_STORAGE = 5; /** * Indicates user operation failed because maximum user limit has been reached. */ public static final int USER_OPERATION_ERROR_MAX_USERS = 6; /** * Result returned from various user operations. * * @hide */ @Retention(RetentionPolicy.SOURCE) @IntDef(prefix = { "USER_OPERATION_" }, value = { USER_OPERATION_SUCCESS, USER_OPERATION_ERROR_UNKNOWN, USER_OPERATION_ERROR_MANAGED_PROFILE, USER_OPERATION_ERROR_MAX_RUNNING_USERS, USER_OPERATION_ERROR_CURRENT_USER, USER_OPERATION_ERROR_LOW_STORAGE, USER_OPERATION_ERROR_MAX_USERS }) public @interface UserOperationResult { } /** * Thrown to indicate user operation failed. */ public static class UserOperationException extends RuntimeException { private final @UserOperationResult int mUserOperationResult; /** * Constructs a UserOperationException with specific result code. * * @param message the detail message * @param userOperationResult the result code * @hide */ public UserOperationException(String message, @UserOperationResult int userOperationResult) { super(message); mUserOperationResult = userOperationResult; } /** * Returns the operation result code. */ public @UserOperationResult int getUserOperationResult() { return mUserOperationResult; } } /** @hide */ @UnsupportedAppUsage public static UserManager get(Context context) { return (UserManager) context.getSystemService(Context.USER_SERVICE); } /** @hide */ public UserManager(Context context, IUserManager service) { mService = service; mContext = context.getApplicationContext(); } /** * Returns whether this device supports multiple users with their own login and customizable * space. * @return whether the device supports multiple users. */ public static boolean supportsMultipleUsers() { return getMaxSupportedUsers() > 1 && SystemProperties.getBoolean("fw.show_multiuserui", Resources.getSystem().getBoolean(R.bool.config_enableMultiUserUI)); } /** * @hide * @return Whether the device is running with split system user. It means the system user and * primary user are two separate users. Previously system user and primary user are combined as * a single owner user. see @link {android.os.UserHandle#USER_OWNER} */ @TestApi public static boolean isSplitSystemUser() { return RoSystemProperties.FW_SYSTEM_USER_SPLIT; } /** * @return Whether guest user is always ephemeral * @hide */ public static boolean isGuestUserEphemeral() { return Resources.getSystem().getBoolean(com.android.internal.R.bool.config_guestUserEphemeral); } /** * Returns whether switching users is currently allowed. * <p>For instance switching users is not allowed if the current user is in a phone call, * system user hasn't been unlocked yet, or {@link #DISALLOW_USER_SWITCH} is set. * @hide */ public boolean canSwitchUsers() { boolean allowUserSwitchingWhenSystemUserLocked = Settings.Global.getInt(mContext.getContentResolver(), Settings.Global.ALLOW_USER_SWITCHING_WHEN_SYSTEM_USER_LOCKED, 0) != 0; boolean isSystemUserUnlocked = isUserUnlocked(UserHandle.SYSTEM); boolean inCall = TelephonyManager.getDefault().getCallState() != TelephonyManager.CALL_STATE_IDLE; boolean isUserSwitchDisallowed = hasUserRestriction(DISALLOW_USER_SWITCH); return (allowUserSwitchingWhenSystemUserLocked || isSystemUserUnlocked) && !inCall && !isUserSwitchDisallowed; } /** * Returns the user handle for the user that this process is running under. * * @return the user handle of this process. * @hide */ @UnsupportedAppUsage public @UserIdInt int getUserHandle() { return UserHandle.myUserId(); } /** * Returns the user name of the user making this call. This call is only * available to applications on the system image; it requires the * MANAGE_USERS permission. * @return the user name */ public String getUserName() { UserInfo user = getUserInfo(getUserHandle()); return user == null ? "" : user.name; } /** * Returns whether user name has been set. * <p>This method can be used to check that the value returned by {@link #getUserName()} was * set by the user and is not a placeholder string provided by the system. * @hide */ public boolean isUserNameSet() { try { return mService.isUserNameSet(getUserHandle()); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Used to determine whether the user making this call is subject to * teleportations. * * <p>As of {@link android.os.Build.VERSION_CODES#LOLLIPOP}, this method can * now automatically identify goats using advanced goat recognition technology.</p> * * @return Returns true if the user making this call is a goat. */ public boolean isUserAGoat() { return mContext.getPackageManager().isPackageAvailable("com.coffeestainstudios.goatsimulator"); } /** * Used to check if this process is running under the primary user. The primary user * is the first human user on a device. * * @return whether this process is running under the primary user. * @hide */ public boolean isPrimaryUser() { UserInfo user = getUserInfo(UserHandle.myUserId()); return user != null && user.isPrimary(); } /** * Used to check if this process is running under the system user. The system user * is the initial user that is implicitly created on first boot and hosts most of the * system services. * * @return whether this process is running under the system user. */ public boolean isSystemUser() { return UserHandle.myUserId() == UserHandle.USER_SYSTEM; } /** * @hide * Returns whether the caller is running as an admin user. There can be more than one admin * user. */ @UnsupportedAppUsage public boolean isAdminUser() { return isUserAdmin(UserHandle.myUserId()); } /** * @hide * Returns whether the provided user is an admin user. There can be more than one admin * user. */ @UnsupportedAppUsage public boolean isUserAdmin(@UserIdInt int userId) { UserInfo user = getUserInfo(userId); return user != null && user.isAdmin(); } /** * @hide * @deprecated Use {@link #isRestrictedProfile()} */ @UnsupportedAppUsage @Deprecated public boolean isLinkedUser() { return isRestrictedProfile(); } /** * Returns whether the caller is running as restricted profile. Restricted profile may have * a reduced number of available apps, app restrictions and account restrictions. * @return whether the user making this call is a linked user * @hide */ @SystemApi public boolean isRestrictedProfile() { try { return mService.isRestricted(); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Checks if specified user can have restricted profile. * @hide */ public boolean canHaveRestrictedProfile(@UserIdInt int userId) { try { return mService.canHaveRestrictedProfile(userId); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns whether the calling user has at least one restricted profile associated with it. * @return * @hide */ @SystemApi public boolean hasRestrictedProfiles() { try { return mService.hasRestrictedProfiles(); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Checks if a user is a guest user. * @return whether user is a guest user. * @hide */ @UnsupportedAppUsage public boolean isGuestUser(int id) { UserInfo user = getUserInfo(id); return user != null && user.isGuest(); } /** * Checks if the calling app is running as a guest user. * @return whether the caller is a guest user. * @hide */ public boolean isGuestUser() { UserInfo user = getUserInfo(UserHandle.myUserId()); return user != null && user.isGuest(); } /** * Checks if the calling app is running in a demo user. When running in a demo user, * apps can be more helpful to the user, or explain their features in more detail. * * @return whether the caller is a demo user. */ public boolean isDemoUser() { try { return mService.isDemoUser(UserHandle.myUserId()); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Checks if the calling app is running in a managed profile. * * @return whether the caller is in a managed profile. * @hide */ @SystemApi @RequiresPermission(android.Manifest.permission.MANAGE_USERS) public boolean isManagedProfile() { // No need for synchronization. Once it becomes non-null, it'll be non-null forever. // Worst case we might end up calling the AIDL method multiple times but that's fine. if (mIsManagedProfileCached != null) { return mIsManagedProfileCached; } try { mIsManagedProfileCached = mService.isManagedProfile(UserHandle.myUserId()); return mIsManagedProfileCached; } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Checks if the specified user is a managed profile. * Requires {@link android.Manifest.permission#MANAGE_USERS} permission, otherwise the caller * must be in the same profile group of specified user. * * @return whether the specified user is a managed profile. * @hide */ @SystemApi @RequiresPermission(android.Manifest.permission.MANAGE_USERS) public boolean isManagedProfile(@UserIdInt int userId) { if (userId == UserHandle.myUserId()) { return isManagedProfile(); } try { return mService.isManagedProfile(userId); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Gets badge for a managed profile. * Requires {@link android.Manifest.permission#MANAGE_USERS} permission, otherwise the caller * must be in the same profile group of specified user. * * @return which badge to use for the managed profile badge id will be less than * UserManagerService.getMaxManagedProfiles() * @hide */ public int getManagedProfileBadge(@UserIdInt int userId) { try { return mService.getManagedProfileBadge(userId); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Checks if the calling app is running as an ephemeral user. * * @return whether the caller is an ephemeral user. * @hide */ public boolean isEphemeralUser() { return isUserEphemeral(UserHandle.myUserId()); } /** * Returns whether the specified user is ephemeral. * @hide */ public boolean isUserEphemeral(@UserIdInt int userId) { final UserInfo user = getUserInfo(userId); return user != null && user.isEphemeral(); } /** * Return whether the given user is actively running. This means that * the user is in the "started" state, not "stopped" -- it is currently * allowed to run code through scheduled alarms, receiving broadcasts, * etc. A started user may be either the current foreground user or a * background user; the result here does not distinguish between the two. * * <p>Note prior to Android Nougat MR1 (SDK version <= 24; * {@link android.os.Build.VERSION_CODES#N}, this API required a system permission * in order to check other profile's status. * Since Android Nougat MR1 (SDK version >= 25; * {@link android.os.Build.VERSION_CODES#N_MR1}), the restriction has been relaxed, and now * it'll accept any {@link android.os.UserHandle} within the same profile group as the caller. * * @param user The user to retrieve the running state for. */ // Note this requires either INTERACT_ACROSS_USERS or MANAGE_USERS. public boolean isUserRunning(UserHandle user) { return isUserRunning(user.getIdentifier()); } /** {@hide} */ public boolean isUserRunning(@UserIdInt int userId) { try { return mService.isUserRunning(userId); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Return whether the given user is actively running <em>or</em> stopping. * This is like {@link #isUserRunning(UserHandle)}, but will also return * true if the user had been running but is in the process of being stopped * (but is not yet fully stopped, and still running some code). * * <p>Note prior to Android Nougat MR1 (SDK version <= 24; * {@link android.os.Build.VERSION_CODES#N}, this API required a system permission * in order to check other profile's status. * Since Android Nougat MR1 (SDK version >= 25; * {@link android.os.Build.VERSION_CODES#N_MR1}), the restriction has been relaxed, and now * it'll accept any {@link android.os.UserHandle} within the same profile group as the caller. * * @param user The user to retrieve the running state for. */ // Note this requires either INTERACT_ACROSS_USERS or MANAGE_USERS. public boolean isUserRunningOrStopping(UserHandle user) { try { // TODO: reconcile stopped vs stopping? return ActivityManager.getService().isUserRunning(user.getIdentifier(), ActivityManager.FLAG_OR_STOPPED); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Return whether the calling user is running in an "unlocked" state. * <p> * On devices with direct boot, a user is unlocked only after they've * entered their credentials (such as a lock pattern or PIN). On devices * without direct boot, a user is unlocked as soon as it starts. * <p> * When a user is locked, only device-protected data storage is available. * When a user is unlocked, both device-protected and credential-protected * private app data storage is available. * * @see Intent#ACTION_USER_UNLOCKED * @see Context#createDeviceProtectedStorageContext() */ public boolean isUserUnlocked() { return isUserUnlocked(Process.myUserHandle()); } /** * Return whether the given user is running in an "unlocked" state. * <p> * On devices with direct boot, a user is unlocked only after they've * entered their credentials (such as a lock pattern or PIN). On devices * without direct boot, a user is unlocked as soon as it starts. * <p> * When a user is locked, only device-protected data storage is available. * When a user is unlocked, both device-protected and credential-protected * private app data storage is available. * <p>Requires {@code android.permission.MANAGE_USERS} or * {@code android.permission.INTERACT_ACROSS_USERS}, otherwise specified {@link UserHandle user} * must be the calling user or a managed profile associated with it. * * @param user to retrieve the unlocked state for. * @see Intent#ACTION_USER_UNLOCKED * @see Context#createDeviceProtectedStorageContext() */ public boolean isUserUnlocked(UserHandle user) { return isUserUnlocked(user.getIdentifier()); } /** {@hide} */ @UnsupportedAppUsage public boolean isUserUnlocked(@UserIdInt int userId) { try { return mService.isUserUnlocked(userId); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** {@hide} */ public boolean isUserUnlockingOrUnlocked(UserHandle user) { return isUserUnlockingOrUnlocked(user.getIdentifier()); } /** {@hide} */ public boolean isUserUnlockingOrUnlocked(@UserIdInt int userId) { try { return mService.isUserUnlockingOrUnlocked(userId); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Return the time when the calling user started in elapsed milliseconds since boot, * or 0 if not started. * * @hide */ @UnsupportedAppUsage public long getUserStartRealtime() { try { return mService.getUserStartRealtime(); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Return the time when the calling user was unlocked elapsed milliseconds since boot, * or 0 if not unlocked. * * @hide */ @UnsupportedAppUsage public long getUserUnlockRealtime() { try { return mService.getUserUnlockRealtime(); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns the UserInfo object describing a specific user. * Requires {@link android.Manifest.permission#MANAGE_USERS} permission. * @param userHandle the user handle of the user whose information is being requested. * @return the UserInfo object for a specific user. * @hide */ @UnsupportedAppUsage public UserInfo getUserInfo(@UserIdInt int userHandle) { try { return mService.getUserInfo(userHandle); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide * * Returns who set a user restriction on a user. * @param restrictionKey the string key representing the restriction * @param userHandle the UserHandle of the user for whom to retrieve the restrictions. * @return The source of user restriction. Any combination of {@link #RESTRICTION_NOT_SET}, * {@link #RESTRICTION_SOURCE_SYSTEM}, {@link #RESTRICTION_SOURCE_DEVICE_OWNER} * and {@link #RESTRICTION_SOURCE_PROFILE_OWNER} * @deprecated use {@link #getUserRestrictionSources(String, int)} instead. */ @Deprecated @SystemApi @UserRestrictionSource @RequiresPermission(android.Manifest.permission.MANAGE_USERS) public int getUserRestrictionSource(String restrictionKey, UserHandle userHandle) { try { return mService.getUserRestrictionSource(restrictionKey, userHandle.getIdentifier()); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide * * Returns a list of users who set a user restriction on a given user. * @param restrictionKey the string key representing the restriction * @param userHandle the UserHandle of the user for whom to retrieve the restrictions. * @return a list of user ids enforcing this restriction. */ @SystemApi @RequiresPermission(android.Manifest.permission.MANAGE_USERS) public List<EnforcingUser> getUserRestrictionSources(String restrictionKey, UserHandle userHandle) { try { return mService.getUserRestrictionSources(restrictionKey, userHandle.getIdentifier()); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns the user-wide restrictions imposed on this user. * @return a Bundle containing all the restrictions. */ public Bundle getUserRestrictions() { return getUserRestrictions(Process.myUserHandle()); } /** * Returns the user-wide restrictions imposed on the user specified by <code>userHandle</code>. * @param userHandle the UserHandle of the user for whom to retrieve the restrictions. * @return a Bundle containing all the restrictions. */ public Bundle getUserRestrictions(UserHandle userHandle) { try { return mService.getUserRestrictions(userHandle.getIdentifier()); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide * Returns whether the given user has been disallowed from performing certain actions * or setting certain settings through UserManager. This method disregards restrictions * set by device policy. * @param restrictionKey the string key representing the restriction * @param userHandle the UserHandle of the user for whom to retrieve the restrictions. */ @UnsupportedAppUsage public boolean hasBaseUserRestriction(String restrictionKey, UserHandle userHandle) { try { return mService.hasBaseUserRestriction(restrictionKey, userHandle.getIdentifier()); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * This will no longer work. Device owners and profile owners should use * {@link DevicePolicyManager#addUserRestriction(ComponentName, String)} instead. */ // System apps should use UserManager.setUserRestriction() instead. @Deprecated public void setUserRestrictions(Bundle restrictions) { throw new UnsupportedOperationException("This method is no longer supported"); } /** * This will no longer work. Device owners and profile owners should use * {@link DevicePolicyManager#addUserRestriction(ComponentName, String)} instead. */ // System apps should use UserManager.setUserRestriction() instead. @Deprecated public void setUserRestrictions(Bundle restrictions, UserHandle userHandle) { throw new UnsupportedOperationException("This method is no longer supported"); } /** * Sets the value of a specific restriction. * Requires the MANAGE_USERS permission. * @param key the key of the restriction * @param value the value for the restriction * @deprecated use {@link android.app.admin.DevicePolicyManager#addUserRestriction( * android.content.ComponentName, String)} or * {@link android.app.admin.DevicePolicyManager#clearUserRestriction( * android.content.ComponentName, String)} instead. */ @Deprecated public void setUserRestriction(String key, boolean value) { setUserRestriction(key, value, Process.myUserHandle()); } /** * @hide * Sets the value of a specific restriction on a specific user. * Requires the MANAGE_USERS permission. * @param key the key of the restriction * @param value the value for the restriction * @param userHandle the user whose restriction is to be changed. * @deprecated use {@link android.app.admin.DevicePolicyManager#addUserRestriction( * android.content.ComponentName, String)} or * {@link android.app.admin.DevicePolicyManager#clearUserRestriction( * android.content.ComponentName, String)} instead. */ @Deprecated public void setUserRestriction(String key, boolean value, UserHandle userHandle) { try { mService.setUserRestriction(key, value, userHandle.getIdentifier()); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns whether the current user has been disallowed from performing certain actions * or setting certain settings. * * @param restrictionKey The string key representing the restriction. * @return {@code true} if the current user has the given restriction, {@code false} otherwise. */ public boolean hasUserRestriction(String restrictionKey) { return hasUserRestriction(restrictionKey, Process.myUserHandle()); } /** * @hide * Returns whether the given user has been disallowed from performing certain actions * or setting certain settings. * @param restrictionKey the string key representing the restriction * @param userHandle the UserHandle of the user for whom to retrieve the restrictions. */ @UnsupportedAppUsage public boolean hasUserRestriction(String restrictionKey, UserHandle userHandle) { try { return mService.hasUserRestriction(restrictionKey, userHandle.getIdentifier()); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide * Returns whether any user on the device has the given user restriction set. */ public boolean hasUserRestrictionOnAnyUser(String restrictionKey) { try { return mService.hasUserRestrictionOnAnyUser(restrictionKey); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Return the serial number for a user. This is a device-unique * number assigned to that user; if the user is deleted and then a new * user created, the new users will not be given the same serial number. * @param user The user whose serial number is to be retrieved. * @return The serial number of the given user; returns -1 if the * given UserHandle does not exist. * @see #getUserForSerialNumber(long) */ public long getSerialNumberForUser(UserHandle user) { return getUserSerialNumber(user.getIdentifier()); } /** * Return the user associated with a serial number previously * returned by {@link #getSerialNumberForUser(UserHandle)}. * @param serialNumber The serial number of the user that is being * retrieved. * @return Return the user associated with the serial number, or null * if there is not one. * @see #getSerialNumberForUser(UserHandle) */ public UserHandle getUserForSerialNumber(long serialNumber) { int ident = getUserHandle((int) serialNumber); return ident >= 0 ? new UserHandle(ident) : null; } /** * Creates a user with the specified name and options. For non-admin users, default user * restrictions are going to be applied. * Requires {@link android.Manifest.permission#MANAGE_USERS} permission. * * @param name the user's name * @param flags flags that identify the type of user and other properties. * @see UserInfo * * @return the UserInfo object for the created user, or null if the user could not be created. * @hide */ @UnsupportedAppUsage public UserInfo createUser(String name, int flags) { UserInfo user = null; try { user = mService.createUser(name, flags); // TODO: Keep this in sync with // UserManagerService.LocalService.createUserEvenWhenDisallowed if (user != null && !user.isAdmin() && !user.isDemo()) { mService.setUserRestriction(DISALLOW_SMS, true, user.id); mService.setUserRestriction(DISALLOW_OUTGOING_CALLS, true, user.id); } } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } return user; } /** * Creates a guest user and configures it. * @param context an application context * @param name the name to set for the user * @hide */ public UserInfo createGuest(Context context, String name) { UserInfo guest = null; try { guest = mService.createUser(name, UserInfo.FLAG_GUEST); if (guest != null) { Settings.Secure.putStringForUser(context.getContentResolver(), Settings.Secure.SKIP_FIRST_USE_HINTS, "1", guest.id); } } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } return guest; } /** * Creates a user with the specified name and options as a profile of another user. * Requires {@link android.Manifest.permission#MANAGE_USERS} permission. * * @param name the user's name * @param flags flags that identify the type of user and other properties. * @param userHandle new user will be a profile of this user. * * @return the {@link UserInfo} object for the created user, or null if the user * could not be created. * @hide */ @UnsupportedAppUsage public UserInfo createProfileForUser(String name, int flags, @UserIdInt int userHandle) { return createProfileForUser(name, flags, userHandle, null); } /** * Version of {@link #createProfileForUser(String, int, int)} that allows you to specify * any packages that should not be installed in the new profile by default, these packages can * still be installed later by the user if needed. * * @param name the user's name * @param flags flags that identify the type of user and other properties. * @param userHandle new user will be a profile of this user. * @param disallowedPackages packages that will not be installed in the profile being created. * * @return the {@link UserInfo} object for the created user, or null if the user * could not be created. * @hide */ public UserInfo createProfileForUser(String name, int flags, @UserIdInt int userHandle, String[] disallowedPackages) { try { return mService.createProfileForUser(name, flags, userHandle, disallowedPackages); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Similar to {@link #createProfileForUser(String, int, int, String[])} * except bypassing the checking of {@link UserManager#DISALLOW_ADD_MANAGED_PROFILE}. * Requires {@link android.Manifest.permission#MANAGE_USERS} permission. * * @see #createProfileForUser(String, int, int, String[]) * @hide */ public UserInfo createProfileForUserEvenWhenDisallowed(String name, int flags, @UserIdInt int userHandle, String[] disallowedPackages) { try { return mService.createProfileForUserEvenWhenDisallowed(name, flags, userHandle, disallowedPackages); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Creates a restricted profile with the specified name. This method also sets necessary * restrictions and adds shared accounts. * * @param name profile's name * @return UserInfo object for the created user, or null if the user could not be created. * @hide */ public UserInfo createRestrictedProfile(String name) { try { UserHandle parentUserHandle = Process.myUserHandle(); UserInfo user = mService.createRestrictedProfile(name, parentUserHandle.getIdentifier()); if (user != null) { AccountManager.get(mContext).addSharedAccountsFromParentUser(parentUserHandle, UserHandle.of(user.id)); } return user; } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns an intent to create a user for the provided name and account name. The name * and account name will be used when the setup process for the new user is started. * <p> * The intent should be launched using startActivityForResult and the return result will * indicate if the user consented to adding a new user and if the operation succeeded. Any * errors in creating the user will be returned in the result code. If the user cancels the * request, the return result will be {@link Activity#RESULT_CANCELED}. On success, the * result code will be {@link Activity#RESULT_OK}. * <p> * Use {@link #supportsMultipleUsers()} to first check if the device supports this operation * at all. * <p> * The new user is created but not initialized. After switching into the user for the first * time, the preferred user name and account information are used by the setup process for that * user. * * @param userName Optional name to assign to the user. * @param accountName Optional account name that will be used by the setup wizard to initialize * the user. * @param accountType Optional account type for the account to be created. This is required * if the account name is specified. * @param accountOptions Optional bundle of data to be passed in during account creation in the * new user via {@link AccountManager#addAccount(String, String, String[], * Bundle, android.app.Activity, android.accounts.AccountManagerCallback, * Handler)}. * @return An Intent that can be launched from an Activity. * @see #USER_CREATION_FAILED_NOT_PERMITTED * @see #USER_CREATION_FAILED_NO_MORE_USERS * @see #supportsMultipleUsers */ public static Intent createUserCreationIntent(@Nullable String userName, @Nullable String accountName, @Nullable String accountType, @Nullable PersistableBundle accountOptions) { Intent intent = new Intent(ACTION_CREATE_USER); if (userName != null) { intent.putExtra(EXTRA_USER_NAME, userName); } if (accountName != null && accountType == null) { throw new IllegalArgumentException("accountType must be specified if accountName is " + "specified"); } if (accountName != null) { intent.putExtra(EXTRA_USER_ACCOUNT_NAME, accountName); } if (accountType != null) { intent.putExtra(EXTRA_USER_ACCOUNT_TYPE, accountType); } if (accountOptions != null) { intent.putExtra(EXTRA_USER_ACCOUNT_OPTIONS, accountOptions); } return intent; } /** * @hide * * Returns the preferred account name for user creation. */ @SystemApi @RequiresPermission(android.Manifest.permission.MANAGE_USERS) public String getSeedAccountName() { try { return mService.getSeedAccountName(); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide * * Returns the preferred account type for user creation. */ @SystemApi @RequiresPermission(android.Manifest.permission.MANAGE_USERS) public String getSeedAccountType() { try { return mService.getSeedAccountType(); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide * * Returns the preferred account's options bundle for user creation. * @return Any options set by the requestor that created the user. */ @SystemApi @RequiresPermission(android.Manifest.permission.MANAGE_USERS) public PersistableBundle getSeedAccountOptions() { try { return mService.getSeedAccountOptions(); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide * * Called by a system activity to set the seed account information of a user created * through the user creation intent. * @param userId * @param accountName * @param accountType * @param accountOptions * @see #createUserCreationIntent(String, String, String, PersistableBundle) */ public void setSeedAccountData(int userId, String accountName, String accountType, PersistableBundle accountOptions) { try { mService.setSeedAccountData(userId, accountName, accountType, accountOptions, /* persist= */ true); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide * Clears the seed information used to create this user. */ @SystemApi @RequiresPermission(android.Manifest.permission.MANAGE_USERS) public void clearSeedAccountData() { try { mService.clearSeedAccountData(); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide * Marks the guest user for deletion to allow a new guest to be created before deleting * the current user who is a guest. * @param userHandle * @return */ public boolean markGuestForDeletion(@UserIdInt int userHandle) { try { return mService.markGuestForDeletion(userHandle); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Sets the user as enabled, if such an user exists. * * <p>Requires {@link android.Manifest.permission#MANAGE_USERS} permission. * * <p>Note that the default is true, it's only that managed profiles might not be enabled. * Also ephemeral users can be disabled to indicate that their removal is in progress and they * shouldn't be re-entered. Therefore ephemeral users should not be re-enabled once disabled. * * @param userId the id of the profile to enable * @hide */ public void setUserEnabled(@UserIdInt int userId) { try { mService.setUserEnabled(userId); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Assigns admin privileges to the user, if such a user exists. * * <p>Requires {@link android.Manifest.permission#MANAGE_USERS} and * {@link android.Manifest.permission#INTERACT_ACROSS_USERS_FULL} permissions. * * @param userHandle the id of the user to become admin * @hide */ @RequiresPermission(allOf = { Manifest.permission.INTERACT_ACROSS_USERS_FULL, Manifest.permission.MANAGE_USERS }) public void setUserAdmin(@UserIdInt int userHandle) { try { mService.setUserAdmin(userHandle); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Evicts the user's credential encryption key from memory by stopping and restarting the user. * * @hide */ public void evictCredentialEncryptionKey(@UserIdInt int userHandle) { try { mService.evictCredentialEncryptionKey(userHandle); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Return the number of users currently created on the device. */ public int getUserCount() { List<UserInfo> users = getUsers(); return users != null ? users.size() : 1; } /** * Returns information for all users on this device, including ones marked for deletion. * To retrieve only users that are alive, use {@link #getUsers(boolean)}. * <p> * Requires {@link android.Manifest.permission#MANAGE_USERS} permission. * @return the list of users that exist on the device. * @hide */ @UnsupportedAppUsage public List<UserInfo> getUsers() { try { return mService.getUsers(false); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns serial numbers of all users on this device. * * @param excludeDying specify if the list should exclude users being removed. * @return the list of serial numbers of users that exist on the device. * @hide */ @SystemApi @RequiresPermission(android.Manifest.permission.MANAGE_USERS) public long[] getSerialNumbersOfUsers(boolean excludeDying) { try { List<UserInfo> users = mService.getUsers(excludeDying); long[] result = new long[users.size()]; for (int i = 0; i < result.length; i++) { result[i] = users.get(i).serialNumber; } return result; } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @return the user's account name, null if not found. * @hide */ @RequiresPermission(allOf = { Manifest.permission.INTERACT_ACROSS_USERS_FULL, Manifest.permission.MANAGE_USERS }) public @Nullable String getUserAccount(@UserIdInt int userHandle) { try { return mService.getUserAccount(userHandle); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Set account name for the given user. * @hide */ @RequiresPermission(allOf = { Manifest.permission.INTERACT_ACROSS_USERS_FULL, Manifest.permission.MANAGE_USERS }) public void setUserAccount(@UserIdInt int userHandle, @Nullable String accountName) { try { mService.setUserAccount(userHandle, accountName); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns information for Primary user. * Requires {@link android.Manifest.permission#MANAGE_USERS} permission. * * @return the Primary user, null if not found. * @hide */ public @Nullable UserInfo getPrimaryUser() { try { return mService.getPrimaryUser(); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Checks whether it's possible to add more users. Caller must hold the MANAGE_USERS * permission. * * @return true if more users can be added, false if limit has been reached. * @hide */ public boolean canAddMoreUsers() { final List<UserInfo> users = getUsers(true); final int totalUserCount = users.size(); int aliveUserCount = 0; for (int i = 0; i < totalUserCount; i++) { UserInfo user = users.get(i); if (!user.isGuest()) { aliveUserCount++; } } return aliveUserCount < getMaxSupportedUsers(); } /** * Checks whether it's possible to add more managed profiles. Caller must hold the MANAGE_USERS * permission. * if allowedToRemoveOne is true and if the user already has a managed profile, then return if * we could add a new managed profile to this user after removing the existing one. * * @return true if more managed profiles can be added, false if limit has been reached. * @hide */ public boolean canAddMoreManagedProfiles(@UserIdInt int userId, boolean allowedToRemoveOne) { try { return mService.canAddMoreManagedProfiles(userId, allowedToRemoveOne); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns list of the profiles of userHandle including * userHandle itself. * Note that this returns both enabled and not enabled profiles. See * {@link #getEnabledProfiles(int)} if you need only the enabled ones. * * Requires {@link android.Manifest.permission#MANAGE_USERS} permission. * @param userHandle profiles of this user will be returned. * @return the list of profiles. * @hide */ @UnsupportedAppUsage public List<UserInfo> getProfiles(@UserIdInt int userHandle) { try { return mService.getProfiles(userHandle, false /* enabledOnly */); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Requires {@link android.Manifest.permission#MANAGE_USERS} permission. * @param userId one of the two user ids to check. * @param otherUserId one of the two user ids to check. * @return true if the two user ids are in the same profile group. * @hide */ public boolean isSameProfileGroup(@UserIdInt int userId, int otherUserId) { try { return mService.isSameProfileGroup(userId, otherUserId); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns list of the profiles of userHandle including * userHandle itself. * Note that this returns only enabled. * * Requires {@link android.Manifest.permission#MANAGE_USERS} permission. * @param userHandle profiles of this user will be returned. * @return the list of profiles. * @hide */ @UnsupportedAppUsage public List<UserInfo> getEnabledProfiles(@UserIdInt int userHandle) { try { return mService.getProfiles(userHandle, true /* enabledOnly */); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns a list of UserHandles for profiles associated with the user that the calling process * is running on, including the user itself. * * @return A non-empty list of UserHandles associated with the calling user. */ public List<UserHandle> getUserProfiles() { int[] userIds = getProfileIds(UserHandle.myUserId(), true /* enabledOnly */); List<UserHandle> result = new ArrayList<>(userIds.length); for (int userId : userIds) { result.add(UserHandle.of(userId)); } return result; } /** * Returns a list of ids for profiles associated with the specified user including the user * itself. * * @param userId id of the user to return profiles for * @param enabledOnly whether return only {@link UserInfo#isEnabled() enabled} profiles * @return A non-empty list of ids of profiles associated with the specified user. * * @hide */ public int[] getProfileIds(@UserIdInt int userId, boolean enabledOnly) { try { return mService.getProfileIds(userId, enabledOnly); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @see #getProfileIds(int, boolean) * @hide */ @UnsupportedAppUsage public int[] getProfileIdsWithDisabled(@UserIdInt int userId) { return getProfileIds(userId, false /* enabledOnly */); } /** * @see #getProfileIds(int, boolean) * @hide */ public int[] getEnabledProfileIds(@UserIdInt int userId) { return getProfileIds(userId, true /* enabledOnly */); } /** * Returns the device credential owner id of the profile from * which this method is called, or userHandle if called from a user that * is not a profile. * * @hide */ public int getCredentialOwnerProfile(@UserIdInt int userHandle) { try { return mService.getCredentialOwnerProfile(userHandle); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns the parent of the profile which this method is called from * or null if called from a user that is not a profile. * * @hide */ @UnsupportedAppUsage public UserInfo getProfileParent(@UserIdInt int userHandle) { try { return mService.getProfileParent(userHandle); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Enables or disables quiet mode for a managed profile. If quiet mode is enabled, apps in a * managed profile don't run, generate notifications, or consume data or battery. * <p> * If a user's credential is needed to turn off quiet mode, a confirm credential screen will be * shown to the user. * <p> * The change may not happen instantly, however apps can listen for * {@link Intent#ACTION_MANAGED_PROFILE_AVAILABLE} and * {@link Intent#ACTION_MANAGED_PROFILE_UNAVAILABLE} broadcasts in order to be notified of * the change of the quiet mode. Apps can also check the current state of quiet mode by * calling {@link #isQuietModeEnabled(UserHandle)}. * <p> * The caller must either be the foreground default launcher or have one of these permissions: * {@code MANAGE_USERS} or {@code MODIFY_QUIET_MODE}. * * @param enableQuietMode whether quiet mode should be enabled or disabled * @param userHandle user handle of the profile * @return {@code false} if user's credential is needed in order to turn off quiet mode, * {@code true} otherwise * @throws SecurityException if the caller is invalid * @throws IllegalArgumentException if {@code userHandle} is not a managed profile * * @see #isQuietModeEnabled(UserHandle) */ public boolean requestQuietModeEnabled(boolean enableQuietMode, @NonNull UserHandle userHandle) { return requestQuietModeEnabled(enableQuietMode, userHandle, null); } /** * Similar to {@link #requestQuietModeEnabled(boolean, UserHandle)}, except you can specify * a target to start when user is unlocked. If {@code target} is specified, caller must have * the {@link android.Manifest.permission#MANAGE_USERS} permission. * * @see {@link #requestQuietModeEnabled(boolean, UserHandle)} * @hide */ public boolean requestQuietModeEnabled(boolean enableQuietMode, @NonNull UserHandle userHandle, IntentSender target) { try { return mService.requestQuietModeEnabled(mContext.getPackageName(), enableQuietMode, userHandle.getIdentifier(), target); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns whether the given profile is in quiet mode or not. * Notes: Quiet mode is only supported for managed profiles. * * @param userHandle The user handle of the profile to be queried. * @return true if the profile is in quiet mode, false otherwise. */ public boolean isQuietModeEnabled(UserHandle userHandle) { try { return mService.isQuietModeEnabled(userHandle.getIdentifier()); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * If the target user is a managed profile of the calling user or the caller * is itself a managed profile, then this returns a badged copy of the given * icon to be able to distinguish it from the original icon. For badging an * arbitrary drawable use {@link #getBadgedDrawableForUser( * android.graphics.drawable.Drawable, UserHandle, android.graphics.Rect, int)}. * <p> * If the original drawable is a BitmapDrawable and the backing bitmap is * mutable as per {@link android.graphics.Bitmap#isMutable()}, the badging * is performed in place and the original drawable is returned. * </p> * * @param icon The icon to badge. * @param user The target user. * @return A drawable that combines the original icon and a badge as * determined by the system. * @removed */ public Drawable getBadgedIconForUser(Drawable icon, UserHandle user) { return mContext.getPackageManager().getUserBadgedIcon(icon, user); } /** * If the target user is a managed profile of the calling user or the caller * is itself a managed profile, then this returns a badged copy of the given * drawable allowing the user to distinguish it from the original drawable. * The caller can specify the location in the bounds of the drawable to be * badged where the badge should be applied as well as the density of the * badge to be used. * <p> * If the original drawable is a BitmapDrawable and the backing bitmap is * mutable as per {@link android.graphics.Bitmap#isMutable()}, the badging * is performed in place and the original drawable is returned. * </p> * * @param badgedDrawable The drawable to badge. * @param user The target user. * @param badgeLocation Where in the bounds of the badged drawable to place * the badge. If it's {@code null}, the badge is applied on top of the entire * drawable being badged. * @param badgeDensity The optional desired density for the badge as per * {@link android.util.DisplayMetrics#densityDpi}. If it's not positive, * the density of the display is used. * @return A drawable that combines the original drawable and a badge as * determined by the system. * @removed */ public Drawable getBadgedDrawableForUser(Drawable badgedDrawable, UserHandle user, Rect badgeLocation, int badgeDensity) { return mContext.getPackageManager().getUserBadgedDrawableForDensity(badgedDrawable, user, badgeLocation, badgeDensity); } /** * If the target user is a managed profile of the calling user or the caller * is itself a managed profile, then this returns a copy of the label with * badging for accessibility services like talkback. E.g. passing in "Email" * and it might return "Work Email" for Email in the work profile. * * @param label The label to change. * @param user The target user. * @return A label that combines the original label and a badge as * determined by the system. * @removed */ public CharSequence getBadgedLabelForUser(CharSequence label, UserHandle user) { return mContext.getPackageManager().getUserBadgedLabel(label, user); } /** * Returns information for all users on this device. Requires * {@link android.Manifest.permission#MANAGE_USERS} permission. * * @param excludeDying specify if the list should exclude users being * removed. * @return the list of users that were created. * @hide */ @UnsupportedAppUsage public @NonNull List<UserInfo> getUsers(boolean excludeDying) { try { return mService.getUsers(excludeDying); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Removes a user and all associated data. * Requires {@link android.Manifest.permission#MANAGE_USERS} permission. * @param userHandle the integer handle of the user, where 0 is the primary user. * @hide */ @UnsupportedAppUsage public boolean removeUser(@UserIdInt int userHandle) { try { return mService.removeUser(userHandle); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Similar to {@link #removeUser(int)} except bypassing the checking of * {@link UserManager#DISALLOW_REMOVE_USER} * or {@link UserManager#DISALLOW_REMOVE_MANAGED_PROFILE}. * * @see {@link #removeUser(int)} * @hide */ public boolean removeUserEvenWhenDisallowed(@UserIdInt int userHandle) { try { return mService.removeUserEvenWhenDisallowed(userHandle); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Updates the user's name. * Requires {@link android.Manifest.permission#MANAGE_USERS} permission. * * @param userHandle the user's integer handle * @param name the new name for the user * @hide */ public void setUserName(@UserIdInt int userHandle, String name) { try { mService.setUserName(userHandle, name); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Sets the user's photo. * @param userHandle the user for whom to change the photo. * @param icon the bitmap to set as the photo. * @hide */ public void setUserIcon(@UserIdInt int userHandle, Bitmap icon) { try { mService.setUserIcon(userHandle, icon); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns a file descriptor for the user's photo. PNG data can be read from this file. * @param userHandle the user whose photo we want to read. * @return a {@link Bitmap} of the user's photo, or null if there's no photo. * @see com.android.internal.util.UserIcons#getDefaultUserIcon for a default. * @hide */ @UnsupportedAppUsage public Bitmap getUserIcon(@UserIdInt int userHandle) { try { ParcelFileDescriptor fd = mService.getUserIcon(userHandle); if (fd != null) { try { return BitmapFactory.decodeFileDescriptor(fd.getFileDescriptor()); } finally { try { fd.close(); } catch (IOException e) { } } } } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } return null; } /** * Returns the maximum number of users that can be created on this device. A return value * of 1 means that it is a single user device. * @hide * @return a value greater than or equal to 1 */ @UnsupportedAppUsage public static int getMaxSupportedUsers() { // Don't allow multiple users on certain builds if (android.os.Build.ID.startsWith("JVP")) return 1; if (ActivityManager.isLowRamDeviceStatic()) { // Low-ram devices are Svelte. Most of the time they don't get multi-user. if ((Resources.getSystem().getConfiguration().uiMode & Configuration.UI_MODE_TYPE_MASK) != Configuration.UI_MODE_TYPE_TELEVISION) { return 1; } } return SystemProperties.getInt("fw.max_users", Resources.getSystem().getInteger(R.integer.config_multiuserMaximumUsers)); } /** * Returns true if the user switcher should be shown, this will be if device supports multi-user * and there are at least 2 users available that are not managed profiles. * @hide * @return true if user switcher should be shown. */ public boolean isUserSwitcherEnabled() { if (!supportsMultipleUsers()) { return false; } if (hasUserRestriction(DISALLOW_USER_SWITCH)) { return false; } // If Demo Mode is on, don't show user switcher if (isDeviceInDemoMode(mContext)) { return false; } List<UserInfo> users = getUsers(true); if (users == null) { return false; } int switchableUserCount = 0; for (UserInfo user : users) { if (user.supportsSwitchToByUser()) { ++switchableUserCount; } } final boolean guestEnabled = !mContext.getSystemService(DevicePolicyManager.class) .getGuestUserDisabled(null); return switchableUserCount > 1 || guestEnabled; } /** * @hide */ @UnsupportedAppUsage public static boolean isDeviceInDemoMode(Context context) { return Settings.Global.getInt(context.getContentResolver(), Settings.Global.DEVICE_DEMO_MODE, 0) > 0; } /** * Returns a serial number on this device for a given userHandle. User handles can be recycled * when deleting and creating users, but serial numbers are not reused until the device is wiped. * @param userHandle * @return a serial number associated with that user, or -1 if the userHandle is not valid. * @hide */ @UnsupportedAppUsage public int getUserSerialNumber(@UserIdInt int userHandle) { try { return mService.getUserSerialNumber(userHandle); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns a userHandle on this device for a given user serial number. User handles can be * recycled when deleting and creating users, but serial numbers are not reused until the device * is wiped. * @param userSerialNumber * @return the userHandle associated with that user serial number, or -1 if the serial number * is not valid. * @hide */ @UnsupportedAppUsage public @UserIdInt int getUserHandle(int userSerialNumber) { try { return mService.getUserHandle(userSerialNumber); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns a {@link Bundle} containing any saved application restrictions for this user, for the * given package name. Only an application with this package name can call this method. * * <p>The returned {@link Bundle} consists of key-value pairs, as defined by the application, * where the types of values may be: * <ul> * <li>{@code boolean} * <li>{@code int} * <li>{@code String} or {@code String[]} * <li>From {@link android.os.Build.VERSION_CODES#M}, {@code Bundle} or {@code Bundle[]} * </ul> * * <p>NOTE: The method performs disk I/O and shouldn't be called on the main thread * * @param packageName the package name of the calling application * @return a {@link Bundle} with the restrictions for that package, or an empty {@link Bundle} * if there are no saved restrictions. * * @see #KEY_RESTRICTIONS_PENDING */ @WorkerThread public Bundle getApplicationRestrictions(String packageName) { try { return mService.getApplicationRestrictions(packageName); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide */ @WorkerThread public Bundle getApplicationRestrictions(String packageName, UserHandle user) { try { return mService.getApplicationRestrictionsForUser(packageName, user.getIdentifier()); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide */ @WorkerThread public void setApplicationRestrictions(String packageName, Bundle restrictions, UserHandle user) { try { mService.setApplicationRestrictions(packageName, restrictions, user.getIdentifier()); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Sets a new challenge PIN for restrictions. This is only for use by pre-installed * apps and requires the MANAGE_USERS permission. * @param newPin the PIN to use for challenge dialogs. * @return Returns true if the challenge PIN was set successfully. * @deprecated The restrictions PIN functionality is no longer provided by the system. * This method is preserved for backwards compatibility reasons and always returns false. */ @Deprecated public boolean setRestrictionsChallenge(String newPin) { return false; } /** * @hide * Set restrictions that should apply to any future guest user that's created. */ public void setDefaultGuestRestrictions(Bundle restrictions) { try { mService.setDefaultGuestRestrictions(restrictions); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide * Gets the default guest restrictions. */ public Bundle getDefaultGuestRestrictions() { try { return mService.getDefaultGuestRestrictions(); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * Returns creation time of the user or of a managed profile associated with the calling user. * @param userHandle user handle of the user or a managed profile associated with the * calling user. * @return creation time in milliseconds since Epoch time. */ public long getUserCreationTime(UserHandle userHandle) { try { return mService.getUserCreationTime(userHandle.getIdentifier()); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide * Checks if any uninitialized user has the specific seed account name and type. * * @param accountName The account name to check for * @param accountType The account type of the account to check for * @return whether the seed account was found */ public boolean someUserHasSeedAccount(String accountName, String accountType) { try { return mService.someUserHasSeedAccount(accountName, accountType); } catch (RemoteException re) { throw re.rethrowFromSystemServer(); } } /** * @hide * User that enforces a restriction. * * @see #getUserRestrictionSources(String, UserHandle) */ @SystemApi public static final class EnforcingUser implements Parcelable { private final @UserIdInt int userId; private final @UserRestrictionSource int userRestrictionSource; /** * @hide */ public EnforcingUser(@UserIdInt int userId, @UserRestrictionSource int userRestrictionSource) { this.userId = userId; this.userRestrictionSource = userRestrictionSource; } private EnforcingUser(Parcel in) { userId = in.readInt(); userRestrictionSource = in.readInt(); } public static final Creator<EnforcingUser> CREATOR = new Creator<EnforcingUser>() { @Override public EnforcingUser createFromParcel(Parcel in) { return new EnforcingUser(in); } @Override public EnforcingUser[] newArray(int size) { return new EnforcingUser[size]; } }; @Override public int describeContents() { return 0; } @Override public void writeToParcel(Parcel dest, int flags) { dest.writeInt(userId); dest.writeInt(userRestrictionSource); } /** * Returns an id of the enforcing user. * * <p> Will be UserHandle.USER_NULL when restriction is set by the system. */ public UserHandle getUserHandle() { return UserHandle.of(userId); } /** * Returns the status of the enforcing user. * * <p> One of {@link #RESTRICTION_SOURCE_SYSTEM}, * {@link #RESTRICTION_SOURCE_DEVICE_OWNER} and * {@link #RESTRICTION_SOURCE_PROFILE_OWNER} */ public @UserRestrictionSource int getUserRestrictionSource() { return userRestrictionSource; } } }