entry :
overrideConfig.mModeConfigs.entrySet()) {
copy.mModeConfigs.put(entry.getKey(), entry.getValue());
}
}
}
}
return copy;
}
public String toString() {
synchronized (mModeConfigLock) {
return "[Name:" + mPackageName + " Modes: " + mModeConfigs.toString() + "]";
}
}
}
private final class LocalService extends GameManagerInternal implements CompatScaleProvider {
@Override
public float getResolutionScalingFactor(String packageName, int userId) {
final int gameMode = getGameModeFromSettingsUnchecked(packageName, userId);
return getResolutionScalingFactorInternal(packageName, gameMode, userId);
}
@Nullable
@Override
public CompatScale getCompatScale(@NonNull String packageName, int uid) {
UserHandle userHandle = UserHandle.getUserHandleForUid(uid);
int userId = userHandle.getIdentifier();
float scalingFactor = getResolutionScalingFactor(packageName, userId);
if (scalingFactor > 0) {
return new CompatScale(1f / scalingFactor);
}
return null;
}
}
/**
* SystemService lifecycle for GameService.
*
* @hide
*/
public static class Lifecycle extends SystemService {
private GameManagerService mService;
public Lifecycle(Context context) {
super(context);
mService = new GameManagerService(context);
}
@Override
public void onStart() {
publishBinderService(Context.GAME_SERVICE, mService);
mService.publishLocalService();
mService.registerDeviceConfigListener();
mService.registerPackageReceiver();
}
@Override
public void onBootPhase(int phase) {
if (phase == PHASE_BOOT_COMPLETED) {
mService.onBootCompleted();
mService.registerStatsCallbacks();
}
}
@Override
public void onUserStarting(@NonNull TargetUser user) {
Slog.d(TAG, "Starting user " + user.getUserIdentifier());
mService.onUserStarting(user, /*settingDataDirOverride*/ null);
}
@Override
public void onUserUnlocking(@NonNull TargetUser user) {
mService.onUserUnlocking(user);
}
@Override
public void onUserStopping(@NonNull TargetUser user) {
mService.onUserStopping(user);
}
@Override
public void onUserSwitching(@Nullable TargetUser from, @NonNull TargetUser to) {
mService.onUserSwitching(from, to);
}
}
private boolean isValidPackageName(String packageName, int userId) {
try {
return mPackageManager.getPackageUidAsUser(packageName, userId)
== Binder.getCallingUid();
} catch (NameNotFoundException e) {
return false;
}
}
private void checkPermission(String permission) throws SecurityException {
if (mContext.checkCallingOrSelfPermission(permission)
!= PackageManager.PERMISSION_GRANTED) {
throw new SecurityException("Access denied to process: " + Binder.getCallingPid()
+ ", must have permission " + permission);
}
}
private @GameMode int[] getAvailableGameModesUnchecked(String packageName, int userId) {
final GamePackageConfiguration config = getConfig(packageName, userId);
if (config == null) {
return new int[]{GameManager.GAME_MODE_STANDARD, GameManager.GAME_MODE_CUSTOM};
}
return config.getAvailableGameModes();
}
private boolean isPackageGame(String packageName, @UserIdInt int userId) {
try {
final ApplicationInfo applicationInfo = mPackageManager
.getApplicationInfoAsUser(packageName, PackageManager.MATCH_ALL, userId);
return applicationInfo.category == ApplicationInfo.CATEGORY_GAME;
} catch (PackageManager.NameNotFoundException e) {
return false;
}
}
/**
* Get an array of game modes available for a given package.
* Checks that the caller has {@link android.Manifest.permission#MANAGE_GAME_MODE}.
*/
@Override
@RequiresPermission(Manifest.permission.MANAGE_GAME_MODE)
public @GameMode int[] getAvailableGameModes(String packageName, int userId)
throws SecurityException {
checkPermission(Manifest.permission.MANAGE_GAME_MODE);
if (!isPackageGame(packageName, userId)) {
return new int[]{};
}
return getAvailableGameModesUnchecked(packageName, userId);
}
private @GameMode int getGameModeFromSettingsUnchecked(String packageName,
@UserIdInt int userId) {
synchronized (mLock) {
if (!mSettings.containsKey(userId)) {
Slog.d(TAG, "User ID '" + userId + "' does not have a Game Mode"
+ " selected for package: '" + packageName + "'");
return GameManager.GAME_MODE_STANDARD;
}
return mSettings.get(userId).getGameModeLocked(packageName);
}
}
/**
* Get the Game Mode for the package name.
* Verifies that the calling process is for the matching package UID or has
* {@link android.Manifest.permission#MANAGE_GAME_MODE}.
*/
@Override
public @GameMode int getGameMode(@NonNull String packageName, @UserIdInt int userId)
throws SecurityException {
userId = ActivityManager.handleIncomingUser(Binder.getCallingPid(),
Binder.getCallingUid(), userId, false, true, "getGameMode",
"com.android.server.app.GameManagerService");
// Restrict to games only.
if (!isPackageGame(packageName, userId)) {
// The game mode for applications that are not identified as game is always
// UNSUPPORTED. See {@link PackageManager#setApplicationCategoryHint(String, int)}
return GameManager.GAME_MODE_UNSUPPORTED;
}
// This function handles two types of queries:
// 1) A normal, non-privileged app querying its own Game Mode.
// 2) A privileged system service querying the Game Mode of another package.
// The least privileged case is a normal app performing a query, so check that first and
// return a value if the package name is valid. Next, check if the caller has the necessary
// permission and return a value. Do this check last, since it can throw an exception.
if (isValidPackageName(packageName, userId)) {
return getGameModeFromSettingsUnchecked(packageName, userId);
}
// Since the package name doesn't match, check the caller has the necessary permission.
checkPermission(Manifest.permission.MANAGE_GAME_MODE);
return getGameModeFromSettingsUnchecked(packageName, userId);
}
/**
* Get the GameModeInfo for the package name.
* Verifies that the calling process is for the matching package UID or has
* {@link android.Manifest.permission#MANAGE_GAME_MODE}. If the package is not a game,
* null is always returned.
*/
@Override
@RequiresPermission(Manifest.permission.MANAGE_GAME_MODE)
@Nullable
public GameModeInfo getGameModeInfo(@NonNull String packageName, @UserIdInt int userId) {
userId = ActivityManager.handleIncomingUser(Binder.getCallingPid(),
Binder.getCallingUid(), userId, false, true, "getGameModeInfo",
"com.android.server.app.GameManagerService");
// Check the caller has the necessary permission.
checkPermission(Manifest.permission.MANAGE_GAME_MODE);
if (!isPackageGame(packageName, userId)) {
return null;
}
final @GameMode int activeGameMode = getGameModeFromSettingsUnchecked(packageName, userId);
final GamePackageConfiguration config = getConfig(packageName, userId);
if (config != null) {
final @GameMode int[] overriddenGameModes = config.getOverriddenGameModes();
final @GameMode int[] availableGameModes = config.getAvailableGameModes();
GameModeInfo.Builder gameModeInfoBuilder = new GameModeInfo.Builder()
.setActiveGameMode(activeGameMode)
.setAvailableGameModes(availableGameModes)
.setOverriddenGameModes(overriddenGameModes)
.setDownscalingAllowed(config.mAllowDownscale)
.setFpsOverrideAllowed(config.mAllowFpsOverride);
for (int gameMode : availableGameModes) {
if (!config.willGamePerformOptimizations(gameMode)) {
GamePackageConfiguration.GameModeConfiguration gameModeConfig =
config.getGameModeConfiguration(gameMode);
if (gameModeConfig != null) {
gameModeInfoBuilder.setGameModeConfiguration(gameMode,
gameModeConfig.toPublicGameModeConfig());
}
}
}
return gameModeInfoBuilder.build();
} else {
return new GameModeInfo.Builder()
.setActiveGameMode(activeGameMode)
.setAvailableGameModes(getAvailableGameModesUnchecked(packageName, userId))
.build();
}
}
/**
* Sets the Game Mode for the package name.
* Verifies that the calling process has {@link android.Manifest.permission#MANAGE_GAME_MODE}.
*/
@Override
@RequiresPermission(Manifest.permission.MANAGE_GAME_MODE)
public void setGameMode(String packageName, @GameMode int gameMode, int userId)
throws SecurityException {
checkPermission(Manifest.permission.MANAGE_GAME_MODE);
if (gameMode == GameManager.GAME_MODE_UNSUPPORTED) {
Slog.d(TAG, "No-op for attempt to set UNSUPPORTED mode for app: " + packageName);
return;
} else if (!isPackageGame(packageName, userId)) {
Slog.d(TAG, "No-op for attempt to set game mode for non-game app: " + packageName);
return;
}
int fromGameMode;
synchronized (mLock) {
userId = ActivityManager.handleIncomingUser(Binder.getCallingPid(),
Binder.getCallingUid(), userId, false, true, "setGameMode",
"com.android.server.app.GameManagerService");
if (!mSettings.containsKey(userId)) {
Slog.d(TAG, "Failed to set game mode for package " + packageName
+ " as user " + userId + " is not started");
return;
}
GameManagerSettings userSettings = mSettings.get(userId);
fromGameMode = userSettings.getGameModeLocked(packageName);
userSettings.setGameModeLocked(packageName, gameMode);
}
updateInterventions(packageName, gameMode, userId);
synchronized (mGameModeListenerLock) {
for (IGameModeListener listener : mGameModeListeners.keySet()) {
Binder.allowBlocking(listener.asBinder());
try {
listener.onGameModeChanged(packageName, fromGameMode, gameMode, userId);
} catch (RemoteException ex) {
Slog.w(TAG, "Cannot notify game mode change for listener added by "
+ mGameModeListeners.get(listener));
}
}
}
sendUserMessage(userId, WRITE_SETTINGS, EVENT_SET_GAME_MODE, WRITE_DELAY_MILLIS);
sendUserMessage(userId, WRITE_GAME_MODE_INTERVENTION_LIST_FILE,
EVENT_SET_GAME_MODE, 0 /*delayMillis*/);
int gameUid = -1;
try {
gameUid = mPackageManager.getPackageUidAsUser(packageName, userId);
} catch (NameNotFoundException ex) {
Slog.d(TAG, "Cannot find the UID for package " + packageName + " under user " + userId);
}
FrameworkStatsLog.write(FrameworkStatsLog.GAME_MODE_CHANGED, gameUid,
Binder.getCallingUid(), gameModeToStatsdGameMode(fromGameMode),
gameModeToStatsdGameMode(gameMode));
}
/**
* Get if ANGLE is enabled for the package for the currently enabled game mode.
* Checks that the caller has {@link android.Manifest.permission#MANAGE_GAME_MODE}.
*/
@Override
@RequiresPermission(Manifest.permission.MANAGE_GAME_MODE)
public @GameMode boolean isAngleEnabled(String packageName, int userId)
throws SecurityException {
final int gameMode = getGameMode(packageName, userId);
if (gameMode == GameManager.GAME_MODE_UNSUPPORTED) {
return false;
}
final GamePackageConfiguration config;
synchronized (mDeviceConfigLock) {
config = mConfigs.get(packageName);
if (config == null) {
return false;
}
}
GamePackageConfiguration.GameModeConfiguration gameModeConfiguration =
config.getGameModeConfiguration(gameMode);
if (gameModeConfiguration == null) {
return false;
}
return gameModeConfiguration.getUseAngle();
}
/**
* If loading boost is applicable for the package for the currently enabled game mode, return
* the boost duration. If no configuration is available for the selected package or mode, the
* default is returned.
*/
public int getLoadingBoostDuration(String packageName, int userId)
throws SecurityException {
final int gameMode = getGameMode(packageName, userId);
if (gameMode == GameManager.GAME_MODE_UNSUPPORTED) {
return -1;
}
final GamePackageConfiguration config;
synchronized (mDeviceConfigLock) {
config = mConfigs.get(packageName);
}
if (config == null) {
return -1;
}
GamePackageConfiguration.GameModeConfiguration gameModeConfiguration =
config.getGameModeConfiguration(gameMode);
if (gameModeConfiguration == null) {
return -1;
}
return gameModeConfiguration.getLoadingBoostDuration();
}
/**
* If loading boost is enabled, invoke it.
*/
@Override
@RequiresPermission(Manifest.permission.MANAGE_GAME_MODE)
@GameMode public void notifyGraphicsEnvironmentSetup(String packageName, int userId)
throws SecurityException {
userId = ActivityManager.handleIncomingUser(Binder.getCallingPid(),
Binder.getCallingUid(), userId, false, true, "notifyGraphicsEnvironmentSetup",
"com.android.server.app.GameManagerService");
if (!isValidPackageName(packageName, userId)) {
Slog.d(TAG, "No-op for attempt to notify graphics env setup for different package"
+ "than caller with uid: " + Binder.getCallingUid());
return;
}
final int gameMode = getGameMode(packageName, userId);
if (gameMode == GameManager.GAME_MODE_UNSUPPORTED) {
Slog.d(TAG, "No-op for attempt to notify graphics env setup for non-game app: "
+ packageName);
return;
}
int loadingBoostDuration = getLoadingBoostDuration(packageName, userId);
if (loadingBoostDuration != -1) {
if (loadingBoostDuration == 0 || loadingBoostDuration > LOADING_BOOST_MAX_DURATION) {
loadingBoostDuration = LOADING_BOOST_MAX_DURATION;
}
if (mHandler.hasMessages(CANCEL_GAME_LOADING_MODE)) {
// The loading mode has already been set and is waiting to be unset. It is not
// required to set the mode again and we should replace the queued cancel
// instruction.
mHandler.removeMessages(CANCEL_GAME_LOADING_MODE);
} else {
Slog.v(TAG, "Game loading power mode ON (loading boost on game start)");
mPowerManagerInternal.setPowerMode(Mode.GAME_LOADING, true);
}
mHandler.sendMessageDelayed(
mHandler.obtainMessage(CANCEL_GAME_LOADING_MODE), loadingBoostDuration);
}
}
/**
* Sets the game service provider to a given package, meant for testing.
*
* This setting persists until the next call or until the next reboot.
*
*
Checks that the caller has {@link android.Manifest.permission#SET_GAME_SERVICE}.
*/
@Override
@RequiresPermission(Manifest.permission.SET_GAME_SERVICE)
public void setGameServiceProvider(@Nullable String packageName) throws SecurityException {
checkPermission(Manifest.permission.SET_GAME_SERVICE);
if (mGameServiceController == null) {
return;
}
mGameServiceController.setGameServiceProvider(packageName);
}
/**
* Updates the resolution scaling factor for the package's target game mode and activates it.
*
* @param scalingFactor enable scaling override over any other compat scaling if positive,
* or disable the override otherwise
* @throws SecurityException if caller doesn't have
* {@link android.Manifest.permission#MANAGE_GAME_MODE}
* permission.
* @throws IllegalArgumentException if the user ID provided doesn't exist.
*/
@Override
@RequiresPermission(Manifest.permission.MANAGE_GAME_MODE)
public void updateResolutionScalingFactor(String packageName, int gameMode, float scalingFactor,
int userId) throws SecurityException, IllegalArgumentException {
checkPermission(Manifest.permission.MANAGE_GAME_MODE);
synchronized (mLock) {
if (!mSettings.containsKey(userId)) {
throw new IllegalArgumentException("User " + userId + " wasn't started");
}
}
setGameModeConfigOverride(packageName, userId, gameMode, null /*fpsStr*/,
Float.toString(scalingFactor));
}
/**
* Gets the resolution scaling factor for the package's target game mode.
*
* @return scaling factor for the game mode if exists or negative value otherwise.
* @throws SecurityException if caller doesn't have
* {@link android.Manifest.permission#MANAGE_GAME_MODE}
* permission.
* @throws IllegalArgumentException if the user ID provided doesn't exist.
*/
@Override
@RequiresPermission(Manifest.permission.MANAGE_GAME_MODE)
public float getResolutionScalingFactor(String packageName, int gameMode, int userId)
throws SecurityException, IllegalArgumentException {
checkPermission(Manifest.permission.MANAGE_GAME_MODE);
synchronized (mLock) {
if (!mSettings.containsKey(userId)) {
throw new IllegalArgumentException("User " + userId + " wasn't started");
}
}
return getResolutionScalingFactorInternal(packageName, gameMode, userId);
}
float getResolutionScalingFactorInternal(String packageName, int gameMode, int userId) {
final GamePackageConfiguration packageConfig = getConfig(packageName, userId);
if (packageConfig == null) {
return GamePackageConfiguration.GameModeConfiguration.DEFAULT_SCALING;
}
final GamePackageConfiguration.GameModeConfiguration modeConfig =
packageConfig.getGameModeConfiguration(gameMode);
if (modeConfig != null) {
return modeConfig.getScaling();
}
return GamePackageConfiguration.GameModeConfiguration.DEFAULT_SCALING;
}
/**
* Updates the config for the game's {@link GameManager#GAME_MODE_CUSTOM} mode.
*
* @throws SecurityException if caller doesn't have
* {@link android.Manifest.permission#MANAGE_GAME_MODE}
* permission.
* @throws IllegalArgumentException if the user ID provided doesn't exist.
*/
@Override
@RequiresPermission(Manifest.permission.MANAGE_GAME_MODE)
public void updateCustomGameModeConfiguration(String packageName,
GameModeConfiguration gameModeConfig, int userId)
throws SecurityException, IllegalArgumentException {
checkPermission(Manifest.permission.MANAGE_GAME_MODE);
if (!isPackageGame(packageName, userId)) {
Slog.d(TAG, "No-op for attempt to update custom game mode for non-game app: "
+ packageName);
return;
}
synchronized (mLock) {
if (!mSettings.containsKey(userId)) {
throw new IllegalArgumentException("User " + userId + " wasn't started");
}
}
// TODO(b/243448953): add validation on gameModeConfig provided
// Adding game mode config override of the given package name
GamePackageConfiguration configOverride;
synchronized (mLock) {
if (!mSettings.containsKey(userId)) {
return;
}
final GameManagerSettings settings = mSettings.get(userId);
// look for the existing GamePackageConfiguration override
configOverride = settings.getConfigOverrideLocked(packageName);
if (configOverride == null) {
configOverride = new GamePackageConfiguration(packageName);
settings.setConfigOverrideLocked(packageName, configOverride);
}
}
GamePackageConfiguration.GameModeConfiguration internalConfig =
configOverride.getOrAddDefaultGameModeConfiguration(GameManager.GAME_MODE_CUSTOM);
final float scalingValueFrom = internalConfig.getScaling();
final int fpsValueFrom = internalConfig.getFps();
internalConfig.updateFromPublicGameModeConfig(gameModeConfig);
sendUserMessage(userId, WRITE_SETTINGS, EVENT_UPDATE_CUSTOM_GAME_MODE_CONFIG,
WRITE_DELAY_MILLIS);
sendUserMessage(userId, WRITE_GAME_MODE_INTERVENTION_LIST_FILE,
EVENT_UPDATE_CUSTOM_GAME_MODE_CONFIG, WRITE_DELAY_MILLIS /*delayMillis*/);
final int gameMode = getGameMode(packageName, userId);
if (gameMode == GameManager.GAME_MODE_CUSTOM) {
updateInterventions(packageName, gameMode, userId);
}
Slog.i(TAG, "Updated custom game mode config for package: " + packageName
+ " with FPS=" + internalConfig.getFps() + ";Scaling="
+ internalConfig.getScaling() + " under user " + userId);
int gameUid = -1;
try {
gameUid = mPackageManager.getPackageUidAsUser(packageName, userId);
} catch (NameNotFoundException ex) {
Slog.d(TAG, "Cannot find the UID for package " + packageName + " under user " + userId);
}
FrameworkStatsLog.write(FrameworkStatsLog.GAME_MODE_CONFIGURATION_CHANGED, gameUid,
Binder.getCallingUid(), gameModeToStatsdGameMode(GameManager.GAME_MODE_CUSTOM),
scalingValueFrom, gameModeConfig.getScalingFactor(),
fpsValueFrom, gameModeConfig.getFpsOverride());
}
/**
* Adds a game mode listener.
*
* @throws SecurityException if caller doesn't have
* {@link android.Manifest.permission#MANAGE_GAME_MODE}
* permission.
*/
@Override
@RequiresPermission(Manifest.permission.MANAGE_GAME_MODE)
public void addGameModeListener(@NonNull IGameModeListener listener) {
checkPermission(Manifest.permission.MANAGE_GAME_MODE);
try {
final IBinder listenerBinder = listener.asBinder();
listenerBinder.linkToDeath(new DeathRecipient() {
@Override public void binderDied() {
// TODO(b/258851194): add traces on binder death based listener removal
removeGameModeListenerUnchecked(listener);
listenerBinder.unlinkToDeath(this, 0 /*flags*/);
}
}, 0 /*flags*/);
synchronized (mGameModeListenerLock) {
mGameModeListeners.put(listener, Binder.getCallingUid());
}
} catch (RemoteException ex) {
Slog.e(TAG,
"Failed to link death recipient for IGameModeListener from caller "
+ Binder.getCallingUid() + ", abandoned its listener registration", ex);
}
}
/**
* Removes a game mode listener.
*
* @throws SecurityException if caller doesn't have
* {@link android.Manifest.permission#MANAGE_GAME_MODE}
* permission.
*/
@Override
@RequiresPermission(Manifest.permission.MANAGE_GAME_MODE)
public void removeGameModeListener(@NonNull IGameModeListener listener) {
// TODO(b/258851194): add traces on manual listener removal
checkPermission(Manifest.permission.MANAGE_GAME_MODE);
removeGameModeListenerUnchecked(listener);
}
private void removeGameModeListenerUnchecked(IGameModeListener listener) {
synchronized (mGameModeListenerLock) {
mGameModeListeners.remove(listener);
}
}
/**
* Adds a game state listener.
*/
@Override
public void addGameStateListener(@NonNull IGameStateListener listener) {
try {
final IBinder listenerBinder = listener.asBinder();
listenerBinder.linkToDeath(new DeathRecipient() {
@Override public void binderDied() {
removeGameStateListenerUnchecked(listener);
listenerBinder.unlinkToDeath(this, 0 /*flags*/);
}
}, 0 /*flags*/);
synchronized (mGameStateListenerLock) {
mGameStateListeners.put(listener, Binder.getCallingUid());
}
} catch (RemoteException ex) {
Slog.e(TAG,
"Failed to link death recipient for IGameStateListener from caller "
+ Binder.getCallingUid() + ", abandoned its listener registration", ex);
}
}
/**
* Removes a game state listener.
*/
@Override
public void removeGameStateListener(@NonNull IGameStateListener listener) {
removeGameStateListenerUnchecked(listener);
}
private void removeGameStateListenerUnchecked(IGameStateListener listener) {
synchronized (mGameStateListenerLock) {
mGameStateListeners.remove(listener);
}
}
/**
* Notified when boot is completed.
*/
@VisibleForTesting
void onBootCompleted() {
Slog.d(TAG, "onBootCompleted");
if (mGameServiceController != null) {
mGameServiceController.onBootComplete();
}
mContext.registerReceiver(new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (Intent.ACTION_SHUTDOWN.equals(intent.getAction())) {
synchronized (mLock) {
// Note that the max wait time of broadcast is 10s (see
// {@ShutdownThread#MAX_BROADCAST_TIMEMAX_BROADCAST_TIME}) currently so
// this can be optional only if we have message delay plus processing
// time significant smaller to prevent data loss.
for (Map.Entry entry : mSettings.entrySet()) {
final int userId = entry.getKey();
sendUserMessage(userId, WRITE_SETTINGS,
EVENT_RECEIVE_SHUTDOWN_INDENT, 0 /*delayMillis*/);
sendUserMessage(userId,
WRITE_GAME_MODE_INTERVENTION_LIST_FILE,
EVENT_RECEIVE_SHUTDOWN_INDENT,
0 /*delayMillis*/);
}
}
}
}
}, new IntentFilter(Intent.ACTION_SHUTDOWN));
Slog.v(TAG, "Game loading power mode OFF (game manager service start/restart)");
mPowerManagerInternal.setPowerMode(Mode.GAME_LOADING, false);
Slog.v(TAG, "Game power mode OFF (game manager service start/restart)");
mPowerManagerInternal.setPowerMode(Mode.GAME, false);
mGameDefaultFrameRateValue = (float) mSysProps.getInt(
PROPERTY_RO_SURFACEFLINGER_GAME_DEFAULT_FRAME_RATE, 60);
Slog.v(TAG, "Game Default Frame Rate : " + mGameDefaultFrameRateValue);
}
private void sendUserMessage(int userId, int what, String eventForLog, int delayMillis) {
Message msg = mHandler.obtainMessage(what, userId);
if (!mHandler.sendMessageDelayed(msg, delayMillis)) {
Slog.e(TAG, "Failed to send user message " + what + " on " + eventForLog);
}
}
void onUserStarting(@NonNull TargetUser user, File settingDataDirOverride) {
final int userId = user.getUserIdentifier();
if (settingDataDirOverride != null) {
synchronized (mLock) {
if (!mSettings.containsKey(userId)) {
GameManagerSettings userSettings = new GameManagerSettings(
settingDataDirOverride);
mSettings.put(userId, userSettings);
userSettings.readPersistentDataLocked();
}
}
}
sendUserMessage(userId, POPULATE_GAME_MODE_SETTINGS, EVENT_ON_USER_STARTING,
0 /*delayMillis*/);
if (mGameServiceController != null) {
mGameServiceController.notifyUserStarted(user);
}
}
void onUserUnlocking(@NonNull TargetUser user) {
if (mGameServiceController != null) {
mGameServiceController.notifyUserUnlocking(user);
}
}
void onUserStopping(TargetUser user) {
final int userId = user.getUserIdentifier();
synchronized (mLock) {
if (!mSettings.containsKey(userId)) {
return;
}
sendUserMessage(userId, REMOVE_SETTINGS, EVENT_ON_USER_STOPPING, 0 /*delayMillis*/);
}
if (mGameServiceController != null) {
mGameServiceController.notifyUserStopped(user);
}
}
void onUserSwitching(TargetUser from, TargetUser to) {
final int toUserId = to.getUserIdentifier();
// we want to re-populate the setting when switching user as the device config may have
// changed, which will only update for the previous user, see
// DeviceConfigListener#onPropertiesChanged.
sendUserMessage(toUserId, POPULATE_GAME_MODE_SETTINGS, EVENT_ON_USER_SWITCHING,
0 /*delayMillis*/);
if (mGameServiceController != null) {
mGameServiceController.notifyNewForegroundUser(to);
}
}
/**
* Remove frame rate override due to mode switch
*/
private void resetFps(String packageName, @UserIdInt int userId) {
try {
final float fps = 0.0f;
final int uid = mPackageManager.getPackageUidAsUser(packageName, userId);
setGameModeFrameRateOverride(uid, fps);
} catch (PackageManager.NameNotFoundException e) {
return;
}
}
private static int modeToBitmask(@GameMode int gameMode) {
return (1 << gameMode);
}
private boolean bitFieldContainsModeBitmask(int bitField, @GameMode int gameMode) {
return (bitField & modeToBitmask(gameMode)) != 0;
}
@RequiresPermission(Manifest.permission.WRITE_SECURE_SETTINGS)
private void updateUseAngle(String packageName, @GameMode int gameMode) {
// TODO (b/188475576): Nothing to do yet. Remove if it's still empty when we're ready to
// ship.
}
private void updateFps(GamePackageConfiguration packageConfig, String packageName,
@GameMode int gameMode, @UserIdInt int userId) {
final GamePackageConfiguration.GameModeConfiguration modeConfig =
packageConfig.getGameModeConfiguration(gameMode);
if (modeConfig == null) {
Slog.d(TAG, "Game mode " + gameMode + " not found for " + packageName);
return;
}
try {
final float fps = modeConfig.getFps();
final int uid = mPackageManager.getPackageUidAsUser(packageName, userId);
setGameModeFrameRateOverride(uid, fps);
} catch (PackageManager.NameNotFoundException e) {
return;
}
}
private void updateInterventions(String packageName,
@GameMode int gameMode, @UserIdInt int userId) {
final GamePackageConfiguration packageConfig = getConfig(packageName, userId);
if (gameMode == GameManager.GAME_MODE_STANDARD
|| gameMode == GameManager.GAME_MODE_UNSUPPORTED || packageConfig == null
|| packageConfig.willGamePerformOptimizations(gameMode)
|| packageConfig.getGameModeConfiguration(gameMode) == null) {
resetFps(packageName, userId);
// resolution scaling does not need to be reset as it's now read dynamically on game
// restart, see #getResolutionScalingFactor and CompatModePackages#getCompatScale.
// TODO: reset Angle intervention here once implemented
if (packageConfig == null) {
Slog.v(TAG, "Package configuration not found for " + packageName);
return;
}
} else {
updateFps(packageConfig, packageName, gameMode, userId);
}
updateUseAngle(packageName, gameMode);
}
/**
* Set the Game Mode Configuration override.
* Update the config if exists, create one if not.
*/
@VisibleForTesting
@RequiresPermission(Manifest.permission.MANAGE_GAME_MODE)
public void setGameModeConfigOverride(String packageName, @UserIdInt int userId,
@GameMode int gameMode, String fpsStr, String scaling) throws SecurityException {
checkPermission(Manifest.permission.MANAGE_GAME_MODE);
int gameUid = -1;
try {
gameUid = mPackageManager.getPackageUidAsUser(packageName, userId);
} catch (NameNotFoundException ex) {
Slog.d(TAG, "Cannot find the UID for package " + packageName + " under user " + userId);
}
GamePackageConfiguration pkgConfig = getConfig(packageName, userId);
if (pkgConfig != null && pkgConfig.getGameModeConfiguration(gameMode) != null) {
final GamePackageConfiguration.GameModeConfiguration currentModeConfig =
pkgConfig.getGameModeConfiguration(gameMode);
FrameworkStatsLog.write(FrameworkStatsLog.GAME_MODE_CONFIGURATION_CHANGED, gameUid,
Binder.getCallingUid(), gameModeToStatsdGameMode(gameMode),
currentModeConfig.getScaling() /* fromScaling */,
scaling == null ? currentModeConfig.getScaling()
: Float.parseFloat(scaling) /* toScaling */,
currentModeConfig.getFps() /* fromFps */,
fpsStr == null ? currentModeConfig.getFps()
: Integer.parseInt(fpsStr)) /* toFps */;
} else {
FrameworkStatsLog.write(FrameworkStatsLog.GAME_MODE_CONFIGURATION_CHANGED, gameUid,
Binder.getCallingUid(), gameModeToStatsdGameMode(gameMode),
GamePackageConfiguration.GameModeConfiguration.DEFAULT_SCALING /* fromScaling*/,
scaling == null ? GamePackageConfiguration.GameModeConfiguration.DEFAULT_SCALING
: Float.parseFloat(scaling) /* toScaling */,
0 /* fromFps */,
fpsStr == null ? 0 : Integer.parseInt(fpsStr) /* toFps */);
}
// Adding game mode config override of the given package name
GamePackageConfiguration configOverride;
synchronized (mLock) {
if (!mSettings.containsKey(userId)) {
return;
}
final GameManagerSettings settings = mSettings.get(userId);
// look for the existing GamePackageConfiguration override
configOverride = settings.getConfigOverrideLocked(packageName);
if (configOverride == null) {
configOverride = new GamePackageConfiguration(packageName);
settings.setConfigOverrideLocked(packageName, configOverride);
}
}
// modify GameModeConfiguration intervention settings
GamePackageConfiguration.GameModeConfiguration modeConfigOverride =
configOverride.getOrAddDefaultGameModeConfiguration(gameMode);
if (fpsStr != null) {
modeConfigOverride.setFpsStr(fpsStr);
} else {
modeConfigOverride.setFpsStr(
GamePackageConfiguration.GameModeConfiguration.DEFAULT_FPS);
}
if (scaling != null) {
modeConfigOverride.setScaling(Float.parseFloat(scaling));
}
Slog.i(TAG, "Package Name: " + packageName
+ " FPS: " + String.valueOf(modeConfigOverride.getFps())
+ " Scaling: " + modeConfigOverride.getScaling());
setGameMode(packageName, gameMode, userId);
}
/**
* Reset the overridden gameModeConfiguration of the given mode.
* Remove the config override if game mode is not specified.
*/
@VisibleForTesting
@RequiresPermission(Manifest.permission.MANAGE_GAME_MODE)
public void resetGameModeConfigOverride(String packageName, @UserIdInt int userId,
@GameMode int gameModeToReset) throws SecurityException {
checkPermission(Manifest.permission.MANAGE_GAME_MODE);
// resets GamePackageConfiguration of a given packageName.
// If a gameMode is specified, only reset the GameModeConfiguration of the gameMode.
synchronized (mLock) {
if (!mSettings.containsKey(userId)) {
return;
}
final GameManagerSettings settings = mSettings.get(userId);
if (gameModeToReset != -1) {
final GamePackageConfiguration configOverride = settings.getConfigOverrideLocked(
packageName);
if (configOverride == null) {
return;
}
final int modesBitfield = configOverride.getAvailableGameModesBitfield();
if (!bitFieldContainsModeBitmask(modesBitfield, gameModeToReset)) {
return;
}
configOverride.removeModeConfig(gameModeToReset);
if (!configOverride.hasActiveGameModeConfig()) {
settings.removeConfigOverrideLocked(packageName);
}
} else {
settings.removeConfigOverrideLocked(packageName);
}
}
// Make sure after resetting the game mode is still supported.
// If not, set the game mode to standard
int gameMode = getGameMode(packageName, userId);
final GamePackageConfiguration config = getConfig(packageName, userId);
final int newGameMode = getNewGameMode(gameMode, config);
if (gameMode != newGameMode) {
setGameMode(packageName, GameManager.GAME_MODE_STANDARD, userId);
return;
}
setGameMode(packageName, gameMode, userId);
}
private int getNewGameMode(int gameMode, GamePackageConfiguration config) {
int newGameMode = gameMode;
if (config != null) {
int modesBitfield = config.getAvailableGameModesBitfield();
// Remove UNSUPPORTED to simplify the logic here, since we really just
// want to check if we support selectable game modes
modesBitfield &= ~modeToBitmask(GameManager.GAME_MODE_UNSUPPORTED);
if (!bitFieldContainsModeBitmask(modesBitfield, gameMode)) {
// always default to STANDARD if there is no mode config
newGameMode = GameManager.GAME_MODE_STANDARD;
}
} else {
// always default to STANDARD if there is no package config
newGameMode = GameManager.GAME_MODE_STANDARD;
}
return newGameMode;
}
/**
* Returns the string listing all the interventions currently set to a game.
*/
@RequiresPermission(Manifest.permission.QUERY_ALL_PACKAGES)
public String getInterventionList(String packageName, int userId) {
checkPermission(Manifest.permission.QUERY_ALL_PACKAGES);
final GamePackageConfiguration packageConfig = getConfig(packageName, userId);
final StringBuilder listStrSb = new StringBuilder();
if (packageConfig == null) {
listStrSb.append("\n No intervention found for package ")
.append(packageName);
return listStrSb.toString();
}
listStrSb.append("\n")
.append(packageConfig.toString());
return listStrSb.toString();
}
/**
* @hide
*/
@VisibleForTesting
void updateConfigsForUser(@UserIdInt int userId, boolean checkGamePackage,
String... packageNames) {
if (checkGamePackage) {
packageNames = Arrays.stream(packageNames).filter(
p -> isPackageGame(p, userId)).toArray(String[]::new);
}
try {
synchronized (mDeviceConfigLock) {
for (final String packageName : packageNames) {
final GamePackageConfiguration config =
new GamePackageConfiguration(mPackageManager, packageName, userId);
if (config.isActive()) {
Slog.v(TAG, "Adding config: " + config.toString());
mConfigs.put(packageName, config);
} else {
Slog.v(TAG, "Inactive package config for "
+ config.getPackageName() + ":" + config.toString());
mConfigs.remove(packageName);
}
}
}
synchronized (mLock) {
if (!mSettings.containsKey(userId)) {
return;
}
}
for (final String packageName : packageNames) {
int gameMode = getGameMode(packageName, userId);
// Make sure the user settings and package configs don't conflict.
// I.e. the user setting is set to a mode that no longer available due to
// config/manifest changes.
// Most of the time we won't have to change anything.
GamePackageConfiguration config = null;
synchronized (mDeviceConfigLock) {
config = mConfigs.get(packageName);
}
final int newGameMode = getNewGameMode(gameMode, config);
if (newGameMode != gameMode) {
setGameMode(packageName, newGameMode, userId);
} else {
// Make sure we handle the case when the interventions are changed while
// the game mode remains the same. We call only updateInterventions() here.
updateInterventions(packageName, gameMode, userId);
}
}
sendUserMessage(userId, WRITE_GAME_MODE_INTERVENTION_LIST_FILE,
"UPDATE_CONFIGS_FOR_USERS", 0 /*delayMillis*/);
} catch (Exception e) {
Slog.e(TAG, "Failed to update configs for user " + userId + ": " + e);
}
}
/*
Write the interventions and mode of each game to file /system/data/game_mode_intervention.list
Each line will contain the information of each game, separated by tab.
The format of the output is:
For example:
com.android.app1 1425 1 2 angle=0,scaling=1.0,fps=60 3 angle=1,scaling=0.5,fps=30
*/
private void writeGameModeInterventionsToFile(@UserIdInt int userId) {
FileOutputStream fileOutputStream = null;
BufferedWriter bufferedWriter;
try {
fileOutputStream = mGameModeInterventionListFile.startWrite();
bufferedWriter = new BufferedWriter(new OutputStreamWriter(fileOutputStream,
Charset.defaultCharset()));
final StringBuilder sb = new StringBuilder();
final List installedGamesList = getInstalledGamePackageNamesByAllUsers(userId);
for (final String packageName : installedGamesList) {
GamePackageConfiguration packageConfig = getConfig(packageName, userId);
if (packageConfig == null) {
continue;
}
sb.append(packageName);
sb.append("\t");
sb.append(mPackageManager.getPackageUidAsUser(packageName, userId));
sb.append("\t");
sb.append(getGameMode(packageName, userId));
sb.append("\t");
final int[] modes = packageConfig.getAvailableGameModes();
for (int mode : modes) {
final GamePackageConfiguration.GameModeConfiguration gameModeConfiguration =
packageConfig.getGameModeConfiguration(mode);
if (gameModeConfiguration == null) {
continue;
}
sb.append(mode);
sb.append("\t");
final int useAngle = gameModeConfiguration.getUseAngle() ? 1 : 0;
sb.append(TextUtils.formatSimple("angle=%d", useAngle));
sb.append(",");
final float scaling = gameModeConfiguration.getScaling();
sb.append("scaling=");
sb.append(scaling);
sb.append(",");
final int fps = gameModeConfiguration.getFps();
sb.append(TextUtils.formatSimple("fps=%d", fps));
sb.append("\t");
}
sb.append("\n");
}
bufferedWriter.append(sb);
bufferedWriter.flush();
FileUtils.sync(fileOutputStream);
mGameModeInterventionListFile.finishWrite(fileOutputStream);
} catch (Exception e) {
mGameModeInterventionListFile.failWrite(fileOutputStream);
Slog.wtf(TAG, "Failed to write game_mode_intervention.list, exception " + e);
}
return;
}
private int[] getAllUserIds(@UserIdInt int currentUserId) {
final List users = mUserManager.getUsers();
int[] userIds = new int[users.size()];
for (int i = 0; i < userIds.length; ++i) {
userIds[i] = users.get(i).id;
}
if (currentUserId != -1) {
userIds = ArrayUtils.appendInt(userIds, currentUserId);
}
return userIds;
}
private String[] getInstalledGamePackageNames(@UserIdInt int userId) {
final List packages =
mPackageManager.getInstalledPackagesAsUser(0, userId);
return packages.stream().filter(e -> e.applicationInfo != null && e.applicationInfo.category
== ApplicationInfo.CATEGORY_GAME)
.map(e -> e.packageName)
.toArray(String[]::new);
}
private List getInstalledGamePackageNamesByAllUsers(@UserIdInt int currentUserId) {
HashSet packageSet = new HashSet<>();
final int[] userIds = getAllUserIds(currentUserId);
for (int userId : userIds) {
packageSet.addAll(Arrays.asList(getInstalledGamePackageNames(userId)));
}
return new ArrayList<>(packageSet);
}
/**
* @hide
*/
public GamePackageConfiguration getConfig(String packageName, int userId) {
GamePackageConfiguration overrideConfig = null;
GamePackageConfiguration config;
synchronized (mDeviceConfigLock) {
config = mConfigs.get(packageName);
}
synchronized (mLock) {
if (mSettings.containsKey(userId)) {
overrideConfig = mSettings.get(userId).getConfigOverrideLocked(packageName);
}
}
if (overrideConfig == null || config == null) {
return overrideConfig == null ? config : overrideConfig;
}
return config.copyAndApplyOverride(overrideConfig);
}
private void registerPackageReceiver() {
final IntentFilter packageFilter = new IntentFilter();
packageFilter.addAction(ACTION_PACKAGE_ADDED);
packageFilter.addAction(ACTION_PACKAGE_REMOVED);
packageFilter.addDataScheme("package");
final BroadcastReceiver packageReceiver = new BroadcastReceiver() {
@Override
public void onReceive(@NonNull final Context context, @NonNull final Intent intent) {
final Uri data = intent.getData();
try {
final int userId = getSendingUserId();
if (userId != ActivityManager.getCurrentUser()) {
return;
}
final String packageName = data.getSchemeSpecificPart();
try {
final ApplicationInfo applicationInfo = mPackageManager
.getApplicationInfoAsUser(
packageName, PackageManager.MATCH_ALL, userId);
if (applicationInfo.category != ApplicationInfo.CATEGORY_GAME) {
return;
}
} catch (NameNotFoundException e) {
// Ignore the exception.
}
switch (intent.getAction()) {
case ACTION_PACKAGE_ADDED:
updateConfigsForUser(userId, true /*checkGamePackage*/, packageName);
break;
case ACTION_PACKAGE_REMOVED:
if (!intent.getBooleanExtra(EXTRA_REPLACING, false)) {
synchronized (mDeviceConfigLock) {
mConfigs.remove(packageName);
}
synchronized (mLock) {
if (mSettings.containsKey(userId)) {
mSettings.get(userId).removeGameLocked(packageName);
}
sendUserMessage(userId, WRITE_SETTINGS,
Intent.ACTION_PACKAGE_REMOVED, WRITE_DELAY_MILLIS);
sendUserMessage(userId,
WRITE_GAME_MODE_INTERVENTION_LIST_FILE,
Intent.ACTION_PACKAGE_REMOVED, WRITE_DELAY_MILLIS);
}
}
break;
default:
// do nothing
break;
}
} catch (NullPointerException e) {
Slog.e(TAG, "Failed to get package name for new package");
}
}
};
mContext.registerReceiverForAllUsers(packageReceiver, packageFilter,
/* broadcastPermission= */ null, /* scheduler= */ null);
}
private void registerDeviceConfigListener() {
mDeviceConfigListener = new DeviceConfigListener();
}
private void publishLocalService() {
LocalService localService = new LocalService();
ActivityTaskManagerInternal atmi =
LocalServices.getService(ActivityTaskManagerInternal.class);
atmi.registerCompatScaleProvider(COMPAT_SCALE_MODE_GAME, localService);
LocalServices.addService(GameManagerInternal.class, localService);
}
private void registerStatsCallbacks() {
final StatsManager statsManager = mContext.getSystemService(StatsManager.class);
statsManager.setPullAtomCallback(
FrameworkStatsLog.GAME_MODE_INFO,
null, // use default PullAtomMetadata values
DIRECT_EXECUTOR,
this::onPullAtom);
statsManager.setPullAtomCallback(
FrameworkStatsLog.GAME_MODE_CONFIGURATION,
null, // use default PullAtomMetadata values
DIRECT_EXECUTOR,
this::onPullAtom);
statsManager.setPullAtomCallback(
FrameworkStatsLog.GAME_MODE_LISTENER,
null, // use default PullAtomMetadata values
DIRECT_EXECUTOR,
this::onPullAtom);
}
private int onPullAtom(int atomTag, @NonNull List data) {
if (atomTag == FrameworkStatsLog.GAME_MODE_INFO
|| atomTag == FrameworkStatsLog.GAME_MODE_CONFIGURATION) {
int userId = ActivityManager.getCurrentUser();
Set packages;
synchronized (mDeviceConfigLock) {
packages = mConfigs.keySet();
}
for (String p : packages) {
GamePackageConfiguration config = getConfig(p, userId);
if (config == null) {
continue;
}
int uid = -1;
try {
uid = mPackageManager.getPackageUidAsUser(p, userId);
} catch (NameNotFoundException ex) {
Slog.d(TAG,
"Cannot find UID for package " + p + " under user handle id " + userId);
}
if (atomTag == FrameworkStatsLog.GAME_MODE_INFO) {
data.add(
FrameworkStatsLog.buildStatsEvent(FrameworkStatsLog.GAME_MODE_INFO, uid,
gameModesToStatsdGameModes(config.getOverriddenGameModes()),
gameModesToStatsdGameModes(config.getAvailableGameModes())));
} else if (atomTag == FrameworkStatsLog.GAME_MODE_CONFIGURATION) {
for (int gameMode : config.getAvailableGameModes()) {
GamePackageConfiguration.GameModeConfiguration modeConfig =
config.getGameModeConfiguration(gameMode);
if (modeConfig != null) {
data.add(FrameworkStatsLog.buildStatsEvent(
FrameworkStatsLog.GAME_MODE_CONFIGURATION, uid,
gameModeToStatsdGameMode(gameMode), modeConfig.getFps(),
modeConfig.getScaling()));
}
}
}
}
} else if (atomTag == FrameworkStatsLog.GAME_MODE_LISTENER) {
synchronized (mGameModeListenerLock) {
data.add(FrameworkStatsLog.buildStatsEvent(FrameworkStatsLog.GAME_MODE_LISTENER,
mGameModeListeners.size()));
}
}
return android.app.StatsManager.PULL_SUCCESS;
}
private static int[] gameModesToStatsdGameModes(int[] modes) {
if (modes == null) {
return null;
}
int[] statsdModes = new int[modes.length];
int i = 0;
for (int mode : modes) {
statsdModes[i++] = gameModeToStatsdGameMode(mode);
}
return statsdModes;
}
private static int gameModeToStatsdGameMode(int mode) {
switch (mode) {
case GameManager.GAME_MODE_BATTERY:
return FrameworkStatsLog.GAME_MODE_CONFIGURATION__GAME_MODE__GAME_MODE_BATTERY;
case GameManager.GAME_MODE_PERFORMANCE:
return FrameworkStatsLog.GAME_MODE_CONFIGURATION__GAME_MODE__GAME_MODE_PERFORMANCE;
case GameManager.GAME_MODE_CUSTOM:
return FrameworkStatsLog.GAME_MODE_CONFIGURATION__GAME_MODE__GAME_MODE_CUSTOM;
case GameManager.GAME_MODE_STANDARD:
return FrameworkStatsLog.GAME_MODE_CONFIGURATION__GAME_MODE__GAME_MODE_STANDARD;
case GameManager.GAME_MODE_UNSUPPORTED:
return FrameworkStatsLog.GAME_MODE_CONFIGURATION__GAME_MODE__GAME_MODE_UNSUPPORTED;
default:
return FrameworkStatsLog.GAME_MODE_CONFIGURATION__GAME_MODE__GAME_MODE_UNSPECIFIED;
}
}
private static int gameStateModeToStatsdGameState(int mode) {
switch (mode) {
case GameState.MODE_NONE:
return FrameworkStatsLog.GAME_STATE_CHANGED__STATE__MODE_NONE;
case GameState.MODE_GAMEPLAY_INTERRUPTIBLE:
return FrameworkStatsLog.GAME_STATE_CHANGED__STATE__MODE_GAMEPLAY_INTERRUPTIBLE;
case GameState.MODE_GAMEPLAY_UNINTERRUPTIBLE:
return FrameworkStatsLog.GAME_STATE_CHANGED__STATE__MODE_GAMEPLAY_UNINTERRUPTIBLE;
case GameState.MODE_CONTENT:
return FrameworkStatsLog.GAME_STATE_CHANGED__STATE__MODE_CONTENT;
case GameState.MODE_UNKNOWN:
default:
return FrameworkStatsLog.GAME_STATE_CHANGED__STATE__MODE_UNKNOWN;
}
}
private static ServiceThread createServiceThread() {
ServiceThread handlerThread = new ServiceThread(TAG,
Process.THREAD_PRIORITY_BACKGROUND, true /*allowIo*/);
handlerThread.start();
return handlerThread;
}
@VisibleForTesting
void setGameModeFrameRateOverride(int uid, float frameRate) {
nativeSetGameModeFrameRateOverride(uid, frameRate);
}
@VisibleForTesting
void setGameDefaultFrameRateOverride(int uid, float frameRate) {
Slog.v(TAG, "setDefaultFrameRateOverride : " + uid + " , " + frameRate);
nativeSetGameDefaultFrameRateOverride(uid, frameRate);
}
private float getGameDefaultFrameRate(boolean isEnabled) {
float gameDefaultFrameRate = 0.0f;
if (gameDefaultFrameRate()) {
gameDefaultFrameRate = isEnabled ? mGameDefaultFrameRateValue : 0.0f;
}
return gameDefaultFrameRate;
}
@Override
@EnforcePermission(Manifest.permission.MANAGE_GAME_MODE)
public void toggleGameDefaultFrameRate(boolean isEnabled) {
toggleGameDefaultFrameRate_enforcePermission();
if (gameDefaultFrameRate()) {
Slog.v(TAG, "toggleGameDefaultFrameRate : " + isEnabled);
this.toggleGameDefaultFrameRateUnchecked(isEnabled);
}
}
private void toggleGameDefaultFrameRateUnchecked(boolean isEnabled) {
// Here we only need to immediately update games that are in the foreground.
// We will update game default frame rate when a game comes into foreground in
// MyUidObserver.
synchronized (mLock) {
if (isEnabled) {
mSysProps.set(
PROPERTY_DEBUG_GFX_GAME_DEFAULT_FRAME_RATE_DISABLED, "false");
} else {
mSysProps.set(
PROPERTY_DEBUG_GFX_GAME_DEFAULT_FRAME_RATE_DISABLED, "true");
}
}
// Update all foreground games' frame rate.
synchronized (mUidObserverLock) {
for (int uid : mGameForegroundUids) {
setGameDefaultFrameRateOverride(uid, getGameDefaultFrameRate(isEnabled));
}
}
}
/**
* load dynamic library for frame rate overriding JNI calls
*/
private static native void nativeSetGameModeFrameRateOverride(int uid, float frameRate);
private static native void nativeSetGameDefaultFrameRateOverride(int uid, float frameRate);
final class MyUidObserver extends UidObserver {
@Override
public void onUidGone(int uid, boolean disabled) {
synchronized (mUidObserverLock) {
handleUidMovedOffTop(uid);
}
}
@Override
public void onUidStateChanged(int uid, int procState, long procStateSeq, int capability) {
switch (procState) {
case ActivityManager.PROCESS_STATE_TOP:
handleUidMovedToTop(uid);
return;
default:
handleUidMovedOffTop(uid);
}
}
private void handleUidMovedToTop(int uid) {
final String[] packages = mPackageManager.getPackagesForUid(uid);
if (packages == null || packages.length == 0) {
return;
}
final int userId = ActivityManager.getCurrentUser();
final boolean isNotGame = Arrays.stream(packages).noneMatch(
p -> isPackageGame(p, userId));
synchronized (mUidObserverLock) {
if (isNotGame) {
if (!mGameForegroundUids.isEmpty() && mNonGameForegroundUids.isEmpty()) {
Slog.v(TAG, "Game power mode OFF (first non-game in foreground)");
mPowerManagerInternal.setPowerMode(Mode.GAME, false);
}
mNonGameForegroundUids.add(uid);
return;
}
if (mGameForegroundUids.isEmpty() && mNonGameForegroundUids.isEmpty()) {
Slog.v(TAG, "Game power mode ON (first game in foreground)");
mPowerManagerInternal.setPowerMode(Mode.GAME, true);
}
final boolean isGameDefaultFrameRateDisabled =
mSysProps.getBoolean(
PROPERTY_DEBUG_GFX_GAME_DEFAULT_FRAME_RATE_DISABLED, false);
setGameDefaultFrameRateOverride(uid,
getGameDefaultFrameRate(!isGameDefaultFrameRateDisabled));
mGameForegroundUids.add(uid);
}
}
private void handleUidMovedOffTop(int uid) {
synchronized (mUidObserverLock) {
if (mGameForegroundUids.contains(uid)) {
mGameForegroundUids.remove(uid);
if (mGameForegroundUids.isEmpty() && mNonGameForegroundUids.isEmpty()) {
Slog.v(TAG, "Game power mode OFF (no games in foreground)");
mPowerManagerInternal.setPowerMode(Mode.GAME, false);
}
} else if (mNonGameForegroundUids.contains(uid)) {
mNonGameForegroundUids.remove(uid);
if (mNonGameForegroundUids.isEmpty() && !mGameForegroundUids.isEmpty()) {
Slog.v(TAG, "Game power mode ON (only games in foreground)");
mPowerManagerInternal.setPowerMode(Mode.GAME, true);
}
}
}
}
}
}