Temas Avanzados de Android

// SharedPreferences — forma clásica
val prefs = getSharedPreferences("mi_app", Context.MODE_PRIVATE)
prefs.edit().apply {
    putString("nombre", "Juan")
    putBoolean("sesion", true)
}.apply()  // asíncrono

// DataStore — forma moderna (recomendada)
val NAME_KEY = stringPreferencesKey("nombre")

// Guardar
lifecycleScope.launch {
    dataStore.edit { prefs -> prefs[NAME_KEY] = "Juan" }
}

// Leer como Flow reactivo
val nombre: Flow<String> = dataStore.data
    .map { prefs -> prefs[NAME_KEY] ?: "" }

// Implementación básica — abrir mapa y añadir marcador
class MapActivity : AppCompatActivity(), OnMapReadyCallback {

    override fun onMapReady(map: GoogleMap) {
        val madrid = LatLng(40.4168, -3.7038)
        map.addMarker(
            MarkerOptions().position(madrid).title("Madrid")
        )
        map.animateCamera(
            CameraUpdateFactory.newLatLngZoom(madrid, 12f)
        )
    }
}

// Obtener la última ubicación conocida
val fusedClient = LocationServices.getFusedLocationProviderClient(this)

fusedClient.lastLocation.addOnSuccessListener { location ->
    location?.let {
        val lat = it.latitude   // ej: 40.4168
        val lng = it.longitude  // ej: -3.7038
    }
}

// Actualizaciones periódicas (cada 5 segundos)
val request = LocationRequest.Builder(
    Priority.PRIORITY_HIGH_ACCURACY, 5000L)
    .setMinUpdateIntervalMillis(2000L)
    .build()

fusedClient.requestLocationUpdates(request, locationCallback,
    Looper.getMainLooper())

// Crear una geovalla circular de 150 metros
val geofence = Geofence.Builder()
    .setRequestId("oficina")
    .setCircularRegion(lat, lng, 150f)  // radio en metros
    .setTransitionTypes(
        Geofence.GEOFENCE_TRANSITION_ENTER or
        Geofence.GEOFENCE_TRANSITION_EXIT)
    .setExpirationDuration(Geofence.NEVER_EXPIRE)
    .build()

class SensorActivity : AppCompatActivity(), SensorEventListener {

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

    override fun onCreate(b: Bundle?) {
        super.onCreate(b)
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
    }

    override fun onResume() {          // Registrar al volver a primer plano
        super.onResume()
        sensorManager.registerListener(this, sensor,
            SensorManager.SENSOR_DELAY_NORMAL)
    }

    override fun onPause() {           // SIEMPRE desregistrar al pausar
        super.onPause()
        sensorManager.unregisterListener(this)
    }

    override fun onSensorChanged(event: SensorEvent) {
        val x = event.values[0]  // Eje X
        val y = event.values[1]  // Eje Y
        val z = event.values[2]  // Eje Z
    }
}

// Desde recurso local (res/raw/musica.mp3)
val player = MediaPlayer.create(this, R.raw.musica)
player?.start()

// Desde URL — no bloqueante
MediaPlayer().apply {
    setDataSource("https://ejemplo.com/audio.mp3")
    setOnPreparedListener { start() }
    prepareAsync()  // No bloquea el hilo principal
}

// IMPORTANTE: siempre liberar en onDestroy()
override fun onDestroy() {
    super.onDestroy()
    player?.release()
    player = null
}

// ExoPlayer con Media3
private var player: ExoPlayer? = null

override fun onStart() {
    super.onStart()
    player = ExoPlayer.Builder(this).build().also {
        binding.playerView.player = it
        val item = MediaItem.fromUri("https://ejemplo.com/video.m3u8")
        it.setMediaItem(item)
        it.prepare()
        it.playWhenReady = true
    }
}

override fun onStop() {
    super.onStop()
    player?.release()
    player = null
}

// Solicitar permisos en runtime
val requestPermissions = registerForActivityResult(
    ActivityResultContracts.RequestMultiplePermissions()) { perms ->
    val camOk = perms[Manifest.permission.CAMERA] == true
    val micOk = perms[Manifest.permission.RECORD_AUDIO] == true
    if (camOk && micOk) startCamera()
}

requestPermissions.launch(arrayOf(
    Manifest.permission.CAMERA,
    Manifest.permission.RECORD_AUDIO
))

// res/xml/widget_info.xml — configuración del widget
<appwidget-provider
    android:minWidth="110dp"
    android:minHeight="40dp"
    android:updatePeriodMillis="1800000"   // 30 minutos (mínimo)
    android:previewImage="@drawable/widget_preview"
    android:initialLayout="@layout/widget_layout"/>

// AppWidgetProvider — lógica del widget
class MiWidget : AppWidgetProvider() {
    override fun onUpdate(context: Context, manager: AppWidgetManager, ids: IntArray) {
        ids.forEach { id ->
            val views = RemoteViews(context.packageName, R.layout.widget_layout)
            views.setTextViewText(R.id.tv_widget, "¡Actualizado!")

            // Acción al tocar el widget
            val intent = Intent(context, MainActivity::class.java)
            val pi = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_IMMUTABLE)
            views.setOnClickPendingIntent(R.id.tv_widget, pi)
            manager.updateAppWidget(id, views)
        }
    }
}

// Interface de la API — describe los endpoints
interface ApiService {
    @GET("users")
    suspend fun getUsers(): Response<List<User>>

    @GET("users/{id}")
    suspend fun getUser(@Path("id") id: Int): Response<User>

    @POST("users")
    suspend fun createUser(@Body user: UserRequest): Response<User>

    @GET("products")
    suspend fun searchProducts(
        @Query("q") query: String,
        @Query("page") page: Int = 1
    ): Response<List<Product>>
}

// Uso en ViewModel con corrutinas
fun loadUsers() {
    viewModelScope.launch {
        try {
            val response = RetrofitClient.instance.getUsers()
            if (response.isSuccessful) {
                _users.value = response.body() ?: emptyList()
            }
        } catch (e: IOException) {
            Log.e("VM", "Sin conexión: ${e.message}")
        }
    }
}

// Interceptor OkHttp — añade el token a todas las peticiones
class AuthInterceptor(private val tokenProvider: () -> String?) : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val token = tokenProvider()
        return if (token != null) {
            val request = chain.request().newBuilder()
                .header("Authorization", "Bearer $token")
                .build()
            chain.proceed(request)
        } else {
            chain.proceed(chain.request())
        }
    }
}

// 1. Escanear dispositivos BLE cercanos
val scanCallback = object : ScanCallback() {
    override fun onScanResult(callbackType: Int, result: ScanResult) {
        val device = result.device
        Log.d("BLE", "Encontrado: ${device.name} / ${device.address}")
        // RSSI = intensidad de señal en dBm (más cercano a 0 = más fuerte)
        Log.d("BLE", "Señal: ${result.rssi} dBm")
    }
}
scanner.startScan(filters, settings, scanCallback)

// 2. Conectar y leer una característica
val gatt = device.connectGatt(context, false,
    object : BluetoothGattCallback() {
        override fun onConnectionStateChange(gatt, status, newState) {
            if (newState == BluetoothProfile.STATE_CONNECTED)
                gatt.discoverServices()
        }
        override fun onCharacteristicRead(
            gatt, characteristic, value: ByteArray, status) {
            val datos = String(value)
            runOnUiThread { actualizarUI(datos) }
        }
    }
)

// 3. Siempre cerrar al terminar
gatt?.close()