Le système de gestion SystemUIOverlayWindow
vous permet d'afficher et
gérer les vues dans SystemUIOverlayWindow
. Actuellement, cette fenêtre est utilisée pour les vues
y compris le sélecteur d'utilisateur en plein écran, le panneau de notifications et le verrouillage du clavier. Cette page ne:
- Créez des restrictions sur ce que l'OEM peut ajouter à la fenêtre.
- vous obliger à adopter les abstractions décrites sur cette page ;
Présentation
Vous pouvez utiliser le système de gestion SystemUIOverlayWindow
pour afficher des vues telles que le
mentions légales, sélecteur d'utilisateur en plein écran, caméra arrière, commandes du système CVC et verrouillage du clavier. Ce
se situe en dehors de l'espace de l'application et vous permet de contrôler l'ordre de plan de la vue,
les déclencheurs d'affichage/masquage et les personnalisations globales, y compris l'emplacement, la taille, la transparence et
et la couleur. En même temps, vous n'avez pas besoin de vous préoccuper de l'état des barres système ou d'autres
Objets d'UI du système qui doivent être masqués ou affichés lorsque leur vue respective est masquée ou affichée.
Pour tirer parti de SystemUIOverlayWindow
, vous devez créer des contrôleurs de vue pour vos vues
médiateurs. Les médiateurs sont transmis au contrôleur d'état global de la fenêtre. Voici les médiateurs des vues:
- Coordonnez les actions entre les contrôleurs de vue.
- Intégrez la logique métier pour les contrôleurs de vue.
Contrôleurs de vue (coordonnés par des médiateurs de vues):
- Prenez le contrôle de son environnement.
- Créez des setters via lesquels
OverlayViewsMediator
peut associer une logique métier. - Créer l'animation d'affichage et de masquage de sa vue
SystemUIOverlayWindow
Manager, un composant SystemUI,sert de point d'entrée pour
initialiser et enregistrer les médiateurs avec le contrôleur d'état global, tandis que le contrôleur d'état global
est lié aux contrôleurs de vue de manière à ce que les médiateurs puissent les appeler directement.
pour afficher et masquer
des vues dans la fenêtre.
Contrôleur d'affichage de la superposition
OverlayViewController
est responsable de la vue affichée dans SystemUIOverlayWindow
et contrôle la façon dont elle est
révélées et
cachées. Il permet également d'associer les écouteurs requis afin qu'ils puissent être liés
à la logique métier.
Signatures de méthodes importantes
/**
* 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
Le contrôleur OverlayPanelViewController
étend OverlayViewController
et fournit des fonctionnalités d'animation de déplacement supplémentaires à sa super-classe.
OverlayViewMediator
OverlayViewMediator
contient la logique métier qui révèle ou masque
plusieurs instances OverlayViewController
. Par conséquent, il gère également
la coordination entre les contrôleurs de vue.
/** * 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
est responsable d'être l'objet SystemUI qui sert de point d'entrée pour le
le système de gestion SystemUIOverlayWindow
pour initialiser et enregistrer
Instances OverlayViewMediator
avec OverlayViewGlobalStateController
.
![Afficher le flux de la vue](https://source.android.google.cn/static/docs/automotive/images/sysui_system_01.png?authuser=5&hl=fr)
OverlayViewGlobalStateController
OverlayViewGlobalStateController
reçoit les appels de
OverlayViewController
pour être révélés ou dissimulés. Par conséquent, il est également
contient l'état de ce qui est affiché ou masqué dans SystemUIOverlayWindow
.
Le flux d'affichage de la vue est illustré ci-dessous:
![Afficher le flux d'affichage](https://source.android.google.cn/static/docs/automotive/images/sysui_system_02.png?authuser=5&hl=fr)
Masquer le flux d'affichage
Le flux de masquage de la vue est illustré ci-dessous:
![Masquer le flux d'affichage](https://source.android.google.cn/static/docs/automotive/images/sysui_system_03.png?authuser=5&hl=fr)
Signatures de méthode publique
Les signatures de méthode publique sont encodées comme suit:
/**
* 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);
}
Ajouter une vue à SysUIOverlayWindow
Pour en savoir plus, reportez-vous à l'atelier de programmation.
Étape 1: Ajouter un ViewStub à SysUIOverlayWindow
Ajouter ViewStub
vers
mise en page des fenêtres.
Étape 2: Créer un OverlayViewController
Utilisez le nouveau ViewStub
pour créer un objet injectable
OverlayViewController
Étape 3: OverlayViewMediator
Créer un injectable
OverlayViewMediator
ou en utiliser un existant (ignorer l'étape 4) et enregistrer des écouteurs pour masquer ou afficher le nouveau
OverlayViewController
Étape 4: Configurer le nouveau OverlayViewMediator
Ajoutez votre nouveau OverlayViewMediator
à
OverlayWindowModule
et à
config_carSystemUIOverlayViewsMediator
Mises en garde
Lorsque SysUIPrimaryWindow
couvre l'intégralité de l'écran, tous les éléments situés sous la fenêtre
n'enregistrent pas d'événements tactiles. Ainsi, lorsque la fenêtre couvre la totalité de l'écran, mais que son contenu
laisser un espace négatif, vous pouvez choisir
de le flouter et de joindre des écouteurs
cet espace pour fermer
le contenu de la fenêtre.