Creación del Motor de Lente para Selfie Cam en Android

Curso de Desarrollo de Aplicaciones con Huawei

Contenido del curso

Introducción a HMS Core

Autenticación con HMS Account Kit

Construyendo nuestra cámara de selfies con HMS ML Kit

Aplicando notificaciones push con HMS Push kit

Conclusiones y consejos

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0013:15

Creación del Motor de Lente para Selfie Cam en Android

Curso de Desarrollo de Aplicaciones con Huawei

Clase 19 de 31

Clase 19 / 31

Recursos

Construir una cámara de selfies con reconocimiento facial requiere un componente central que controle el lente del dispositivo: el Lens Engine. Este motor, proporcionado por Machine Learning de Huawei, es la pieza que conecta la superficie de la cámara con las capas de procesamiento gráfico. A continuación se explica paso a paso cómo implementarlo en Android con Kotlin.

¿Cómo se estructura la clase LensEnginePreview?

Dentro del paquete de cámara del proyecto se crea una nueva clase llamada LensEnginePreview [01:00]. Esta clase recibe como parámetros de constructor un contexto y un conjunto de atributos, y hereda de ViewGroup, la clase base de Android que agrupa vistas hijas.

Al heredar de ViewGroup es obligatorio implementar el método onLayout, que define cómo se posicionan los elementos visuales dentro del contenedor.

Las variables principales que se declaran son:

context: almacena el contexto de la actividad.
surfaceView: instancia de SurfaceView, la clase Android que gestiona la superficie donde se renderiza la imagen de la cámara [01:40].
startRequested: booleano que indica si ya se solicitó el arranque de la cámara.
surfaceAvailable: booleano que confirma si la superficie está lista para usarse.
lensEngine: objeto de tipo LensEngine del SDK de Huawei ML Kit, inicializado en nulo [02:15].
overlay: referencia a la clase GraphicOverlay creada en clases anteriores, también inicializada en nulo.

En el bloque init se establece startRequested y surfaceAvailable en false, se instancia el SurfaceView con el contexto y se agrega como vista hija mediante addView [02:50].

¿Qué funciones controlan el ciclo de vida de la cámara?

El ciclo de vida del lente se gestiona con tres funciones fundamentales.

¿Cómo funciona start?

La función start recibe el lensEngine y verifica que no sea nulo [03:20]. Si es nulo, significa que el motor ya no está disponible y se detiene el proceso. Cuando el motor existe, se asigna a la variable de clase, se marca startRequested = true y se invoca a startIfReady.

Una segunda sobrecarga de start acepta además el overlay, lo asigna y luego delega en la primera versión [04:10]. Esta separación permite inicializar la cámara con o sin capa gráfica.

¿Qué hacen stop y release?

La función stop verifica que el lensEngine no sea nulo y, de ser así, lo cierra con close() [03:40]. Esto detiene la captura de la cámara.

La función release libera completamente el recurso llamando a release() sobre el lensEngine y reasignándolo a nulo [05:00]. Se utiliza, por ejemplo, después de tomar una foto para devolver el control del hardware.

¿Cómo verifica startIfReady que la cámara esté lista?

Esta función es el corazón de la lógica de arranque [05:20]. Solo ejecuta el inicio real cuando se cumplen dos condiciones:

startRequested es true.
surfaceAvailable es true.

Cuando ambas se cumplen, se invoca lensEngine.run() pasándole el holder del SurfaceView. A continuación se obtienen las dimensiones de la pantalla mediante displayDimension del motor [05:50].

Se calculan dos valores de corrección con los métodos coarse (máximo) y atLeast (mínimo) del objeto Size de Huawei, aplicados al ancho y alto respectivamente [06:10]. Esto garantiza que la imagen se ajuste correctamente al tamaño del dispositivo.

Después se evalúa la orientación mediante context.resources.configuration.orientation. Si el dispositivo está en modo portrait, el overlay recibe la información de cámara con los valores mínimo y máximo invertidos respecto a landscape, junto con el lensType, que puede ser BACK_LENS o FRONT_LENS según la cámara activa [06:50]. Finalmente se limpia el overlay y se restablece startRequested a false.

