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

Only log aborted activity background starts to TRON

Browse Source 
And compute the relevant information only once, to be faster.

Bug: 123434182
Bug: 110956953
Test: atest WmTests:ActivityStarterTests
Change-Id: Id40653f01e3b96a667ad9a9642edee5d3d06db3c
This commit is contained in:
Michal Karpinski
2019-01-28 15:13:32 +00:00
parent bf1d8ab140
commit 4fd5b84341
3 changed files with 41 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
services/core/java/com/android/server/wm/ActivityMetricsLogger.java
View File

@@ -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);
}

105
services/core/java/com/android/server/wm/ActivityStarter.java
View File

@@ -749,9 +749,15 @@ class ActivityStarter {
boolean abortBackgroundStart = false;
if (!abort) {
abortBackgroundStart = shouldAbortBackgroundActivityStart(callingUid, callingPid,
callingPackage, realCallingUid, callerApp, originatingPendingIntent,
allowBackgroundActivityStart, intent);
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;
}
/**

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

@@ -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));
}
/**