主界面与设备连接交互

@Entry
@Component
struct MainPage {
  @State currentIndex: number = BottomTab.CONNECT; //当前索引的初始化的值
  private lastClickTime = 0;
  private tabsController: TabsController = new TabsController()
  ...
  build() {
    Stack() {
      Tabs({ barPosition: BarPosition.End, controller: this.tabsController }) {
        TabContent() {
          ConnectView().width('100%').height('100%')
        }
        .tabBar(this.TabBuilder($r('app.string.connect'), BottomTab.CONNECT, $r('app.media.bt_sel'),
          $r('app.media.bt_nol')))

        TabContent() {
          UpgradeView().width('100%').height('100%')
        }
        .tabBar(this.TabBuilder($r('app.string.upgrade'), BottomTab.UPGRADE, $r('app.media.update_sel'),
          $r('app.media.update_nol')))

        TabContent() {
          SettingsView({ isShow: this.currentIndex == BottomTab.SETTINGS })
            .width('100%')
            .height('100%')
            .backgroundColor($r('app.color.white_secondary'))
        }
        .tabBar(this.TabBuilder($r('app.string.settings'), BottomTab.SETTINGS, $r('app.media.setting_sel'),
          $r('app.media.setting_nol')))
      }
      ...
      .onChange((index: number) => {
        this.currentIndex = index;
      })
    }
  }

  @Builder
  TabBuilder(titleRes: Resource, targetIndex: number, selectedImg: Resource, normalImg: Resource) {
    Column() {
      Image(this.currentIndex === targetIndex ? selectedImg : normalImg)
        .size({ width: 28, height: 28 })
      Text(titleRes)
        .fontColor(this.currentIndex === targetIndex ? $r('app.color.blue') : '#808080')
        .fontSize(10)
    }
    ...
    .onClick(() => {
      this.tryToChangeTab(targetIndex);
    })
  }

  private tryToChangeTab(targetIndex: number) {
    this.currentIndex = targetIndex;
    this.tabsController.changeIndex(targetIndex);
  }

  aboutToAppear(): void {
    getContext(this).eventHub.on(ConnectView.EVENT_CHANGE_TAB, () => {
      this.tryToChangeTab(BottomTab.UPGRADE)
    })
    this.otaWrapperListener.onMandatoryUpgrade = (device) => {
      if (!bluetoothOTAManager.getOTAWrapper()?.isOTA()) {
        this.mandatoryUpdateDialogController.open()
      }
    }
    bluetoothOTAManager.getOTAWrapper()?.registerRcspCallback(this.otaWrapperListener)
    ToolsUtil.setWindowKeepScreenOn(true, getContext())
  }

  aboutToDisappear(): void {
    getContext(this).eventHub.off(ConnectView.EVENT_CHANGE_TAB)
  }

  onBackPress(): boolean | void {
    const currTime = systemDateTime.getTime()
    if (currTime - this.lastClickTime > 1200) {
      this.lastClickTime = currTime
      promptAction.showToast({ message: $r('app.string.double_click_to_exit'), duration: 1500, alignment: Alignment.Center })
    } else {
      (getContext(this) as common.UIAbilityContext)?.terminateSelf()
      return false
    }
    return true
  }

  private mandatoryUpdateDialogController: CustomDialogController = new CustomDialogController({
    autoCancel: false,
    onWillDismiss: () => {
    },
    builder: CustomContentDialog({
      primaryTitle: $r('app.string.tips'),
      contentBuilder: () => {
        this.buildMandatoryTips();
      },
      buttons: [{
        value: $r('app.string.confirm'), role: ButtonRole.ERROR, action: () => {
          getContext(this).eventHub.emit(ConnectView.EVENT_CHANGE_TAB)
        }
      }],
    }),
  });

  private onBleFoundDevice = (findDevs: BluetoothDevice[]) => {
    if (bluetoothInstance.communicationWay == "EDR") {
      return
    }
    this.findDeviceList = new Array<BluetoothDevice>()
    this.findDeviceList.push(...this.connectedDeviceList)
    let tempList = findDevs.sort((a, b) => {
      const bRssi = b.rssi ?? 0
      const aRssi = a.rssi ?? 0
      return bRssi - aRssi
    })
    tempList =
      tempList.filter(e => this.connectedDeviceList.findIndex(connectedDev => connectedDev.deviceId === e.deviceId) ==
        -1)
    this.findDeviceList.push(...tempList)
    const str = this.displayFilter
    if (str) {
      this.deviceList = this.findDeviceList.filter(e => e.deviceName?.includes(str))
    } else {
      this.deviceList =
        this.findDeviceList.filter(e => e.isSystemConnected ||
          (e.deviceName != undefined && e.deviceName.length != 0))
    }
  }

  private onBleScanStateChange = (scanState: ScanStateInfo) => {
    if (bluetoothInstance.communicationWay == "EDR") {
      return
    }
    switch (scanState.state) {
      case ScanState.SCAN_STATE_FINISH:
        this.isRefreshing = false
        break;
      case ScanState.SCAN_STATE_START:
        break;
      case ScanState.SCAN_STATE_FAILED:
        this.isRefreshing = false
        if (scanState.error?.code == 2900003) { //蓝牙不可用
          promptAction.showToast({ message: $r('app.string.bluetooth_disabled'), duration: 500 })
        }
        break;
    }
  }

  private filterDialogController: CustomDialogController = new CustomDialogController({
    cornerRadius: 12,
    autoCancel: false,
    alignment: DialogAlignment.Center,
    builder: CustomContentDialog({
      contentBuilder: () => this.buildSearchFilter(),
      buttons: [{
        value: $r('app.string.cancel'), fontColor: $r('app.color.black'), action: () => {
          this.inputFilter = this.displayFilter // cancel and reset
        }
      }, {
        value: $r('app.string.confirm'), action: () => {
          let tmp = this.inputFilter
          this.displayFilter = tmp
          this.appSettings.filter = tmp
          PreferencesHelper.getInstance().putValue(PreferenceKey.APP_SETTINGS, this.appSettings)
        }
      }],
    }),
  });

  public init() {
    //蓝牙 初始化
    this.initBluetooth()
    //OTAWrapper 初始化
    this.initRcsp()
  }

  private initBluetooth() {

    this.bluetoothInstance.bleImpl.on(ScanEventType.SCAN_STATE_CHANGE, this.scanStateCallbackFun)
    this.bluetoothInstance.bleImpl.on(ScanEventType.SCAN_DEVICE_FIND, this.deviceFindCallbackFun)
    this.bluetoothInstance.bleImpl.on(BaseConnectEventTypeConstant.CONNECT_STATE_CHANGE, this.connectStateCallbackFun)
    this.bluetoothInstance.bleImpl.on(BleConnectEventTypeConstant.CONNECT_BLE_CHARACTERISTIC_CHANGE,
      this.characteristicInfoCallbackFun)

    this.bluetoothInstance.sppImpl.on(BaseConnectEventTypeConstant.CONNECT_STATE_CHANGE, this.connectStateCallbackFun)
    this.bluetoothInstance.sppImpl.on(SppConnectEventTypeConstant.CONNECT_DATA_READ_CHANGE,
      this.sppDataReadInfoCallbackFun)
  }

  private initRcsp() {
    this.otaWrapperOption = {
      /**是否需要认证**/
      isUseAuth: (): boolean => {
        return true
      },
      isInnerReconnect: () => {
        return true
      },
      /**扫描设备**/
      sanDevice: () => {
        //升级成功-扫描的是平时设备。升级中 -扫描的是BLE设备
        this.bluetoothInstance.startScan(10 * 1000, "BLE")
        if (this.bluetoothInstance.communicationWay == "EDR") {
          this.bluetoothInstance.startScan(10 * 1000, "EDR")
        }
      },
      /**连接设备**/
      connectDevice: (device: OTADevice) => {
        //目前回连只有BLE设备
        const isBle = true
        const deviceId = device.deviceId
        if (isBle) {
          this.bluetoothInstance.connect(new BleDevice(deviceId))
        } else {
          this.bluetoothInstance.connect(new SppDevice(deviceId))
        }
      },
      /**断开设备**/
      disconnectDevice: (device: OTADevice) => {
        // 此处需判断设备类型
        const isBle =
          this.bluetoothInstance.bleImpl.getConnectedDevice().findIndex(item => item.deviceId == device.deviceId) != -1
        const deviceId = device.deviceId
        if (isBle) {
          this.bluetoothInstance.disconnect(new BleDevice(deviceId))
        } else {
          this.bluetoothInstance.disconnect(new SppDevice(deviceId))
        }
      },
      /**发送数据**/
      sendData: (device: OTADevice, data: Uint8Array) => {
        // 此处需判断设备类型
        const isBle =
          this.bluetoothInstance.bleImpl.getConnectedDevice().findIndex(item => item.deviceId == device.deviceId) != -1
        const deviceId = device.deviceId
        if (isBle) {
          this.bluetoothInstance.bleImpl.sendData(new BleDevice(deviceId), RCSP_UUID_SERVICE, RCSP_UUID_WRITE, data)
        } else {
          this.bluetoothInstance.sppImpl.sendData(new SppDevice(deviceId), RCSP_SOCKET_UUID, data)
        }
      }
    }
    this.otaWrapper = new OTAWrapper(this.otaWrapperOption)
  }

