Merge "Remove the tentative FGS logic" into udc-dev am: 79d9f58d95 (a7653f3a) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/am/ActiveServices.java

+7 −189

Original line number	Original line	Diff line number	Diff line
	@@ -2156,7 +2156,6 @@ public final class ActiveServices {
	}		}
	}		}

	final boolean enableFgsWhileInUseFix = mAm.mConstants.mEnableFgsWhileInUseFix;
	final boolean fgsTypeChangingFromShortFgs = r.isForeground && isOldTypeShortFgs;		final boolean fgsTypeChangingFromShortFgs = r.isForeground && isOldTypeShortFgs;

	if (fgsTypeChangingFromShortFgs) {		if (fgsTypeChangingFromShortFgs) {
	@@ -2214,19 +2213,7 @@ public final class ActiveServices {
	}		}
	}		}

	boolean resetNeededForLogging = false;		if (!fgsTypeChangingFromShortFgs && r.mStartForegroundCount == 0) {

	// Re-evaluate mAllowWhileInUsePermissionInFgs and mAllowStartForeground
	// (i.e. while-in-use and BFSL flags) if needed.
	//
	// Consider the below if-else section to be in the else of the above
	// `if (fgsTypeChangingFromShortFgs)`.
	// Using an else would increase the indent further, so we don't use it here
	// and instead just add !fgsTypeChangingFromShortFgs to all if's.
	//
	// The first if's are for the original while-in-use logic.
	if (!fgsTypeChangingFromShortFgs && !enableFgsWhileInUseFix
	&& r.mStartForegroundCount == 0) {
	/*		/*
	If the service was started with startService(), not		If the service was started with startService(), not
	startForegroundService(), and if startForeground() isn't called within		startForegroundService(), and if startForeground() isn't called within
	@@ -2257,8 +2244,7 @@ public final class ActiveServices {
	r.mLoggedInfoAllowStartForeground = false;		r.mLoggedInfoAllowStartForeground = false;
	}		}
	}		}
	} else if (!fgsTypeChangingFromShortFgs && !enableFgsWhileInUseFix		} else if (!fgsTypeChangingFromShortFgs && r.mStartForegroundCount >= 1) {
	&& r.mStartForegroundCount >= 1) {
	// We get here if startForeground() is called multiple times		// We get here if startForeground() is called multiple times
	// on the same service after it's created, regardless of whether		// on the same service after it's created, regardless of whether
	// stopForeground() has been called or not.		// stopForeground() has been called or not.
	@@ -2269,100 +2255,6 @@ public final class ActiveServices {
	r.appInfo.uid, r.intent.getIntent(), r, r.userId,		r.appInfo.uid, r.intent.getIntent(), r, r.userId,
	BackgroundStartPrivileges.NONE,		BackgroundStartPrivileges.NONE,
	false /* isBindService /, false / isStartService */);		false /* isBindService /, false / isStartService */);
	} else if (!fgsTypeChangingFromShortFgs && enableFgsWhileInUseFix) {
	// The new while-in-use logic.
	//
	// When startForeground() is called, we _always_ call
	// setFgsRestrictionLocked() to set the restrictions according to the
	// current state of the app.
	// (So if the app is now in TOP, for example, the service will now always
	// get while-in-use permissions.)
	//
	// Note, setFgsRestrictionLocked() will never disallow
	// mAllowWhileInUsePermissionInFgs nor mAllowStartForeground
	// (i.e. while-in-use and BFSL flags) once they're set to "allowed".
	//
	// HOWEVER, if these flags were set to "allowed" in Context.startService()
	// (as opposed to startForegroundService()), when the service wasn't yet
	// a foreground service, then we may not always
	// want to trust them -- for example, if the service has been running as a
	// BG service or a bound service for a long time when the app is not longer
	// in the foreground, then we shouldn't grant while-in-user nor BFSL.
	// So in that case, we need to reset it first.

	final long delayMs =
	(r.mLastUntrustedSetFgsRestrictionAllowedTime == 0) ? 0
	: (SystemClock.elapsedRealtime()
	- r.mLastUntrustedSetFgsRestrictionAllowedTime);
	final boolean resetNeeded =
	!r.isForeground
	&& delayMs > mAm.mConstants.mFgsStartForegroundTimeoutMs;
	if (resetNeeded) {
	// We don't want to reset mDebugWhileInUseReasonInBindService here --
	// we'll instead reset it in the following code, using the simulated
	// legacy logic.
	resetFgsRestrictionLocked(r,
	/resetDebugWhileInUseReasonInBindService=/ false);
	}

	// Simulate the reset flow in the legacy logic to reset
	// mDebugWhileInUseReasonInBindService.
	// (Which is only used to compare to the old logic.)
	final long legacyDelayMs = SystemClock.elapsedRealtime() - r.createRealTime;
	if ((r.mStartForegroundCount == 0)
	&& (legacyDelayMs > mAm.mConstants.mFgsStartForegroundTimeoutMs)) {
	r.mDebugWhileInUseReasonInBindService = REASON_DENIED;
	}

	setFgsRestrictionLocked(r.serviceInfo.packageName, r.app.getPid(),
	r.appInfo.uid, r.intent.getIntent(), r, r.userId,
	BackgroundStartPrivileges.NONE,
	false /* isBindService /, false / isStartService */);

	final String temp = "startForegroundDelayMs:" + delayMs
	+ "; started: " + r.startRequested
	+ "; num_bindings: " + r.getConnections().size()
	+ "; wasForeground: " + r.isForeground
	+ "; resetNeeded:" + resetNeeded;
	if (r.mInfoAllowStartForeground != null) {
	r.mInfoAllowStartForeground += "; " + temp;
	} else {
	r.mInfoAllowStartForeground = temp;
	}
	r.mLoggedInfoAllowStartForeground = false;

	resetNeededForLogging = resetNeeded;
	}

	// If the service has any bindings and it's not yet a FGS
	// we compare the new and old while-in-use logics.
	// (If it's not the first startForeground() call, we already reset the
	// while-in-use and BFSL flags, so the logic change wouldn't matter.)
	//
	// Note, mDebugWhileInUseReasonInBindService does not fully simulate the
	// legacy logic, because we'll only set it in bindService(), but the actual
	// mAllowWhileInUsePermissionInFgsReason can change afterwards, in a subsequent
	// Service.startForeground(). This check will only provide "rough" check.
	// But if mDebugWhileInUseReasonInBindService is _not_ DENIED, and
	// mDebugWhileInUseReasonInStartForeground _is_ DENIED, then that means we'd
	// now detected a behavior change.
	// OTOH, if it's changing from non-DENIED to another non-DENIED, that may
	// not be a problem.
	if (enableFgsWhileInUseFix
	&& !r.isForeground
	&& (r.getConnections().size() > 0)
	&& (r.mDebugWhileInUseReasonInBindService
	!= r.mDebugWhileInUseReasonInStartForeground)) {
	logWhileInUseChangeWtf("FGS while-in-use changed (b/276963716): old="
	+ reasonCodeToString(r.mDebugWhileInUseReasonInBindService)
	+ " new="
	+ reasonCodeToString(r.mDebugWhileInUseReasonInStartForeground)
	+ " startForegroundCount=" + r.mStartForegroundCount
	+ " started=" + r.startRequested
	+ " num_bindings=" + r.getConnections().size()
	+ " resetNeeded=" + resetNeededForLogging
	+ " "
	+ r.shortInstanceName);
	}		}

	// If the foreground service is not started from TOP process, do not allow it to		// If the foreground service is not started from TOP process, do not allow it to
	@@ -2471,10 +2363,6 @@ public final class ActiveServices {
	}		}
	r.isForeground = true;		r.isForeground = true;

	// Once the service becomes a foreground service,
	// the FGS restriction information always becomes "trustable".
	r.mLastUntrustedSetFgsRestrictionAllowedTime = 0;

	// The logging of FOREGROUND_SERVICE_STATE_CHANGED__STATE__ENTER event could		// The logging of FOREGROUND_SERVICE_STATE_CHANGED__STATE__ENTER event could
	// be deferred, make a copy of mAllowStartForeground and		// be deferred, make a copy of mAllowStartForeground and
	// mAllowWhileInUsePermissionInFgs.		// mAllowWhileInUsePermissionInFgs.
	@@ -2620,13 +2508,6 @@ public final class ActiveServices {
	}		}
	}		}

	/**
	* It just does a wtf, but extracted to a method, so we can do a signature search on pitot.
	*/
	private void logWhileInUseChangeWtf(String message) {
	Slog.wtf(TAG, message);
	}

	private boolean withinFgsDeferRateLimit(ServiceRecord sr, final long now) {		private boolean withinFgsDeferRateLimit(ServiceRecord sr, final long now) {
	// If we're still within the service's deferral period, then by definition		// If we're still within the service's deferral period, then by definition
	// deferral is not rate limited.		// deferral is not rate limited.
	@@ -3839,25 +3720,9 @@ public final class ActiveServices {
	return 0;		return 0;
	}		}
	}		}
	if (!mAm.mConstants.mEnableFgsWhileInUseFix) {
	// Old while-in-use logic.
	setFgsRestrictionLocked(callingPackage, callingPid, callingUid, service, s, userId,		setFgsRestrictionLocked(callingPackage, callingPid, callingUid, service, s, userId,
	BackgroundStartPrivileges.NONE, true /* isBindService */,		BackgroundStartPrivileges.NONE, true /* isBindService */,
	false /* isStartService */);		false /* isStartService */);
	} else {
	// New logic will not call setFgsRestrictionLocked() here, but we still
	// keep track of the allow reason from the old logic here, so we can compare to
	// the new logic.
	// Once we're confident enough in the new logic, we should remove it.
	if (s.mDebugWhileInUseReasonInBindService == REASON_DENIED) {
	s.mDebugWhileInUseReasonInBindService =
	shouldAllowFgsWhileInUsePermissionLocked(
	callingPackage, callingPid, callingUid, s.app,
	BackgroundStartPrivileges.NONE,
	true /* isBindService */,
	false /* DO NOT enableFgsWhileInUseFix; use the old logic */);
	}
	}

	if (s.app != null) {		if (s.app != null) {
	ProcessServiceRecord servicePsr = s.app.mServices;		ProcessServiceRecord servicePsr = s.app.mServices;
	@@ -7554,15 +7419,13 @@ public final class ActiveServices {
	* @param r the service to start.		* @param r the service to start.
	* @param isStartService True if it's called from Context.startService().		* @param isStartService True if it's called from Context.startService().
	* False if it's called from Context.startForegroundService() or		* False if it's called from Context.startForegroundService() or
	* Service.startService().		* Service.startForeground().
	* @return true if allow, false otherwise.		* @return true if allow, false otherwise.
	*/		*/
	private void setFgsRestrictionLocked(String callingPackage,		private void setFgsRestrictionLocked(String callingPackage,
	int callingPid, int callingUid, Intent intent, ServiceRecord r, int userId,		int callingPid, int callingUid, Intent intent, ServiceRecord r, int userId,
	BackgroundStartPrivileges backgroundStartPrivileges, boolean isBindService,		BackgroundStartPrivileges backgroundStartPrivileges, boolean isBindService,
	boolean isStartService) {		boolean isStartService) {
	final long now = SystemClock.elapsedRealtime();

	// Check DeviceConfig flag.		// Check DeviceConfig flag.
	if (!mAm.mConstants.mFlagBackgroundFgsStartRestrictionEnabled) {		if (!mAm.mConstants.mFlagBackgroundFgsStartRestrictionEnabled) {
	r.mAllowWhileInUsePermissionInFgs = true;		r.mAllowWhileInUsePermissionInFgs = true;
	@@ -7580,60 +7443,30 @@ public final class ActiveServices {
	isBindService);		isBindService);
	// We store them to compare the old and new while-in-use logics to each other.		// We store them to compare the old and new while-in-use logics to each other.
	// (They're not used for any other purposes.)		// (They're not used for any other purposes.)
	if (isBindService) {
	r.mDebugWhileInUseReasonInBindService = allowWhileInUse;
	} else {
	r.mDebugWhileInUseReasonInStartForeground = allowWhileInUse;
	}
	if (!r.mAllowWhileInUsePermissionInFgs) {		if (!r.mAllowWhileInUsePermissionInFgs) {
	r.mAllowWhileInUsePermissionInFgs = (allowWhileInUse != REASON_DENIED);		r.mAllowWhileInUsePermissionInFgs = (allowWhileInUse != REASON_DENIED);
	newlyAllowed \|= r.mAllowWhileInUsePermissionInFgs;
	}		}
	if (r.mAllowStartForeground == REASON_DENIED) {		if (r.mAllowStartForeground == REASON_DENIED) {
	r.mAllowStartForeground = shouldAllowFgsStartForegroundWithBindingCheckLocked(		r.mAllowStartForeground = shouldAllowFgsStartForegroundWithBindingCheckLocked(
	allowWhileInUse, callingPackage, callingPid, callingUid, intent, r,		allowWhileInUse, callingPackage, callingPid, callingUid, intent, r,
	backgroundStartPrivileges, isBindService);		backgroundStartPrivileges, isBindService);
	newlyAllowed \|= r.mAllowStartForeground != REASON_DENIED;
	}		}
	} else {		} else {
	allowWhileInUse = REASON_UNKNOWN;		allowWhileInUse = REASON_UNKNOWN;
	}		}
	r.mAllowWhileInUsePermissionInFgsReason = allowWhileInUse;		r.mAllowWhileInUsePermissionInFgsReason = allowWhileInUse;

	if (isStartService && !r.isForeground && newlyAllowed) {
	// If it's called by Context.startService() (not by startForegroundService()),
	// and we're setting "allowed", then we can't fully trust it yet -- we'll need to reset
	// the restrictions if startForeground() is called after the grace period.
	r.mLastUntrustedSetFgsRestrictionAllowedTime = now;
	}
	}		}

	/**		/**
	* Reset various while-in-use and BFSL related information.		* Reset various while-in-use and BFSL related information.
	*/		*/
	void resetFgsRestrictionLocked(ServiceRecord r) {		void resetFgsRestrictionLocked(ServiceRecord r) {
	resetFgsRestrictionLocked(r, /resetDebugWhileInUseReasonInBindService=/ true);
	}

	/**
	* Reset various while-in-use and BFSL related information.
	*/
	void resetFgsRestrictionLocked(ServiceRecord r,
	boolean resetDebugWhileInUseReasonInBindService) {
	r.mAllowWhileInUsePermissionInFgs = false;		r.mAllowWhileInUsePermissionInFgs = false;
	r.mAllowWhileInUsePermissionInFgsReason = REASON_DENIED;		r.mAllowWhileInUsePermissionInFgsReason = REASON_DENIED;
	r.mDebugWhileInUseReasonInStartForeground = REASON_DENIED;

	// In Service.startForeground(), we reset this field using a legacy logic,
	// so resetting this field is optional.
	if (resetDebugWhileInUseReasonInBindService) {
	r.mDebugWhileInUseReasonInBindService = REASON_DENIED;
	}
	r.mAllowStartForeground = REASON_DENIED;		r.mAllowStartForeground = REASON_DENIED;
	r.mInfoAllowStartForeground = null;		r.mInfoAllowStartForeground = null;
	r.mInfoTempFgsAllowListReason = null;		r.mInfoTempFgsAllowListReason = null;
	r.mLoggedInfoAllowStartForeground = false;		r.mLoggedInfoAllowStartForeground = false;
	r.mLastUntrustedSetFgsRestrictionAllowedTime = 0;
	r.updateAllowUiJobScheduling(r.mAllowWhileInUsePermissionInFgs);		r.updateAllowUiJobScheduling(r.mAllowWhileInUsePermissionInFgs);
	}		}

	@@ -7668,22 +7501,11 @@ public final class ActiveServices {
	private @ReasonCode int shouldAllowFgsWhileInUsePermissionLocked(String callingPackage,		private @ReasonCode int shouldAllowFgsWhileInUsePermissionLocked(String callingPackage,
	int callingPid, int callingUid, @Nullable ProcessRecord targetProcess,		int callingPid, int callingUid, @Nullable ProcessRecord targetProcess,
	BackgroundStartPrivileges backgroundStartPrivileges, boolean isBindService) {		BackgroundStartPrivileges backgroundStartPrivileges, boolean isBindService) {
	return shouldAllowFgsWhileInUsePermissionLocked(callingPackage,
	callingPid, callingUid, targetProcess, backgroundStartPrivileges, isBindService,
	/* enableFgsWhileInUseFix =*/ mAm.mConstants.mEnableFgsWhileInUseFix);
	}

	private @ReasonCode int shouldAllowFgsWhileInUsePermissionLocked(String callingPackage,
	int callingPid, int callingUid, @Nullable ProcessRecord targetProcess,
	BackgroundStartPrivileges backgroundStartPrivileges, boolean isBindService,
	boolean enableFgsWhileInUseFix) {
	int ret = REASON_DENIED;		int ret = REASON_DENIED;

	// Define some local variables for better readability...
	final boolean useOldLogic = !enableFgsWhileInUseFix;
	final boolean forStartForeground = !isBindService;		final boolean forStartForeground = !isBindService;

	if (useOldLogic \|\| forStartForeground) {		if (forStartForeground) {
	final int uidState = mAm.getUidStateLocked(callingUid);		final int uidState = mAm.getUidStateLocked(callingUid);
	if (ret == REASON_DENIED) {		if (ret == REASON_DENIED) {
	// Allow FGS while-in-use if the caller's process state is PROCESS_STATE_PERSISTENT,		// Allow FGS while-in-use if the caller's process state is PROCESS_STATE_PERSISTENT,
	@@ -7733,10 +7555,6 @@ public final class ActiveServices {
	}		}
	}		}

	if (enableFgsWhileInUseFix && ret == REASON_DENIED) {
	ret = shouldAllowFgsWhileInUsePermissionByBindingsLocked(callingUid);
	}

	if (ret == REASON_DENIED) {		if (ret == REASON_DENIED) {
	// Allow FGS while-in-use if the WindowManager allows background activity start.		// Allow FGS while-in-use if the WindowManager allows background activity start.
	// This is mainly to get the 10 seconds grace period if any activity in the caller has		// This is mainly to get the 10 seconds grace period if any activity in the caller has

services/core/java/com/android/server/am/ActivityManagerConstants.java

+0 −19

Original line number	Original line	Diff line number	Diff line
	@@ -1058,13 +1058,6 @@ final class ActivityManagerConstants extends ContentObserver {
	/** @see #KEY_USE_MODERN_TRIM */		/** @see #KEY_USE_MODERN_TRIM */
	public boolean USE_MODERN_TRIM = DEFAULT_USE_MODERN_TRIM;		public boolean USE_MODERN_TRIM = DEFAULT_USE_MODERN_TRIM;

	private static final String KEY_ENABLE_FGS_WHILE_IN_USE_FIX =
	"key_enable_fgs_while_in_use_fix";

	private static final boolean DEFAULT_ENABLE_FGS_WHILE_IN_USE_FIX = false;

	public volatile boolean mEnableFgsWhileInUseFix = DEFAULT_ENABLE_FGS_WHILE_IN_USE_FIX;

	private final OnPropertiesChangedListener mOnDeviceConfigChangedListener =		private final OnPropertiesChangedListener mOnDeviceConfigChangedListener =
	new OnPropertiesChangedListener() {		new OnPropertiesChangedListener() {
	@Override		@Override
	@@ -1233,9 +1226,6 @@ final class ActivityManagerConstants extends ContentObserver {
	case KEY_ENABLE_WAIT_FOR_FINISH_ATTACH_APPLICATION:		case KEY_ENABLE_WAIT_FOR_FINISH_ATTACH_APPLICATION:
	updateEnableWaitForFinishAttachApplication();		updateEnableWaitForFinishAttachApplication();
	break;		break;
	case KEY_ENABLE_FGS_WHILE_IN_USE_FIX:
	updateEnableFgsWhileInUseFix();
	break;
	case KEY_MAX_PREVIOUS_TIME:		case KEY_MAX_PREVIOUS_TIME:
	updateMaxPreviousTime();		updateMaxPreviousTime();
	break;		break;
	@@ -2005,12 +1995,6 @@ final class ActivityManagerConstants extends ContentObserver {
	DEFAULT_ENABLE_WAIT_FOR_FINISH_ATTACH_APPLICATION);		DEFAULT_ENABLE_WAIT_FOR_FINISH_ATTACH_APPLICATION);
	}		}

	private void updateEnableFgsWhileInUseFix() {
	mEnableFgsWhileInUseFix = DeviceConfig.getBoolean(
	DeviceConfig.NAMESPACE_ACTIVITY_MANAGER,
	KEY_ENABLE_FGS_WHILE_IN_USE_FIX,
	DEFAULT_ENABLE_FGS_WHILE_IN_USE_FIX);
	}
	private void updateUseTieredCachedAdj() {		private void updateUseTieredCachedAdj() {
	USE_TIERED_CACHED_ADJ = DeviceConfig.getBoolean(		USE_TIERED_CACHED_ADJ = DeviceConfig.getBoolean(
	DeviceConfig.NAMESPACE_ACTIVITY_MANAGER,		DeviceConfig.NAMESPACE_ACTIVITY_MANAGER,
	@@ -2211,9 +2195,6 @@ final class ActivityManagerConstants extends ContentObserver {
	pw.print(" "); pw.print(KEY_SYSTEM_EXEMPT_POWER_RESTRICTIONS_ENABLED);		pw.print(" "); pw.print(KEY_SYSTEM_EXEMPT_POWER_RESTRICTIONS_ENABLED);
	pw.print("="); pw.println(mFlagSystemExemptPowerRestrictionsEnabled);		pw.print("="); pw.println(mFlagSystemExemptPowerRestrictionsEnabled);

	pw.print(" "); pw.print(KEY_ENABLE_FGS_WHILE_IN_USE_FIX);
	pw.print("="); pw.println(mEnableFgsWhileInUseFix);

	pw.print(" "); pw.print(KEY_SHORT_FGS_TIMEOUT_DURATION);		pw.print(" "); pw.print(KEY_SHORT_FGS_TIMEOUT_DURATION);
	pw.print("="); pw.println(mShortFgsTimeoutDuration);		pw.print("="); pw.println(mShortFgsTimeoutDuration);
	pw.print(" "); pw.print(KEY_SHORT_FGS_PROC_STATE_EXTRA_WAIT_DURATION);		pw.print(" "); pw.print(KEY_SHORT_FGS_PROC_STATE_EXTRA_WAIT_DURATION);

services/core/java/com/android/server/am/ServiceRecord.java

+0 −23

Original line number	Original line	Diff line number	Diff line
	@@ -177,12 +177,6 @@ final class ServiceRecord extends Binder implements ComponentName.WithComponentN
	@PowerExemptionManager.ReasonCode		@PowerExemptionManager.ReasonCode
	int mAllowWhileInUsePermissionInFgsReason = REASON_DENIED;		int mAllowWhileInUsePermissionInFgsReason = REASON_DENIED;

	// Integer version of mAllowWhileInUsePermissionInFgs that we keep track to compare
	// the old and new logics.
	// TODO: Remove them once we're confident in the new logic.
	int mDebugWhileInUseReasonInStartForeground = REASON_DENIED;
	int mDebugWhileInUseReasonInBindService = REASON_DENIED;

	// A copy of mAllowWhileInUsePermissionInFgs's value when the service is entering FGS state.		// A copy of mAllowWhileInUsePermissionInFgs's value when the service is entering FGS state.
	boolean mAllowWhileInUsePermissionInFgsAtEntering;		boolean mAllowWhileInUsePermissionInFgsAtEntering;
	/** Allow scheduling user-initiated jobs from the background. */		/** Allow scheduling user-initiated jobs from the background. */
	@@ -224,13 +218,6 @@ final class ServiceRecord extends Binder implements ComponentName.WithComponentN
	// is called.		// is called.
	int mStartForegroundCount;		int mStartForegroundCount;

	// Last time mAllowWhileInUsePermissionInFgs or mAllowStartForeground was set to "allowed"
	// from "disallowed" when the service was _not_ already a foreground service.
	// this means they're set in startService(). (not startForegroundService)
	// In startForeground(), if this timestamp is too old, we can't trust these flags, so
	// we need to reset them.
	long mLastUntrustedSetFgsRestrictionAllowedTime;

	// This is a service record of a FGS delegate (not a service record of a real service)		// This is a service record of a FGS delegate (not a service record of a real service)
	boolean mIsFgsDelegate;		boolean mIsFgsDelegate;
	@Nullable ForegroundServiceDelegation mFgsDelegation;		@Nullable ForegroundServiceDelegation mFgsDelegation;
	@@ -624,12 +611,6 @@ final class ServiceRecord extends Binder implements ComponentName.WithComponentN
	pw.print(prefix); pw.print("mAllowWhileInUsePermissionInFgsReason=");		pw.print(prefix); pw.print("mAllowWhileInUsePermissionInFgsReason=");
	pw.println(PowerExemptionManager.reasonCodeToString(mAllowWhileInUsePermissionInFgsReason));		pw.println(PowerExemptionManager.reasonCodeToString(mAllowWhileInUsePermissionInFgsReason));

	pw.print(prefix); pw.print("debugWhileInUseReasonInStartForeground=");
	pw.println(PowerExemptionManager.reasonCodeToString(
	mDebugWhileInUseReasonInStartForeground));
	pw.print(prefix); pw.print("debugWhileInUseReasonInBindService=");
	pw.println(PowerExemptionManager.reasonCodeToString(mDebugWhileInUseReasonInBindService));

	pw.print(prefix); pw.print("allowUiJobScheduling="); pw.println(mAllowUiJobScheduling);		pw.print(prefix); pw.print("allowUiJobScheduling="); pw.println(mAllowUiJobScheduling);
	pw.print(prefix); pw.print("recentCallingPackage=");		pw.print(prefix); pw.print("recentCallingPackage=");
	pw.println(mRecentCallingPackage);		pw.println(mRecentCallingPackage);
	@@ -642,10 +623,6 @@ final class ServiceRecord extends Binder implements ComponentName.WithComponentN
	pw.print(prefix); pw.print("infoAllowStartForeground=");		pw.print(prefix); pw.print("infoAllowStartForeground=");
	pw.println(mInfoAllowStartForeground);		pw.println(mInfoAllowStartForeground);

	pw.print(prefix); pw.print("lastUntrustedSetFgsRestrictionAllowedTime=");
	TimeUtils.formatDuration(mLastUntrustedSetFgsRestrictionAllowedTime, now, pw);
	pw.println();

	if (delayed) {		if (delayed) {
	pw.print(prefix); pw.print("delayed="); pw.println(delayed);		pw.print(prefix); pw.print("delayed="); pw.println(delayed);
	}		}