Todos los artículos

Mobile11 min de lectura

El iPad también es celular: lo que se rompe en la tablet

Mi app React Native corría en el iPad, pero no fue pensada para él. Qué se rompió en la tablet, las reglas de layout que lo arreglaron y cómo reviso cada pantalla.

También en Português, English, Français

Una app mía siempre corrió en el iPad. La configuración supportsTablet: true estaba ahí desde el principio, la app salía como universal, sin las franjas negras de una app de iPhone estirada. Y justo por eso nunca la miré de verdad: si abre, funciona, ¿no?

En septiembre abrí la app en el simulador del iPad Pro 11" y pasé pantalla por pantalla. El resumen de mis notas de ese día: la app corre nativa en el iPad, pero no fue pensada para él. Todo lo que ocupa la pantalla entera solo estiraba el layout del celular.

Este post es lo que encontré, las reglas que adopté y la forma en que reviso cada pantalla nueva desde entonces.

TL;DR#

  • Lo que se rompe en la tablet casi siempre es el ancho: un botón de 800 pt, una línea de texto de 780 pt, una grilla en porcentaje con el margen chueco.
  • Decide por el ancho de la ventana, nunca por el modelo del dispositivo. Un iPad en Split View es angosto como un celular.
  • El contenido deja de estirarse en 760 pt y se centra. Los formularios se detienen en 480 pt.
  • La grilla calcula cuántas columnas caben, sin width: "48%".
  • Escenas con arte dibujado: todo escala junto, a partir de un solo sistema de coordenadas.
  • Y la regla que cierra todo: ninguna pantalla está lista sin la captura del iPad.

Lo que vi en el iPad#

Algunas de mis notas de ese día, en el iPad Pro 11" en vertical (834 × 1210 pt):

  • Login: campos y botones de punta a punta. Parecía un formulario roto.
  • Botones principales: unos 800 pt de ancho.
  • Pantallas de lectura: líneas de texto de unos 780 pt. Un texto corrido de ese tamaño cansa; lo cómodo anda cerca de 600.
  • Grillas: dos columnas gigantes y el margen derecho más grande que el izquierdo.
  • Pantallas con marco: un marco de dispositivo de 440 pt, usado en algunas pantallas, apretaba el contenido en el medio de la tablet.
  • Letra: la misma de 14 pt del celular, lejos de los ojos, en el medio de una pantalla de 11 pulgadas.

Y había algo que estaba bien: los diálogos. Ya tenían un ancho máximo y quedaban centrados. Esa fue la pista para resolver el resto.

Por qué el margen quedaba chueco#

Este merece un párrafo, porque aparece en casi toda app. Las grillas eran así:

<View style={{ flexDirection: "row", flexWrap: "wrap", justifyContent: "space-between" }}>
  {items.map((item) => <Card key={item.id} style={{ width: "48%" }} />)}
</View>

Dos tarjetas de 48% suman 96%. En el iPhone, el 4% que sobra son 1 o 2 pt y nadie lo ve. En el iPad, son unos 40 pt, y según la alineación caen todos de un lado. El porcentaje esconde lo que sobra en el celular y lo muestra en la tablet.

Regla 1: decide la ventana, no el dispositivo#

La tentación es preguntar "¿es un iPad?". Pero lo que importa es el espacio que tiene la app:

  • Un iPad en Split View es angosto como un celular.
  • Un celular en horizontal es ancho, pero bajo, y no se convierte en tablet.

Así que creé una regla de medida, por ancho de la ventana:

layout.ts
export type WidthClass = "compact" | "medium" | "wide";
 
// Where the class changes. "medium" is a tablet in portrait, "wide" in landscape.
export const CLASS_LIMIT = { medium: 600, wide: 900 } as const;
 
export function widthClass(width: number): WidthClass {
  if (width >= CLASS_LIMIT.wide) return "wide";
  if (width >= CLASS_LIMIT.medium) return "medium";
  return "compact";
}
 
export function useLayout() {
  const { width } = useWindowDimensions();
  const cls = widthClass(width);
  return { width, cls, isTablet: cls !== "compact" };
}

useWindowDimensions cambia cuando cambia la ventana (gira, entra en Split View), así que la pantalla acompaña sin ningún código extra.

Regla 2: el contenido tiene techo#

Por encima de cierto ancho, el contenido deja de estirarse y se centra. Elegí 760 pt: cabe una grilla de 4 y el texto corrido todavía se lee. Los formularios y los textos de presentación son más angostos, 480 pt.

