// not working !!
val fd = ParcelFileDescriptor.open(context.getExternalFilesDir(null)!!.resolve("pcm").apply { println(path) }, ParcelFileDescriptor.MODE_READ_ONLY)
val intent = Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
    putExtra(RecognizerIntent.EXTRA_LANGUAGE, "ja-JP")
    putExtra(RecognizerIntent.EXTRA_LANGUAGE_PREFERENCE, "ja-JP")
    putExtra(RecognizerIntent.EXTRA_AUDIO_SOURCE, fd)
    putExtra(RecognizerIntent.EXTRA_AUDIO_SOURCE_ENCODING, AudioFormat.ENCODING_PCM_16BIT)
    putExtra(RecognizerIntent.EXTRA_AUDIO_SOURCE_CHANNEL_COUNT, 2)
    putExtra(RecognizerIntent.EXTRA_AUDIO_SOURCE_SAMPLING_RATE, 44100)
}
val recognizer = SpeechRecognizer.createSpeechRecognizer(context)
recognizer?.setRecognitionListener(object : RecognitionListener {
    override fun onReadyForSpeech(params: Bundle?) {
        println("onReadyForSpeech")
    }
 
    override fun onBeginningOfSpeech() {
        println("onBeginningOfSpeech")
    }
 
    override fun onRmsChanged(rmsdB: Float) {
        println("onRmsChanged")
    }
 
    override fun onBufferReceived(buffer: ByteArray?) {
        println("onBufferReceived")
    }
 
    override fun onEndOfSpeech() {
        println("onEndOfSpeech")
    }
 
    override fun onError(error: Int) {
        println("onError $error")
    }
 
    override fun onResults(results: Bundle?) {
        println("onResults $results")
    }
 
    override fun onPartialResults(partialResults: Bundle?) {
        println("onPartialResults $partialResults")
    }
 
    override fun onEvent(eventType: Int, params: Bundle?) {
        println("onEvent $eventType $params")
    }
})
recognizer.startListening(intent)

implementation("net.java.dev.jna:jna:5.15.0@aar")
implementation("com.alphacephei:vosk-android:0.3.47@aar")

dependencies {
 
    // Vosk
    implementation("net.java.dev.jna:jna:5.15.0@aar")
    implementation("com.alphacephei:vosk-android:0.3.47@aar")
    implementation("androidx.lifecycle:lifecycle-service:2.8.7")
 
    // 以下省略

<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            HiroidTheme {
                MainScreen()
            }
        }
    }
}
 
@Composable
private fun MainScreen() {
    val context = LocalContext.current
 
    // 権限
    val permissionRequest = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.RequestPermission(),
        onResult = { isGranted ->
            if (isGranted) {
                Toast.makeText(context, "権限が付与されました", Toast.LENGTH_SHORT).show()
            }
        }
    )
 
    // 権限を要求
    LaunchedEffect(key1 = Unit) {
        permissionRequest.launch(android.Manifest.permission.RECORD_AUDIO)
    }
 
    Scaffold { innerPadding ->
        Column(modifier = Modifier.padding(innerPadding)) {
            Button(onClick = {
                // todo このあとすぐ
            }) { Text("開始") }
            Button(onClick = {
                // todo このあとすぐ
            }) { Text("終了") }
        }
    }
}

<service
    android:name=".VoskCaptionService"
    android:enabled="true"
    android:exported="true"
    android:foregroundServiceType="mediaProjection"></service>

class VoskCaptionService : LifecycleService() {
 
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        super.onStartCommand(intent, flags, startId)
        // todo この後すぐ！！！
        return START_NOT_STICKY
    }
 
    companion object {
 
        // Intent に MediaProjection の結果を入れるのでそのキー
        private const val INTENT_KEY_MEDIA_PROJECTION_RESULT_CODE = "result_code"
        private const val INTENT_KEY_MEDIA_PROJECTION_RESULT_DATA = "result_data"
 
        /** フォアグラウンドサービスを開始する */
        fun startService(context: Context, resultCode: Int, data: Intent) {
            val intent = Intent(context, VoskCaptionService::class.java).apply {
                // サービスで MediaProjection を開始するのに必要
                putExtra(INTENT_KEY_MEDIA_PROJECTION_RESULT_CODE, resultCode)
                putExtra(INTENT_KEY_MEDIA_PROJECTION_RESULT_DATA, data)
            }
            ContextCompat.startForegroundService(context, intent)
        }
 
        /** フォアグラウンドサービスを終了する */
        fun stopService(context: Context) {
            val intent = Intent(context, VoskCaptionService::class.java)
            context.stopService(intent)
        }
    }
}

// MediaProjection
val mediaProjectionManager = remember { context.getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager }
val mediaProjectionRequest = rememberLauncherForActivityResult(
    contract = ActivityResultContracts.StartActivityForResult(),
    onResult = {
        VoskCaptionService.startService(
            context = context,
            resultCode = it.resultCode,
            data = it.data ?: return@rememberLauncherForActivityResult
        )
    }
)
 
Scaffold { innerPadding ->
    Column(modifier = Modifier.padding(innerPadding)) {
        Button(onClick = {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
                mediaProjectionRequest.launch(mediaProjectionManager.createScreenCaptureIntent(MediaProjectionConfig.createConfigForDefaultDisplay()))
            } else {
                mediaProjectionRequest.launch(mediaProjectionManager.createScreenCaptureIntent())
            }
        }) { Text("開始") }
        Button(onClick = {
            VoskCaptionService.stopService(context)
        }) { Text("終了") }
    }
}

/** Vosk を使って文字起こしをする */
class VoskAndroid(private val modelPath: String) {
 
    private var model: Model? = null
    private var recognizer: Recognizer? = null
 
    /** モデルを読み込む */
    suspend fun prepare() {
        withContext(Dispatchers.IO) {
            model = Model(modelPath)
            recognizer = Recognizer(model, SAMPLING_RATE.toFloat())
        }
    }
 
    /** 喋り声の音声（PCM）を入力し、文字起こし結果を取得する */
    suspend fun recognizeFromSpeechPcm(pcmByteArray: ByteArray): VoskResult? {
        val recognizer = recognizer ?: return null
 
        // 文字起こしする
        val isFullyText = withContext(Dispatchers.Default) {
            recognizer.acceptWaveForm(pcmByteArray, pcmByteArray.size)
        }
 
        // JSON なのでパースする
        val voskResult = if (isFullyText) {
            val jsonObject = JSONObject(recognizer.result)
            VoskResult.Result(text = jsonObject.getString("text"))
        } else {
            val jsonObject = JSONObject(recognizer.partialResult)
            VoskResult.Partial(partial = jsonObject.getString("partial"))
        }
 
        // 空文字なら return
        return if (voskResult.isBlank) {
            null
        } else {
            voskResult
        }
    }
 
    /** 破棄する */
    fun destroy() {
        model?.close()
        recognizer?.close()
    }
 
    /** [recognizeFromSpeechPcm]の返り値 */
    sealed interface VoskResult {
        val isBlank: Boolean
            get() = when (this) {
                is Partial -> partial.isBlank()
                is Result -> text.isBlank()
            }
 
        /** 確定した文章 */
        @JvmInline
        value class Result(val text: String) : VoskResult
 
        /** 部分的に確定した文章 */
        @JvmInline
        value class Partial(val partial: String) : VoskResult
    }
 
    companion object {
        /** Vosk で受け付けるサンプリングレート */
        const val SAMPLING_RATE = 16000
    }
}

/** 端末内の音声を MediaProjection を使って録音する */
object InternalAudioTool {
 
