Prise en charge du mode multifenêtre

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">
</ph>
Figure 1 : Affichez deux applications côte à côte en mode Écran partagé.

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 et minHeight d'une activité pour déterminer l'activité peut s'exécuter en mode multifenêtre. Si resizeableActivity="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 :

  1. Ouvrez l'écran "Récents".
  2. Faites glisser une application pour l'afficher.
  3. Appuyez sur l'icône de l'application dans la barre de titre.
  4. Sélectionnez l'option "Écran partagé" dans le menu.
  5. 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:

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) } }

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:

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. } }

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.

Figure 2 : Caméra en mode multifenêtre.

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">
</ph> <ph type="x-smartling-placeholder">
</ph> Figure 3 : Plusieurs instances d'une activité sur plusieurs écrans

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 :

val activityDisplay = activity.getDisplay()

Obtenez les métriques de la fenêtre d'activité actuelle :

val windowMetrics = activity.getWindowManager().getCurrentWindowMetrics()

Obtenez les métriques de la fenêtre maximale pour la configuration système actuelle :

val 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:

val displayManager =
getSystemService(Context.DISPLAY_SERVICE) as DisplayManager val 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 :

val activityManager =
getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager val
activityAllowed = activityManager.isActivityStartAllowedOnDisplay(context,
displayId, intent)

Ensuite, lancez l'activité sur l'écran :

val 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.

Figure 4 : Clavier sur un écran secondaire.

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".

Figure 5 : Fond d'écran sur téléphone et écran secondaire.

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.

Figure 6. Lanceur d'applications Material Design sur un téléphone.
<ph type="x-smartling-placeholder">
</ph>
Figure 7 : Lanceur d'applications Material Design sur un écran secondaire.

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:

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

val windowMetrics =
context.createDisplayContext(display)
.createWindowContext(WindowManager.LayoutParams.TYPE_APPLICATION, null)
.getSystemService(WindowManager::class.java) .maximumWindowMetrics

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 est resizeableActivity="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 classe Gravity 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 :

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
Précédent
Utiliser des classes de taille de fenêtre
Suivant
Créer une navigation adaptative