Le mode multifenêtre permet à plusieurs applications de partager le même écran simultanément. Les applications peuvent se trouver côte à côte ou l'une au-dessus de l'autre (mode Écran partagé), l'une dans l'autre une petite fenêtre superposée à d'autres applications (mode Picture-in-picture) ou applications dans des fenêtres redimensionnables et mobiles séparées (mode Format libre).
<ph type="x-smartling-placeholder">L'expérience utilisateur dépend de la version d'Android et du type d'appareil:
Android 7.0 (niveau d'API 24) introduit le mode Écran partagé sur les petits écrans. et le mode Picture-in-picture sur certains d'entre eux.
Le mode Écran partagé remplit l'écran avec deux applications qui s'affichent. côte à côte ou l'un au-dessus de l'autre. Les utilisateurs peuvent faire glisser le séparateur séparer les deux applications pour agrandir une application et réduire l'autre.
Le mode Picture-in-picture permet aux utilisateurs de poursuivre la lecture de la vidéo. lorsque vous interagissez avec une autre application (voir la section Compatibilité Picture-in-picture).
Le mode Format libre, dans lequel les utilisateurs peuvent redimensionner librement chaque activité, peuvent être activées par les fabricants d'appareils à grand écran.
Vous pouvez configurer la manière dont votre application gère le mode multifenêtre en spécifiant les dimensions minimales autorisées de votre activité. Vous pouvez également désactiver mode multifenêtre pour votre application en définissant
resizeabableActivity="false"
pour garantir que le système affiche toujours votre application en plein écran.
Android 8.0 (niveau d'API 26) étend le mode Picture-in-picture aux petits appareils dotés d'un écran.
Android 12 (niveau d'API 31) rend le mode multifenêtre standard.
Sur les grands écrans (classe de taille de fenêtre moyenne ou grande), la plate-forme est compatible avec toutes les applications en mode multifenêtre, quelle que soit l'application. configuration. Si la valeur est
resizeableActivity="false"
, l'application est placée dans mode de compatibilité lorsque cela est nécessaire pour s'adapter aux dimensions de l'écran.Sur les petits écrans (classe de taille de fenêtre compact), le système vérifie
minWidth
etminHeight
d'une activité pour déterminer l'activité peut s'exécuter en mode multifenêtre. SiresizeableActivity="false"
, l'application ne peut pas s'exécuter dans mode multifenêtre indépendamment de la largeur et de la hauteur minimales.
Mode Écran partagé
Les utilisateurs peuvent activer le mode Écran partagé en procédant comme suit :
- Ouvrez l'écran "Récents".
- Faites glisser une application pour l'afficher.
- Appuyez sur l'icône de l'application dans la barre de titre.
- Sélectionnez l'option "Écran partagé" dans le menu.
- Sélectionnez une autre application à partir de l'écran "Applications récentes", ou fermez l'écran "Applications récentes" et exécuter une autre application
Les utilisateurs peuvent quitter le mode Écran partagé en faisant glisser le séparateur de fenêtre vers le bord de l'écran (vers le haut ou vers le bas, vers la gauche ou vers la droite).
Lancer dans une fenêtre adjacente
Si votre application a besoin d'accéder au contenu via un intent, vous pouvez utiliser
FLAG_ACTIVITY_LAUNCH_ADJACENT
pour ouvrir le contenu dans un
une fenêtre d'écran partagé.
FLAG_ACTIVITY_LAUNCH_ADJACENT
a été introduit dans Android 7.0 (niveau d'API 24) pour
autoriser les applications exécutées en mode Écran partagé à lancer des activités dans l'environnement adjacent
fenêtre.
Android 12L (niveau d'API 32) ou version ultérieure a étendu la définition de l'indicateur à autoriser les applications s'exécutant en plein écran à activer le mode Écran partagé, puis à lancer dans la fenêtre adjacente.
Pour lancer une activité adjacente, utilisez FLAG_ACTIVITY_LAUNCH_ADJACENT
dans
conjointement avec FLAG_ACTIVITY_NEW_TASK
. Par exemple:
Kotlin
fun openUrlInAdjacentWindow(url: String) { Intent(Intent.ACTION_VIEW).apply { data = Uri.parse(url) addFlags(Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT or Intent.FLAG_ACTIVITY_NEW_TASK) }.also { intent -> startActivity(intent) } }
Java
public void openUrlInAdjacentWindow(String url) { Intent intent = new Intent(Intent.ACTION_VIEW); intent.setData(Uri.parse(url)); intent.addFlags(Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT | Intent.FLAG_ACTIVITY_NEW_TASK); startActivity(intent); }
Cycle de vie d'une activité en mode multifenêtre
Le mode multifenêtre ne modifie pas le cycle de vie de l'activité. Toutefois, l'état de reprise des applications dans plusieurs fenêtres varie selon les versions de Android
Multireprise
Android 10 (niveau d'API 29) ou version ultérieure est compatible avec la multireprise,
les activités restent à l'état RESUMED
lorsque l'appareil est en mode multifenêtre
. Une activité peut être mise en pause si une activité transparente se superpose à la
ou si l'activité n'est pas sélectionnable (par exemple, si l'activité est dans
mode Picture-in-picture. Il est également possible qu'aucune activité ne soit ciblée à un
un certain temps, par exemple, si le panneau des notifications est ouvert. onStop()
fonctionne normalement: elle est appelée chaque fois qu'une activité est supprimée.
l'écran.
Le multireprise est également disponible sur certains appareils équipés d'Android 9 (niveau d'API 28). Pour activer la multireprise sur les appareils Android 9, ajoutez les métadonnées de fichier manifeste suivantes :
<meta-data android:name="android.allow_multiple_resumed_activities" android:value="true" />
Pour vérifier qu'un appareil donné est compatible avec ces métadonnées du fichier manifeste, reportez-vous aux spécifications de l'appareil.
Android 9
En mode multifenêtre sur Android 9 (niveau d'API 28) ou une version antérieure, seule l'activité avec laquelle l'utilisateur a interagi le plus récemment est active à un moment donné. Ce
l'activité est considérée comme la plus élevée et est la seule de la RESUMED
state. Toutes les autres activités visibles sont STARTED
, mais pas RESUMED
.
Cependant, le système attribue à ces activités visibles, mais pas réactivées, des performances supérieures
par rapport aux activités non visibles. Si l'utilisateur interagit avec l'une des
les activités visibles, l'activité reprend et l'activité la plus élevée
l'activité passe à l'état STARTED
.
Lorsqu'il y a plusieurs activités au sein d'un même processus applicatif actif, l'activité dont l'ordre de priorité est le plus élevé est reprise et les autres sont mises en veille.
Modifications de configuration
Lorsque l'utilisateur passe une application en mode multifenêtre, le système en informe activité d'une modification de configuration, comme spécifié dans la section Gérer la configuration modifications. Cela se produit également lorsque l'utilisateur redimensionne ou rétablit l'application. en mode plein écran.
Ce changement a les mêmes conséquences sur le cycle de vie de l'activité que lorsque le système avertit l'application que l'appareil est passé du mode portrait à l'orientation paysage, sauf que les dimensions de l'application sont modifiées au lieu tout simplement en cours d'échange. Votre activité peut gérer elle-même le changement de configuration. votre application peut autoriser le système à détruire l'activité et à la recréer à l'aide du de nouvelles dimensions.
Si l'utilisateur redimensionne une fenêtre et l'agrandit dans l'une ou l'autre dimension, le système redimensionne l'activité pour qu'elle corresponde à l'action utilisateur et modifie la configuration si nécessaire. Si l'application prend du retard dans le dessin dans les zones nouvellement exposées,
remplit temporairement ces zones avec la couleur spécifiée par le paramètre
windowBackground
ou par défaut
Attribut de style windowBackgroundFallback
.
Accès exclusif aux ressources
Pour prendre en charge la fonctionnalité de multireprise, utilisez la
Rappel de cycle de vie de onTopResumedActivityChanged()
Le rappel est invoqué lorsqu'une activité gagne ou perd la première activité réactivée. ce qui est important lorsqu'une activité utilise une ressource Singleton partagée comme le micro ou la caméra:
Kotlin
override fun onTopResumedActivityChanged(topResumed: Boolean) { if (topResumed) { // Top resumed activity. // Can be a signal to re-acquire exclusive resources. } else { // No longer the top resumed activity. } }
Java
@Override public void onTopResumedActivityChanged(boolean topResumed) { if (topResumed) { // Top resumed activity. // Can be a signal to re-acquire exclusive resources. } else { // No longer the top resumed activity. } }
Notez qu'une application peut perdre des ressources pour d'autres raisons, par exemple la suppression d'un équipement matériel.
Dans tous les cas, une application doit gérer de manière optimale les événements et les changements d'état qui affectent les ressources disponibles.
Pour les applications qui utilisent un appareil photo,
CameraManager.AvailabilityCallback#onCameraAccessPrioritiesChanged()
indique qu'il peut être judicieux d'essayer d'accéder à la caméra.
Cette méthode est disponible à partir d'Android 10 (niveau d'API 29).
N'oubliez pas que resizeableActivity=false
ne garantit pas l'exclusivité de la caméra.
car les autres applications qui utilisent l'appareil photo peuvent être ouvertes sur d'autres écrans.
![](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/multi-window-mode/camera.png?authuser=5&hl=fr)
Votre application n'a pas besoin de libérer l'appareil photo lorsqu'elle n'est plus au premier plan. Par exemple, vous pouvez poursuivre l'aperçu de l'appareil photo pendant que l'utilisateur interagit. avec l'application récemment réactivée qui vient d'être sélectionnée. Votre application peut donc conserver l'appareil photo lorsqu'il ne s'agit pas de l'application la plus réactivée, mais qu'il doit gérer correctement l'étui. Lorsque l'application la plus réactivée souhaite utiliser la caméra, il peut l'ouvrir, et votre application n'y aura plus accès. Votre application peut rouvrir le lorsque l'application récupère la mise au point.
Une fois qu'une application reçoit une CameraDevice.StateCallback#onDisconnected()
les appels ultérieurs effectués sur l'appareil photo génèrent une
CameraAccessException
.
Multi-écran
Android 10 (niveau d'API 29) accepte les activités sur les écrans secondaires. Si une activité est exécutée sur un appareil avec plusieurs écrans, les utilisateurs peuvent la déplacer d'un écran à un autre. Le multireprise s'applique des scénarios multi-écrans également ; plusieurs activités peuvent recevoir des entrées utilisateur en même temps.
Une application peut spécifier l'écran sur lequel elle doit s'exécuter lorsqu'elle se lance ou lorsqu'elle crée une autre activité. Ce comportement dépend du mode de lancement de l'activité défini dans le fichier manifeste, ainsi que des options et des indicateurs d'intent définis par l'entité qui lance l'activité. Pour en savoir plus, consultez la classe ActivityOptions
.
plus de détails.
Lorsqu'une activité est déplacée vers un affichage secondaire, elle peut faire l'objet d'une mise à jour du contexte, du redimensionnement de la fenêtre, ainsi que de modifications de la configuration et des ressources. Si l'activité
gère le changement de configuration, l'activité est notifiée
onConfigurationChanged()
; sinon l'activité est relancée.
Une activité doit vérifier l'affichage actuel dans onCreate()
et
onConfigurationChanged()
si vous gérez les modifications de configuration. Veillez à mettre à jour les ressources et la mise en page lorsque l'affichage change.
Si le mode de lancement sélectionné pour une activité autorise plusieurs instances, le lancement sur un écran secondaire peut créer une nouvelle instance de l'activité. Les deux activités sont réactivées en même temps.
<ph type="x-smartling-placeholder">![](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/multi-window-mode/multi-display.png?authuser=5&hl=fr)
Vous pouvez également en savoir plus sur les API multi-écrans introduites sur Android 8.0.
Contexte d'activité ou d'application
L'utilisation du contexte adéquat est essentielle pour les campagnes multi-écrans. Lors de l'accès aux ressources, le contexte de l'activité (qui est affiché) est différent du contexte de l'application (qui ne l'est pas).
Le contexte d'activité contient des informations sur l'écran et est toujours ajusté en fonction de la zone d'affichage dans laquelle l'activité apparaît. Vous pouvez ainsi obtenir les bonnes informations sur la densité d'affichage ou les métriques de fenêtre l'application. Vous devez toujours utiliser le contexte de l'activité (ou une autre contexte) pour obtenir des informations sur la fenêtre ou l'affichage actuel. Cette opération affecte certaines API système qui utilisent des informations issues du contexte (par exemple, Présentation des notifications toast).
La configuration de la fenêtre d'activité et l'affichage parent définissent les ressources et le contexte. Obtenez l'écran actuel comme suit :
Kotlin
val activityDisplay = activity.getDisplay()
Java
Display activityDisplay = activity.getDisplay();
Obtenez les métriques de la fenêtre d'activité actuelle :
Kotlin
val windowMetrics = activity.getWindowManager().getCurrentWindowMetrics()
Java
WindowMetrics windowMetrics = activity.getWindowManager().getCurrentWindowMetrics();
Obtenez les métriques de la fenêtre maximale pour la configuration système actuelle :
Kotlin
val maximumWindowMetrics = activity.getWindowManager().getMaximumWindowMetrics()
Java
WindowMetrics maximumWindowMetrics = activity.getWindowManager().getMaximumWindowMetrics();
Les métriques de la fenêtre maximale permettent de faire des calculs, des choix de mise en page ou de déterminer la taille des ressources à extraire à l'avance. Cette possibilité liée à onCreate()
vous permet de prendre ces décisions avant la première mise en page. Elles ne doivent pas être utilisées pour mettre en page des éléments de vue spécifiques.
utilisez plutôt les informations de l'objet Configuration
.
Encoches
Les pliables peuvent présenter une géométrie d'encoche différente selon qu'ils sont ouverts ou fermés. Pour éviter les problèmes d'encoche, consultez Prendre en charge les encoches.
Écrans secondaires
Vous pouvez obtenir les écrans disponibles à partir du service système DisplayManager
:
Kotlin
val displayManager = getSystemService(Context.DISPLAY_SERVICE) as DisplayManager val displays = displayManager.getDisplays()
Java
DisplayManager displayManager = (DisplayManager) getSystemService(Context.DISPLAY_SERVICE); Display[] displays = displayManager.getDisplays();
Utilisez la classe Display
pour obtenir des informations sur un affichage particulier, par exemple
comme la taille d'affichage, ou des indicateurs qui indiquent si un écran est sécurisé.
Cependant, ne partez pas du principe que la taille d'affichage sera la même
la zone d'affichage allouée à votre application. N'oubliez pas qu'en mode multifenêtre,
votre application occupe une partie de l'écran.
Déterminez si une activité peut être lancée sur un écran :
Kotlin
val activityManager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager val activityAllowed = activityManager.isActivityStartAllowedOnDisplay(context, displayId, intent)
Java
ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE); boolean activityAllowed = activityManager.isActivityStartAllowedOnDisplay(context, displayId, intent);
Ensuite, lancez l'activité sur l'écran :
Kotlin
val options = ActivityOptions.makeBasic() options.setLaunchDisplayId(targetDisplay.displayId) startActivity(intent, options.toBundle())
Java
ActivityOptions options = ActivityOptions.makeBasic(); options.setLaunchDisplayId(targetDisplay.displayId); startActivity(intent, options.toBundle());
Compatibilité multi-écran
Android offre une compatibilité multi-écran pour les claviers, fonds d'écran et lanceurs de logiciels.
Clavier virtuel
Un clavier peut être affiché sur un écran secondaire si celui-ci est configuré pour accepter les décorations système. L'éditeur du mode de saisie apparaît automatiquement si un champ de texte demande la saisie de cet affichage.
![](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/multi-window-mode/keyboard.png?authuser=5&hl=fr)
Fond d'écran
Sous Android 10 (niveau d'API 29), les écrans secondaires peuvent comporter un fond d'écran. La
le framework crée une instance distincte de WallpaperService.Engine
pour chaque
l'écran. Assurez-vous que la surface de chaque moteur est tracée indépendamment. Développeurs
peuvent charger des éléments à l'aide du contexte d'affichage
WallpaperService.Engine#getDisplayContext()
. Vérifiez également que
WallpaperInfo.xml
ensembles de fichiers android:supportsMultipleDisplays="true"
.
![](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/multi-window-mode/wallpaper.png?authuser=5&hl=fr)
Lanceurs d'applications
Une nouvelle catégorie de filtre d'intent, SECONDARY_HOME
, fournit une activité dédiée aux écrans secondaires. Les instances de l'activité sont utilisées sur tous les écrans compatibles avec les décorations système, à raison d'une par écran.
<activity>
...
<intent-filter>
<category android:name="android.intent.category.SECONDARY_HOME" />
...
</intent-filter>
</activity>
L'activité doit avoir un mode de lancement qui n'empêche pas plusieurs instances et qui peut s'adapter à différentes tailles d'écran. Le mode de lancement ne peut pas être singleInstance
ni singleTask
.
Par exemple, l'implémentation AOSP de Launcher3
prend en charge
Activité SECONDARY_HOME
.
![](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/multi-window-mode/launcher-phone.png?authuser=5&hl=fr)
![](https://developer.android.com/static/develop/ui/compose/images/layouts/adaptive/multi-window-mode/launcher-display.png?authuser=5&hl=fr)
Métriques sur les fenêtres
Android 11 (niveau d'API 30) a introduit les méthodes WindowManager
suivantes
pour indiquer les limites des applications exécutées en mode multifenêtre:
getCurrentWindowMetrics()
: renvoie un objetWindowMetrics
pour l'état actuel du fenêtrage du système.getMaximumWindowMetrics()
: renvoieWindowMetrics
pour la valeur l'état de fenêtrage potentiel du système.
Méthodes de la bibliothèque Jetpack WindowManager computeCurrentWindowMetrics()
et computeMaximumWindowMetrics()
offrent des fonctionnalités similaires
respectivement, mais avec rétrocompatibilité jusqu'au niveau d'API 14.
Pour obtenir des métriques concernant des écrans autres que l'écran actuel, procédez comme suit : (comme indiqué dans l'extrait de code):
- Créez un contexte d'affichage
- Créez un contexte de fenêtre pour l'affichage
- Récupérez l'instance
WindowManager
du contexte de fenêtre - Récupérez les métriques
WindowMetrics
de la zone d'affichage maximale disponible pour l'application
Kotlin
val windowMetrics = context.createDisplayContext(display) .createWindowContext(WindowManager.LayoutParams.TYPE_APPLICATION, null) .getSystemService(WindowManager::class.java) .maximumWindowMetrics
Java
WindowMetrics windowMetrics = context.createDisplayContext(display) .createWindowContext(WindowManager.LayoutParams.TYPE_APPLICATION, null) .getSystemService(WindowManager.class) .getMaximumWindowMetrics();
Méthodes obsolètes
Les méthodes Display
getSize()
et getMetrics()
ont été abandonnées dans
Niveau d'API 30 à remplacer par les nouvelles méthodes WindowManager
.
Android 12 (niveau d'API 31) abandonne les méthodes Display
getRealSize()
et
getRealMetrics()
et met à jour son comportement pour qu'il corresponde plus précisément
le comportement de getMaximumWindowMetrics()
.
Configuration du mode multifenêtre
Si votre application cible Android 7.0 (niveau d'API 24) ou une version ultérieure, vous pouvez configurer la manière
et si les activités de votre application sont compatibles avec le mode multifenêtre. Vous pouvez définir
dans votre fichier manifeste pour contrôler à la fois la taille et la mise en page. Une activité racine
les paramètres d'attribut s'appliquent à toutes les activités de sa pile de tâches. Par exemple :
si l'activité racine a android:resizeableActivity="true"
, alors toutes
les activités de la pile
de tâches sont redimensionnables. Sur certains appareils plus grands, tels que
Chromebooks, votre application peut s'exécuter dans une fenêtre redimensionnable, même si vous spécifiez
android:resizeableActivity="false"
Si cela fait planter votre application, vous pouvez utiliser
filtres Google Play pour limiter la disponibilité de votre application sur ces appareils.
Android 12 (niveau d'API 31) est défini par défaut sur le mode multifenêtre. Sur les grands écrans
(classe de taille de fenêtre moyenne ou étendue), toutes les applications s'exécutent en mode multifenêtre.
quelle que soit la configuration de l'application. Sur les petits écrans, le système vérifie
minWidth
, minHeight
et resizeableActivity
de l'activité
pour déterminer si l'activité peut s'exécuter en mode multifenêtre.
resizeableActivity
Définissez cet attribut dans le fichier <activity>
ou <application>
de votre fichier manifeste
pour activer ou désactiver le mode multifenêtre pour les niveaux d'API 30 et inférieurs:
<application
android:name=".MyActivity"
android:resizeableActivity=["true" | "false"] />;
Si cet attribut est défini sur true
, l'activité peut être lancée en écran partagé.
et Format libre. Si l'attribut est défini sur false
, l'activité n'est pas
prend en charge le mode multifenêtre. Si la valeur est "false" et que l'utilisateur tente
lance l'activité en mode multifenêtre, elle prend en charge l'intégralité
l'écran.
Si votre application cible le niveau d'API 24 ou supérieur, mais que vous ne spécifiez pas de valeur pour le paramètre pour cet attribut, sa valeur est définie par défaut sur "true".
Si votre application cible le niveau d'API 31 ou supérieur, cet attribut fonctionne différemment sur petits et grands écrans:
- Grands écrans (classe de taille de fenêtre moyenne ou étendue): toutes les applications.
prend en charge le mode multifenêtre. L'attribut indique si une activité peut
seront redimensionnées. Si la valeur est
resizeableActivity="false"
, l'application est placée dans mode de compatibilité lorsque cela est nécessaire, conformément aux dimensions d'affichage. - Petits écrans (classe de taille de fenêtre compact): si
resizeableActivity="true"
, et largeur et hauteur minimales de l'activité respectent les exigences du mode multifenêtre, l'activité est compatible avec le mode multifenêtre . Si la valeur estresizeableActivity="false"
, l'activité n'est pas compatible mode multifenêtre indépendamment de la largeur et de la hauteur minimales de l'activité.
supportsPictureInPicture
Définissez cet attribut dans le nœud <activity>
de votre fichier manifeste pour indiquer si
l'activité prend en charge le mode Picture-in-picture.
<activity
android:name=".MyActivity"
android:supportsPictureInPicture=["true" | "false"] />
configChanges
Pour gérer vous-même les modifications de la configuration multifenêtre, par exemple lorsqu'un utilisateur
redimensionne une fenêtre, ajoutez l'attribut android:configChanges
à votre application
Nœud <activity>
du fichier manifeste avec au moins les valeurs suivantes:
<activity
android:name=".MyActivity"
android:configChanges="screenSize | smallestScreenSize
| screenLayout | orientation" />
Après avoir ajouté android:configChanges
, votre activité et vos fragments reçoivent une
rappel à onConfigurationChanged()
au lieu d'être détruit et
recréés. Vous pouvez ensuite mettre à jour manuellement vos vues, actualiser les ressources
d'effectuer d'autres opérations si nécessaire.
<layout>
Sur Android 7.0 (niveau d'API 24) ou version ultérieure, l'élément du fichier manifeste <layout>
accepte plusieurs attributs qui affectent le comportement d'une activité en mode multifenêtre
mode:
android:defaultHeight
,android:defaultWidth
: hauteur et largeur par défaut de l'activité lorsqu'elle est lancée en mode Format libre.android:gravity
: emplacement initial de l'activité lorsqu'elle est lancée dans en mode Format libre. Consultez la classeGravity
pour connaître les valeurs appropriées.android:minHeight
,android:minWidth
: hauteur et largeur minimales de l'activité dans les modes Écran partagé et Format libre. Si l'utilisateur change d'adresse le séparateur en mode Écran partagé pour réduire une activité minimale spécifiée, le système recadre l'activité à la taille de l'utilisateur requêtes.
Le code suivant montre comment spécifier la taille et l'emplacement par défaut d'une activité, ainsi que sa taille minimale lorsque l'activité est affichée en Format libre :
<activity android:name=".MyActivity">
<layout android:defaultHeight="500dp"
android:defaultWidth="600dp"
android:gravity="top|end|..."
android:minHeight="450dp"
android:minWidth="300dp" />
</activity>
Mode multifenêtre au moment de l'exécution
À partir d'Android 7.0, le système offre des fonctionnalités pour prendre en charge les applications qui peuvent s'exécuter en mode multifenêtre.
Fonctionnalités désactivées en mode multifenêtre
En mode multifenêtre, Android peut désactiver ou ignorer les fonctionnalités qui ne s'appliquent pas à une activité qui partage l'écran de l'appareil avec d'autres activités ou applications.
En outre, certaines options de personnalisation de l'UI du système sont désactivées. Par exemple : les applications ne peuvent pas masquer la barre d'état si elles s'exécutent en mode multifenêtre (voir Contrôler la visibilité de l'interface utilisateur du système)
Le système ignore les modifications apportées à l'attribut android:screenOrientation
.
Requêtes et rappels en mode multifenêtre
La classe Activity
propose les méthodes suivantes pour assurer la compatibilité avec le mode multifenêtre.
mode:
isInMultiWindowMode()
: indique si l'activité est en cours mode multifenêtre.isInPictureInPictureMode()
: indique si l'activité est en cours en mode Picture-in-picture.onMultiWindowModeChanged()
: le système appelle cette méthode chaque fois que l'activité passe en mode multifenêtre ou la quitte. Le système transmet la méthode une valeur "true" si l'activité passe en mode multifenêtre ou "false" si l'activité quitte le mode multifenêtre.onPictureInPictureModeChanged()
: le système appelle cette méthode chaque fois que l'activité passe en mode Picture-in-picture. Le système transmet Méthode a la valeur "true" si l'activité entre en Picture-in-picture ou sur "false" si l'activité quitte le mode Picture-in-picture.
La classe Fragment
expose les versions de la plupart de ces méthodes. Exemple :
Fragment.onMultiWindowModeChanged()
.
Mode Picture-in-picture
Pour mettre une activité en mode Picture-in-picture, appelez
enterPictureInPictureMode()
Cette méthode n'a aucun effet si l'appareil
ne sont pas compatibles avec le mode Picture-in-picture. Pour en savoir plus, consultez la section Ajouter des vidéos à l'aide de
Picture-in-picture (PIP).
Nouvelles activités en mode multifenêtre
Lorsque vous lancez une nouvelle activité, vous pouvez indiquer qu'elle doit être
affiché à côté de celui en cours, si possible. Utiliser l'indicateur d'intent
FLAG_ACTIVITY_LAUNCH_ADJACENT
, qui indique au système d'essayer de créer la
nouvelle activité dans une fenêtre adjacente, les deux activités partagent donc l'écran. La
système fait de son mieux pour y parvenir, mais cela n'est pas garanti.
Si un appareil est en mode Format libre et que vous lancez une nouvelle activité, vous pouvez
spécifier les dimensions de la nouvelle activité et l'emplacement de l'écran en appelant
ActivityOptions.setLaunchBounds()
. Cette méthode n'a aucun effet si l'appareil
n'est pas en mode multifenêtre.
Au niveau d'API 30 ou inférieur, si vous lancez une activité dans une pile de tâches, l'activité remplace celle qui s'affiche à l'écran et hérite de l'ensemble de son mode multifenêtre. propriétés. Si vous souhaitez lancer la nouvelle activité dans une fenêtre distincte dans mode multifenêtre, vous devez le lancer dans une nouvelle pile de tâches.
Android 12 (niveau d'API 31) permet aux applications de diviser la fenêtre de tâche d'une application entre plusieurs activités. Vous déterminez la façon dont votre application affiche ses (plein écran, côte à côte ou empilé) en créant un fichier XML de configuration ou d'appels à l'API Jetpack WindowManager.
Glisser-déposer
Les utilisateurs peuvent glisser-déposer des données d'une activité à l'autre pendant que les deux activités partagent l'écran. (Avant la version 7.0 d'Android, les utilisateurs ne pouvaient faire glisser
et supprimer des données au sein d'une même activité.) Pour ajouter rapidement la prise en charge de l'acceptation
le contenu supprimé, consultez l'API DropHelper
. Pour des fonctionnalités complètes de glisser-déposer
consultez la section Activer le glisser-déposer.
Multi-instance
Chaque activité racine a sa propre tâche, qui s'exécute selon un processus distinct et s'affiche dans sa propre fenêtre. Pour lancer une nouvelle instance de votre application dans une fenêtre distincte, vous pouvez démarrer de nouvelles activités avec l'option FLAG_ACTIVITY_NEW_TASK
. Toi
vous pouvez associer cette propriété à certains attributs multifenêtres pour demander
un emplacement spécifique
pour la nouvelle fenêtre. Par exemple, une application d'achat peut afficher
plusieurs périodes pour
comparer les produits.
Android 12 (niveau d'API 31) vous permet de lancer deux instances d'une activité côte à côte dans la même fenêtre de tâches.
Si vous souhaitez autoriser les utilisateurs à démarrer une autre instance de votre application
le lanceur d'applications ou la barre des tâches, assurez-vous que l'activité
définit android:resizeableActivity="true"
et n'utilise pas de mode de lancement
empêche l'utilisation de plusieurs instances. Par exemple, une activité singleInstancePerTask
peut
instanciés plusieurs fois dans différentes tâches lorsque
FLAG_ACTIVITY_MULTIPLE_TASK
ou FLAG_ACTIVITY_NEW_DOCUMENT
est défini.
Ne confondez pas l'utilisation multi-instance avec une mise en page à plusieurs panneaux, comme une mise en page liste/détails
présentation qui utilise SlidingPaneLayout
, qui s'exécute à l'intérieur d'une seule
fenêtre.
Notez que lorsque plusieurs instances s'exécutent dans des fenêtres distinctes sur un appareil pliable, une ou plusieurs instances peuvent être mises en arrière-plan si la position change. Par exemple, supposons qu'un appareil soit déployé et que deux instances d'application s'exécutent dans deux fenêtres de chaque côté de la ligne de flottaison. Si l'appareil est plié, l'une des instances peut être arrêtée au lieu d'essayer de remplir les fenêtres des deux instances sur un écran plus petit.
Validation du mode multifenêtre
Que votre application cible ou non le niveau d'API 24 ou supérieur, vous devez vérifier comment elle se comporte en mode multifenêtre si un utilisateur tente de le lancer en mode multifenêtre ; sur un appareil équipé d'Android 7.0 ou version ultérieure.
Appareils de test
Les appareils équipés d'Android 7.0 (niveau d'API 24) ou version ultérieure sont compatibles avec le mode multifenêtre.
Niveau d'API 23 ou inférieur
Lorsque les utilisateurs tentent d'afficher l'application en mode multifenêtre, le système la redimensionne de force, sauf si l'application déclare une orientation fixe.
Si votre application ne déclare pas d'orientation fixe, vous devez la lancer sur un appareil fonctionnant sous Android 7.0 ou version ultérieure et tenter d'installer l'application dans mode Écran partagé. Vérifier que l'expérience utilisateur est acceptable lorsque l'application est automatiquement redimensionné.
Si l'application déclare une orientation fixe, vous devez essayer de passer en mode multifenêtre. Vérifiez que l'application reste en mode plein écran.
Niveaux d'API 24 à 30
Si votre application cible les niveaux d'API 24 à 30 et ne désactive pas la compatibilité multifenêtre, vérifiez le comportement suivant dans les modes Écran partagé et Format libre :
Lancez l'application en plein écran, puis passez en mode multifenêtre en en appuyant de manière prolongée sur le bouton Récents. Vérifiez que l'application change de mode.
Lancez l'application directement en mode multifenêtre et vérifiez qu'elle se lance correctement. Vous pouvez lancer une application en mode multifenêtre en appuyant sur Appuyez sur le bouton Récents, puis appuyez de manière prolongée sur la barre de titre de votre application. en la faisant glisser vers l'une des zones en surbrillance sur l'écran.
Redimensionnez votre application en mode Écran partagé en faisant glisser le séparateur d'écran. Valider que l'application est redimensionnée sans plantage et que les éléments d'interface nécessaires sont visible.
Si vous avez indiqué des dimensions minimales pour votre application, essayez de redimensionner la pour que la taille de la fenêtre soit inférieure à ces dimensions. Vérifiez que vous ne pouvez pas redimensionner l'application pour qu'elle dépasse la taille minimale spécifiée .
Lors de tous les tests, vérifiez que les performances de votre application sont acceptables. Pour vérifiez que le délai de mise à jour de l'interface utilisateur n'est pas trop long l'application est redimensionnée.
Niveau d'API 31 ou supérieur
Si votre appli cible le niveau d'API 31 ou supérieur et la largeur minimale de l'activité principale et la hauteur minimale sont inférieures ou égales aux dimensions respectives du zone d'affichage disponible, vérifiez tous les comportements recensés pour les niveaux d'API 24 à 30.
Checklist pour les tests
Pour vérifier les performances de votre application en mode multifenêtre, essayez les opérations suivantes. Vous devez essayer ces opérations en mode Écran partagé et en mode Format libre, sauf indication contraire.
Activer et désactiver le mode multifenêtre
Passer de votre application à une autre et vérifier son comportement correctement lorsqu'il est visible mais pas actif. Par exemple, si votre application est vidéo, vérifiez que la lecture se poursuit pendant que l'utilisateur interagissant avec une autre application.
En mode Écran partagé, essayez de déplacer le séparateur d'écran pour que votre application de plus en plus grands. Essayez ces opérations côte à côte et l'une ci-dessus les autres configurations. Vérifier que l'application ne plante pas (étape essentielle) est visible et l'opération de redimensionnement ne prend pas trop de temps.
Effectuez plusieurs opérations de redimensionnement à la suite. Vérifier que votre application ne plante pas et ne fuit pas de mémoire. Le Profileur de mémoire d'Android Studio fournit des informations sur l'utilisation de mémoire de votre application (voir Inspecter la mémoire de votre application son utilisation avec le Profileur de mémoire).
utiliser votre application normalement dans différentes configurations de fenêtres ; vérifier que l'application se comporte correctement. Vérifiez que le texte est lisible et que Les éléments de l'interface utilisateur ne sont pas trop petits pour permettre une interaction.
Compatibilité avec le mode multifenêtre désactivé
Aux niveaux d'API 24 à 30, si vous avez désactivé le mode multifenêtre en définissant
android:resizeableActivity="false"
, vous devez lancer votre application sur un appareil
équipés d'Android 7.0 à 11, et tenter d'afficher l'écran partagé
de format libre. Vérifiez que l'application reste en plein écran.
.
Ressources supplémentaires
Pour en savoir plus sur la fonctionnalité multifenêtre dans Android, consultez les articles suivants :
- Exemple d'application MultiWindowPlayground pour Android
Recommandations personnalisées * Remarque: Le texte du lien s'affiche lorsque JavaScript est désactivé. * Mode de compatibilité de l'appareil * Prise en charge du redimensionnement des grands écrans * Gérer les modifications de configuration