Sería interesante que en este curso se tomaran el tiempo para detallar ciertos conceptos. Por ejemplo, en esta clase, los cálculos realizados para que el foco de la cámara y el rostro "no se salgan de los límites", convierten la experiencia en un reto de copiar y pegar código; al menos para mí. Sin archivos o enlaces que permitan al estudiante reforzar el tema o la clase .. solo una observación.
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]:
previewWidthigual a 320.previewHeightigual 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
previewWidthen una variable temporal. - Igualamos
previewWidthalpreviewHeight. - Igualamos
previewHeighta 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:
childWidthde tipo entero.childHeightde tipo entero.childXOffsetigual a cero.childYOffsetigual 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
childWidthtoma el valor delviewWidth, y elchildHeightse calcula multiplicandopreviewHeightpor elheightRatio. 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
LensEnginePreviewconmatch_parenten ancho y alto, identificado con el IDpreview. - El
GraphicOverlaydentro del preview, con el IDface_overlay. - Las alineaciones
alignParentStart, top y botton entruepara 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.