simplest kotlin code to make an android screen reader with compose jetpac that can user set default tts engine from installed tts engines inside it

dependencies {
    implementation "androidx.compose.ui:ui:1.0.0"
    implementation "androidx.compose.material:material:1.0.0"
    implementation "androidx.compose.ui:ui-tooling-preview:1.0.0"
    implementation "androidx.activity:activity-compose:1.3.1"
}

import android.app.Activity
import android.content.Context
import android.os.Bundle
import android.speech.tts.TextToSpeech
import android.speech.tts.TextToSpeech.EngineInfo
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import java.util.*

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            val viewModel: TTSViewModel = viewModel()
            TTSSelectionScreen(viewModel, this)
        }
    }
}

@Composable
fun TTSSelectionScreen(viewModel: TTSViewModel, activity: Activity) {
    val ttsEngines by remember { viewModel.ttsEngines }
    val selectedEngine by remember { viewModel.selectedEngine }

    LaunchedEffect(Unit) {
        viewModel.loadTTSEngines(activity)
    }

    Column(modifier = Modifier.padding(16.dp)) {
        Text("Select TTS Engine")
        Spacer(modifier = Modifier.height(8.dp))
        ttsEngines?.let { engines ->
            engines.forEach { engine ->
                Row(verticalAlignment = Alignment.CenterVertically) {
                    RadioButton(
                        selected = (selectedEngine == engine),
                        onClick = { viewModel.setDefaultEngine(activity, engine) }
                    )
                    Text(engine.label)
                }
                Spacer(modifier = Modifier.height(8.dp))
            }
        }
    }
}

class TTSViewModel : androidx.lifecycle.ViewModel() {
    var ttsEngines = mutableStateOf<List<EngineInfo>?>(null)
    var selectedEngine = mutableStateOf<EngineInfo?>(null)

    fun loadTTSEngines(context: Context) {
        val tts = TextToSpeech(context, null)
        ttsEngines.value = tts.engines
        selectedEngine.value = tts.defaultEngine?.let { engineName ->
            tts.engines.find { it.name == engineName }
        }
    }

    fun setDefaultEngine(context: Context, engine: EngineInfo) {
        val tts = TextToSpeech(context) {
            if (it == TextToSpeech.SUCCESS) {
                tts.defaultEngine = engine.name
                selectedEngine.value = engine
            }
        }
    }
}

@Preview(showBackground = true)
@Composable
fun DefaultPreview() {
    val viewModel: TTSViewModel = viewModel()
    TTSSelectionScreen(viewModel = viewModel, activity = MainActivity())
}

where is the code piece that gets text from android os and sends them to selected tts ?!

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

import android.os.Bundle
import android.speech.tts.TextToSpeech
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import java.util.*

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            val viewModel: TTSViewModel = viewModel()
            TTSSelectionScreen(viewModel, this)
        }
    }
}

@Composable
fun TTSSelectionScreen(viewModel: TTSViewModel, activity: MainActivity) {
    val ttsEngines by remember { viewModel.ttsEngines }
    val selectedEngine by remember { viewModel.selectedEngine }
    val textToRead = remember { mutableStateOf("") }

    LaunchedEffect(Unit) {
        viewModel.loadTTSEngines(activity)
    }

    Column(modifier = Modifier.padding(16.dp)) {
        Text("Select TTS Engine")
        Spacer(modifier = Modifier.height(8.dp))
        ttsEngines?.let { engines ->
            engines.forEach { engine ->
                Row(verticalAlignment = Alignment.CenterVertically) {
                    RadioButton(
                        selected = (selectedEngine == engine),
                        onClick = { viewModel.setDefaultEngine(activity, engine) }
                    )
                    Text(engine.label)
                }
                Spacer(modifier = Modifier.height(8.dp))
            }
        }
        Spacer(modifier = Modifier.height(16.dp))
        TextField(
            value = textToRead.value,
            onValueChange = { textToRead.value = it },
            label = { Text("Enter text to read") }
        )
        Spacer(modifier = Modifier.height(8.dp))
        Button(onClick = { viewModel.speakText(activity, textToRead.value) }) {
            Text("Read Text")
        }
    }
}

class TTSViewModel : androidx.lifecycle.ViewModel() {
    var ttsEngines = mutableStateOf<List<TextToSpeech.EngineInfo>?>(null)
    var selectedEngine = mutableStateOf<TextToSpeech.EngineInfo?>(null)
    private var tts: TextToSpeech? = null

    fun loadTTSEngines(context: Context) {
        tts = TextToSpeech(context, null)
        ttsEngines.value = tts?.engines
        selectedEngine.value = tts?.defaultEngine?.let { engineName ->
            tts?.engines?.find { it.name == engineName }
        }
    }

    fun setDefaultEngine(context: Context, engine: TextToSpeech.EngineInfo) {
        tts = TextToSpeech(context) {
            if (it == TextToSpeech.SUCCESS) {
                tts?.defaultEngine = engine.name
                selectedEngine.value = engine
            }
        }
    }

    fun speakText(context: Context, text: String) {
        tts?.speak(text, TextToSpeech.QUEUE_FLUSH, null, null)
    }
}

