0:0011:54

Recursos

Resumen

Si estás construyendo una cámara personalizada en Android, aprenderás a programar la función onLayout para calcular dimensiones de previsualización y crear la actividad que aloja todos los objetos gráficos de clases anteriores. Esto importa porque evita que tu foco, tu cuadro y el rostro detectado se salgan de los límites de la pantalla.

¿Qué hace la función onLayout en la previsualización de cámara?

La función onLayout es el corazón de esta clase. Aquí calculamos cómo debe pintarse el preview de la cámara según las dimensiones del dispositivo y la orientación.

Comenzamos definiendo dos variables base [00:34]:

  • previewWidth igual a 320.
  • previewHeight igual a 240.

Antes de usar cualquier cálculo, verificamos que el LensEngine no sea nulo. Si existe, obtenemos un objeto de tipo tamaño desde displayDimensions, que nos devuelve las dimensiones reales de visualización [00:55]. Luego igualamos previewHeight al alto y previewWidth al ancho de ese tamaño.

¿Por qué se verifica que el LensEngine no sea nulo? Porque si el motor de lente no está inicializado, no existen dimensiones reales que leer. Validar evita que la app falle al intentar pintar una cámara que todavía no arrancó.

¿Cómo se maneja la orientación portrait?

Después de confirmar que el LensEngine existe, validamos que el contexto también exista y que la configuración esté en orientación portrait o vertical [01:26].

Cuando la pantalla está en vertical, hacemos un intercambio de valores usando una variable temporal:

  • Guardamos previewWidth en una variable temporal.
  • Igualamos previewWidth al previewHeight.
  • Igualamos previewHeight a la variable temporal.

La idea de este intercambio es que el layout sea lo más concreto posible en cuanto a tamaños, adaptándose a cómo el usuario sostiene el teléfono.

¿Cómo se calculan las dimensiones del hijo (child) en el layout?

Aquí viene lo interesante: definimos las medidas del contenedor y de su hijo para que todo encaje. Creamos width como right menos left y viewHeight como botton menos top [02:11].

Luego declaramos las variables del hijo:

  • childWidth de tipo entero.
  • childHeight de tipo entero.
  • childXOffset igual a cero.
  • childYOffset igual a cero.

Con estos valores calculamos el widthRatio dividiendo medidas en float, y comparamos el ratio de ancho contra el ratio de alto. Es importante validar el ratio de ancho y de altura porque así le decimos a la cámara que no se salga de los límites del foco, y el cuadro de detección tampoco se escapa [03:14].

¿Qué pasa si el ratio de ancho es mayor que el de alto? El childWidth toma el valor del viewWidth, y el childHeight se calcula multiplicando previewHeight por el heightRatio. El offset en Y se ajusta restando y dividiendo entre dos para centrar.

Cuando ocurre lo contrario, invertimos la lógica: el childWidth se calcula con el previewHeight multiplicado por el ratio, el childHeight toma el viewHeight, y el childXOffset se ajusta para mantener el centrado. Para poder modificar estos valores durante la validación, cambiamos las declaraciones de val a var [04:04].

¿Cómo se pinta el cuadro sin salirse de los límites?

Usamos un ciclo for que recorre desde cero hasta el número de hijos del layout. Con getChild en la posición i llamamos al método layout pasándole cuatro valores calculados con los offsets [05:12].

Esto le indica al layout que, después de todos los cálculos, pinte exactamente un cuadro con cuatro coordenadas sin salirse del área. Cerramos la lógica dentro de un bloque try: si el layout está listo y el lente existe, se pinta la previsualización.

El bloque catch captura posibles excepciones. Si algo falla, registramos el error con el mensaje "no se pudo iniciar la cámara" [05:42]. Con esto queda terminada la función de layout.

¿Cómo se crea la actividad de cámara en Android?

Con la función lista, creamos un nuevo paquete llamado face [06:01]. Dentro de él agregamos una nueva actividad para alojar la cámara, llamada LiveFaceActivityCamera.

Mientras Android genera la actividad, importamos el R del proyecto, que es la referencia a los recursos. Todos los objetos que creamos en clases anteriores los vamos a llamar aquí: los overlays y el preview del LensEngine.

¿Qué estructura de layout usa la cámara?

Al entrar a la actividad de cámara, cambiamos el ConstraintLayout por un RelativeLayout [06:43]. Quitamos el contexto y configuramos el layout en orientación vertical.

Los elementos que agregamos son:

  • El LensEnginePreview con match_parent en ancho y alto, identificado con el ID preview.
  • El GraphicOverlay dentro del preview, con el ID face_overlay.
  • Las alineaciones alignParentStart, top y botton en true para que el overlay cubra bien el área [07:30].

De esta forma el overlay queda alineado al inicio y a los extremos superior e inferior, listo para dibujar la detección sobre la imagen en vivo.

Más adelante crearemos el botón para tomar la foto y voltear la selfie cam entre el lente trasero y el delantero. Con la función onLayout pintada, hicimos todos los cálculos para que el foco, la cámara y el rostro respeten los límites de la pantalla.

¿Ya probaste intercambiar los valores en orientación vertical? Cuéntame en los comentarios cómo te fue al conectar el LensEnginePreview con tu overlay.

Función onLayout: cálculos para la cámara personalizada

Ver clases