Para llegar a una audiencia amplia y garantizar una experiencia de usuario óptima en la diversidad de dispositivos Android existentes, es crucial implementar diseños de interfaz de usuario adaptables. Una interfaz bien adaptada garantiza una visualización coherente y funcional en teléfonos inteligentes, tabletas, dispositivos plegables, equipos con Chrome OS, así como en diferentes orientaciones (vertical u horizontal) y modos redimensionables, como la multi-ventana.

Categorías de Tamaño de Ventana para Diseño Adaptable

Las categorías de tamaño de ventana representan un conjunto de umbrales en el tamaño del área visible de una aplicación, diseñados para facilitar la creación, el desarrollo y la validación de interfaces de usuario adaptables. Estos puntos de ruptura se han definido estratégicamente para ofrecer un equilibrio entre simplicidad de implementación y la flexibilidad necesaria para optimizar la experiencia de usuario en escenarios variados.

Estas categorías clasifican el espacio de visualización disponible para una aplicación en tres estados: Compacto, Medio y Expandido. La clasificación se aplica de manera independiente tanto al ancho como a la altura disponible, lo que significa que en cualquier momento, una aplicación tiene una categoría de tamaño para el ancho y otra para la altura. Sin embargo, dada la prevalencia del desplazamiento vertical, la categoría de ancho suele ser más influyente en la adaptación de la interfaz.

Puntos de Ruptura y Dispositivos Típicos

Los puntos de ruptura de las categorías de tamaño de ventana se correlacionan con escenarios de dispositivos comunes, sirviendo como un marco de referencia útil al diseñar interfaces. Aunque es valioso conceptualizar estos umbrales en relación con los dispositivos físicos, es importante recordar que las categorías de tamaño de ventana son dinámicas y no están inherentemente ligadas al tamaño físico de la pantalla, sino al espacio que la aplicación tiene disponible.

• Ancho Compacto: Menos de 600dp. Repersenta la mayoría de los teléfonos en orientación vertical.
• Ancho Medio: 600dp o más. Típico en tabletas en orientación vertical y grandes pantallas internas de dispositivos plegables.
• Ancho Expandido: 840dp o más. Usualmente en tabletas en orientación horizontal y grandes pantallas internas de dispositivos plegables en horizontal.
• Altura Compacta: Menos de 480dp. Frecuente en teléfonos en orientación horizontal.
• Altura Media: 480dp o más. Observado en tabletas en horizontal y la mayoría de los teléfonos en vertical.
• Altura Expandida: 900dp o más. Común en tabletas en vertical.

Nota: Para la mayoría de las aplicaciones, centrarse en las categorías de tamaño de ancho es suficiente al construir interfaces adaptables.

Naturaleza Dinámica de las Categorías de Ventana

Las categorías de tamaño de ventana no corresponden a una lógica de "es una tableta", sino que están determinadas por el espacio de la ventana disponible para la aplicación, independientemente del tipo de dispositivo que la ejecuta. Esto tiene dos implicaciones significativas:

• Un dispositivo físico no garantiza una categoría de tamaño de ventana específica. El espacio disponible puede variar debido a modos de pantalla dividida en móviles, ventanas flotantes redimensionables en Chrome OS, o los diferentes estados de plegado/desplegado en dispositivos plegables.
• Las categorías pueden cambiar durante el ciclo de vida de la aplicación. La rotación del dispositivo, la multitarea, o los estados de plegado/desplegado pueden alterar el espacio disponible. Por lo tanto, la interfaz de la aplicación debe ajustarse dinámicamente.

Estas categorías se alinean con los puntos de ruptura de diseño adaptativo de Material Design. Son útiles para tomar decisiones de diseño de alto nivel, como decidir si adoptar un diseño canónico particular para aprovechar el espacio adicional de la pantalla.

Cálculo de Categorías de Tamaño de Ventana en Vistas y Compose

Las aplicaciones basadas en vistas deben calcular las categorías de tamaño de ventana a partir de las métricas proporcionadas por la biblioteca Jetpack WindowManager. A continuación, se muestra cómo calcular estas categorías y recibir actualizaciones cuando cambian, utilizando Kotlin y Java:

Vistas (Kotlin)

import android.app.Activity
import android.content.res.Configuration
import android.os.Bundle
import android.view.View
import android.view.ViewGroup
import androidx.window.layout.WindowMetricsCalculator