  public startOTA(deviceId: string, otaCallback: OTAUpgradeCallback) {
    const otaConfig: JL_OTA.OtaConfig = new JL_OTA.OtaConfig()
    otaConfig.isSupportNewRebootWay = true //支持新回连方式
    const tempOtaUpgradeCallback: OTAUpgradeCallback = {
      onStartOTA: () => {
        otaCallback.onStartOTA()
      },
      onExecuteDisconnectDevice: (): void => {
        otaCallback.onExecuteDisconnectDevice()
      },
      onNeedReconnect: (reConnectMsg: JL_OTA.ReconnectInfo, reconnectCallback: JL_OTA.OnResultCallback<string>) => {
        /**  note： 如果需要使用自定义回连方式，请在此处实现。下面是实现的参考方式。
         *  连接成功时，调用 reconnectCallback.onResult(device.deviceId);通知SDK 设备的新的deviceId。
         * **/
        otaCallback.onNeedReconnect(reConnectMsg,reconnectCallback)
        if (this.otaWrapperOption?.isInnerReconnect()==false) {//使用自定义回连方式，不使用sdk内部回连方式
          const oldDeviceMac = reConnectMsg.deviceBleMac?.toUpperCase().replace(/:/g, "");
          const oldDeviceMacReverse = oldDeviceMac?.split('')?.reverse()?.join(''); //mac反转
          const oldDeviceMacPrefix = oldDeviceMac?.substring(0, 10);
          ...
          const op: ReconnectOp = {
            startScanDevice: () => {
              this.otaWrapperOption?.sanDevice()
            },
            isReconnectDevice: (scanDevice: BluetoothDevice) => {//判断设备是不是目标回连设备
              ...
              if (reConnectMsg.isSupportNewReconnectADV) { //使用新回连方式，需要通过rcsp协议获取到设备的ble地址
                ...
                const index = advertiseStr.indexOf("D60541544F4C4A");
                if (index != -1 && scanDevice.advertiseData) {
                  const unit8Array = new Uint8Array(scanDevice.advertiseData);
                  const macArray = unit8Array.slice((index / 2) + 8, (index / 2) + 14).reverse();
                  result = oldDeviceMac == JL_OTA.toHexString(macArray).toUpperCase();
                }
                ...
              } else { //旧回连方式，deviceId相同即可
                if (deviceId != undefined) {
                  if (deviceId == scanDevice.deviceId) {
                    result = true;
                  }
                  ...
                }
              }
              return result;
            },
            connectDevice: (device: BluetoothDevice) => {
              this.otaWrapperOption?.connectDevice(device)
            }
          };
          const callback: ReconnectCallback = {
            onReconnectSuccess: (device: BluetoothDevice) => {
              Log.i(TAG, "onReconnectSuccess : " + device);
              this._ReconnectMap.delete(deviceId);
              reconnectCallback.onResult(device.deviceId);
            },
            onReconnectFailed: () => {
              Log.i(TAG, "onReconnectFailed : ");
              this._ReconnectMap.delete(deviceId);
              reconnectCallback.onError(JL_OTA.OtaError.ERR_OTA_RECONNECT_DEVICE_TIMEOUT,
                JL_OTA.OtaError.getErrorDesc(JL_OTA.OtaError.ERR_OTA_RECONNECT_DEVICE_TIMEOUT, ""));
            },
            onDeviceConnectFailed: (_dev) => {
              this.otaWrapperOption?.sanDevice()
            },
            onDeviceConnectDisconnected: (dev) => {
              this.otaWrapperOption?.sanDevice()
            }
          };
          const reconnect = new Reconnect(op, callback);
          this._ReconnectMap.set(deviceId, reconnect);
          reconnect.startReconnect(JL_OTA.OTAImpl.RECONNECT_DEVICE_TIMEOUT);
        }
      },
      ...
      onStopOTA: () => {
        otaCallback.onStopOTA()
        const reconnect = this._ReconnectMap.get(deviceId);
        reconnect?.stopReconnect();
      },
      onCancelOTA: () => {
        otaCallback.onCancelOTA()
        const reconnect = this._ReconnectMap.get(deviceId);
        reconnect?.stopReconnect();
      },
      onError: (error: number, message: string) => {
        otaCallback.onError(error,message)
        const reconnect = this._ReconnectMap.get(deviceId);
        reconnect?.stopReconnect();
      },