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:
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 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:
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 sind als Methoden einer Aktivität implementiert. Daher wird die Aktivität im Argument von
computeMaximumWindowMetrics()
alsthis
dereferenziert. - Die Methode
computeMaximumWindowMetrics()
wird anstelle voncomputeCurrentWindowMetrics()
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:
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 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: