Home / Lenguajes / Cámara en Android: captura fotos y vídeo con Camera2 y CameraX
Cámara en Android: captura fotos y vídeo con Camera2 y CameraX

Cámara en Android: captura fotos y vídeo con Camera2 y CameraX

16 November 2026 · 18 min de lectura ··

Qué vamos a construir y por qué importa la cámara en Android

Casi cualquier aplicación móvil termina necesitando la cámara: escanear un documento, subir una foto de perfil, grabar un clip corto o leer un código. Android ofrece varias capas para lograrlo, y elegir la correcta desde el principio te ahorra semanas de depuración. En este tutorial recorreremos la capa de bajo nivel, Camera2, que expone el hardware casi sin intermediarios, y después veremos cómo se resuelve lo mismo con CameraX, la biblioteca de Jetpack que hoy es la opción recomendada para la mayoría de los proyectos.

El objetivo práctico es una pantalla con tres capacidades: una vista previa en vivo, un botón para tomar una fotografía en JPEG y otro para grabar vídeo con audio. Todo el código está en Kotlin, que es el lenguaje por defecto del ecosistema Android; la rama estable actual es Kotlin 2.4, y los ejemplos no dependen de ninguna característica experimental.

Antes de entrar en materia conviene aclarar el panorama de versiones. Camera2 existe desde Android 5.0 (API 21) y sigue siendo parte del framework, así que no se “actualiza” como una librería. CameraX, en cambio, se publica por separado en Google Maven, y su última versión estable en el momento de escribir esto es la 1.6.1. La serie 1.6 se apoya internamente en CameraPipe, la misma pila de captura que usan las cámaras de los Pixel, por lo que a menudo obtendrás mejor compatibilidad entre fabricantes sin escribir una línea extra.

Si quieres situar todo esto en perspectiva histórica, te puede interesar la historia de Android y su impacto en la industria móvil, que explica por qué la fragmentación de dispositivos es el gran enemigo de cualquier API de cámara.

Camera2 frente a CameraX: cuándo elegir cada una

La pregunta honesta no es cuál es mejor, sino cuánto control necesitas. Camera2 te entrega un mando completo: exposición manual, enfoque, balance de blancos, ráfagas, cámaras físicas múltiples, formatos RAW. A cambio, tú gestionas el ciclo de vida, los hilos, los tamaños soportados y las rarezas de cada fabricante.

CameraX envuelve Camera2 con una API orientada a casos de uso (Preview, ImageCapture, VideoCapture, ImageAnalysis) que respeta el ciclo de vida de Android y corrige muchos problemas conocidos de dispositivos concretos. Para una app de mensajería, un formulario con foto o un lector de códigos, CameraX es casi siempre la respuesta.

Una regla práctica para decidir:

  • Usa CameraX si necesitas vista previa, foto, vídeo o análisis de fotogramas con comportamiento fiable en muchos teléfonos.
  • Usa Camera2 directamente si requieres control manual avanzado, soporte de modos muy específicos del hardware o quieres aprender cómo funciona la plataforma por dentro.
  • Considera el intent del sistema que abre la aplicación de cámara del usuario si solo necesitas una imagen puntual y no te importa la interfaz.

Aunque CameraX sea la recomendación, entender Camera2 vale la pena: los conceptos de sesión, solicitud de captura y superficie aparecen igual en ambas, y cuando algo falla en CameraX los registros hablan en términos de Camera2.

Preparar el proyecto y los permisos

Crea un proyecto con una actividad vacía y abre el archivo de configuración del módulo. Para el bloque de Camera2 no necesitas dependencias adicionales, pero ya dejaremos preparadas las de CameraX para la última parte.

// app/build.gradle.kts
android {
    namespace = "dev.ejemplo.camaralab"
    compileSdk = 36

    defaultConfig {
        applicationId = "dev.ejemplo.camaralab"
        minSdk = 24
        targetSdk = 36
    }
}

dependencies {
    val camerax = "1.6.1"
    implementation("androidx.camera:camera-core:$camerax")
    implementation("androidx.camera:camera-camera2:$camerax")
    implementation("androidx.camera:camera-lifecycle:$camerax")
    implementation("androidx.camera:camera-view:$camerax")
    implementation("androidx.camera:camera-video:$camerax")
}

Revisa siempre la versión de compileSdk y de CameraX en la documentación oficial de tu fecha, porque ambas avanzan con frecuencia. En el manifiesto declaramos los permisos y marcamos la cámara como característica no obligatoria para que la app siga instalable en dispositivos sin ella.

<manifest xmlns:android="http://schemas.android.com/apk/res/android">

    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.RECORD_AUDIO" />

    <uses-feature
        android:name="android.hardware.camera"
        android:required="false" />

    <application
        android:theme="@style/Theme.CamaraLab">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Declarar el permiso no basta: CAMERA y RECORD_AUDIO son permisos peligrosos y hay que pedirlos en tiempo de ejecución. La API moderna para ello es el contrato de resultados de actividad, que sustituye al viejo onRequestPermissionsResult.

class MainActivity : AppCompatActivity() {

    private val pedirPermisos =
        registerForActivityResult(
            ActivityResultContracts.RequestMultiplePermissions()
        ) { resultado ->
            if (resultado.values.all { it }) {
                iniciarCamara()
            } else {
                Toast.makeText(
                    this,
                    "Sin permisos no podemos usar la cámara",
                    Toast.LENGTH_LONG
                ).show()
            }
        }

    private fun permisosConcedidos() = listOf(
        Manifest.permission.CAMERA,
        Manifest.permission.RECORD_AUDIO
    ).all {
        ContextCompat.checkSelfPermission(this, it) ==
            PackageManager.PERMISSION_GRANTED
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        if (permisosConcedidos()) {
            iniciarCamara()
        } else {
            pedirPermisos.launch(
                arrayOf(
                    Manifest.permission.CAMERA,
                    Manifest.permission.RECORD_AUDIO
                )
            )
        }
    }

    private fun iniciarCamara() { /* lo completamos más abajo */ }
}

Si trabajas con otros stacks móviles, la lógica de permisos es muy parecida; por ejemplo, en la guía de Flutter para aplicaciones multiplataforma verás cómo los plugins esconden estas mismas llamadas nativas.

La anatomía de Camera2 en cinco piezas

Camera2 se entiende mejor como una tubería. Tú describes qué quieres capturar y hacia dónde enviarlo, y el sistema produce fotogramas continuamente. Las piezas son estas:

  1. CameraManager: servicio del sistema que enumera las cámaras, informa de sus características y abre la que elijas.
  2. CameraDevice: la conexión abierta con una cámara concreta, que se obtiene de forma asíncrona.
  3. Surface: el destino de los píxeles, ya sea una vista en pantalla, un lector de imágenes o un grabador.
  4. CaptureRequest: la descripción de una captura, con una plantilla (previa, foto, grabación) y los destinos y ajustes.
  5. CameraCaptureSession: el canal que une los destinos con el dispositivo y por el que envías las solicitudes.

Casi todo es asíncrono mediante callbacks, y cada callback se ejecuta en el hilo que tú indiques. Por eso lo primero que haremos es crear un hilo propio, de modo que el trabajo de cámara no compita con el dibujo de la interfaz.

Diseño de la pantalla

Usaremos un TextureView para la previa. Existe también SurfaceView, que es más eficiente, pero TextureView se comporta como una vista normal (se puede animar o transformar) y simplifica el ejemplo. Dos botones completan la interfaz.

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextureView
        android:id="@+id/vistaPrevia"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:gravity="center"
        android:orientation="horizontal"
        android:padding="16dp">

        <Button
            android:id="@+id/botonFoto"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Foto" />

        <Button
            android:id="@+id/botonVideo"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginStart="16dp"
            android:text="Grabar" />
    </LinearLayout>