export const MAX_CONTENT_WIDTH = 760;
export const MAX_FORM_WIDTH = 480;
 
// Ready to spread into a style: stretches up to the ceiling and centers.
// On a phone the window is narrower than the ceiling and nothing changes.
export const CONTENT_COLUMN = { width: "100%", maxWidth: MAX_CONTENT_WIDTH, alignSelf: "center" } as const;
export const FORM_COLUMN = { width: "100%", maxWidth: MAX_FORM_WIDTH, alignSelf: "center" } as const;

El detalle que más me gusta: en el celular esto no cambia nada. La ventana ya es más angosta que el techo. No hay ningún if (isTablet) desparramado por las pantallas, y el riesgo de romper el iPhone al arreglar el iPad es casi cero.

Para las pantallas que pintan el fondo de punta a punta (el encabezado de color, una lista que se desplaza en toda la ventana), en lugar del techo calculo un margen extra para centrar solo el contenido.

Regla 3: la grilla cuenta columnas#

En lugar del porcentaje, la grilla pregunta cuántas columnas caben sin que la tarjeta quede más angosta que un mínimo:

export function gridColumns(args: {
  width: number;
  minCellWidth: number;
  gap: number;
  min?: number;
  max?: number;
}): number {
  const { width, minCellWidth, gap, min = 1, max = 6 } = args;
  const fits = Math.floor((width + gap) / (minCellWidth + gap));
  return Math.max(min, Math.min(max, fits));
}
 
// Exact cell width: split what is left after the gaps, no percentages.
export function cellWidth(width: number, columns: number, gap: number): number {
  return Math.floor((width - gap * (columns - 1)) / columns);
}
  • min mantiene la grilla del celular con la cara de siempre.
  • max evita siete botones uno al lado del otro, que no se leen.
  • cellWidth divide exactamente lo que sobra, así que los márgenes quedan iguales de los dos lados.
La misma grilla: dos columnas en el iPhone y cuatro en el iPad, sin un if de tablet en la pantalla

Regla 4: iPad solo en vertical#

Acá tuve que elegir. Con orientation: "portrait" en el app.config, yo creía que la app quedaba en vertical en cualquier dispositivo. En el iPhone, sí. En el iPad, Expo agregaba las cuatro orientaciones al Info.plist, porque Apple lo exige a quien soporta Split View. Y la app giraba a horizontal, con layouts que nunca se habían probado así.

Para quedar solo en vertical en el iPad, la app tiene que salir del Split View:

app.config.ts
ios: {
  supportsTablet: true,
  // Opting out of Split View is what lets Apple accept portrait only on iPad.
  requireFullScreen: true,
  infoPlist: {
    // Explicit, not inherited from `orientation`: the Expo plugin does not
    // remove this key from an older prebuild, and it would keep all four
    // orientations until someone ran `prebuild --clean`.
    "UISupportedInterfaceOrientations~ipad": [
      "UIInterfaceOrientationPortrait",
      "UIInterfaceOrientationPortraitUpsideDown",
    ],
  },
},

Es un intercambio, no un arreglo. Quien usa el iPad con dos apps lado a lado no puede hacerlo con esta app. Para una app que la persona usa con atención total, me pareció que valía la pena. Para una app de notas, decidiría lo contrario.

Regla 5: la letra crece sola#

En el celular, la pantalla queda a un palmo de la cara. En el iPad, queda más lejos y la misma letra se ve chica. Entonces quien nunca eligió un tamaño de fuente recibe el tamaño más grande en la tablet:

export function defaultFontLevel(chosen: FontLevel | null, win: { width: number; height: number }): FontLevel {
  // Whoever picked a size in Settings keeps it, on any device.
  if (chosen) return chosen;
  // Shorter side: a phone in landscape is not a tablet, and a narrow Split View keeps phone text.
  const shorterSide = Math.min(win.width, win.height);
  return widthClass(shorterSide) === "compact" ? "default" : "xlarge";
}

Regla 6: el arte y la escena escalan juntos#

La app tiene algunas escenas interactivas con arte dibujado, y fueron pensadas en puntos de celular. Y en el iPad apareció el peor tipo de bug: el que funciona, pero queda feo.

En una de ellas, el arte de fondo se estiraba para llenar la pantalla, pero la imagen salía en su tamaño natural (1 punto por píxel). El objetivo terminaba abajo y cortado, y los elementos que la persona toca quedaban fuera de lugar, lejos del dibujo.

