App-Ausrichtung auf Smartphones, aber nicht auf Geräten mit großen Displays einschränken

Ihre App funktioniert auf Smartphones im Hochformat einwandfrei. Daher haben Sie die App auf das Hochformat beschränkt. Sie sehen jedoch die Möglichkeit, auf großen Displays im Querformat mehr zu tun.

Wie kann man die App auf kleinen Bildschirmen auf das Hochformat beschränken, auf großen Bildschirmen aber das Querformat aktivieren?

Dieser Leitfaden ist eine vorübergehende Maßnahme, bis Sie Ihre App so verbessern können, dass alle Gerätekonfigurationen vollständig unterstützt werden.

Ergebnisse

Ihre App bleibt auf kleinen Bildschirmen unabhängig von der Geräteausrichtung im Hochformat. Auf großen Displays unterstützt die App sowohl das Quer- als auch das Hochformat.

App-Ausrichtung verwalten

Wenn Sie die Querformat-Ausrichtung auf großen Displays aktivieren möchten, legen Sie im App-Manifest fest, dass Ausrichtungsänderungen standardmäßig verarbeitet werden. Bestimmen Sie zur Laufzeit die Größe des App-Fensters. Wenn das App-Fenster klein ist, können Sie die Ausrichtung der App einschränken, indem Sie die Ausrichtungseinstellung im Manifest überschreiben.

1. Ausrichtungseinstellung im App-Manifest angeben

Sie können entweder das Element screenOrientation im App-Manifest nicht deklarieren (in diesem Fall wird die Ausrichtung standardmäßig auf unspecified festgelegt) oder die Bildschirmausrichtung auf fullUser festlegen. Wenn der Nutzer die sensorbasierte Drehung nicht gesperrt hat, unterstützt Ihre App alle Geräteausrichtungen.

<activity
    android:name=".MyActivity"
    android:screenOrientation="fullUser">

Der Unterschied zwischen unspecified und fullUser ist gering, aber wichtig. Wenn Sie keinen screenOrientation-Wert deklarieren, wählt das System die Ausrichtung aus. Die Richtlinie, die das System zur Definition der Ausrichtung verwendet, kann sich von Gerät zu Gerät unterscheiden. Wenn Sie hingegen fullUser angeben, entspricht das eher dem Verhalten, das der Nutzer für das Gerät definiert hat: Wenn der Nutzer die sensorbasierte Drehung gesperrt hat, folgt die App der Nutzereinstellung. Andernfalls erlaubt das System alle vier möglichen Bildschirmausrichtungen (Hochformat, Querformat, umgekehrtes Hochformat oder umgekehrtes Querformat). Weitere Informationen finden Sie unter screenOrientation.

2. Bildschirmgröße ermitteln

Wenn das Manifest so konfiguriert ist, dass alle vom Nutzer erlaubten Ausrichtungen unterstützt werden, können Sie die App-Ausrichtung programmatisch basierend auf der Bildschirmgröße festlegen.

Fügen Sie die Jetpack WindowManager-Bibliotheken der Datei build.gradle oder build.gradle.kts des Moduls hinzu:

Kotlin

implementation("androidx.window:window:version")
implementation("androidx.window:window-core:version")

Groovy

implementation 'androidx.window:window:version'
implementation 'androidx.window:window-core:version'

Verwenden Sie die Jetpack WindowManager-Methode WindowMetricsCalculator#computeMaximumWindowMetrics(), um die Displaygröße des Geräts als WindowMetrics-Objekt abzurufen. Die Fenstermesswerte können mit Fenstergrößenklassen verglichen werden, um zu entscheiden, wann die Ausrichtung eingeschränkt werden soll.

Fenstergrößenklassen bieten die Breakpoints zwischen kleinen und großen Bildschirmen.

Verwenden Sie die Breakpoints WindowWidthSizeClass#COMPACT und WindowHeightSizeClass#COMPACT, um die Bildschirmgröße zu bestimmen:

Kotlin

/** Determines whether the device has a compact screen. **/
fun compactScreen() : Boolean {
    val metrics = WindowMetricsCalculator.getOrCreate().computeMaximumWindowMetrics(this)
    val width = metrics.bounds.width()
    val height = metrics.bounds.height()
    val density = resources.displayMetrics.density
    val windowSizeClass = WindowSizeClass.compute(width/density, height/density)

    return windowSizeClass.windowWidthSizeClass == WindowWidthSizeClass.COMPACT ||
        windowSizeClass.windowHeightSizeClass == WindowHeightSizeClass.COMPACT
}

Java

