[3.3.0][魔方] 功能代码提交

core/function-impl/mogo-core-function-devatools/build.gradle

@@ -89,6 +89,7 @@ dependencies {
     implementation rootProject.ext.dependencies.androidautoSize
     implementation rootProject.ext.dependencies.koomnative
     implementation rootProject.ext.dependencies.koomxhook
+    implementation rootProject.ext.dependencies.mofang_runtime
     implementation group: "com.tencent.matrix", name: "matrix-android-lib", version: MATRIX_VERSION, changing: true
     implementation group: "com.tencent.matrix", name: "matrix-android-commons", version: MATRIX_VERSION, changing: true
     implementation group: "com.tencent.matrix", name: "matrix-trace-canary", version: MATRIX_VERSION, changing: true

core/function-impl/mogo-core-function-devatools/src/main/java/com/zhjt/mogo_core_function_devatools/DevaToolsProvider.kt

@@ -1,6 +1,7 @@
 package com.zhjt.mogo_core_function_devatools
 
 import android.app.Activity
+import android.app.Application
 import android.content.Context
 import android.view.View
 import android.view.ViewGroup
@@ -19,6 +20,7 @@ import com.mogo.eagle.core.function.api.devatools.IDevaToolsProvider
 import com.mogo.eagle.core.function.api.devatools.apm.*
 import com.mogo.eagle.core.function.api.devatools.strict.*
 import com.mogo.eagle.core.function.api.devatools.download.*
+import com.mogo.eagle.core.function.api.devatools.mofang.*
 import com.mogo.eagle.core.function.api.lookaround.*
 import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger
 import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.w
@@ -44,7 +46,7 @@ import com.zhjt.mogo_core_function_devatools.koom.KoomInitTask
 import com.zhjt.mogo_core_function_devatools.logcatch.MogoLogCatchManager
 import com.zhjt.mogo_core_function_devatools.lookaround.*
 import com.zhjt.mogo_core_function_devatools.matrix.DynamicConfigImpl
-import com.zhjt.mogo_core_function_devatools.mofang.MoFangManager.Companion.moFangManager
+import com.zhjt.mogo_core_function_devatools.mofang.*
 import com.zhjt.mogo_core_function_devatools.monitor.MonitorManager
 import com.zhjt.mogo_core_function_devatools.monitor.db.MonitorDb
 import com.zhjt.mogo_core_function_devatools.monitor.db.MonitorDb.Companion.getDb
@@ -75,6 +77,8 @@ class DevaToolsProvider : IDevaToolsProvider {
 
     private val lookAroundDataProvider by lazy { MoGoLookAroundProviderImpl() }
 
+    private val mofangProvider by lazy { MoGoMoFangProviderImpl() }
+
     @Volatile
     private var mDockerVersion: String? = null
 
@@ -97,7 +101,6 @@ class DevaToolsProvider : IDevaToolsProvider {
 
         //升级(鹰眼/工控)与监控服务
         iPCReportManager.initServer()
-        moFangManager.init(mContext!!)
         BindingCarManager.init(mContext!!)
         apmEnvProvider.init(if(DebugConfig.isDebug()) "0" else "1", "${ DebugConfig.getNetMode() }", mDockerVersion ?: "")
         BadCaseManager.init()
@@ -107,6 +110,9 @@ class DevaToolsProvider : IDevaToolsProvider {
             WeakNetworkStrategy.startListen()
         }
         lookAroundDataProvider.init(mContext!!)
+        (mContext as? Application)?.also {
+            mofangProvider.init(it)
+        }
     }
 
     override fun checkMonitorDb() {
@@ -358,4 +364,6 @@ class DevaToolsProvider : IDevaToolsProvider {
     override fun strict(): IStrictModeProvider = strictModeProvider
 
     override fun lookAroundDataProvider(): IMoGoLookAroundProvider = lookAroundDataProvider
+
+    override fun mofang(): IMoGoMoFangProvider = mofangProvider
 }

core/function-impl/mogo-core-function-devatools/src/main/java/com/zhjt/mogo_core_function_devatools/mofang/MoFangCommandExecutor.kt

@@ -0,0 +1,197 @@
+package com.zhjt.mogo_core_function_devatools.mofang
+
+import android.os.*
+import android.util.*
+import android.view.KeyEvent
+import com.mogo.eagle.core.function.call.autopilot.*
+import com.mogo.eagle.core.network.utils.GsonUtil
+
+internal class MoFangCommandExecutor {
+
+    companion object {
+        private const val TAG = "MoFangCommandExecutor"
+        private const val MSG_WHAT_KEY_CODE_A = 0x01
+        private const val MSG_WHAT_KEY_CODE_BL = 0x02
+        private const val MSG_WHAT_KEY_CODE_C = 0x03
+        private const val MSG_WHAT_KEY_CODE_D = 0x04
+        private const val MSG_WHAT_KEY_CODE_E = 0x05
+        private const val MSG_WHAT_KEY_CODE_EL = 0x06
+        private const val MSG_WHAT_KEY_CODE_AB = 0x07
+    }
+
+    private val handlerCallback = Handler.Callback { msg ->
+        when(msg.what) {
+            MSG_WHAT_KEY_CODE_A, MSG_WHAT_KEY_CODE_AB, MSG_WHAT_KEY_CODE_BL -> {
+                Log.d(TAG, "--- msg: $msg ---")
+                var send = false
+                try {
+                    val acc = msg.obj as? Double
+                    if (acc != null && acc != 0.0) {
+                        send = true
+                        CallerAutoPilotControlManager.sendOperatorSetAcceleratedSpeed(acc)
+                    }
+                } catch (t: Throwable) {
+                    t.printStackTrace()
+                    Log.e(TAG, "error: ${t.message}, msg-> $msg")
+                } finally {
+                    if (send) {
+                        msg.target.sendMessageDelayed(Message.obtain(msg), 500)
+                    }
+                }
+            }
+            MSG_WHAT_KEY_CODE_C, MSG_WHAT_KEY_CODE_D -> {
+                try {
+                    if (msg.arg1 != -1 && msg.arg1 != 1) {
+                        return@Callback true
+                    }
+                    val isLeft = msg.arg1 == -1
+                    if (isLeft) {
+                        Log.d(TAG, "--- 左变道执行了 ----")
+                        CallerAutoPilotControlManager.sendOperatorChangeLaneLeft()
+                    } else {
+                        Log.d(TAG, "--- 右变道执行了 ----")
+                        CallerAutoPilotControlManager.sendOperatorChangeLaneRight()
+                    }
+                } catch (t: Throwable) {
+                    t.printStackTrace()
+                    Log.e(TAG, "error: ${t.message}, msg-> $msg")
+                }
+            }
+            MSG_WHAT_KEY_CODE_E -> {
+                try {
+                    val autoPilotStatusInfo = CallerAutoPilotStatusListenerManager.getAutoPilotStatusInfo()
+                    val parameters = autoPilotStatusInfo.autopilotControlParameters
+                    Log.d(TAG, "--- 启动自驾 ----入参:${GsonUtil.jsonFromObject(parameters)}")
+                    CallerAutoPilotControlManager.startAutoPilot(parameters)
+                } catch (t: Throwable) {
+                    t.printStackTrace()
+                    Log.e(TAG, "error: ${t.message}, msg-> $msg")
+                }
+            }
+            MSG_WHAT_KEY_CODE_EL ->  {
+                var send = false
+                try {
+                    val value = msg.obj as? Double
+                    if (value != null && value != 0.0) {
+                        send = value != 2.0
+                        Log.d(TAG, "--- 长按鸣笛 ---入参:$value")
+                        CallerAutoPilotControlManager.sendOperatorSetHorn(value)
+                    }
+                } catch (t: Throwable) {
+                    t.printStackTrace()
+                    Log.e(TAG, "error: ${t.message}, msg-> $msg")
+                } finally {
+                    if (send) {
+                        msg.target.sendMessageDelayed(Message.obtain(msg).also { it.obj = 2.0 }, 500)
+                    }
+                }
+            }
+        }
+        true
+    }
+
+    private val handler by lazy {
+        HandlerThread("mf-command-executor").let {
+            it.start()
+            Handler(it.looper, handlerCallback)
+        }
+    }
+
+
+    fun handleSingleClick(keycode: Int) {
+        if (keycode == KeyEvent.KEYCODE_A) {
+            Log.d(TAG, "--- 单机键A --- 加速度每隔500ms减少1 ----")
+            handler.removeMessages(MSG_WHAT_KEY_CODE_BL)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_A)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_AB)
+            handler.sendMessage(Message.obtain().also {
+                it.what = MSG_WHAT_KEY_CODE_A
+                it.obj = -1.0
+            })
+        }
+        if (keycode == KeyEvent.KEYCODE_B) {
+            Log.d(TAG, "--- 单机键B --- 复原 ----")
+            handler.removeMessages(MSG_WHAT_KEY_CODE_BL)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_A)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_AB)
+            try {
+                CallerAutoPilotControlManager.sendOperatorSetAcceleratedSpeed(0.0)
+            } catch (t: Throwable) {
+                t.printStackTrace()
+            }
+        }
+
+        if (keycode == KeyEvent.KEYCODE_C) {
+            Log.d(TAG, "--- 单机键C --- 左变道 ----")
+            handler.removeMessages(MSG_WHAT_KEY_CODE_C)
+            handler.sendMessage(Message.obtain().also {
+                it.what = MSG_WHAT_KEY_CODE_C
+                it.arg1 = -1
+            })
+        }
+
+        if (keycode == KeyEvent.KEYCODE_D) {
+            Log.d(TAG, "--- 单机键D --- 右变道 ----")
+            handler.removeMessages(MSG_WHAT_KEY_CODE_D)
+            handler.sendMessage(Message.obtain().also {
+                it.what = MSG_WHAT_KEY_CODE_D
+                it.arg1 = 1
+            })
+        }
+
+        if (keycode == KeyEvent.KEYCODE_E) {
+            Log.d(TAG, "--- 单机键E --- 启动自驾 ----")
+            handler.removeMessages(MSG_WHAT_KEY_CODE_E)
+            handler.sendMessage(Message.obtain().also {
+                it.what = MSG_WHAT_KEY_CODE_E
+            })
+        }
+
+    }
+
+    fun handleLongClick(keyCode: Int) {
+        if (keyCode == KeyEvent.KEYCODE_E) {
+            Log.d(TAG, "--- 长按键E --- 鸣笛 ----")
+            handler.removeMessages(MSG_WHAT_KEY_CODE_EL)
+            handler.sendMessage(Message.obtain().also {
+                it.what = MSG_WHAT_KEY_CODE_EL
+                it.obj = 1.0
+            })
+        }
+        if (keyCode == KeyEvent.KEYCODE_B) {
+            Log.d(TAG, "--- 长按键B --- 加速度加1 ----")
+            handler.removeMessages(MSG_WHAT_KEY_CODE_BL)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_A)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_AB)
+            handler.sendMessage(Message.obtain().also {
+                it.what = MSG_WHAT_KEY_CODE_BL
+                it.obj = 1.0
+            })
+        }
+    }
+
+    fun handleCombineClick(vararg keyCodes: Int) {
+        if (isCombineEqual(KeyEvent.KEYCODE_A, KeyEvent.KEYCODE_B, *keyCodes)) {
+            //AB组合键，加速度每隔500毫秒，减小2
+            Log.d(TAG, "---- 组合键AB ---- 按下，加速度每隔500毫秒，减小2 ---")
+            handler.removeCallbacksAndMessages(null)
+            handler.sendMessage(Message.obtain().also {
+                it.what =  MSG_WHAT_KEY_CODE_AB
+                it.obj = -2.0
+            })
+
+        }
+    }
+
+    private fun isCombineEqual(key1: Int, key2: Int, vararg keyCodes: Int): Boolean {
+        if (keyCodes.size < 2) {
+            return false
+        }
+        val k1 = keyCodes[0]
+        val k2 = keyCodes[1]
+        if ((k1 == key1 && k2 == key2) || (k1 == key2 && k2 == key1)) {
+            return true
+        }
+        return false
+    }
+}