enum class ScreenCategory { SMALL, REGULAR, LARGE }

class ResponsiveActivity : Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ... (establecer el contenido de la vista, por ejemplo, setContentView(R.layout.activity_responsive))

        // Identifique un contenedor donde pueda añadir una vista auxiliar de forma segura.
        // Por ejemplo, el contenedor raíz de su diseño.
        val displayContainer: ViewGroup = findViewById(android.R.id.content)

        // Añadir una vista utilitaria para capturar los cambios de configuración.
        // Esto es necesario porque Activity.onConfigurationChanged no siempre se invoca.
        displayContainer.addView(object : View(this) {
            override fun onConfigurationChanged(newConfig: Configuration?) {
                super.onConfigurationChanged(newConfig)
                calculateScreenCategories()
            }
        })
        calculateScreenCategories()
    }

    private fun calculateScreenCategories() {
        val windowMetrics = WindowMetricsCalculator.getOrCreate()
            .computeCurrentWindowMetrics(this)

        val density = resources.displayMetrics.density
        val widthInDp = windowMetrics.bounds.width() / density

        val widthCategory = when {
            widthInDp < 600f -> ScreenCategory.SMALL
            widthInDp < 840f -> ScreenCategory.REGULAR
            else -> ScreenCategory.LARGE
        }

        val heightInDp = windowMetrics.bounds.height() / density
        val heightCategory = when {
            heightInDp < 480f -> ScreenCategory.SMALL
            heightInDp < 900f -> ScreenCategory.REGULAR
            else -> ScreenCategory.LARGE
        }

        // Aquí se pueden utilizar widthCategory y heightCategory para ajustar el UI.
        // Log.d("ResponsiveActivity", "Width Category: $widthCategory, Height Category: $heightCategory")
    }
}

Vistas (Java)

import android.app.Activity;
import android.content.res.Configuration;
import android.os.Bundle;
import android.view.View;
import android.view.ViewGroup;

import androidx.window.layout.WindowMetrics;
import androidx.window.layout.WindowMetricsCalculator;

public enum DimensionGroup { SMALL, MEDIUM, LARGE }

public class AdaptableActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // ... (establecer el contenido de la vista, por ejemplo, setContentView(R.layout.activity_adaptable))

        // Encuentra un contenedor seguro, como el contenido raíz de la Activity.
        ViewGroup rootLayout = findViewById(android.R.id.content);

        // Añade una vista auxiliar para detectar cambios de configuración.
        rootLayout.addView(new View(this) {
            @Override
            protected void onConfigurationChanged(Configuration newConfig) {
                super.onConfigurationChanged(newConfig);
                determineScreenDimensions();
            }
        });

        determineScreenDimensions();
    }

    private void determineScreenDimensions() {
        WindowMetrics currentWindowMetrics = WindowMetricsCalculator.getOrCreate()
                .computeCurrentWindowMetrics(this);

        float displayDensity = getResources().getDisplayMetrics().density;

        float currentWidthInDp = currentWindowMetrics.getBounds().width() / displayDensity;
        DimensionGroup widthGroup;

        if (currentWidthInDp < 600f) {
            widthGroup = DimensionGroup.SMALL;
        } else if (currentWidthInDp < 840f) {
            widthGroup = DimensionGroup.MEDIUM;
        } else {
            widthGroup = DimensionGroup.LARGE;
        }

        float currentHeightInDp = currentWindowMetrics.getBounds().height() / displayDensity;
        DimensionGroup heightGroup;

        if (currentHeightInDp < 480f) {
            heightGroup = DimensionGroup.SMALL;
        } else if (currentHeightInDp < 900f) {
            heightGroup = DimensionGroup.MEDIUM;
        } else {
            heightGroup = DimensionGroup.LARGE;
        }

        // Aquí se pueden usar widthGroup y heightGroup para influir en el layout.
        // Por ejemplo: Log.d("AdaptableActivity", "Width Group: " + widthGroup + ", Height Group: " + heightGroup);
    }
}

Compose

Las aplicaciones basadas en Jetpack Compose deben utilizar la función calculateWindowSizeClass() de la biblioteca material3-window-size-class para obtener la WindowSizeClass actual.

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.material3.windowsizeclass.calculateWindowSizeClass
import androidx.compose.runtime.Composable // Asegúrate de importar Composable si defines MyAdaptiveApp aquí

class ResponsiveComposeActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            val currentWindowSizeClass = calculateWindowSizeClass(this)
            MyAdaptiveApp(currentWindowSizeClass) // Reemplaza MyApp
        }
    }
}

// Ejemplo de cómo podrías usar MyAdaptiveApp
// @Composable
// fun MyAdaptiveApp(windowSizeClass: WindowSizeClass) {
//    // Implementa aquí la lógica de tu UI adaptable usando windowSizeClass
//    // Por ejemplo, un NavigationRail en ancho expandido, un BottomNavigation en ancho compacto.
//    when (windowSizeClass.widthSizeClass) {
//        WindowWidthSizeClass.Compact -> { /* Layout para pantallas pequeñas */ }
//        WindowWidthSizeClass.Medium -> { /* Layout para pantallas medianas */ }
//        WindowWidthSizeClass.Expanded -> { /* Layout para pantallas grandes */ }
//    }
// }

Implementación de la Adaptación del Diseño

Una vez que las categorías de tamaño de ventana son monitoreadas en la aplicación, es posible ajustar el diseño de la interfaz de usuario basándose en la clasificación actual.

• Para diseños basados en vistas, consulte la documentación sobre cómo migrar interfaces a diseños adaptables.
• Para diseños basados en Compose, la guía sobre cómo construir layouts responsivos es un recurso clave.

Consideraciones para el Soporte de Diversas Clases de Tamaño de Ventana

Al introducir modificaciones en el diseño, es fundamental realizar pruebas exhaustivas del comportamiento de la interfaz en una variedad de tamaños de ventana, prestando especial atención a los umbrales de ancho Compacto, Medio y Expandido.

Si su aplicación ya posee un diseño optimizado para pantallas pequeñas, la recomendación es priorizar la optimización para la categoría de ancho Expandido. Esto proporciona el mayor espacio para integrar contenido adicional o variaciones significativas en la interfaz. Posteriormente, defina qué tipo de diseño resulta más adecuado para la categoría de ancho Medio, considerando la creación de diseños específicos para este rango.

Para enriquecer la experiencia del usuario, se pueden incorporar características avanzadas como el soporte para estados de plegado en dispositivos flexibles o la optimización para diferentes métodos de entrada como teclado, ratón y lápiz óptico.

Para una visión más profunda sobre cómo asegurar un rendimiento excepcional de su aplicación en todos los dispositivos y tamaños de pantalla, consulte la guía de calidad de aplicaciones para pantallas grandes.

Nota: Las siguientes secciones se centran principalmente en el uso de diseños basados en vistas. Para la guía de Compose, refiérase a la documentación específica.

Diseño Flexible (Adaptive Design)

El punto de partida para dar soporte a una gama amplia de factores de forma es construir un diseño intrínsecamente flexible a los cambios de tamaño de pantalla.

Uso de ConstraintLayout para Diseños Elásticos

ConstraintLayout es la base ideal para crear diseños de interfaz de usuario adaptables. Permite definir la posición y el tamaño de cada componente de la interfaz en relación con otros elementos y con el contenedor padre. Esta aproximación asegura que los componentes se reorganicen y redimensionen de forma coherente cuando el tamaño de la pantalla cambia.

El editor de diseño de Android Studio simplifica la construcción de layouts con ConstraintLayout. Ofrece una interfaz visual intuitiva para arrastrar vistas, aplicar restricciones relativas entre ellas y con el contenedor padre, y configurar propiedades sin la necesidad de editar directamente el código XML.

Para más información, consulte la guía sobre cómo construir interfaces adaptables con ConstraintLayout.

Dimensiones Adaptables con 'wrap_content', 'match_parent' y '0dp'

Para que los layouts se ajusten de manera fluida a diversas dimensiones de pantalla, es fundamental evitar el uso de valores fijos para el ancho y la altura de la mayoría de los componentes de la interfaz. En su lugar, se deben emplear valores flexibles como wrap_content, match_parent o 0dp (restricción de coincidencia):

• wrap_content: Permite que la vista ajuste su tamaño al mínimo necesario para acomodar su contenido.
• match_parent: Extiende la vista para ocupar todo el espacio disponible dentro de su contenedor padre.
• 0dp (también conocido como 'match constraint' en ConstraintLayout): Similar a match_parent, esta opción permite que la vista ocupe todo el espacio disponible definido por sus restricciones.

