Technisches Lastenheft · Phase 1

// ═══════════════════════════════════════════════════════════════
// BACKGROUND SERVICE · Klassen-Hierarchie · Android + iOS
// Ziel: Mikrofon-Monitoring mit minimalem Akku-Verbrauch
// ═══════════════════════════════════════════════════════════════

// ─────────────────────────────────────────────────────────────────
// ANDROID: Klassen-Hierarchie
// ─────────────────────────────────────────────────────────────────

abstract class BaseSecSIService : Service() {
    abstract val serviceId:   Int
    abstract val channelId:   String
    abstract fun onSessionActive(): Boolean

    protected fun startAsForeground(label: String, icon: Int) {
        createNotificationChannel()
        startForeground(serviceId, buildMinimalNotification(label, icon))
    }

    private fun buildMinimalNotification(label: String, icon: Int): Notification =
        NotificationCompat.Builder(this, channelId)
            .setSmallIcon(icon)
            .setContentTitle("")         // Leer für Unauffälligkeit
            .setOngoing(true)
            .setPriority(NotificationCompat.PRIORITY_MIN)
            .setShowWhen(false)
            .setVisibility(NotificationCompat.VISIBILITY_SECRET)  // Nicht auf Lockscreen
            .build()
}

// ── Haupt-Service: SafetyMonitoringService ───────────────────────
class SafetyMonitoringService : BaseSecSIService() {

    override val serviceId = 1337
    override val channelId = "secsi_monitoring"
    override fun onSessionActive() = sessionRepository.hasActiveSession()

    // Sub-Services als Coroutine-Jobs
    private val serviceJobs = mutableMapOf<String, Job>()
    private val serviceScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)

    // Komponenten (Dependency Injection via Hilt)
    @Inject lateinit var keywordEngine:    KeywordDetectionEngine
    @Inject lateinit var audioCapturer:    BatteryAwareAudioCapture
    @Inject lateinit var locationTracker:  AdaptiveLocationTracker
    @Inject lateinit var alarmDispatcher:  AlarmDispatcher
    @Inject lateinit var sessionRepo:      SessionRepository

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        startAsForeground("", R.drawable.ic_secsi_minimal)

        when (intent?.action) {
            ACTION_START_SESSION  -> startAllMonitors()
            ACTION_STOP_SESSION   -> stopAllMonitors()
            ACTION_KEYWORD_ONLY   -> startKeywordOnly()   // Leichtgewichtig
        }
        return START_STICKY
    }

    private fun startAllMonitors() {
        serviceJobs["keyword"]  = serviceScope.launch { runKeywordDetection() }
        serviceJobs["location"] = serviceScope.launch { runLocationTracking() }
        serviceJobs["health"]   = serviceScope.launch { runHealthChecks() }
    }

    private suspend fun runKeywordDetection() {
        keywordEngine.initialize()
        audioCapturer.startCapture { frame ->
            keywordEngine.processFrame(frame)
                ?.let { alarmDispatcher.dispatchKeywordAlert(it) }
        }
    }

    private fun stopAllMonitors() {
        serviceJobs.values.forEach { it.cancel() }
        keywordEngine.stopDetection()
        audioCapturer.stop()
        locationTracker.stop()
        stopSelf()
    }
}

// ── BatteryAwareAudioCapture ──────────────────────────────────────
// Passt Audio-Qualität dynamisch an Akku-Stand an

