https://source.android.com/ 
/*
 * 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.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.

 Users are different from accounts, which are managed by AccountManager. Each user can have their own set of accounts. 
 See DevicePolicyManager.ACTION_PROVISION_MANAGED_PROFILE for more on managed profiles. 
/**
 * 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";
    private final IUserManager mService;
    private final Context mContext;

    private Boolean mIsManagedProfileCached;

    
@hide
No user restriction.
/**
     * @hide
     * No user restriction.
     */
    @SystemApi
    public static final int RESTRICTION_NOT_SET = 0x0;

    
@hide
User restriction set by system/user.
/**
     * @hide
     * User restriction set by system/user.
     */
    @SystemApi
    public static final int RESTRICTION_SOURCE_SYSTEM = 0x1;

    
@hide
User restriction set by a device owner.
/**
     * @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.
/**
     * @hide
     * User restriction set by a profile owner.
     */
    @SystemApi
    public static final int RESTRICTION_SOURCE_PROFILE_OWNER = 0x4;

    
@hide
/** @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 programmatically added by Authenticator. The default value is false.

From VERSION_CODES.N a profile or device owner app can still use AccountManager APIs to add or remove accounts when account management is disallowed. 
Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

This restriction has no effect in a managed profile.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false. 
Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

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.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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.

 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.

The default value is false.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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.

The default value is false.

This user restriction has no effect on managed profiles.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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.

The default value is false.

This user restriction has no effect on managed profiles.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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.

The default value is false.

This user restriction has no effect on managed profiles.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 not restrict the user from turning bluetooth on or off.
The default value is false.

This restriction doesn't prevent the user from using bluetooth. For disallowing usage of bluetooth completely on the device, use DISALLOW_BLUETOOTH. 
This restriction has no effect in a managed profile.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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.

 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.

The default value is false.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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.

Default is true for managed profiles and false for otherwise. When a device upgrades to VERSION_CODES.O, the system sets it for all existing managed profiles. 
Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.


This restriction has no effect on managed profiles.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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
false. This restriction has an effect when set by device owners and, in Android 6.0 (API level 23) or higher, profile owners. 
This restriction also prevents VPNs from starting. However, in Android 7.0 (API level 24) or higher, the system does start always-on VPNs created by the device or profile owner. 
Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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.

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.

This user restriction is different from DISALLOW_SHARE_LOCATION, as the device owner or profile owner can still enable or disable location mode via DevicePolicyManager.setSecureSetting when this restriction is on. 
The default value is false.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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.

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.

The default value is false.

This user restriction has no effect on managed profiles.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

In Android 9.0 or higher, if tethering is enabled when this restriction is set,
tethering will be automatically turned off.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

This restriction has no effect on secondary users and managed profiles since only the
primary user can reset the network settings of the device.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

This restriction has no effect on secondary users and managed profiles since only the
primary user can factory reset the device.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

This restriction has no effect on secondary users and managed profiles since only the
primary user can add other users.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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.

The default value for an unmanaged user is false.
For users with a device owner set, the default is true.

This restriction has no effect on managed profiles.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

In Android 8.0 (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. 
Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

This restriction has no effect on secondary users and managed profiles since only the
primary user can configure cell broadcasts.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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 false.

This restriction has no effect on secondary users and managed profiles since only the
primary user can configure mobile networks.

Key for user restrictions.

Type: Boolean

See Also:
/**
     * 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:

  • uninstalling apps
    • 

  • disabling apps
    • 

  • clearing app caches
    • 

  • clearing app data
    • 

  • force stopping apps
    • 

  • clearing app defaults
    • 

    
The default value is false.

    Note: 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 PackageInstaller. DISALLOW_UNINSTALL_APPS or DevicePolicyManager.setUninstallBlocked(ComponentName, String, boolean) should be used to prevent the user from uninstalling apps completely, and DevicePolicyManager.addPersistentPreferredActivity(ComponentName, IntentFilter, ComponentName) to add a default intent handler for a given intent filter. 
    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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 false.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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
false.

    This restriction has no effect on managed profiles.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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 false.

    When the restriction is set by profile owners, then it only applies to relevant
profiles.

    This restriction has no effect on managed profiles.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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 false.

    This restriction has no effect on managed profiles.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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 false.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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 false.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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.

  • LayoutParams.TYPE_TOAST
    • 

  • LayoutParams.TYPE_PHONE
    • 

  • LayoutParams.TYPE_PRIORITY_PHONE
    • 

  • LayoutParams.TYPE_SYSTEM_ALERT
    • 

  • LayoutParams.TYPE_SYSTEM_ERROR
    • 

  • LayoutParams.TYPE_SYSTEM_OVERLAY
    • 

  • LayoutParams.TYPE_APPLICATION_OVERLAY
    • 

    This can only be set by device owners and profile owners on the primary user.
The default value is false.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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 false.

    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.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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 false.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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 false.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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.

    See Also:
    @hide
    /**
     * 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 false.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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 false.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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 false.

    See Also:
    @hide
    /**
     * 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
     */    
    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 false.

    This restriction can be set by device owners and profile owners.

    See Also:
    @hide
    /**
     * 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 Also:
    @hide
    /**
     * 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 Also:
    @hide
    /**
     * 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 false.

    See Also:
    /**
     * 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 false.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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
false. Setting this restriction has no effect if the bootloader is already
unlocked.

    Not for use by third-party applications.

    See Also:
    Deprecated:use setOemUnlockAllowedByCarrier.setOemUnlockAllowedByCarrier(boolean, byte[]) instead.
    @hide
    /**
     * 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.

    Note: Setting this restriction alone doesn't automatically set a separate challenge. Profile owner can ask the user to set a new password using DevicePolicyManager.ACTION_SET_NEW_PASSWORD and verify it using DevicePolicyManager.isUsingUnifiedPassword(ComponentName). 
    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.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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 Intent.ACTION_VIEW, category Intent.CATEGORY_BROWSABLE, scheme http or https, and which define a host can handle intents from the managed profile. The default value is false.

    Key for user restrictions.

    Type: Boolean

    See Also:
    /**
     * 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.

    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 false.

    See Also:
    /**
     * 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.

     This restriction can only be set by the device owner, it will be applied to all users. Device owner can still switch user via DevicePolicyManager.switchUser(ComponentName, UserHandle) when this restriction is set. 
    The default value is false.

    See Also:
    /**
     * 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.

     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 DevicePolicyManager.addCrossProfileIntentFilter calls by the profile owner. 
    
This restriction is only meaningful when set by profile owner. When it is set by device
owner, it does not have any effect.

    
The default value is false.

    See Also:
    /**
     * 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 false. 
    See Also:
    /**
     * 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.

    
Applications that support restrictions should check for the presence of this key.
A true 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.

    Key for application restrictions.

    Type: Boolean

    See Also:
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /** @hide */    
    public static final int PIN_VERIFICATION_FAILED_INCORRECT = -3;
    
    @hide
    /** @hide */    
    public static final int PIN_VERIFICATION_FAILED_NOT_SET = -2;
    
    @hide
    /** @hide */    
    public static final int PIN_VERIFICATION_SUCCESS = -1;

    
    Sent when user restrictions have changed.

    @hide
    /**
     * 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 createUserCreationIntent(String, String, String, PersistableBundle). 
    /**
     * 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 createUserCreationIntent(String, String, String, PersistableBundle). 
    /**
     * 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.

    /**
     * Indicates user operation is successful.
     */    
    public static final int USER_OPERATION_SUCCESS = 0;

    
    Indicates user operation failed for unknown reason.

    /**
     * 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.

    /**
     * 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.

    /**
     * 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.

    /**
     * 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.

    /**
     * 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.

    /**
     * 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
    /**
     * 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.

    /**
     * Thrown to indicate user operation failed.
     */    
    public static class UserOperationException extends RuntimeException {
        private final @UserOperationResult int mUserOperationResult;

        
    Constructs a UserOperationException with specific result code.

    Params:
    • message – the detail message
    • userOperationResult – the result code
    @hide
    /**
         * 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.

    /**
         * Returns the operation result code.
         */    
        public @UserOperationResult int getUserOperationResult() {
            return mUserOperationResult;
        }
    }

    
    @hide
    /** @hide */    
    public static UserManager get(Context context) {
        return (UserManager) context.getSystemService(Context.USER_SERVICE);
    }

    
    @hide
    /** @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.

    Returns:whether the device supports multiple users.
    /**
     * 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
    Returns: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}
    /**
     * @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;
    }

    
    Returns:Whether guest user is always ephemeral
    @hide
    /**
     * @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.

    For instance switching users is not allowed if the current user is in a phone call, system user hasn't been unlocked yet, or DISALLOW_USER_SWITCH is set. 
    @hide
    /**
     * 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.

    Returns:the user handle of this process.
    @hide
    /**
     * Returns the user handle for the user that this process is running under.
     *
     * @return the user handle of this process.
     * @hide
     */    
    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.

    Returns:the user name
    /**
     * 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.

    This method can be used to check that the value returned by getUserName() was set by the user and is not a placeholder string provided by the system. 
    @hide
    /**
     * 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.

    As of VERSION_CODES.LOLLIPOP, this method can now automatically identify goats using advanced goat recognition technology.
    

    Returns:Returns true if the user making this call is a goat.
    /**
     * 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.

    Returns:whether this process is running under the primary user.
    @hide
    /**
     * 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.

    Returns:whether this process is running under the system user.
    /**
     * 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.
    /**
     * @hide
     * Returns whether the caller is running as an admin user. There can be more than one admin
     * user.
     */    
    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.
    /**
     * @hide
     * Returns whether the provided user is an admin user. There can be more than one admin
     * user.
     */    
    public boolean isUserAdmin(@UserIdInt int userId) {
        UserInfo user = getUserInfo(userId);
        return user != null && user.isAdmin();
    }

    
    @hide
    Deprecated:Use isRestrictedProfile()
    /**
     * @hide
     * @deprecated Use {@link #isRestrictedProfile()}
     */    
    @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.

    Returns:whether the user making this call is a linked user
    @hide
    /**
     * 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
    /**
     * 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.

    Returns:
    @hide
    /**
     * 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.

    Returns:whether user is a guest user.
    @hide
    /**
     * Checks if a user is a guest user.
     * @return whether user is a guest user.
     * @hide
     */    
    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.

    Returns:whether the caller is a guest user.
    @hide
    /**
     * 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.

    Returns:whether the caller is a demo user.
    /**
     * 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.

    Returns:whether the caller is in a managed profile.
    @hide
    /**
     * 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 MANAGE_USERS.MANAGE_USERS permission, otherwise the caller must be in the same profile group of specified user. 
    Returns:whether the specified user is a managed profile.
    @hide
    /**
     * 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 MANAGE_USERS.MANAGE_USERS permission, otherwise the caller must be in the same profile group of specified user. 
    Returns:which badge to use for the managed profile badge id will be less than
        UserManagerService.getMaxManagedProfiles()
    @hide
    /**
     * 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.

    Returns:whether the caller is an ephemeral user.
    @hide
    /**
     * 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
    /**
     * 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.

    Note prior to Android Nougat MR1 (SDK version <= 24; in order to check other profile's status.
Since Android Nougat MR1 (SDK version >= 25;{android.os.Build.VERSION_CODES#N_MR1)), the restriction has been relaxed, and now
it'll accept any UserHandle within the same profile group as the caller. 
    Params:
    • user – The user to retrieve the running state for.
    /**
     * 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 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} 
    /** {@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 or stopping. This is like 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). 
    Note prior to Android Nougat MR1 (SDK version <= 24; in order to check other profile's status.
Since Android Nougat MR1 (SDK version >= 25;{android.os.Build.VERSION_CODES#N_MR1)), the restriction has been relaxed, and now
it'll accept any UserHandle within the same profile group as the caller. 
    Params:
    • user – The user to retrieve the running state for.
    /**
     * 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 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.

    
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.

    
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 Also:
    /**
     * 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.

    
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.

    
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.

    Requires android.permission.MANAGE_USERS or android.permission.INTERACT_ACROSS_USERS, otherwise specified user must be the calling user or a managed profile associated with it. 
    Params:
    • user – to retrieve the unlocked state for.
    See Also:
    /**
     * 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} 
    /** {@hide} */    
    public boolean isUserUnlocked(@UserIdInt int userId) {
        try {
            return mService.isUserUnlocked(userId);
        } catch (RemoteException re) {
            throw re.rethrowFromSystemServer();
        }
    }

    
    {@hide} 
    /** {@hide} */    
    public boolean isUserUnlockingOrUnlocked(UserHandle user) {
        return isUserUnlockingOrUnlocked(user.getIdentifier());
    }

    
    {@hide} 
    /** {@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
    /**
     * Return the time when the calling user started in elapsed milliseconds since boot,
     * or 0 if not started.
     *
     * @hide
     */    
    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
    /**
     * Return the time when the calling user was unlocked elapsed milliseconds since boot,
     * or 0 if not unlocked.
     *
     * @hide
     */    
    public long getUserUnlockRealtime() {
        try {
            return mService.getUserUnlockRealtime();
        } catch (RemoteException re) {
            throw re.rethrowFromSystemServer();
        }
    }

    
    Returns the UserInfo object describing a specific user. Requires MANAGE_USERS.MANAGE_USERS permission. 
    Params:
    • userHandle – the user handle of the user whose information is being requested.
    Returns:the UserInfo object for a specific user.
    @hide
    /**
     * 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
     */    
    public UserInfo getUserInfo(@UserIdInt int userHandle) {
        try {
            return mService.getUserInfo(userHandle);
        } catch (RemoteException re) {
            throw re.rethrowFromSystemServer();
        }
    }

    
    Params:
    • restrictionKey – the string key representing the restriction
    • userHandle – the UserHandle of the user for whom to retrieve the restrictions.
    @hide
Returns who set a user restriction on a user.
    Returns:The source of user restriction. Any combination of RESTRICTION_NOT_SET, RESTRICTION_SOURCE_SYSTEM, RESTRICTION_SOURCE_DEVICE_OWNER and RESTRICTION_SOURCE_PROFILE_OWNER
    Deprecated:use getUserRestrictionSources(String, UserHandle) instead.
    /**
     * @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();
        }
    }

    
    Params:
    • restrictionKey – the string key representing the restriction
    • userHandle – the UserHandle of the user for whom to retrieve the restrictions.
    @hide
Returns a list of users who set a user restriction on a given user.
    Returns:a list of user ids enforcing this restriction.
    /**
     * @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.

    Returns:a Bundle containing all the restrictions.
    /**
     * 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 userHandle.

    Params:
    • userHandle – the UserHandle of the user for whom to retrieve the restrictions.
    Returns:a Bundle containing all the restrictions.
    /**
     * 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();
        }
    }

     
    Params:
    • restrictionKey – the string key representing the restriction
    • userHandle – the UserHandle of the user for whom to retrieve the restrictions.
    @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.
    /**
     * @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.
     */    
    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 DevicePolicyManager.addUserRestriction(ComponentName, String) instead. 
    /**
     * 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 DevicePolicyManager.addUserRestriction(ComponentName, String) instead. 
    /**
     * 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.

    Params:
    • key – the key of the restriction
    • value – the value for the restriction
    Deprecated:use DevicePolicyManager.addUserRestriction(ComponentName, String) or DevicePolicyManager.clearUserRestriction(ComponentName, String) instead.
    /**
     * 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());
    }

    
    Params:
    • key – the key of the restriction
    • value – the value for the restriction
    • userHandle – the user whose restriction is to be changed.
    @hide
Sets the value of a specific restriction on a specific user.
Requires the MANAGE_USERS permission.
    Deprecated:use DevicePolicyManager.addUserRestriction(ComponentName, String) or DevicePolicyManager.clearUserRestriction(ComponentName, String) instead.
    /**
     * @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.

    Params:
    • restrictionKey – The string key representing the restriction.
    Returns:true if the current user has the given restriction, false otherwise.
    /**
     * 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());
    }

    
    Params:
    • restrictionKey – the string key representing the restriction
    • userHandle – the UserHandle of the user for whom to retrieve the restrictions.
    @hide
Returns whether the given user has been disallowed from performing certain actions
or setting certain settings.
    /**
     * @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.
     */    
    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.
    /**
     * @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.

    Params:
    • user – The user whose serial number is to be retrieved.
    See Also:
    Returns:The serial number of the given user; returns -1 if the
given UserHandle does not exist.
    /**
     * 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 getSerialNumberForUser(UserHandle). 
    Params:
    • serialNumber – The serial number of the user that is being
retrieved.
    See Also:
    Returns:Return the user associated with the serial number, or null
if there is not one.
    /**
     * 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 MANAGE_USERS.MANAGE_USERS permission. 
    Params:
    • name – the user's name
    • flags – flags that identify the type of user and other properties.
    See Also:
    Returns:the UserInfo object for the created user, or null if the user could not be created.
    @hide
    /**
     * 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
     */    
    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.

    Params:
    • context – an application context
    • name – the name to set for the user
    @hide
    /**
     * 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 MANAGE_USERS.MANAGE_USERS permission. 
    Params:
    • name – the user's name
    • flags – flags that identify the type of user and other properties.
    • userHandle – new user will be a profile of this user.
    Returns:the UserInfo object for the created user, or null if the user could not be created.
    @hide
    /**
     * 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
     */    
    public UserInfo createProfileForUser(String name, int flags, @UserIdInt int userHandle) {
        return createProfileForUser(name, flags, userHandle, null);
    }

    
    Version of 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. 
    Params:
    • name – the user's name
    • flags – flags that identify the type of user and other properties.
    • userHandle – new user will be a profile of this user.
    • disallowedPackages – packages that will not be installed in the profile being created.
    Returns:the UserInfo object for the created user, or null if the user could not be created.
    @hide
    /**
     * 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 createProfileForUser(String, int, int, String[]) except bypassing the checking of DISALLOW_ADD_MANAGED_PROFILE. Requires MANAGE_USERS.MANAGE_USERS permission. 
    See Also:
    @hide
    /**
     * 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.

    Params:
    • name – profile's name
    Returns:UserInfo object for the created user, or null if the user could not be created.
    @hide
    /**
     * 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.

     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 Activity.RESULT_CANCELED. On success, the result code will be Activity.RESULT_OK. 
     Use supportsMultipleUsers() to first check if the device supports this operation at all. 
    
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.

    Params:
    See Also:
    Returns:An Intent that can be launched from an Activity.
    /**
     * 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.
    /**
     * @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.
    /**
     * @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.
    Returns:Any options set by the requestor that created the user.
    /**
     * @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();
        }
    }

    
    Params:
    • userId – 
    • accountName – 
    • accountType – 
    • accountOptions – 
    See Also:
    @hide
Called by a system activity to set the seed account information of a user created
through the user creation intent.
    /**
     * @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.
    /**
     * @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();
        }
    }

    
    Params:
    • userHandle – 
    @hide
Marks the guest user for deletion to allow a new guest to be created before deleting
the current user who is a guest.
    Returns:
    /**
     * @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.

    Requires MANAGE_USERS.MANAGE_USERS permission. 
    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.

    Params:
    • userId – the id of the profile to enable
    @hide
    /**
     * 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.

    Requires MANAGE_USERS.MANAGE_USERS and INTERACT_ACROSS_USERS_FULL.INTERACT_ACROSS_USERS_FULL permissions. 
    Params:
    • userHandle – the id of the user to become admin
    @hide
    /**
     * 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
    /**
     * 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.

    /**
     * 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 getUsers(boolean). 
     Requires MANAGE_USERS.MANAGE_USERS permission. 
    Returns:the list of users that exist on the device.
    @hide
    /**
     * 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
     */    
    public List<UserInfo> getUsers() {
        try {
            return mService.getUsers(false);
        } catch (RemoteException re) {
            throw re.rethrowFromSystemServer();
        }
    }

    
    Returns serial numbers of all users on this device.

    Params:
    • excludeDying – specify if the list should exclude users being removed.
    Returns:the list of serial numbers of users that exist on the device.
    @hide
    /**
     * 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();
        }
    }

    
    Returns:the user's account name, null if not found.
    @hide
    /**
     * @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
    /**
     * 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 MANAGE_USERS.MANAGE_USERS permission. 
    Returns:the Primary user, null if not found.
    @hide
    /**
     * 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.

    Returns:true if more users can be added, false if limit has been reached.
    @hide
    /**
     * 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.

    Returns:true if more managed profiles can be added, false if limit has been reached.
    @hide
    /**
     * 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 getEnabledProfiles(int) if you need only the enabled ones. Requires MANAGE_USERS.MANAGE_USERS permission. 
    Params:
    • userHandle – profiles of this user will be returned.
    Returns:the list of profiles.
    @hide
    /**
     * 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
     */    
    public List<UserInfo> getProfiles(@UserIdInt int userHandle) {
        try {
            return mService.getProfiles(userHandle, false /* enabledOnly */);
        } catch (RemoteException re) {
            throw re.rethrowFromSystemServer();
        }
    }

    
    Requires MANAGE_USERS.MANAGE_USERS permission. 
    Params:
    • userId – one of the two user ids to check.
    • otherUserId – one of the two user ids to check.
    Returns:true if the two user ids are in the same profile group.
    @hide
    /**
     * 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 MANAGE_USERS.MANAGE_USERS permission. 
    Params:
    • userHandle – profiles of this user will be returned.
    Returns:the list of profiles.
    @hide
    /**
     * 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
     */    
    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.

    Returns:A non-empty list of UserHandles associated with the calling user.
    /**
     * 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.

    Params:
    • userId –      id of the user to return profiles for
    • enabledOnly – whether return only enabled profiles
    Returns:A non-empty list of ids of profiles associated with the specified user.
    @hide
    /**
     * 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 Also:
    • getProfileIds(int, boolean)
    @hide
    /**
     * @see #getProfileIds(int, boolean)
     * @hide
     */    
    public int[] getProfileIdsWithDisabled(@UserIdInt int userId) {
        return getProfileIds(userId, false /* enabledOnly */);
    }

    
    See Also:
    • getProfileIds(int, boolean)
    @hide
    /**
     * @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
    /**
     * 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
    /**
     * 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
     */    
    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.

    
If a user's credential is needed to turn off quiet mode, a confirm credential screen will be
shown to the user.

     The change may not happen instantly, however apps can listen for Intent.ACTION_MANAGED_PROFILE_AVAILABLE and 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 isQuietModeEnabled(UserHandle). 
     The caller must either be the foreground default launcher or have one of these permissions: MANAGE_USERS or MODIFY_QUIET_MODE. 
    Params:
    • enableQuietMode – whether quiet mode should be enabled or disabled
    • userHandle – user handle of the profile
    Throws:
    See Also:
    Returns:false if user's credential is needed in order to turn off quiet mode, true otherwise
    /**
     * 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 requestQuietModeEnabled(boolean, UserHandle), except you can specify a target to start when user is unlocked. If target is specified, caller must have the MANAGE_USERS.MANAGE_USERS permission. 
    See Also:
    @hide
    /**
     * 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.

    Params:
    • userHandle – The user handle of the profile to be queried.
    Returns:true if the profile is in quiet mode, false otherwise.
    /**
     * 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 getBadgedDrawableForUser(Drawable, UserHandle, Rect, int). 
     If the original drawable is a BitmapDrawable and the backing bitmap is mutable as per Bitmap.isMutable(), the badging is performed in place and the original drawable is returned. 
    

    Params:
    • icon – The icon to badge.
    • user – The target user.
    Returns:A drawable that combines the original icon and a badge as
        determined by the system.
    @removed
    /**
     * 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.

     If the original drawable is a BitmapDrawable and the backing bitmap is mutable as per Bitmap.isMutable(), the badging is performed in place and the original drawable is returned. 
    

    Params:
    • badgedDrawable – The drawable to badge.
    • user – The target user.
    • badgeLocation – Where in the bounds of the badged drawable to place the badge. If it's null, the badge is applied on top of the entire drawable being badged.
    • badgeDensity – The optional desired density for the badge as per DisplayMetrics.densityDpi. If it's not positive, the density of the display is used.
    Returns:A drawable that combines the original drawable and a badge as
        determined by the system.
    @removed
    /**
     * 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.

    Params:
    • label – The label to change.
    • user – The target user.
    Returns:A label that combines the original label and a badge as
        determined by the system.
    @removed
    /**
     * 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 MANAGE_USERS.MANAGE_USERS permission. 
    Params:
    • excludeDying – specify if the list should exclude users being
           removed.
    Returns:the list of users that were created.
    @hide
    /**
     * 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
     */    
    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 MANAGE_USERS.MANAGE_USERS permission. 
    Params:
    • userHandle – the integer handle of the user, where 0 is the primary user.
    @hide
    /**
     * 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
     */    
    public boolean removeUser(@UserIdInt int userHandle) {
        try {
            return mService.removeUser(userHandle);
        } catch (RemoteException re) {
            throw re.rethrowFromSystemServer();
        }
    }

    
    Similar to removeUser(int) except bypassing the checking of DISALLOW_REMOVE_USER or DISALLOW_REMOVE_MANAGED_PROFILE. 
    See Also:
    @hide
    /**
     * 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 MANAGE_USERS.MANAGE_USERS permission. 
    Params:
    • userHandle – the user's integer handle
    • name – the new name for the user
    @hide
    /**
     * 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.

    Params:
    • userHandle – the user for whom to change the photo.
    • icon – the bitmap to set as the photo.
    @hide
    /**
     * 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.

    Params:
    • userHandle – the user whose photo we want to read.
    See Also:
    Returns:a Bitmap of the user's photo, or null if there's no photo.
    @hide
    /**
     * 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
     */    
    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
    Returns:a value greater than or equal to 1
    /**
     * 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
     */    
    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
    Returns:true if user switcher should be shown.
    /**
     * 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
    /**
     * @hide
     */    
    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.

    Params:
    • userHandle – 
    Returns:a serial number associated with that user, or -1 if the userHandle is not valid.
    @hide
    /**
     * 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
     */    
    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.

    Params:
    • userSerialNumber – 
    Returns:the userHandle associated with that user serial number, or -1 if the serial number