<TextView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="Lorem ipsum dolor sit amet, consectetur adipiscing elit." />

Este ejemplo de TextView ajusta su ancho para llenar el espacio disponible (match_parent) y su altura para contener su texto (wrap_content), lo que le permite adaptarse a diferentes tamaños de pantalla y volúmenes de texto.

Aunque LinearLayout permite distribuir vistas proporcionalmente usando pesos (layout_weight), su anidamiento puede llevar a múltiples pasadas de medición, afectando el rendimiento de la interfaz. Se recomienda convertir layouts anidados de LinearLayout a ConstraintLayout y utilizar cadenas de restricciones para replicar el comportamiento ponderado, mejorando la eficiencia.

Nota: En ConstraintLayout, el uso de match_parent para las dimensiones es a menudo reemplazado por 0dp (match constraint) para aprovechar un comportamiento de ajuste más específico. Consulte la documentación sobre cómo redimensionar vistas en ConstraintLayout para más detalles.

Diseño Adaptativo (Responsive Design)

Aunque un diseño flexible es fundamental para la adaptación a distintos tamaños de pantalla, no siempre garantiza una experiencia de usuario ideal en todos los dispositivos. Un diseño concebido para un teléfono móvil, por ejemplo, podría no ser óptimo en una tableta. El diseño adaptativo (o responsivo) aborda esto ofreciendo layouts alternativos, específicamente optimizados para rangos de tamaños de pantalla distintos.

Implementando Interfaces Maestro-Detalle con SlidingPaneLayout

Las interfaces de tipo maestro-detalle (o lista-detalle) exhiben comportamientos distintos según el tamaño de la pantalla. En pantallas de mayor tamaño, los paneles de lista y detalle suelen presentarse uno junto al otro. Al seleccionar un elemento de la lista, su información se carga en el panel de detalle sin alterar la disposición general. En contraste, en pantallas pequeñas, los paneles se muestran de forma independiente, cada uno ocupando toda el área visible. La selección de un elemento en el panel de lista provoca que el panel de detalle reemplace al de lista, y la navegación hacia atrás restaura la vista de la lista.

SlidingPaneLayout simplifica la gestión de esta lógica, determinando automáticamente cuál de las dos experiencias de usuario es la más adecuada para el tamaño de ventana actual:

<?xml version="1.0" encoding="utf-8"?>
<androidx.slidingpanelayout.widget.SlidingPaneLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainDisplayActivity">

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/list_items_view"
        android:layout_width="290dp"
        android:layout_height="match_parent"
        android:layout_gravity="start" />

    <androidx.fragment.app.FragmentContainerView
        android:id="@+id/detail_content_fragment"
        android:name="androidx.navigation.fragment.NavHostFragment"
        android:layout_width="310dp"
        android:layout_height="match_parent"
        android:layout_weight="1"
        app:defaultNavHost="true"
        app:navGraph="@navigation/app_nav_graph" />

</androidx.slidingpanelayout.widget.SlidingPaneLayout>

El comportamiento de SlidingPaneLayout se rige por las propiedades layout_width y layout_weight de las dos vistas contenidas. En el ejemplo anterior, si el ancho de la ventana es suficientemente amplio (al menos 610dp), los paneles se mostrarán lado a lado. Si el ancho de la ventana es inferior, los paneles se superpondrán, deslizándose uno sobre el otro para ocupar la totalidad del espacio de la aplicación de manera individual.

Cuando el ancho de la ventana excede el total mínimo especificado (610dp), los valores de layout_weight permiten ajustar el tamaño de los paneles proporcionalmente. El panel de la lista conservará su ancho fijo (290dp), mientras que el panel de detalle, gracias a su peso, ocupará todo el espacio horizontal restante por encima de ese umbral.

Nota: Una excepción al comportamiento estándar de layout_weight se observa en SlidingPaneLayout v1.2.0 y posteriores en dispositivos plegables, donde el layout ajustará automáticamente los paneles para situarlos a cada lado de un pliegue o bisagra.

Recursos de Layout Alternativos Mediante Calificadores

Para adaptar la interfaz de usuario a una variedad de tamaños de pantalla cambiantes, se pueden utilizar recursos de layout alternativos, identificados por calificadores de recursos.

Al crear directorios adicionales en res/layout/ de su proyecto, es posible proporcionar layouts específicos para configuraciones de pantalla distintas. Cada directorio se nombra añadiendo un calificador de configuración de pantalla al nombre layout (por ejemplo, layout-w600dp para pantallas con un ancho disponible de 600dp).

