Prendre en charge le redimensionnement des grands écrans

Le passage des téléphones à différents facteurs de forme d'écran implique de réfléchir à la façon dont votre jeu gère la gestion des fenêtres. Sur Googlebook, ChromeOS et Google Play Games sur PC, votre jeu peut s'exécuter en mode fenêtré sur une interface de bureau principale. Sur les nouvelles tablettes et les nouveaux appareils pliables Android équipés d'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 écran partagé avec d'autres applications, être redimensionné et même être déplacé entre l'écran intérieur et l'écran extérieur des appareils pliables, ce qui entraîne une modification de la configuration de la taille de la fenêtre et, sur certains appareils, de l'orientation.

Redimensionnement avec les jeux Unity

Configuration de base pour les grands écrans

Indiquez si votre jeu est capable de gérer le redimensionnement :

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

Si vous ne pouvez pas prendre en charge le redimensionnement, 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 le redimensionnement des fenêtres tout en respectant le format spécifié. La taille de la fenêtre est automatiquement définie 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é des fenêtres n'est pas requise ici, mais elle reste 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

Pour maximiser la zone visible de votre jeu en plein écran sur les tablettes grand écran, les appareils pliables, les Googlebooks, ChromeOS et les écrans connectés, utilisez le mode immersif plein écran et masquez les barres système en définissant des indicateurs sur decorView, la visibilité de l'UI 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.

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 l'encadre en mode de compatibilité et, si nécessaire, invite le joueur avant de passer à une configuration non compatible.

Sur certains appareils, lorsqu'un joueur passe à une configuration non compatible, il peut être invité à recharger le jeu et à recréer l'activité pour l'adapter au mieux à la nouvelle disposition de la fenêtre, ce qui perturbe l'expérience de jeu. Testez votre jeu dans différentes configurations du mode multifenêtre (taille de fenêtre 2/3, 1/2, 1/3) et vérifiez qu'aucun élément de gameplay ou d'UI n'est coupé ou inaccessible. Testez également la façon dont votre jeu réagit à la continuité des écrans pliables lorsque vous passez de l'écran intérieur à l'écran extérieur et inversement. Si vous rencontrez des problèmes, gérez explicitement ces événements de configuration et ajoutez une prise en charge avancée de la redimensionnabilité sur grand écran.

Redimensionnement avancé pour les grands écrans

Pour quitter le mode de compatibilité et éviter de recréer l'activité :

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

   <android:resizeableActivity="true" />
   

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

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

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

   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 effectuez le rendu à la taille de fenêtre complète. Cette méthode peut ne pas fonctionner dans tous les cas en raison des différences de format. Vous pouvez également ancrer l'UI de votre jeu à la nouvelle taille de fenêtre et mettre votre contenu de gameplay principal au format letterbox. Si des limites techniques ou de conception vous empêchent d'utiliser l'une ou l'autre de ces approches, effectuez votre propre letterboxing dans le moteur pour préserver le format, et mettez à l'échelle les dimensions les plus adaptées tout en déclarant resizeableActivity = false et en évitant le mode configuration.

Quelle que soit l'approche que vous adoptez, testez votre jeu dans différentes configurations (plié et déplié, différentes rotations, mode écran partagé) et assurez-vous qu'aucun élément de l'UI du jeu n'est coupé ou chevauché, qu'il n'y a pas de problème d'accessibilité des cibles tactiles ni de problème de format qui déforme le jeu (en l'étirant, en le comprimant ou en le déformant d'une autre manière).

De plus, les grands écrans sont généralement associés à de plus grands pixels, car le même nombre de pixels est réparti sur une zone beaucoup plus grande. Cela peut entraîner une pixellisation des tampons de rendu redimensionnés ou des composants de résolution inférieure. Utilisez vos composants de la meilleure qualité sur les appareils à grand écran et profiler les performances de votre jeu pour vous assurer qu'il n'y a aucun problème. 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é pour les grands écrans. 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 le focus 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 mettre en pause votre jeu, ne vous fiez pas à 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 changement d'état, tels que onConfigurationChanged() ou onResume(). Notez que vous pouvez toujours utiliser la méthode isInMultiWindowMode() pour détecter si l'activité actuelle s'exécute en mode multifenêtre.

Avec le fenêtrage du bureau sur Googlebook, ChromeOS, ainsi que sur les tablettes et appareils pliables à grand écran, 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. Dans ce cas, vous devez déclarer la taille de la fenêtre. Nous vous recommandons deux approches.

La première option consiste à utiliser des attributs spécifiques sur la balise <layout> dans votre fichier manifeste Android. Les attributs defaultHeight et defaultWidth contrôlent les dimensions initiales. Faites également attention aux attributs minHeight et minWidth pour empêcher vos joueurs de redimensionner la fenêtre du jeu dans des dimensions que vous ne prenez pas en charge. Enfin, l'attribut gravity détermine l'emplacement de la fenêtre à l'écran lors de son lancement. 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 pour définir la taille de la fenêtre consiste à utiliser des 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 dans un état 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 offre une bonne prise en charge du mode multifenêtre.

Compatibilité avec les positions des appareils pliables

Utilisez la bibliothèque de mise en page WindowManager de Jetpack pour prendre en charge les positions pliées, comme la position sur table, afin d'améliorer 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);
}