</FrameLayout>

Un detalle que provoca confusión: la superficie del TextureView no existe hasta que la vista se adjunta a la ventana. Por eso no se puede abrir la cámara directamente en onCreate; hay que esperar a que el listener avise de que la textura está disponible. Si la vista ya estaba disponible (al volver de segundo plano, por ejemplo), se arranca directamente.

Elegir la cámara y abrirla

Empezamos por el hilo de fondo y por el selector de cámara. Recorremos los identificadores, consultamos las características de cada una y nos quedamos con la trasera. De sus configuraciones de flujo tomamos un tamaño de salida compatible.

class CamaraController(
    private val contexto: Context,
    private val vista: TextureView
) {
    private val manager =
        contexto.getSystemService(Context.CAMERA_SERVICE) as CameraManager

    private var hilo: HandlerThread? = null
    private var manejador: Handler? = null

    private var dispositivo: CameraDevice? = null
    private var sesion: CameraCaptureSession? = null
    private lateinit var idCamara: String
    private lateinit var tamanoPrevia: Size

    fun arrancarHilo() {
        hilo = HandlerThread("hilo-camara").also { it.start() }
        manejador = Handler(hilo!!.looper)
    }

    fun detenerHilo() {
        hilo?.quitSafely()
        hilo?.join()
        hilo = null
        manejador = null
    }

    private fun elegirCamaraTrasera() {
        for (id in manager.cameraIdList) {
            val info = manager.getCameraCharacteristics(id)
            val lado = info.get(CameraCharacteristics.LENS_FACING)
            if (lado == CameraCharacteristics.LENS_FACING_BACK) {
                val mapa = info.get(
                    CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP
                ) ?: continue
                idCamara = id
                tamanoPrevia = mapa
                    .getOutputSizes(SurfaceTexture::class.java)
                    .filter { it.width * 9 == it.height * 16 }
                    .maxByOrNull { it.width * it.height }
                    ?: mapa.getOutputSizes(SurfaceTexture::class.java).first()
                return
            }
        }
        error("Este dispositivo no tiene cámara trasera")
    }
}

El filtro width * 9 == height * 16 busca resoluciones 16:9 para evitar una previa deformada. En una aplicación real calcularías la proporción más cercana a la de tu vista, y ajustarías además con una matriz de transformación si la pantalla rota.

Abrir la cámara requiere un StateCallback, que informa de tres situaciones: apertura correcta, desconexión y error. Gestionar el error con mensajes legibles te ahorrará mucho tiempo, porque los códigos numéricos no dicen nada a simple vista.

@SuppressLint("MissingPermission")
fun abrir() {
    elegirCamaraTrasera()
    manager.openCamera(idCamara, object : CameraDevice.StateCallback() {
        override fun onOpened(camera: CameraDevice) {
            dispositivo = camera
            crearSesionDePrevia()
        }

        override fun onDisconnected(camera: CameraDevice) {
            camera.close()
            dispositivo = null
        }

        override fun onError(camera: CameraDevice, codigo: Int) {
            camera.close()
            dispositivo = null
            val motivo = when (codigo) {
                ERROR_CAMERA_IN_USE -> "La cámara está en uso por otra app"
                ERROR_MAX_CAMERAS_IN_USE -> "Demasiadas cámaras abiertas"
                ERROR_CAMERA_DISABLED -> "Una política del sistema la bloquea"
                ERROR_CAMERA_DEVICE -> "Fallo fatal del dispositivo"
                ERROR_CAMERA_SERVICE -> "Fallo del servicio de cámara"
                else -> "Error desconocido ($codigo)"
            }
            Log.e("Camara", motivo)
        }
    }, manejador)
}