Estos calificadores de configuración describen el espacio de pantalla visible disponible para la aplicación. El sistema Android considera elementos de la interfaz de usuario del sistema (como barras de navegación y estado) y cambios en la configuración de la ventana (como el modo multi-ventana) al seleccionar el layout apropiado para su aplicación.

Para crear layouts alternativos en Android Studio (versión 3.0 o superior):

1. Abra su layout por defecto y haga clic en el icono "Orientation for Preview" en la barra de herramientas.
2. En el menú desplegable, seleccione una de las variaciones sugeridas (ej. "Create Landscape Variation") o haga clic en "Create Other".
3. Si elige "Create Other", aparecerá la ventana "Select Resource Directory". Seleccione un calificador de pantalla del lado izquierdo y añádalo a la lista de "Chosen qualifiers". Haga clic en "OK" una vez que haya añadido los calificadores deseados.

El sistema generará una copia de su archivo de layout por defecto en el nuevo directorio, permitiéndole personalizar el diseño para esa configuración específica.

Calificador de "Ancho Mínimo" (sw<N>dp)

Este calificador permite proporcionar layouts específicos para pantallas con un ancho mínimo medido en píxeles independientes de la densidad (dp o dip). Esto asegura que el diseño se adapte a tamaños de pantalla concretos sin verse afectado por la densidad de píxeles.

Ejemplo de uso para una actividad principal optimizada para teléfonos y tabletas:

res/layout/activity_main_view.xml         <!-- Para teléfonos (ancho mínimo menor a 600dp) -->
res/layout-sw600dp/activity_main_view.xml  <!-- Para tabletas de 7" (600dp de ancho o más) -->

El "ancho mínimo" se refiere a la dimensión más corta de la pantalla, independientemente de la orientación actual del dispositivo, ofreciendo una forma consistente de especificar el tamaño global de pantalla para un layout.

Algunos valores de ancho mínimo comunes:

• 320dp: Pantallas de teléfono típicas (ej., 240x320 ldpi, 320x480 mdpi, 480x800 hdpi).
• 480dp: Pantallas de teléfono grandes (aproximadamente 5 pulgadas, ej., 480x800 mdpi).
• 600dp: Tabletas de 7 pulgadas (ej., 600x1024 mdpi).
• 720dp: Tabletas de 10 pulgadas (ej., 720x1280 mdpi, 800x1280 mdpi).

Las dimensiones especificadas con calificadores de recursos como "ancho mínimo" se refieren al espacio disponible de la ventana de la aplicación en dp, no al tamaño físico absoluto de la pantalla. El sistema puede reservar parte de la pantalla para elementos de la interfaz de usuario del sistema. Si la aplicación se ejecuta en modo multi-ventana, solo tendrá acceso a las dimensiones de su propia ventana. Al redimensionar esta ventana, se activará un cambio de configuración para que el sistema pueda seleccionar el archivo de layout apropiado.

Calificador de "Ancho Disponible" (w<N>dp)

Si necesita que el layout cambie basándose en el ancho o la altura disponibles actualmente, en lugar del ancho mínimo de la pantalla, el calificador de "ancho disponible" es adecuado. Por ejemplo, para usar un layout de doble panel cuando el ancho de la pantalla es de al menos 600dp, sin importar si el dispositivo está en orientación vertical u horizontal:

res/layout/main_layout.xml           <!-- Para teléfonos (ancho disponible menor a 600dp) -->
res/layout-w600dp/main_layout.xml    <!-- Para tabletas de 7" o cualquier pantalla con 600dp de ancho disponible (incluyendo teléfonos en horizontal) -->

Similarmente, si su aplicación se centra en la altura disponible, puede utilizar el calificador de "altura disponible", por ejemplo, layout-h600dp para pantallas con una altura de al menos 600dp.

Calificador de "Orientación de Pantalla" (port / land)

Aunque la combinación de calificadores de "ancho mínimo" y "ancho disponible" puede ser suficiente para cubrir la mayoría de las variaciones de tamaño, puede haber casos en los que desee alterar la experiencia de usuario cuando el usuario cambia entre las orientaciones vertical (portrait) y horizontal (landscape).

Para ello, puede añadir los calificadores port o land al nombre del directorio de layout, asegurándose de que sigan a los calificadores de tamaño. Por ejemplo:

