ระบบการจัดการ SystemUIOverlayWindow

ระบบการจัดการ SystemUIOverlayWindow จัดเตรียมวิธีให้คุณแสดงและจัดการมุมมองใน SystemUIOverlayWindow ปัจจุบัน หน้าต่างนี้ใช้สำหรับมุมมองต่างๆ รวมถึงตัวสลับผู้ใช้แบบเต็มหน้าจอ แผงการแจ้งเตือน และคีย์การ์ด หน้านี้ไม่ได้:

• สร้างข้อจำกัดเกี่ยวกับสิ่งที่ OEM สามารถเพิ่มลงในหน้าต่างได้
• บังคับให้คุณใช้นามธรรมที่อธิบายไว้ในหน้านี้

ภาพรวม

คุณสามารถใช้ SystemUIOverlayWindow Management System เพื่อแสดงมุมมองต่างๆ เช่น ประกาศทางกฎหมาย ตัวสลับผู้ใช้แบบเต็มหน้าจอ กล้องมองหลัง ตัวควบคุม HVAC และคีย์การ์ด หน้าต่างนี้อยู่นอกพื้นที่แอป และให้คุณควบคุมลำดับ Z ของมุมมอง ทริกเกอร์แสดง/ซ่อน และการปรับแต่งโดยรวม รวมถึงตำแหน่ง มุมมอง ขนาด ความโปร่งใส และสี ในเวลาเดียวกัน คุณไม่จำเป็นต้องกังวลเกี่ยวกับสถานะของแถบระบบหรือออบเจ็กต์ System UI อื่นๆ ที่จำเป็นต้องซ่อนหรือแสดงเมื่อมุมมองที่เกี่ยวข้องถูกซ่อนหรือแสดง

เพื่อใช้ประโยชน์จาก SystemUIOverlayWindow คุณสร้างตัวควบคุมมุมมองสำหรับคุณดูสื่อกลาง ผู้ไกล่เกลี่ยจะถูกส่งไปยังตัวควบคุมสถานะส่วนกลางของหน้าต่าง ผู้ไกล่เกลี่ยมุมมองเหล่านี้:

• ประสานงานระหว่างตัวควบคุมมุมมอง
• ตรรกะทางธุรกิจของเฮาส์สำหรับตัวควบคุมมุมมอง

ดูตัวควบคุม (ประสานงานโดยผู้ไกล่เกลี่ยมุมมอง):

• เป็นเจ้าของมุมมอง
• สร้างตัวตั้งค่าที่ OverlayViewsMediator สามารถแนบตรรกะทางธุรกิจได้
• สร้างมุมมองที่เปิดเผยและปกปิดภาพเคลื่อนไหว

SystemUIOverlayWindow Manager ซึ่งเป็นส่วนประกอบของ SystemUI ทำหน้าที่เป็นจุดเริ่มต้นในการเริ่มต้นและลงทะเบียนผู้ไกล่เกลี่ยด้วยตัวควบคุมสถานะส่วนกลาง ในขณะที่ตัวควบคุมสถานะส่วนกลางเชื่อมโยงกับตัวควบคุมมุมมองในลักษณะที่ผู้ไกล่เกลี่ยสามารถเรียกตัวควบคุมมุมมองได้โดยตรงเพื่อแสดงและซ่อนมุมมองใน หน้าต่าง.

โอเวอร์เลย์วิวคอนโทรลเลอร์

OverlayViewController รับผิดชอบมุมมองที่แสดงใน SystemUIOverlayWindow และควบคุมวิธีการเปิดเผยและซ่อนมุมมอง นอกจากนี้ยังช่วยให้สามารถแนบผู้ฟังที่จำเป็นเพื่อให้สามารถเชื่อมโยงกับตรรกะทางธุรกิจได้

ลายเซ็นวิธีการที่สำคัญ

/**
 * Owns a {@link View} that is present in SystemUIOverlayWindow.
 */