    /** 端末内の音声を録音する */
    @SuppressLint("MissingPermission")
    fun recordInternalAudio(
        context: Context,
        resultCode: Int,
        resultData: Intent
    ) = callbackFlow {
        val mediaProjectionManager = context.getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
        val bufferSize = AudioRecord.getMinBufferSize(
            VoskAndroid.SAMPLING_RATE,
            AudioFormat.CHANNEL_IN_MONO,
            AudioFormat.ENCODING_PCM_16BIT
        )
 
        // MediaProjection
        val mediaProjection = mediaProjectionManager.getMediaProjection(resultCode, resultData).apply {
            // 画面録画中のコールバック
            registerCallback(object : MediaProjection.Callback() {
                // MediaProjection 終了時
                override fun onStop() {
                    super.onStop()
                    cancel()
                }
            }, null)
        }
        // 内部音声取るのに使う
        val playbackConfig = AudioPlaybackCaptureConfiguration.Builder(mediaProjection).apply {
            addMatchingUsage(AudioAttributes.USAGE_MEDIA)
            addMatchingUsage(AudioAttributes.USAGE_GAME)
            addMatchingUsage(AudioAttributes.USAGE_UNKNOWN)
        }.build()
        val audioFormat = AudioFormat.Builder().apply {
            setEncoding(AudioFormat.ENCODING_PCM_16BIT)
            setSampleRate(VoskAndroid.SAMPLING_RATE)
            setChannelMask(AudioFormat.CHANNEL_IN_MONO)
        }.build()
        val audioRecord = AudioRecord.Builder().apply {
            setAudioPlaybackCaptureConfig(playbackConfig)
            setAudioFormat(audioFormat)
            setBufferSizeInBytes(bufferSize)
        }.build()
 
        // 開始
        try {
            audioRecord.startRecording()
            while (true) {
                yield()
                val pcmAudio = ByteArray(bufferSize)
                audioRecord.read(pcmAudio, 0, pcmAudio.size)
                trySend(pcmAudio)
            }
        } finally {
            audioRecord.stop()
            audioRecord.release()
            mediaProjection.stop()
        }
    }
}

class VoskCaptionService : LifecycleService() {
 
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        super.onStartCommand(intent, flags, startId)
 
        // フォアグラウンドサービス通知を出す
        val notificationManager = NotificationManagerCompat.from(this)
        if (notificationManager.getNotificationChannel(CHANNEL_ID) == null) {
            val channel = NotificationChannelCompat.Builder(CHANNEL_ID, NotificationManagerCompat.IMPORTANCE_LOW).apply {
                setName("文字起こしサービス実行中")
            }.build()
            notificationManager.createNotificationChannel(channel)
        }
        val notification = NotificationCompat.Builder(this, CHANNEL_ID).apply {
            setContentTitle("文字起こしサービス")
            setContentText("端末内の音声を収集して、文字起こしをしています。")
            setSmallIcon(R.drawable.ic_launcher_foreground)
        }.build()
        ServiceCompat.startForeground(this, NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION)
 
        if (intent != null) {
            lifecycleScope.launch {
                // モデルを指定して Vosk
                val modelPath = getExternalFilesDir(null)!!.resolve("vosk-model-small-ja-0.22")
                val voskAndroid = VoskAndroid(modelPath.path).apply { prepare() }
 
                try {
                    withContext(Dispatchers.Default) {
                        InternalAudioTool
                            .recordInternalAudio(
                                context = this@VoskCaptionService,
                                resultCode = intent.getIntExtra(INTENT_KEY_MEDIA_PROJECTION_RESULT_CODE, -1),
                                resultData = IntentCompat.getParcelableExtra(intent, INTENT_KEY_MEDIA_PROJECTION_RESULT_DATA, Intent::class.java)!!
                            )
                            .conflate()
                            .collect { pcm ->
                                val result = voskAndroid.recognizeFromSpeechPcm(pcm) ?: return@collect
                                println(result)
                            }
                    }
                } finally {
                    // recordInternalAudio が MediaProjection 終了でキャンセル例外を投げる
                    voskAndroid.destroy()
                    stopSelf()
                }
            }
        }
        return START_NOT_STICKY
    }
 
    companion object {
 
        // 通知周り
        private const val NOTIFICATION_ID = 1234
        private const val CHANNEL_ID = "hiroid_running_service"
 
        // Intent に MediaProjection の結果を入れるのでそのキー
        private const val INTENT_KEY_MEDIA_PROJECTION_RESULT_CODE = "result_code"
        private const val INTENT_KEY_MEDIA_PROJECTION_RESULT_DATA = "result_data"
 
        /** フォアグラウンドサービスを開始する */
        fun startService(context: Context, resultCode: Int, data: Intent) {
            val intent = Intent(context, VoskCaptionService::class.java).apply {
                // サービスで MediaProjection を開始するのに必要
                putExtra(INTENT_KEY_MEDIA_PROJECTION_RESULT_CODE, resultCode)
                putExtra(INTENT_KEY_MEDIA_PROJECTION_RESULT_DATA, data)
            }
            ContextCompat.startForegroundService(context, intent)
        }
 
        /** フォアグラウンドサービスを終了する */
        fun stopService(context: Context) {
            val intent = Intent(context, VoskCaptionService::class.java)
            context.stopService(intent)
        }
    }
}

