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

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

Wie können Sie 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 sie alle Gerätekonfigurationen vollständig unterstützt.

App-Ausrichtung verwalten

Wenn Sie die Querformatanzeige auf großen Bildschirmen aktivieren möchten, legen Sie in Ihrem App-Manifest fest, dass die Ausrichtung standardmäßig geändert werden soll. Bestimmen Sie die Größe des App-Fensters zur Laufzeit. Wenn das App-Fenster klein ist, beschränken Sie die Ausrichtung der App, indem Sie die Manifest-Ausrichtungseinstellung überschreiben.

1. Ausrichtungseinstellung im App-Manifest angeben

Sie können entweder das Element screenOrientation des App-Manifests nicht deklarieren (in diesem Fall ist die Standardausrichtung unspecified) 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 subtil, aber wichtig. Wenn Sie keinen screenOrientation-Wert angeben, wählt das System die Ausrichtung aus. Die Richtlinie, die das System zum Definieren der Ausrichtung verwendet, kann sich von Gerät zu Gerät unterscheiden. Wenn Sie hingegen fullUser angeben, entspricht das eher dem vom Nutzer für das Gerät festgelegten Verhalten: Wenn der Nutzer die sensorbasierte Drehung gesperrt hat, folgt die App der Nutzereinstellung. Andernfalls erlaubt das System jede der 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 zulässigen Ausrichtungen unterstützt werden, können Sie die App-Ausrichtung programmatisch basierend auf der Bildschirmgröße angeben.

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

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

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

Verwenden Sie die Methode WindowMetricsCalculator#computeMaximumWindowMetrics() des Jetpack WindowManager, um die Bildschirmgröß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 geben die Grenzwerte zwischen kleinen und großen Bildschirmen an.

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

/** 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
}

/** 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 sind 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 Displayausrichtung ignoriert wird. Es hat keinen Sinn, die Größe des App-Fensters zu bestimmen und die Ausrichtungseinstellung zu überschreiben, es sei denn, das App-Fenster umfasst den gesamten Bildschirm des Geräts.

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

3. Einstellung im App-Manifest überschreiben

Wenn Sie festgestellt haben, dass das Gerät ein kompaktes Display hat, können Sie Activity#setRequestedOrientation() aufrufen, um die screenOrientation-Einstellung des Manifests zu überschreiben:

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

@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 maximale Fenstergröße erhalten und die Ausrichtungseinstellung überschreiben, wenn die Aktivität die Größe ändert oder zwischen Displays verschoben wird, z. B. nach einer Gerätedrehung oder wenn ein faltbares Gerät zusammengeklappt oder aufgeklappt wird. Weitere Informationen dazu, wann Konfigurationsänderungen auftreten und wann sie zu einer Neuerstellung von Aktivitäten führen, finden Sie unter Konfigurationsänderungen verarbeiten.

Wichtige Fakten

• screenOrientation: App-Manifest-Einstellung, mit der Sie festlegen können, wie Ihre App auf Änderungen der Geräteausrichtung reagiert
• Jetpack WindowManager: Bibliotheken, mit denen Sie Größe und Seitenverhältnis des App-Fensters festlegen können; abwärtskompatibel mit API-Level 14
• Activity#setRequestedOrientation(): Methode, mit der Sie die App-Ausrichtung zur Laufzeit ändern können

Ergebnisse

Ihre App sollte jetzt auf kleinen Bildschirmen unabhängig von der Gerätedrehung im Hochformat bleiben. Auf großen Bildschirmen sollte die App das Quer- und Hochformat unterstützen.

Sammlungen, die diesen Leitfaden enthalten

Dieser Leitfaden ist Teil der folgenden ausgewählten Sammlungen von Kurzanleitungen, die allgemeinere Ziele der Android-Entwicklung abdecken:

Für große Bildschirme optimieren

Sorgen Sie dafür, dass Ihre App auf Tablets, faltbaren Geräten und ChromeOS-Geräten optimiert genutzt werden kann.

Sammlung von Kurzanleitungen

Hast du Fragen oder Feedback?

Auf unserer Seite mit häufig gestellten Fragen finden Sie Kurzanleitungen. Sie können sich auch gern an uns wenden.

Zu den FAQs Feedback geben