¡Poder sin límites! Integrando APIs de Hardware Android: Sensores, NFC y Bluetooth LE

¡Bienvenido al fascinante mundo de la integración de hardware en Android! 🚀

En la actualidad, las aplicaciones móviles van mucho más allá de la simple interacción con la pantalla. Aprovechar las capacidades de hardware de un dispositivo Android, como sus sensores, la comunicación NFC o la conectividad Bluetooth Low Energy (BLE), abre un abanico de posibilidades para crear experiencias de usuario innovadoras, inmersivas y altamente funcionales. Este tutorial te sumergirá en las APIs clave de Android para interactuar con estos componentes de hardware, desde la detección de movimiento hasta la comunicación con dispositivos externos.

🎯 Objetivos del Tutorial

Al finalizar este tutorial, serás capaz de:

• Entender los fundamentos de las APIs de hardware de Android.
• Implementar la detección y el uso de sensores (acelerómetro, giroscopio, magnetómetro, etc.).
• Integrar la tecnología NFC para leer y escribir etiquetas, y para la comunicación P2P.
• Desarrollar aplicaciones que interactúen con dispositivos Bluetooth Low Energy (BLE), incluyendo escaneo, conexión y comunicación.
• Gestionar los permisos necesarios para cada API de hardware.
• Manejar los ciclos de vida de los componentes de hardware para una gestión eficiente de los recursos.

📖 1. Fundamentos de la Interacción con Hardware en Android

Antes de sumergirnos en el código, es crucial entender cómo Android gestiona el acceso al hardware subyacente. La plataforma proporciona una capa de abstracción que permite a los desarrolladores interactuar con los componentes de hardware de una manera consistente, sin necesidad de preocuparse por las complejidades del hardware específico del dispositivo.

1.1. Permisos de Hardware 🔑

La seguridad es primordial en Android. Por lo tanto, el acceso a la mayoría de las funcionalidades de hardware requiere que tu aplicación solicite permisos específicos al usuario. Estos permisos se declaran en el archivo AndroidManifest.xml y, para permisos "peligrosos" (como ubicación, acceso a la cámara o Bluetooth), también deben ser solicitados en tiempo de ejecución.

<!-- Ejemplos de permisos comunes para hardware -->
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_SCAN" /> <!-- API 31+ -->
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" /> <!-- API 31+ -->
<uses-permission android:name="android.permission.NFC" />

<!-- Para hardware que no es esencial pero mejora la experiencia -->
<uses-feature android:name="android.hardware.bluetooth_le" android:required="false" />
<uses-feature android:name="android.hardware.nfc" android:required="false" />
<uses-feature android:name="android.hardware.sensor.accelerometer" android:required="false" />

El atributo android:required="false" en <uses-feature> indica que tu aplicación puede funcionar sin ese hardware, lo que la hace disponible para más dispositivos. Si required="true", la app solo se mostrará en la Play Store a dispositivos con ese hardware.

1.2. Ciclo de Vida de los Componentes 🔄

La interacción con hardware a menudo implica el uso de recursos del sistema que consumen batería o memoria. Es fundamental iniciar y detener los componentes de hardware (como sensores o escaneos BLE) en los momentos adecuados del ciclo de vida de tu Activity o Fragment para evitar fugas de memoria o un consumo excesivo de energía.

Normalmente, las operaciones de inicio se realizan en onResume() o onCreate(), y las de detención en onPause() o onDestroy().

📡 2. Sensores de Android: Percibiendo el Entorno

Android ofrece una amplia gama de sensores que permiten a tu aplicación "sentir" el entorno del dispositivo. Estos sensores se agrupan en tres categorías principales:

• Sensores de movimiento: Acelerómetro, giroscopio, sensor de rotación vectorial.
• Sensores de posición: Magnetómetro (brújula), orientación (deprecated), georrotación.
• Sensores de entorno: Barómetro, fotómetro (luz), termómetro (deprecated), humedad.

2.1. Accediendo al SensorManager

El punto de entrada para interactuar con los sensores es el SensorManager.

class SensorActivity : AppCompatActivity(), SensorEventListener {

    private lateinit var sensorManager: SensorManager
    private var accelerometer: Sensor? = null

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

        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager

        // Comprobar si el dispositivo tiene un acelerómetro
        if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null) {
            accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
            Log.d("SensorActivity", "Acelerómetro disponible")
        } else {
            Log.e("SensorActivity", "Acelerómetro no disponible")
            // Manejar la falta del sensor, quizás deshabilitar alguna funcionalidad
        }
    }

    override fun onResume() {
        super.onResume()
        // Registrar el listener para el acelerómetro cuando la actividad está activa
        accelerometer?.also { accel ->
            sensorManager.registerListener(this, accel, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }

    override fun onPause() {
        super.onPause()
        // Es importante desregistrar el listener para ahorrar batería
        sensorManager.unregisterListener(this)
    }

    // Implementación de SensorEventListener
    override fun onSensorChanged(event: SensorEvent?) {
        if (event?.sensor?.type == Sensor.TYPE_ACCELEROMETER) {
            val x = event.values[0] // Aceleración a lo largo del eje X
            val y = event.values[1] // Aceleración a lo largo del eje Y
            val z = event.values[2] // Aceleración a lo largo del eje Z
            Log.d("SensorActivity", "X: $x, Y: $y, Z: $z")
            // Aquí puedes actualizar la UI o realizar alguna acción
        }
    }

    override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {
        // Se llama cuando la precisión del sensor cambia
        Log.d("SensorActivity", "Precisión del sensor ${sensor?.name} cambió a $accuracy")
    }
}

2.2. Tipos de Sensores Comunes

2.3. Sensores Compuestos y Más Avanzados

Android también ofrece sensores "virtuales" o compuestos que combinan datos de múltiples sensores físicos para proporcionar información más útil y estable, como:

• TYPE_GRAVITY: Componente de gravedad de la aceleración.
• TYPE_LINEAR_ACCELERATION: Aceleración sin la gravedad.
• TYPE_ROTATION_VECTOR: Orientación del dispositivo como un vector de rotación.

Estos sensores simplifican la tarea de obtener datos de movimiento complejos.

💳 3. Comunicación NFC: Interacciones de Proximidad

Near Field Communication (NFC) permite a dos dispositivos (o un dispositivo y una etiqueta) comunicarse cuando están muy cerca el uno del otro (típicamente a unos pocos centímetros). Es ideal para pagos móviles, intercambio de datos rápido, emparejamiento con dispositivos y lectura/escritura de etiquetas NFC.

3.1. Configuración de NFC

Primero, declara los permisos en tu AndroidManifest.xml:

<uses-permission android:name="android.permission.NFC" />
<uses-feature android:name="android.hardware.nfc" android:required="true" />

Luego, verifica si NFC está disponible y habilitado en el dispositivo:

class NfcActivity : AppCompatActivity() {

    private var nfcAdapter: NfcAdapter? = null

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

        nfcAdapter = NfcAdapter.getDefaultAdapter(this)

        if (nfcAdapter == null) {
            Log.e("NfcActivity", "NFC no está disponible en este dispositivo.")
            // Manejar la falta de NFC, quizás deshabilitar la funcionalidad
            return
        }

        if (!nfcAdapter!!.isEnabled) {
            Log.w("NfcActivity", "NFC está disponible pero no habilitado. Por favor, actívalo en la configuración.")
            // Puedes sugerir al usuario que habilite NFC
            // val intent = Intent(Settings.ACTION_NFC_SETTINGS)
            // startActivity(intent)
        }
    }
    // ... (rest of activity lifecycle methods)
}

3.2. Lectura de Etiquetas NFC (NFC Reader Mode)

Para leer etiquetas NFC, tu Activity necesita ser la que maneje las intenciones NFC. Esto se logra configurando un intent-filter en el AndroidManifest.xml o utilizando el enableReaderMode() de NfcAdapter.

Opción 1: intent-filter (para tipos de etiquetas específicos)

<activity android:name=".NfcActivity">
    <intent-filter>
        <action android:name="android.nfc.action.NDEF_DISCOVERED"/>
        <category android:name="android.intent.category.DEFAULT"/>
        <data android:mimeType="text/plain" /> <!-- Ejemplo: para etiquetas de texto plano -->
    </intent-filter>
    <intent-filter>
        <action android:name="android.nfc.action.TAG_DISCOVERED"/>
        <category android:name="android.intent.category.DEFAULT"/>
    </intent-filter>
    <!-- Para otros tipos, puedes usar TECH_DISCOVERED con un meta-data -->
</activity>

Cuando una etiqueta se detecta, se dispara la intención apropiada y tu Activity la recibirá en onNewIntent().