¿Para qué sirve el SurfaceCallback?

Se crea una clase interna llamada SurfaceCallback que implementa SurfaceHolder.Callback [07:30]. Sus tres métodos controlan el estado de la superficie:

surfaceChanged: no requiere acción porque la superficie mantiene su forma.
surfaceDestroyed: establece surfaceAvailable = false.
surfaceCreated: marca surfaceAvailable = true, ejecuta startIfReady dentro de un bloque try-catch y captura cualquier IOException mostrando un mensaje de error si la cámara no puede arrancar [08:00].

Este callback es el enlace entre el sistema Android y la lógica del LensEngine, asegurando que la cámara solo se active cuando la superficie esté realmente disponible.

¿Has implementado Huawei ML Kit en alguno de tus proyectos? Comparte tu experiencia y las dificultades que encontraste.

Resumen

¿Cómo se estructura la clase LensEnginePreview?

Al heredar de ViewGroup es obligatorio implementar el método onLayout, que define cómo se posicionan los elementos visuales dentro del contenedor.

Las variables principales que se declaran son:

context: almacena el contexto de la actividad.
surfaceView: instancia de SurfaceView, la clase Android que gestiona la superficie donde se renderiza la imagen de la cámara [01:40].
startRequested: booleano que indica si ya se solicitó el arranque de la cámara.
surfaceAvailable: booleano que confirma si la superficie está lista para usarse.
lensEngine: objeto de tipo LensEngine del SDK de Huawei ML Kit, inicializado en nulo [02:15].
overlay: referencia a la clase GraphicOverlay creada en clases anteriores, también inicializada en nulo.

En el bloque init se establece startRequested y surfaceAvailable en false, se instancia el SurfaceView con el contexto y se agrega como vista hija mediante addView [02:50].

¿Qué funciones controlan el ciclo de vida de la cámara?

El ciclo de vida del lente se gestiona con tres funciones fundamentales.

¿Cómo funciona start?

Una segunda sobrecarga de start acepta además el overlay, lo asigna y luego delega en la primera versión [04:10]. Esta separación permite inicializar la cámara con o sin capa gráfica.

¿Qué hacen stop y release?

La función stop verifica que el lensEngine no sea nulo y, de ser así, lo cierra con close() [03:40]. Esto detiene la captura de la cámara.

¿Cómo verifica startIfReady que la cámara esté lista?

Esta función es el corazón de la lógica de arranque [05:20]. Solo ejecuta el inicio real cuando se cumplen dos condiciones:

startRequested es true.
surfaceAvailable es true.

¿Para qué sirve el SurfaceCallback?

Se crea una clase interna llamada SurfaceCallback que implementa SurfaceHolder.Callback [07:30]. Sus tres métodos controlan el estado de la superficie:

surfaceChanged: no requiere acción porque la superficie mantiene su forma.
surfaceDestroyed: establece surfaceAvailable = false.
surfaceCreated: marca surfaceAvailable = true, ejecuta startIfReady dentro de un bloque try-catch y captura cualquier IOException mostrando un mensaje de error si la cámara no puede arrancar [08:00].

Este callback es el enlace entre el sistema Android y la lógica del LensEngine, asegurando que la cámara solo se active cuando la superficie esté realmente disponible.

¿Has implementado Huawei ML Kit en alguno de tus proyectos? Comparte tu experiencia y las dificultades que encontraste.

package com.sandoval.hselfiecamera.camera

import android.content.Context
import android.content.res.Configuration
import android.util.AttributeSet
import android.util.Log
import android.view.SurfaceHolder
import android.view.SurfaceView
import android.view.ViewGroup
import com.huawei.hms.common.size.Size
import com.huawei.hms.mlsdk.common.LensEngine
import com.sandoval.hselfiecamera.overlay.GraphicOverlay
import java.io.IOException

class LensEnginePreview(context: Context, attrs: AttributeSet?) : ViewGroup(context, attrs) {

    private val mContext: Context = context
    private val mSurfaceView: SurfaceView
    private var mStartRequested: Boolean
    private var mSurfaceAvailable: Boolean
    private var mLensEngine: LensEngine? = null
    private var mOverlay: GraphicOverlay? = null

    init {
        mStartRequested = false
        mSurfaceAvailable = false
        mSurfaceView = SurfaceView(context)
        // Nuestra vista va a pedir un callback para agregar el lente
        this.addView(mSurfaceView)
    }

    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
        TODO("Not yet implemented")
    }

    @Throws(IOException::class)
    fun start(lensEngine: LensEngine?, overlay: GraphicOverlay?) {
        mOverlay = overlay
        start(lensEngine)
    }

    @Throws(IOException::class)
    fun start(lensEngine: LensEngine?) {
        if (lensEngine == null) {
            stop()
        }
        mLensEngine = lensEngine
        if (mLensEngine != null) {
            mStartRequested = true
            // Vamos a crear una funcion que nos va a decir
            //si la camara esta lista
        }
    }

    fun stop() {
        if (mLensEngine != null) {
            mLensEngine!!.close()
        }
    }

    fun release() {
        if (mLensEngine != null) {
            mLensEngine!!.release()
            mLensEngine = null
        }
    }

    @Throws(IOException::class)
    fun startIfReady() {
        if (mStartRequested && mSurfaceAvailable) {
            mLensEngine!!.run(mSurfaceView.holder)
            if (overlay != null) {
                val size: Size = mLensEngine!!.displayDimension
                val min: Int = size.width.coerceAtMost(size.height)
                val max: Int = size.width.coerceAtLeast((size.height))
                if (Configuration.ORIENTATION_PORTRAIT == mContext.resources.configuration.orientation) {
                    mOverlay!!.setCameraInfo(min, max, mLensEngine!!.lensType)
                } else {
                    mOverlay!!.setCameraInfo(max, min, mLensEngine!!.lensType)
                }
                mOverlay!!.clear()
            }
            mStartRequested = false
        }
    }

    private inner class SurfaceCallback : SurfaceHolder.Callback {


        override fun surfaceChanged(
            holder: SurfaceHolder?,
            format: Int,
            width: Int,
            height: Int
        ) {
        }

        override fun surfaceDestroyed(holder: SurfaceHolder?) {
            mSurfaceAvailable = false
        }

        override fun surfaceCreated(holder: SurfaceHolder?) {
            mSurfaceAvailable = true
            try {
                startIfReady()
            } catch (e: IOException) {
                Log.e("Error: ", "No pudimos iniciar la camra $e")
            }
        }

    }

}

package com.sandoval.hselfiecamera.camera

import android.content.Context
import android.content.res.Configuration
import android.util.AttributeSet
import android.util.Log
import android.view.SurfaceHolder
import android.view.SurfaceView
import android.view.ViewGroup
import com.huawei.hms.common.size.Size
import com.huawei.hms.mlsdk.common.LensEngine
import com.sandoval.hselfiecamera.overlay.GraphicOverlay
import java.io.IOException

class LensEnginePreview(context: Context, attrs: AttributeSet?) : ViewGroup(context, attrs) {

    private val mContext: Context = context
    private val mSurfaceView: SurfaceView
    private var mStartRequested: Boolean
    private var mSurfaceAvailable: Boolean
    private var mLensEngine: LensEngine? = null
    private var mOverlay: GraphicOverlay? = null

