mmap21: Modell-Picker, Thinking-Indikator, LocalModel, ModelManager, versionCode=5

app/build.gradle.kts

@@ -10,8 +10,8 @@ android {
         applicationId = "de.ody"
         minSdk = 28
         targetSdk = 36
-        versionCode = 4
+        versionCode = 5
-        versionName = "0.4.0"
+        versionName = "0.5.0"
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
     signingConfigs {

app/src/main/java/de/ody/model/LocalModel.kt

@@ -0,0 +1,55 @@
+package de.ody.model
+
+import java.io.File
+
+/**
+ * Repräsentiert ein lokal verfügbares GGUF-Modell.
+ * Vorbereitet für ODY-DEVICE-PROFILER-0.1 (supportsNoThink, family, estimatedRamBytes).
+ */
+enum class ModelFamily { QWEN3, MINISTRAL, LFM, UNKNOWN }
+
+data class LocalModel(
+    val id: String,                      // z.B. "Qwen3-1.7B-Q4_K_M"
+    val displayName: String,             // z.B. "Qwen3 1.7B Q4_K_M"
+    val file: File,
+    val sizeBytes: Long,
+    val family: ModelFamily,
+    val supportsNoThink: Boolean,        // /no_think Token unterstützt (Qwen3)
+    val estimatedRamBytes: Long,         // Schätzung: Dateigröße * 1.2
+    val lastLoadSuccessful: Boolean = true,
+) {
+    val sizeMb: Int get() = (sizeBytes / 1024 / 1024).toInt()
+    val sizeDisplay: String get() = when {
+        sizeBytes >= 1_073_741_824L -> "%.1f GB".format(sizeBytes / 1_073_741_824.0)
+        else                        -> "%d MB".format(sizeMb)
+    }
+
+    companion object {
+        /** Erstellt ein LocalModel aus einer GGUF-Datei mit automatischer Metadaten-Erkennung */
+        fun fromFile(file: File): LocalModel {
+            val name = file.nameWithoutExtension
+            val family = when {
+                name.contains("qwen3", ignoreCase = true)     -> ModelFamily.QWEN3
+                name.contains("ministral", ignoreCase = true) -> ModelFamily.MINISTRAL
+                name.contains("lfm", ignoreCase = true)       -> ModelFamily.LFM
+                else                                           -> ModelFamily.UNKNOWN
+            }
+            val displayName = name
+                .replace("-", " ")
+                .replace("_", " ")
+                .split(" ")
+                .joinToString(" ") { it.replaceFirstChar { c -> c.uppercase() } }
+
+            return LocalModel(
+                id                  = name,
+                displayName         = displayName,
+                file                = file,
+                sizeBytes           = file.length(),
+                family              = family,
+                supportsNoThink     = family == ModelFamily.QWEN3,
+                estimatedRamBytes   = (file.length() * 1.2).toLong(),
+                lastLoadSuccessful  = true,
+            )
+        }
+    }
+}

app/src/main/java/de/ody/model/ModelManager.kt

@@ -0,0 +1,113 @@
+package de.ody.model
+
+import android.content.Context
+import android.util.Log
+import java.io.File
+import java.io.InputStream
+
+/**
+ * ModelManager — scannt ODYs eigenen models/-Ordner und verwaltet Modellwechsel.
+ * Import über Android Storage Access Framework (ACTION_OPEN_DOCUMENT) wird in
+ * MainActivity.kt gehandhabt; der URI-Stream wird hier per importFromStream() abgelegt.
+ */
+class ModelManager(private val context: Context) {
+
+    companion object {
+        private const val TAG = "ModelManager"
+        private val GGUF_MAGIC = byteArrayOf(0x47, 0x47, 0x55, 0x46) // "GGUF"
+        private const val MIN_SIZE_BYTES = 50L * 1024 * 1024 // 50 MB Mindestgröße
+    }
+
+    private fun modelsDir(): File {
+        val dir = File(context.filesDir, "models")
+        dir.mkdirs()
+        return dir
+    }
+
+    /** Scannt den models/-Ordner und gibt alle validen GGUF-Dateien zurück */
+    fun scanModels(): List<LocalModel> {
+        val dir = modelsDir()
+        val files = dir.listFiles() ?: return emptyList()
+        return files
+            .filter { it.isFile && it.extension.equals("gguf", ignoreCase = true) }
+            .filter { it.length() >= MIN_SIZE_BYTES }
+            .filter { isValidGguf(it) }
+            .sortedByDescending { it.length() }
+            .map { LocalModel.fromFile(it) }
+            .also { Log.i(TAG, "scanModels: ${it.size} Modelle gefunden in ${dir.absolutePath}") }
+    }
+
+    /** Prüft GGUF-Magic-Bytes */
+    private fun isValidGguf(file: File): Boolean {
+        return try {
+            val magic = file.inputStream().use { it.readNBytes(4) }
+            magic.contentEquals(GGUF_MAGIC)
+        } catch (e: Exception) {
+            Log.w(TAG, "isValidGguf: Fehler bei ${file.name}: ${e.message}")
+            false
+        }
+    }
+
+    /**
+     * Importiert ein Modell aus einem InputStream (z.B. von ACTION_OPEN_DOCUMENT URI).
+     * Schreibt in models/<fileName>.gguf.part, dann atomar umbenennen.
+     * Gibt die fertige File zurück oder null bei Fehler.
+     */
+    fun importFromStream(
+        inputStream: InputStream,
+        fileName: String,
+        onProgress: (Long, Long) -> Unit = { _, _ -> },
+    ): File? {
+        val safeName = fileName.replace(Regex("[^a-zA-Z0-9._\-]"), "_")
+            .let { if (it.endsWith(".gguf")) it else "$it.gguf" }
+        val partFile = File(modelsDir(), "$safeName.part")
+        val finalFile = File(modelsDir(), safeName)
+
+        if (finalFile.exists() && isValidGguf(finalFile)) {
+            Log.i(TAG, "importFromStream: $safeName bereits vorhanden")
+            return finalFile
+        }
+
+        return try {
+            val buffer = ByteArray(65_536)
+            var written = 0L
+            partFile.outputStream().use { out ->
+                var n: Int
+                while (inputStream.read(buffer).also { n = it } != -1) {
+                    out.write(buffer, 0, n)
+                    written += n
+                    onProgress(written, -1L)
+                }
+                out.flush()
+            }
+            if (!isValidGguf(partFile)) {
+                partFile.delete()
+                Log.e(TAG, "importFromStream: Ungültige GGUF-Datei nach Import")
+                null
+            } else {
+                partFile.renameTo(finalFile)
+                Log.i(TAG, "importFromStream: $safeName erfolgreich importiert (${written / 1024 / 1024} MB)")
+                finalFile
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "importFromStream: Fehler", e)
+            partFile.delete()
+            null
+        }
+    }
+
+    /** Löscht ein Modell aus dem models/-Ordner */
+    fun deleteModel(model: LocalModel): Boolean {
+        return try {
+            model.file.delete().also {
+                Log.i(TAG, "deleteModel: ${model.id} gelöscht=$it")
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "deleteModel: Fehler", e)
+            false
+        }
+    }
+
+    /** Gibt den models/-Pfad zurück (für ADB-Hinweise) */
+    fun getModelsDirPath(): String = modelsDir().absolutePath
+}