Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Move getUserSwitchability from UserManager to UserManagerService." into tm-qpr-dev

Browse Source
This commit is contained in:
Yasin Kilicdere
2023-01-10 17:59:42 +00:00
committed by Android (Google) Code Review
parent 8165fae2c8 e2062736ec
commit 11f8189e55
3 changed files with 72 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
core/java/android/os/IUserManager.aidl
View File

@@ -74,6 +74,7 @@ interface IUserManager {
String getUserAccount(int userId);
void setUserAccount(int userId, String accountName);
long getUserCreationTime(int userId);
int getUserSwitchability(int userId);
boolean isUserSwitcherEnabled(int mUserId);
boolean isRestricted(int userId);
boolean canHaveRestrictedProfile(int userId);

56
core/java/android/os/UserManager.java
View File

@@ -58,7 +58,6 @@ import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.location.LocationManager;
import android.provider.Settings;
import android.telephony.TelephonyManager;
import android.util.AndroidException;
import android.util.ArraySet;
import android.util.Log;
@@ -1673,7 +1672,7 @@ public class UserManager {
public static final int SWITCHABILITY_STATUS_SYSTEM_USER_LOCKED = 1 << 2;
/**
* Result returned in {@link #getUserSwitchability()} indicating user swichability.
* Result returned in {@link #getUserSwitchability()} indicating user switchability.
* @hide
*/
@Retention(RetentionPolicy.SOURCE)
@@ -2040,25 +2039,16 @@ public class UserManager {
* @hide
*/
@Deprecated
@RequiresPermission(allOf = {
Manifest.permission.READ_PHONE_STATE,
Manifest.permission.MANAGE_USERS}, // Can be INTERACT_ACROSS_USERS instead.
conditional = true)
@RequiresPermission(anyOf = {android.Manifest.permission.MANAGE_USERS,
android.Manifest.permission.INTERACT_ACROSS_USERS})
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
@UserHandleAware
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 = false;
TelephonyManager telephonyManager = mContext.getSystemService(TelephonyManager.class);
if (telephonyManager != null) {
inCall = telephonyManager.getCallState() != TelephonyManager.CALL_STATE_IDLE;
try {
return mService.getUserSwitchability(mUserId) == SWITCHABILITY_STATUS_OK;
} catch (RemoteException re) {
throw re.rethrowFromSystemServer();
}
boolean isUserSwitchDisallowed = hasUserRestrictionForUser(DISALLOW_USER_SWITCH, mUserId);
return (allowUserSwitchingWhenSystemUserLocked || isSystemUserUnlocked) && !inCall
&& !isUserSwitchDisallowed;
}
/**
@@ -2092,34 +2082,14 @@ public class UserManager {
* @return A {@link UserSwitchabilityResult} flag indicating if the user is switchable.
* @hide
*/
@RequiresPermission(allOf = {Manifest.permission.READ_PHONE_STATE,
android.Manifest.permission.MANAGE_USERS,
android.Manifest.permission.INTERACT_ACROSS_USERS}, conditional = true)
@RequiresPermission(anyOf = {android.Manifest.permission.MANAGE_USERS,
android.Manifest.permission.INTERACT_ACROSS_USERS})
public @UserSwitchabilityResult int getUserSwitchability(UserHandle userHandle) {
final TelephonyManager tm =
(TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
int flags = SWITCHABILITY_STATUS_OK;
if (tm.getCallState() != TelephonyManager.CALL_STATE_IDLE) {
flags |= SWITCHABILITY_STATUS_USER_IN_CALL;
try {
return mService.getUserSwitchability(userHandle.getIdentifier());
} catch (RemoteException re) {
throw re.rethrowFromSystemServer();
}
if (hasUserRestrictionForUser(DISALLOW_USER_SWITCH, userHandle)) {
flags |= SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED;
}
// System User is always unlocked in Headless System User Mode, so ignore this flag
if (!isHeadlessSystemUserMode()) {
final boolean allowUserSwitchingWhenSystemUserLocked = Settings.Global.getInt(
mContext.getContentResolver(),
Settings.Global.ALLOW_USER_SWITCHING_WHEN_SYSTEM_USER_LOCKED, 0) != 0;
final boolean systemUserUnlocked = isUserUnlocked(UserHandle.SYSTEM);
if (!allowUserSwitchingWhenSystemUserLocked && !systemUserUnlocked) {
flags |= SWITCHABILITY_STATUS_SYSTEM_USER_LOCKED;
}
}
return flags;
}
/**

58
services/core/java/com/android/server/pm/UserManagerService.java
View File

@@ -91,6 +91,7 @@ import android.security.GateKeeper;
import android.service.gatekeeper.IGateKeeperService;
import android.service.voice.VoiceInteractionManagerInternal;
import android.stats.devicepolicy.DevicePolicyEnums;
import android.telecom.TelecomManager;
import android.text.TextUtils;
import android.util.ArrayMap;
import android.util.ArraySet;
@@ -1760,6 +1761,63 @@ public class UserManagerService extends IUserManager.Stub {
}
}
/**
* Returns whether switching users is currently allowed for the provided user.
* <p>
* Switching users is not allowed in the following cases:
* <li>the user is in a phone call</li>
* <li>{@link UserManager#DISALLOW_USER_SWITCH} is set</li>
* <li>system user hasn't been unlocked yet</li>
*
* @return A {@link UserManager.UserSwitchabilityResult} flag indicating if the user is
* switchable.
*/
public @UserManager.UserSwitchabilityResult int getUserSwitchability(int userId) {
checkManageOrInteractPermissionIfCallerInOtherProfileGroup(userId, "getUserSwitchability");
final TimingsTraceAndSlog t = new TimingsTraceAndSlog();
t.traceBegin("getUserSwitchability-" + userId);
int flags = UserManager.SWITCHABILITY_STATUS_OK;
t.traceBegin("TM.isInCall");
final long identity = Binder.clearCallingIdentity();
try {
final TelecomManager telecomManager = mContext.getSystemService(TelecomManager.class);
if (telecomManager != null && telecomManager.isInCall()) {
flags |= UserManager.SWITCHABILITY_STATUS_USER_IN_CALL;
}
} finally {
Binder.restoreCallingIdentity(identity);
}
t.traceEnd();
t.traceBegin("hasUserRestriction-DISALLOW_USER_SWITCH");
if (mLocalService.hasUserRestriction(DISALLOW_USER_SWITCH, userId)) {
flags |= UserManager.SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED;
}
t.traceEnd();
// System User is always unlocked in Headless System User Mode, so ignore this flag
if (!UserManager.isHeadlessSystemUserMode()) {
t.traceBegin("getInt-ALLOW_USER_SWITCHING_WHEN_SYSTEM_USER_LOCKED");
final boolean allowUserSwitchingWhenSystemUserLocked = Settings.Global.getInt(
mContext.getContentResolver(),
Settings.Global.ALLOW_USER_SWITCHING_WHEN_SYSTEM_USER_LOCKED, 0) != 0;
t.traceEnd();
t.traceBegin("isUserUnlocked-USER_SYSTEM");
final boolean systemUserUnlocked = mLocalService.isUserUnlocked(UserHandle.USER_SYSTEM);
t.traceEnd();
if (!allowUserSwitchingWhenSystemUserLocked && !systemUserUnlocked) {
flags |= UserManager.SWITCHABILITY_STATUS_SYSTEM_USER_LOCKED;
}
}
t.traceEnd();
return flags;
}
@Override
public boolean isUserSwitcherEnabled(@UserIdInt int mUserId) {
boolean multiUserSettingOn = Settings.Global.getInt(mContext.getContentResolver(),