Observa que pasamos manejador como segundo argumento: así los tres métodos del callback se ejecutan en nuestro hilo y no en el principal. Las constantes ERROR_* pertenecen a CameraDevice.StateCallback, por lo que en tu archivo las importarás o las prefijarás.

Mostrar la vista previa en vivo

Con la cámara abierta, necesitamos una superficie y una solicitud de tipo previa. Tomamos la textura de la vista, le fijamos el tamaño del búfer y la envolvemos en una Surface. Después creamos la sesión; solo cuando el sistema avisa de que está configurada podemos lanzar la solicitud repetitiva.

private var superficiePrevia: Surface? = null
private lateinit var solicitudPrevia: CaptureRequest.Builder

private fun crearSesionDePrevia() {
    val textura = vista.surfaceTexture ?: return
    textura.setDefaultBufferSize(tamanoPrevia.width, tamanoPrevia.height)
    val superficie = Surface(textura).also { superficiePrevia = it }

    solicitudPrevia = dispositivo!!
        .createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW)
        .apply { addTarget(superficie) }

    val destinos = listOf(superficie, lectorFotos.surface)
    dispositivo!!.createCaptureSession(
        destinos,
        object : CameraCaptureSession.StateCallback() {
            override fun onConfigured(s: CameraCaptureSession) {
                sesion = s
                s.setRepeatingRequest(
                    solicitudPrevia.build(), null, manejador
                )
            }

            override fun onConfigureFailed(s: CameraCaptureSession) {
                Log.e("Camara", "No se pudo configurar la sesión")
            }
        },
        manejador
    )
}

La solicitud repetitiva es lo que mantiene el flujo de fotogramas activo: el sistema la reenvía a la cámara una y otra vez hasta que la detengas. Fíjate en que ya incluimos el lector de imágenes de la siguiente sección entre los destinos de la sesión; los destinos se declaran al crear la sesión y no se pueden añadir después sin recrearla.

Nota sobre versiones: el método createCaptureSession con lista de superficies está marcado como obsoleto desde Android 9 en favor de una variante que recibe un SessionConfiguration y un Executor. Sigue funcionando y es la más simple para aprender, pero en un proyecto nuevo con minSdk alto conviene migrar a la forma moderna.

Enlazamos todo con el ciclo de vida de la actividad. Es una de las partes en que más apps filtran recursos, porque la cámara es exclusiva: si no la liberas en onPause, otra aplicación no podrá abrirla.

override fun onResume() {
    super.onResume()
    camara.arrancarHilo()
    if (vista.isAvailable) {
        camara.abrir()
    } else {
        vista.surfaceTextureListener = object : TextureView.SurfaceTextureListener {
            override fun onSurfaceTextureAvailable(t: SurfaceTexture, w: Int, h: Int) =
                camara.abrir()
            override fun onSurfaceTextureSizeChanged(t: SurfaceTexture, w: Int, h: Int) {}
            override fun onSurfaceTextureDestroyed(t: SurfaceTexture) = true
            override fun onSurfaceTextureUpdated(t: SurfaceTexture) {}
        }
    }
}

override fun onPause() {
    camara.cerrar()
    camara.detenerHilo()
    super.onPause()
}

Y el método de cierre, que respeta el orden correcto: primero la sesión, luego el dispositivo y por último los lectores.

fun cerrar() {
    sesion?.close(); sesion = null
    dispositivo?.close(); dispositivo = null
    lectorFotos.close()
    superficiePrevia?.release(); superficiePrevia = null
}

Tomar una fotografía en JPEG

Para las fotos usamos una plantilla distinta, la de captura fija, y un ImageReader que recibe los bytes ya codificados. Lo creamos con el tamaño máximo que la cámara ofrezca en JPEG y le damos un margen de dos imágenes en memoria para que una captura no bloquee a la siguiente.

private val lectorFotos: ImageReader by lazy {
    val mapa = manager.getCameraCharacteristics(idCamara)
        .get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)!!
    val maximo = mapa.getOutputSizes(ImageFormat.JPEG)
        .maxByOrNull { it.width * it.height }!!

    ImageReader.newInstance(maximo.width, maximo.height, ImageFormat.JPEG, 2)
        .apply {
            setOnImageAvailableListener({ lector ->
                val imagen = lector.acquireNextImage() ?: return@setOnImageAvailableListener
                imagen.use {
                    val bytes = ByteArray(it.planes[0].buffer.remaining())
                    it.planes[0].buffer.get(bytes)
                    guardarFoto(bytes)
                }
            }, manejador)
        }
}

Hay un punto crítico: la imagen debe cerrarse siempre tras usarla, sin excepción. La función use de Kotlin llama a close() aunque haya excepciones. Si olvidas cerrarla, el lector se queda sin búferes y las capturas posteriores dejan de llegar sin ningún aviso claro, uno de los fallos más desconcertantes de esta API.

Guardar el archivo en almacenamiento privado de la app no requiere permisos adicionales:

private fun guardarFoto(bytes: ByteArray) {
    val nombre = "foto_${System.currentTimeMillis()}.jpg"
    val archivo = File(contexto.getExternalFilesDir(Environment.DIRECTORY_PICTURES), nombre)
    archivo.writeBytes(bytes)
    Log.i("Camara", "Foto guardada en ${archivo.absolutePath}")
}

Ahora el disparo. Construimos una solicitud de captura fija con el lector como destino, indicamos la orientación del JPEG según la rotación de la pantalla y la enviamos con capture. A diferencia de la repetitiva, esta se ejecuta una sola vez.

private val orientaciones = mapOf(
    Surface.ROTATION_0 to 90,
    Surface.ROTATION_90 to 0,
    Surface.ROTATION_180 to 270,
    Surface.ROTATION_270 to 180
)

fun tomarFoto(rotacionPantalla: Int) {
    val solicitud = dispositivo!!
        .createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE)
        .apply {
            addTarget(lectorFotos.surface)
            set(CaptureRequest.JPEG_ORIENTATION, orientaciones[rotacionPantalla])
            set(CaptureRequest.CONTROL_AF_MODE,
                CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE)
        }
    sesion!!.capture(solicitud.build(), null, manejador)
}

La tabla de orientaciones asume una cámara trasera con sensor montado a 90 grados, que es lo habitual. Para ser exacto en todos los dispositivos, lee SENSOR_ORIENTATION de las características y combínalo con la rotación del display; así evitas fotos giradas en tabletas y plegables.

Grabar vídeo con MediaRecorder

La grabación añade un nuevo destino: el MediaRecorder. Su configuración es sensible al orden de las llamadas; si alteras la secuencia obtendrás una IllegalStateException sin mucha información. Primero se fijan las fuentes, luego el formato de contenedor, después codificadores y parámetros, y por último prepare().

private var grabador: MediaRecorder? = null
private lateinit var archivoVideo: File

private fun prepararGrabador() {
    archivoVideo = File(
        contexto.getExternalFilesDir(Environment.DIRECTORY_MOVIES),
        "clip_${System.currentTimeMillis()}.mp4"
    )
    grabador = (if (Build.VERSION.SDK_INT >= 31) MediaRecorder(contexto)
                else @Suppress("DEPRECATION") MediaRecorder()).apply {
        setAudioSource(MediaRecorder.AudioSource.MIC)
        setVideoSource(MediaRecorder.VideoSource.SURFACE)
        setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
        setOutputFile(archivoVideo.absolutePath)
        setVideoEncodingBitRate(8_000_000)
        setVideoFrameRate(30)
        setVideoSize(tamanoPrevia.width, tamanoPrevia.height)
        setVideoEncoder(MediaRecorder.VideoEncoder.H264)
        setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
        prepare()
    }
}

