怎么注册 udpSocket.bind 这样的函数

[qq547176052]

你的需求是否与某个问题相关？ (Is your feature request related to a problem?)

package com.didi.dimina.api.network

import android.util.Log
import com.didi.dimina.api.APIResult
import com.didi.dimina.api.ApiHandler
import com.didi.dimina.api.ApiRegistry
import com.didi.dimina.api.NoneResult
import com.didi.dimina.api.SyncResult
import com.didi.dimina.common.ApiUtils
import com.didi.dimina.engine.qjs.JSValue
import com.didi.dimina.ui.container.DiminaActivity
import org.json.JSONObject
import java.net.DatagramPacket
import java.net.DatagramSocket
import java.net.InetAddress
import java.net.InetSocketAddress
import java.nio.charset.StandardCharsets
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger

/**
 * UDP Socket API实现
 * 实现 createUDPSocket, UDPSocket.bind, UDP_test 三个函数
 */
class UdpSocketApi : ApiHandler {

    companion object {
        private const val TAG = "UdpSocketApi"

        // API方法名常量定义
        const val CREATE_UDP_SOCKET = "createUDPSocket"
        const val UDPSOCKET_BIND = "UDPSocket.bind"
        const val UDP_TEST = "UDP_test"
    }

    // 使用线程安全的Map管理UDP Socket实例
    private val udpSockets = ConcurrentHashMap<String, UdpSocketInstance>()
    private val idCounter = AtomicInteger(1)

    fun registerWith(registry: ApiRegistry) {
        // 注册三个API
        registry.register(CREATE_UDP_SOCKET, this)
        registry.register(UDPSOCKET_BIND, this)
        registry.register(UDP_TEST, this)
        Log.d(TAG, "✅ UDP Socket API注册完成: createUDPSocket, UDPSocket.bind, UDP_test")
    }

    override fun handleAction(
        activity: DiminaActivity,
        appId: String,
        apiName: String,
        params: JSONObject,
        responseCallback: (String) -> Unit
    ): APIResult {
        Log.d(TAG, "处理UDP API: $apiName")

        return when (apiName) {
            CREATE_UDP_SOCKET -> createUdpSocket(activity, appId, params, responseCallback)
            UDPSOCKET_BIND -> bindUdpSocket(params, responseCallback)
            UDP_TEST -> udpTest(activity, appId, params, responseCallback)
            else -> {
                Log.w(TAG, "未知的UDP API: $apiName")
                NoneResult()
            }
        }
    }

    /**
     * 1. createUDPSocket - 创建UDP Socket实例
     * 同步API：返回包含UDPSocket对象的SyncResult
     */
    private fun createUdpSocket(
        activity: DiminaActivity,
        appId: String,
        params: JSONObject,
        responseCallback: (String) -> Unit
    ): APIResult {
        Log.d(TAG, "=== createUDPSocket 开始 ===")
        Log.d(TAG, "参数: ${params.toString(2)}")

        return try {
            val socketId = "udp_${System.currentTimeMillis()}"
            val instanceId = idCounter.getAndIncrement()

            Log.d(TAG, "创建Socket实例: $socketId, instanceId: $instanceId")

            // 创建UDP Socket实例
            val udpInstance = UdpSocketInstance(socketId, instanceId)
            udpSockets[socketId] = udpInstance

            // 构建符合微信小程序规范的UDPSocket对象
            // 关键：使用框架期望的方法声明方式
            val udpSocketObj = JSONObject().apply {
                // 基础标识字段
                put("_id", instanceId)
                put("socketId", socketId)

                // 方法声明 - 使用布尔值true，框架会自动创建函数
                put("bind", true)      // 绑定端口方法
                put("send", true)      // 发送消息方法
                put("close", true)     // 关闭Socket方法
                put("onMessage", true) // 监听消息方法
                put("offMessage", true) // 取消监听消息方法

                // 添加类型标识，帮助框架识别对象类型
                put("__className", "UDPSocket")
                put("__type", "native_instance")

                // 成功状态
                put("errMsg", "$CREATE_UDP_SOCKET:ok")
            }

            Log.d(TAG, "✅ UDP Socket创建成功")
            Log.d(TAG, "返回对象: ${udpSocketObj.toString(2)}")

            // 同步返回UDPSocket对象
            val jsValue = createJSValue(udpSocketObj)
            SyncResult(jsValue)

        } catch (e: Exception) {
            Log.e(TAG, "❌ 创建UDP Socket失败", e)
            val errorObj = JSONObject().apply {
                put("errMsg", "$CREATE_UDP_SOCKET:fail")
                put("error", e.message ?: "Unknown error")
            }
            val jsValue = createJSValue(errorObj)
            SyncResult(jsValue)
        } finally {
            Log.d(TAG, "=== createUDPSocket 结束 ===")
        }
    }

