Limitare l'orientamento dell'app sugli smartphone, ma non sui dispositivi con schermi grandi

La tua app funziona perfettamente sugli smartphone in formato verticale, quindi hai limitato l'app solo al formato verticale. Tuttavia, vedi un'opportunità per fare di più su schermi di grandi dimensioni in orientamento orizzontale.

Come puoi avere entrambe le cose: limitare l'app all'orientamento verticale su schermi piccoli, ma attivare l'orientamento orizzontale su schermi grandi?

Questa guida è una misura temporanea finché non potrai migliorare la tua app per fornire un supporto completo per tutte le configurazioni del dispositivo.

Gestire l'orientamento dell'app

Per attivare l'orientamento orizzontale su schermi di grandi dimensioni, imposta il file manifest dell'app in modo che gestisca le modifiche dell'orientamento per impostazione predefinita. In fase di esecuzione, determina le dimensioni della finestra dell'app. Se la finestra dell'app è piccola, limita l'orientamento dell'app sostituendo l'impostazione dell'orientamento del manifest.

1. Specificare l'impostazione dell'orientamento nel file manifest dell'app

Puoi evitare di dichiarare l'elemento screenOrientation del manifest dell'app (in questo caso l'orientamento predefinito è unspecified) o impostare l'orientamento dello schermo su fullUser. Se l'utente non ha bloccato la rotazione basata sui sensori, la tua app supporterà tutti gli orientamenti del dispositivo.

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

La differenza tra unspecified e fullUser è sottile, ma importante. Se non dichiari un valore screenOrientation, il sistema sceglie l'orientamento e il criterio utilizzato per definirlo potrebbe essere diverso da un dispositivo all'altro. D'altra parte, la specifica di fullUser corrisponde più da vicino al comportamento definito dall'utente per il dispositivo: se l'utente ha bloccato la rotazione basata sui sensori, l'app segue la preferenza dell'utente; in caso contrario, il sistema consente uno dei quattro possibili orientamenti dello schermo (ritratto, orizzontale, ritratto inverso o orizzontale inverso). Consulta screenOrientation.

2. Determinare le dimensioni dello schermo

Con il file manifest impostato per supportare tutti gli orientamenti consentiti dall'utente, puoi specificare l'orientamento dell'app in modo programmatico in base alle dimensioni dello schermo.

Aggiungi le librerie Jetpack WindowManager al file build.gradle o build.gradle.kts del modulo:

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

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

Utilizza il metodo WindowManager WindowMetricsCalculator#computeMaximumWindowMetrics() di Jetpack per ottenere le dimensioni dello schermo del dispositivo come oggetto WindowMetrics. Le metriche della finestra possono essere messe in confronto con le classi di dimensioni della finestra per decidere quando limitare l'orientamento.

Le classi di dimensioni di Windows forniscono gli intervalli tra le schermate piccole e grandi.

Utilizza gli indicatori di interruzione WindowWidthSizeClass#COMPACT e WindowHeightSizeClass#COMPACT per determinare le dimensioni dello schermo:

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

Nota:
• Gli esempi sono implementati come metodi di un'attività, pertanto l'attività viene dereferenziata come this nell'argomento di computeMaximumWindowMetrics().
• Viene utilizzato il metodo computeMaximumWindowMetrics() anziché computeCurrentWindowMetrics() perché l'app può essere avviata in modalità multi-finestra, che ignora l'impostazione dell'orientamento dello schermo. Non ha senso determinare le dimensioni della finestra dell'app e sostituire l'impostazione dell'orientamento, a meno che la finestra dell'app non sia l'intero schermo del dispositivo.

Consulta WindowManager per istruzioni su come dichiarare le dipendenze per rendere disponibile il metodo computeMaximumWindowMetrics() nella tua app.

3. Sostituire l'impostazione del manifest dell'app

Una volta stabilito che il dispositivo ha uno schermo compatto, puoi chiamare Activity#setRequestedOrientation() per sostituire l'impostazione screenOrientation del manifest:

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

Aggiungendo la logica ai metodi onCreate() e View.onConfigurationChanged(), puoi ottenere le metriche della finestra massima e ignorare l'impostazione dell'orientamento ogni volta che l'attività viene ridimensionata o spostata tra i display, ad esempio dopo la rotazione di un dispositivo o quando un dispositivo pieghevole viene chiuso o aperto. Per ulteriori informazioni su quando si verificano le modifiche alla configurazione e quando causano la ricreazione delle attività, consulta Gestire le modifiche alla configurazione.

Punti chiave

• screenOrientation: impostazione del manifest dell'app che consente di specificare come l'app risponde alle modifiche dell'orientamento del dispositivo
• Jetpack WindowManager: insieme di librerie che ti consentono di determinare le dimensioni e le proporzioni della finestra dell'app; compatibile con le versioni precedenti fino al livello API 14
• Activity#setRequestedOrientation(): metodo con cui puoi cambiare l'orientamento dell'app in fase di esecuzione

Risultati

Ora l'app dovrebbe rimanere in orientamento verticale su schermi piccoli indipendentemente dalla rotazione del dispositivo. Su schermi di grandi dimensioni, l'app deve supportare gli orientamenti orizzontale e verticale.

Raccolte che contengono questa guida

Questa guida fa parte di queste raccolte di guide rapide selezionate che coprono obiettivi di sviluppo Android più ampi:

Ottimizzazione per schermi di grandi dimensioni

Consenti alla tua app di supportare un'esperienza utente ottimizzata su tablet, dispositivi pieghevoli e ChromeOS.

Collezione di guide rapide

Domande o feedback

Visita la nostra pagina delle domande frequenti e scopri le guide rapide o contattaci per farci sapere cosa ne pensi.

Vai alle domande frequenti Lascia un feedback