is not valid.
    @hide
    /**
     * 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
     */    
    public @UserIdInt int getUserHandle(int userSerialNumber) {
        try {
            return mService.getUserHandle(userSerialNumber);
        } catch (RemoteException re) {
            throw re.rethrowFromSystemServer();
        }
    }

    
    Returns a 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. 
    The returned Bundle consists of key-value pairs, as defined by the application, where the types of values may be: 
    

    NOTE: The method performs disk I/O and shouldn't be called on the main thread

    Params:
    • packageName – the package name of the calling application
    See Also:
    Returns:a Bundle with the restrictions for that package, or an empty Bundle if there are no saved restrictions.
    /**
     * 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
    /**
     * @hide
     */    
    @WorkerThread
    public Bundle getApplicationRestrictions(String packageName, UserHandle user) {
        try {
            return mService.getApplicationRestrictionsForUser(packageName, user.getIdentifier());
        } catch (RemoteException re) {
            throw re.rethrowFromSystemServer();
        }
    }

    
    @hide
    /**
     * @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.

    Params:
    • newPin – the PIN to use for challenge dialogs.
    Returns: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.
    /**
     * 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.
    /**
     * @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.
    /**
     * @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.

    Params:
    • userHandle – user handle of the user or a managed profile associated with the
                  calling user.
    Returns:creation time in milliseconds since Epoch time.
    /**
     * 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();
        }
    }

    
    Params:
    • accountName – The account name to check for
    • accountType – The account type of the account to check for
    @hide
Checks if any uninitialized user has the specific seed account name and type.
    Returns:whether the seed account was found
    /**
     * @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();
        }
    }

    
    See Also:
    @hide
User that enforces a restriction.
    /**
     * @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
    /**
         * @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.

     Will be UserHandle.USER_NULL when restriction is set by the system.

    /**
         * 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;
        }
    }
}