core/function-impl/mogo-core-function-devatools/src/main/java/com/zhjt/mogo_core_function_devatools/mofang/MoFangManager.kt

@@ -1,353 +0,0 @@
-package com.zhjt.mogo_core_function_devatools.mofang
-
-import android.annotation.SuppressLint
-import android.bluetooth.BluetoothAdapter
-import android.bluetooth.BluetoothDevice
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.view.KeyEvent
-import com.mogo.eagle.core.data.config.HmiBuildConfig
-import com.mogo.eagle.core.data.deva.mofang.MfConstants
-import com.mogo.eagle.core.function.api.devatools.mofang.IMoGoMoFangListener
-import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotControlManager.sendOperatorChangeLaneLeft
-import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotControlManager.sendOperatorChangeLaneRight
-import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotControlManager.sendOperatorSetAcceleratedSpeed
-import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotControlManager.sendOperatorSetHorn
-import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotControlManager.startAutoPilot
-import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager.getAutoPilotStatusInfo
-import com.mogo.eagle.core.function.call.devatools.CallerDevaToolsListenerManager.invokeMoFangStatus
-import com.mogo.eagle.core.function.call.mofang.CallerMofangListenerManager
-import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.d
-import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.e
-import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.Companion.M_F
-import com.mogo.eagle.core.utilcode.mogo.storage.SharedPrefsMgr
-import com.mogo.eagle.core.utilcode.util.ToastUtils
-import com.mogo.eagle.core.utilcode.util.UiThreadHandler
-import java.util.*
-
-
-/**
- * 魔方连接状态和设备管理
- */
-@SuppressLint("StaticFieldLeak")
-class MoFangManager private constructor() : IMoGoMoFangListener {
-
-    companion object {
-        val moFangManager: MoFangManager by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
-            MoFangManager()
-        }
-    }
-
-    private var mContext: Context? = null
-    private val TAG = "MoFangManager"
-    private lateinit var mBluetoothAdapter: BluetoothAdapter
-    private var isMfConnect: Boolean = false //添加状态判断
-
-    private var startPressTime: Long = 0 //开始按键时间
-    private var isPressEnd = false //按键是否结束
-    @Volatile
-    private var isCombinationKey = 0 //是否是组合按键 1单击，2长按，3组合
-    private var pressADownTime: Long = 0
-    private var pressAUpTime: Long = 0
-    private var pressBDownTime: Long = 0
-    private var pressBUpTime: Long = 0
-    private var pressCDownTime: Long = 0
-    private var pressCUpTime: Long = 0
-    private var pressDDownTime: Long = 0
-    private var pressDUpTime: Long = 0
-    private var pressEDownTime: Long = 0
-    private var pressEUpTime: Long = 0
-
-    private val clickTime = 300 //单击
-    private val clickTimeInterval = 330
-    private val longPressTime = 670
-    private val longPressTimeInterval = 700
-    private var timerHorn: Timer? = null
-    private var timerAcc: Timer? = null
-
-
-    fun init(context: Context) {
-        mContext = context
-        initBluetooth(context)
-        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
-        if (!mBluetoothAdapter.isEnabled) {
-            mBluetoothAdapter.enable()
-        }
-        mBluetoothAdapter.startDiscovery()
-        showBondedDevice(mBluetoothAdapter)
-
-        CallerMofangListenerManager.addListener(TAG, this)
-    }
-
-    fun release() {
-        CallerMofangListenerManager.removeListener(TAG)
-    }
-
-    /**
-     * 初始化蓝牙广播
-     */
-    private fun initBluetooth(context: Context) {
-        val intentFilter = IntentFilter();
-        // 监视蓝牙关闭和打开的状态
-        intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED)
-        // 监视蓝牙设备与APP连接的状态
-        intentFilter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED)
-        intentFilter.addAction(BluetoothDevice.ACTION_ACL_CONNECTED)
-        // 注册广播
-        context.registerReceiver(bluetoothMonitorReceiver, intentFilter)
-    }
-
-    /**
-     * 查找蓝牙连接过的蓝牙设备
-     */
-    private fun showBondedDevice(bluetoothAdapter: BluetoothAdapter) {
-        if (bluetoothAdapter != null) {
-            val deviceList = bluetoothAdapter.bondedDevices
-            for (device in deviceList) {
-                try {
-                    //使用反射调用获取设备连接状态方
-                    val isConnectedMethod = BluetoothDevice::class.java.getDeclaredMethod("isConnected")
-                    isConnectedMethod.isAccessible = true
-                    val isConnected = isConnectedMethod.invoke(device) as Boolean
-                    d("$M_F${TAG}"," showBondedDevice name = ${device.name} ---address = ${device.address}----isMfConnect = $isMfConnect ---isConnected = $isConnected")
-                    if (device.name == "MINI_KEYBOARD") { //并且连接
-                        mContext?.let { SharedPrefsMgr.getInstance(it).putString(MfConstants.BLUETOOTH_NAME, device.name) }
-                        UiThreadHandler.postDelayed({
-                            invokeMoFangStatus(isConnected)
-                        }, 1000)
-                    }
-
-                    mContext?.let { SharedPrefsMgr.getInstance(it).putBoolean(MfConstants.BLUETOOTH_STATUS, isConnected) }
-                    if (isConnected) {
-                        isMfConnect = true
-                    }
-                } catch (e: NoSuchMethodException) {
-                    e.printStackTrace()
-                }
-            }
-        }
-    }
-
-
-    private val bluetoothMonitorReceiver: BroadcastReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context, intent: Intent) {
-            when (intent.action) {
-                BluetoothAdapter.ACTION_STATE_CHANGED -> { //中间状态
-                    d("$M_F${TAG}","bluetoothMonitorReceiver ACTION_STATE_CHANGED  action = ${intent.action}")
-                }
-
-                BluetoothDevice.ACTION_ACL_CONNECTED -> { //蓝牙设备已连接
-                    if (!isMfConnect) {
-//                        showBondedDevice(mBluetoothAdapter)
-                        invokeMoFangStatus(true)
-                        isMfConnect = true
-                        mContext?.let { SharedPrefsMgr.getInstance(it).putBoolean(MfConstants.BLUETOOTH_STATUS, true) }
-                    }
-                    d("$M_F${TAG}","bluetoothMonitorReceiver  ACTION_ACL_CONNECTED ----- isMfConnect = $isMfConnect")
-                }
-
-                BluetoothDevice.ACTION_ACL_DISCONNECTED -> { //蓝牙设备已断开 主动更新
-                    d("$M_F${TAG}","bluetoothMonitorReceiver  ACTION_ACL_DISCONNECTED ----- isMfConnect = $isMfConnect ")
-                    if (isMfConnect) {
-                        invokeMoFangStatus(false)
-                        isMfConnect = false
-                        mContext?.let { SharedPrefsMgr.getInstance(it).putBoolean(MfConstants.BLUETOOTH_STATUS, false) }
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * 魔方按键处理
-     */
-    override fun onMofangHandle(keyCode: Int, action: Int): Boolean {
-        if(mContext == null){
-            return false
-        }
-        val bluetoothName = SharedPrefsMgr.getInstance(mContext!!).getString(
-            MfConstants.BLUETOOTH_NAME)
-        if (bluetoothName == "MINI_KEYBOARD") {
-            if (!isPressEnd) {
-                isPressEnd = true
-                startPressTime = System.currentTimeMillis()
-            }
-            e(M_F + "MoFangManager",
-                "dispatchKeyEvent ------ bluetoothName = $bluetoothName ---code = $keyCode -----action = $action ---HmiBuildConfig.isShowMfToastView = ${HmiBuildConfig.isShowMfToastView}")
-            if (keyCode == KeyEvent.KEYCODE_A) { //单击 -1，长按无操作，AB组合-2
-                if (action == KeyEvent.ACTION_DOWN) {
-                    pressADownTime = System.currentTimeMillis()
-                    d(M_F + "MoFangManager",
-                        "dispatchKeyEvent A down pressADownTime = " + pressADownTime + "---" + (pressADownTime - startPressTime) + "----isCombinationKey = " + isCombinationKey + "--pressBDownTime = " + pressBDownTime)
-                    if (pressADownTime - startPressTime in (clickTimeInterval + 1) until longPressTime && pressBDownTime > 0) {
-                        if (HmiBuildConfig.isShowMfToastView) {
-                            ToastUtils.showShort("方块 A 按AB组合 +1 timeInterval: ${pressADownTime - startPressTime}ms---$pressBDownTime")
-                        }
-                        sendAcc(true, +1.0)
-                        isCombinationKey = 3
-                    }
-                    if (isCombinationKey != 3 && isCombinationKey != 1) {
-                        if (pressADownTime - startPressTime > longPressTimeInterval) {
-                            if (HmiBuildConfig.isShowMfToastView) {
-                                ToastUtils.showShort("方块 长按A -2 timeInterval: ${pressADownTime - startPressTime}ms")
-                            }
-                            sendAcc(true, -2.0)
-                            isCombinationKey = 2
-                        }
-                    }
-                } else if (action == KeyEvent.ACTION_UP) {
-                    pressAUpTime = System.currentTimeMillis()
-                    d(M_F + "MoFangManager",
-                        "dispatchKeyEvent A up    pressAUpTime = " + pressAUpTime + "---" + (pressAUpTime - startPressTime) + "--pressBDownTime = " + pressBDownTime + "---isCombinationKey = $isCombinationKey")
-                    if (pressAUpTime - startPressTime < clickTime && isCombinationKey != 3) {
-                        isCombinationKey = 1
-                        if (HmiBuildConfig.isShowMfToastView) {
-                            ToastUtils.showShort("方块 单击A -1 timeInterval: ${pressAUpTime - startPressTime}ms")
-                        }
-                        sendAcc(true, -1.0)
-                    }
-                    pressADownTime = 0
-                    isPressEnd = false
-                    UiThreadHandler.postDelayed({ isCombinationKey = 0 }, 300)
-                }
-            } else if (keyCode == KeyEvent.KEYCODE_B) { //单击复原，长按+1，AB组合-2
-                if (action == KeyEvent.ACTION_DOWN) {
-                    pressBDownTime = System.currentTimeMillis()
-                    d(M_F + "MoFangManager",
-                        "dispatchKeyEvent B down pressBDownTime = " + pressBDownTime + "--差-" + (pressBDownTime - startPressTime) + "---isCombinationKey = " + isCombinationKey + "--pressADownTime = " + pressADownTime
-                    )
-                    if (pressBDownTime - startPressTime > clickTimeInterval && pressBDownTime - startPressTime < longPressTime && pressADownTime > 0) {
-                        if (HmiBuildConfig.isShowMfToastView) {
-                            ToastUtils.showShort("方块 B 按AB组合 +1 timeInterval: ${pressBDownTime - startPressTime}ms ---pressADownTime = $pressADownTime ")
-                        }
-                        sendAcc(true, +1.0)
-                        isCombinationKey = 3
-                    }
-                    if (isCombinationKey != 3 && isCombinationKey != 1) {
-                        if (pressBDownTime - startPressTime > longPressTimeInterval) {
-                            if (HmiBuildConfig.isShowMfToastView) {
-                                ToastUtils.showShort("方块 长按B 无操作 timeInterval: ${pressBDownTime - startPressTime}ms")
-                            }
-                            isCombinationKey = 2
-                        }
-                    }
-                } else if (action == KeyEvent.ACTION_UP) {
-                    pressBUpTime = System.currentTimeMillis()
-                    d(M_F + "MoFangManager",
-                        "dispatchKeyEvent B up   pressBUpTime = " + pressBUpTime + "--差-" + (pressBUpTime - startPressTime) + "--pressADownTime = " + pressADownTime + "----isCombinationKey = $isCombinationKey")
-                    if (pressBUpTime - startPressTime < clickTime && isCombinationKey != 3) {
-                        if (HmiBuildConfig.isShowMfToastView) {
-                            ToastUtils.showShort("方块 单击B  0  timeInterval: ${pressBUpTime - startPressTime}ms")
-                        }
-                        sendAcc(false, 0.0)
-                        isCombinationKey = 1
-                    }
-                    pressBDownTime = 0
-                    isPressEnd = false
-                    UiThreadHandler.postDelayed({ isCombinationKey = 0 }, 300)
-                }
-            } else if (keyCode == KeyEvent.KEYCODE_C) { //单击左变道，长按无操作
-                if (action == KeyEvent.ACTION_DOWN) {
-                    pressCDownTime = System.currentTimeMillis()
-                    d(M_F + "MoFangManager",
-                        "dispatchKeyEvent 方块 长按C 无操作 time dif = " + (pressCDownTime - startPressTime))
-                    if (pressCDownTime - startPressTime > longPressTimeInterval) {
-                        if (HmiBuildConfig.isShowMfToastView) {
-                            ToastUtils.showShort("方块 长按C 无操作 timeInterval: ${pressCDownTime - startPressTime}ms")
-                        }
-                    }
-                } else if (action == KeyEvent.ACTION_UP) {
-                    pressCUpTime = System.currentTimeMillis()
-                    isPressEnd = false
-                    d(M_F + "MoFangManager",
-                        "dispatchKeyEvent 方块 单击C ← 向左变道 time dif = " + (pressCUpTime - startPressTime))
-                    if (pressCUpTime - startPressTime < clickTime) {
-                        if (HmiBuildConfig.isShowMfToastView) {
-                            ToastUtils.showShort("方块 单击C ← 向左变道 timeInterval: ${pressCUpTime - startPressTime}ms")
-                        }
-                        sendOperatorChangeLaneLeft()
-                    }
-                }
-            } else if (keyCode == KeyEvent.KEYCODE_D) { //单击向右变道，双击无操作
-                if (action == KeyEvent.ACTION_DOWN) {
-                    pressDDownTime = System.currentTimeMillis()
-                    d(M_F + "MoFangManager",
-                        "dispatchKeyEvent 方块 长按D 无操作 time dif = " + (pressDDownTime - startPressTime))
-                    if (pressDDownTime - startPressTime > longPressTimeInterval) {
-                        if (HmiBuildConfig.isShowMfToastView) {
-                            ToastUtils.showShort("方块 长按D 无操作 timeInterval: ${pressDDownTime - startPressTime}ms")
-                        }
-                    }
-                } else if (action == KeyEvent.ACTION_UP) {
-                    pressDUpTime = System.currentTimeMillis()
-                    isPressEnd = false
-                    d(M_F + "MoFangManager",
-                        "dispatchKeyEvent 方块 单击D → 向右变道 time dif = " + (pressDUpTime - startPressTime))
-                    if (pressDUpTime - startPressTime < clickTime) {
-                        if (HmiBuildConfig.isShowMfToastView) {
-                            ToastUtils.showShort("方块 单击D → 向右变道 timeInterval: ${pressDUpTime - startPressTime}ms")
-                        }
-                        sendOperatorChangeLaneRight()
-                    }
-                }
-            } else if (keyCode == KeyEvent.KEYCODE_E) { //单击启动自驾，长按鸣笛
-                if (action == KeyEvent.ACTION_DOWN) {
-                    pressEDownTime = System.currentTimeMillis()
-                    d(M_F + "MoFangManager",
-                        "dispatchKeyEvent 方块 长按E 鸣笛 time dif = " + (pressEDownTime - startPressTime))
-                    if (pressEDownTime - startPressTime > longPressTimeInterval) {
-                        if (HmiBuildConfig.isShowMfToastView) {
-                            ToastUtils.showShort("方块 长按E 鸣笛 timeInterval: ${pressEDownTime - startPressTime}ms")
-                        }
-                        sendOperatorSetHorn(1.0)
-                        if (timerHorn == null) {
-                            timerHorn = Timer()
-                        }
-                        timerHorn!!.schedule(object : TimerTask() {
-                            override fun run() {
-                                sendOperatorSetHorn(2.0)
-                                timerHorn = null
-                            }
-                        }, 500)
-                    }
-                } else if (action == KeyEvent.ACTION_UP) {
-                    pressEUpTime = System.currentTimeMillis()
-                    isPressEnd = false
-                    d(M_F + "MoFangManager",
-                        "方块 单击E 开启自动驾驶 time dif = " + (pressEUpTime - startPressTime))
-                    if (pressEUpTime - startPressTime < clickTime) {
-                        if (HmiBuildConfig.isShowMfToastView) {
-                            ToastUtils.showShort("方块 单击E 开启自动驾驶 timeInterval: ${pressEUpTime - startPressTime}ms")
-                        }
-                        startAutoPilot(getAutoPilotStatusInfo().autopilotControlParameters)
-                    }
-                }
-            }
-        }
-        return false
-    }
-
-    @Synchronized
-    private fun sendAcc(isSend: Boolean, acc: Double) {
-        if (isSend) {
-            if (timerAcc == null) {
-                timerAcc = Timer()
-                timerAcc!!.schedule(object : TimerTask() {
-                    override fun run() {
-                        sendOperatorSetAcceleratedSpeed(acc)
-                    }
-                }, 0, 500)
-            }
-        } else {
-            if (timerAcc != null) {
-                timerAcc!!.cancel()
-                timerAcc = null
-            }
-            sendOperatorSetAcceleratedSpeed(acc)
-        }
-    }
-
-}
-

core/function-impl/mogo-core-function-devatools/src/main/java/com/zhjt/mogo_core_function_devatools/mofang/MoGoMoFangProviderImpl.kt

@@ -0,0 +1,153 @@
+package com.zhjt.mogo_core_function_devatools.mofang
+
+import android.app.*
+import android.bluetooth.*
+import android.util.*
+import android.view.*
+import android.view.Window.Callback
+import android.widget.Toast
+import com.mogo.core.mofang.connect.MoFangManager
+import com.mogo.core.mofang.connect.device.*
+import com.mogo.core.mofang.connect.listener.*
+import com.mogo.eagle.core.function.api.devatools.mofang.*
+import com.mogo.eagle.core.function.api.devatools.mofang.IMoGoMoFangProvider.OnMoFangStatusListener
+import com.mogo.eagle.core.utilcode.util.UiThreadHandler
+import com.mogo.eagle.core.utilcode.util.Utils
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicInteger
+
+internal class MoGoMoFangProviderImpl: IMoGoMoFangProvider, OnMoFangDeviceListener {
+
+    companion object {
+        private const val TAG = "MoGoMoFangProviderImpl"
+    }
+
+    private val battery by lazy { AtomicInteger(0) }
+
+    private val listeners by lazy { ConcurrentHashMap<String, OnMoFangStatusListener>() }
+
+    private val executor by lazy { MoFangCommandExecutor() }
+
+    override fun init(app: Application) {
+        MoFangManager.init(MoFangDevice.Builder().application(app).listener(this))
+    }
+
+    override fun connect() {
+        MoFangManager.connect()
+    }
+
+    override fun disconnect() {
+        MoFangManager.disconnect()
+    }
+
+    override fun isConnected(): Boolean {
+        return MoFangManager.isConnected()
+    }
+
+    override fun provideWindowCallback(delegate: Callback?): Callback {
+        val ret = MoFangManager.providerWindowCallback()
+        ret.setDelegate(delegate)
+        return ret
+    }
+
+    override fun registerMoFangStatusListener(tag: String, listener: OnMoFangStatusListener) {
+        listeners[tag] = listener
+    }
+
+    override fun unRegisterMoFangStatusListener(listener: OnMoFangStatusListener) {
+        listeners.entries.find { it.value == listener }?.also { listeners.remove(it.key) }
+    }
+
+    override fun onBluetoothBatteryChanged(battery: Int) {
+        if (this.battery.get() != battery) {
+            UiThreadHandler.post {
+                listeners.values.forEach {
+                    it.onMoFangBatteryChanged(battery)
+                }
+            }
+            this.battery.set(battery)
+        }
+    }
+
+    override fun onBluetoothConnected(device: BluetoothDevice?) {
+        UiThreadHandler.post {
+            listeners.values.forEach {
+                it.onMoFangConnected()
+            }
+        }
+    }
+
+    override fun onBluetoothDisconnected(device: BluetoothDevice?, systemOff: Boolean) {
+        UiThreadHandler.post {
+            listeners.values.forEach {
+                it.onMoFangDisconnected()
+            }
+        }
+    }
+
+    override fun onBluetoothKeyBoardCombineClicked(vararg keyCodes: Int) {
+        try {
+            executor.handleCombineClick(*keyCodes)
+        } finally {
+            UiThreadHandler.post { listeners.values.forEach {
+                it.onMoFangCombineClicked(*keyCodes)
+            } }
+
+        }
+
+    }
+
+    override fun onBluetoothKeyBoardLongClicked(keyCode: Int) {
+        try {
+            executor.handleLongClick(keyCode)
+        } finally {
+            UiThreadHandler.post {
+                listeners.values.forEach {
+                    it.onMoFangLongClicked(keyCode)
+                }
+            }
+        }
+    }
+
+    override fun onBluetoothKeyboardClicked(keyCode: Int) {
+        try {
+            executor.handleSingleClick(keyCode)
+        } finally {
+            UiThreadHandler.post {
+                listeners.values.forEach {
+                    it.onMoFangClicked(keyCode)
+                }
+            }
+        }
+    }
+
+    override fun onBluetoothKeyboardEvent(event: KeyEvent) { }
+
+    override fun onBluetoothKeyboardInputInvalid() {
+        Log.d(TAG, "--- onBluetoothKeyboardInputInvalid ---")
+        UiThreadHandler.post {
+            listeners.values.forEach {
+                it.onMoFangStatusError("检测到鹰眼未处于前台, 魔方指令暂不能使用, 请将鹰眼切换到前台运行...")
+            }
+        }
+    }
+
+    override fun onBluetoothKeyboardInputValid() {
+        Log.d(TAG, "--- onBluetoothKeyboardInputValid ---")
+    }
+
+    override fun onBluetoothOpenAgreed() {
+        Log.d(TAG, "--- onBluetoothOpenAgreed ---")
+    }
+
+    override fun onBluetoothOpenDenied() {
+        Log.d(TAG, "--- onBluetoothOpenDenied ---")
+    }
+
+    override fun onBluetoothSettingRequest() {
+        Log.d(TAG, "--- onBluetoothSettingRequest ---")
+        UiThreadHandler.post {
+            Toast.makeText(Utils.getApp(), "检测到魔方未正确连接，请在系统蓝牙设置页面，找到魔方并配对连接...", Toast.LENGTH_SHORT).show()
+        }
+    }
+}