Merge "Only log aborted activity background starts to TRON" (4f7a8581) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/wm/ActivityMetricsLogger.java

+1 −39

Original line number	Diff line number	Diff line
		@@ -841,13 +841,11 @@ class ActivityMetricsLogger {
		Log.i(TAG, sb.toString());
		}

		void logActivityStart(Intent intent, WindowProcessController callerApp, ActivityRecord r,
		void logAbortedBgActivityStart(Intent intent, WindowProcessController callerApp,
		int callingUid, String callingPackage, int callingUidProcState,
		boolean callingUidHasAnyVisibleWindow,
		int realCallingUid, int realCallingUidProcState,
		boolean realCallingUidHasAnyVisibleWindow,
		int targetUid, String targetPackage, int targetUidProcState,
		boolean targetUidHasAnyVisibleWindow, String targetWhitelistTag,
		boolean comingFromPendingIntent) {

		final long nowElapsed = SystemClock.elapsedRealtime();
		@@ -865,13 +863,6 @@ class ActivityMetricsLogger {
		processStateAmToProto(realCallingUidProcState));
		builder.addTaggedData(FIELD_REAL_CALLING_UID_HAS_ANY_VISIBLE_WINDOW,
		realCallingUidHasAnyVisibleWindow ? 1 : 0);
		builder.addTaggedData(FIELD_TARGET_UID, targetUid);
		builder.addTaggedData(FIELD_TARGET_PACKAGE_NAME, targetPackage);
		builder.addTaggedData(FIELD_TARGET_UID_PROC_STATE,
		processStateAmToProto(targetUidProcState));
		builder.addTaggedData(FIELD_TARGET_UID_HAS_ANY_VISIBLE_WINDOW,
		targetUidHasAnyVisibleWindow ? 1 : 0);
		builder.addTaggedData(FIELD_TARGET_WHITELIST_TAG, targetWhitelistTag);
		builder.addTaggedData(FIELD_COMING_FROM_PENDING_INTENT, comingFromPendingIntent ? 1 : 0);
		if (intent != null) {
		builder.addTaggedData(FIELD_INTENT_ACTION, intent.getAction());
		@@ -904,35 +895,6 @@ class ActivityMetricsLogger {
		(nowUptime - callerApp.getWhenUnimportant()));
		}
		}
		if (r != null) {
		builder.addTaggedData(FIELD_TARGET_SHORT_COMPONENT_NAME, r.shortComponentName);
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_LAUNCH_MODE, r.info.launchMode);
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_TARGET_ACTIVITY, r.info.targetActivity);
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_FLAGS, r.info.flags);
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_REAL_ACTIVITY,
		r.mActivityComponent.toShortString());
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_SHORT_COMPONENT_NAME, r.shortComponentName);
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_PROCESS_NAME, r.processName);
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_IS_FULLSCREEN, r.fullscreen ? 1 : 0);
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_IS_NO_DISPLAY, r.noDisplay ? 1 : 0);
		if (r.lastVisibleTime != 0) {
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_MILLIS_SINCE_LAST_VISIBLE,
		(nowUptime - r.lastVisibleTime));
		}
		if (r.resultTo != null) {
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_RESULT_TO_PKG_NAME,
		r.resultTo.packageName);
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_RESULT_TO_SHORT_COMPONENT_NAME,
		r.resultTo.shortComponentName);
		}
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_IS_VISIBLE, r.visible ? 1 : 0);
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_IS_VISIBLE_IGNORING_KEYGUARD,
		r.visibleIgnoringKeyguard ? 1 : 0);
		if (r.lastLaunchTime != 0) {
		builder.addTaggedData(FIELD_ACTIVITY_RECORD_MILLIS_SINCE_LAST_LAUNCH,
		(nowUptime - r.lastLaunchTime));
		}
		}
		mMetricsLogger.write(builder);
		}

services/core/java/com/android/server/wm/ActivityStarter.java

+36 −69

