Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d4411a51 authored by Diego Vela's avatar Diego Vela
Browse files

Migrate System Logs to ProtoLog 

Migrate logs for States and Tasks
Remove DEBUG_PAUSE flag
Remove DEBUG_SAVES_STATE flag
Remove DEBUG_STATES flag
Remove DEBUG_TASKS flag

Bug: 153162675
Test: n/a
Change-Id: I3811f58ff5c904dab0b1ff61d29d83d78ec1a121
parent 31b3d88a

core/java/com/android/internal/protolog/ProtoLogGroup.java

+4 −0
Original line number Diff line number Diff line
@@ -48,6 +48,10 @@ public enum ProtoLogGroup implements IProtoLogGroup { 
            Consts.TAG_WM),

    WM_DEBUG_LOCKTASK(Consts.ENABLE_DEBUG, Consts.ENABLE_LOG_TO_PROTO_DEBUG, false,

            Consts.TAG_WM),

    WM_DEBUG_STATES(Consts.ENABLE_DEBUG, Consts.ENABLE_LOG_TO_PROTO_DEBUG, false,

            Consts.TAG_WM),

    WM_DEBUG_TASKS(Consts.ENABLE_DEBUG, Consts.ENABLE_LOG_TO_PROTO_DEBUG, false,

            Consts.TAG_WM),

    WM_DEBUG_STARTING_WINDOW(Consts.ENABLE_DEBUG, Consts.ENABLE_LOG_TO_PROTO_DEBUG, false,

            Consts.TAG_WM),

    WM_SHOW_TRANSACTIONS(Consts.ENABLE_DEBUG, Consts.ENABLE_LOG_TO_PROTO_DEBUG, false,

data/etc/services.core.protolog.json

+624 −0

File changed.

Preview size limit exceeded, changes collapsed.

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

+48 −67
Original line number Diff line number Diff line
@@ -116,6 +116,7 @@ import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_FOCUS; 
import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_FOCUS_LIGHT;

import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_ORIENTATION;

import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_STARTING_WINDOW;

import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_STATES;

import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_SWITCH;

import static com.android.server.policy.WindowManagerPolicy.FINISH_LAYOUT_REDO_ANIM;

import static com.android.server.policy.WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
@@ -150,10 +151,7 @@ import static com.android.server.wm.ActivityRecordProto.WINDOW_TOKEN; 
import static com.android.server.wm.ActivityStackSupervisor.PRESERVE_WINDOWS;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_APP;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_CLEANUP;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_PAUSE;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RESULTS;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_SAVED_STATE;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_STATES;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_SWITCH;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_TRANSITION;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_USER_LEAVING;
@@ -1133,16 +1131,14 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 


    boolean scheduleTopResumedActivityChanged(boolean onTop) {

        if (!attachedToProcess()) {

            if (DEBUG_STATES) {

                Slog.w(TAG, "Can't report activity position update - client not running"

                                + ", activityRecord=" + this);

            }

            ProtoLog.w(WM_DEBUG_STATES,

                    "Can't report activity position update - client not running, "

                            + "activityRecord=%s", this);

            return false;

        }

        try {

            if (DEBUG_STATES) {

                Slog.v(TAG, "Sending position change to " + this + ", onTop: " + onTop);

            }

            ProtoLog.v(WM_DEBUG_STATES, "Sending position change to %s, onTop: %b",

                    this, onTop);



            mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), appToken,

                    TopResumedActivityChangeItem.obtain(onTop));
@@ -2518,10 +2514,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
     */

    @FinishRequest int finishIfPossible(int resultCode, Intent resultData,

            NeededUriGrants resultGrants, String reason, boolean oomAdj) {

        if (DEBUG_RESULTS || DEBUG_STATES) {

            Slog.v(TAG_STATES, "Finishing activity r=" + this + ", result=" + resultCode

                    + ", data=" + resultData + ", reason=" + reason);

        }

        ProtoLog.v(WM_DEBUG_STATES, "Finishing activity r=%s, result=%d, data=%s, "

                + "reason=%s", this, resultCode, resultData, reason);



        if (finishing) {

            Slog.w(TAG, "Duplicate finish request for r=" + this);
@@ -2603,7 +2597,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
                setVisibility(false);



                if (stack.mPausingActivity == null) {

                    if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Finish needs to pause: " + this);

                    ProtoLog.v(WM_DEBUG_STATES, "Finish needs to pause: %s", this);

                    if (DEBUG_USER_LEAVING) {

                        Slog.v(TAG_USER_LEAVING, "finish() => pause with userLeaving=false");

                    }
@@ -2650,7 +2644,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
                }

                return removedActivity ? FINISH_RESULT_REMOVED : FINISH_RESULT_REQUESTED;

            } else {

                if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Finish waiting for pause of: " + this);

                ProtoLog.v(WM_DEBUG_STATES, "Finish waiting for pause of: %s", this);

            }



            return FINISH_RESULT_REQUESTED;
@@ -2807,7 +2801,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
     */

    @VisibleForTesting

    boolean addToFinishingAndWaitForIdle() {

        if (DEBUG_STATES) Slog.v(TAG, "Enqueueing pending finish: " + this);

        ProtoLog.v(WM_DEBUG_STATES, "Enqueueing pending finish: %s", this);

        setState(FINISHING, "addToFinishingAndWaitForIdle");

        if (!mStackSupervisor.mFinishingActivities.contains(this)) {

            mStackSupervisor.mFinishingActivities.add(this);
@@ -2835,10 +2829,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
        }



        if (isState(DESTROYING, DESTROYED)) {

            if (DEBUG_STATES) {

                Slog.v(TAG_STATES, "activity " + this + " already destroying."

                        + "skipping request with reason:" + reason);

            }

            ProtoLog.v(WM_DEBUG_STATES, "activity %s already destroying, skipping "

                    + "request with reason:%s", this, reason);

            return false;

        }
@@ -2879,16 +2871,13 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            // the list yet.  Otherwise, we can just immediately put it in the destroyed state since

            // we are not removing it from the list.

            if (finishing && !skipDestroy) {

                if (DEBUG_STATES) {

                    Slog.v(TAG_STATES, "Moving to DESTROYING: " + this + " (destroy requested)");

                }

                ProtoLog.v(WM_DEBUG_STATES, "Moving to DESTROYING: %s (destroy requested)", this);

                setState(DESTROYING,

                        "destroyActivityLocked. finishing and not skipping destroy");

                mAtmService.mH.postDelayed(mDestroyTimeoutRunnable, DESTROY_TIMEOUT);

            } else {

                if (DEBUG_STATES) {

                    Slog.v(TAG_STATES, "Moving to DESTROYED: " + this + " (destroy skipped)");

                }

                ProtoLog.v(WM_DEBUG_STATES, "Moving to DESTROYED: %s "

                        + "(destroy skipped)", this);

                setState(DESTROYED,

                        "destroyActivityLocked. not finishing or skipping destroy");

                if (DEBUG_APP) Slog.v(TAG_APP, "Clearing app during destroy for activity " + this);
@@ -2900,7 +2889,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
                removeFromHistory(reason + " hadNoApp");

                removedFromHistory = true;

            } else {

                if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to DESTROYED: " + this + " (no app)");

                ProtoLog.v(WM_DEBUG_STATES, "Moving to DESTROYED: %s (no app)", this);

                setState(DESTROYED, "destroyActivityLocked. not finishing and had no app");

            }

        }
@@ -2935,9 +2924,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 


        takeFromHistory();

        removeTimeouts();

        if (DEBUG_STATES) {

            Slog.v(TAG_STATES, "Moving to DESTROYED: " + this + " (removed from history)");

        }

        ProtoLog.v(WM_DEBUG_STATES, "Moving to DESTROYED: %s (removed from history)",

                this);

        setState(DESTROYED, "removeFromHistory");

        if (DEBUG_APP) Slog.v(TAG_APP, "Clearing app during remove for activity " + this);

        detachFromProcess();
@@ -4455,12 +4443,12 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
    }



    void setState(ActivityState state, String reason) {

        if (DEBUG_STATES) Slog.v(TAG_STATES, "State movement: " + this + " from:" + getState()

                        + " to:" + state + " reason:" + reason);

        ProtoLog.v(WM_DEBUG_STATES, "State movement: %s from:%s to:%s reason:%s",

                this, getState(), state, reason);



        if (state == mState) {

            // No need to do anything if state doesn't change.

            if (DEBUG_STATES) Slog.v(TAG_STATES, "State unchanged from:" + state);

            ProtoLog.v(WM_DEBUG_STATES, "State unchanged from:%s", state);

            return;

        }
@@ -4943,7 +4931,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 


    static void activityResumedLocked(IBinder token) {

        final ActivityRecord r = ActivityRecord.forTokenLocked(token);

        if (DEBUG_SAVED_STATE) Slog.i(TAG_STATES, "Resumed activity; dropping state of: " + r);

        ProtoLog.i(WM_DEBUG_STATES, "Resumed activity; dropping state of: %s", r);

        if (r == null) {

            // If an app reports resumed after a long delay, the record on server side might have

            // been removed (e.g. destroy timeout), so the token could be null.
@@ -5014,8 +5002,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
    }



    void activityPaused(boolean timeout) {

        if (DEBUG_PAUSE) Slog.v(TAG_PAUSE,

                "Activity paused: token=" + appToken + ", timeout=" + timeout);

        ProtoLog.v(WM_DEBUG_STATES, "Activity paused: token=%s, timeout=%b", appToken,

                timeout);



        final Task stack = getStack();
@@ -5023,8 +5011,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            removePauseTimeout();



            if (stack.mPausingActivity == this) {

                if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to PAUSED: " + this

                        + (timeout ? " (due to timeout)" : " (pause complete)"));

                ProtoLog.v(WM_DEBUG_STATES, "Moving to PAUSED: %s %s", this,

                        (timeout ? "(due to timeout)" : " (pause complete)"));

                mAtmService.deferWindowLayout();

                try {

                    stack.completePauseLocked(true /* resumeNext */, null /* resumingActivity */);
@@ -5039,8 +5027,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
                if (isState(PAUSING)) {

                    setState(PAUSED, "activityPausedLocked");

                    if (finishing) {

                        if (DEBUG_PAUSE) Slog.v(TAG,

                                "Executing finish of failed to pause activity: " + this);

                        ProtoLog.v(WM_DEBUG_STATES,

                                "Executing finish of failed to pause activity: %s", this);

                        completeFinishing("activityPausedLocked");

                    }

                }
@@ -5057,7 +5045,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
    void schedulePauseTimeout() {

        pauseTime = SystemClock.uptimeMillis();

        mAtmService.mH.postDelayed(mPauseTimeoutRunnable, PAUSE_TIMEOUT);

        if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Waiting for pause to complete...");

        ProtoLog.v(WM_DEBUG_STATES, "Waiting for pause to complete...");

    }



    private void removePauseTimeout() {
@@ -5086,17 +5074,15 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
        if (isNoHistory()) {

            if (!finishing) {

                if (!stack.shouldSleepActivities()) {

                    if (DEBUG_STATES) Slog.d(TAG_STATES, "no-history finish of " + this);

                    ProtoLog.d(WM_DEBUG_STATES, "no-history finish of %s", this);

                    if (finishIfPossible("stop-no-history", false /* oomAdj */)

                            != FINISH_RESULT_CANCELLED) {

                        resumeKeyDispatchingLocked();

                        return;

                    }

                } else {

                    if (DEBUG_STATES) {

                        Slog.d(TAG_STATES, "Not finishing noHistory " + this

                                + " on stop because we're just sleeping");

                    }

                    ProtoLog.d(WM_DEBUG_STATES, "Not finishing noHistory %s on stop "

                            + "because we're just sleeping", this);

                }

            }

        }
@@ -5107,9 +5093,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
        resumeKeyDispatchingLocked();

        try {

            stopped = false;

            if (DEBUG_STATES) {

                Slog.v(TAG_STATES, "Moving to STOPPING: " + this + " (stop requested)");

            }

            ProtoLog.v(WM_DEBUG_STATES, "Moving to STOPPING: %s (stop requested)", this);



            setState(STOPPING, "stopIfPossible");

            if (DEBUG_VISIBILITY) {

                Slog.v(TAG_VISIBILITY, "Stopping:" + this);
@@ -5129,7 +5114,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            Slog.w(TAG, "Exception thrown during pause", e);

            // Just in case, assume it to be stopped.

            stopped = true;

            if (DEBUG_STATES) Slog.v(TAG_STATES, "Stop failed; moving to STOPPED: " + this);

            ProtoLog.v(WM_DEBUG_STATES, "Stop failed; moving to STOPPED: %s", this);

            setState(STOPPED, "stopIfPossible");

            if (deferRelaunchUntilPaused) {

                destroyImmediately("stop-except");
@@ -5158,9 +5143,9 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            launchCount = 0;

            updateTaskDescription(description);

        }

        if (DEBUG_SAVED_STATE) Slog.i(TAG_SAVED_STATE, "Saving icicle of " + this + ": " + mIcicle);

        ProtoLog.i(WM_DEBUG_STATES, "Saving icicle of %s: %s", this, mIcicle);

        if (!stopped) {

            if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to STOPPED: " + this + " (stop complete)");

            ProtoLog.v(WM_DEBUG_STATES, "Moving to STOPPED: %s (stop complete)", this);

            removeStopTimeout();

            stopped = true;

            if (isStopping) {
@@ -5196,10 +5181,9 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
        boolean forceIdle = mStackSupervisor.mStoppingActivities.size() > MAX_STOPPING_TO_FORCE

                || (isRootOfTask() && stack.getChildCount() <= 1);

        if (scheduleIdle || forceIdle) {

            if (DEBUG_PAUSE) {

                Slog.v(TAG_PAUSE, "Scheduling idle now: forceIdle=" + forceIdle

                        + "immediate=" + !idleDelayed);

            }

            ProtoLog.v(WM_DEBUG_STATES,

                    "Scheduling idle now: forceIdle=%b immediate=%b", forceIdle, !idleDelayed);



            if (!idleDelayed) {

                mStackSupervisor.scheduleIdle();

            } else {
@@ -7126,9 +7110,9 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            } else {

                ProtoLog.v(WM_DEBUG_CONFIGURATION, "Config is relaunching %s",

                        this);

                if (DEBUG_STATES && !mVisibleRequested) {

                    Slog.v(TAG_STATES, "Config is relaunching invisible activity " + this

                            + " called by " + Debug.getCallers(4));

                if (!mVisibleRequested) {

                    ProtoLog.v(WM_DEBUG_STATES, "Config is relaunching invisible "

                            + "activity %s called by %s", this, Debug.getCallers(4));

                }

                relaunchActivityLocked(preserveWindow);

            }
@@ -7261,9 +7245,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
        startFreezingScreenLocked(0);



        try {

            if (DEBUG_SWITCH || DEBUG_STATES) Slog.i(TAG_SWITCH,

                    "Moving to " + (andResume ? "RESUMED" : "PAUSED") + " Relaunching " + this

                            + " callers=" + Debug.getCallers(6));

            ProtoLog.i(WM_DEBUG_STATES, "Moving to %s Relaunching %s callers=%s" ,

                    (andResume ? "RESUMED" : "PAUSED"), this, Debug.getCallers(6));

            forceNewConfig = false;

            startRelaunching();

            final ClientTransactionItem callbackItem = ActivityRelaunchItem.obtain(pendingResults,
@@ -7286,13 +7269,11 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            // request resume if this activity is currently resumed, which implies we aren't

            // sleeping.

        } catch (RemoteException e) {

            if (DEBUG_SWITCH || DEBUG_STATES) Slog.i(TAG_SWITCH, "Relaunch failed", e);

            ProtoLog.i(WM_DEBUG_STATES, "Relaunch failed %s", e);

        }



        if (andResume) {

            if (DEBUG_STATES) {

                Slog.d(TAG_STATES, "Resumed after relaunch " + this);

            }

            ProtoLog.d(WM_DEBUG_STATES, "Resumed after relaunch %s", this);

            results = null;

            newIntents = null;

            mAtmService.getAppWarningsLocked().onResumeActivity(this);

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

+29 −32
Original line number Diff line number Diff line
@@ -44,15 +44,14 @@ import static android.os.Process.INVALID_UID; 
import static android.os.Trace.TRACE_TAG_WINDOW_MANAGER;

import static android.view.Display.DEFAULT_DISPLAY;



import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_STATES;

import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_TASKS;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_ALL;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_CLEANUP;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_IDLE;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_PAUSE;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RECENTS;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_STACK;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_STATES;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_SWITCH;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_TASKS;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_IDLE;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_PAUSE;

import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_RECENTS;
@@ -66,7 +65,6 @@ import static com.android.server.wm.ActivityTaskManagerService.H.FIRST_SUPERVISO 
import static com.android.server.wm.ActivityTaskManagerService.RELAUNCH_REASON_NONE;

import static com.android.server.wm.RootWindowContainer.MATCH_TASK_IN_STACKS_OR_RECENT_TASKS;

import static com.android.server.wm.RootWindowContainer.MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE;

import static com.android.server.wm.RootWindowContainer.TAG_STATES;

import static com.android.server.wm.SurfaceAnimator.ANIMATION_TYPE_APP_TRANSITION;

import static com.android.server.wm.SurfaceAnimator.ANIMATION_TYPE_RECENTS;

import static com.android.server.wm.Task.ActivityState.PAUSED;
@@ -135,6 +133,7 @@ import com.android.internal.annotations.GuardedBy; 
import com.android.internal.annotations.VisibleForTesting;

import com.android.internal.content.ReferrerIntent;

import com.android.internal.os.TransferPipe;

import com.android.internal.protolog.common.ProtoLog;

import com.android.internal.util.ArrayUtils;

import com.android.internal.util.function.pooled.PooledConsumer;

import com.android.internal.util.function.pooled.PooledLambda;
@@ -721,9 +720,9 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { 
            // While there are activities pausing we skipping starting any new activities until

            // pauses are complete. NOTE: that we also do this for activities that are starting in

            // the paused state because they will first be resumed then paused on the client side.

            if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG_PAUSE,

                    "realStartActivityLocked: Skipping start of r=" + r

                    + " some activities pausing...");

            ProtoLog.v(WM_DEBUG_STATES,

                    "realStartActivityLocked: Skipping start of r=%s some activities pausing...",

                    r);

            return false;

        }
@@ -919,8 +918,8 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { 
            // This activity is not starting in the resumed state... which should look like we asked

            // it to pause+stop (but remain visible), and it has done so and reported back the

            // current icicle and other state.

            if (DEBUG_STATES) Slog.v(TAG_STATES,

                    "Moving to PAUSED: " + r + " (starting in paused state)");

            ProtoLog.v(WM_DEBUG_STATES, "Moving to PAUSED: %s "

                    + "(starting in paused state)", r);

            r.setState(PAUSED, "realStartActivityLocked");

            mRootWindowContainer.executeAppTransitionForAllDisplay();

        }
@@ -1071,11 +1070,11 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { 
    /** Check if caller is allowed to launch activities on specified display. */

    boolean isCallerAllowedToLaunchOnDisplay(int callingPid, int callingUid, int launchDisplayId,

            ActivityInfo aInfo) {

        if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check: displayId=" + launchDisplayId

                + " callingPid=" + callingPid + " callingUid=" + callingUid);

        ProtoLog.d(WM_DEBUG_TASKS, "Launch on display check: displayId=%d callingPid=%d "

                + "callingUid=%d", launchDisplayId, callingPid, callingUid);



        if (callingPid == -1 && callingUid == -1) {

            if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check: no caller info, skip check");

            ProtoLog.d(WM_DEBUG_TASKS, "Launch on display check: no caller info, skip check");

            return true;

        }
@@ -1091,8 +1090,7 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { 
        final int startAnyPerm = mService.checkPermission(INTERNAL_SYSTEM_WINDOW, callingPid,

                callingUid);

        if (startAnyPerm == PERMISSION_GRANTED) {

            if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"

                    + " allow launch any on display");

            ProtoLog.d(WM_DEBUG_TASKS, "Launch on display check: allow launch any on display");

            return true;

        }
@@ -1104,36 +1102,36 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { 
            // Limit launching on untrusted displays because their contents can be read from Surface

            // by apps that created them.

            if ((aInfo.flags & ActivityInfo.FLAG_ALLOW_EMBEDDED) == 0) {

                if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"

                        + " disallow launch on virtual display for not-embedded activity.");

                ProtoLog.d(WM_DEBUG_TASKS, "Launch on display check: disallow launch on "

                        + "virtual display for not-embedded activity.");

                return false;

            }

            // Check if the caller is allowed to embed activities from other apps.

            if (mService.checkPermission(ACTIVITY_EMBEDDING, callingPid, callingUid)

                    == PERMISSION_DENIED && !uidPresentOnDisplay) {

                if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"

                        + " disallow activity embedding without permission.");

                ProtoLog.d(WM_DEBUG_TASKS, "Launch on display check: disallow activity "

                        + "embedding without permission.");

                return false;

            }

        }



        if (!displayContent.isPrivate()) {

            // Anyone can launch on a public display.

            if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"

                    + " allow launch on public display");

            ProtoLog.d(WM_DEBUG_TASKS, "Launch on display check: allow launch on public "

                    + "display");

            return true;

        }



        // Check if the caller is the owner of the display.

        if (display.getOwnerUid() == callingUid) {

            if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"

                    + " allow launch for owner of the display");

            ProtoLog.d(WM_DEBUG_TASKS, "Launch on display check: allow launch for owner of the"

                    + " display");

            return true;

        }



        if (uidPresentOnDisplay) {

            if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"

                    + " allow launch for caller present on the display");

            ProtoLog.d(WM_DEBUG_TASKS, "Launch on display check: allow launch for caller "

                    + "present on the display");

            return true;

        }
@@ -1832,8 +1830,8 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { 
            final boolean animating = s.isAnimating(TRANSITION | PARENTS,

                    ANIMATION_TYPE_APP_TRANSITION | ANIMATION_TYPE_RECENTS)

                    || mService.getTransitionController().inTransition(s);

            if (DEBUG_STATES) Slog.v(TAG, "Stopping " + s + ": nowVisible=" + s.nowVisible

                    + " animating=" + animating + " finishing=" + s.finishing);

            ProtoLog.v(WM_DEBUG_STATES, "Stopping %s: nowVisible=%b animating=%b "

                    + "finishing=%s", s, s.nowVisible, animating, s.finishing);

            if (!animating || mService.mShuttingDown) {

                if (!processPausingActivities && s.isState(PAUSING)) {

                    // Defer processing pausing activities in this iteration and reschedule
@@ -1843,7 +1841,7 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { 
                    continue;

                }



                if (DEBUG_STATES) Slog.v(TAG, "Ready to stop: " + s);

                ProtoLog.v(WM_DEBUG_STATES, "Ready to stop: %s", s);

                if (readyToStopActivities == null) {

                    readyToStopActivities = new ArrayList<>();

                }
@@ -2077,7 +2075,7 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { 
        msg.obj = r;

        r.topResumedStateLossTime = SystemClock.uptimeMillis();

        mHandler.sendMessageDelayed(msg, TOP_RESUMED_STATE_LOSS_TIMEOUT);

        if (DEBUG_STATES) Slog.v(TAG_STATES, "Waiting for top state to be released by " + r);

        ProtoLog.v(WM_DEBUG_STATES, "Waiting for top state to be released by %s", r);

    }



    /**
@@ -2085,10 +2083,9 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { 
     * activity if needed.

     */

    void handleTopResumedStateReleased(boolean timeout) {

        if (DEBUG_STATES) {

            Slog.v(TAG_STATES, "Top resumed state released "

                    + (timeout ? " (due to timeout)" : " (transition complete)"));

        }

        ProtoLog.v(WM_DEBUG_STATES, "Top resumed state released %s",

                    (timeout ? "(due to timeout)" : "(transition complete)"));



        mHandler.removeMessages(TOP_RESUMED_STATE_LOSS_TIMEOUT_MSG);

        if (!mTopResumedActivityWaitingForPrev) {

            // Top resumed activity state loss already handled.

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

+5 −10

File changed.

Preview size limit exceeded, changes collapsed.