Prendre en charge le redimensionnement des grands écrans

Passer des téléphones aux différents facteurs de forme d'écran de grande taille implique de prendre en compte la façon dont votre jeu gère la gestion des fenêtres. Sur ChromeOS et Google Play Jeux sur PC, votre jeu peut s'exécuter en mode fenêtré sur une interface de bureau principale. Sur les nouvelles tablettes et appareils pliables Android exécutant Android 12L (niveau d'API 32) ou version ultérieure avec une largeur d'écran supérieure à 600 dp, votre jeu peut s'exécuter côte à côte en mode fractionné avec d'autres applications, être redimensionné et même être déplacé entre l'écran intérieur et l'écran extérieur sur les appareils pliables, ce qui entraîne un changement de configuration pour la taille de la fenêtre et, sur certains appareils, l'orientation.

Redimensionnement des jeux Unity

Configuration de base pour les grands écrans

Indiquez si votre jeu peut être redimensionné:

<android:resizeableActivity="true" or "false" />

Si vous ne pouvez pas prendre en charge la redimensionnabilité, assurez-vous que le fichier manifeste du jeu définit explicitement les formats minimal et maximal compatibles:

<!-- Render full screen between 3:2 and 21:9 aspect ratio -->
<!-- Let the platform letterbox otherwise -->
<activity android:minAspectRatio="1.5">
<activity android:maxAspectRatio="2.33">

Google Play Jeux sur PC

Pour Google Play Jeux sur PC, la plate-forme gère la redimensionnement de la fenêtre tout en respectant le format spécifié. La taille de la fenêtre est automatiquement verrouillée sur les dimensions optimales. Vous devez prendre en charge au moins le format 16:9 si votre orientation principale est le mode paysage et le format 9:16 si votre jeu est en mode portrait. Pour une expérience optimale, prenez explicitement en charge les formats 21:9, 16:10 et 3:2 pour un jeu en mode paysage. La redimensionnabilité de la fenêtre n'est pas obligatoire, mais elle est toujours utile pour la compatibilité avec d'autres facteurs de forme.

Pour en savoir plus et découvrir les bonnes pratiques, consultez Configurer les fonctionnalités graphiques pour Google Play Jeux sur PC.

Grands écrans ChromeOS et Android

Pour maximiser la zone visible de votre jeu en plein écran sur ChromeOS et les appareils Android à grand écran, prenez en charge le mode immersif plein écran et masquez les barres système en définissant des indicateurs sur decorView, la visibilité de l'interface utilisateur du système ou via l'API WindowInsetsCompat. Vous devez également gérer correctement les événements de configuration de rotation et de redimensionnement, ou les empêcher de se produire sur les appareils ChromeOS.

Notez que sur les appareils Android à grand écran, votre jeu peut s'exécuter dans des configurations que vous ne gérez peut-être pas encore. Si votre jeu n'est pas compatible avec toutes les configurations de taille et d'orientation de fenêtre, la plate-forme affiche votre jeu en mode compatibilité et, si nécessaire, invite le joueur avant de passer à une configuration non prise en charge.

Sur certains appareils, lorsqu'un joueur passe à une configuration non prise en charge, il peut être invité à recharger le jeu et à recréer l'activité pour qu'elle s'adapte au mieux à la nouvelle mise en page de la fenêtre, ce qui perturbe l'expérience de jeu. Testez votre jeu dans différentes configurations de mode multifenêtre (taille de fenêtre de 2/3, 1/2 ou 1/3) et vérifiez qu'aucun élément de jeu ni d'interface utilisateur n'est coupé ou inaccessible. En outre, testez la façon dont votre jeu réagit à la continuité des appareils pliables lorsque vous passez de l'écran intérieur à l'écran extérieur. Si des problèmes surviennent, gérez explicitement ces événements de configuration et ajoutez une prise en charge avancée de la redimensionnement pour les grands écrans.

Possibilité de redimensionner les applications sur grand écran

Pour quitter le mode de compatibilité et éviter la recréation d'activités, procédez comme suit:

1. Déclarez votre activité principale comme redimensionnable:

   <android:resizeableActivity="true" />
   

2. Déclarez une prise en charge explicite des attributs "orientation", "screenSize", "smallestScreenSize", "screenLayout" et "density" dans l'attribut android:configChanges de l'élément <activity> de votre fichier manifeste de jeu pour recevoir tous les événements de configuration pour grand écran:

   <android:configChanges="screenSize | smallestScreenSize | screenLayout | orientation | keyboard |
                           keyboardHidden | density" />
   

3. Forcez onConfigurationChanged() et gérez l'événement de configuration, y compris l'orientation, la taille de la fenêtre, la largeur et la hauteur actuelles:

   Kotlin

   override fun onConfigurationChanged(newConfig: Configuration) {
      super.onConfigurationChanged(newConfig)
      val density: Float = resources.displayMetrics.density
      val newScreenWidthPixels =
   (newConfig.screenWidthDp * density).toInt()
      val newScreenHeightPixels =
   (newConfig.screenHeightDp * density).toInt()
   
      // Configuration.ORIENTATION_PORTRAIT or ORIENTATION_LANDSCAPE
      val newScreenOrientation: Int = newConfig.orientation
   
      // ROTATION_0, ROTATION_90, ROTATION_180, or ROTATION_270
      val newScreenRotation: Int =
   windowManager.defaultDisplay.rotation
   }

   Java

   @Override
   public void onConfigurationChanged(Configuration newConfig) {
      super.onConfigurationChanged(newConfig);
      float density = getResources().getDisplayMetrics().density;
      int newScreenWidthPixels = (int) (newConfig.screenWidthDp * density);
      int newScreenHeightPixels = (int) (newConfig.screenHeightDp * density);
   
      // Configuration.ORIENTATION_PORTRAIT or ORIENTATION_LANDSCAPE
      int newScreenOrientation = newConfig.orientation;
   
      // ROTATION_0, ROTATION_90, ROTATION_180, or ROTATION_270
      int newScreenRotation = getWindowManager().getDefaultDisplay()
              .getRotation();
   }

Vous pouvez également interroger WindowManager pour vérifier la rotation actuelle de l'appareil. À l'aide de ces métadonnées, vérifiez les nouvelles dimensions de la fenêtre et affichez-la à sa taille complète. Cela peut ne pas fonctionner dans tous les cas en raison de différences de format. Vous pouvez donc ancrer l'interface utilisateur de votre jeu à la nouvelle taille de fenêtre et afficher le contenu principal du jeu en mode letterbox. Si des limites techniques ou de conception empêchent l'une ou l'autre de ces approches, créez votre propre format letterbox dans le moteur pour préserver le format, et adaptez-le aux meilleures dimensions possibles en déclarant resizeableActivity = false et en évitant le mode de configuration.

Quelle que soit l'approche que vous choisissez, testez votre jeu dans différentes configurations (pliage et dépliage, différents changements de rotation, mode écran partagé) et assurez-vous qu'aucun élément d'interface utilisateur du jeu n'est coupé ou ne se chevauche, qu'il n'y a pas de problèmes d'accessibilité des cibles tactiles ni de problèmes de format qui pourraient entraîner l'étirement, l'écrasement ou la distorsion du jeu.

De plus, les écrans plus grands signifient généralement des pixels plus grands, car vous avez le même nombre de pixels pour une zone beaucoup plus grande. Cela peut entraîner une pixellisation pour les tampons de rendu réduits ou les éléments de résolution inférieure. Utilisez vos composants de la plus haute qualité sur les appareils à grand écran et effectuez un profilage des performances de votre jeu pour vous assurer qu'il n'y a pas de problèmes. Si votre jeu est compatible avec plusieurs niveaux de qualité, assurez-vous qu'il tient compte des appareils à grand écran.

Mode multifenêtre

Le mode multifenêtre permet à plusieurs applications de partager le même écran simultanément. 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 (voir Cycle de vie d'une activité en mode multifenêtre dans Compatibilité avec le mode multifenêtre).

Lorsque le joueur active une application ou un jeu en mode multifenêtre, le système notifie l'activité d'une modification de configuration comme spécifié dans la section Redimensionnement avancé sur grand écran. Une modification de la configuration se produit également lorsque le joueur redimensionne le jeu ou le remet en mode plein écran.

Rien ne garantit que l'application retrouvera la sélection lorsqu'elle sera mise en mode multifenêtre. Par conséquent, si vous utilisez l'un des événements d'état de l'application pour suspendre votre jeu, ne vous appuyez pas sur l'événement d'acquisition du focus (onWindowFocusChanged() avec la valeur de focus définie sur "true") pour reprendre le jeu. Utilisez plutôt d'autres gestionnaires d'événements ou de modification d'état, tels que onConfigurationChanged() ou onResume(). Notez que vous pouvez toujours utiliser la méthode isInMultiWindowMode() pour détecter si l'activité en cours s'exécute en mode multifenêtre.

Avec le mode multifenêtre sur ChromeOS, les dimensions initiales de la fenêtre deviennent un élément important à prendre en compte. Un jeu n'a pas besoin d'être en plein écran. Vous devez donc déclarer la taille de la fenêtre dans ce cas. Il existe deux approches recommandées.

La première option utilise des attributs spécifiques sur la balise <layout> dans votre fichier manifeste Android. Les attributs defaultHeight et defaultWidth contrôlent les dimensions initiales. Veillez également à utiliser les attributs minHeight et minWidth pour empêcher vos joueurs de redimensionner la fenêtre de jeu en dimensions non compatibles. Enfin, l'attribut gravity détermine l'emplacement de la fenêtre à l'écran lorsqu'elle est lancée. Voici un exemple de balise de mise en page utilisant ces attributs:

<layout android:defaultHeight="500dp"
        android:defaultWidth="600dp"
        android:gravity="top|end"
        android:minHeight="450dp"
        android:minWidth="300dp" />

La deuxième option de paramétrage de la taille de la fenêtre fonctionne à l'aide de limites de lancement dynamiques. Vous pouvez définir les dimensions de la fenêtre de départ à l'aide de setLaunchBounds(Rect)⁠⁠. Si un rectangle vide est spécifié, l'activité est lancée en mode maximisé.

De plus, si vous utilisez les moteurs de jeu Unity ou Unreal, assurez-vous d'utiliser une version récente (Unity 2019.4.40 et Unreal 5.3 ou version ultérieure) qui prend bien en charge le mode multifenêtre.

Prise en charge des positions pliables

Utilisez la bibliothèque de mise en page WindowManager de Jetpack pour prendre en charge les positions pliables, telles que la position sur une table, afin d'accroître l'immersion et l'engagement des joueurs:

fun isTableTopPosture(foldFeature : FoldingFeature?) : Boolean {
    contract { returns(true) implies (foldFeature != null) }
    return foldFeature?.state == FoldingFeature.State.HALF_OPENED &&
            foldFeature.orientation == FoldingFeature.Orientation.HORIZONTAL
}

boolean isTableTopPosture(FoldingFeature foldFeature) {
    return (foldFeature != null) &&
           (foldFeature.getState() == FoldingFeature.State.HALF_OPENED) &&
           (foldFeature.getOrientation() == FoldingFeature.Orientation.HORIZONTAL);
}