    /**
     * 2. UDPSocket.bind - 绑定UDP Socket到指定端口
     * 同步API：返回绑定结果的SyncResult
     */
    private fun bindUdpSocket(
        params: JSONObject,
        responseCallback: (String) -> Unit
    ): APIResult {
        Log.d(TAG, "=== UDPSocket.bind 开始 ===")
        Log.d(TAG, "参数: ${params.toString(2)}")

        return try {
            val socketId = params.optString("socketId", "")
            if (socketId.isBlank()) {
                throw IllegalArgumentException("socketId不能为空")
            }

            Log.d(TAG, "查找Socket实例: $socketId")
            val udpInstance = udpSockets[socketId]
            if (udpInstance == null) {
                throw IllegalArgumentException("UDP Socket不存在: $socketId")
            }

            val port = params.optInt("port", 0)
            val address = params.optString("address", "0.0.0.0")

            Log.d(TAG, "绑定到: $address:$port")

            // 执行绑定操作
            val actualPort = udpInstance.bind(address, port)

            // 构建同步返回结果
            val result = JSONObject().apply {
                put("socketId", socketId)
                put("port", actualPort)
                put("address", address)
                put("errMsg", "$UDPSOCKET_BIND:ok")
            }

            Log.d(TAG, "✅ UDP Socket绑定成功: 端口 $actualPort")

            // 同步返回绑定结果
            val jsValue = createJSValue(result)
            SyncResult(jsValue)

        } catch (e: Exception) {
            Log.e(TAG, "❌ 绑定UDP Socket失败", e)
            val errorObj = JSONObject().apply {
                put("errMsg", "$UDPSOCKET_BIND:fail")
                put("error", e.message ?: "Unknown error")
            }
            val jsValue = createJSValue(errorObj)
            SyncResult(jsValue)
        } finally {
            Log.d(TAG, "=== UDPSocket.bind 结束 ===")
        }
    }

    /**
     * 3. UDP_test - 测试函数，用于调试和验证
     * 同步API：返回测试结果的SyncResult
     */
    private fun udpTest(
        activity: DiminaActivity,
        appId: String,
        params: JSONObject,
        responseCallback: (String) -> Unit
    ): APIResult {
        Log.d(TAG, "=== UDP_test 开始 ===")
        Log.d(TAG, "参数: ${params.toString(2)}")

        return try {
            // 收集测试信息
            val testInfo = JSONObject().apply {
                // 基本信息
                put("test", "UDP Socket API 测试")
                put("timestamp", System.currentTimeMillis())
                put("appId", appId)
                put("activity", activity.javaClass.simpleName)

                // 当前状态
                put("udpSocketsCount", udpSockets.size)
                put("managedSockets", JSONObject(udpSockets.keys.associateWith {
                    udpSockets[it]?.getStatus() ?: "unknown"
                }))

                // 参数信息
                put("receivedParams", params)

                // 测试结果
                put("createUDPSocket", "✅ 已注册")
                put("UDPSocket.bind", "✅ 已注册")
                put("UDP_test", "✅ 正在执行")

                // 系统信息
                put("idCounter", idCounter.get())
                put("thread", Thread.currentThread().name)
            }

            Log.d(TAG, "📊 测试信息收集完成")

            // 执行具体的测试用例
            val testResults = executeTestCases()
            testInfo.put("testResults", testResults)

            // 最终结果
            testInfo.put("overall", if (testResults.optBoolean("allPassed", false)) "✅ 通过" else "❌ 失败")
            testInfo.put("errMsg", "$UDP_TEST:ok")

            Log.d(TAG, "✅ UDP测试完成")
            Log.d(TAG, "测试结果: ${testInfo.toString(2)}")

            // 同步返回测试结果
            val jsValue = createJSValue(testInfo)
            SyncResult(jsValue)

        } catch (e: Exception) {
            Log.e(TAG, "❌ UDP测试失败", e)
            val errorObj = JSONObject().apply {
                put("errMsg", "$UDP_TEST:fail")
                put("error", e.message ?: "Unknown error")
                put("timestamp", System.currentTimeMillis())
            }
            val jsValue = createJSValue(errorObj)
            SyncResult(jsValue)
        } finally {
            Log.d(TAG, "=== UDP_test 结束 ===")
        }
    }

