neoagent 2.3.1-beta.50 → 2.3.1-beta.52

package/flutter_app/android/app/build.gradle.kts

@@ -98,6 +98,8 @@ android {
 
 dependencies {
     implementation("androidx.activity:activity-ktx:1.10.1")
+    implementation("androidx.car.app:app:1.7.0")
+    implementation("androidx.car.app:app-projected:1.7.0")
     implementation("androidx.health.connect:connect-client:1.1.0")
     implementation("androidx.security:security-crypto:1.1.0")
     implementation("androidx.work:work-runtime-ktx:2.10.1")

package/flutter_app/android/app/src/main/AndroidManifest.xml

@@ -1,6 +1,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.MANAGE_OWN_CALLS" />
     <uses-permission android:name="android.permission.CAMERA" />
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
@@ -31,6 +32,9 @@
         android:name="${applicationName}"
         android:icon="@mipmap/ic_launcher"
         android:usesCleartextTraffic="true">
+        <meta-data
+            android:name="com.google.android.gms.car.application"
+            android:resource="@xml/automotive_app_desc" />
         <activity
             android:name=".MainActivity"
             android:exported="true"
@@ -95,6 +99,26 @@
             android:name="androidx.work.impl.foreground.SystemForegroundService"
             android:foregroundServiceType="dataSync"
             tools:node="merge" />
+        <service
+            android:name=".telecom.NeoAgentConnectionService"
+            android:exported="true"
+            android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE">
+            <intent-filter>
+                <action android:name="android.telecom.ConnectionService" />
+            </intent-filter>
+        </service>
+        
+        <service
+            android:name=".auto.NeoAgentCarAppService"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="androidx.car.app.CarAppService" />
+                <category android:name="androidx.car.app.category.IOT" />
+            </intent-filter>
+            <meta-data
+                android:name="androidx.car.app.minCarApiLevel"
+                android:value="1" />
+        </service>
         <service
             android:name=".recording.RecordingForegroundService"
             android:exported="false"

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/MainActivity.kt

@@ -26,6 +26,14 @@ import com.neoagent.flutter_app.widgets.WidgetSyncScheduler
 import io.flutter.embedding.android.FlutterFragmentActivity
 import io.flutter.embedding.engine.FlutterEngine
 import io.flutter.plugin.common.EventChannel
+import android.telecom.PhoneAccount
+import android.telecom.PhoneAccountHandle
+import android.telecom.TelecomManager
+import android.content.ComponentName
+import android.os.Bundle
+import android.telecom.DisconnectCause
+import android.content.Context
+import com.neoagent.flutter_app.telecom.NeoAgentConnectionService
 import io.flutter.plugin.common.MethodChannel
 import io.flutter.plugins.GeneratedPluginRegistrant
 import kotlinx.coroutines.launch
@@ -50,11 +58,22 @@ class MainActivity : FlutterFragmentActivity() {
 
     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
         super.configureFlutterEngine(flutterEngine)
+        io.flutter.embedding.engine.FlutterEngineCache.getInstance().put("main_engine", flutterEngine)
         GeneratedPluginRegistrant.registerWith(flutterEngine)
 
         healthGateway = HealthConnectGateway(this)
         healthSyncScheduler = HealthSyncScheduler(this)
         widgetSyncScheduler = WidgetSyncScheduler(this)
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val telecomManager = getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+            val componentName = ComponentName(this, NeoAgentConnectionService::class.java)
+            val phoneAccountHandle = PhoneAccountHandle(componentName, "NeoAgentVoiceId")
+            val phoneAccount = PhoneAccount.builder(phoneAccountHandle, "NeoAgent Voice Assistant")
+                .setCapabilities(PhoneAccount.CAPABILITY_SELF_MANAGED)
+                .build()
+            telecomManager.registerPhoneAccount(phoneAccount)
+        }
         recordingStateStore = RecordingStateStore(this)
         permissionLauncher = registerForActivityResult(
             PermissionController.createRequestPermissionResultContract(),
@@ -91,6 +110,44 @@ class MainActivity : FlutterFragmentActivity() {
                 )
             }
         }
+        MethodChannel(
+            flutterEngine.dartExecutor.binaryMessenger,
+            "neoagent/telecom",
+        ).setMethodCallHandler { call, result ->
+            when (call.method) {
+                "startCallRouting" -> {
+                    try {
+                        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+                            result.error("UNSUPPORTED", "Self-managed calls require Android O or newer", null)
+                            return@setMethodCallHandler
+                        }
+                        val telecomManager = getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+                        val componentName = ComponentName(this, NeoAgentConnectionService::class.java)
+                        val phoneAccountHandle = PhoneAccountHandle(componentName, "NeoAgentVoiceId")
+                        val extras = Bundle().apply {
+                            putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle)
+                            putInt(TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE, android.telecom.VideoProfile.STATE_AUDIO_ONLY)
+                            putBoolean("is_flutter_initiated", true)
+                        }
+                        telecomManager.placeCall(Uri.parse("tel:NeoAgent"), extras)
+                        result.success(true)
+                    } catch (e: SecurityException) {
+                        result.error("PERMISSION_DENIED", "Missing Manage Own Calls permission", null)
+                    } catch (e: Exception) {
+                        result.error("ERROR", e.message, null)
+                    }
+                }
+                "stopCallRouting" -> {
+                    NeoAgentConnectionService.getAndClearCurrentConnection()?.let {
+                        it.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+                        it.destroy()
+                    }
+                    result.success(true)
+                }
+                else -> result.notImplemented()
+            }
+        }
+
         MethodChannel(
             flutterEngine.dartExecutor.binaryMessenger,
             "neoagent/health",

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/auto/NeoAgentCarAppService.kt

@@ -0,0 +1,114 @@
+package com.neoagent.flutter_app.auto
+
+import android.content.Intent
+import android.content.Context
+import android.net.Uri
+import android.os.Bundle
+import android.telecom.PhoneAccount
+import android.telecom.PhoneAccountHandle
+import android.telecom.TelecomManager
+import android.content.ComponentName
+import android.content.pm.ApplicationInfo
+import androidx.car.app.CarAppService
+import androidx.car.app.CarContext
+import androidx.car.app.CarToast
+import androidx.car.app.Screen
+import androidx.car.app.Session
+import androidx.car.app.model.Action
+import androidx.car.app.model.CarIcon
+import androidx.car.app.model.GridItem
+import androidx.car.app.model.GridTemplate
+import androidx.car.app.model.ItemList
+import androidx.car.app.model.Template
+import androidx.car.app.validation.HostValidator
+import androidx.core.graphics.drawable.IconCompat
+import com.neoagent.flutter_app.MainActivity
+import com.neoagent.flutter_app.R
+import com.neoagent.flutter_app.widgets.VoiceLaunchWidgetProvider
+import com.neoagent.flutter_app.telecom.NeoAgentConnectionService
+
+class NeoAgentCarAppService : CarAppService() {
+    override fun onCreateSession(): Session = NeoAgentCarSession()
+
+    override fun createHostValidator(): HostValidator {
+        val debuggable =
+            (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0
+        return if (debuggable) {
+            HostValidator.ALLOW_ALL_HOSTS_VALIDATOR
+        } else {
+            HostValidator.Builder(this)
+                .addAllowedHosts(R.array.hosts_allowlist)
+                .build()
+        }
+    }
+}
+
+private class NeoAgentCarSession : Session() {
+    override fun onCreateScreen(intent: Intent): Screen {
+        return NeoAgentCarHomeScreen(carContext)
+    }
+}
+
+private class NeoAgentCarHomeScreen(carContext: CarContext) : Screen(carContext) {
+    override fun onGetTemplate(): Template {
+        val voiceItem = GridItem.Builder()
+            .setTitle("Voice mode")
+            .setText("Tap to talk")
+            .setImage(
+                CarIcon.Builder(
+                    IconCompat.createWithResource(carContext, R.mipmap.ic_launcher),
+                ).build(),
+                GridItem.IMAGE_TYPE_ICON,
+            )
+            .setOnClickListener { launchVoiceAssistant() }
+            .build()
+
+        val grid = ItemList.Builder().addItem(voiceItem).build()
+        val template = GridTemplate.Builder()
+            .setTitle("NeoAgent")
+            .setHeaderAction(Action.APP_ICON)
+            .setSingleList(grid)
+
+        if (carContext.carAppApiLevel >= 8) {
+            template.setItemSize(GridTemplate.ITEM_SIZE_LARGE)
+        }
+
+        return template.build()
+    }
+
+    private fun launchVoiceAssistant() {
+        try {
+            val telecomManager = carContext.getSystemService(Context.TELECOM_SERVICE) as? TelecomManager
+            if (telecomManager == null) {
+                CarToast.makeText(carContext, "Telecom service unavailable", CarToast.LENGTH_LONG).show()
+                return
+            }
+            val componentName = ComponentName(carContext, NeoAgentConnectionService::class.java)
+            val phoneAccountHandle = PhoneAccountHandle(componentName, "NeoAgentVoiceId")
+            
+            val phoneAccount = PhoneAccount.builder(phoneAccountHandle, "NeoAgent Voice Assistant")
+                .setCapabilities(PhoneAccount.CAPABILITY_SELF_MANAGED)
+                .build()
+            
+            telecomManager.registerPhoneAccount(phoneAccount)
+            
+            val extras = Bundle().apply {
+                putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle)
+                // For proper routing:
+                putInt(TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE, android.telecom.VideoProfile.STATE_AUDIO_ONLY)
+            }
+            
+            telecomManager.placeCall(Uri.parse("tel:NeoAgent"), extras)
+            
+            CarToast.makeText(
+                carContext,
+                "Starting voice mode...",
+                CarToast.LENGTH_SHORT,
+            ).show()
+        } catch (e: SecurityException) {
+            CarToast.makeText(carContext, "Missing phone permission", CarToast.LENGTH_LONG).show()
+        } catch (e: Exception) {
+            CarToast.makeText(carContext, "Could not start call: ${e.message}", CarToast.LENGTH_LONG).show()
+        }
+    }
+}

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/telecom/NeoAgentConnection.kt

@@ -0,0 +1,118 @@
+package com.neoagent.flutter_app.telecom
+
+import android.content.Context
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import android.telecom.Connection
+import android.telecom.DisconnectCause
+import android.telecom.TelecomManager
+import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.embedding.engine.FlutterEngineCache
+import io.flutter.embedding.engine.dart.DartExecutor
+import io.flutter.plugin.common.MethodChannel
+
+class NeoAgentConnection(private val context: Context) : Connection() {
+    private var flutterEngine: FlutterEngine? = null
+    var isFlutterInitiated: Boolean = false
+    private var voiceHeadlessStarted: Boolean = false
+
+    init {
+        audioModeIsVoip = true
+        setAddress(Uri.parse("tel:NeoAgent"), TelecomManager.PRESENTATION_ALLOWED)
+        setCallerDisplayName("NeoAgent", TelecomManager.PRESENTATION_ALLOWED)
+        connectionProperties = PROPERTY_SELF_MANAGED
+        connectionCapabilities = CAPABILITY_MUTE or CAPABILITY_HOLD
+    }
+
+    override fun onAnswer() {
+        setActive()
+        startVoiceAssistantHeadless()
+    }
+
+    override fun onAnswer(videoState: Int) {
+        onAnswer()
+    }
+
+    override fun onReject() {
+        setDisconnected(DisconnectCause(DisconnectCause.REJECTED))
+        destroy()
+        cleanup()
+    }
+
+    override fun onAbort() {
+        setDisconnected(DisconnectCause(DisconnectCause.REJECTED))
+        destroy()
+        cleanup()
+    }
+
+    override fun onDisconnect() {
+        setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+        destroy()
+        cleanup()
+    }
+
+    override fun onStateChanged(state: Int) {
+        super.onStateChanged(state)
+        if (state == STATE_ACTIVE) {
+            startVoiceAssistantHeadless()
+        } else if (state == STATE_DISCONNECTED) {
+            cleanup()
+        }
+    }
+
+    private fun startVoiceAssistantHeadless() {
+        if (voiceHeadlessStarted) return
+        voiceHeadlessStarted = true
+        if (flutterEngine != null) return
+
+        // Wait a slight moment for audio routing to settle before capturing mic
+        Handler(Looper.getMainLooper()).postDelayed({
+            // Check if there is already an active engine to avoid duplicating connections
+            var existingEngine = FlutterEngineCache.getInstance().get("main_engine")
+            
+            if (existingEngine != null) {
+                // If engine exists (app is in background), we can just trigger it via method channel
+                flutterEngine = existingEngine
+            } else {
+                // Spawn headless engine
+                flutterEngine = FlutterEngine(context.applicationContext)
+                flutterEngine?.dartExecutor?.executeDartEntrypoint(
+                    DartExecutor.DartEntrypoint.createDefault()
+                )
+            }
+            
+            if (!isFlutterInitiated) {
+                // To ensure the flutter side starts the LiveVoiceCapture session automatically
+                // we should ideally notify it through a MethodChannel.
+                // But since this is a headless connection, if we just initialize the engine,
+                // we need to tell it to start voice mode.
+                // We will invoke a method call to Dart.
+                MethodChannel(
+                    flutterEngine!!.dartExecutor.binaryMessenger,
+                    "neoagent/car_auto"
+                ).invokeMethod("startVoiceMode", null)
+                isFlutterInitiated = true
+            }
+
+        }, 500)
+    }
+
+    private fun cleanup() {
+        if (!isFlutterInitiated) {
+            val messenger = flutterEngine?.dartExecutor?.binaryMessenger
+            if (messenger != null) {
+                MethodChannel(
+                    messenger,
+                    "neoagent/car_auto"
+                ).invokeMethod("stopVoiceMode", null)
+            }
+        }
+        
+        NeoAgentConnectionService.getAndClearCurrentConnection()
+        
+        // We only destroy the engine if we created it headless and we want to clean up.
+        // For simplicity and reusing existing state, we can leave it running 
+        // to handle the end-of-call cleanly on the dart side.
+    }
+}

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/telecom/NeoAgentConnectionService.kt

@@ -0,0 +1,86 @@
+package com.neoagent.flutter_app.telecom
+
+import android.content.Context
+import android.net.Uri
+import android.os.Bundle
+import android.telecom.Connection
+import android.telecom.ConnectionService
+import android.telecom.ConnectionRequest
+import android.telecom.PhoneAccountHandle
+import android.telecom.TelecomManager
+import android.telecom.DisconnectCause
+
+class NeoAgentConnectionService : ConnectionService() {
+    override fun onCreateOutgoingConnection(
+        connectionManagerPhoneAccount: PhoneAccountHandle?,
+        request: ConnectionRequest?
+    ): Connection {
+        return createConnection(request, isIncoming = false)
+    }
+
+    override fun onCreateOutgoingConnectionFailed(
+        connectionManagerPhoneAccount: PhoneAccountHandle?,
+        request: ConnectionRequest?
+    ) {
+        super.onCreateOutgoingConnectionFailed(connectionManagerPhoneAccount, request)
+    }
+
+    override fun onCreateIncomingConnection(
+        connectionManagerPhoneAccount: PhoneAccountHandle?,
+        request: ConnectionRequest?
+    ): Connection {
+        return createConnection(request, isIncoming = true)
+    }
+
+    override fun onCreateIncomingConnectionFailed(
+        connectionManagerPhoneAccount: PhoneAccountHandle?,
+        request: ConnectionRequest?
+    ) {
+        super.onCreateIncomingConnectionFailed(connectionManagerPhoneAccount, request)
+    }
+
+    companion object {
+        @Volatile
+        private var currentConnection: NeoAgentConnection? = null
+
+        @Synchronized
+        fun getAndClearCurrentConnection(): NeoAgentConnection? {
+            val conn = currentConnection
+            currentConnection = null
+            return conn
+        }
+        
+        @Synchronized
+        fun swapConnection(newConnection: NeoAgentConnection) {
+            currentConnection?.let {
+                try {
+                    it.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+                    it.destroy()
+                } catch (e: Exception) {
+                    // Ignore
+                }
+            }
+            currentConnection = newConnection
+        }
+    }
+
+    private fun createConnection(request: ConnectionRequest?, isIncoming: Boolean): Connection {
+        val connection = NeoAgentConnection(applicationContext)
+        swapConnection(connection)
+        
+        // Custom flag from Flutter to know if it started the call
+        val isFlutterInitiated = request?.extras?.getBoolean("is_flutter_initiated") ?: false
+        connection.isFlutterInitiated = isFlutterInitiated
+
+        connection.connectionProperties = Connection.PROPERTY_SELF_MANAGED
+        connection.setInitializing()
+        
+        if (isIncoming) {
+            connection.setRinging()
+        } else {
+            connection.setDialing()
+        }
+        
+        return connection
+    }
+}

package/flutter_app/android/app/src/main/res/xml/automotive_app_desc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<automotiveApp>
+    <uses name="template" />
+</automotiveApp>