Cámara en desarrollo móvil: qué es, tipos de API y cómo usarla

Qué es una cámara en aplicaciones móviles

Una cámara móvil es un módulo óptico integrado que consta de un lente, un sensor de imagen y un procesador de señal de imagen (ISP). El desarrollador accede a la cámara a través del sistema operativo utilizando frameworks especializados. En Android, estos son Camera2 API (bajo nivel) y CameraX (alto nivel, basado en Camera2), y en iOS — AVFoundation y UIKit para escenarios simples. Cada plataforma proporciona su propio conjunto de herramientas, pero el concepto general es el mismo: la aplicación inicializa una sesión de captura, configura parámetros (resolución, enfoque, exposición) y recibe un flujo de fotogramas o imágenes individuales.

Capacidades de hardware de las cámaras modernas

Las cámaras móviles modernas admiten muchos modos de disparo: HDR, modo nocturno, retrato con desenfoque de fondo, video en cámara lenta y grabación en formato RAW. El desarrollador tiene acceso a ajustes de software: ISO (sensibilidad del sensor), velocidad de obturación (exposición), balance de blancos, enfoque (automático y manual) y estabilización de imagen. Los dispositivos emblemáticos pueden tener hasta 4 cámaras con diferentes distancias focales, y la aplicación puede seleccionar una cámara específica por ID.

Tipos de API para trabajar con la cámara

Las plataformas móviles ofrecen varias APIs para trabajar con la cámara, que varían en nivel de abstracción y funcionalidad. La elección de una API específica depende de los requisitos del proyecto: para captura simple de fotos, CameraX o UIImagePickerController es suficiente; para aplicaciones profesionales, se necesita Camera2 o AVFoundation con control directo del sensor. A continuación se muestra una comparación de las principales APIs.

Cuándo elegir CameraX

CameraX es la opción óptima para la mayoría de las aplicaciones Android que necesitan una cámara sin personalización profunda. La biblioteca maneja automáticamente el ciclo de vida de Activity y Fragment, admite permisos y garantiza compatibilidad entre diferentes versiones de Android. CameraX garantiza un comportamiento consistente en el 95% de dispositivos Android gracias a su capa de compatibilidad. Si necesita vista previa de cámara (Preview), captura de fotos (ImageCapture) o análisis de fotogramas (ImageAnalysis) — CameraX maneja los tres escenarios sin escribir código complejo.

Cuándo elegir Camera2

Camera2 es una API de bajo nivel para escenarios profesionales: grabación RAW, ajuste manual de exposición, captura en ráfaga y control simultáneo de múltiples cámaras. Camera2 requiere que el desarrollador tenga un conocimiento profundo del pipeline de captura de imágenes, la gestión de StateMachine y el manejo de callbacks. Use Camera2 solo si CameraX no cubre los requisitos: por ejemplo, aplicaciones de escaneo de documentos con enfoque manual o cámaras personalizadas con resolución no estándar.

Solicitud de permisos de cámara

El acceso a la cámara requiere permiso explícito del usuario en ambas plataformas. En Android, el permiso CAMERA se agrega al manifiesto, y a partir de Android 6.0, el permiso también debe solicitarse en tiempo de ejecución mediante ActivityCompat.requestPermissions. En iOS, la clave NSCameraUsageDescription se agrega a Info.plist con una descripción de por qué se usa la cámara. Sin esta descripción, la aplicación fallará al intentar acceder a la cámara. A partir de iOS 14, el diálogo de permisos muestra no solo el nombre de la aplicación sino también la razón especificada — la redacción debe ser clara para el usuario.

Implementación en Android con CameraX

CameraX simplifica el trabajo con la cámara a solo unas pocas líneas de código. Para iniciar una vista previa, debe crear una instancia de Preview, vincularla a un LifecycleOwner y obtener un SurfaceProvider para la visualización. Para la captura de fotos, se utiliza ImageCapture con un destino de guardado. A continuación se muestra un ejemplo completo de iniciar la cámara y tomar una foto usando CameraX en Kotlin.

Configuración de Preview e ImageCapture

val preview = Preview.Builder()
    .build()
    .also {
        it.surfaceProvider = viewFinder.surfaceProvider
    }

val imageCapture = ImageCapture.Builder()
    .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
    .build()

val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
cameraProviderFuture.addListener(Runnable {
    val cameraProvider = cameraProviderFuture.get()
    val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

    try {
        cameraProvider.unbindAll()
        cameraProvider.bindToLifecycle(
            this, cameraSelector, preview, imageCapture
        )
    } catch (e: Exception) {
        Log.e("CameraX", "Error de vinculación", e)
    }
}, ContextCompact.getMainExecutor(this))

El método bindToLifecycle vincula la cámara al ciclo de vida de la Activity — cuando la pantalla gira o la aplicación pasa a segundo plano, la cámara se libera automáticamente. CameraSelector.DEFAULT_BACK_CAMERA selecciona la cámara trasera; para la cámara frontal, se usa DEFAULT_FRONT_CAMERA. Después de la vinculación, Preview comienza a mostrar el feed de la cámara en PreviewView, y el usuario ve la imagen de la cámara en la pantalla.

Captura de una foto

val photoFile = File(
    externalMediaDirs.firstOrNull(),
    "IMG_${System.currentTimeMillis()}.jpg"
)
val outputOptions = ImageCapture.OutputFileOptions
    .Builder(photoFile)
    .build()

imageCapture.takePicture(
    outputOptions,
    ContextCompact.getMainExecutor(this),
    object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(output: ImageCapture.OutputFileResults) {
            Log.d("CameraX", "Photo saved: ${photoFile.absolutePath}")
        }
        override fun onError(exception: ImageCaptureException) {
            Log.e("CameraX", "Error de captura", exception)
        }
    }
)

El método takePicture captura un fotograma de la cámara y lo guarda en un archivo. OutputFileOptions admite escritura en File, ContentResolver y MediaStore. En el callback onImageSaved, la aplicación recibe una notificación de guardado exitoso y puede actualizar la IU. CAPTURE_MODE_MINIMIZE_LATENCY garantiza la máxima velocidad de obturación al reducir el posprocesamiento.

Implementación en iOS con AVFoundation

En iOS, el acceso a la cámara lo proporciona el framework AVFoundation a través de la clase AVCaptureSession. El desarrollador crea una sesión de captura, agrega las entradas necesarias (AVCaptureDeviceInput) y salidas (AVCapturePhotoOutput, AVCaptureVideoDataOutput), e inicia la sesión. AVCaptureVideoPreviewLayer se utiliza para mostrar la vista previa. A continuación se muestra un ejemplo de configuración de una sesión para captura de fotos en Swift.

import AVFoundation

let captureSession = AVCaptureSession()
captureSession.sessionPreset = .photo

guard let camera = AVCaptureDevice.default(
    for: .video
) else { return }

guard let input = try? AVCaptureDeviceInput(device: camera)
else { return }

let output = AVCapturePhotoOutput()
captureSession.addInput(input)
captureSession.addOutput(output)

DispatchQueue.global(qos: .userInitiated).async {
    captureSession.startRunning()
}

AVCaptureSessionPreset.photo establece la resolución óptima para fotos (generalmente 12 MP en dispositivos modernos). La entrada es un AVCaptureDeviceInput creado para la cámara del dispositivo. Después de agregar la entrada y la salida, la sesión se inicia en un hilo de fondo mediante startRunning — iniciar la sesión puede tomar hasta 200 ms en dispositivos antiguos. Para capturar una foto, se llama a capturePhoto(with:delegate:), y el resultado se devuelve a través de AVCapturePhotoCaptureDelegate.

Características y limitaciones

Al trabajar con la cámara en dispositivos móviles, se deben considerar las limitaciones de hardware: calentamiento del dispositivo durante grabación prolongada, consumo de batería al trabajar con alta resolución y calidad de cámara variable en diferentes dispositivos. En Android, la fragmentación del ecosistema hace que la misma configuración de CameraX pueda comportarse de manera diferente en distintos modelos. En iOS, las limitaciones se refieren principalmente a licencias: usar la cámara en segundo plano requiere un permiso especial de Apple. También es importante recordar que los simuladores no tienen acceso a una cámara real — las pruebas solo son posibles en un dispositivo físico.

Compatibilidad con diferentes versiones del SO

CameraX resuelve el problema de fragmentación de Android a través de la capa de compatibilidad CameraXConfig — la biblioteca aplica automáticamente soluciones para errores conocidos de fabricantes. En iOS, AVFoundation funciona de manera uniforme en todos los dispositivos a partir de iOS 6, pero algunas funciones (como el Modo Retrato o LiDAR) solo están disponibles en iPhone 12 y modelos más nuevos. Al desarrollar una aplicación multiplataforma, se recomienda usar Flutter o React Native con plugins de cámara — abstraen las diferencias de plataforma y proporcionan una API unificada para ambos sistemas operativos.