Unterstützung großer Bildschirmgrößen

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Wenn Sie von Smartphones auf verschiedene Formfaktoren mit großen Bildschirmen umstellen, müssen Sie berücksichtigen, wie Ihr Spiel die Fensterverwaltung handhabt. Unter ChromeOS und Google Play Spiele auf dem PC kann Ihr Spiel im Fenstermodus über die Hauptoberfläche des Desktops ausgeführt werden. Auf neuen Android-Tablets und faltbaren Geräten mit Android 12L (API-Ebene 32) oder höher mit einer Bildschirmbreite von mehr als 600 dp kann Ihr Spiel im Splitscreen-Modus neben anderen Apps ausgeführt, die Größe geändert und auf faltbaren Geräten sogar zwischen dem inneren und dem äußeren Display verschoben werden. Dies führt zu einer Konfigurationsänderung für die Fenstergröße und auf einigen Geräten auch für die Ausrichtung.

Größenänderung bei Unity-Spielen

Grundlegende Konfiguration für große Bildschirme

Geben Sie an, ob Ihr Spiel die Größe ändern kann:

 or "false" />

Wenn die Größe nicht geändert werden kann, müssen im Spielmanifest das minimale und maximale unterstützte Seitenverhältnis ausdrücklich definiert werden:

 android:minAspectRatio="1.5">
 android:maxAspectRatio="2.33">

Google Play Spiele auf dem PC

Bei Google Play Spiele auf dem PC kann die Größe des Fensters geändert werden, wobei das angegebene Seitenverhältnis beibehalten wird. Die Fenstergröße wird automatisch auf die optimalen Abmessungen festgelegt. Sie müssen mindestens ein Seitenverhältnis von 16:9 unterstützen, wenn die Hauptausrichtung im Querformat ist, und ein Seitenverhältnis von 9:16, wenn Ihr Spiel im Hochformat ist. Für die beste Leistung sollten Sie die Seitenverhältnisse 21:9, 16:10 und 3:2 für ein Spiel im Querformat explizit unterstützen. Die Größe des Fensters kann hier nicht geändert werden, was aber für die Kompatibilität mit anderen Formfaktoren von Vorteil ist.

Weitere Informationen und Best Practices finden Sie unter Grafik für Google Play Spiele auf dem PC konfigurieren.

Große Bildschirme unter ChromeOS und Android

Wenn Sie den sichtbaren Bereich für Ihr Spiel im Vollbildmodus auf ChromeOS-Geräten und Android-Geräten mit großem Display maximieren möchten, unterstützen Sie den Vollbildmodus und blenden Sie die Systemleisten aus, indem Sie Flags für decorView, die Sichtbarkeit der System-UI oder die WindowInsetsCompat API festlegen. Außerdem sollten Sie Konfigurationsereignisse wie Bildschirmausrichtung und -größenänderung ordnungsgemäß verarbeiten oder verhindern, dass sie auf ChromeOS-Geräten auftreten.

Auf Android-Geräten mit großem Bildschirm kann Ihr Spiel in Konfigurationen ausgeführt werden, die Sie möglicherweise noch nicht unterstützen. Wenn Ihr Spiel nicht alle Konfigurationen für Fenstergröße und -ausrichtung unterstützt, wird es im Kompatibilitätsmodus im Letterbox-Format angezeigt. Falls erforderlich, wird der Spieler vor dem Wechsel zu einer nicht unterstützten Konfiguration aufgefordert.

Wenn ein Nutzer auf einem Gerät zu einer nicht unterstützten Konfiguration wechselt, wird er möglicherweise aufgefordert, das Spiel neu zu laden und die Aktivität so neu zu erstellen, dass sie am besten zum neuen Fensterlayout passt. Das beeinträchtigt das Spielerlebnis. Testen Sie Ihr Spiel in verschiedenen Konfigurationen des Multifenstermodus (Fenstergröße 2/3, 1/2, 1/3) und prüfen Sie, ob keine Spiel- oder UI-Elemente abgeschnitten oder nicht zugänglich sind. Testen Sie außerdem, wie Ihr Spiel auf faltbare Geräte reagiert, wenn Sie zwischen dem inneren und dem äußeren Display wechseln. Wenn Probleme auftreten, müssen Sie diese Konfigurationsereignisse explizit verarbeiten und eine erweiterte Unterstützung für die Größenänderung auf großen Bildschirmen hinzufügen.

Erweiterte Größenanpassung auf großen Bildschirmen

So beenden Sie den Kompatibilitätsmodus und vermeiden die Neuerstellung von Aktivitäten:

1. Deklarieren Sie Ihre Hauptaktivität als skalierbar:

    />
   

2. Deklarieren Sie im Attribut android:configChanges des Elements Ihres Spielmanifests die explizite Unterstützung für „orientation“, „screenSize“, „smallestScreenSize“, „screenLayout“ und „density“, um alle Konfigurationsereignisse für große Bildschirme zu erhalten:

    | smallestScreenSize | screenLayout | orientation | keyboard |
                           keyboardHidden | density" />
   

3. Überschreiben Sie onConfigurationChanged() und verarbeiten Sie das Konfigurationsereignis, einschließlich der aktuellen Ausrichtung, Fenstergröße, Breite und Höhe:

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