/** Determines whether the device has a compact screen. **/
private boolean compactScreen() {
    WindowMetrics metrics = WindowMetricsCalculator.getOrCreate().computeMaximumWindowMetrics(this);
    int width = metrics.getBounds().width();
    int height = metrics.getBounds().height();
    float density = getResources().getDisplayMetrics().density;
    WindowSizeClass windowSizeClass = WindowSizeClass.compute(width/density, height/density);
    return windowSizeClass.getWindowWidthSizeClass() == WindowWidthSizeClass.COMPACT ||
                windowSizeClass.getWindowHeightSizeClass() == WindowHeightSizeClass.COMPACT;
}
    Hinweis:
  • Die Beispiele werden als Methoden einer Aktivität implementiert. Daher wird die Aktivität im Argument von computeMaximumWindowMetrics() als this dereferenziert.
  • Die Methode computeMaximumWindowMetrics() wird anstelle von computeCurrentWindowMetrics() verwendet, da die App im Mehrfenstermodus gestartet werden kann, wodurch die Einstellung für die Bildschirmausrichtung ignoriert wird. Es ist nicht sinnvoll, die Größe des App-Fensters zu bestimmen und die Ausrichtungseinstellung zu überschreiben, es sei denn, das App-Fenster entspricht dem gesamten Gerätebildschirm.

Eine Anleitung zum Deklarieren von Abhängigkeiten, damit die computeMaximumWindowMetrics()-Methode in Ihrer App verfügbar ist, finden Sie unter WindowManager.

3. Einstellung im App-Manifest überschreiben

Wenn Sie festgestellt haben, dass das Gerät eine kompakte Displaygröße hat, können Sie Activity#setRequestedOrientation() aufrufen, um die screenOrientation-Einstellung des Manifests zu überschreiben:

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    requestedOrientation = if (compactScreen())
        ActivityInfo.SCREEN_ORIENTATION_PORTRAIT else
        ActivityInfo.SCREEN_ORIENTATION_FULL_USER
    ...
    // Replace with a known container that you can safely add a
    // view to where the view won't affect the layout and the view
    // won't be replaced.
    val container: ViewGroup = binding.container

    // Add a utility view to the container to hook into
    // View.onConfigurationChanged. This is required for all
    // activities, even those that don't handle configuration
    // changes. You can't use Activity.onConfigurationChanged,
    // since there are situations where that won't be called when
    // the configuration changes. View.onConfigurationChanged is
    // called in those scenarios.
    container.addView(object : View(this) {
        override fun onConfigurationChanged(newConfig: Configuration?) {
            super.onConfigurationChanged(newConfig)
            requestedOrientation = if (compactScreen())
                ActivityInfo.SCREEN_ORIENTATION_PORTRAIT else
                ActivityInfo.SCREEN_ORIENTATION_FULL_USER
        }
    })
}

Java

@Override
protected void onCreate(Bundle savedInstance) {
    super.onCreate(savedInstanceState);
    if (compactScreen()) {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    } else {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_FULL_USER);
    }
    ...
    // Replace with a known container that you can safely add a
    // view to where the view won't affect the layout and the view
    // won't be replaced.
    ViewGroup container = binding.container;

    // Add a utility view to the container to hook into
    // View.onConfigurationChanged. This is required for all
    // activities, even those that don't handle configuration
    // changes. You can't use Activity.onConfigurationChanged,
    // since there are situations where that won't be called when
    // the configuration changes. View.onConfigurationChanged is
    // called in those scenarios.
    container.addView(new View(this) {
        @Override
        protected void onConfigurationChanged(Configuration newConfig) {
            super.onConfigurationChanged(newConfig);
            if (compactScreen()) {
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            } else {
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_FULL_USER);
            }
        }
    });
}

Wenn Sie die Logik den Methoden onCreate() und View.onConfigurationChanged() hinzufügen, können Sie die Messwerte für das maximale Fenster abrufen und die Ausrichtungseinstellung überschreiben, wenn die Größe der Aktivität geändert oder sie zwischen Displays verschoben wird, z. B. nach einer Drehung des Geräts oder wenn ein faltbares Gerät gefaltet oder entfaltet wird. Weitere Informationen dazu, wann Konfigurationsänderungen auftreten und wann sie dazu führen, dass Aktivitäten neu erstellt werden, finden Sie unter Konfigurationsänderungen verarbeiten.

Wichtige Fakten

  • screenOrientation: App-Manifesteinstellung, mit der Sie festlegen können, wie Ihre App auf Änderungen der Geräteausrichtung reagiert
  • Jetpack WindowManager: Eine Reihe von Bibliotheken, mit denen Sie die Größe und das Seitenverhältnis des App-Fensters bestimmen können. Abwärtskompatibel bis API-Level 14.
  • Activity#setRequestedOrientation(): Methode, mit der Sie die Ausrichtung der App zur Laufzeit ändern können

Sammlungen, die diesen Leitfaden enthalten

Dieser Leitfaden ist Teil der folgenden kuratierten Sammlungen von Kurzanleitungen, die umfassendere Ziele der Android-Entwicklung abdecken:

Sorgen Sie dafür, dass Ihre App eine optimierte Nutzerfreundlichkeit auf Tablets, Foldables und ChromeOS-Geräten bietet.
Sammlung von Kurzanleitungen

Fragen oder Feedback

Auf der Seite mit den häufig gestellten Fragen finden Sie Kurzanleitungen. Sie können uns aber auch gern kontaktieren und uns Ihre Meinung mitteilen.
Zu den FAQs Feedback geben