test fix + version choosing implemented

Author: waiafur

ai/.gitignore

@@ -1 +1,2 @@
-/build
+/build
+/src/androidTest/assets/bus.jpg

ai/build.gradle.kts

@@ -58,6 +58,34 @@ android {
         sourceCompatibility = JavaVersion.VERSION_11
         targetCompatibility = JavaVersion.VERSION_11
     }
+    val downloadTestImage by tasks.register<Exec>("downloadTestImage") {
+        val outputDir = layout.projectDirectory.dir("src/androidTest/assets")
+        val imageUrl = "https://github.com/ultralytics/yolov5/raw/master/data/images/bus.jpg"
+        val outputFile = outputDir.file("bus.jpg")
+
+        commandLine(
+            if (System.getProperty("os.name").lowercase().contains("windows")) {
+                listOf(
+                    "powershell",
+                    "-Command",
+                    "Invoke-WebRequest",
+                    "-Uri",
+                    imageUrl,
+                    "-OutFile",
+                    outputFile.asFile.absolutePath,
+                )
+            } else {
+                listOf("curl", "-L", "-o", outputFile.asFile.absolutePath, imageUrl)
+            },
+        )
+
+        outputs.file(outputFile)
+    }
+
+// Добавь зависимость, чтобы таск выполнялся перед тестами
+    tasks.matching { it.name == "preBuild" }.configureEach {
+        dependsOn(downloadTestImage)
+    }
 }
 
 val prepareYolo26Model =

ai/src/androidTest/assets/.gitkeep

@@ -87,4 +87,56 @@ class OpenVinoAiLayerInstrumentedTest {
             assertTrue(initialized)
             assertTrue(engine.isReady())
         }
+
+    private fun copyTestImage(context: android.content.Context): String {
+        val testImageFile = File(context.filesDir, "bus.jpg")
+        if (!testImageFile.exists()) {
+            context.assets.open("bus.jpg").use { input ->
+                testImageFile.outputStream().use { output ->
+                    input.copyTo(output)
+                }
+            }
+        }
+        return testImageFile.absolutePath
+    }
+
+    @Test
+    fun yolo26n_detectsBus_onTestImage() =
+        runBlocking {
+            val context = InstrumentationRegistry.getInstrumentation().targetContext
+            val modelPath = File(context.filesDir, "models/yolo26n_openvino_model/yolo26n.xml").absolutePath
+            val engine = createEngine(modelPath)
+
+            withContext(Dispatchers.Default) {
+                engine.initialize()
+            }
+            assertTrue("Engine should be ready", engine.isReady())
+
+            val imagePath = copyTestImage(context)
+            val result = engine.runYoloTagging(imagePath)
+
+            assertTrue("Should detect objects", result.isNotEmpty())
+            assertTrue("Should detect bus", result.contains("bus"))
+        }
+
+    @Test
+    fun yoloV10n_detectsBus_onTestImage() =
+        runBlocking {
+            val context = InstrumentationRegistry.getInstrumentation().targetContext
+            val modelPath = File(context.filesDir, "models/yolov10n_openvino_model/yolov10n.xml").absolutePath
+            val engine = createEngine(modelPath)
+
+            val initialized =
+                withContext(Dispatchers.Default) {
+                    engine.initialize()
+                }
+            assertTrue("Engine should initialize with yoloV10", initialized)
+            assertTrue("Engine should be ready", engine.isReady())
+
+            val imagePath = copyTestImage(context)
+            val result = engine.runYoloTagging(imagePath)
+
+            assertTrue("Should detect objects", result.isNotEmpty())
+            assertTrue("Should detect bus", result.contains("bus"))
+        }
 }

ai/src/androidTest/java/com/itlab/ai/OpenVinoAiLayerInstrumentedTest.kt