Sie können auch WindowManager abfragen, um die aktuelle Gerätedrehung zu prüfen. Prüfe anhand dieser Metadaten die neuen Fensterabmessungen und rendere sie in der vollständigen Fenstergröße. Aufgrund von Unterschieden beim Seitenverhältnis funktioniert das möglicherweise nicht in allen Fällen. Alternativ können Sie die Benutzeroberfläche Ihres Spiels an der neuen Fenstergröße verankern und die Hauptinhalte des Gameplays im Letterbox-Format anzeigen. Wenn technische oder Designeinschränkungen einen der beiden Ansätze verhindern, kannst du ein eigenes In-Engine-Letterboxing verwenden, um das Seitenverhältnis beizubehalten, und die Videowiedergabe auf die bestmöglichen Abmessungen skalieren. Deklariere dabei resizeableActivity = false und vermeide den Konfigurationsmodus.

Unabhängig von Ihrem Ansatz sollten Sie Ihr Spiel in verschiedenen Konfigurationen testen (Zu- und Aufklappen, verschiedene Drehungen, Splitscreen-Modus) und darauf achten, dass keine UI-Elemente im Spiel abgeschnitten oder überlappend sind, keine Probleme mit der Zugänglichkeit von Touch-Targets auftreten und keine Probleme mit dem Seitenverhältnis vorliegen, die dazu führen, dass das Spiel gedehnt, gestaucht oder anderweitig verzerrt wird.

Außerdem bedeuten größere Bildschirme in der Regel größere Pixel, da dieselbe Anzahl von Pixeln auf einer viel größeren Fläche verteilt ist. Das kann bei verkleinerten Framebuffern oder Assets mit niedriger Auflösung zu Pixelfehlern führen. Verwenden Sie auf Geräten mit großem Display die Assets mit der höchsten Qualität und erstellen Sie ein Leistungsprofil für Ihr Spiel, um Probleme zu vermeiden. Wenn Ihr Spiel mehrere Qualitätsstufen unterstützt, muss es auch Geräte mit großen Displays berücksichtigen.

Mehrfenstermodus

Im Multifenstermodus können mehrere Apps gleichzeitig auf demselben Bildschirm angezeigt werden. Der Aktivitätszyklus ändert sich durch den Modus mit mehreren Fenstern nicht. Der fortgesetzte Status von Apps in mehreren Fenstern unterscheidet sich jedoch in verschiedenen Android-Versionen (siehe Aktivitätszyklus im Modus mit mehreren Fenstern unter Modus mit mehreren Fenstern unterstützen).

Wenn der Nutzer eine App oder ein Spiel im Multifenstermodus öffnet, benachrichtigt das System die Aktivität einer Konfigurationsänderung, wie im Abschnitt Erweiterte Größeanpassung auf großen Bildschirmen angegeben. Eine Konfigurationsänderung tritt auch auf, wenn der Spieler die Größe des Spiels ändert oder es wieder in den Vollbildmodus versetzt.

Es gibt keine Garantie dafür, dass die Anwendung wieder den Fokus erhält, wenn sie in den Mehrfenstermodus versetzt wird. Wenn Sie also eines der App-Statusereignisse verwenden, um Ihr Spiel anzuhalten, sollten Sie nicht das Ereignis „acquire focus“ (onWindowFocusChanged() mit dem Fokuswert „true“) verwenden, um das Spiel fortzusetzen. Verwenden Sie stattdessen andere Ereignis- oder Statusänderungs-Handler wie onConfigurationChanged() oder onResume(). Mit der Methode isInMultiWindowMode() können Sie jederzeit prüfen, ob die aktuelle Aktivität im Multifenstermodus ausgeführt wird.

Im Mehrfenstermodus von ChromeOS sind die ursprünglichen Fensterabmessungen ein wichtiger Faktor. Ein Spiel muss nicht im Vollbildmodus angezeigt werden. Sie müssen angeben, wie groß das Fenster in diesem Fall sein soll. Dafür gibt es zwei empfohlene Vorgehensweisen.

Bei der ersten Option werden bestimmte Attribute für das -Tag in Ihrem Android-Manifest verwendet. Die Attribute defaultHeight und defaultWidth steuern die ursprünglichen Dimensionen. Achten Sie auch auf die Attribute minHeight und minWidth, um zu verhindern, dass Ihre Spieler das Spielfenster auf eine Größe ändern, die Sie nicht unterstützen. Schließlich gibt es das gravity-Attribut, das festlegt, wo auf dem Bildschirm das Fenster beim Starten angezeigt wird. Hier ein Beispiel für ein Layout-Tag mit diesen Attributen:

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

Die zweite Option zum Festlegen der Fenstergröße funktioniert mithilfe dynamischer Startgrenzen. Mit setLaunchBounds(Rect)⁠⁠ können Sie die Anfangsabmessungen des Fensters definieren. Wenn ein leeres Rechteck angegeben wird, wird die Aktivität maximiert gestartet.

Wenn Sie die Unity- oder Unreal-Spiele-Engine verwenden, achten Sie außerdem darauf, dass Sie eine aktuelle Version (Unity 2019.4.40 und Unreal 5.3 oder höher) verwenden, die den Modus mit mehreren Fenstern gut unterstützt.

Faltbarer Rückensupport

Verwenden Sie die WindowManager-Layoutbibliothek von Jetpack, um faltbare Positionen wie die Tablet-Position zu unterstützen und so die Immersion und Interaktion der Spieler zu verbessern:

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