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

Commit b7e3d029 authored by Diego Vela's avatar Diego Vela Committed by Android (Google) Code Review
Browse files

Merge "Migrate System Logs to ProtoLog"

parents 94ddd9d4 d4411a51

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.