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

Commit 828ff7e3 authored by Wale Ogunwale's avatar Wale Ogunwale
Browse files

Support insets on secondary displays 

Indroduced DisplayFrames object to track frames used to calculate
window insets per display vs. at a global level in PhoneWindowManager.

Bug: 64148922
Change-Id: I19f166920eba0a4f933a223a77e096bcc8dab0c1
Test: bit FrameworksServicesTests:com.android.server.wm.ScreenDecorWindowTests
Test: go/wm-smoke
parent 7bb06e01

api/current.txt

+1 −0
Original line number Diff line number Diff line
@@ -4943,6 +4943,7 @@ package android.app { 
    method public void setInTouchMode(boolean);

    method public void start();

    method public android.app.Activity startActivitySync(android.content.Intent);

    method public android.app.Activity startActivitySync(android.content.Intent, android.os.Bundle);

    method public deprecated void startAllocCounting();

    method public void startPerformanceSnapshot();

    method public void startProfiling();

api/system-current.txt

+1 −0
Original line number Diff line number Diff line
@@ -5129,6 +5129,7 @@ package android.app { 
    method public void setInTouchMode(boolean);

    method public void start();

    method public android.app.Activity startActivitySync(android.content.Intent);

    method public android.app.Activity startActivitySync(android.content.Intent, android.os.Bundle);

    method public deprecated void startAllocCounting();

    method public void startPerformanceSnapshot();

    method public void startProfiling();

api/test-current.txt

+1 −0
Original line number Diff line number Diff line
@@ -4972,6 +4972,7 @@ package android.app { 
    method public void setInTouchMode(boolean);

    method public void start();

    method public android.app.Activity startActivitySync(android.content.Intent);

    method public android.app.Activity startActivitySync(android.content.Intent, android.os.Bundle);

    method public deprecated void startAllocCounting();

    method public void startPerformanceSnapshot();

    method public void startProfiling();

core/java/android/app/Instrumentation.java

+37 −7
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
package android.app;



import android.annotation.IntDef;

import android.annotation.Nullable;

import android.content.ActivityNotFoundException;

import android.content.ComponentName;

import android.content.Context;
@@ -427,8 +428,37 @@ public class Instrumentation { 
     * @param intent Description of the activity to start.

     *

     * @see Context#startActivity

     * @see #startActivitySync(Intent, Bundle)

     */

    public Activity startActivitySync(Intent intent) {

        return startActivitySync(intent, null /* options */);

    }



    /**

     * Start a new activity and wait for it to begin running before returning.

     * In addition to being synchronous, this method as some semantic

     * differences from the standard {@link Context#startActivity} call: the

     * activity component is resolved before talking with the activity manager

     * (its class name is specified in the Intent that this method ultimately

     * starts), and it does not allow you to start activities that run in a

     * different process.  In addition, if the given Intent resolves to

     * multiple activities, instead of displaying a dialog for the user to

     * select an activity, an exception will be thrown.

     *

     * <p>The function returns as soon as the activity goes idle following the

     * call to its {@link Activity#onCreate}.  Generally this means it has gone

     * through the full initialization including {@link Activity#onResume} and

     * drawn and displayed its initial window.

     *

     * @param intent Description of the activity to start.

     * @param options Additional options for how the Activity should be started.

     * May be null if there are no options.  See {@link android.app.ActivityOptions}

     * for how to build the Bundle supplied here; there are no supported definitions

     * for building it manually.

     *

     * @see Context#startActivity(Intent, Bundle)

     */

    public Activity startActivitySync(Intent intent, @Nullable Bundle options) {

        validateNotAppThread();



        synchronized (mSync) {
@@ -457,7 +487,7 @@ public class Instrumentation { 
            }

            mWaitingActivities.add(aw);



            getTargetContext().startActivity(intent);

            getTargetContext().startActivity(intent, options);



            do {

                try {

core/java/android/view/DisplayFrames.java

0 → 100644
+189 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License

 */



package android.view;



import static android.view.Surface.ROTATION_180;

import static android.view.Surface.ROTATION_270;

import static android.view.Surface.ROTATION_90;

import static com.android.server.wm.proto.DisplayFramesProto.STABLE_BOUNDS;



import android.graphics.Rect;

import android.util.proto.ProtoOutputStream;



import java.io.PrintWriter;



/**

 * Container class for all the display frames that affect how we do window layout on a display.

 * @hide

 */

public class DisplayFrames {

    public final int mDisplayId;



    /**

     * The current size of the screen; really; extends into the overscan area of the screen and

     * doesn't account for any system elements like the status bar.

     */

    public final Rect mOverscan = new Rect();



    /**

     * The current visible size of the screen; really; (ir)regardless of whether the status bar can

     * be hidden but not extending into the overscan area.

     */

    public final Rect mUnrestricted = new Rect();



    /** Like mOverscan*, but allowed to move into the overscan region where appropriate. */

    public final Rect mRestrictedOverscan = new Rect();



    /**

     * The current size of the screen; these may be different than (0,0)-(dw,dh) if the status bar

     * can't be hidden; in that case it effectively carves out that area of the display from all

     * other windows.

     */

    public final Rect mRestricted = new Rect();



    /**

     * During layout, the current screen borders accounting for any currently visible system UI

     * elements.

     */

    public final Rect mSystem = new Rect();



    /** For applications requesting stable content insets, these are them. */

    public final Rect mStable = new Rect();



    /**

     * For applications requesting stable content insets but have also set the fullscreen window

     * flag, these are the stable dimensions without the status bar.

     */

    public final Rect mStableFullscreen = new Rect();



    /**

     * During layout, the current screen borders with all outer decoration (status bar, input method

     * dock) accounted for.

     */

    public final Rect mCurrent = new Rect();



    /**

     * During layout, the frame in which content should be displayed to the user, accounting for all

     * screen decoration except for any space they deem as available for other content. This is

     * usually the same as mCurrent*, but may be larger if the screen decor has supplied content

     * insets.

     */

    public final Rect mContent = new Rect();



    /**

     * During layout, the frame in which voice content should be displayed to the user, accounting

     * for all screen decoration except for any space they deem as available for other content.

     */

    public final Rect mVoiceContent = new Rect();



    /** During layout, the current screen borders along which input method windows are placed. */

    public final Rect mDock = new Rect();



    private final Rect mDisplayInfoOverscan = new Rect();

    private final Rect mRotatedDisplayInfoOverscan = new Rect();

    public int mDisplayWidth;

    public int mDisplayHeight;



    public int mRotation;



    public DisplayFrames(int displayId, DisplayInfo info) {

        mDisplayId = displayId;

        onDisplayInfoUpdated(info);

    }



    public void onDisplayInfoUpdated(DisplayInfo info) {

        mDisplayWidth = info.logicalWidth;

        mDisplayHeight = info.logicalHeight;

        mRotation = info.rotation;

        mDisplayInfoOverscan.set(

                info.overscanLeft, info.overscanTop, info.overscanRight, info.overscanBottom);

    }



    public void onBeginLayout() {

        switch (mRotation) {

            case ROTATION_90:

                mRotatedDisplayInfoOverscan.left = mDisplayInfoOverscan.top;

                mRotatedDisplayInfoOverscan.top = mDisplayInfoOverscan.right;

                mRotatedDisplayInfoOverscan.right = mDisplayInfoOverscan.bottom;

                mRotatedDisplayInfoOverscan.bottom = mDisplayInfoOverscan.left;

                break;

            case ROTATION_180:

                mRotatedDisplayInfoOverscan.left = mDisplayInfoOverscan.right;

                mRotatedDisplayInfoOverscan.top = mDisplayInfoOverscan.bottom;

                mRotatedDisplayInfoOverscan.right = mDisplayInfoOverscan.left;

                mRotatedDisplayInfoOverscan.bottom = mDisplayInfoOverscan.top;

                break;

            case ROTATION_270:

                mRotatedDisplayInfoOverscan.left = mDisplayInfoOverscan.bottom;

                mRotatedDisplayInfoOverscan.top = mDisplayInfoOverscan.left;

                mRotatedDisplayInfoOverscan.right = mDisplayInfoOverscan.top;

                mRotatedDisplayInfoOverscan.bottom = mDisplayInfoOverscan.right;

                break;

            default:

                mRotatedDisplayInfoOverscan.set(mDisplayInfoOverscan);

                break;

        }



        mRestrictedOverscan.set(0, 0, mDisplayWidth, mDisplayHeight);

        mOverscan.set(mRestrictedOverscan);

        mSystem.set(mRestrictedOverscan);

        mUnrestricted.set(mRotatedDisplayInfoOverscan);

        mUnrestricted.right = mDisplayWidth - mUnrestricted.right;

        mUnrestricted.bottom = mDisplayHeight - mUnrestricted.bottom;

        mRestricted.set(mUnrestricted);

        mDock.set(mUnrestricted);

        mContent.set(mUnrestricted);

        mVoiceContent.set(mUnrestricted);

        mStable.set(mUnrestricted);

        mStableFullscreen.set(mUnrestricted);

        mCurrent.set(mUnrestricted);



    }



    public int getInputMethodWindowVisibleHeight() {

        return mDock.bottom - mCurrent.bottom;

    }



    public void writeToProto(ProtoOutputStream proto, long fieldId) {

        final long token = proto.start(fieldId);

        mStable.writeToProto(proto, STABLE_BOUNDS);

        proto.end(token);

    }



    public void dump(String prefix, PrintWriter pw) {

        pw.println(prefix + "DisplayFrames w=" + mDisplayWidth + " h=" + mDisplayHeight

                + " r=" + mRotation);

        final String myPrefix = prefix + "  ";

        dumpFrame(mStable, "mStable", myPrefix, pw);

        dumpFrame(mStableFullscreen, "mStableFullscreen", myPrefix, pw);

        dumpFrame(mDock, "mDock", myPrefix, pw);

        dumpFrame(mCurrent, "mCurrent", myPrefix, pw);

        dumpFrame(mSystem, "mSystem", myPrefix, pw);

        dumpFrame(mContent, "mContent", myPrefix, pw);

        dumpFrame(mVoiceContent, "mVoiceContent", myPrefix, pw);

        dumpFrame(mOverscan, "mOverscan", myPrefix, pw);

        dumpFrame(mRestrictedOverscan, "mRestrictedOverscan", myPrefix, pw);

        dumpFrame(mRestricted, "mRestricted", myPrefix, pw);

        dumpFrame(mUnrestricted, "mUnrestricted", myPrefix, pw);

        dumpFrame(mDisplayInfoOverscan, "mDisplayInfoOverscan", myPrefix, pw);

        dumpFrame(mRotatedDisplayInfoOverscan, "mRotatedDisplayInfoOverscan", myPrefix, pw);

    }



    private void dumpFrame(Rect frame, String name, String prefix, PrintWriter pw) {

        pw.print(prefix + name + "="); frame.printShortString(pw); pw.println();

    }

}