class BatteryAwareAudioCapture @Inject constructor(
    private val context: Context,
    private val batteryMonitor: BatteryMonitor
) {
    companion object {
        // Volle Qualität (Akku > 30%)
        const val FULL_SAMPLE_RATE   = 16000
        const val FULL_BUFFER_SIZE   = 1600  // 100ms @ 16kHz

        // Eco-Modus (Akku ≤ 30%)
        const val ECO_SAMPLE_RATE    = 8000
        const val ECO_BUFFER_SIZE    = 800   // 100ms @ 8kHz
        const val ECO_DUTY_CYCLE_MS  = 500   // 500ms hören, 500ms pausieren

        // Ultra-Eco (Akku ≤ 15%)
        const val UECO_SAMPLE_RATE   = 8000
        const val UECO_DUTY_CYCLE_MS = 200   // 200ms hören, 800ms pausieren
    }

    private var audioRecord:     AudioRecord? = null
    private var isCapturing:     Boolean      = false
    private val captureScope     = CoroutineScope(Dispatchers.IO)

    fun startCapture(onFrame: (ShortArray) -> Unit) {
        isCapturing = true
        captureScope.launch {
            while (isCapturing) {
                val batteryLevel = batteryMonitor.getCurrentLevel()
                val config       = selectConfig(batteryLevel)
                captureFrame(config, onFrame)

                // Duty-Cycle-Pause (Akku-Schonung)
                if (config.hasDutyCycle) delay(config.pauseMs)
            }
        }
    }

    private fun selectConfig(batteryLevel: Int): CaptureConfig = when {
        batteryLevel > 30 -> CaptureConfig.FULL
        batteryLevel > 15 -> CaptureConfig.ECO
        else              -> CaptureConfig.ULTRA_ECO
    }

    private suspend fun captureFrame(config: CaptureConfig, onFrame: (ShortArray) -> Unit) {
        initAudioRecord(config)
        val buffer = ShortArray(config.bufferSize)
        val read   = audioRecord!!.read(buffer, 0, config.bufferSize)
        if (read > 0) onFrame(buffer.copyOf(read))
        if (!config.continuous) releaseAudioRecord()  // Eco: AudioRecord freigeben
    }
}

enum class CaptureConfig(
    val sampleRate:  Int,
    val bufferSize:  Int,
    val continuous:  Boolean,
    val hasDutyCycle:Boolean,
    val pauseMs:     Long
) {
    FULL      (16000, 1600, true,  false, 0),
    ECO       (8000,  800,  false, true,  500),
    ULTRA_ECO (8000,  800,  false, true,  800)
}

// ── AdaptiveLocationTracker ───────────────────────────────────────
class AdaptiveLocationTracker @Inject constructor(
    private val fusedLocationClient: FusedLocationProviderClient
) {
    // Intervall dynamisch anpassen: Gefahr = häufiger, Ruhephase = seltener
    private val dangerRequest = LocationRequest.Builder(Priority.HIGH_ACCURACY, 5_000).build()
    private val idleRequest   = LocationRequest.Builder(Priority.BALANCED_POWER, 30_000).build()

    fun setEscalationLevel(level: EscalationLevel) {
        val request = if (level == EscalationLevel.INTERVENTION) dangerRequest else idleRequest
        fusedLocationClient.requestLocationUpdates(request, locationCallback, Looper.getMainLooper())
    }
}

// ─────────────────────────────────────────────────────────────────
// iOS: Klassen-Hierarchie
// ─────────────────────────────────────────────────────────────────

// ── SafetyMonitoringCoordinator (iOS-Äquivalent zum Android-Service)

class SafetyMonitoringCoordinator {

    static let shared = SafetyMonitoringCoordinator()

    // Sub-Koordinatoren
    let keywordEngine      = KeywordDetectionEngine()
    let audioCapture       = BatteryAwareAudioCapture()
    let locationTracker    = AdaptiveLocationTracker()
    let alarmDispatcher    = AlarmDispatcher()
    var backgroundTask:    UIBackgroundTaskIdentifier = .invalid

    func startSession(type: SessionType) throws {
        // Background-Task registrieren (bis zu 30s bei App-Hintergrundwechsel)
        backgroundTask = UIApplication.shared.beginBackgroundTask {
            self.extendBackgroundExecution()
        }
        try keywordEngine.startDetection { [weak self] keyword, confidence in
            self?.alarmDispatcher.dispatch(keyword: keyword, confidence: confidence)
        }
        locationTracker.startAdaptiveTracking()
    }

    // BGProcessingTask für längere Background-Arbeit (iOS 13+)
    func scheduleBackgroundRefresh() {
        let request        = BGProcessingTaskRequest(identifier: "de.sec-si.monitoring")
        request.requiresNetworkConnectivity  = false
        request.requiresExternalPower        = false
        request.earliestBeginDate            = Date(timeIntervalSinceNow: 60)
        try? BGTaskScheduler.shared.submit(request)
    }
}