public class OverlayViewController {

    /**
     * Shows content of {@link OverlayViewController}.
     *
     * Should be used to show view externally and in particular by {@link OverlayViewMediator}.
     */
    public final void start();

    /**
     * Hides content of {@link OverlayViewController}.
     *
     * Should be used to hide view externally and in particular by {@link OverlayViewMediator}.
     */
    public final void stop();

    /**
     * Inflate layout owned by controller.
     */
    public final void inflate(ViewGroup baseLayout);

    /**
     * Called once inflate finishes.
     */
    protected void onFinishInflate();

    /**
     * Returns {@code true} if layout owned by controller has been inflated.
     */
    public final boolean isInflated();

    /**
     * Subclasses should override this method to implement reveal animations and implement logic
     * specific to when the layout owned by the controller is shown.
     *
     * Should only be overridden by Superclass but not called by any {@link OverlayViewMediator}.
     */
    protected void showInternal();

    /**
     * Subclasses should override this method to implement conceal animations and implement logic
     * specific to when the layout owned by the controller is hidden.
     *
     * Should only be overridden by Superclass but not called by any {@link OverlayViewMediator}.
     */
    protected void hideInternal();

    /**
     * Provides access to layout owned by controller.
     */
    protected final View getLayout();

    /** Returns the {@link OverlayViewGlobalStateController}. */
    protected final OverlayViewGlobalStateController getOverlayViewGlobalStateController();

    /** Returns whether the view controlled by this controller is visible. */
    public final boolean isVisible();

    /**
     * Returns the ID of the focus area that should receive focus when this view is the
     * topmost view or {@link View#NO_ID} if there is no focus area.
     */
    @IdRes
    protected int getFocusAreaViewId();

    /** Returns whether the view controlled by this controller has rotary focus. */
    protected final boolean hasRotaryFocus();

    /**
     * Sets whether this view allows rotary focus. This should be set to {@code true} for the
     * topmost layer in the overlay window and {@code false} for the others.
     */
    public void setAllowRotaryFocus(boolean allowRotaryFocus);

    /**
     * Refreshes the rotary focus in this view if we are in rotary mode. If the view already has
     * rotary focus, it leaves the focus alone. Returns {@code true} if a new view was focused.
     */
    public boolean refreshRotaryFocusIfNeeded();

    /**
     * Returns {@code true} if heads up notifications should be displayed over this view.
     */
    protected boolean shouldShowHUN();

    /**
     * Returns {@code true} if navigation bar insets should be displayed over this view. Has no
     * effect if {@link #shouldFocusWindow} returns {@code false}.
     */
    protected boolean shouldShowNavigationBarInsets();

    /**
     * Returns {@code true} if status bar insets should be displayed over this view. Has no
     * effect if {@link #shouldFocusWindow} returns {@code false}.
     */
    protected boolean shouldShowStatusBarInsets();

    /**
     * Returns {@code true} if this view should be hidden during the occluded state.
     */
    protected boolean shouldShowWhenOccluded();

    /**
     * Returns {@code true} if the window should be focued when this view is visible. Note that
     * returning {@code false} here means that {@link #shouldShowStatusBarInsets} and
     * {@link #shouldShowNavigationBarInsets} will have no effect.
     */
    protected boolean shouldFocusWindow();

    /**
     * Returns {@code true} if the window should use stable insets. Using stable insets means that
     * even when system bars are temporarily not visible, inset from the system bars will still be
     * applied.
     *
     * NOTE: When system bars are hidden in transient mode, insets from them will not be applied
     * even when the system bars become visible. Setting the return value to {@true} here can
     * prevent the OverlayView from overlapping with the system bars when that happens.
     */
    protected boolean shouldUseStableInsets();

    /**
     * Returns the insets types to fit to the sysui overlay window when this
     * {@link OverlayViewController} is in the foreground.
     */
    @WindowInsets.Type.InsetsType
    protected int getInsetTypesToFit();