    /**
     * 执行具体的测试用例
     */
    private fun executeTestCases(): JSONObject {
        val results = JSONObject()
        var allPassed = true

        // 测试用例1: 创建Socket测试
        try {
            val testSocketId = "test_udp_${System.currentTimeMillis()}"
            val testInstance = UdpSocketInstance(testSocketId, idCounter.getAndIncrement())

            results.put("createSocket", JSONObject().apply {
                put("status", "✅ 通过")
                put("socketId", testSocketId)
                put("instanceId", testInstance.instanceId)
            })
        } catch (e: Exception) {
            allPassed = false
            results.put("createSocket", JSONObject().apply {
                put("status", "❌ 失败")
                put("error", e.message)
            })
        }

        // 测试用例2: 绑定端口测试
        try {
            val testSocket = DatagramSocket(0) // 使用随机端口测试
            val localPort = testSocket.localPort
            testSocket.close()

            results.put("bindPort", JSONObject().apply {
                put("status", "✅ 通过")
                put("testPort", localPort)
                put("reuseAddress", testSocket.reuseAddress)
            })
        } catch (e: Exception) {
            allPassed = false
            results.put("bindPort", JSONObject().apply {
                put("status", "❌ 失败")
                put("error", e.message)
            })
        }

        // 测试用例3: 网络地址解析测试
        try {
            val localhost = InetAddress.getByName("127.0.0.1")
            val anyAddress = InetAddress.getByName("0.0.0.0")

            results.put("network", JSONObject().apply {
                put("status", "✅ 通过")
                put("localhost", localhost.hostAddress)
                put("anyAddress", anyAddress.hostAddress)
                put("localhostReachable", localhost.isReachable(1000))
            })
        } catch (e: Exception) {
            allPassed = false
            results.put("network", JSONObject().apply {
                put("status", "❌ 失败")
                put("error", e.message)
            })
        }

        results.put("allPassed", allPassed)
        results.put("testCount", 3)
        results.put("passedCount", if (allPassed) 3 else 2) // 简化计算

        return results
    }

    /**
     * 创建JSValue的辅助方法
     */
    private fun createJSValue(jsonObject: JSONObject): JSValue {
        return try {
            // 使用Dimina框架的标准方式创建JSValue
            JSValue.createObject(jsonObject.toString())
        } catch (e: Exception) {
            Log.e(TAG, "创建JSValue失败，使用备用方案", e)
            try {
                // 备用方案：创建空对象
                JSValue.createObject("{}")
            } catch (e2: Exception) {
                Log.e(TAG, "备用方案也失败", e2)
                throw RuntimeException("无法创建JSValue")
            }
        }
    }

    /**
     * UDP Socket实例内部类
     */
    private inner class UdpSocketInstance(
        val socketId: String,
        val instanceId: Int
    ) {
        private var socket: DatagramSocket? = null
        private var isBound = AtomicBoolean(false)
        private var localPort: Int = 0
        private var bindAddress: String = ""

        /**
         * 绑定Socket到指定地址和端口
         */
        @Throws(Exception::class)
        fun bind(address: String, port: Int): Int {
            if (isBound.get()) {
                throw IllegalStateException("Socket已经绑定")
            }

            Log.d(TAG, "执行实际Socket绑定: $address:$port")

            try {
                val inetAddress = InetAddress.getByName(address)

                // 创建并绑定Socket
                socket = DatagramSocket(null).apply {
                    reuseAddress = true // 允许地址重用
                    // 绑定到指定地址和端口
                    bind(InetSocketAddress(inetAddress, if (port == 0) 0 else port))
                }

                isBound.set(true)
                localPort = socket?.localPort ?: 0
                bindAddress = address

                Log.d(TAG, "✅ Socket绑定成功: $address:$localPort")
                return localPort

            } catch (e: java.net.BindException) {
                Log.e(TAG, "端口绑定失败: $port，尝试随机端口", e)

                // 端口被占用时使用随机端口
                socket = DatagramSocket().apply {
                    reuseAddress = true
                }
                isBound.set(true)
                localPort = socket?.localPort ?: 0
                bindAddress = "0.0.0.0" // 随机绑定使用任意地址

                Log.d(TAG, "✅ 随机端口绑定成功: $localPort")
                return localPort
            }
        }

        /**
         * 发送UDP消息
         */
        @Throws(Exception::class)
        fun send(message: String, address: String, port: Int): Int {
            if (!isBound.get()) {
                throw IllegalStateException("Socket未绑定")
            }

            val data = message.toByteArray(StandardCharsets.UTF_8)
            val targetAddress = InetAddress.getByName(address)
            val packet = DatagramPacket(data, data.size, targetAddress, port)

            socket?.send(packet)
            Log.d(TAG, "✅ 发送UDP消息: ${data.size}字节 -> $address:$port")
            return data.size
        }

        /**
         * 关闭Socket
         */
        fun close() {
            isBound.set(false)
            socket?.close()
            socket = null
            Log.d(TAG, "✅ Socket关闭: $socketId")
        }

        /**
         * 获取Socket状态
         */
        fun getStatus(): String {
            return if (isBound.get()) {
                "已绑定到 $bindAddress:$localPort"
            } else {
                "未绑定"
            }
        }
    }

    /**
     * 清理资源
     */
    fun cleanup() {
        Log.d(TAG, "清理UDP Socket资源")
        udpSockets.values.forEach { it.close() }
        udpSockets.clear()
    }
}

c

小程序调用 bindResult = udpSocket.bind(Number(port));
得到 [JS] UDP测试: ❌ 端口绑定失败: not a function

udpSocket.bind 注册不成功
这个应该怎么j
j解决