override fun onNewIntent(intent: Intent?) {
    super.onNewIntent(intent)
    if (NfcAdapter.ACTION_NDEF_DISCOVERED == intent?.action |
        NfcAdapter.ACTION_TAG_DISCOVERED == intent?.action) {
        
        val rawMsgs = intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES)
        if (rawMsgs != null) {
            val msgs: Array<NdefMessage> = Array(rawMsgs.size) { i -> rawMsgs[i] as NdefMessage }
            // Procesar los mensajes NDEF aquí
            for (msg in msgs) {
                for (record in msg.records) {
                    val payload = String(record.payload)
                    Log.d("NfcActivity", "Payload: $payload")
                    // Puedes filtrar por record.tnf y record.type para manejar diferentes tipos de datos
                }
            }
        } else {
            // Esto ocurre con ACTION_TAG_DISCOVERED si no es un tag NDEF
            val tag = intent.getParcelableExtra<Tag>(NfcAdapter.EXTRA_TAG)
            Log.d("NfcActivity", "Tag no NDEF detectada: ${tag?.id?.toHexString()}")
            // Puedes usar NfcA, NfcB, NfcF, IsoDep, Ndef, NdefFormatable para interactuar con el tag
        }
    }
}

private fun ByteArray.toHexString(): String = joinToString("") { "%02x".format(it) }

Opción 2: enableReaderMode() (recomendado para un control preciso)

Esta opción te da un control más granular sobre qué tipos de tags quieres detectar y evita que otras apps manejen el intent.

class NfcActivity : AppCompatActivity(), NfcAdapter.ReaderCallback {

    private var nfcAdapter: NfcAdapter? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_nfc)
        nfcAdapter = NfcAdapter.getDefaultAdapter(this)
        // ... (Verificación de NFC)
    }

    override fun onResume() {
        super.onResume()
        nfcAdapter?.enableReaderMode(this, this, 
            NfcAdapter.FLAG_READER_NFC_A or NfcAdapter.FLAG_READER_NFC_B, 
            null)
    }

    override fun onPause() {
        super.onPause()
        nfcAdapter?.disableReaderMode(this)
    }

    override fun onTagDiscovered(tag: Tag?) {
        // Un tag NFC ha sido detectado
        Log.d("NfcActivity", "Tag descubierto: ${tag?.id?.toHexString()}")
        // Aquí puedes interactuar directamente con el objeto Tag para leer/escribir
        val nfcV = NfcV.get(tag)
        if (nfcV != null) {
            try {
                nfcV.connect()
                val response = nfcV.transceive(byteArrayOf(0x02, 0x20, 0x00, 0x00)) // Ejemplo: leer un bloque
                Log.d("NfcActivity", "Respuesta NFC-V: ${response.toHexString()}")
            } catch (e: IOException) {
                Log.e("NfcActivity", "Error al comunicar con NfcV", e)
            } finally {
                try { nfcV.close() } catch (e: IOException) { /* ignore */ }
            }
        }
    }

    private fun ByteArray.toHexString(): String = joinToString("") { "%02x".format(it) }
}

3.3. Escritura de Etiquetas NFC

La escritura de etiquetas NFC sigue un proceso similar al de lectura, pero necesitas un objeto NdefMessage con los NdefRecord que deseas escribir. Asegúrate de que la etiqueta sea NdefFormatable o ya esté formateada como Ndef.

// ... dentro de onTagDiscovered o una función que se llama cuando se detecta un Tag
private fun writeTag(tag: Tag) {
    val ndef = Ndef.get(tag)
    if (ndef != null) {
        try {
            ndef.connect()
            if (ndef.isWritable) {
                val record = NdefRecord.createTextRecord("en", "Hola desde Android!")
                val message = NdefMessage(record)
                ndef.writeNdefMessage(message)
                Log.d("NfcActivity", "Mensaje NDEF escrito con éxito.")
            } else {
                Log.e("NfcActivity", "El tag no es escribible.")
            }
        } catch (e: IOException) {
            Log.e("NfcActivity", "Error al escribir en el tag NFC", e)
        } catch (e: FormatException) {
            Log.e("NfcActivity", "Error de formato NDEF", e)
        } finally {
            try { ndef.close() } catch (e: IOException) { /* ignore */ }
        }
    } else {
        // Si no es un tag NDEF, puedes intentar formatearlo
        val formatable = NdefFormatable.get(tag)
        if (formatable != null) {
            try {
                formatable.connect()
                formatable.format(NdefMessage(NdefRecord.createTextRecord("en", "Formateado!")))
                Log.d("NfcActivity", "Tag formateado y escrito.")
            } catch (e: Exception) {
                Log.e("NfcActivity", "Error al formatear o escribir tag", e)
            } finally {
                try { formatable.close() } catch (e: IOException) { /* ignore */ }
            }
        } else {
            Log.e("NfcActivity", "Tipo de tag no soportado para escritura NDEF.")
        }
    }
}

