neoagent 2.3.1-beta.6 → 2.3.1-beta.60

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

@@ -0,0 +1,104 @@
+package com.neoagent.flutter_app.recording
+
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.File
+import java.io.OutputStreamWriter
+import java.net.HttpURLConnection
+import java.net.URL
+import java.nio.charset.StandardCharsets
+
+class RecordingUploadClient {
+    fun uploadChunk(
+        backendUrl: String,
+        sessionCookie: String,
+        sessionId: String,
+        meta: PendingChunkMeta,
+        file: File,
+    ) {
+        val url = URL(resolveUrl(backendUrl, "/api/recordings/$sessionId/chunks"))
+        val connection = (url.openConnection() as HttpURLConnection).apply {
+            requestMethod = "POST"
+            doOutput = true
+            connectTimeout = 20_000
+            readTimeout = 60_000
+            setRequestProperty("Cookie", sessionCookie)
+            setRequestProperty("Content-Type", meta.mimeType)
+            setRequestProperty("X-Recording-Source-Key", SOURCE_KEY)
+            setRequestProperty("X-Recording-Sequence", meta.sequence.toString())
+            setRequestProperty("X-Recording-Start-Ms", meta.startMs.toString())
+            setRequestProperty("X-Recording-End-Ms", meta.endMs.toString())
+        }
+
+        file.inputStream().use { input ->
+            connection.outputStream.use { output ->
+                input.copyTo(output)
+            }
+        }
+
+        val statusCode = connection.responseCode
+        if (statusCode !in 200..299) {
+            val body = readResponse(connection)
+            connection.disconnect()
+            throw IllegalStateException("Chunk upload failed ($statusCode): $body")
+        }
+        connection.disconnect()
+    }
+
+    fun finalizeSession(
+        backendUrl: String,
+        sessionCookie: String,
+        sessionId: String,
+        stopReason: String,
+    ) {
+        val url = URL(resolveUrl(backendUrl, "/api/recordings/$sessionId/finalize"))
+        val connection = (url.openConnection() as HttpURLConnection).apply {
+            requestMethod = "POST"
+            doOutput = true
+            connectTimeout = 20_000
+            readTimeout = 60_000
+            setRequestProperty("Cookie", sessionCookie)
+            setRequestProperty("Content-Type", "application/json")
+        }
+
+        val payload = JSONObject()
+            .put("stopReason", stopReason)
+            .toString()
+        OutputStreamWriter(connection.outputStream, StandardCharsets.UTF_8).use { writer ->
+            writer.write(payload)
+        }
+
+        val statusCode = connection.responseCode
+        if (statusCode !in 200..299) {
+            val body = readResponse(connection)
+            connection.disconnect()
+            throw IllegalStateException("Finalize failed ($statusCode): $body")
+        }
+        connection.disconnect()
+    }
+
+    private fun readResponse(connection: HttpURLConnection): String {
+        val stream = connection.errorStream ?: connection.inputStream ?: return ""
+        return stream.bufferedReader().use(BufferedReader::readText)
+    }
+
+    private fun resolveUrl(baseUrl: String, path: String): String {
+        val trimmed = baseUrl.trim().removeSuffix("/")
+        return if (trimmed.isEmpty()) {
+            path
+        } else {
+            "$trimmed$path"
+        }
+    }
+
+    companion object {
+        const val SOURCE_KEY = "microphone"
+    }
+}
+
+data class PendingChunkMeta(
+    val sequence: Int,
+    val startMs: Long,
+    val endMs: Long,
+    val mimeType: String = "audio/wav",
+)

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
+    }
+}