Compatibilité avec le 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 une petite fenêtre superposée aux autres (mode Picture-in-picture) ou dans des fenêtres individuelles redimensionnables (mode Format libre).

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) a introduit le mode Écran partagé sur les petits écrans et le mode Picture-in-picture sur certains appareils.

  • Le mode Écran partagé remplit l'écran avec deux applications, qui s'affichent côte à côte ou l'une au-dessus de l'autre. Les utilisateurs peuvent faire glisser le séparateur qui sépare les deux applications pour agrandir l'une et l'autre.

  • Le mode Picture-in-picture permet aux utilisateurs de continuer la lecture de la vidéo tout en interagissant avec une autre application (voir la section Compatibilité Picture-in-picture).

  • Les fabricants d'appareils à grand écran peuvent activer le mode Format libre, dans lequel les utilisateurs peuvent redimensionner librement chaque activité.

  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 le mode multifenêtre pour votre application en définissant resizeabableActivity="false" pour vous assurer 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 appareils à petit écran.

• Android 12 (niveau d'API 31) rend le mode multifenêtre standard.

  • Sur les grands écrans (plus petite largeur >= 600 dp), la plate-forme accepte toutes les applications en mode multifenêtre, quelle que soit leur configuration. Si la valeur est resizeableActivity="false", l'application passe en mode de compatibilité si nécessaire pour s'adapter aux dimensions d'affichage.

  • Sur les petits écrans (la plus petite largeur est inférieure à 600 dp), le système vérifie les éléments minWidth et minHeight d'une activité pour déterminer si celle-ci peut s'exécuter en mode multifenêtre. Si la valeur est resizeableActivity="false", l'application ne peut pas s'exécuter en mode multifenêtre, quelles que soient la largeur et la hauteur minimales.

  Remarque :Les fabricants d'appareils peuvent modifier ces comportements.

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écutez 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).