Original line number	Diff line number	Diff line
		@@ -749,9 +749,15 @@ class ActivityStarter {

		boolean abortBackgroundStart = false;
		if (!abort) {
		try {
		Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
		"shouldAbortBackgroundActivityStart");
		abortBackgroundStart = shouldAbortBackgroundActivityStart(callingUid, callingPid,
		callingPackage, realCallingUid, callerApp, originatingPendingIntent,
		allowBackgroundActivityStart, intent);
		} finally {
		Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
		}
		abort \|= (abortBackgroundStart && !mService.isBackgroundActivityStartsEnabled());
		// TODO: remove this toast after feature development is done
		if (abortBackgroundStart) {
		@@ -903,12 +909,6 @@ class ActivityStarter {
		mService.onStartActivitySetDidAppSwitch();
		mController.doPendingActivityLaunches(false);

		// maybe log to TRON, but only if we haven't already in shouldAbortBackgroundActivityStart()
		if (!abortBackgroundStart) {
		maybeLogActivityStart(callingUid, callingPackage, realCallingUid, intent, callerApp, r,
		originatingPendingIntent, false /abortedStart/);
		}

		return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
		true /* doResume */, checkedOptions, inTask, outActivity);
		}
		@@ -927,17 +927,31 @@ class ActivityStarter {
		return false;
		}
		// don't abort if the callingUid is in the foreground or is a persistent system process
		final boolean isCallingUidForeground = mService.isUidForeground(callingUid);
		final boolean isCallingUidPersistentSystemProcess = isUidPersistentSystemProcess(
		callingUid);
		final int callingUidProcState = mService.getUidStateLocked(callingUid);
		final boolean callingUidHasAnyVisibleWindow =
		mService.mWindowManager.mRoot.isAnyNonToastWindowVisibleForUid(callingUid);
		final boolean isCallingUidForeground = callingUidHasAnyVisibleWindow
		\|\| callingUidProcState == ActivityManager.PROCESS_STATE_TOP;
		final boolean isCallingUidPersistentSystemProcess = (callingUid == Process.SYSTEM_UID)
		\|\| callingUidProcState <= ActivityManager.PROCESS_STATE_PERSISTENT_UI;
		if (isCallingUidForeground \|\| isCallingUidPersistentSystemProcess) {
		return false;
		}
		// take realCallingUid into consideration
		final boolean isRealCallingUidForeground = mService.isUidForeground(
		realCallingUid);
		final boolean isRealCallingUidPersistentSystemProcess = isUidPersistentSystemProcess(
		realCallingUid);
		final int realCallingUidProcState = (callingUid == realCallingUid)
		? callingUidProcState
		: mService.getUidStateLocked(realCallingUid);
		final boolean realCallingUidHasAnyVisibleWindow = (callingUid == realCallingUid)
		? callingUidHasAnyVisibleWindow
		: mService.mWindowManager.mRoot.isAnyNonToastWindowVisibleForUid(realCallingUid);
		final boolean isRealCallingUidForeground = (callingUid == realCallingUid)
		? isCallingUidForeground
		: realCallingUidHasAnyVisibleWindow
		\|\| realCallingUidProcState == ActivityManager.PROCESS_STATE_TOP;
		final boolean isRealCallingUidPersistentSystemProcess = (callingUid == realCallingUid)
		? isCallingUidPersistentSystemProcess
		: (realCallingUid == Process.SYSTEM_UID)
		\|\| realCallingUidProcState <= ActivityManager.PROCESS_STATE_PERSISTENT_UI;
		if (realCallingUid != callingUid) {
		// don't abort if the realCallingUid is in the foreground and callingUid isn't
		if (isRealCallingUidForeground) {
		@@ -975,61 +989,14 @@ class ActivityStarter {
		+ "; isBgStartWhitelisted: " + allowBackgroundActivityStart
		+ "; intent: " + intent
		+ "]");
		maybeLogActivityStart(callingUid, callingPackage, realCallingUid, intent, callerApp,
		null /r/, originatingPendingIntent, true /abortedStart/);
		return true;
		}

		/** Returns true if uid is in a persistent state. */
		private boolean isUidPersistentSystemProcess(int uid) {
		return (uid == Process.SYSTEM_UID)
		\|\| (mService.getUidStateLocked(uid) <= ActivityManager.PROCESS_STATE_PERSISTENT_UI);
		}

		private void maybeLogActivityStart(int callingUid, String callingPackage, int realCallingUid,
		Intent intent, WindowProcessController callerApp, ActivityRecord r,
		PendingIntentRecord originatingPendingIntent, boolean abortedStart) {
		boolean callerAppHasForegroundActivity =
		callerApp != null && callerApp.hasForegroundActivities();
		if (!mService.isActivityStartsLoggingEnabled() \|\| callerAppHasForegroundActivity
		\|\| (!abortedStart && r == null)) {
		// skip logging in this case
		return;
		}

		try {
		Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "logActivityStart");
		final int callingUidProcState = mService.getUidStateLocked(callingUid);
		final boolean callingUidHasAnyVisibleWindow =
		mService.mWindowManager.mRoot.isAnyNonToastWindowVisibleForUid(callingUid);
		final int realCallingUidProcState = (callingUid == realCallingUid)
		? callingUidProcState
		: mService.getUidStateLocked(realCallingUid);
		final boolean realCallingUidHasAnyVisibleWindow = (callingUid == realCallingUid)
		? callingUidHasAnyVisibleWindow
		: mService.mWindowManager.mRoot.isAnyNonToastWindowVisibleForUid(
		realCallingUid);
		final String targetPackage = (r != null) ? r.packageName : null;
		final int targetUid = (r!= null) ? ((r.appInfo != null) ? r.appInfo.uid : -1) : -1;
		final int targetUidProcState = mService.getUidStateLocked(targetUid);
		final boolean targetUidHasAnyVisibleWindow = (targetUid != -1)
		? mService.mWindowManager.mRoot.isAnyNonToastWindowVisibleForUid(targetUid)
		: false;
		final String targetWhitelistTag = (targetUid != -1)
		? mService.getPendingTempWhitelistTagForUidLocked(targetUid)
		: null;

		mSupervisor.getActivityMetricsLogger().logActivityStart(intent, callerApp, r,
		callingUid, callingPackage, callingUidProcState,
		callingUidHasAnyVisibleWindow,
		realCallingUid, realCallingUidProcState,
		realCallingUidHasAnyVisibleWindow,
		targetUid, targetPackage, targetUidProcState,
		targetUidHasAnyVisibleWindow, targetWhitelistTag,
		// log aborted activity start to TRON
		if (mService.isActivityStartsLoggingEnabled()) {
		mSupervisor.getActivityMetricsLogger().logAbortedBgActivityStart(intent, callerApp,
		callingUid, callingPackage, callingUidProcState, callingUidHasAnyVisibleWindow,
		realCallingUid, realCallingUidProcState, realCallingUidHasAnyVisibleWindow,
		(originatingPendingIntent != null));
		} finally {
		Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
		}
		return true;
		}

		/**

services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java

+4 −6

Original line number	Diff line number	Diff line
		@@ -523,9 +523,8 @@ public class ActivityStarterTests extends ActivityTestsBase {
		starter.setReason("testActivityStartsLogging_noLoggingWhenDisabled").execute();

		// verify logging wasn't done
		verify(mActivityMetricsLogger, never()).logActivityStart(any(), any(), any(), anyInt(),
		any(), anyInt(), anyBoolean(), anyInt(), anyInt(), anyBoolean(), anyInt(), any(),
		anyInt(), anyBoolean(), any(), anyBoolean());
		verify(mActivityMetricsLogger, never()).logAbortedBgActivityStart(any(), any(), anyInt(),
		any(), anyInt(), anyBoolean(), anyInt(), anyInt(), anyBoolean(), anyBoolean());
		}

		/**
		@@ -546,10 +545,9 @@ public class ActivityStarterTests extends ActivityTestsBase {
		starter.setReason("testActivityStartsLogging_logsWhenEnabled").execute();

		// verify the above activity start was logged
		verify(mActivityMetricsLogger, times(1)).logActivityStart(any(), any(), any(),
		verify(mActivityMetricsLogger, times(1)).logAbortedBgActivityStart(any(), any(),
		eq(FAKE_CALLING_UID), eq(FAKE_CALLING_PACKAGE), anyInt(), anyBoolean(),
		eq(FAKE_REAL_CALLING_UID), anyInt(), anyBoolean(), anyInt(),
		any(), anyInt(), anyBoolean(), any(), eq(false));
		eq(FAKE_REAL_CALLING_UID), anyInt(), anyBoolean(), eq(false));
		}

		/**