王明 / Food-Labeling-Management-Platform

  /**

   * 经典蓝牙工具（Android APP-PLUS）
   * 兼容官方 UniApp SDK 经典蓝牙实现，并补充当前项目需要的简化调用：
   * - getPairedDevices()
   * - startClassicDiscovery(onDeviceFound, onDiscoveryFinished)
   * - cancelClassicDiscovery()
   * - connDevice(address, callback)
   * - disConnDevice()
   * - sendByteData(byteData)

   */

  // #ifdef APP-PLUS

  let BluetoothAdapter = plus.android.importClass('android.bluetooth.BluetoothAdapter')
  let Intent = plus.android.importClass('android.content.Intent')
  let IntentFilter = plus.android.importClass('android.content.IntentFilter')
  let BluetoothDevice = plus.android.importClass('android.bluetooth.BluetoothDevice')
  let UUID = plus.android.importClass('java.util.UUID')
  let Toast = plus.android.importClass('android.widget.Toast')

  let Thread = plus.android.importClass('java.lang.Thread')

  let MY_UUID = UUID.fromString('00001101-0000-1000-8000-00805F9B34FB')
  
  let invoke = plus.android.invoke
  let btAdapter = BluetoothAdapter.getDefaultAdapter()
  let activity = plus.android.runtimeMainActivity()
  
  let btSocket = null
  let btInStream = null
  let btOutStream = null
  let setIntervalId = 0
  
  let btFindReceiver = null
  let btStatusReceiver = null
  // #endif

  function normalizeDeviceType (deviceType) {
    if (deviceType === 1) return 'classic'
    if (deviceType === 2) return 'ble'
    if (deviceType === 3) return 'dual'
    return 'unknown'

  }
  

  function fallbackRfcommSocket (device, insecure = false) {

    try {

      const cls = invoke(device, 'getClass')
      const intClass = plus.android.importClass('java.lang.Integer').TYPE
      const methodName = insecure ? 'createInsecureRfcommSocket' : 'createRfcommSocket'
      const method = invoke(cls, 'getMethod', methodName, intClass)
      return invoke(method, 'invoke', device, 1)
    } catch (e) {
      console.error('RFCOMM fallback failed:', e)
      return null
    }

  }
  

  function getErrorMessage (error) {
    if (!error) return 'Unknown error'
    if (typeof error === 'string') return error
    return String(error.message || error.errMsg || error)

  }

  
  function normalizeWriteByte (value) {
    const byte = Number(value) || 0
    return byte & 0xff
  }
  

  function toSignedWriteByte (value) {
    const byte = normalizeWriteByte(value)
    return byte >= 128 ? byte - 256 : byte
  }
  

  function normalizeWriteChunk (byteData, start, end) {
    const out = []
    for (let i = start; i < end; i++) {

      out.push(toSignedWriteByte(byteData[i]))

    }
    return out
  }
  

  function isConnectionStateConnected (state) {
    return String(state || '').trim().toLowerCase() === 'connected'
  }
  

  function getClassicBondState (device) {
    // #ifdef APP-PLUS
    try {
      const state = invoke(device, 'getBondState')
      return typeof state === 'number' ? state : Number(state)
    } catch (_) {
      return null
    }
    // #endif
    return null
  }
  
  function isClassicBonded (device) {
    const state = getClassicBondState(device)
    if (state == null || Number.isNaN(state)) return true
    return state === 12
  }
  

  function runOnUiThread (fn) {
    // #ifdef APP-PLUS
    try {
      if (activity && typeof activity.runOnUiThread === 'function') {
        const runnable = plus.android.implements('java.lang.Runnable', {
          run: function () {
            try {
              fn && fn()
            } catch (e) {
              console.error('runOnUiThread callback failed:', e)
            }
          },
        })
        activity.runOnUiThread(runnable)
        return
      }
    } catch (e) {
      console.error('runOnUiThread failed:', e)
    }
    // #endif
    try {
      setTimeout(() => {
        try {
          fn && fn()
        } catch (e) {
          console.error('setTimeout callback failed:', e)
        }
      }, 0)
    } catch (e) {
      console.error('async callback fallback failed:', e)
    }
  }
  
  function startBackgroundTask (task) {
    // #ifdef APP-PLUS
    const runnable = plus.android.implements('java.lang.Runnable', {
      run: function () {
        try {
          task && task()
        } catch (e) {
          console.error('Background task failed:', e)
        }
      },
    })
    const thread = new Thread(runnable)
    thread.start()
    return
    // #endif
    try {
      task && task()
    } catch (e) {
      console.error('Fallback task failed:', e)
    }
  }
  

  function createSocketCandidates (device) {
    return [
      {
        name: 'secure-service-record',
        create: () => invoke(device, 'createRfcommSocketToServiceRecord', MY_UUID),
      },
      {
        name: 'insecure-service-record',
        create: () => invoke(device, 'createInsecureRfcommSocketToServiceRecord', MY_UUID),
      },
      {
        name: 'secure-channel-1',
        create: () => fallbackRfcommSocket(device, false),
      },
      {
        name: 'insecure-channel-1',
        create: () => fallbackRfcommSocket(device, true),
      },
    ]

  }

  
  var blueToothTool = {

    state: {
      bluetoothEnable: false,
      bluetoothState: '',
      discoveryDeviceState: false,
      readThreadState: false,
      connectionState: 'idle',
      lastAddress: '',
      lastSocketStrategy: '',
      lastError: '',
      lastSendError: '',
      outputReady: false,
      lastSendMode: 'idle',

      isSending: false,

    },
    options: {
      listenBTStatusCallback: function (state) {},
      discoveryDeviceCallback: function (newDevice) {},
      discoveryFinishedCallback: function () {},
      readDataCallback: function (dataByteArr) {},
      connExceptionCallback: function (e) {},
    },
    init (setOptions) {
      Object.assign(this.options, setOptions || {})
      this.state.bluetoothEnable = this.getBluetoothStatus()
      this.listenBluetoothStatus()
    },
    setErrorState (message, type = 'general') {
      const text = String(message || '')
      this.state.lastError = text
      if (type === 'send') {
        this.state.lastSendError = text
      }
    },
    clearErrorState () {
      this.state.lastError = ''
      this.state.lastSendError = ''
    },

    shortToast (msg) {
      // #ifdef APP-PLUS

      try {
        if (activity) Toast.makeText(activity, String(msg), Toast.LENGTH_SHORT).show()
      } catch (_) {}

      // #endif
    },

    isSupportBluetooth () {
      // #ifdef APP-PLUS
      return btAdapter != null
      // #endif
      return false
    },

    getBluetoothStatus () {
      // #ifdef APP-PLUS

      return btAdapter != null && btAdapter.isEnabled()
      // #endif
      return false
    },

    turnOnBluetooth () {
      // #ifdef APP-PLUS
      if (btAdapter == null) {
        this.shortToast('Bluetooth not available')
        return
      }
      if (!btAdapter.isEnabled()) {
        if (activity == null) {
          this.shortToast('Activity not available')
          return
        }
        let intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
        activity.startActivityForResult(intent, 1)
        return
      }
      this.shortToast('Bluetooth already enabled')
      // #endif
    },
    turnOffBluetooth () {
      // #ifdef APP-PLUS
      if (btAdapter != null && btAdapter.isEnabled()) {
        btAdapter.disable()
      }
      if (btFindReceiver != null) {
        try { activity.unregisterReceiver(btFindReceiver) } catch (_) {}
        btFindReceiver = null
      }
      this.state.bluetoothEnable = false
      this.cancelDiscovery()
      this.closeBtSocket()
      // #endif
    },

    getPairedDevices () {
      // #ifdef APP-PLUS

      let pairedDevices = []

      try {

        if (btAdapter == null || !btAdapter.isEnabled()) return pairedDevices
        let pairedDevicesAndroid = btAdapter.getBondedDevices()
        if (!pairedDevicesAndroid) return pairedDevices
        let it = invoke(pairedDevicesAndroid, 'iterator')
        while (invoke(it, 'hasNext')) {
          let device = invoke(it, 'next')
          let deviceType = invoke(device, 'getType')
          let deviceId = invoke(device, 'getAddress')
          let deviceName = invoke(device, 'getName')
          pairedDevices.push({
            name: deviceName != null ? String(deviceName).trim() || 'Unknown Device' : 'Unknown Device',
            deviceId: String(deviceId || ''),
            type: normalizeDeviceType(deviceType),
          })

        }
      } catch (e) {
        console.error('getPairedDevices error:', e)
      }
      return pairedDevices
      // #endif
      return []
    },

    discoveryNewDevice () {

      // #ifdef APP-PLUS

      if (btAdapter == null || !btAdapter.isEnabled() || activity == null) return
      if (btFindReceiver != null) {
        try { activity.unregisterReceiver(btFindReceiver) } catch (e) { console.error(e) }

        btFindReceiver = null

        this.cancelDiscovery()

      }

      let options = this.options

      btFindReceiver = plus.android.implements('io.dcloud.android.content.BroadcastReceiver', {

        onReceive: function (context, intent) {
          plus.android.importClass(context)
          plus.android.importClass(intent)
          let action = intent.getAction()

          if (BluetoothDevice.ACTION_FOUND === action) {

            let device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)

            if (!device) return

            let deviceType = invoke(device, 'getType')
            let deviceId = invoke(device, 'getAddress')
            let deviceName = invoke(device, 'getName')
            let newDevice = {
              name: deviceName != null ? String(deviceName).trim() || 'Unknown Device' : 'Unknown Device',
              deviceId: String(deviceId || ''),
              type: normalizeDeviceType(deviceType),
            }
            options.discoveryDeviceCallback && options.discoveryDeviceCallback(newDevice)

          }
          if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED === action) {

            blueToothTool.cancelDiscovery()
            options.discoveryFinishedCallback && options.discoveryFinishedCallback()

          }
        },
      })

      let filter = new IntentFilter()

      filter.addAction(BluetoothDevice.ACTION_FOUND)
      filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)
      activity.registerReceiver(btFindReceiver, filter)
      btAdapter.startDiscovery()

      this.state.discoveryDeviceState = true

      // #endif
    },

    startClassicDiscovery (onDeviceFound, onDiscoveryFinished) {
      this.init({
        discoveryDeviceCallback: onDeviceFound || function () {},
        discoveryFinishedCallback: onDiscoveryFinished || function () {},
      })
      this.discoveryNewDevice()
    },
    listenBluetoothStatus () {

      // #ifdef APP-PLUS

      if (activity == null) return
      if (btStatusReceiver != null) {
        try { activity.unregisterReceiver(btStatusReceiver) } catch (e) { console.error(e) }
        btStatusReceiver = null
      }
      btStatusReceiver = plus.android.implements('io.dcloud.android.content.BroadcastReceiver', {
        onReceive: (context, intent) => {
          plus.android.importClass(context)
          plus.android.importClass(intent)
          let action = intent.getAction()
          if (action === BluetoothAdapter.ACTION_STATE_CHANGED) {
            let blueState = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, 0)
            let stateStr = ''
            switch (blueState) {
              case BluetoothAdapter.STATE_TURNING_ON:
                stateStr = 'STATE_TURNING_ON'
                break
              case BluetoothAdapter.STATE_ON:
                stateStr = 'STATE_ON'
                this.state.bluetoothEnable = true
                break
              case BluetoothAdapter.STATE_TURNING_OFF:
                stateStr = 'STATE_TURNING_OFF'
                break
              case BluetoothAdapter.STATE_OFF:
                stateStr = 'STATE_OFF'
                this.state.bluetoothEnable = false
                break
            }
            this.state.bluetoothState = stateStr
            this.options.listenBTStatusCallback && this.options.listenBTStatusCallback(stateStr)
          }
        },
      })
      let filter = new IntentFilter()
      filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED)
      activity.registerReceiver(btStatusReceiver, filter)
      if (this.state.bluetoothEnable) {
        this.options.listenBTStatusCallback && this.options.listenBTStatusCallback('STATE_ON')

      }
      // #endif
    },

    connDevice (address, callback) {
      // #ifdef APP-PLUS

      this.cancelDiscovery()

      if (btSocket != null) this.closeBtSocket()
      this.state.readThreadState = false

      this.state.connectionState = 'connecting'
      this.state.lastAddress = String(address || '')
      this.state.outputReady = false
      this.clearErrorState()
  
      if (btAdapter == null) {

        this.shortToast('Bluetooth not available')

        this.state.connectionState = 'error'
        this.setErrorState('Bluetooth not available')
        callback && callback(false)

        return false
      }

      let device = null

      try {

        device = invoke(btAdapter, 'getRemoteDevice', address)

        const candidates = createSocketCandidates(device)
        let socket = null
        let lastError = null
        for (let i = 0; i < candidates.length; i++) {
          const candidate = candidates[i]
          try {
            socket = candidate.create()
            if (socket) {
              this.state.lastSocketStrategy = candidate.name
              break
            }
          } catch (e) {
            lastError = e
            console.warn('create socket failed:', candidate.name, e)
          }
        }
        btSocket = socket
        if (!btSocket) {
          this.state.connectionState = 'error'
          this.setErrorState(lastError ? getErrorMessage(lastError) : 'Unable to create Bluetooth socket')
          callback && callback(false)

          return false
        }

      } catch (e) {
        console.error(e)
        this.state.connectionState = 'error'
        this.setErrorState(getErrorMessage(e))
        callback && callback(false)
        return false

      }

      try {

        invoke(btSocket, 'connect')

        if (!isClassicBonded(device)) {
          throw new Error('Bluetooth PIN or pairing key is incorrect')
        }

        const streamReady = this.readData()
        if (!streamReady) {
          throw new Error(this.state.lastError || 'Bluetooth output stream not ready')
        }
        this.state.connectionState = 'connected'
        this.shortToast('Classic Bluetooth connected')
        callback && callback(true)

      } catch (e) {

        console.error(e)
        this.state.connectionState = 'error'
        this.setErrorState(getErrorMessage(e))
        callback && callback(false)
        try {
          btSocket.close()
          btSocket = null
        } catch (e1) {
          console.error(e1)
        }
        btInStream = null
        btOutStream = null

        return false
      }
      return true
      // #endif

      callback && callback(false)

      return false
    },
    disConnDevice () {
      // #ifdef APP-PLUS

      if (btSocket != null) this.closeBtSocket()

      this.state.readThreadState = false

      // #endif
    },
    closeBtSocket () {
      // #ifdef APP-PLUS
      this.state.readThreadState = false

      this.state.outputReady = false
      this.state.connectionState = 'idle'
      clearInterval(setIntervalId)
      setIntervalId = 0
      if (!btSocket) return
      try {
        btSocket.close()
      } catch (e) {
        console.error(e)

      }

      btSocket = null
      btInStream = null
      btOutStream = null

      // #endif
    },

    cancelDiscovery () {
      // #ifdef APP-PLUS
      if (btAdapter != null && btAdapter.isDiscovering()) {
        btAdapter.cancelDiscovery()
      }
      if (btFindReceiver != null && activity != null) {
        try { activity.unregisterReceiver(btFindReceiver) } catch (_) {}
        btFindReceiver = null
      }
      this.state.discoveryDeviceState = false
      // #endif
    },
    cancelClassicDiscovery () {
      this.cancelDiscovery()
    },
    readData () {
      // #ifdef APP-PLUS
      if (!btSocket) {
        this.shortToast('Please connect Bluetooth device first.')
        this.state.connectionState = 'error'
        this.setErrorState('Please connect Bluetooth device first.')
        return false
      }
      try {
        btInStream = invoke(btSocket, 'getInputStream')
        btOutStream = invoke(btSocket, 'getOutputStream')
      } catch (e) {
        console.error(e)
        this.setErrorState(getErrorMessage(e))
        this.closeBtSocket()
        return false
      }
      this.read()
      this.state.readThreadState = true
      this.state.outputReady = !!btOutStream
      return true
      // #endif
      return false
    },
    read () {
      // #ifdef APP-PLUS
      clearInterval(setIntervalId)
      setIntervalId = setInterval(() => {
        if (this.state.readThreadState) {
          let start = new Date().getTime()
          let dataArr = []
          try {
            while (btInStream && invoke(btInStream, 'available') !== 0) {
              let data = invoke(btInStream, 'read')
              dataArr.push(data)
              let current = new Date().getTime()
              if (current - start > 20) break
            }
          } catch (e) {
            this.state.readThreadState = false
            this.state.connectionState = 'error'
            this.setErrorState(getErrorMessage(e))
            this.options.connExceptionCallback && this.options.connExceptionCallback(e)
          }
          if (dataArr.length > 0) {
            this.options.readDataCallback && this.options.readDataCallback(dataArr)
          }
        }
      }, 40)
      // #endif
    },
    sendData (dataStr) {

      // #ifdef APP-PLUS
      if (!btOutStream) {

        this.shortToast('Output stream not ready')
        return false
      }
      let bytes = invoke(dataStr, 'getBytes', 'gb18030')
      try {
        this.sendByteData(bytes)
      } catch (e) {
        return false
      }
      return true
      // #endif
      return false
    },

    /**
     * @param {any} byteData
     * @param {(percent0to99: number) => void} [onProgress] 按已写字节占比回调 0–99（完成由 sendByteDataAsync 再报 100）
     */
    sendByteData (byteData, onProgress) {

      // #ifdef APP-PLUS

      if (!btOutStream) {
        this.state.outputReady = false
        this.state.connectionState = 'error'
        this.setErrorState('Classic Bluetooth output stream not ready', 'send')
        this.shortToast('Not connected')
        return false
      }
      const socketConnected = this.isSocketConnected()
      const connectionUsable = socketConnected || isConnectionStateConnected(this.state.connectionState)
      if (!connectionUsable) {
        this.state.connectionState = 'error'
        this.setErrorState('Classic Bluetooth connection is not ready', 'send')

        this.shortToast('Not connected')
        return false
      }
      try {

        const CHUNK_SIZE = 4096

        const total = byteData && byteData.length ? byteData.length : 0

        this.state.lastSendMode = 'chunk-write'
        this.state.lastSendError = ''

        for (let i = 0; i < byteData.length; i += CHUNK_SIZE) {

          const chunk = byteData.slice(i, Math.min(i + CHUNK_SIZE, byteData.length))

          try {
            btOutStream.write(chunk)
          } catch (writeChunkError) {
            this.state.lastSendMode = 'byte-write-fallback'

            const signedChunk = normalizeWriteChunk(byteData, i, Math.min(i + CHUNK_SIZE, byteData.length))

            for (let j = 0; j < chunk.length; j++) {

              invoke(btOutStream, 'write', normalizeWriteByte(signedChunk[j]))

            }
          }

          if (typeof onProgress === 'function' && total > 0) {
            const sent = Math.min(total, i + chunk.length)
            const pct = Math.min(99, Math.floor((sent / total) * 100))
            try {
              onProgress(pct)
            } catch (pe) {
              console.error('sendByteData onProgress failed:', pe)
            }
          }

        }

        return true
      } catch (e) {

        const message = getErrorMessage(e)
        console.error('sendByteData failed:', e)
        this.setErrorState(message, 'send')
        this.state.connectionState = 'error'

        return false
      }
      // #endif
      return false

    },

    /**
     * @param {(ok: boolean, errorMessage?: string) => void} callback
     * @param {(percent0to99: number) => void} [onProgress] 发送过程中 0–99
     */
    sendByteDataAsync (byteData, callback, onProgress) {

      // #ifdef APP-PLUS
      if (!btOutStream) {
        this.state.outputReady = false
        this.state.connectionState = 'error'
        this.setErrorState('Classic Bluetooth output stream not ready', 'send')
        runOnUiThread(() => {
          callback && callback(false, this.getLastError())
        })
        return false
      }
      const socketConnected = this.isSocketConnected()
      const connectionUsable = socketConnected || isConnectionStateConnected(this.state.connectionState)
      if (!connectionUsable) {
        this.state.connectionState = 'error'
        this.setErrorState('Classic Bluetooth connection is not ready', 'send')
        runOnUiThread(() => {
          callback && callback(false, this.getLastError())
        })
        return false
      }
      this.state.isSending = true
      this.state.lastSendError = ''
      startBackgroundTask(() => {
        let ok = false
        let errorMessage = ''
        try {

          ok = this.sendByteData(byteData, onProgress)

          if (!ok) {
            errorMessage = this.getLastError() || 'Classic Bluetooth send failed'
          }
        } catch (e) {
          errorMessage = getErrorMessage(e)
          this.setErrorState(errorMessage, 'send')
          this.state.connectionState = 'error'
        } finally {
          this.state.isSending = false
        }
        runOnUiThread(() => {
          callback && callback(ok, errorMessage)
        })
      })
      return true
      // #endif
      callback && callback(false, 'Classic Bluetooth is only available in the app.')
      return false
    },

    isSocketConnected () {
      // #ifdef APP-PLUS
      if (!btSocket) return false
      try {
        return !!invoke(btSocket, 'isConnected')
      } catch (_) {
        return false
      }
      // #endif
      return false
    },
    ensureConnection (address) {
      // #ifdef APP-PLUS
      const targetAddress = String(address || this.state.lastAddress || '')
      if (targetAddress) {
        this.state.lastAddress = targetAddress
      }

      if (btOutStream && (this.isSocketConnected() || isConnectionStateConnected(this.state.connectionState))) {

        this.state.outputReady = true
        return true
      }
      if (!targetAddress) {
        this.setErrorState('Bluetooth address missing')
        return false
      }
      let connected = false
      this.connDevice(targetAddress, (ok) => {
        connected = !!ok
      })
      return connected && !!btOutStream
      // #endif
      return false
    },
    getLastError () {
      return this.state.lastSendError || this.state.lastError || ''
    },
    getDebugState () {
      return {
        ...this.state,
        socketConnected: this.isSocketConnected(),
        outputReady: !!btOutStream,
        inputReady: !!btInStream,
      }
    },

  }
  
  export default blueToothTool