Gérer les fenêtres

ChromeOS est compatible avec les applications Android dans plusieurs fenêtres. Le système affiche les applications dans des conteneurs de fenêtres dont la taille est déterminée par le facteur de forme de l'appareil, comme illustré dans la figure 1.

Figure 1. Fenêtre d'application sur différents appareils.

Il est important de concevoir des mises en page qui fonctionnent avec différentes tailles d'écran. Si vous suivez les consignes Android pour prendre en charge différentes tailles d'écran, votre application fonctionnera également bien sur ChromeOS.

Cette page explique comment aider la fenêtre de votre application à se lancer correctement, à se redimensionner de manière fluide et à afficher tout son contenu lorsque sa taille change.

Taille du lancement initial

Les applications peuvent demander leur taille de lancement initiale de l'une des manières suivantes :

Utilisez une taille de lancement uniquement pour les environnements de bureau. Cela permet au gestionnaire de fenêtres de définir l'orientation et les limites appropriées. Pour indiquer une préférence en mode ordinateur, ajoutez les balises meta suivantes dans <activity> :

&lt;meta-data android:name=&#34;WindowManagerPreference:FreeformWindowSize&#34;
           android:value=&#34;[phone|tablet|maximize]&#34; /&gt;
&lt;meta-data android:name=&#34;WindowManagerPreference:FreeformWindowOrientation&#34;
           android:value=&#34;[portrait|landscape]&#34; /&gt;

Utilisez des limites de lancement statiques. Utilisez <layout> dans l'entrée de fichier manifeste de votre activité pour spécifier une taille de lancement "fixe", comme dans l'exemple suivant :

&lt;layout android:defaultHeight=&#34;500dp&#34;
            android:defaultWidth=&#34;600dp&#34;
            android:gravity=&#34;top|end&#34;
            android:minHeight=&#34;450dp&#34;
            android:minWidth=&#34;300dp&#34; /&gt;

Utilisez des limites de lancement dynamiques. Une activité peut définir et utiliser ActivityOptions.setLaunchBounds(Rect) lors de la création d'une activité. En spécifiant un rectangle vide, votre application peut être affichée en fenêtre agrandie.

Redimensionner les fenêtres

Dans ChromeOS, les utilisateurs peuvent redimensionner la fenêtre d'une application de la manière habituelle : en faisant glisser l'angle inférieur droit, comme illustré à la figure 2.

Figure 2. Fenêtre d'application redimensionnable.

Il existe deux options pour gérer le redimensionnement de la fenêtre lorsque vous utilisez la classe View :

Répondez aux modifications de configuration de manière dynamique en appelant onConfigurationChanged(..). Par exemple, vous pouvez ajouter android:configChanges="screenSize|smallestScreenSize|orientation|screenLayout" au fichier manifeste de l'activité. Pour en savoir plus sur la gestion des modifications de configuration, consultez Gérer les modifications de configuration.
Laissez le système redémarrer l'activité. Dans ce cas, implémentez onSaveInstanceState et utilisez le composant d'architecture ViewModel pour restaurer l'état enregistré précédent.

Lorsque vous utilisez Jetpack Compose, le comportement de redimensionnement dépend de la configuration de votre activité. Si elle gère les modifications de manière dynamique, une recomposition est déclenchée lorsque la taille de la fenêtre change. Si l'activité est redémarrée par le système, une composition initiale a lieu après le redémarrage. Dans tous les cas, il est important de créer des mises en page Compose qui s'adaptent aux différentes tailles de fenêtre. Ne partez pas du principe que les tailles sont fixes.

Dimensions de la fenêtre

Faites en sorte que vos activités lisent les dimensions de leur fenêtre à chaque démarrage et organisent leur contenu en fonction de la configuration actuelle.