    /**
     * Optionally returns the sides of enabled system bar insets to fit to the sysui overlay window
     * when this {@link OverlayViewController} is in the foreground.
     *
     * For example, if the bottom and left system bars are enabled and this method returns
     * WindowInsets.Side.LEFT, then the inset from the bottom system bar will be ignored.
     *
     * NOTE: By default, this method returns {@link #INVALID_INSET_SIDE}, so insets to fit are
     * defined by {@link #getInsetTypesToFit()}, and not by this method, unless it is overridden
     * by subclasses.
     *
     * NOTE: {@link #NO_INSET_SIDE} signifies no insets from any system bars will be honored. Each
     * {@link OverlayViewController} can first take this value and add sides of the system bar
     * insets to honor to it.
     *
     * NOTE: If getInsetSidesToFit is overridden to return {@link WindowInsets.Side}, it always
     * takes precedence over {@link #getInsetTypesToFit()}. That is, the return value of {@link
     * #getInsetTypesToFit()} will be ignored.
     */
    @WindowInsets.Side.InsetsSide
    protected int getInsetSidesToFit();
}

โอเวอร์เลย์พาเนลวิวคอนโทรลเลอร์

คอนโทรลเลอร์ OverlayPanelViewController ขยาย OverlayViewController และมอบความสามารถเพิ่มเติมในการลากภาพเคลื่อนไหวให้กับซูเปอร์คลาส

OverlayViewMediator

OverlayViewMediator เป็นที่เก็บตรรกะทางธุรกิจที่แสดงหรือซ่อนอินสแตนซ์ OverlayViewController หลายรายการ ดังนั้นในลักษณะที่ยังจัดการการประสานงานระหว่างตัวควบคุมมุมมองด้วย

/**
 * Controls when to show and hide {@link OverlayViewController}(s).
 */
public interface OverlayViewMediator {

    /**
     * Register listeners that could use ContentVisibilityAdjuster to show/hide content.
     *
     * Note that we do not unregister listeners because SystemUI components are expected to live
     * for the lifecycle of the device.
     */
    void registerListeners();

    /**
     * Allows for post-inflation callbacks and listeners to be set inside required {@link
     * OverlayViewController}(s).
     */
    void setupOverlayContentViewControllers();
}

SystemUIOverlayWindowManager

SystemUIOverlayWindowManager มีหน้าที่รับผิดชอบในการเป็นอ็อบเจ็กต์ SystemUI ที่ทำหน้าที่เป็นจุดเริ่มต้นสำหรับ SystemUIOverlayWindow Management System เพื่อเริ่มต้นและลงทะเบียนอินสแตนซ์ OverlayViewMediator ด้วย OverlayViewGlobalStateController

OverlayViewGlobalStateController

OverlayViewGlobalStateController รับสายจากอินสแตนซ์ OverlayViewController เพื่อเปิดเผยหรือปกปิดตัวเอง ดังนั้นจึงยังคงรักษาสถานะของสิ่งที่แสดงหรือซ่อนไว้ใน SystemUIOverlayWindow

โฟลว์มุมมองการแสดงมีภาพประกอบด้านล่าง:

ซ่อนโฟลว์การดู

โฟลว์การซ่อนมุมมองแสดงไว้ด้านล่าง:

ลายเซ็นวิธีการสาธารณะ

ลายเซ็นวิธีการสาธารณะได้รับการเข้ารหัสดังนี้:

​/**
 * This controller is responsible for the following:
 * <p><ul>
 * <li>Holds the global state for SystemUIOverlayWindow.
 * <li>Allows {@link SystemUIOverlayWindowManager} to register {@link OverlayViewMediator}(s).
 * <li>Enables {@link OverlayViewController)(s) to reveal/conceal themselves while respecting the
 * global state of SystemUIOverlayWindow.
 * </ul>
 */