    init {
        mStartRequested = false
        mSurfaceAvailable = false
        mSurfaceView = SurfaceView(context)
        // Nuestra vista va a pedir un callback para agregar el lente
        this.addView(mSurfaceView)
    }

    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
        TODO("Not yet implemented")
    }

    @Throws(IOException::class)
    fun start(lensEngine: LensEngine?, overlay: GraphicOverlay?) {
        mOverlay = overlay
        start(lensEngine)
    }

    @Throws(IOException::class)
    fun start(lensEngine: LensEngine?) {
        if (lensEngine == null) {
            stop()
        }
        mLensEngine = lensEngine
        if (mLensEngine != null) {
            mStartRequested = true
            // Vamos a crear una funcion que nos va a decir
            //si la camara esta lista
        }
    }

    fun stop() {
        if (mLensEngine != null) {
            mLensEngine!!.close()
        }
    }

    fun release() {
        if (mLensEngine != null) {
            mLensEngine!!.release()
            mLensEngine = null
        }
    }

    @Throws(IOException::class)
    fun startIfReady() {
        if (mStartRequested && mSurfaceAvailable) {
            mLensEngine!!.run(mSurfaceView.holder)
            if (overlay != null) {
                val size: Size = mLensEngine!!.displayDimension
                val min: Int = size.width.coerceAtMost(size.height)
                val max: Int = size.width.coerceAtLeast((size.height))
                if (Configuration.ORIENTATION_PORTRAIT == mContext.resources.configuration.orientation) {
                    mOverlay!!.setCameraInfo(min, max, mLensEngine!!.lensType)
                } else {
                    mOverlay!!.setCameraInfo(max, min, mLensEngine!!.lensType)
                }
                mOverlay!!.clear()
            }
            mStartRequested = false
        }
    }

    private inner class SurfaceCallback : SurfaceHolder.Callback {


        override fun surfaceChanged(
            holder: SurfaceHolder?,
            format: Int,
            width: Int,
            height: Int
        ) {
        }

        override fun surfaceDestroyed(holder: SurfaceHolder?) {
            mSurfaceAvailable = false
        }

        override fun surfaceCreated(holder: SurfaceHolder?) {
            mSurfaceAvailable = true
            try {
                startIfReady()
            } catch (e: IOException) {
                Log.e("Error: ", "No pudimos iniciar la camra $e")
            }
        }

    }

}

Introducción a HMS Core

Creación de Cámara Selfie con Kits de Huawei

Depuración de Aplicaciones en la Nube con Huawei Cloud Debugging

Desarrollo de Aplicaciones con Huawei Mobile Services Core

Creación de Proyecto Android Studio con Huawei Kits

Creación de Aplicaciones en AppGallery Connect de Huawei

Generación de Huella Digital SHA-256 para Android Studio

Configuración de APIs Huawei para Proyecto de Selfies en Android Studio

Configuración de Gradle para Huawei en Android Studio

Sincronización de aplicaciones con dependencias Huawei en Gradle

Autenticación con HMS Account Kit

Diseño de Pantalla de Login con Huawei Account Kit

Autenticación con Huawei Account Kit en Aplicaciones Android

Autenticación con Huawei ID en Aplicaciones Android

Implementación de Logout con Huawei AccountKit y Refactorización en Android

Construyendo nuestra cámara de selfies con HMS ML Kit

Diseño de Pantalla en Selficam con Huawei ML Kit

Permisos de Cámara en Aplicaciones Android

Configuración y Personalización de Cámaras en Android

Personalización de Interfaz Gráfica para Cámara en Android

Reconocimiento Facial con Machine Learning en Android

Creación del Motor de Lente para Selfie Cam en Android

Implementación de Layout para Actividad de Cámara en Android

Integración de Cámara y Botones en Aplicación de Selfies

Implementación de Verificación Facial en App Android

Detección de Sonrisa y Rostro en Cámaras Huawei

Detección de Rostros y Cambio de Cámara en Android Studio

Implementación de Funcionalidad de Toma y Retoma de Fotos en Android

Guardar fotos en la galería con Android y Huawei Machine Learning

Aplicando notificaciones push con HMS Push kit

Implementación de Huawei Push Notifications en Android

Implementación de Push Notifications en AppGallery Connect

Configuración y Envío de Notificaciones Push en AppGallery Connect

Conclusiones y consejos

Solución de Problemas Comunes en Desarrollo con Huawei HMS Core

Eventos de Huawei para Desarrolladores y Servicios Ofrecidos

Creación del Motor de Lente para Selfie Cam en Android