Pour déterminer la configuration actuelle, appelez getResources().getConfiguration() sur l'activité actuelle. N'utilisez pas la configuration de l'activité en arrière-plan ni celle des ressources système. L'activité en arrière-plan n'indique pas de taille, tandis que la configuration système peut contenir plusieurs fenêtres de tailles et d'orientations contradictoires, de sorte qu'aucune donnée utilisable ne peut être extraite.

Notez que la taille de la fenêtre et celle de l'écran ne sont pas identiques. Pour obtenir la taille de la fenêtre en DP, utilisez Activity.getResources().getConfiguration().screenWidth et Activity.getResources().getConfiguration().screenHeight. Vous n'aurez probablement jamais besoin d'utiliser la taille de l'écran.

Limites de contenu

Les limites du contenu d'une fenêtre peuvent changer après le redimensionnement. Par exemple, la zone qui est utilisée par l'application peut être modifiée si la taille de la fenêtre dépasse celle de l'écran. Respectez les consignes suivantes :

Les applications qui utilisent le processus de mise en page d'Android sont automatiquement mises en page dans l'espace disponible.
Les applications natives doivent lire la zone disponible et surveiller les changements de taille pour éviter qu'il y ait des éléments d'interface utilisateur inaccessibles. Appelez les méthodes suivantes pour déterminer la taille disponible initiale de cette surface :
- NativeActivity.mLastContent[X/Y/Width/Height]()
- findViewById(android.R.id.content).get[Width/Height]()
La surveillance continue peut être effectuée à l'aide d'un observateur :
- NativeActivity.onContentRectChangedNative()
- NativeActivity.onGlobalLayout()
- Ajouter un écouteur à view.addOnLayoutChangeListener(findViewById(android.R.id.content))
Si l'application pré-met à l'échelle ses illustrations, faites-le chaque fois que la résolution change.

Redimensionnement de forme libre

ChromeOS permet de redimensionner librement n'importe quelle fenêtre : l'utilisateur peut modifier la largeur, la hauteur et la position d'une fenêtre sur l'écran. De nombreuses applications Android sont écrites sans tenir compte du redimensionnement de forme libre. Tenez compte des problèmes suivants :

La position de l'écran peut changer. Utilisez toujours le système pour effectuer des transformations de coordonnées de fenêtre à écran et d'écran à fenêtre.
Si vous utilisez le système d'affichage d'Android, la mise en page de votre fenêtre change automatiquement lorsque sa taille change.
Si votre application n'utilise pas le système d'affichage et occupe toute la surface de l'écran, elle doit gérer elle-même les changements de taille.
Pour les applications natives, utilisez les membres mLastContent ou la vue du contenu pour déterminer la taille initiale.
Lorsque l'application est en cours d'exécution, écoutez les événements onContentRectChangedNative ou onGlobalLayout pour réagir aux changements de taille.
Lorsque la taille de l'application change, redimensionnez ou rechargez les mises en page et les éléments graphiques, et mettez à jour les zones de saisie.

Mode plein écran

