🎯 Critical: Wire database to ViewModel for persistent history

This is the FINAL MILE fix - history now survives app restarts.

## SharedViewModel
- Now takes HistoryRepository as constructor parameter
- processScanResult persists to SQLite database
- scanHistory is now an observable Flow from DB
- Added statistics method for dashboard display
- Added deleteScan for individual removal

## Android (Koin DI)
- Added DatabaseDriverFactory provider
- Added QRShieldDatabase singleton
- Added SqlDelightHistoryRepository binding
- ViewModel now receives repository via DI

## Desktop
- Initialized SQLite database directly
- ViewModel now has persistent storage cross-platform

## What this means for users
- Scan history persists after app restart
- History is stored locally (SQLite)
- Search and filter work on real data
- Ready for production use

Author: Raoof128

androidApp/src/main/kotlin/com/qrshield/android/di/AndroidModule.kt

@@ -1,6 +1,10 @@
 package com.qrshield.android.di
 
 import com.qrshield.core.PhishingEngine
+import com.qrshield.data.DatabaseDriverFactory
+import com.qrshield.data.HistoryRepository
+import com.qrshield.data.SqlDelightHistoryRepository
+import com.qrshield.db.QRShieldDatabase
 import com.qrshield.scanner.QrScanner
 import com.qrshield.scanner.QrScannerFactory
 import com.qrshield.ui.SharedViewModel
@@ -12,18 +16,46 @@ import org.koin.dsl.module
 
 /**
  * Koin dependency injection module for Android.
+ * 
+ * Provides all dependencies needed for the Android app including:
+ * - Database and repository
+ * - Scanner implementation
+ * - ViewModel with persistence
+ * 
+ * @author QR-SHIELD Security Team
+ * @since 1.0.0
  */
 val androidModule = module {
 
-    // Application scope
+    // Application scope for coroutines
     single { CoroutineScope(SupervisorJob() + Dispatchers.Main) }
 
     // Core engines
     single { PhishingEngine() }
 
-    // Scanner
+    // Database driver factory (Android-specific)
+    single { DatabaseDriverFactory(androidContext()) }
+    
+    // SQLDelight database
+    single { 
+        val driver = get<DatabaseDriverFactory>().createDriver()
+        QRShieldDatabase(driver)
+    }
+    
+    // History repository with persistence
+    single<HistoryRepository> { 
+        SqlDelightHistoryRepository(get()) 
+    }
+    
+    // Scanner (Android-specific using CameraX + ML Kit)
     single<QrScanner> { QrScannerFactory(androidContext()).create() }
 
-    // ViewModel
-    factory { SharedViewModel(get(), get()) }
+    // ViewModel with injected repository
+    factory { 
+        SharedViewModel(
+            phishingEngine = get(),
+            historyRepository = get(),
+            coroutineScope = get()
+        ) 
+    }
 }

common/src/commonMain/kotlin/com/qrshield/ui/SharedViewModel.kt

@@ -1,35 +1,57 @@
 package com.qrshield.ui
 
 import com.qrshield.core.PhishingEngine