El arreglo fue tener un solo sistema de coordenadas, en los píxeles del arte: los puntos de referencia medidos en el propio archivo, y el fondo dibujado con ancho y alto explícitos en esa escala. Todos los elementos de la escena usan las mismas coordenadas, así que no hay forma de que uno se salga del lugar del otro.

Para los escenarios de esas escenas, una función decide cuánto puede crecer el dibujo:

// How much a drawing of size `base` can grow to fit `available` without
// distortion: the smaller slack, never below 1 (the phone stays as designed)
// and never above `max`.
export function scaleToFit(available: Size, base: Size, max = 2.4): number {
  if (!(available.width > 0) || !(available.height > 0)) return 1;
  const fits = Math.min(available.width / base.width, available.height / base.height);
  return Math.min(max, Math.max(1, fits));
}

El escenario crece, y los elementos crecen junto con él, en la misma proporción. Nunca por debajo de 1, para que el celular quede como fue dibujado, y nunca por encima de 2,4, para que nadie vea el píxel del dibujo.

Cómo reviso cada pantalla#

Después de eso, lo volví regla: ninguna pantalla está lista sin la captura del iPad, al lado de la captura del iPhone. En la práctica:

  • Un simulador de iPad fijo, el iPad Pro 11". Es lo bastante ancho para romper un layout de celular y lo bastante angosto para que parezca que todo está bien.
  • Una cuenta de prueba solo para la tablet, con los datos lo bastante avanzados para que aparezcan todas las pantallas.
  • Tests de geometría para las escenas, en un iPhone chico, uno grande y una tablet. Lo que se puede probar con cálculo, lo pruebo en Jest.

Dos tips del simulador que me ahorraron tiempo:

No hace falta recompilar para el iPad. Si la app del simulador de iPad está vieja, puedes copiar la del iPhone, que acepta iPad y mantiene el login:

xcrun simctl install <ipad-udid> "$(xcrun simctl get_app_container <iphone-udid> com.example.app app)"

Apaga el iPad cuando termines. Dos simuladores encendidos aprietan la memoria de cualquier máquina.

Lo que atrapó la captura#

Para este post, abrí una pantalla de tienda de la app en los dos simuladores, y la primera tarjeta del iPad tenía un título cortado en el medio de la palabra. Recreé el problema acá con una tienda de ejemplo:

Cuatro columnas más la letra más grande de la tablet: la palabra larga se corta en el medio

"Personalizaçã" en una línea y "o" en la otra (Personalização es “personalización” en portugués). Cada regla por separado está bien: caben cuatro columnas, y la letra más grande se lee mejor. Juntas, dejan la tarjeta demasiado angosta para una palabra larga. Todavía no lo arreglé. El camino que veo es darle al título un ancho mínimo por columna (el minCellWidth de la grilla) donde quepa la palabra más larga en el tamaño de letra de la tablet, o dejar que el título se achique un poco antes de cortarse. Es exactamente el tipo de cosa que solo aparece mirando la pantalla.

Lo que aprendí#

"Corre en el iPad" no es "funciona en el iPad". La app nunca dio error en la tablet. Solo parecía mal hecha.

Un techo de ancho resuelve más que un breakpoint. Un maxWidth con alignSelf: "center" arregló más pantallas de las que cualquier if (isTablet) habría arreglado, y sin riesgo para el celular.

El porcentaje esconde lo que sobra. Calcular columnas y ancho exacto deja la grilla honesta en cualquier tamaño.

Las reglas correctas también chocan. Una grilla que crece y una fuente que crece, cada una con sentido, rompieron una palabra. Por eso la captura del iPad entra en cada entrega.

Checklist#

  • Abre la app en un iPad de verdad (o en el simulador) y pasa por todas las pantallas.
  • Decide el layout por el ancho de la ventana, nunca por el modelo.
  • maxWidth en el contenido (unos 760) y en el formulario (unos 480), centrado.
  • Cambia las grillas en porcentaje por un número de columnas calculado.
  • Decide las orientaciones del iPad a propósito, sabiendo que solo vertical exige salir del Split View.
  • Arte y escena interactiva en un solo sistema de coordenadas, con escala mínima y máxima.
  • Captura del iPhone y del iPad antes de decir que está listo.

Referencias#

  • Mobile
  • react-native
  • ipad
  • ios
  • layout
  • expo

Escrito por

Ingeniera de software y diseñadora. Escribo sobre lo que encuentro construyendo apps, APIs y productos.