@Preview(showBackground = true)
@Composable
fun DefaultPreview() {
    val viewModel: TTSViewModel = viewModel()
    TTSSelectionScreen(viewModel = viewModel, activity = MainActivity())
}

     package com.example.app

     import android.accessibilityservice.AccessibilityService
     import android.view.accessibility.AccessibilityEvent

     class MyAccessibilityService : AccessibilityService() {
         override fun onAccessibilityEvent(event: AccessibilityEvent?) {
             // Handle accessibility events (e.g., text changes, button clicks)
         }

         override fun onInterrupt() {
             // Handle interruption
         }
     }
     

     <service
         android:name=".MyAccessibilityService"
         android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
         <intent-filter>
             <action android:name="android.accessibilityservice.AccessibilityService" />
         </intent-filter>
         <meta-data
             android:name="android.accessibilityservice"
             android:resource="@xml/accessibility_service_config" />
     </service>
     

     <accessibility-service
         xmlns:android="http://schemas.android.com/apk/res/android"
         android:accessibilityEventTypes="typeAllMask"
         android:accessibilityFeedbackType="feedbackSpoken"
         android:notificationTimeout="100" />
     

     import 'package:flutter/material.dart';
     import 'package:flutter/services.dart';

     class MyAccessibility {
       static const platform = MethodChannel('com.example.app/accessibility');

       Future<void> startService() async {
         try {
           await platform.invokeMethod('startAccessibilityService');
         } on PlatformException catch (e) {
           print("Failed to start service: ${e.message}");
         }
       }
     }

     void main() {
       runApp(MyApp());
     }

     class MyApp extends StatelessWidget {
       @override
       Widget build(BuildContext context) {
         return MaterialApp(
           home: Scaffold(
             appBar: AppBar(title: Text('Screen Reader')),
             body: Center(
               child: ElevatedButton(
                 onPressed: () => MyAccessibility().startService(),
                 child: Text('Start Screen Reader'),
               ),
             ),
           ),
         );
       }
     }
     

     import UIKit
     import Flutter

     @UIApplicationMain
     @objc class AppDelegate: FlutterAppDelegate {
         override func application(
             _ application: UIApplication,
             didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
         ) -> Bool {
             let controller = window?.rootViewController as! FlutterViewController
             let channel = FlutterMethodChannel(name: "com.example.app/accessibility", binaryMessenger: controller.binaryMessenger)
             channel.setMethodCallHandler { call, result in
                 if call.method == "startAccessibilityService" {
                     UIAccessibility.post(notification: .announcement, argument: "Screen reader started")
                     result(nil)
                 } else {
                     result(FlutterMethodNotImplemented)
                 }
             }
             GeneratedPluginRegistrant.register(with: self)
             return super.application(application, didFinishLaunchingWithOptions: launchOptions)
         }
     }
     

     #include <flutter/method_channel.h>
     #include <flutter/plugin_registrar_windows.h>
     #include <windows.h>
     #include <uiautomation.h>

     class ScreenReaderPlugin : public flutter::Plugin {
     public:
         static void RegisterWithRegistrar(flutter::PluginRegistrarWindows* registrar) {
             auto channel = std::make_unique<flutter::MethodChannel<>>(
                 registrar->messenger(), "com.example.app/accessibility",
                 &flutter::StandardMethodCodec::GetInstance());

             auto plugin = std::make_unique<ScreenReaderPlugin>();

             channel->SetMethodCallHandler(
                 [plugin_pointer = plugin.get()](const auto& call, auto result) {
                     plugin_pointer->HandleMethodCall(call, std::move(result));
                 });

             registrar->AddPlugin(std::move(plugin));
         }

         void HandleMethodCall(const flutter::MethodCall<>& call,
                               std::unique_ptr<flutter::MethodResult<>> result) {
             if (call.method_name() == "startAccessibilityService") {
                 // Implement UI Automation logic here
                 result->Success();
             } else {
                 result->NotImplemented();
             }
         }
     };

     void ScreenReaderPluginRegisterWithRegistrar(
         FlutterDesktopPluginRegistrarRef registrar) {
         ScreenReaderPlugin::RegisterWithRegistrar(
             flutter::PluginRegistrarManager::GetInstance()
                 ->GetRegistrar<flutter::PluginRegistrarWindows>(registrar));
     }
     

     import Cocoa
     import FlutterMacOS

     @main
     class AppDelegate: FlutterAppDelegate {
         override func applicationDidFinishLaunching(_ notification: Notification) {
             let controller = mainFlutterWindow?.contentViewController as! FlutterViewController
             let channel = FlutterMethodChannel(name: "com.example.app/accessibility", binaryMessenger: controller.engine.binaryMessenger)
             channel.setMethodCallHandler { call, result in
                 if call.method == "startAccessibilityService" {
                     // Implement macOS Accessibility API logic here
                     result(nil)
                 } else {
                     result(FlutterMethodNotImplemented)
                 }
             }
             super.applicationDidFinishLaunching(notification)
         }
     }
     

     #include <flutter_linux/flutter_linux.h>
     #include <atspi/atspi.h>

     void screen_reader_plugin_register_with_registrar(FlPluginRegistrar* registrar) {
         g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
             fl_plugin_registrar_get_messenger(registrar),
             "com.example.app/accessibility",
             FL_METHOD_CODEC(fl_standard_method_codec));

         fl_method_channel_set_method_call_handler(channel, method_call_cb, nullptr, nullptr);
     }

     static void method_call_cb(FlMethodChannel* channel, FlMethodCall* method_call, gpointer user_data) {
         if (strcmp(fl_method_call_get_name(method_call), "startAccessibilityService") == 0) {
             // Implement AT-SPI logic here
             fl_method_call_respond_success(method_call, nullptr, nullptr);
         } else {
             fl_method_call_respond_not_implemented(method_call, nullptr);
         }
     }