描述你想要的解决方案 (Describe the solution you'd like)

注册 udpSocket.bind 函数,能被小程序调用

描述你考虑过的替代方案 (Describe alternatives you've considered)

No response

平台 (Platform)

• Android
• iOS
• Harmony
• Web

补充信息 (Additional context)

No response

[qq547176052]

package com.didi.dimina.core

import android.app.Activity
import android.content.Context
import android.util.Log
import com.didi.dimina.Dimina
import com.didi.dimina.api.ApiRegistry
import com.didi.dimina.api.AsyncResult
import com.didi.dimina.api.SyncResult
import com.didi.dimina.api.base.AppEventApi
import com.didi.dimina.api.base.BaseAPI
import com.didi.dimina.api.base.SystemApi
import com.didi.dimina.api.device.ClipboardApi
import com.didi.dimina.api.device.ContactApi
import com.didi.dimina.api.device.KeyboardApi
import com.didi.dimina.api.device.PhoneApi
import com.didi.dimina.api.device.ScanApi
import com.didi.dimina.api.device.VibrateAPI
import com.didi.dimina.api.media.ImageApi
import com.didi.dimina.api.media.VideoApi
import com.didi.dimina.api.route.RouteApi
import com.didi.dimina.api.storage.StorageApi
import com.didi.dimina.api.ui.InteractionApi
import com.didi.dimina.api.ui.MenuApi
import com.didi.dimina.api.ui.NavigationBarApi
import com.didi.dimina.api.ui.ScrollApi
import com.didi.dimina.bean.MiniProgram
import com.didi.dimina.common.ApiUtils
import com.didi.dimina.common.LogUtils
import com.didi.dimina.common.Utils
import com.didi.dimina.common.VersionUtils
import com.didi.dimina.engine.qjs.JSValue
import com.didi.dimina.ui.container.DiminaActivity
import org.json.JSONObject
import java.io.File

/**
 * Author: Doslin
 *
 * MiniApp API architecture to handle container-side APIs like navigation, photo gallery, camera functionality, etc.
 * This class provides a centralized way to manage all API handlers and their callbacks.
 */
class MiniApp private constructor() {
    private val tag = "MiniApp"

    private val apiRegistry = ApiRegistry()

    // Map to store JsCore instances for each MiniProgram
    private val jsCoreMap = mutableMapOf<String, JsCore>()

    // Map to store Bridge instances for each MiniProgram
    private val bridgeListMap = mutableMapOf<String, MutableList<Bridge>>()

    companion object {
        @Volatile
        private var instance: MiniApp = MiniApp()

        fun getInstance(): MiniApp {
            return instance
        }
    }

    init {
        // Register API handlers that are common for all MiniPrograms
        registerApiHandlers()
    }

    /**
     * Open a MiniProgram in DiminaActivity 在DiminaActivity中打开一个小程序
     *
     * @param miniProgram The MiniProgram to open
     */
    fun openApp(context: Activity, miniProgram: MiniProgram) {
        // Initialize or get JsCore for this MiniProgram 为此小程序初始化或获取JsCore
        getOrCreateJsCore(miniProgram.appId, context)

        DiminaActivity.launch(context, miniProgram)
    }

    /**
     * Get the JsCore instance for a specific MiniProgram
     *
     * @param appId The ID of the MiniProgram
     * @param context The context to use for initializing JsCore if needed
     * @return The JsCore instance for the MiniProgram
     */
    fun getJsCore(appId: String, context: Context? = null): JsCore {
        return getOrCreateJsCore(appId, context)
    }

    /**
     * Get or create a JsCore instance for a specific MiniProgram
     *
     * @param appId The ID of the MiniProgram
     * @return The JsCore instance for the MiniProgram
     */
    private fun getOrCreateJsCore(appId: String, context: Context? = null): JsCore {
        return jsCoreMap.getOrPut(appId) {
            LogUtils.d(tag, "为appId创建新的JsCore实例: $appId")
            JsCore().apply {
                init { initialized ->
                    if (initialized) {
                        context?.let {
                            try {
                                // 判断是否需要检测 JSSDK 的逻辑：调试模式或者 App 版本已更新
                                if (Dimina.getInstance().isDebugMode() || VersionUtils.isAppVersionUpdated(context)) {
                                    LogUtils.d(tag, "检查JSSDK更新...")
                                    val jsConfigString =
                                        context.assets.open("jssdk/config.json").bufferedReader()
                                            .use { it.readText() }
                                    val sdkObject = JSONObject(jsConfigString)
                                    val newVersionCode = sdkObject.getInt("versionCode")
                                    val versionName = sdkObject.getString("versionName")
                                    val oldVersionCode = VersionUtils.getJSVersion()
                                    if (newVersionCode > oldVersionCode) {
                                        LogUtils.d(tag, "JSSDK 发现更新: $versionName($newVersionCode)")
                                        if (Utils.unzipAssets(
                                                context,
                                                "jssdk/main.zip",
                                                "jssdk/$newVersionCode",
                                            )
                                        ) {
                                            VersionUtils.setJSVersion(newVersionCode)
                                            LogUtils.d(tag, "JSSDK 已成功更新到版本 $versionName($newVersionCode)")
                                        } else {
                                            LogUtils.e(
                                                tag,
                                                "提取失败 JSSDK: $versionName($newVersionCode)"
                                            )
                                        }
                                    } else {
                                        LogUtils.d(tag, "JSSDK已经更新: $versionName($newVersionCode)")
                                    }
                                } else {
                                    LogUtils.d(tag, "跳过JSSDK更新检查，上次检查是最近的")
                                }
                                evaluateFromFile(
                                    File(
                                        context.filesDir.absolutePath,
                                        "jssdk/${VersionUtils.getJSVersion()}/main/assets/service.js"
                                    ).absolutePath
                                )
                                LogUtils.d(tag, "JsCore已为appId初始化: $appId")



                                LogUtils.d(tag, "注入 js_injection.js: $appId")
                                val tempFile = File.createTempFile("js_injection", ".js")

                                try {
                                    val jsCode = injectUdpImplementation()
                                    tempFile.writeText(jsCode)
                                    evaluateFromFile(tempFile.absolutePath)
                                    LogUtils.d(tag, "✅ 注入 js_injection.js 成功: $appId")
                                } catch (e: Exception) {
                                    // 只有发生异常时才执行
                                    LogUtils.e(tag, "❌ 注入 js_injection.js 失败: $appId, 错误: ${e.message}")
                                } finally {
                                    // 无论成功失败都要清理资源
                                    tempFile.delete()
                                    LogUtils.d(tag, "🧹 清理临时文件完成: $appId")
                                }


                            } catch (e: Exception) {
                                LogUtils.e(tag, "提取js-sdk时出错: ${e.message}")
                            }
                        }
                    } else {
                        LogUtils.e(tag, "未能为appId初始化JsCore: $appId")
                    }
                }
            }
        }
    }





    /**
     * 注入UDP实现和心跳（在logic.js之后）
     */
    /*
    private fun injectUdpImplementation() {

        try {
            val implementationCode = """
            // UDP实现和心跳
            console.log('🚀 UDP API已就绪');
            // 心跳检测
            setInterval(() => {
                console.log('💓 JS线程心跳检测 - 时间:', new Date().toLocaleTimeString());
                console.log('💓 wx:', wx);

            }, 5000);
        """.trimIndent()

            executeJsCodeViaFile(implementationCode)
            Log.d(tag, "✅ UDP实现注入成功")

        } catch (e: Exception) {
            Log.e(tag, "❌ UDP实现注入失败", e)
        }





    }
    */
    /**
     * 注入UDP实现和心跳（在logic.js之后）
     */
    private fun injectUdpImplementation(): String {
        try {
            val implementationCode = """
            // 注入js代码
            console.log('MiniApp','🚀 注入js代码 API已就绪');
            
                function injectAaaFunction() {
                    try {
                        // 注入 wx.aaa 函数
                        wx.aaa = function(input) {
                            console.log('MiniApp','🔧 wx.aaa被调用，参数:', input);
                            
                            // 返回一个包含输入参数和额外信息的对象
                            return {
                                success: true,
                                input: input,
                                message: '函数调用成功',
                                timestamp: Date.now(),
                                thread: 'js_thread',
                                version: '1.0.0'
                            };
                        };
                        console.log('MiniApp','✅ wx.aaa函数注入成功');
                        console.log('MiniApp','📋 当前wx对象的方法:', Object.keys(wx).filter(key => 
                            typeof wx[key] === 'function'
                        ));
                        
                    } catch (error) {
                        console.error('MiniApp','❌ 注入函数失败:', error);
                    }
                }

            if (typeof wx !== 'undefined' && wx !== null) {
                        console.log('MiniApp','✅ wx对象存在，开始注入函数');
                        injectAaaFunction();
            }else{
                console.log('MiniApp','❌ wx对象不存在');
            }

        """.trimIndent()


            Log.d(tag, "✅ UDP实现和wx.aaa函数注入成功")
            return  implementationCode

        } catch (e: Exception) {
            Log.e(tag, "❌ UDP实现注入失败", e)
        }
        return ""
    }



















    /**
     * Registers all API handlers with the registry
     */
    private fun registerApiHandlers() {
        // base
        BaseAPI().registerWith(apiRegistry)
        SystemApi().registerWith(apiRegistry)

        // device
        ClipboardApi().registerWith(apiRegistry)
        KeyboardApi().registerWith(apiRegistry)
        PhoneApi().registerWith(apiRegistry)
        ContactApi().registerWith(apiRegistry)
        com.didi.dimina.api.device.NetworkApi().registerWith(apiRegistry)
        VibrateAPI().registerWith(apiRegistry)
        ScanApi().registerWith(apiRegistry)

        // media
        ImageApi().registerWith(apiRegistry)
        VideoApi().registerWith(apiRegistry)

        // route
        RouteApi().registerWith(apiRegistry)

        // ui
        AppEventApi().registerWith(apiRegistry)
        InteractionApi().registerWith(apiRegistry)
        NavigationBarApi().registerWith(apiRegistry)
        ScrollApi().registerWith(apiRegistry)
        MenuApi().registerWith(apiRegistry)

        // network
        com.didi.dimina.api.network.NetworkApi().registerWith(apiRegistry)
        // ===== 添加UDP API注册 =====
        com.didi.dimina.api.network.UdpSocketApi().registerWith(apiRegistry)

        // storage
        StorageApi().registerWith(apiRegistry)
    }

    /**
     * Gets a set of all available API names from registered handlers
     *
     * @return Set of all available API names
     */
    fun getAvailableApis(): Set<String> {
        return apiRegistry.getRegisteredApiNames()
    }

    /**
     * Handles API invocation from JavaScript
     *
     * @param context The Activity context
     * @param apiName The name of the API to invoke
     * @param params Parameters for the API call
     * @param responseCallback Callback to send response back to JavaScript
     * @return True if API was successfully invoked, false otherwise
     */
    fun invokeAPI(
        appId: String,
        context: DiminaActivity,
        apiName: String,
        params: JSONObject,
        responseCallback: (String) -> Unit,
    ): JSValue? {

        var isAsyncMethod = false
        try {
            LogUtils.d(tag, "Invoking API: $apiName with params: $params")

            // Invoke the API
            val result = apiRegistry.invoke(context, appId, apiName, params, responseCallback)
            if (result is AsyncResult) {
                isAsyncMethod = true
                val errorMsg = result.value.optString("errMsg", "")
                if (errorMsg.isNotEmpty()) {
                    if (errorMsg.endsWith(":ok")) {
                        ApiUtils.invokeSuccess(params, result.value, responseCallback)
                    } else {
                        // API not found or invocation failed
                        ApiUtils.invokeFail(params, result.value, responseCallback)
                    }
                    return null
                }
            } else if (result is SyncResult) {
                return result.value
            }
        } catch (e: Exception) {
            // Collect all error information
            e.printStackTrace()
            LogUtils.e(tag, "Error invoking API: ${e.message}")
            if (isAsyncMethod) {
                ApiUtils.invokeFail(params,  JSONObject().apply {
                    put("errMsg", "$apiName:fail ${e.message}")
                }, responseCallback)
            }
        } finally {
            if (isAsyncMethod) {
                ApiUtils.invokeComplete(params, responseCallback)
            }
        }
        return null
    }

    /**
     * Get the list of Bridge instances for a specific MiniProgram
     *
     * @param appId The ID of the MiniProgram
     * @return The list of Bridge instances for the MiniProgram
     */
    fun getBridgeList(appId: String): MutableList<Bridge> {
        return bridgeListMap.getOrPut(appId) { mutableListOf() }
    }

    /**
     * Add a Bridge instance for a specific MiniProgram
     *
     * @param appId The ID of the MiniProgram
     * @param bridge The Bridge instance to add
     */
    fun addBridge(appId: String, bridge: Bridge) {
        getBridgeList(appId).add(bridge)
        LogUtils.d(
            tag,
            "Added Bridge for appId: $appId, total bridges: ${getBridgeList(appId).size}"
        )
    }

    /**
     * Remove the Bridge instance for a specific MiniProgram
     *
     * @param appId The ID of the MiniProgram
     * @return The removed Bridge instance, or null if no Bridge was removed
     */
    fun removeBridge(appId: String, bridge: Bridge): Bridge? {
        val bridgeList = getBridgeList(appId)
        if (bridgeList.isEmpty()) return null

        val removedBridge = if (bridgeList.remove(bridge)) bridge else null
        LogUtils.d(tag, "Removed Bridge for appId: $appId, remaining bridges: ${bridgeList.size}")
        return removedBridge
    }

    /**
     * Check if there are any Bridge instances for a specific MiniProgram
     *
     * @param appId The ID of the MiniProgram
     * @return True if there are no Bridge instances, false otherwise
     */
    fun isBridgeListEmpty(appId: String): Boolean {
        return getBridgeList(appId).isEmpty()
    }

    fun isBridgeListEmpty(): Boolean {
        return bridgeListMap.isEmpty()
    }

    /**
     * Get the last Bridge instance for a specific MiniProgram
     *
     * @param appId The ID of the MiniProgram
     * @return The last Bridge instance, or null if there are no Bridge instances
     */
    fun getLastBridge(appId: String): Bridge? {
        return getBridgeList(appId).lastOrNull()
    }

    /**
     * Clears all API resources and callbacks for a specific MiniProgram
     *
     * @param appId The ID of the MiniProgram to clear resources for
     */
    fun clear(appId: String) {
        // Clear JsCore for this appId
        jsCoreMap[appId]?.let { jsCore ->
            LogUtils.d(tag, "Destroying JsCore for appId: $appId")
            jsCore.destroy()
            jsCoreMap.remove(appId)
        }

        // Clear Bridge list for this appId
        bridgeListMap.remove(appId)?.let { bridges ->
            LogUtils.d(tag, "Removed ${bridges.size} bridges for appId: $appId")
        }
    }

    /**
     * Clears all API resources and callbacks for all MiniPrograms
     */
    fun clearAll() {
        // Destroy all JsCore instances
        jsCoreMap.forEach { (appId, jsCore) ->
            LogUtils.d(tag, "Destroying JsCore for appId: $appId")
            jsCore.destroy()
        }
        jsCoreMap.clear()

        // Clear all Bridge lists
        bridgeListMap.clear()
        LogUtils.d(tag, "Cleared all Bridge lists")
    }

    fun destroy() {
        // Clear API resources
        apiRegistry.clear()
    }
}

在 MiniApp.kt 注入一个js文件代码,然后将 udpSocket.bind() 转为 udpSocket_bind() 这样的方法调用怎么样

[qq547176052]

@dos1in 给点建议

[dos1in]

@dos1in 给点建议

js api 参考 https://github.com/didi/dimina/blob/main/fe/packages/service/src/api/core/network/websocket/index.js，写在 jssdk 中

[qq547176052]

不太明白这里创建 这个函数有什么作用

[qq547176052]

@dos1in 请教一下

[qq547176052]

我的想法是这样的
小程序 调用 const udpSocket = wx.createUDPSocket(); 原生api无法返回 bind 类型 为函数类型
var bindResult = udpSocket.bind(Number(port)); 所以这个函数没法调用

我就想到 在小程序注入js 实现代理翻译 小程序和原生api 的通讯

[dos1in]

你上面不需要在 android 中注入 js api，只要在jssdk 中声明相关的函数，会自动挂载在 wx 对象上。具体实现写在 android 中就行。

[qq547176052]

你上面不需要在 android 中注入 js api，只要在jssdk 中声明相关的函数，会自动挂载在 wx 对象上。具体实现写在 android 中就行。

在jssdk 中声明 的 aaa函数 在小程序调用 var a = wx.aaa("嘎嘎嘎嘎") 不生效,这是什么问题

[dos1in]

android 中还要 registerWith

[qq547176052]

android 中还要 registerWith

现在是这个不生效

export function aaa(opts) {
    console.log("MiniApp 测试拦截wx.aaa:", opts);
	 invokeAPI('aaa', opts)
     return "MiniApp 测试拦截wx.aaa" + opts;
}

[dos1in]

参考其他 api 实现吧。

[qq547176052]

参考其他 api 实现吧。

现在能绑定端口还有收到消息了 但是我应该怎么将消息 传给 小程序
也就是说 安卓原生api怎么将消息主动发送给小程序

[dos1in]

同步方法返回 SyncResult，异步方法返回 AsyncResult。

[qq547176052]

同步方法返回 SyncResult，异步方法返回 AsyncResult。

你好,请教一下,原生安卓api应该怎么发消息给这个函数