Add cache mechanism to sherpa tts

android/SherpaOnnxTtsEngine/app/src/main/java/com/k2fsa/sherpa/onnx/tts/engine/MainActivity.kt

@@ -32,6 +32,7 @@ import androidx.compose.material3.Slider
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -46,6 +47,8 @@ import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import java.io.File
+import kotlin.math.roundToInt
+import kotlinx.coroutines.delay
 import kotlin.time.TimeSource
 
 const val TAG = "sherpa-onnx-tts-engine"
@@ -76,6 +79,9 @@ class MainActivity : ComponentActivity() {
         Log.i(TAG, "Finish initializing AudioTrack")
 
         val preferenceHelper = PreferenceHelper(this)
+
+        TtsEngine.cacheSize = preferenceHelper.getCacheSizeInMB()
+
         setContent {
             SherpaOnnxTtsEngineTheme {
                 // A surface container using the 'background' color from the theme
@@ -88,6 +94,17 @@ class MainActivity : ComponentActivity() {
                     }) {
                         Box(modifier = Modifier.padding(it)) {
                             Column(modifier = Modifier.padding(16.dp)) {
+                                // Track used cache size in a mutable state
+                                var usedCacheSizeMB by remember { mutableStateOf(0) }
+
+                                // LaunchedEffect to periodically update the used cache size
+                                LaunchedEffect(Unit) {
+                                    while (true) {
+                                        usedCacheSizeMB = TtsEngine.tts?.getTotalUsedCacheSizeInMB() ?: 0
+                                        delay(5000) // Update every 5 seconds
+                                    }
+                                }
+
                                 Column {
                                     Text("Speed " + String.format("%.1f", TtsEngine.speed))
                                     Slider(
@@ -99,6 +116,20 @@ class MainActivity : ComponentActivity() {
                                         valueRange = 0.2F..3.0F,
                                         modifier = Modifier.fillMaxWidth()
                                     )
+
+                                    Text("Cache Size: ${TtsEngine.cacheSize}MB (${usedCacheSizeMB}MB used)")
+                                    Slider(
+                                        value = TtsEngine.cacheSizeState.value.toFloat(),
+                                        onValueChange = { newValue ->
+                                            // Round the value to the nearest multiple of 10
+                                            val roundedValue = (newValue / 5).roundToInt() * 5
+                                            TtsEngine.cacheSize = roundedValue
+                                            preferenceHelper.setCacheSizeInMB(roundedValue)
+                                            TtsEngine.tts?.setCacheSizeInMB(roundedValue)
+                                        },
+                                        valueRange = 0f..100f,
+                                        modifier = Modifier.fillMaxWidth()
+                                    )
                                 }
 
                                 val testTextContent = getSampleText(TtsEngine.lang ?: "")
@@ -263,6 +294,21 @@ class MainActivity : ComponentActivity() {
                                     Row {
                                         Text(rtfText)
                                     }
+
+                                    Button(
+                                        modifier = Modifier.padding(20.dp),
+                                        onClick = {
+                                            TtsEngine.tts?.clearCache() // Call the clearCache method
+                                            usedCacheSizeMB = 0 // Reset used cache size
+                                            Toast.makeText(
+                                                applicationContext,
+                                                "Cache cleared!",
+                                                Toast.LENGTH_SHORT
+                                            ).show()
+                                        }
+                                    ) {
+                                        Text("Clear")
+                                    }
                                 }
                             }
                         }
@@ -272,6 +318,13 @@ class MainActivity : ComponentActivity() {
         }
     }
 
+    override fun onResume() {
+        super.onResume()
+        // Update used cache size when the app is resumed
+        val usedCacheSizeMB = TtsEngine.tts?.getTotalUsedCacheSizeInMB() ?: 0
+        Log.i(TAG, "App resumed. Used cache size: ${usedCacheSizeMB}MB")
+    }
+
     override fun onDestroy() {
         stopMediaPlayer()
         super.onDestroy()

android/SherpaOnnxTtsEngine/app/src/main/java/com/k2fsa/sherpa/onnx/tts/engine/PreferencesHelper.kt

@@ -6,6 +6,7 @@ class PreferenceHelper(context: Context) {
     private val PREFS_NAME = "com.k2fsa.sherpa.onnx.tts.engine"
     private val SPEED_KEY = "speed"
     private val SID_KEY = "speaker_id"
+    private val CACHE_SIZE_KEY = "cache_size"
 
     private val sharedPreferences: SharedPreferences =
         context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
@@ -29,4 +30,14 @@ class PreferenceHelper(context: Context) {
     fun getSid(): Int {
         return sharedPreferences.getInt(SID_KEY, 0)
     }
-}
+
+    fun setCacheSizeInMB(value: Int) {
+        val editor = sharedPreferences.edit()
+        editor.putInt(CACHE_SIZE_KEY, value)
+        editor.apply()
+    }
+
+    fun getCacheSizeInMB(): Int {
+        return sharedPreferences.getInt(CACHE_SIZE_KEY, 20) // Default cache size is 20MB
+    }
+}

android/SherpaOnnxTtsEngine/app/src/main/java/com/k2fsa/sherpa/onnx/tts/engine/TtsEngine.kt

@@ -25,6 +25,7 @@ object TtsEngine {
 
 
     val speedState: MutableState<Float> = mutableFloatStateOf(1.0F)
+    val cacheSizeState: MutableState<Int> = mutableIntStateOf(0)
     val speakerIdState: MutableState<Int> = mutableIntStateOf(0)
 
     var speed: Float
@@ -33,6 +34,12 @@ object TtsEngine {
             speedState.value = value
         }
 
+    var cacheSize: Int
+        get() = cacheSizeState.value
+        set(value) {
+            cacheSizeState.value = value
+        }
+
     var speakerId: Int
         get() = speakerIdState.value
         set(value) {
@@ -190,8 +197,11 @@ object TtsEngine {
 
         speed = PreferenceHelper(context).getSpeed()
         speakerId = PreferenceHelper(context).getSid()
+        cacheSize = PreferenceHelper(context).getCacheSizeInMB()
 
         tts = OfflineTts(assetManager = assets, config = config)
+
+        tts?.setCacheSizeInMB(cacheSize)
     }
 
 

sherpa-onnx/csrc/CMakeLists.txt

@@ -155,6 +155,7 @@ if(SHERPA_ONNX_ENABLE_TTS)
     jieba-lexicon.cc
     lexicon.cc
     melo-tts-lexicon.cc
+    offline-tts-cache-mechanism.cc
     offline-tts-character-frontend.cc
     offline-tts-frontend.cc
     offline-tts-impl.cc