💡 4. Bluetooth Low Energy (BLE): Conectividad Eficiente

Bluetooth Low Energy (BLE) es una tecnología inalámbrica diseñada para la comunicación de bajo consumo con dispositivos pequeños, como wearables, sensores de salud, dispositivos IoT y balizas. A diferencia del Bluetooth clásico, BLE está optimizado para transferencias de datos intermitentes y rápidas, lo que lo hace ideal para dispositivos que funcionan con baterías pequeñas.

4.1. Permisos de BLE

Los permisos de BLE han evolucionado con las versiones de Android. Para API 31 (Android 12) y superiores, necesitas BLUETOOTH_SCAN y BLUETOOTH_CONNECT.

<uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30" />

<!-- Para Android 12 (API 31) y superior -->
<uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> <!-- Necesario para el escaneo en algunas versiones -->

<uses-feature android:name="android.hardware.bluetooth_le" android:required="true" />

También es necesario solicitar ACCESS_FINE_LOCATION en tiempo de ejecución para el escaneo de BLE en Android 10 e inferiores, ya que las balizas BLE pueden usarse para inferir la ubicación del usuario.

4.2. Activación de Bluetooth

Similar a NFC, primero debes verificar si Bluetooth está disponible y habilitado:

class BleActivity : AppCompatActivity() {

    private val REQUEST_ENABLE_BT = 1
    private val REQUEST_BLUETOOTH_PERMISSIONS = 2
    private lateinit var bluetoothAdapter: BluetoothAdapter

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

        val bluetoothManager = getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
        bluetoothAdapter = bluetoothManager.adapter

        if (!bluetoothAdapter.isEnabled) {
            val enableBtIntent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
            startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT)
        }

        checkPermissions()
    }

    private fun checkPermissions() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { // Android 12 (API 31) y superior
            if (checkSelfPermission(Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED |
                checkSelfPermission(Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
                requestPermissions(
                    arrayOf(Manifest.permission.BLUETOOTH_SCAN, Manifest.permission.BLUETOOTH_CONNECT),
                    REQUEST_BLUETOOTH_PERMISSIONS
                )
            }
        } else { // Android 11 (API 30) e inferior
            if (checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
                requestPermissions(arrayOf(Manifest.permission.ACCESS_FINE_LOCATION), REQUEST_BLUETOOTH_PERMISSIONS)
            }
        }
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (requestCode == REQUEST_BLUETOOTH_PERMISSIONS) {
            if (grantResults.all { it == PackageManager.PERMISSION_GRANTED }) {
                Log.d("BleActivity", "Permisos Bluetooth concedidos")
                // Ahora puedes iniciar el escaneo BLE
            } else {
                Log.e("BleActivity", "Permisos Bluetooth denegados")
                // Manejar denegación de permisos
            }
        }
    }

    // ... (rest of activity lifecycle methods and BLE operations)
}

4.3. Escaneo de Dispositivos BLE

Para encontrar dispositivos BLE, usarás BluetoothLeScanner.

// Dentro de BleActivity, después de verificar permisos y Bluetooth habilitado
private var bluetoothLeScanner: BluetoothLeScanner? = null
private val scanResults = mutableListOf<BluetoothDevice>()

private val leScanCallback = object : ScanCallback() {
    override fun onScanResult(callbackType: Int, result: ScanResult) {
        super.onScanResult(callbackType, result)
        result.device?.let { device ->
            if (!scanResults.contains(device)) {
                scanResults.add(device)
                Log.d("BleActivity", "Dispositivo encontrado: ${device.name ?: "Desconocido"} (${device.address})")
                // Actualizar UI, añadir a un RecyclerView, etc.
            }
        }
    }

    override fun onBatchScanResults(results: MutableList<ScanResult>?) {
        super.onBatchScanResults(results)
        results?.forEach { result ->
            result.device?.let { device ->
                if (!scanResults.contains(device)) {
                    scanResults.add(device)
                    Log.d("BleActivity", "Dispositivo en batch: ${device.name ?: "Desconocido"} (${device.address})")
                }
            }
        }
    }

    override fun onScanFailed(errorCode: Int) {
        super.onScanFailed(errorCode)
        Log.e("BleActivity", "Escaneo BLE falló con código: $errorCode")
    }
}