Remarque : Android 12L (niveau d'API 32) ou version ultérieure permet aux utilisateurs d'activer le mode Écran partagé depuis l'écran "Récents" en sélectionnant l'option Diviser qui se trouve sous l'application active lorsqu'au moins deux applications figurent dans cette liste.

Lancer dans une fenêtre adjacente

Si votre application doit accéder au contenu via un intent, vous pouvez utiliser FLAG_ACTIVITY_LAUNCH_ADJACENT pour ouvrir le contenu dans une fenêtre d'écran partagé adjacente.

FLAG_ACTIVITY_LAUNCH_ADJACENT a été introduit dans Android 7.0 (niveau d'API 24) pour permettre aux applications exécutées en mode Écran partagé de lancer des activités dans la fenêtre adjacente.

Android 12L (niveau d'API 32) ou version ultérieure a étendu la définition de l'indicateur pour permettre aux applications exécutées en plein écran d'activer le mode Écran partagé, puis de lancer des activités dans la fenêtre adjacente.

Pour lancer une activité adjacente, utilisez FLAG_ACTIVITY_LAUNCH_ADJACENT 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);
}

Remarque : Les OEM peuvent activer le comportement d'Android 12L sur les anciennes versions d'Android. Dans ce cas, FLAG_ACTIVITY_LAUNCH_ADJACENT fonctionne comme pour le niveau d'API 32.

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 d'Android.

Multireprise

Android 10 (niveau d'API 29) ou version ultérieure est compatible avec la multireprise. Toutes 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 ou si l'activité n'est pas sélectionnable (par exemple, si elle est en mode Picture-in-picture). Il est également possible qu'aucune activité ne soit active à un moment donné, par exemple si le panneau des notifications est ouvert. La méthode onStop() fonctionne comme d'habitude: elle est appelée chaque fois qu'une activité est supprimée de 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é. Cette activité est considérée comme la plus élevée et constitue la seule activité à l'état RESUMED. Toutes les autres activités visibles sont STARTED, mais pas RESUMED. Cependant, le système accorde une priorité plus élevée à ces activités visibles, mais non réactivées, qu'aux activités non visibles. Si l'utilisateur interagit avec l'une des activités visibles, cette activité est réactivée et l'activité précédemment la plus élevée 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.

Remarque :En mode multifenêtre sur Android 9 ou une version antérieure, il est possible qu'une application ne soit pas à l'état RESUMED, même si elle est visible par l'utilisateur, mais qu'elle doive continuer à fonctionner en arrière-plan. Par exemple, une application vidéo dans cet état doit continuer à lire sa vidéo. C'est pourquoi nous vous recommandons de ne pas suspendre la lecture des vidéos en réponse à l'événement de cycle de vie ON_PAUSE. Au lieu de cela, l'activité doit commencer la lecture en réponse à ON_START et la mettre en pause en réponse à ON_STOP. Si vous gérez les événements de cycle de vie directement au lieu d'utiliser le package Lifecycle, mettez la lecture de la vidéo en pause dans votre gestionnaire onStop() et reprenez la lecture dans onStart().

Modifications de configuration

Lorsque l'utilisateur active une application en mode multifenêtre, le système notifie l'activité d'une modification de configuration, comme spécifié dans Gérer les modifications de configuration. Cela se produit également lorsque l'utilisateur redimensionne l'application ou la remet 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 informe l'application que l'appareil est passé de l'orientation portrait à l'orientation paysage, sauf que les dimensions de l'application sont modifiées au lieu d'être simplement permutées. Votre activité peut gérer elle-même le changement de configuration, ou votre application peut autoriser le système à détruire l'activité et à la recréer avec les 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 de zones nouvellement exposées, le système les remplit temporairement avec la couleur spécifiée par l'attribut windowBackground ou par l'attribut de style windowBackgroundFallback par défaut.

Accès exclusif aux ressources

Pour faciliter la compatibilité de la fonctionnalité de multireprise, utilisez le rappel de cycle de vie onTopResumedActivityChanged().

Le rappel est invoqué lorsqu'une activité gagne ou perd la première position réactivée, ce qui est important lorsqu'une activité utilise une ressource Singleton partagée, telle que le micro ou l'appareil photo.

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 à l'appareil photo. Cette méthode est disponible à partir d'Android 10 (niveau d'API 29).

N'oubliez pas que resizeableActivity=false ne garantit pas un accès exclusif à l'appareil photo, 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 continuer l'aperçu de l'appareil photo pendant que l'utilisateur interagit avec l'application réactivée qui vient d'être sélectionnée. Votre application peut continuer à exécuter l'appareil photo lorsqu'il ne s'agit pas de l'application la plus réactivée, mais elle doit gérer correctement le cas de déconnexion. Lorsque l'application la plus réactivée souhaite utiliser l'appareil photo, elle peut l'ouvrir et votre application perdra l'accès. Votre application peut rouvrir l'appareil photo lorsqu'elle récupère le focus.

Lorsqu'une application reçoit un rappel CameraDevice.StateCallback#onDisconnected(), les appels suivants sur l'appareil photo génèrent une exception 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 également aux scénarios multi-écrans. 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.

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 la modification de configuration, elle en est informée dans onConfigurationChanged(). Sinon, elle est redémarrée.

Une activité doit vérifier l'affichage actuel dans onCreate() et onConfigurationChanged() si vous modifiez la 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 instance de l'activité. Les deux activités sont réactivées en même temps.

Figure 3 : Plusieurs instances d'une activité sur plusieurs écrans

Vous pouvez également vous renseigner sur les API multi-écrans introduites dans 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. Cela vous permet d'obtenir les bonnes informations sur la densité d'affichage ou les métriques de fenêtre de votre application. Vous devez toujours utiliser le contexte d'activité (ou un autre contexte basé sur l'interface utilisateur) pour obtenir des informations sur la fenêtre ou l'écran actuel. Cela a également une incidence sur certaines API système qui utilisent des informations du contexte (par exemple, consultez la section 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. Ces métriques ne doivent pas être utilisées pour disposer d'é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, telles que sa taille ou ses indicateurs de sécurité. Toutefois, ne partez pas du principe que la taille d'affichage sera identique à celle de 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.

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. Le framework crée une instance distincte de WallpaperService.Engine pour chaque écran. Assurez-vous que la surface de chaque moteur est tracée indépendamment. Les développeurs peuvent charger des éléments à l'aide du contexte d'affichage dans WallpaperService.Engine#getDisplayContext(). Assurez-vous également que votre fichier WallpaperInfo.xml définit 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 une activité SECONDARY_HOME.

Figure 6. Lanceur d'applications Material Design sur un téléphone.

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 fournir les limites des applications exécutées en mode multifenêtre:

• getCurrentWindowMetrics(): renvoie un objet WindowMetrics pour l'état de fenêtrage actuel du système.
• getMaximumWindowMetrics(): renvoie WindowMetrics pour le plus grand état de fenêtrage potentiel du système.

Les méthodes computeCurrentWindowMetrics() et computeMaximumWindowMetrics() de la bibliothèque Jetpack WindowManager offrent des fonctionnalités similaires respectivement, mais avec une rétrocompatibilité jusqu'au niveau d'API 14.

Pour obtenir des métriques pour des écrans autres que l'affichage 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 au niveau d'API 30 au profit des nouvelles méthodes WindowManager.

Android 12 (niveau d'API 31) abandonne les méthodes Display getRealSize() et getRealMetrics(), et met à jour leur comportement pour correspondre plus précisément à celui de getMaximumWindowMetrics().

Remarque :Utilisez Configuration#densityDpi au lieu de getMetrics() ou getRealMetrics() pour obtenir la densité d'affichage.

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 compatibilité de ses activités avec le mode multifenêtre. Vous pouvez définir des attributs dans votre fichier manifeste pour contrôler à la fois la taille et la mise en page. Les paramètres d'attribut d'une activité racine s'appliquent à toutes les activités de sa pile de tâches. Par exemple, si l'activité racine comporte android:resizeableActivity="true", toutes les activités de la pile de tâches peuvent être redimensionnées. Sur certains appareils plus grands, tels que les Chromebooks, votre application peut s'exécuter dans une fenêtre redimensionnable, même si vous spécifiez android:resizeableActivity="false". Si votre application ne fonctionne plus, vous pouvez utiliser des filtres Google Play pour limiter sa disponibilité sur ces appareils.

Remarque :Si vous créez une application à orientations multiples ciblant le niveau d'API 23 ou inférieur et que l'utilisateur l'utilise en mode multifenêtre, le système redimensionne de force l'application. Le système affiche une boîte de dialogue avertissant l'utilisateur que l'application peut se comporter de manière inattendue. Le système ne redimensionne pas les applications à orientation fixe. Si l'utilisateur tente d'ouvrir une application à orientation fixe en mode multifenêtre, l'application occupe la totalité de l'écran.

Android 12 (niveau d'API 31) est défini par défaut sur le mode multifenêtre. Sur les grands écrans (SW >= 600 dp), toutes les applications s'exécutent en mode multifenêtre, quelle que soit leur configuration. Sur les petits écrans, le système vérifie les paramètres minWidth, minHeight et resizeableActivity d'une activité pour déterminer si celle-ci peut s'exécuter en mode multifenêtre.

resizeableActivity

Définissez cet attribut dans l'élément <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 mode Écran partagé et en mode Format libre. Si l'attribut est défini sur false, l'activité n'est pas compatible avec le mode multifenêtre. Si la valeur est "false" et que l'utilisateur tente de lancer l'activité en mode multifenêtre, l'activité s'affiche en plein écran.

Si votre application cible un niveau d'API 24 ou supérieur, mais que vous ne spécifiez pas de valeur pour cet attribut, la valeur de l'attribut 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 les petits et les grands écrans:

• Grands écrans (SW = > 600 dp): toutes les applications sont compatibles avec le mode multifenêtre. L'attribut indique si une activité peut être redimensionnée. Si la valeur est resizeableActivity="false", l'application passe en mode de compatibilité si nécessaire, conformément aux dimensions d'affichage.
• Petits écrans (SW < 600 dp): si resizeableActivity="true" ainsi que la largeur et la 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 avec le mode multifenêtre, quelles que soient la largeur et la hauteur minimales.

supportsPictureInPicture

Définissez cet attribut dans le nœud <activity> de votre fichier manifeste pour indiquer si l'activité est compatible avec le mode Picture-in-picture.

<activity
  android:name=".MyActivity"
  android:supportsPictureInPicture=["true" | "false"] />

Remarque :Si la valeur est supportsPictureInPicture="true", vous devez définir l'attribut android:configChanges pour permettre à votre activité de gérer les modifications de configuration. Consultez Ajouter des vidéos en mode Picture-in-picture (PIP).

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 au nœud <activity> du fichier manifeste de votre application 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 un rappel à onConfigurationChanged() au lieu d'être détruits et recréés. Vous pouvez ensuite mettre à jour manuellement vos vues, actualiser les ressources et 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:

• 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 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 déplace le séparateur en mode Écran partagé pour réduire une activité au minimum spécifié, le système recadre l'activité à la taille demandée par l'utilisateur.

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 compatibles avec les applications pouvant 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'UI 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:

• isInMultiWindowMode(): indique si l'activité est en mode multifenêtre.

• isInPictureInPictureMode(): indique si l'activité est en mode Picture-in-picture.

  Remarque :Le mode Picture-in-picture est un cas particulier du mode multifenêtre. Si myActivity.isInPictureInPictureMode() renvoie true, myActivity.isInMultiWindowMode() renvoie également true.

• onMultiWindowModeChanged(): le système appelle cette méthode chaque fois que l'activité passe en mode multifenêtre ou sort de ce mode. Le système transmet la méthode "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 à la méthode la valeur "true" si l'activité passe en mode Picture-in-picture, ou la valeur "false" si l'activité quitte le mode Picture-in-picture.

La classe Fragment expose les versions de la plupart de ces méthodes, par 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 n'est pas compatible avec le mode Picture-in-picture. Pour en savoir plus, consultez la section Ajouter des vidéos en mode Picture-in-picture (PIP).

Nouvelles activités en mode multifenêtre

Lorsque vous lancez une nouvelle activité, vous pouvez indiquer qu'elle doit s'afficher à côté de l'activité actuelle, si possible. Utilisez 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 afin que les deux activités partagent l'écran. Le système fera de son mieux, 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 et la position de l'écran de la nouvelle activité 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, elle remplace l'activité à l'écran et hérite de toutes ses propriétés multifenêtres. Si vous souhaitez lancer la nouvelle activité dans une fenêtre distincte en mode multifenêtre, vous devez la 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 manière dont votre application affiche ses activités (en plein écran, côte à côte ou empilées) en créant un fichier de configuration XML ou en effectuant des appels d'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 glisser-déposer des données qu'au sein d'une même activité.) Pour ajouter rapidement la prise en charge de l'acceptation du contenu supprimé, consultez l'API DropHelper. Pour obtenir des conseils complets sur le 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. Vous pouvez l'associer à certains attributs multifenêtres afin de demander un emplacement spécifique pour la nouvelle fenêtre. Par exemple, une application d'achat peut afficher plusieurs fenêtres pour comparer des 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 à partir du lanceur d'applications ou de la barre des tâches, assurez-vous que l'activité du lanceur définit android:resizeableActivity="true" et n'utilise pas de mode de lancement qui empêche plusieurs instances. Par exemple, une activité singleInstancePerTask peut être instanciée plusieurs fois dans différentes tâches lorsque FLAG_ACTIVITY_MULTIPLE_TASK ou FLAG_ACTIVITY_NEW_DOCUMENT est défini.

Remarque :Le lanceur d'applications est une boîte de dialogue système qui affiche la liste des applications qui répondent à un intent spécifié. Les utilisateurs peuvent lancer une application en la sélectionnant dans la liste. Consultez la section Types d'intents.

Ne confondez pas le mode multi-instance avec une mise en page à plusieurs panneaux, comme une présentation liste/détails qui utilise SlidingPaneLayout, qui s'exécute dans 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 son comportement en mode multifenêtre si un utilisateur tente de la lancer en mode multifenêtre sur un appareil équipé d'Android 7.0 ou version ultérieure.

Attention :Les applications Unity exécutées sur Unity Long Term Support (LTS) version 2018 ou antérieure perdent leur focus, et la fenêtre de l'application devient noire lorsque l'application s'exécute en plein écran et que le mode Écran partagé est activé. Vous pouvez restaurer l'application en sélectionnant sa fenêtre. Pour éliminer le problème, mettez à niveau votre application Unity vers la version LTS 2019 ou 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 équipé d'Android 7.0 ou version ultérieure et essayer de passer l'application en mode Écran partagé. Vérifiez que l'expérience utilisateur est acceptable en cas de redimensionnement forcé de l'application.

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 appuyant de manière prolongée sur le bouton Recents (Éléments 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. Pour lancer une application en mode multifenêtre, appuyez sur le bouton Recents (Éléments récents), puis appuyez de manière prolongée sur la barre de titre de votre application et faites-la glisser vers l'une des zones en surbrillance à l'écran.

• Redimensionnez votre application en mode Écran partagé en faisant glisser le séparateur d'écran. Vérifiez que l'application est redimensionnée sans plantage et que les éléments d'interface utilisateur nécessaires sont visibles.

• Si vous avez spécifié des dimensions minimales pour votre application, essayez de redimensionner l'application pour que la taille de sa fenêtre soit inférieure à ces dimensions. Vérifiez que la taille de l'application ne peut pas être inférieure aux dimensions minimales spécifiées.

• Lors de tous les tests, vérifiez que les performances de votre application sont acceptables. Par exemple, vérifiez que le délai avant la mise à jour de l'interface utilisateur n'est pas trop long une fois l'application redimensionnée.

Niveau d'API 31 ou supérieur

Si votre application cible le niveau d'API 31 ou supérieur, et que la largeur et la hauteur minimales de l'activité principale sont inférieures ou égales aux dimensions respectives de la zone d'affichage disponible, vérifiez tous les comportements répertoriés pour les niveaux d'API 24 à 30.

Remarque :Vous pouvez déterminer de manière automatisée si votre application est en mode multifenêtre en vérifiant la valeur renvoyée pour Activity#isInMultiWindowMode().

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

• Passez de votre application à une autre et vérifiez qu'elle se comporte correctement tant qu'elle est visible, mais inactive. Par exemple, si votre application lit une vidéo, vérifiez que la lecture se poursuit pendant que l'utilisateur interagit avec une autre application.

• En mode Écran partagé, essayez de déplacer le séparateur d'écran pour augmenter ou réduire la taille de votre application. Essayez ces opérations dans des configurations côte à côte et l'une au-dessus de l'autre. Vérifiez que l'application ne plante pas, que les fonctionnalités essentielles sont visibles et que l'opération de redimensionnement ne prend pas trop de temps.

• Effectuez plusieurs opérations de redimensionnement à la suite. Vérifiez que votre application ne plante pas ou ne libère pas de mémoire. Le Profileur de mémoire d'Android Studio fournit des informations sur l'utilisation de la mémoire de votre application (consultez Inspecter l'utilisation de la mémoire de votre application avec le Profileur de mémoire).

• Utilisez votre application normalement dans différentes configurations de fenêtres et vérifiez qu'elle 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é d'Android 7.0 à 11, et essayer de l'activer en mode Écran partagé et en mode Format libre. Vérifiez que l'application reste en mode 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