0:0010:20

Recursos

Resumen

Configurar una cámara selfie personalizada en Android empieza por crear una estructura de código clara con dos paquetes base: uno para la cámara y otro para la capa visual. Si estás construyendo tu propia selfie cam y no sabes por dónde arrancar, aquí defines toda la inicialización que te permitirá visualizar la cámara más adelante.

Por qué separar la cámara y el overlay en dos paquetes

Lo primero que hacemos es organizar el proyecto en dos paquetes independientes. Uno se llama camera y el otro overlay (o capa). Esta separación mantiene la lógica de captura aislada de la lógica visual, lo que facilita mantener y escalar el código.

Dentro del paquete camera creamos la clase CameraConfiguration [00:40], donde vive toda la configuración. La dejamos como clase open, lo que significa que puede usarse y heredarse desde cualquier parte del código.

¿Qué hace la palabra open en una clase de Kotlin? Marca la clase como heredable y reutilizable. Sin open, Kotlin la trata como final y bloquea que otras clases la extiendan.

Qué variables definen el comportamiento de la cámara

En CameraConfiguration arrancamos con tres variables que controlan cómo se comporta la vista previa:

  • FPS: los frames per second, fijados en 20 [01:10].
  • previewHeight: la altura de tipo entero, igualada a null al inicio.
  • isAutoFocus: de tipo booleano en true para activar el enfoque automático.

Estas variables son la base que la cámara leerá cuando inicialice la vista previa.

Cómo manejar la orientación frontal y trasera de la cámara

Para una selfie cam necesitas controlar hacia dónde mira el lente. Creamos la función sincronizada setCameraFacing [01:40], que recibe un parámetro required. La sincronización importa porque la cámara entrega el foco en tiempo real y no puede trabajar con delay.

Dentro validamos que el facing sea distinto de cameraFacingBack y distinto de cameraFacingFront. Si no mira ni hacia atrás ni hacia adelante, lanzamos el mensaje de cámara inválida, porque probablemente el lente esté trabado.

¿Por qué una función de cámara debe ser sincronizada? Porque la captura ocurre en tiempo real. La sincronización garantiza que la app ejecute la acción de inmediato, sin retrasos que congelen la vista previa.

Dónde se guardan los valores de orientación del lente

Usamos la librería de hardware de Android para traer los valores de orientación:

  • cameraFacingBack: tomado de Android.hardware.Camera.CameraInfo.CAMERA_FACING_BACK.
  • cameraFacingFront: la misma referencia, pero apuntando al lente frontal.

Al declararlas dentro del companion object accedemos a ellas directamente y eliminamos los imports innecesarios [03:00]. Luego creamos la variable sincronizada cameraFacing, con valor por defecto cameraFacingBack y marcada como protected set, de modo que solo se modifica en tiempo de ejecución para evitar un null pointer exception.

Cómo construir la capa gráfica del overlay

En el paquete overlay creamos la clase GraphicOverlay [03:45], la capa gráfica que se dibuja encima de la cámara. Le damos un constructor que recibe un context y un conjunto de atributos de tipo AttributeSet que puede ser nulo. Esta clase hereda de la view de Android, pasando el contexto y los atributos al padre.

Dentro definimos varias variables que controlan la escala y el estado del lienzo:

  • lock: deja la cámara bloqueada en el momento de tomar la foto.
  • previewWidth y previewHeight: inicializados en cero para el ancho y alto.
  • widthScaleValue y heightScaleValue: de tipo flotante en 1.0f, para escalar la vista.

Los valores de escala pasan de protected set a private para que resulten más fáciles de acceder desde el código [05:30].

Cuándo se activa el modo selfie en el overlay

Como ya tenemos CameraConfiguration, el overlay puede leer cameraFacing. Comparamos su valor con cameraFacingFront: cuando el lente esté en posición frontal, la app toma la selfie. Esta variable queda como private set para proteger su estado.

Así conectas la configuración de la cámara con la capa visual sin duplicar lógica.

Cómo pasar la información de la cámara al overlay

Para que la capa gráfica sepa las dimensiones reales, creamos la función sincronizada setCameraInfo [06:30]. Recibe tres parámetros de tipo entero:

  • El ancho de la vista previa.
  • El alto de la vista previa.
  • El facing o posición del lente.

Dentro asigna el lock, el previewWidth, el previewHeight y el cameraFacing. Al terminar llamamos a postInvalidate(), y aquí viene lo importante: esa llamada evita que la vista se quede pegada en la sincronización y mantiene la app fuera de un loop infinito.

Por último dejamos preparadas dos funciones vacías, addGraphics para agregar gráficas y clear para limpiar la capa. Con eso cierras la primera parte de la personalización de la cámara.

¿Ya tienes clara la estructura de tus dos paquetes? Cuéntame en los comentarios cómo vas con tu CameraConfiguration antes de pasar a crear el layout.

Estructura base para una cámara selfie personalizada

Ver clases