@SysUISingleton
public class OverlayViewGlobalStateController {
    /**
     * Register {@link OverlayViewMediator} to use in SystemUIOverlayWindow.
     */
    public void registerMediator(OverlayViewMediator overlayViewMediator);

    /**
     * Show content in Overlay Window using {@link OverlayPanelViewController}.
     *
     * This calls {@link OverlayViewGlobalStateController#showView(OverlayViewController, Runnable)}
     * where the runnable is nullified since the actual showing of the panel is handled by the
     * controller itself.
     */
    public void showView(OverlayPanelViewController panelViewController);

    /**
     * Show content in Overlay Window using {@link OverlayViewController}.
     */
    public void showView(OverlayViewController viewController, @Nullable Runnable show);

    /**
     * Hide content in Overlay Window using {@link OverlayPanelViewController}.
     *
     * This calls {@link OverlayViewGlobalStateController#hideView(OverlayViewController, Runnable)}
     * where the runnable is nullified since the actual hiding of the panel is handled by the
     * controller itself.
     */
    public void hideView(OverlayPanelViewController panelViewController);

    /**
     * Hide content in Overlay Window using {@link OverlayViewController}.
     */
    public void hideView(OverlayViewController viewController, @Nullable Runnable hide);

    /** Returns {@code true} is the window is visible. */
    public boolean isWindowVisible();

    /**
     * Sets the {@link android.view.WindowManager.LayoutParams#FLAG_ALT_FOCUSABLE_IM} flag of the
     * sysui overlay window.
     */
    public void setWindowNeedsInput(boolean needsInput);

    /** Returns {@code true} if the window is focusable. */
    public boolean isWindowFocusable();

    /** Sets the focusable flag of the sysui overlawy window. */
    public void setWindowFocusable(boolean focusable);

    /** Inflates the view controlled by the given view controller. */
    public void inflateView(OverlayViewController viewController);

    /**
     * Return {@code true} if OverlayWindow is in a state where HUNs should be displayed above it.
     */
    public boolean shouldShowHUN();

    /**
     * Set the OverlayViewWindow to be in occluded or unoccluded state. When OverlayViewWindow is
     * occluded, all views mounted to it that are not configured to be shown during occlusion will
     * be hidden.
     */
    public void setOccluded(boolean occluded);
}

วิธีเพิ่มมุมมองให้กับ SysUIOverlayWindow

สำหรับรายละเอียด โปรดดูที่ Codelab

ขั้นตอนที่ 1: เพิ่ม ViewStub ไปยัง SysUIOverlayWindow

เพิ่ม ViewStub ให้กับ โครงร่างหน้าต่าง

ขั้นตอนที่ 2: สร้าง OverlayViewController

ใช้ ViewStub ใหม่เพื่อสร้าง OverlayViewController แบบฉีดได้ใหม่

ขั้นตอนที่ 3: OverlayViewMediator

สร้าง OverlayViewMediator แบบฉีดใหม่หรือใช้อันที่มีอยู่ (ข้ามขั้นตอนที่ 4) และลงทะเบียน Listener เพื่อซ่อนหรือแสดง OverlayViewController ใหม่

ขั้นตอนที่ 4: กำหนดค่า OverlayViewMediator ใหม่

เพิ่ม OverlayViewMediator ใหม่ของคุณไปที่ OverlayWindowModule และ config_carSystemUIOverlayViewsMediator

คำเตือน

เมื่อ SysUIPrimaryWindow ครอบคลุมทั้งหน้าจอ องค์ประกอบใดๆ ใต้หน้าต่างจะไม่บันทึกเหตุการณ์การสัมผัส ดังนั้น เมื่อหน้าต่างครอบคลุมทั้งหน้าจอแต่เนื้อหาเหลือพื้นที่เชิงลบ คุณสามารถเลือกที่จะเบลอพื้นที่เชิงลบและแนบผู้ฟังไปยังพื้นที่นั้นเพื่อปิดเนื้อหาในหน้าต่างได้