Le mode plein écran fonctionne de la même manière que dans la version stock d'Android. Si la fenêtre ne couvre pas tout l'écran, les demandes de superposition en plein écran (masquant tous les éléments de l'UI du système) sont ignorées. Lorsque la fenêtre de l'application est agrandie, les méthodes, mises en page et fonctions normales en plein écran sont exécutées. Les éléments de l'UI du système (barre de contrôle de la fenêtre et étagère) sont alors masqués.

Orientation de l'écran

L'orientation la plus courante pour une application Android est l'orientation portrait, car c'est ainsi que la plupart des téléphones sont tenus. Le mode Portrait est approprié pour les téléphones, mais ne convient pas aux ordinateurs portables ni aux tablettes, pour lesquels le mode Paysage est préférable. Pour que votre application fonctionne d'une manière optimale, nous vous conseillons de la rendre compatible avec les deux orientations.

Certaines applications Android prévoient que lorsqu'un appareil est tenu en mode Portrait, la valeur de rotation est Surface.ROTATION_0. Cela vaut pour la plupart des appareils Android. Cependant, lorsque l'application est exécutée dans un certain mode ARC, la valeur de rotation pour l'orientation portrait peut ne pas correspondre à Surface.ROTATION_0.

Pour obtenir une valeur de rotation précise lors de la lecture de l'accéléromètre ou de capteurs similaires, utilisez la méthode Display.getRotation() et changez l'axe en conséquence.

Activité et orientation racine

Une fenêtre de Chromebook comprend une pile de fenêtres d'activité. Chaque fenêtre de la pile a la même taille et la même orientation.

Les changements soudains d'orientation et de taille sont déroutants dans un environnement de bureau. Le gestionnaire de fenêtres des Chromebooks évite cela d'une manière semblable au mode côte à côte d'Android : l'activité en bas de la pile contrôle les attributs de toutes les activités au-dessus. Cela peut entraîner des situations inattendues, où une activité nouvellement démarrée qui n'est pas redimensionnable en mode Portrait devient redimensionnable en mode Paysage.

Le mode Appareil a également une incidence : en mode Tablette, l'orientation n'est pas verrouillée et chaque fenêtre conserve sa propre orientation, comme il est prévu sous Android.

Consignes d'orientation

Suivez ces consignes pour gérer l'orientation :

Si votre application n'accepte qu'une seule orientation, indiquez-le dans le fichier manifeste afin que le gestionnaire de fenêtres dispose de cette information avant de procéder au lancement. Lorsque vous spécifiez l'orientation, indiquez également celle des capteurs, si possible. Les Chromebooks sont souvent convertibles, et une application à l'envers est une mauvaise expérience utilisateur.
Essayez de ne sélectionner qu'une seule orientation. Évitez de demander une orientation dans le fichier manifeste et d'en définir une autre de manière programmatique par la suite.
Faites attention lorsque vous modifiez l'orientation en fonction de la taille de la fenêtre. L'utilisateur risque de rester bloqué dans une petite fenêtre de taille portrait et de ne pas pouvoir revenir à une fenêtre de taille paysage plus grande.
Dans Chrome, des commandes de fenêtre permettent de basculer entre toutes les mises en page disponibles. En optant pour la bonne option d'orientation, vous pouvez faire en sorte que l'utilisateur bénéficie d'une mise en page adaptée dès qu'il ouvre l'application. Si celle-ci est disponible en mode Portrait et en mode Paysage, c'est l'orientation paysage qui est utilisée par défaut, quand cela est possible. Une fois cette option définie, elle est mémorisée au niveau de chaque application.
Évitez si possible les changements d'orientation inutiles. Par exemple, si l'orientation de l'activité est portrait, mais que l'application appelle setRequestedOrientation(LANDSCAPE) lors de l'exécution, cela entraîne un redimensionnement inutile de la fenêtre, ce qui est gênant pour l'utilisateur et peut entraîner le redémarrage de l'application si elle ne peut pas le gérer. Il est préférable de définir l'orientation une seule fois, par exemple dans le fichier manifeste, puis de ne la modifier que quand cela est nécessaire.

Autres points à prendre en compte

Voici d'autres éléments à prendre en compte lorsque vous utilisez des applications Android dans ChromeOS :

N'appelez pas finish() dans la méthode onDestroy de votre activité. Cette opération entraîne la fermeture de l'application lors du redimensionnement au lieu d'un redémarrage.
N'utilisez pas de types de fenêtres non compatibles, comme TYPE_KEYGUARD et TYPE_APPLICATION_MEDIA.
Veillez à ce que le redémarrage d'une activité soit rapide en mettant en cache les objets précédemment alloués.
Si vous ne souhaitez pas que l'utilisateur redimensionne votre application, spécifiez android:resizeableActivity=false dans votre fichier manifeste.
Testez votre application pour vous assurer qu'elle gère correctement les modifications de la taille de la fenêtre.