1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
15 */
16package android.os;
17
18import android.annotation.Nullable;
19import android.content.Context;
20import android.content.pm.UserInfo;
21import android.graphics.Bitmap;
22
23/**
24 * @hide Only for use within the system server.
25 */
26public abstract class UserManagerInternal {
27    public static final int CAMERA_NOT_DISABLED = 0;
28    public static final int CAMERA_DISABLED_LOCALLY = 1;
29    public static final int CAMERA_DISABLED_GLOBALLY = 2;
30
31    public interface UserRestrictionsListener {
32        /**
33         * Called when a user restriction changes.
34         *
35         * @param userId target user id
36         * @param newRestrictions new user restrictions
37         * @param prevRestrictions user restrictions that were previously set
38         */
39        void onUserRestrictionsChanged(int userId, Bundle newRestrictions, Bundle prevRestrictions);
40    }
41
42    /**
43     * Called by {@link com.android.server.devicepolicy.DevicePolicyManagerService} to set
44     * restrictions enforced by the user.
45     *
46     * @param userId target user id for the local restrictions.
47     * @param restrictions a bundle of user restrictions.
48     * @param isDeviceOwner whether {@code userId} corresponds to device owner user id.
49     * @param cameraRestrictionScope is camera disabled and if so what is the scope of restriction.
50     *        Should be one of {@link #CAMERA_NOT_DISABLED}, {@link #CAMERA_DISABLED_LOCALLY} or
51     *                               {@link #CAMERA_DISABLED_GLOBALLY}
52     */
53    public abstract void setDevicePolicyUserRestrictions(int userId, @Nullable Bundle restrictions,
54            boolean isDeviceOwner, int cameraRestrictionScope);
55
56    /**
57     * Returns the "base" user restrictions.
58     *
59     * Used by {@link com.android.server.devicepolicy.DevicePolicyManagerService} for upgrading
60     * from MNC.
61     */
62    public abstract Bundle getBaseUserRestrictions(int userId);
63
64    /**
65     * Called by {@link com.android.server.devicepolicy.DevicePolicyManagerService} for upgrading
66     * from MNC.
67     */
68    public abstract void setBaseUserRestrictionsByDpmsForMigration(int userId,
69            Bundle baseRestrictions);
70
71    /** Return a user restriction. */
72    public abstract boolean getUserRestriction(int userId, String key);
73
74    /** Adds a listener to user restriction changes. */
75    public abstract void addUserRestrictionsListener(UserRestrictionsListener listener);
76
77    /** Remove a {@link UserRestrictionsListener}. */
78    public abstract void removeUserRestrictionsListener(UserRestrictionsListener listener);
79
80    /**
81     * Called by {@link com.android.server.devicepolicy.DevicePolicyManagerService} to update
82     * whether the device is managed by device owner.
83     */
84    public abstract void setDeviceManaged(boolean isManaged);
85
86    /**
87     * Called by {@link com.android.server.devicepolicy.DevicePolicyManagerService} to update
88     * whether the user is managed by profile owner.
89     */
90    public abstract void setUserManaged(int userId, boolean isManaged);
91
92    /**
93     * Called by {@link com.android.server.devicepolicy.DevicePolicyManagerService} to omit
94     * restriction check, because DevicePolicyManager must always be able to set user icon
95     * regardless of any restriction.
96     * Also called by {@link com.android.server.pm.UserManagerService} because the logic of setting
97     * the icon is in this method.
98     */
99    public abstract void setUserIcon(int userId, Bitmap bitmap);
100
101    /**
102     * Called by {@link com.android.server.devicepolicy.DevicePolicyManagerService} to inform the
103     * user manager whether all users should be created ephemeral.
104     */
105    public abstract void setForceEphemeralUsers(boolean forceEphemeralUsers);
106
107    /**
108     * Switches to the system user and deletes all other users.
109     *
110     * <p>Called by the {@link com.android.server.devicepolicy.DevicePolicyManagerService} when
111     * the force-ephemeral-users policy is toggled on to make sure there are no pre-existing
112     * non-ephemeral users left.
113     */
114    public abstract void removeAllUsers();
115
116    /**
117     * Called by the activity manager when the ephemeral user goes to background and its removal
118     * starts as a result.
119     *
120     * <p>It marks the ephemeral user as disabled in order to prevent it from being re-entered
121     * before its removal finishes.
122     *
123     * @param userId the ID of the ephemeral user.
124     */
125    public abstract void onEphemeralUserStop(int userId);
126
127    /**
128     * Same as UserManager.createUser(), but bypasses the check for
129     * {@link UserManager#DISALLOW_ADD_USER} and {@link UserManager#DISALLOW_ADD_MANAGED_PROFILE}
130     *
131     * <p>Called by the {@link com.android.server.devicepolicy.DevicePolicyManagerService} when
132     * createAndManageUser is called by the device owner.
133     */
134    public abstract UserInfo createUserEvenWhenDisallowed(String name, int flags,
135            String[] disallowedPackages);
136
137    /**
138     * Same as {@link UserManager#removeUser(int userHandle)}, but bypasses the check for
139     * {@link UserManager#DISALLOW_REMOVE_USER} and
140     * {@link UserManager#DISALLOW_REMOVE_MANAGED_PROFILE} and does not require the
141     * {@link android.Manifest.permission#MANAGE_USERS} permission.
142     */
143    public abstract boolean removeUserEvenWhenDisallowed(int userId);
144
145    /**
146     * Return whether the given user is running in an
147     * {@code UserState.STATE_RUNNING_UNLOCKING} or
148     * {@code UserState.STATE_RUNNING_UNLOCKED} state.
149     */
150    public abstract boolean isUserUnlockingOrUnlocked(int userId);
151
152    /**
153     * Return whether the given user is running in an
154     * {@code UserState.STATE_RUNNING_UNLOCKED} state.
155     */
156    public abstract boolean isUserUnlocked(int userId);
157
158    /**
159     * Returns whether the given user is running
160     */
161    public abstract boolean isUserRunning(int userId);
162
163    /**
164     * Returns whether the given user is initialized
165     */
166    public abstract boolean isUserInitialized(int userId);
167
168    /**
169     * Returns whether the given user exists
170     */
171    public abstract boolean exists(int userId);
172
173    /**
174     * Set user's running state
175     */
176    public abstract void setUserState(int userId, int userState);
177
178    /**
179     * Remove user's running state
180     */
181    public abstract void removeUserState(int userId);
182
183    /**
184     * Returns an array of user ids. This array is cached in UserManagerService and passed as a
185     * reference, so do not modify the returned array.
186     *
187     * @return the array of user ids.
188     */
189    public abstract int[] getUserIds();
190
191    /**
192     * Checks if the {@code callingUserId} and {@code targetUserId} are same or in same group
193     * and that the {@code callingUserId} is not a managed profile and
194     * {@code targetUserId} is enabled.
195     *
196     * @return TRUE if the {@code callingUserId} can access {@code targetUserId}. FALSE
197     * otherwise
198     *
199     * @throws SecurityException if the calling user and {@code targetUser} are not in the same
200     * group and {@code throwSecurityException} is true, otherwise if will simply return false.
201     */
202    public abstract boolean isProfileAccessible(int callingUserId, int targetUserId,
203            String debugMsg, boolean throwSecurityException);
204
205    /**
206     * If {@code userId} is of a managed profile, return the parent user ID. Otherwise return
207     * itself.
208     */
209    public abstract int getProfileParentId(int userId);
210
211    /**
212     * Checks whether changing a setting to a value is prohibited by the corresponding user
213     * restriction.
214     *
215     * <p>See also {@link com.android.server.pm.UserRestrictionsUtils#applyUserRestriction(
216     * Context, int, String, boolean)}, which should be in sync with this method.
217     *
218     * @return {@code true} if the change is prohibited, {@code false} if the change is allowed.
219     *
220     * @hide
221     */
222    public abstract boolean isSettingRestrictedForUser(String setting, int userId, String value,
223            int callingUid);
224}
225