# Implementación de Telemetría en App Android Cler

## 1. Crear Servicio de Telemetría

Crear archivo: `app/src/main/java/com/cler/assistant/services/TelemetryService.kt`

```kotlin
package com.cler.assistant.services

import android.app.Service
import android.content.Intent
import android.os.IBinder
import kotlinx.coroutines.*
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import java.io.File

class TelemetryService : Service() {
    
    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
    private val client = OkHttpClient()
    private val API_URL = "http://localhost:8000/api/telemetry.php" // Cambiar a tu dominio en producción
    
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        startTelemetryReporting()
        return START_STICKY
    }
    
    private fun startTelemetryReporting() {
        scope.launch {
            while (isActive) {
                sendTelemetryData()
                delay(60000) // Enviar cada 60 segundos
            }
        }
    }
    
    private suspend fun sendTelemetryData() {
        try {
            val data = JSONObject().apply {
                put("device_id", getDeviceId())
                put("user_id", getUserId())
                put("is_active", true)
                put("storage_used", getStorageUsed())
                put("internet_usage", getInternetUsage())
                put("conversation_count", getConversationCount())
                put("app_usage_minutes", getAppUsageMinutes())
                put("last_activity", System.currentTimeMillis())
            }
            
            val body = data.toString().toRequestBody("application/json".toMediaType())
            val request = Request.Builder()
                .url(API_URL)
                .post(body)
                .build()
            
            client.newCall(request).execute()
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
    
    private fun getDeviceId(): String {
        val prefs = getSharedPreferences("cler_prefs", MODE_PRIVATE)
        return prefs.getString("device_id", android.provider.Settings.Secure.getString(
            contentResolver, android.provider.Settings.Secure.ANDROID_ID
        )) ?: ""
    }
    
    private fun getUserId(): Int {
        val prefs = getSharedPreferences("cler_prefs", MODE_PRIVATE)
        return prefs.getInt("user_id", 0)
    }
    
    private fun getStorageUsed(): Long {
        val dbFile = getDatabasePath("cler_database.db")
        return dbFile.length() / (1024 * 1024) // MB
    }
    
    private fun getInternetUsage(): Long {
        val prefs = getSharedPreferences("cler_stats", MODE_PRIVATE)
        return prefs.getLong("internet_usage_bytes", 0L)
    }
    
    private fun getConversationCount(): Int {
        val prefs = getSharedPreferences("cler_stats", MODE_PRIVATE)
        return prefs.getInt("conversation_count", 0)
    }
    
    private fun getAppUsageMinutes(): Int {
        val prefs = getSharedPreferences("cler_stats", MODE_PRIVATE)
        return prefs.getInt("app_usage_minutes", 0)
    }
    
    override fun onBind(intent: Intent?): IBinder? = null
    
    override fun onDestroy() {
        scope.cancel()
        super.onDestroy()
    }
}
```

## 2. Registrar Uso de Internet

En tu clase de búsqueda web, agregar:

```kotlin
// En WebSearchManager.kt o donde hagas las búsquedas
private fun trackInternetUsage(bytesUsed: Long) {
    val prefs = getSharedPreferences("cler_stats", Context.MODE_PRIVATE)
    val currentUsage = prefs.getLong("internet_usage_bytes", 0L)
    prefs.edit().putLong("internet_usage_bytes", currentUsage + bytesUsed).apply()
}

// Después de cada búsqueda web
response.body?.bytes()?.let { bytes ->
    trackInternetUsage(bytes.size.toLong())
}
```

## 3. Registrar Conversaciones y Tiempo de Uso

En tu Activity principal o ViewModel:

```kotlin
private var appStartTime = 0L

override fun onResume() {
    super.onResume()
    appStartTime = System.currentTimeMillis()
}

override fun onPause() {
    super.onPause()
    if (appStartTime > 0) {
        val sessionMinutes = (System.currentTimeMillis() - appStartTime) / (1000 * 60)
        trackAppUsage(sessionMinutes.toInt())
    }
}

private fun trackAppUsage(minutes: Int) {
    val prefs = getSharedPreferences("cler_stats", Context.MODE_PRIVATE)
    val currentUsage = prefs.getInt("app_usage_minutes", 0)
    prefs.edit().putInt("app_usage_minutes", currentUsage + minutes).apply()
}

// Cada vez que se envía un mensaje
private fun onMessageSent() {
    val prefs = getSharedPreferences("cler_stats", Context.MODE_PRIVATE)
    val count = prefs.getInt("conversation_count", 0)
    prefs.edit().putInt("conversation_count", count + 1).apply()
}
```

## 4. Iniciar Servicio en Application

En `MainActivity.kt` o `Application.kt`:

```kotlin
override fun onCreate() {
    super.onCreate()
    
    // Iniciar servicio de telemetría
    val intent = Intent(this, TelemetryService::class.java)
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        startForegroundService(intent)
    } else {
        startService(intent)
    }
}
```

## 5. Agregar Permisos en AndroidManifest.xml

```xml
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

<application>
    <!-- Otros componentes -->
    
    <service
        android:name=".services.TelemetryService"
        android:enabled="true"
        android:exported="false" />
</application>
```

## 6. Agregar Dependencias en build.gradle

```gradle
dependencies {
    implementation 'com.squareup.okhttp3:okhttp:4.12.0'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
}
```

## 7. Estructura de Datos Enviados

```json
{
  "device_id": "abc123xyz",
  "user_id": 1,
  "is_active": true,
  "storage_used": 45,
  "internet_usage": 1024000,
  "conversation_count": 150,
  "app_usage_minutes": 320,
  "last_activity": 1704067200000
}
```

## 8. Configuración del Servidor

El servidor ya está configurado en:
- **Endpoint**: `http://localhost:8000/api/telemetry.php`
- **Método**: POST
- **Content-Type**: application/json

La tabla `device_telemetry` en PostgreSQL ya está creada y lista para recibir datos.

## 9. Probar la Integración

Puedes probar manualmente con curl:

```bash
curl -X POST http://localhost:8000/api/telemetry.php \
  -H "Content-Type: application/json" \
  -d '{
    "device_id": "test_device_001",
    "user_id": 1,
    "is_active": true,
    "storage_used": 50,
    "internet_usage": 2048000,
    "conversation_count": 25,
    "app_usage_minutes": 120,
    "last_activity": 1704067200000
  }'
```

Después verifica en el dashboard que los datos aparezcan.

## Notas Importantes:

1. **Privacidad**: Asegúrate de informar a los usuarios sobre la recopilación de datos
2. **Batería**: El servicio está optimizado para no consumir mucha batería (1 envío por minuto)
3. **Datos móviles**: Considera usar WorkManager para enviar solo con WiFi si es necesario
4. **Errores**: Implementa un sistema de reintentos si falla el envío