res/layout/activity_master.xml                <!-- Para teléfonos -->
res/layout-land/activity_master.xml           <!-- Para teléfonos en horizontal -->
res/layout-sw600dp/activity_master.xml        <!-- Para tabletas de 7" -->
res/layout-sw600dp-land/activity_master.xml   <!-- Para tabletas de 7" en horizontal -->

Para obtener una lista completa de todos los calificadores de configuración de pantalla, consulte la descripción genarel de recursos de la aplicación.

Modularización de Componentes de UI con Fragments

Al diseñar una aplicación para diversas dimensiones de pantalla, los fragments son una herramienta eficaz para encapsular la lógica de la interfaz de usuario en componentes reutilizables, evitando la duplicación innecesaria de comportamientos entre Activities. Estos fragments pueden combinarse para construir layouts multipanel en dispositivos de gran pantalla o alojarse en Activities separadas para dispositivos con pantallas más pequeñas.

Un ejemplo clásico es el patrón maestro-detalle (ver sección de SlidingPaneLayout), donde un fragmento puede contener la lista de elemantos y otro fragmento, los detalles de un elemento seleccionado. En pantallas grandes, ambos fragmentos pueden coexistir lado a lado, mientras que en pantallas pequeñas, cada uno ocuparía la totalidad de la pantalla de forma independiente.

Para más detalles, consulte la descripción general de fragments.

Integración de Actividades (Activity Embedding)

Para aplicaciones compuestas por múltiples actividades, la integración de actividades ofrece una forma sencilla de construir interfaces adaptables. Esta funcionalidad permite que el sistema muestre varias actividades o múltiples instancias de una misma actividad simultáneamente dentro de la ventana de tarea de una aplicación. En pantallas amplias, las actividades pueden presentarse una al lado de la otra; en pantallas pequeñas, se apilan.

La configuración de cómo su aplicación muestra sus actividades se puede realizar a través de un archivo de configuración XML, que el sistema utiliza para determinar la presentación más adecuada según el tamaño de la pantalla. Alternativamente, se pueden emplear llamadas a la API de Jetpack WindowManager.

La integración de actividades soporta cambios de orientación del dispositivo y dispositivos plegables, ajustando la disposición de las actividades (apilándolas o desapilándolas) a medida que el dispositivo rota o se pliega/despliega.

Para más información, consulte la guía de integración de actividades.

Dimensiones de Pantalla y Relaciones de Aspecto

Es fundamental probar su aplicación en una amplia gama de tamaños y relaciones de aspecto de pantalla para asegurar que la interfaz de usuario se escale correctamente y mantenga su funcionalidad.

Android 10 (API nivel 29) y versiones posteriores ofrecen soporte para una gran variedad de relaciones de aspecto. Los dispositivos plegables, en particular, presentan una diversidad de factores de forma, desde pantallas alargadas cuando están plegados (ej., 21:9) hasta pantallas más cuadradas cuando están desplegados (ej., 1:1).

Para maximizar la compatibilidad, pruebe su aplicación con las siguientes relaciones de aspecto lo más ampliamente posible:

• Relaciones de aspecto comunes: 16:9, 4:3, 3:2, 16:10.
• Relaciones extremas (para plegables): 21:9 (plegado), 1:1 (desplegado).

Si su aplicación no puede soportar ciertas relaciones de aspecto, puede especificar los valores máximos y mínimos (maxAspectRatio y minAspectRatio) que su aplicación es capaz de manejar. Si una pantalla excede estos límites, el sistema podría ejecutar su aplicación en modo de compatibilidad.

Si no dispone de dispositivos físicos con diversas configuraciones de pantalla, el emulador de Android es una herramienta invaluable para simular cualquier tamaño de pantalla. Para pruebas en dispositivos reales sin tenerlos físicamente, Firebase Test Lab le permite acceder a una granja de dispositivos en los centros de datos de Google.

Soporte Restringido para Tamaños de Pantalla Específicos

En situaciones donde no se desea que la aplicación funcione en determinadas configuraciones de pantalla, es posible establecer límites en el grado de redimensionamiento de la aplicación o, incluso, restringir la instalación de la aplicación a dispositivos con configuraciones de pantalla específicas. Para obtener información detallada sobre cómo implementar estas restricciones, consulte la guía para declarar un soporte de pantalla restringido.