El constructor con contexto está disponible desde Android 12 y es el recomendado, razón por la que lo elegimos cuando el nivel de API lo permite. Con el grabador listo, creamos una sesión nueva cuyos destinos son la previa y la superficie del grabador, y con una plantilla de grabación.

fun iniciarGrabacion() {
    prepararGrabador()
    sesion?.close()

    val textura = vista.surfaceTexture!!
    textura.setDefaultBufferSize(tamanoPrevia.width, tamanoPrevia.height)
    val previa = Surface(textura)
    val destinoGrabador = grabador!!.surface

    val solicitud = dispositivo!!
        .createCaptureRequest(CameraDevice.TEMPLATE_RECORD)
        .apply {
            addTarget(previa)
            addTarget(destinoGrabador)
        }

    dispositivo!!.createCaptureSession(
        listOf(previa, destinoGrabador),
        object : CameraCaptureSession.StateCallback() {
            override fun onConfigured(s: CameraCaptureSession) {
                sesion = s
                s.setRepeatingRequest(solicitud.build(), null, manejador)
                grabador!!.start()
            }
            override fun onConfigureFailed(s: CameraCaptureSession) {
                Log.e("Camara", "Fallo al configurar la grabación")
            }
        },
        manejador
    )
}

fun detenerGrabacion() {
    grabador?.apply {
        stop()
        reset()
        release()
    }
    grabador = null
    crearSesionDePrevia()   // volvemos al modo previa
}

Dos cuidados importantes. Primero, llamar a stop() inmediatamente tras start() lanza una excepción porque aún no se grabó ningún fotograma; protege el botón con un breve intervalo o captura el error. Segundo, tras detener la grabación hay que recrear la sesión de previa, porque la anterior contenía un destino que ya no existe.

Para completar el cableado, los botones alternan el estado:

var grabando = false

botonFoto.setOnClickListener {
    camara.tomarFoto(windowManager.defaultDisplay.rotation)
}

botonVideo.setOnClickListener {
    if (grabando) {
        camara.detenerGrabacion()
        botonVideo.text = "Grabar"
    } else {
        camara.iniciarGrabacion()
        botonVideo.text = "Detener"
    }
    grabando = !grabando
}

Ten en cuenta que windowManager.defaultDisplay está obsoleto desde Android 11; en proyectos actuales usa display?.rotation de la actividad o de la vista.

El mismo resultado con CameraX

Ahora viene la comparación que justifica el cambio de herramienta. Con CameraX sustituimos el TextureView por un PreviewView, que gestiona la escala y la rotación por nosotros, y declaramos casos de uso que se vinculan al ciclo de vida. No hay hilos, ni sesiones, ni hay que cerrar nada a mano.

<androidx.camera.view.PreviewView
    android:id="@+id/vistaPrevia"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

La configuración completa cabe en una sola función:

private var capturaFoto: ImageCapture? = null
private var grabacionActiva: Recording? = null
private var capturaVideo: VideoCapture<Recorder>? = null

private fun iniciarCamaraX() {
    val futuro = ProcessCameraProvider.getInstance(this)
    futuro.addListener({
        val proveedor = futuro.get()

        val previa = Preview.Builder().build()
            .also { it.surfaceProvider = vistaPrevia.surfaceProvider }

        capturaFoto = ImageCapture.Builder()
            .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
            .build()

        val grabador = Recorder.Builder()
            .setQualitySelector(QualitySelector.from(Quality.FHD))
            .build()
        capturaVideo = VideoCapture.withOutput(grabador)

        proveedor.unbindAll()
        proveedor.bindToLifecycle(
            this,
            CameraSelector.DEFAULT_BACK_CAMERA,
            previa, capturaFoto, capturaVideo
        )
    }, ContextCompat.getMainExecutor(this))
}

Con bindToLifecycle, CameraX abre y cierra la cámara según el estado de la actividad. Vincular a la vez previa, foto y vídeo funciona en dispositivos con nivel de hardware suficiente; en gamas bajas la biblioteca puede reducir resoluciones automáticamente para que la combinación sea viable, algo que en Camera2 tendrías que calcular tú mismo.