Partial(partial=まー の 清掃 だ から ねぇ なんか カン 並ぶ に 休日 入る か も しん ない です 平日 だっ て です か いい なぁ と て 舐め て た ん です けど ねぇ)
Partial(partial=まー の 清掃 だ から ねぇ なんか カン 並ぶ に 休日 入る か も しん ない です 平日 だっ て です か いい なぁ と て 舐め て た ん です けど ねぇ)
Result(text=まー の 清掃 だ から ねぇ なんか まー 間 並ぶ に 休日 入る か も しん ない です 平日 だっ て です か いい なぁ と て 舐め て た ん です けど ねぇ)
Partial(partial=動い)
Partial(partial=動い)
Partial(partial=後 いい ん)

<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />

Button(onClick = {
    context.startActivity(Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION))
}) { Text("オーバーレイ権限の設定画面") }

class VoskCaptionService : LifecycleService(), SavedStateRegistryOwner {
 
    private val savedStateRegistryController = SavedStateRegistryController.create(this)
    override val savedStateRegistry: SavedStateRegistry
        get() = savedStateRegistryController.savedStateRegistry
 
    private val windowManager by lazy { getSystemService(Context.WINDOW_SERVICE) as WindowManager }
    private val composeView by lazy {
        ComposeView(this).apply {
            setContent {
                Text(text = "ForegroundService + WindowManager + Compose")
            }
        }
    }
 
    private val params = WindowManager.LayoutParams(
        WindowManager.LayoutParams.WRAP_CONTENT,
        WindowManager.LayoutParams.WRAP_CONTENT,
        WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY,
        WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
        PixelFormat.TRANSLUCENT
    )
 
    override fun onCreate() {
        super.onCreate()
        composeView.setViewTreeLifecycleOwner(this)
        composeView.setViewTreeSavedStateRegistryOwner(this)
        savedStateRegistryController.performRestore(null)
        windowManager.addView(composeView, params)
    }
 
    override fun onDestroy() {
        super.onDestroy()
        windowManager.removeView(composeView)
    }
 
    // 以下省略...
}

private val voskResultCaptionState = mutableStateOf(emptyList<VoskAndroid.VoskResult>())
private val composeView by lazy {
    ComposeView(this).apply {
        setContent {
            HiroidTheme {
                LazyColumn(
                    modifier = Modifier
                        .background(MaterialTheme.colorScheme.primaryContainer)
                        .size(300.dp)
                ) {
                    // 表示する
                    items(voskResultCaptionState.value) { result ->
                        Text(
                            text = when (result) {
                                is VoskAndroid.VoskResult.Partial -> result.partial
                                is VoskAndroid.VoskResult.Result -> result.text
                            },
                            color = when (result) {
                                is VoskAndroid.VoskResult.Partial -> MaterialTheme.colorScheme.error
                                is VoskAndroid.VoskResult.Result -> MaterialTheme.colorScheme.primary
                            }
                        )
                        HorizontalDivider()
                    }
                }
            }
        }
    }
}

InternalAudioTool
    .recordInternalAudio(
        context = this@VoskCaptionService,
        resultCode = intent.getIntExtra(INTENT_KEY_MEDIA_PROJECTION_RESULT_CODE, -1),
        resultData = IntentCompat.getParcelableExtra(intent, INTENT_KEY_MEDIA_PROJECTION_RESULT_DATA, Intent::class.java)!!
    )
    .conflate()
    .collect { pcm ->
        // 文字起こし
        val result = voskAndroid.recognizeFromSpeechPcm(pcm) ?: return@collect
        // 配列に足す
        // Partial は配列に一個あれば良い
        voskResultCaptionState.value = listOf(result) + voskResultCaptionState.value.filterIsInstance<VoskAndroid.VoskResult.Result>()
    }

modifier = Modifier
    .background(MaterialTheme.colorScheme.primaryContainer)
    .size(300.dp)
    .pointerInput(key1 = Unit) {
        detectDragGestures { change, dragAmount ->
            change.consume()
            params.x += dragAmount.x.toInt()
            params.y += dragAmount.y.toInt()
            windowManager.updateViewLayout(this@apply, params)
        }
    }