@@ -35,6 +35,31 @@ class OpenVinoEngine(
         private const val CONF_THRESHOLD = 0.35f
         private const val IOU_THRESHOLD = 0.45f
         private const val MAX_DETECTIONS = 300
+
+        fun getOptimalModelPath(context: Context): String {
+            // val forcedModel = System.getProperty("YOLO_MODEL_NUMBER")
+            val forcedModel = "10"
+            return when (forcedModel) {
+                "26" -> "models/yolo26n_openvino_model/yolo26n.xml"
+                "10" -> "models/yolov10n_openvino_model/yolov10n.xml"
+                else -> {
+                    val coreCount = Runtime.getRuntime().availableProcessors()
+                    val totalRam = getTotalRamMB(context)
+                    if (coreCount >= 4 && totalRam >= 2048) {
+                        "models/yolo26n_openvino_model/yolo26n.xml"
+                    } else {
+                        "models/yolov10n_openvino_model/yolov10n.xml"
+                    }
+                }
+            }
+        }
+
+        private fun getTotalRamMB(context1: Context): Long {
+            val activityManager = context1.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+            val memInfo = ActivityManager.MemoryInfo()
+            activityManager.getMemoryInfo(memInfo)
+            return memInfo.totalMem / (1024 * 1024)
+        }
     }
 
     private var core: Core? = null
@@ -123,25 +148,6 @@ class OpenVinoEngine(
         }
     }
 
-    @Suppress("UnusedPrivateMember")
-    private fun getOptimalModelPath(): String {
-        val coreCount = Runtime.getRuntime().availableProcessors()
-        val totalRam = getTotalRamMB()
-
-        return if (coreCount >= 4 && totalRam >= 2048) {
-            "models/yolo26n_openvino_model/yolo26n.xml"
-        } else {
-            "models/yolov10n_openvino_model/yolov10n.xml"
-        }
-    }
-
-    private fun getTotalRamMB(): Long {
-        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
-        val memInfo = ActivityManager.MemoryInfo()
-        activityManager.getMemoryInfo(memInfo)
-        return memInfo.totalMem / (1024 * 1024)
-    }
-
     private fun loadClassNames(): List<String> =
         try {
             val names = mutableListOf<String>()
@@ -349,17 +355,34 @@ class OpenVinoEngine(
     }
 
     private fun resolveModelXmlPath(): String? {
+        // Если путь задан явно и существует — сразу возвращаем
+        if (modelXmlPath.isNotBlank()) {
+            return if (File(modelXmlPath).exists()) {
+                modelXmlPath
+            } else {
+                // Пробуем скопировать из assets
+                val relativePath = modelXmlPath.substringAfter("files/")
+                val targetFile = File(context.filesDir, relativePath)
+                val assetDir = relativePath.substringBeforeLast("/")
+
+                if (copyAssetDirectory(assetDir, targetFile.parentFile ?: context.filesDir)) {
+                    targetFile.absolutePath
+                } else {
+                    Log.e(TAG, "Custom model not found and cannot be copied: $modelXmlPath")
+                    null
+                }
+            }
+        }
+
+        // Дефолт — yolo26n
         val modelDir = File(context.filesDir, DEFAULT_MODEL_ASSET_DIR)
         val modelXml = File(modelDir, DEFAULT_MODEL_XML)
 
-        return when {
-            modelXmlPath.isNotBlank() -> modelXmlPath
-            modelXml.exists() -> modelXml.absolutePath
-            copyAssetDirectory(DEFAULT_MODEL_ASSET_DIR, modelDir) -> modelXml.absolutePath
-            else -> {
-                Log.e(TAG, "Bundled model assets are missing: $DEFAULT_MODEL_ASSET_DIR")
-                null
-            }
+        return if (modelXml.exists() || copyAssetDirectory(DEFAULT_MODEL_ASSET_DIR, modelDir)) {
+            modelXml.absolutePath
+        } else {
+            Log.e(TAG, "Bundled model assets are missing: $DEFAULT_MODEL_ASSET_DIR")
+            null
         }
     }
 

ai/src/main/java/com/itlab/ai/OpenVinoEngine.kt

@@ -7,11 +7,15 @@ import com.itlab.domain.ai.NoteAiService
 import kotlinx.coroutines.runBlocking
 import org.koin.android.ext.koin.androidContext
 import org.koin.dsl.module
+import java.io.File
 
 val aiModule =
     module {
         single {
-            OpenVinoEngine(androidContext()).also { engine ->
+            val context = androidContext()
+            val optimalRelativePath = OpenVinoEngine.getOptimalModelPath(context)
+            val optimalAbsolutePath = File(context.filesDir, optimalRelativePath).absolutePath
+            OpenVinoEngine(context, optimalAbsolutePath).also { engine ->
                 runBlocking { engine.initialize() }
             }
         }