private fun startScan() {
    if (bluetoothAdapter.isEnabled) {
        bluetoothLeScanner = bluetoothAdapter.bluetoothLeScanner
        // Definir filtros de escaneo si quieres buscar dispositivos específicos por UUID
        val scanFilters: List<ScanFilter> = listOf(
            ScanFilter.Builder().setServiceUuid(ParcelUuid(UUID.fromString("0000180A-0000-1000-8000-00805F9B34FB"))).build()
        )
        // Configuración del escaneo
        val scanSettings = ScanSettings.Builder()
            .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY) // O HIGH_POWER, BALANCED, LOW_POWER
            .build()
        
        scanResults.clear()
        bluetoothLeScanner?.startScan(scanFilters, scanSettings, leScanCallback)
        Log.d("BleActivity", "Escaneo BLE iniciado...")
    } else {
        Log.w("BleActivity", "Bluetooth no habilitado, no se puede escanear.")
    }
}

private fun stopScan() {
    bluetoothLeScanner?.stopScan(leScanCallback)
    Log.d("BleActivity", "Escaneo BLE detenido.")
}

override fun onResume() {
    super.onResume()
    // Aquí puedes iniciar el escaneo después de verificar permisos
    // startScan()
}

override fun onPause() {
    super.onPause()
    stopScan()
}

4.4. Conexión y Comunicación con Dispositivos BLE

Una vez que encuentras un dispositivo, puedes conectar a él y descubrir sus servicios y características (GATT - Generic Attribute Profile).

// Dentro de BleActivity
private var bluetoothGatt: BluetoothGatt? = null

private val gattCallback = object : BluetoothGattCallback() {
    override fun onConnectionStateChange(gatt: BluetoothGatt?, status: Int, newState: Int) {
        super.onConnectionStateChange(gatt, status, newState)
        val deviceName = gatt?.device?.name ?: "Desconocido"
        if (newState == BluetoothProfile.STATE_CONNECTED) {
            Log.d("BleActivity", "Conectado a $deviceName. Intentando descubrir servicios...")
            bluetoothGatt?.discoverServices() // Descubre los servicios GATT
        } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
            Log.d("BleActivity", "Desconectado de $deviceName")
            bluetoothGatt?.close()
            bluetoothGatt = null
            // Aquí puedes reintentar la conexión o notificar a la UI
        }
    }

    override fun onServicesDiscovered(gatt: BluetoothGatt?, status: Int) {
        super.onServicesDiscovered(gatt, status)
        if (status == BluetoothGatt.GATT_SUCCESS) {
            Log.d("BleActivity", "Servicios descubiertos para ${gatt?.device?.name}")
            gatt?.services?.forEach { service ->
                Log.d("BleActivity", "Servicio: ${service.uuid}")
                service.characteristics.forEach { characteristic ->
                    Log.d("BleActivity", "  Característica: ${characteristic.uuid}")
                    if (characteristic.uuid == UUID.fromString("TU_UUID_CARACTERISTICA_LECTURA")) {
                        // Puedes leer o habilitar notificaciones/indicaciones aquí
                        gatt.readCharacteristic(characteristic)
                        // Para notificaciones:
                        // gatt.setCharacteristicNotification(characteristic, true)
                        // val descriptor = characteristic.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"))
                        // descriptor?.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
                        // gatt.writeDescriptor(descriptor)
                    }
                    if (characteristic.uuid == UUID.fromString("TU_UUID_CARACTERISTICA_ESCRITURA")) {
                        // Puedes escribir en esta característica
                        val valueToSend = byteArrayOf(0x01, 0x02, 0x03)
                        characteristic.value = valueToSend
                        gatt.writeCharacteristic(characteristic)
                    }
                }
            }
        } else {
            Log.e("BleActivity", "Error al descubrir servicios: $status")
        }
    }

    override fun onCharacteristicRead(gatt: BluetoothGatt?, characteristic: BluetoothGattCharacteristic?, status: Int) {
        super.onCharacteristicRead(gatt, characteristic, status)
        if (status == BluetoothGatt.GATT_SUCCESS) {
            val value = characteristic?.value?.toHexString()
            Log.d("BleActivity", "Lectura exitosa de ${characteristic?.uuid}: $value")
            // Actualizar UI con el valor leído
        }
    }

    override fun onCharacteristicWrite(gatt: BluetoothGatt?, characteristic: BluetoothGattCharacteristic?, status: Int) {
        super.onCharacteristicWrite(gatt, characteristic, status)
        if (status == BluetoothGatt.GATT_SUCCESS) {
            Log.d("BleActivity", "Escritura exitosa en ${characteristic?.uuid}")
        }
    }

    override fun onCharacteristicChanged(gatt: BluetoothGatt?, characteristic: BluetoothGattCharacteristic?) {
        super.onCharacteristicChanged(gatt, characteristic)
        val value = characteristic?.value?.toHexString()
        Log.d("BleActivity", "Característica ${characteristic?.uuid} cambió a: $value")
        // Los datos del dispositivo han cambiado, actualiza la UI
    }
}