+import com.qrshield.data.HistoryRepository
 import com.qrshield.model.RiskAssessment
 import com.qrshield.model.ScanHistoryItem
 import com.qrshield.model.ScanResult
 import com.qrshield.model.ScanSource
 import com.qrshield.model.Verdict
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.datetime.Clock
 
 /**
  * Shared ViewModel for QR-SHIELD UI
  * 
  * Manages UI state across all platforms using Kotlin Coroutines Flow.
+ * Now with persistent history storage via HistoryRepository.
+ * 
+ * @param phishingEngine Engine for analyzing URLs for phishing threats
+ * @param historyRepository Repository for persisting scan history
+ * @param coroutineScope Scope for launching coroutines
+ * 
+ * @author QR-SHIELD Security Team
+ * @since 1.0.0
  */
 class SharedViewModel(
     private val phishingEngine: PhishingEngine = PhishingEngine(),
+    private val historyRepository: HistoryRepository,
     private val coroutineScope: CoroutineScope
 ) {
     private val _uiState = MutableStateFlow<UiState>(UiState.Idle)
     val uiState: StateFlow<UiState> = _uiState.asStateFlow()
 
-    private val _scanHistory = MutableStateFlow<List<ScanHistoryItem>>(emptyList())
-    val scanHistory: StateFlow<List<ScanHistoryItem>> = _scanHistory.asStateFlow()
+    /**
+     * Scan history as an observable Flow from the database.
+     * Automatically updates when new scans are added.
+     */
+    val scanHistory: StateFlow<List<ScanHistoryItem>> = historyRepository
+        .observe()
+        .stateIn(
+            scope = coroutineScope,
+            started = SharingStarted.WhileSubscribed(5000),
+            initialValue = emptyList()
+        )
 
     /**
-     * Process a scan result from camera or gallery
+     * Process a scan result from camera or gallery.
+     * Analyzes the content and persists to database.
      */
     fun processScanResult(result: ScanResult, source: ScanSource) {
         coroutineScope.launch {
@@ -41,8 +63,8 @@ class SharedViewModel(
 
                     _uiState.value = UiState.Result(assessment)
 
-                    // Add to history
-                    addToHistory(result.content, assessment, source)
+                    // Persist to database
+                    saveToHistory(result.content, assessment, source)
                 }
                 is ScanResult.Error -> {
                     _uiState.value = UiState.Error(result.message)
@@ -55,7 +77,8 @@ class SharedViewModel(
     }
 
     /**
-     * Analyze a URL directly (e.g., from clipboard)
+     * Analyze a URL directly (e.g., from clipboard).
+     * Analyzes and persists to database.
      */
     fun analyzeUrl(url: String, source: ScanSource = ScanSource.CLIPBOARD) {
         coroutineScope.launch {
@@ -65,64 +88,94 @@ class SharedViewModel(
 
             _uiState.value = UiState.Result(assessment)
 
-            addToHistory(url, assessment, source)
+            // Persist to database
+            saveToHistory(url, assessment, source)
         }
     }
 
     /**
-     * Start scanning mode
+     * Start scanning mode.
      */
     fun startScanning() {
         _uiState.value = UiState.Scanning
     }
 
     /**
-     * Return to idle state
+     * Return to idle state.
      */
     fun resetToIdle() {
         _uiState.value = UiState.Idle
     }
 
     /**
-     * Clear scan history
+     * Clear scan history from database.
      */
     fun clearHistory() {
-        _scanHistory.value = emptyList()
+        coroutineScope.launch {
+            historyRepository.clearAll()
+        }
+    }
+    
+    /**
+     * Delete a specific scan from history.
+     */
+    fun deleteScan(id: String) {
+        coroutineScope.launch {
+            historyRepository.delete(id)
+        }
     }
 
     /**
-     * Get scan by ID from history
+     * Get scan by ID from history.
      */
-    fun getScanById(id: String): ScanHistoryItem? {
-        return _scanHistory.value.find { it.id == id }
+    suspend fun getScanById(id: String): ScanHistoryItem? {
+        return historyRepository.getById(id)
     }
 
-    private fun addToHistory(
+    /**
+     * Get history statistics (for dashboard display).
+     */
+    suspend fun getStatistics(): HistoryStatistics {
+        val all = historyRepository.getAll()
+        
+        return HistoryStatistics(
+            totalScans = all.size,
+            safeCount = all.count { it.verdict == Verdict.SAFE },
+            suspiciousCount = all.count { it.verdict == Verdict.SUSPICIOUS },
+            maliciousCount = all.count { it.verdict == Verdict.MALICIOUS },
+            averageScore = if (all.isEmpty()) 0.0 else all.map { it.score }.average()
+        )
+    }
+    
+    /**
+     * Save scan result to persistent database.
+     */
+    private suspend fun saveToHistory(
         url: String,
         assessment: RiskAssessment,
         source: ScanSource
     ) {
         val item = ScanHistoryItem(
             id = generateId(),
-            url = url,
-            score = assessment.score,
+            url = url.take(2048), // Bound URL length for security
+            score = assessment.score.coerceIn(0, 100),
             verdict = assessment.verdict,
             scannedAt = currentTimeMillis(),
             source = source
         )
-        _scanHistory.value = listOf(item) + _scanHistory.value.take(99)
+        
+        historyRepository.insert(item)
     }
 
     private fun generateId(): String {
         return "scan_${currentTimeMillis()}_${(0..9999).random()}"
     }
 
-    // Expect function to be implemented per platform
     private fun currentTimeMillis(): Long = Clock.System.now().toEpochMilliseconds()
 }
 
 /**
- * UI State sealed class
+ * UI State sealed class for managing screen states.
  */
 sealed class UiState {
     data object Idle : UiState()
@@ -131,3 +184,20 @@ sealed class UiState {
     data class Result(val assessment: RiskAssessment) : UiState()
     data class Error(val message: String) : UiState()
 }
+
+/**
+ * History statistics for dashboard display.
+ */
+data class HistoryStatistics(
+    val totalScans: Int,
+    val safeCount: Int,
+    val suspiciousCount: Int,
+    val maliciousCount: Int,
+    val averageScore: Double
+) {
+    val safePercentage: Double
+        get() = if (totalScans > 0) safeCount.toDouble() / totalScans * 100 else 0.0
+    
+    val threatPercentage: Double
+        get() = if (totalScans > 0) (suspiciousCount + maliciousCount).toDouble() / totalScans * 100 else 0.0
+}

desktopApp/src/main/kotlin/com/qrshield/desktop/Main.kt

@@ -13,6 +13,9 @@ import androidx.compose.ui.window.Window
 import androidx.compose.ui.window.application
 import androidx.compose.ui.window.rememberWindowState
 import com.qrshield.core.PhishingEngine
+import com.qrshield.data.DatabaseDriverFactory
+import com.qrshield.data.SqlDelightHistoryRepository
+import com.qrshield.db.QRShieldDatabase
 import com.qrshield.model.Verdict
 import com.qrshield.ui.SharedViewModel
 import kotlinx.coroutines.CoroutineScope
@@ -27,6 +30,7 @@ import java.util.Properties
  * Features:
  * - Window size/position persistence
  * - Cross-platform preferences storage
+ * - Persistent scan history via SQLDelight
  */
 fun main() = application {
     // Load saved window preferences
@@ -130,7 +134,24 @@ object WindowPreferences {
 @Preview
 fun QRShieldDesktopApp() {
     val coroutineScope = remember { CoroutineScope(SupervisorJob() + Dispatchers.Main) }
-    val viewModel = remember { SharedViewModel(PhishingEngine(), coroutineScope) }
+    
+    // Initialize database and repository
+    val historyRepository = remember {
+        val driverFactory = DatabaseDriverFactory()
+        val driver = driverFactory.createDriver()
+        val database = QRShieldDatabase(driver)
+        SqlDelightHistoryRepository(database)
+    }
+    
+    // ViewModel with persistence
+    val viewModel = remember { 
+        SharedViewModel(
+            phishingEngine = PhishingEngine(),
+            historyRepository = historyRepository,
+            coroutineScope = coroutineScope
+        ) 
+    }
+    
     var urlInput by remember { mutableStateOf("") }
     var analysisResult by remember { mutableStateOf<AnalysisResult?>(null) }