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

Commit 0ed9e0d9 authored by Riddle Hsu's avatar Riddle Hsu Committed by Android (Google) Code Review
Browse files

Merge changes I6a842810,I1f43ec2c into main 

* changes:
  Use top sched group for apps in split screen
  Move abstraction of activity priority calculation
parents 0cf45352 38842298

core/java/android/window/flags/windowing_frontend.aconfig

+7 −0
Original line number Diff line number Diff line
@@ -145,6 +145,13 @@ flag { 
  is_fixed_read_only: true

}



flag {

  name: "process_priority_policy_for_multi_window_mode"

  namespace: "windowing_frontend"

  description: "Use higher priority for top-like processes"

  bug: "200769420"

}



flag {

  name: "insets_decoupled_configuration"

  namespace: "windowing_frontend"

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

+11 −10
Original line number Diff line number Diff line
@@ -1653,8 +1653,7 @@ public class OomAdjuster { 
            new ComputeOomAdjWindowCallback();



    /** These methods are called inline during computeOomAdjLSP(), on the same thread */

    final class ComputeOomAdjWindowCallback

            implements WindowProcessController.ComputeOomAdjCallback {

    final class ComputeOomAdjWindowCallback {



        ProcessRecord app;

        int adj;
@@ -1684,8 +1683,7 @@ public class OomAdjuster { 
            this.mState = app.mState;

        }



        @Override

        public void onVisibleActivity() {

        void onVisibleActivity(int flags) {

            // App has a visible activity; only upgrade adjustment.

            if (adj > VISIBLE_APP_ADJ) {

                adj = VISIBLE_APP_ADJ;
@@ -1705,12 +1703,17 @@ public class OomAdjuster { 
            if (schedGroup < SCHED_GROUP_DEFAULT) {

                schedGroup = SCHED_GROUP_DEFAULT;

            }

            if ((flags & WindowProcessController.ACTIVITY_STATE_FLAG_RESUMED_SPLIT_SCREEN) != 0) {

                // Another side of split should be the current global top. Use the same top

                // priority for this non-top split.

                schedGroup = SCHED_GROUP_TOP_APP;

                mAdjType = "resumed-split-screen-activity";

            }

            foregroundActivities = true;

            mHasVisibleActivities = true;

        }



        @Override

        public void onPausedActivity() {

        void onPausedActivity() {

            if (adj > PERCEPTIBLE_APP_ADJ) {

                adj = PERCEPTIBLE_APP_ADJ;

                mAdjType = "pause-activity";
@@ -1733,8 +1736,7 @@ public class OomAdjuster { 
            mHasVisibleActivities = false;

        }



        @Override

        public void onStoppingActivity(boolean finishing) {

        void onStoppingActivity(boolean finishing) {

            if (adj > PERCEPTIBLE_APP_ADJ) {

                adj = PERCEPTIBLE_APP_ADJ;

                mAdjType = "stop-activity";
@@ -1764,8 +1766,7 @@ public class OomAdjuster { 
            mHasVisibleActivities = false;

        }



        @Override

        public void onOtherActivity() {

        void onOtherActivity() {

            if (procState > PROCESS_STATE_CACHED_ACTIVITY) {

                procState = PROCESS_STATE_CACHED_ACTIVITY;

                mAdjType = "cch-act";

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

+19 −2
Original line number Diff line number Diff line
@@ -27,6 +27,11 @@ import static android.app.ProcessMemoryState.HOSTING_COMPONENT_TYPE_STARTED_SERV 
import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_OOM_ADJ;

import static com.android.server.am.ProcessList.CACHED_APP_MIN_ADJ;

import static com.android.server.am.ProcessRecord.TAG;

import static com.android.server.wm.WindowProcessController.ACTIVITY_STATE_FLAG_IS_PAUSING_OR_PAUSED;

import static com.android.server.wm.WindowProcessController.ACTIVITY_STATE_FLAG_IS_STOPPING;

import static com.android.server.wm.WindowProcessController.ACTIVITY_STATE_FLAG_IS_STOPPING_FINISHING;

import static com.android.server.wm.WindowProcessController.ACTIVITY_STATE_FLAG_IS_VISIBLE;

import static com.android.server.wm.WindowProcessController.ACTIVITY_STATE_FLAG_MASK_MIN_TASK_LAYER;



import android.annotation.ElapsedRealtimeLong;

import android.app.ActivityManager;
@@ -1108,6 +1113,7 @@ final class ProcessStateRecord { 
        return mCachedCompatChanges[cachedCompatChangeId] == VALUE_TRUE;

    }



    /** This is only called if the process contains activities and is not the global top. */

    @GuardedBy("mService")

    void computeOomAdjFromActivitiesIfNecessary(OomAdjuster.ComputeOomAdjWindowCallback callback,

            int adj, boolean foregroundActivities, boolean hasVisibleActivities, int procState,
@@ -1117,8 +1123,17 @@ final class ProcessStateRecord { 
        }

        callback.initialize(mApp, adj, foregroundActivities, hasVisibleActivities, procState,

                schedGroup, appUid, logUid, processCurTop);

        final int minLayer = Math.min(ProcessList.VISIBLE_APP_LAYER_MAX,

                mApp.getWindowProcessController().computeOomAdjFromActivities(callback));

        final int flags = mApp.getWindowProcessController().getActivityStateFlags();



        if ((flags & ACTIVITY_STATE_FLAG_IS_VISIBLE) != 0) {

            callback.onVisibleActivity(flags);

        } else if ((flags & ACTIVITY_STATE_FLAG_IS_PAUSING_OR_PAUSED) != 0) {

            callback.onPausedActivity();

        } else if ((flags & ACTIVITY_STATE_FLAG_IS_STOPPING) != 0) {

            callback.onStoppingActivity((flags & ACTIVITY_STATE_FLAG_IS_STOPPING_FINISHING) != 0);

        } else {

            callback.onOtherActivity();

        }



        mCachedAdj = callback.adj;

        mCachedForegroundActivities = callback.foregroundActivities;
@@ -1128,6 +1143,8 @@ final class ProcessStateRecord { 
        mCachedAdjType = callback.mAdjType;



        if (mCachedAdj == ProcessList.VISIBLE_APP_ADJ) {

            final int taskLayer = flags & ACTIVITY_STATE_FLAG_MASK_MIN_TASK_LAYER;

            final int minLayer = Math.min(ProcessList.VISIBLE_APP_LAYER_MAX, taskLayer);

            mCachedAdj += minLayer;

        }

    }

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

+30 −32
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ package com.android.server.wm; 
import static android.app.ActivityManager.PROCESS_STATE_CACHED_ACTIVITY;

import static android.app.ActivityManager.PROCESS_STATE_NONEXISTENT;

import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;

import static android.app.WindowConfiguration.WINDOWING_MODE_MULTI_WINDOW;

import static android.content.res.Configuration.ASSETS_SEQ_UNDEFINED;

import static android.os.Build.VERSION_CODES.Q;

import static android.os.InputConstants.DEFAULT_DISPATCHING_TIMEOUT_MILLIS;
@@ -309,14 +310,15 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio 
    private volatile boolean mWasStoppedLogged;



    // The bits used for mActivityStateFlags.

    private static final int ACTIVITY_STATE_FLAG_IS_VISIBLE = 1 << 16;

    private static final int ACTIVITY_STATE_FLAG_IS_PAUSING_OR_PAUSED = 1 << 17;

    private static final int ACTIVITY_STATE_FLAG_IS_STOPPING = 1 << 18;

    private static final int ACTIVITY_STATE_FLAG_IS_STOPPING_FINISHING = 1 << 19;

    private static final int ACTIVITY_STATE_FLAG_IS_WINDOW_VISIBLE = 1 << 20;

    private static final int ACTIVITY_STATE_FLAG_HAS_RESUMED = 1 << 21;

    private static final int ACTIVITY_STATE_FLAG_HAS_ACTIVITY_IN_VISIBLE_TASK = 1 << 22;

    private static final int ACTIVITY_STATE_FLAG_MASK_MIN_TASK_LAYER = 0x0000ffff;

    public static final int ACTIVITY_STATE_FLAG_IS_VISIBLE = 1 << 16;

    public static final int ACTIVITY_STATE_FLAG_IS_PAUSING_OR_PAUSED = 1 << 17;

    public static final int ACTIVITY_STATE_FLAG_IS_STOPPING = 1 << 18;

    public static final int ACTIVITY_STATE_FLAG_IS_STOPPING_FINISHING = 1 << 19;

    public static final int ACTIVITY_STATE_FLAG_IS_WINDOW_VISIBLE = 1 << 20;

    public static final int ACTIVITY_STATE_FLAG_HAS_RESUMED = 1 << 21;

    public static final int ACTIVITY_STATE_FLAG_HAS_ACTIVITY_IN_VISIBLE_TASK = 1 << 22;

    public static final int ACTIVITY_STATE_FLAG_RESUMED_SPLIT_SCREEN = 1 << 23;

    public static final int ACTIVITY_STATE_FLAG_MASK_MIN_TASK_LAYER = 0x0000ffff;



    /**

     * The state for oom-adjustment calculation. The higher 16 bits are the activity states, and the
@@ -1211,31 +1213,13 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio 
        }

    }



    public interface ComputeOomAdjCallback {

        void onVisibleActivity();

        void onPausedActivity();

        void onStoppingActivity(boolean finishing);

        void onOtherActivity();

    }



    /**

     * Returns the minimum task layer rank. It should only be called if {@link #hasActivities}

     * returns {@code true}.

     * Returns the current ACTIVITY_STATE_FLAG_* of this process. It should only be called if

     * {@link #hasActivities} returns {@code true}.

     */

    @HotPath(caller = HotPath.OOM_ADJUSTMENT)

    public int computeOomAdjFromActivities(ComputeOomAdjCallback callback) {

        final int flags = mActivityStateFlags;

        if ((flags & ACTIVITY_STATE_FLAG_IS_VISIBLE) != 0) {

            callback.onVisibleActivity();

        } else if ((flags & ACTIVITY_STATE_FLAG_IS_PAUSING_OR_PAUSED) != 0) {

            callback.onPausedActivity();

        } else if ((flags & ACTIVITY_STATE_FLAG_IS_STOPPING) != 0) {

            callback.onStoppingActivity(

                    (flags & ACTIVITY_STATE_FLAG_IS_STOPPING_FINISHING) != 0);

        } else {

            callback.onOtherActivity();

        }

        return flags & ACTIVITY_STATE_FLAG_MASK_MIN_TASK_LAYER;

    public int getActivityStateFlags() {

        return mActivityStateFlags;

    }



    void computeProcessActivityState() {
@@ -1256,14 +1240,25 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio 
                stateFlags |= ACTIVITY_STATE_FLAG_IS_WINDOW_VISIBLE;

            }

            final Task task = r.getTask();

            if (task != null && task.mLayerRank != Task.LAYER_RANK_INVISIBLE) {

            if (task == null) {

                Slog.e(TAG, "Unexpected detached " + r + " in " + this);

                continue;

            }

            if (task.mLayerRank != Task.LAYER_RANK_INVISIBLE) {

                stateFlags |= ACTIVITY_STATE_FLAG_HAS_ACTIVITY_IN_VISIBLE_TASK;

            }

            if (r.isVisibleRequested()) {

                if (r.isState(RESUMED)) {

                    stateFlags |= ACTIVITY_STATE_FLAG_HAS_RESUMED;

                    final int windowingMode = r.getWindowingMode();

                    if (windowingMode == WINDOWING_MODE_MULTI_WINDOW

                            && com.android.window.flags.Flags

                                    .processPriorityPolicyForMultiWindowMode()

                            && task.getAdjacentTask() != null) {

                        stateFlags |= ACTIVITY_STATE_FLAG_RESUMED_SPLIT_SCREEN;

                    }

                if (task != null && minTaskLayer > 0) {

                }

                if (minTaskLayer > 0) {

                    final int layer = task.mLayerRank;

                    if (layer >= 0 && minTaskLayer > layer) {

                        minTaskLayer = layer;
@@ -2107,6 +2102,9 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio 
                pw.print("V|");

                if ((stateFlags & ACTIVITY_STATE_FLAG_HAS_RESUMED) != 0) {

                    pw.print("R|");

                    if ((stateFlags & ACTIVITY_STATE_FLAG_RESUMED_SPLIT_SCREEN) != 0) {

                        pw.print("RS|");

                    }

                }

            } else if ((stateFlags & ACTIVITY_STATE_FLAG_IS_PAUSING_OR_PAUSED) != 0) {

                pw.print("P|");

services/tests/mockingservicestests/src/com/android/server/am/MockingOomAdjusterTests.java

+10 −17
Original line number Diff line number Diff line
@@ -72,14 +72,12 @@ import static org.junit.Assert.assertEquals; 
import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotEquals;

import static org.junit.Assert.assertTrue;

import static org.mockito.AdditionalAnswers.answer;

import static org.mockito.ArgumentMatchers.anyLong;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.any;

import static org.mockito.Mockito.anyBoolean;

import static org.mockito.Mockito.anyInt;

import static org.mockito.Mockito.atLeastOnce;

import static org.mockito.Mockito.doAnswer;

import static org.mockito.Mockito.doCallRealMethod;

import static org.mockito.Mockito.doNothing;

import static org.mockito.Mockito.doReturn;
@@ -486,27 +484,22 @@ public class MockingOomAdjusterTests { 
                MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));

        WindowProcessController wpc = app.getWindowProcessController();

        doReturn(true).when(wpc).hasActivities();

        doAnswer(answer(callback -> {

            Field field = callback.getClass().getDeclaredField("adj");

            field.set(callback, VISIBLE_APP_ADJ);

            field = callback.getClass().getDeclaredField("foregroundActivities");

            field.set(callback, true);

            field = callback.getClass().getDeclaredField("procState");

            field.set(callback, PROCESS_STATE_TOP);

            field = callback.getClass().getDeclaredField("schedGroup");

            field.set(callback, SCHED_GROUP_TOP_APP);

            field = callback.getClass().getDeclaredField("mAdjType");

            field.set(callback, "vis-activity");

            return 0;

        })).when(wpc).computeOomAdjFromActivities(

                any(WindowProcessController.ComputeOomAdjCallback.class));

        doReturn(WindowProcessController.ACTIVITY_STATE_FLAG_IS_VISIBLE)

                .when(wpc).getActivityStateFlags();

        mService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);

        updateOomAdj(app);



        assertProcStates(app, PROCESS_STATE_TOP, VISIBLE_APP_ADJ, SCHED_GROUP_TOP_APP);

        assertProcStates(app, PROCESS_STATE_TOP, VISIBLE_APP_ADJ, SCHED_GROUP_DEFAULT);

        assertFalse(app.mState.isCached());

        assertFalse(app.mState.isEmpty());

        assertEquals("vis-activity", app.mState.getAdjType());



        doReturn(WindowProcessController.ACTIVITY_STATE_FLAG_IS_VISIBLE

                | WindowProcessController.ACTIVITY_STATE_FLAG_RESUMED_SPLIT_SCREEN)

                .when(wpc).getActivityStateFlags();

        updateOomAdj(app);

        assertProcStates(app, PROCESS_STATE_TOP, VISIBLE_APP_ADJ, SCHED_GROUP_TOP_APP);

        assertEquals("resumed-split-screen-activity", app.mState.getAdjType());

    }



    @SuppressWarnings("GuardedBy")