Merge "Make DisplayContent the DisplayArea.Root"

message DisplayContentProto {

    option (.android.msg_privacy).dest = DEST_AUTOMATIC;

    optional WindowContainerProto window_container = 1;

    // Use root_display_area instead

    optional WindowContainerProto window_container = 1 [deprecated=true];

    optional int32 id = 2;

    reserved 3; // stacks

    optional DockedStackDividerControllerProto docked_stack_divider_controller = 4 [deprecated=true];

    repeated WindowTokenProto overlay_windows = 20 [deprecated=true];

    optional DisplayAreaProto root_display_area = 21;

    optional bool single_task_instance = 22;

    optional int32 focused_root_task_id = 23;

    optional .com.android.server.wm.IdentifierProto resumed_activity = 24;

    }

    @Override

    public final void dumpDebug(ProtoOutputStream proto, long fieldId, int logLevel) {

    public void dumpDebug(ProtoOutputStream proto, long fieldId, int logLevel) {

        final long token = proto.start(fieldId);

        super.dumpDebug(proto, WINDOW_CONTAINER, logLevel);

        proto.write(NAME, mName);

    }

    /**

     * Top-most DisplayArea under DisplayContent.

     * Root of the display area hierarchy.

     */

    public static class Root extends DisplayArea<DisplayArea> {

        Root(WindowManagerService wms) {

import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;

import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;

import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;

import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_UNSET;

import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_USER;

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

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

import static com.android.server.wm.DisplayContentProto.ROTATION;

import static com.android.server.wm.DisplayContentProto.SCREEN_ROTATION_ANIMATION;

import static com.android.server.wm.DisplayContentProto.SINGLE_TASK_INSTANCE;

import static com.android.server.wm.DisplayContentProto.WINDOW_CONTAINER;

import static com.android.server.wm.ProtoLogGroup.WM_DEBUG_APP_TRANSITIONS;

import static com.android.server.wm.ProtoLogGroup.WM_DEBUG_BOOT;

import static com.android.server.wm.ProtoLogGroup.WM_DEBUG_FOCUS;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedList;

 * Utility class for keeping track of the WindowStates and other pertinent contents of a

 * particular Display.

 */

class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowContainer>

        implements WindowManagerPolicy.DisplayContentInfo {

class DisplayContent extends DisplayArea.Root implements WindowManagerPolicy.DisplayContentInfo {

    private static final String TAG = TAG_WITH_CLASS_NAME ? "DisplayContent" : TAG_WM;

    private static final String TAG_STACK = TAG + POSTFIX_STACK;

    /** Unique identifier of this display. */

    final int mDisplayId;

    /**

     * Most surfaces will be a child of this window. There are some special layers and windows

     * which are always on top of others and omitted from Screen-Magnification, for example the

     * strict mode flash or the magnification overlay itself. Those layers will be children of

     * {@link #mOverlayLayer} where mWindowContainers contains everything else.

     */

     // TODO(b/156425461) we don't need this extra layer between DisplayContent and DisplayArea.Root

    private final WindowContainers mWindowContainers =

            new WindowContainers("mWindowContainers", mWmService);

    /**

     * We organize all top-level Surfaces into the following layer.

     * It contains a few Surfaces which are always on top of others, and omitted from

    // TODO(display-area): is "no magnification" in the comment still true?

    private final ImeContainer mImeWindowsContainers = new ImeContainer(mWmService);

    private final DisplayArea.Root mRootDisplayArea = new DisplayArea.Root(mWmService);

    @VisibleForTesting

    final DisplayAreaPolicy mDisplayAreaPolicy;

                .show(mOverlayLayer);

        getPendingTransaction().apply();

        // These are the only direct children we should ever have and they are permanent.

        super.addChild(mWindowContainers, null);

        // Setup the policy and build the display area hierarchy.

        mDisplayAreaPolicy = mWmService.mDisplayAreaPolicyProvider.instantiate(

                mWmService, this, mRootDisplayArea, mImeWindowsContainers);

        mWindowContainers.addChildren();

                mWmService, this /* content */, this /* root */, mImeWindowsContainers);

        mDisplayAreaPolicy.attachDisplayAreas();

        // Sets the display content for the children.

        onDisplayChanged(this);

                return getLastOrientation();

            }

        }

        final int rootOrientation = mRootDisplayArea.getOrientation();

        mLastOrientationSource = mRootDisplayArea.getLastOrientationSource();

        return rootOrientation;

        return super.getOrientation();

    }

    void updateDisplayInfo() {

        return mDisplayAreaPolicy.getTaskDisplayAreaAt(0);

    }

    @Override

    protected void addChild(DisplayChildWindowContainer child,

            Comparator<DisplayChildWindowContainer> comparator) {

        throw new UnsupportedOperationException("See DisplayChildWindowContainer");

    }

    @Override

    protected void addChild(DisplayChildWindowContainer child, int index) {

        throw new UnsupportedOperationException("See DisplayChildWindowContainer");

    }

    @Override

    protected void removeChild(DisplayChildWindowContainer child) {

        // Only allow removal of direct children from this display if the display is in the process

        // of been removed.

        if (mRemovingDisplay) {

            super.removeChild(child);

            return;

        }

        throw new UnsupportedOperationException("See DisplayChildWindowContainer");

    }

    void positionDisplayAt(int position, boolean includingParents) {

        getParent().positionChildAt(position, this, includingParents);

    }

    @Override

    void positionChildAt(int position, DisplayChildWindowContainer child, boolean includingParents) {

        // Children of the display are statically ordered, so the real intention here is to perform

        // the operation on the display and not the static direct children.

        positionDisplayAt(position, includingParents);

    }

    /**

     * Returns true if the input point is within an app window.

     */

        boolean stillDeferringRemoval = false;

        for (int i = getChildCount() - 1; i >= 0; --i) {

            final DisplayChildWindowContainer child = getChildAt(i);

            final DisplayArea child = getChildAt(i);

            stillDeferringRemoval |= child.checkCompleteDeferredRemoval();

            if (getChildCount() == 0) {

                // If this display is pending to be removed because it contains an activity with

        }

    }

    @Override

    public void dumpDebug(ProtoOutputStream proto, long fieldId,

            @WindowTraceLogLevel int logLevel) {

        // Critical log level logs only visible elements to mitigate performance overheard

        }

        final long token = proto.start(fieldId);

        super.dumpDebug(proto, WINDOW_CONTAINER, logLevel);

        super.dumpDebug(proto, ROOT_DISPLAY_AREA, logLevel);

        proto.write(ID, mDisplayId);

        mRootDisplayArea.dumpDebug(proto, ROOT_DISPLAY_AREA, logLevel);

        proto.write(DPI, mBaseDisplayDensity);

        mDisplayInfo.dumpDebug(proto, DISPLAY_INFO);

        proto.write(ROTATION, getRotation());

        }

    }

    /**

     * Base class for any direct child window container of {@link #DisplayContent} need to inherit

     * from. This is mainly a pass through class that allows {@link #DisplayContent} to have

     * homogeneous children type which is currently required by sub-classes of

     * {@link WindowContainer} class.

     */

    static class DisplayChildWindowContainer<E extends WindowContainer> extends WindowContainer<E> {

        DisplayChildWindowContainer(WindowManagerService service) {

            super(service);

            // TODO(display-area): move to ConfigurationContainer?

            mOrientation = SCREEN_ORIENTATION_UNSET;

        }

        @Override

        boolean fillsParent() {

            return true;

        }

        @Override

        boolean isVisible() {

            return true;

        }

    }

    private class WindowContainers extends DisplayChildWindowContainer<WindowContainer> {

        private final String mName;

        WindowContainers(String name, WindowManagerService service) {

            super(service);

            mName = name;

        }

        @Override

        void assignChildLayers(SurfaceControl.Transaction t) {

            mImeWindowsContainers.setNeedsLayer();

            mRootDisplayArea.assignLayer(t, 0);

            final WindowState imeTarget = mInputMethodTarget;

            // In the case where we have an IME target that is not in split-screen mode IME

            // assignment is easy. We just need the IME to go directly above the target. This way

            // children of the target will naturally go above the IME and everyone is happy.

            //

            // In the case of split-screen windowing mode, we need to elevate the IME above the

            // docked divider while keeping the app itself below the docked divider, so instead

            // we use relative layering of the IME targets child windows, and place the IME in

            // the non-app layer (see {@link AboveAppWindowContainers#assignChildLayers}).

            //

            // In the case the IME target is animating, the animation Z order may be different

            // than the WindowContainer Z order, so it's difficult to be sure we have the correct

            // IME target. In this case we just layer the IME over all transitions by placing it

            // in the above applications layer.

            //

            // In the case where we have no IME target we assign it where its base layer would

            // place it in the AboveAppWindowContainers.

            //

            // Keep IME window in mAboveAppWindowsContainers as long as app's starting window

            // exists so it get's layered above the starting window.

            if (imeTarget != null && !(imeTarget.mActivityRecord != null

                    && imeTarget.mActivityRecord.hasStartingWindow()) && (

                    !(imeTarget.inMultiWindowMode()

                            || imeTarget.mToken.isAppTransitioning()) && (

                            imeTarget.getSurfaceControl() != null))) {

                mImeWindowsContainers.assignRelativeLayer(t, imeTarget.getSurfaceControl(),

                        // TODO: We need to use an extra level on the app surface to ensure

                        // this is always above SurfaceView but always below attached window.

                        1);

            }

            // Above we have assigned layers to our children, now we ask them to assign

            // layers to their children.

            mRootDisplayArea.assignChildLayers(t);

        }

        @Override

        String getName() {

            return mName;

        }

        void addChildren() {

            addChild(mRootDisplayArea, 0);

            mDisplayAreaPolicy.attachDisplayAreas();

        }

        @Override

        void positionChildAt(int position, WindowContainer child, boolean includingParents) {

            // Children of the WindowContainers are statically ordered, so the real intention here

            // is to perform the operation on the display and not the static direct children.

            getParent().positionChildAt(position, this, includingParents);

        }

    }

    /**

     * Container for IME windows.

     *

    @Override

    void assignChildLayers(SurfaceControl.Transaction t) {

        mWindowContainers.assignLayer(t, 0);

        mWindowContainers.assignChildLayers(t);

        mImeWindowsContainers.setNeedsLayer();

        final WindowState imeTarget = mInputMethodTarget;

        // In the case where we have an IME target that is not in split-screen mode IME

        // assignment is easy. We just need the IME to go directly above the target. This way

        // children of the target will naturally go above the IME and everyone is happy.

        //

        // In the case of split-screen windowing mode, we need to elevate the IME above the

        // docked divider while keeping the app itself below the docked divider, so instead

        // we use relative layering of the IME targets child windows, and place the IME in

        // the non-app layer (see {@link AboveAppWindowContainers#assignChildLayers}).

        //

        // In the case the IME target is animating, the animation Z order may be different

        // than the WindowContainer Z order, so it's difficult to be sure we have the correct

        // IME target. In this case we just layer the IME over all transitions by placing it

        // in the above applications layer.

        //

        // In the case where we have no IME target we assign it where its base layer would

        // place it in the AboveAppWindowContainers.

        //

        // Keep IME window in mAboveAppWindowsContainers as long as app's starting window

        // exists so it get's layered above the starting window.

        if (imeTarget != null && !(imeTarget.mActivityRecord != null

                && imeTarget.mActivityRecord.hasStartingWindow()) && (

                !(imeTarget.inMultiWindowMode()

                        || imeTarget.mToken.isAppTransitioning()) && (

                        imeTarget.getSurfaceControl() != null))) {

            mImeWindowsContainers.assignRelativeLayer(t, imeTarget.getSurfaceControl(),

                    // TODO: We need to use an extra level on the app surface to ensure

                    // this is always above SurfaceView but always below attached window.

                    1);

        }

        super.assignChildLayers(t);

    }

    /**

        }, false /* traverseTopToBottom */);

    }

    // TODO(b/156425461) Make DisplayContent the DisplayArea.Root

    @Override

    public SurfaceControl getSurfaceControl() {

        return mRootDisplayArea.getSurfaceControl();

    }

    private DisplayArea getWindowContainers() {

        List<DisplayArea<? extends WindowContainer>> windowContainers =

                mDisplayAreaPolicy.getDisplayAreas(FEATURE_WINDOWED_MAGNIFICATION);