Para tomar una foto y guardarla con MediaStore, de modo que aparezca en la galería sin permisos de almacenamiento:

private fun hacerFoto() {
    val valores = ContentValues().apply {
        put(MediaStore.MediaColumns.DISPLAY_NAME, "foto_${System.currentTimeMillis()}")
        put(MediaStore.MediaColumns.MIME_TYPE, "image/jpeg")
        put(MediaStore.MediaColumns.RELATIVE_PATH, "Pictures/CamaraLab")
    }
    val opciones = ImageCapture.OutputFileOptions.Builder(
        contentResolver,
        MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
        valores
    ).build()

    capturaFoto?.takePicture(
        opciones,
        ContextCompat.getMainExecutor(this),
        object : ImageCapture.OnImageSavedCallback {
            override fun onImageSaved(r: ImageCapture.OutputFileResults) {
                Log.i("CamaraX", "Guardada: ${r.savedUri}")
            }
            override fun onError(e: ImageCaptureException) {
                Log.e("CamaraX", "Fallo al capturar", e)
            }
        }
    )
}

Y la grabación de vídeo, que en esta API se reduce a iniciar y detener un objeto Recording:

@SuppressLint("MissingPermission")
private fun alternarVideo() {
    grabacionActiva?.let {
        it.stop()
        grabacionActiva = null
        return
    }

    val valores = ContentValues().apply {
        put(MediaStore.MediaColumns.DISPLAY_NAME, "clip_${System.currentTimeMillis()}")
        put(MediaStore.MediaColumns.RELATIVE_PATH, "Movies/CamaraLab")
    }
    val salida = MediaStoreOutputOptions.Builder(
        contentResolver, MediaStore.Video.Media.EXTERNAL_CONTENT_URI
    ).setContentValues(valores).build()

    grabacionActiva = capturaVideo!!.output
        .prepareRecording(this, salida)
        .withAudioEnabled()
        .start(ContextCompat.getMainExecutor(this)) { evento ->
            if (evento is VideoRecordEvent.Finalize && evento.hasError()) {
                Log.e("CamaraX", "Error de grabación: ${evento.error}")
            }
        }
}

Compara ambos enfoques: la versión de Camera2 ocupó más de cien líneas entre hilos, sesiones, lector de imágenes y grabador; la de CameraX cabe en unas cuarenta, y además se comporta mejor ante rotaciones y cambios de ciclo de vida. Si tu interfaz está escrita con Jetpack Compose, la serie 1.6 incluye un artefacto camera-compose con un visor listo para usar, así que no necesitas incrustar una vista clásica.

Quienes vengan del desarrollo multiplataforma encontrarán una experiencia similar en las bibliotecas de mapas en React Native para iOS y Android, donde también se enlazan permisos, ciclo de vida y vistas nativas.

Errores frecuentes y cómo resolverlos

Después de unas cuantas horas con la cámara, los fallos suelen repetirse. Esta lista resume los más comunes y su causa real:

  • La previa aparece negra: la sesión se creó antes de que la textura estuviera disponible, o se olvidó llamar a setRepeatingRequest dentro de onConfigured.
  • La app se congela al segundo disparo: la imagen del ImageReader no se cerró, de modo que los búferes se agotaron.
  • IllegalStateException al grabar: el orden de configuración del MediaRecorder es incorrecto, o se llamó a prepare() dos veces con el mismo objeto.
  • CameraAccessException con el código de cámara en uso: otra aplicación mantiene el dispositivo abierto, o tu actividad no liberó la cámara en onPause.
  • Fotos giradas 90 grados: la orientación JPEG no se calculó con la orientación del sensor.
  • Previa estirada: el tamaño de salida elegido no coincide con la proporción de la vista.
  • Cierres aleatorios en un modelo concreto: esos dispositivos exigen combinaciones de resoluciones específicas; es el escenario típico donde CameraX evita el problema.