fun connectToDevice(device: BluetoothDevice) {
    bluetoothGatt = device.connectGatt(this, false, gattCallback)
    // El segundo parámetro (autoConnect) indica si reconectar automáticamente
}

fun disconnectFromDevice() {
    bluetoothGatt?.disconnect()
}

private fun ByteArray.toHexString(): String = joinToString("") { "%02x".format(it) }

4.5. Consideraciones para BLE

• UUIDs: Los servicios y características BLE se identifican mediante UUIDs (Universally Unique Identifiers). Deberás conocer los UUIDs de los dispositivos con los que quieres interactuar.
• Perfiles GATT: Los perfiles GATT definen cómo se estructuran los datos y las interacciones para un tipo específico de dispositivo (por ejemplo, perfil de frecuencia cardíaca, perfil de termómetro). Consulta la documentación de los dispositivos BLE que vas a usar.
• Errores y reintentos: La conectividad BLE puede ser volátil. Implementa una lógica robusta para manejar errores de conexión, desconexiones inesperadas y reintentos.
• Hilos: Las operaciones BLE (connectGatt, readCharacteristic, writeCharacteristic) son asíncronas, pero los callbacks se llaman en el hilo principal. Si las operaciones de datos son intensivas, procésalas en un hilo secundario.

✅ 5. Buenas Prácticas y Consejos Adicionales

• Gestión de Permisos: Utiliza bibliotecas como EasyPermissions o el enfoque ActivityResultContracts de Jetpack para simplificar la gestión de permisos en tiempo de ejecución.
• Manejo de Errores: Siempre encapsula las operaciones de hardware en bloques try-catch para manejar IOException y otras excepciones que puedan ocurrir debido a problemas de comunicación o disponibilidad del hardware.
• UI/UX: Proporciona retroalimentación clara al usuario sobre el estado del hardware (NFC habilitado/deshabilitado, escaneando BLE, etc.). Un indicador visual o un mensaje Toast pueden ser muy útiles.
• Consumo de Batería: El uso constante de sensores, escaneo BLE o NFC puede agotar rápidamente la batería. Deshabilita el hardware cuando tu aplicación no lo necesite (ej. en onPause()).
• Pruebas en Dispositivos Reales: Aunque los emuladores de Android han mejorado, la interacción con hardware siempre debe probarse en dispositivos físicos reales para asegurar un comportamiento correcto y un buen rendimiento.
• Background Tasks: Si necesitas interactuar con hardware en segundo plano (ej. un servicio que escanea balizas BLE), considera usar WorkManager o un Foreground Service para gestionar los recursos de forma eficiente y cumplir con las restricciones de Android.

🔮 Futuro y Más Allá

Las APIs de hardware de Android están en constante evolución. Mantente al día con las últimas actualizaciones de la plataforma y las nuevas APIs. Por ejemplo, la API de sensores fusionados, las mejoras en BLE 5.0+, y las integraciones con Android Auto o Wear OS abren nuevas puertas para la innovación. Explora la documentación oficial de Android para profundizar en temas específicos y descubrir aún más posibilidades.

📚 Recursos Adicionales

• Documentación oficial de Sensores de Android
• Documentación oficial de NFC de Android
• Documentación oficial de Bluetooth Low Energy (BLE) de Android
• Ejemplo de código de Sensores en GitHub

🎉 Conclusión

Has llegado al final de este completo tutorial. Ahora tienes una base sólida para integrar el potente hardware de Android en tus aplicaciones. Desde la detección de movimientos con sensores, la interacción de proximidad con NFC, hasta la comunicación de bajo consumo con dispositivos BLE, las posibilidades son infinitas. ¡Anímate a experimentar y crear experiencias móviles verdaderamente innovadoras y conectadas con el mundo real!