Un buen hábito es registrar los códigos de error y el modelo del dispositivo desde el primer día. Para inspeccionar lo que está ocurriendo, el volcado del servicio de cámara de Android es muy útil:

adb shell dumpsys media.camera | head -n 40
Camera module API version: 0x3
Number of camera devices: 2
Device 0 maps to "0"
  Facing: BACK
  Orientation: 90
Device 1 maps to "1"
  Facing: FRONT
  Orientation: 270

Esa salida te dice cuántas cámaras hay, hacia dónde apuntan y con qué orientación de sensor, información esencial para corregir rotaciones.

Buenas prácticas de rendimiento y energía

La cámara es uno de los componentes que más batería consumen, así que conviene tratar bien su ciclo de vida. Libera siempre los recursos cuando la pantalla deja de estar visible, y no mantengas hilos de fondo después de cerrar. Una app que se deja la cámara abierta provoca además el indicador de privacidad del sistema, y los usuarios lo notan.

Elige resoluciones acordes al propósito. Una previa en 4K sobre una pantalla de 1080 píxeles solo gasta memoria y calor. Para análisis de imagen, como leer códigos de barras, basta con una resolución media; trabajar con fotogramas pequeños reduce la latencia y deja más margen de CPU.

Procesa los fotogramas fuera del hilo principal. En Camera2 ya tienes tu Handler; en CameraX el caso de uso ImageAnalysis entrega los fotogramas a un Executor que tú defines, y con la estrategia de mantener solo el último fotograma se descartan los antiguos si el procesamiento va lento.

Por último, guarda los archivos con cuidado. Si el resultado debe ser accesible para el usuario, escribe a través de MediaStore; si es temporal, usa el directorio privado de la app y bórralo cuando termines. Subir imágenes a un servidor suele pedir además comprimir y redimensionar antes del envío, un tema que se aborda en subir, recortar y redimensionar imágenes en Next.js desde el lado web.

Pruebas, emuladores y dispositivos reales

El emulador de Android Studio incluye cámaras virtuales, con una escena 3D que puedes recorrer con el teclado, y sirve para validar flujo y permisos. Sin embargo, no reproduce los problemas de los fabricantes, así que prueba en teléfonos físicos de al menos dos marcas distintas antes de publicar. Presta atención especial a tres escenarios: rotación de pantalla con la cámara abierta, paso a segundo plano durante una grabación y revocación del permiso desde los ajustes.

Si usas Camera2, escribe pruebas instrumentadas que abran y cierren la cámara en bucle; detectan fugas que tardarían días en aparecer de otra forma. Con CameraX puedes usar ProcessCameraProvider con una configuración de prueba y el módulo de pruebas de Jetpack para simular hardware, lo que permite verificar la lógica sin un dispositivo conectado.

Conclusiones

Camera2 es la puerta al hardware: con un CameraManager, un hilo propio, una sesión y solicitudes de captura puedes construir una previa, tomar fotos en JPEG y grabar vídeo con MediaRecorder. Es una API potente pero exigente, donde cada recurso se abre y se cierra a mano, y donde el orden de las operaciones importa tanto como los propios parámetros.

Para la mayoría de las aplicaciones, la ruta sensata hoy es CameraX 1.6, que condensa el mismo resultado en una fracción del código, se integra con el ciclo de vida y esconde las diferencias entre fabricantes. Reserva Camera2 para cuando necesites controles manuales o capacidades que la biblioteca no expone, y aprovecha lo aprendido aquí para interpretar los registros cuando algo falle.

Como siguiente paso, prueba a añadir cambio entre cámara frontal y trasera, enfoque al tocar la pantalla y análisis de fotogramas. Cada una de esas funciones refuerza los conceptos de superficie, solicitud y ciclo de vida que sostienen toda la plataforma de cámara de Android.