page({
    data: {
      devid: '',
      serid: '',
      writeid: '',
      charid: '',
    },
    // 获取本机蓝牙开关状态
    openbluetoothadapter() {
      my.openbluetoothadapter({
        success: res => {
          if (!res.issupportble) {
            my.alert({ content: '抱歉，您的手机蓝牙暂不可用' });
            return;
          }
          my.alert({ content: '初始化成功！' });
        },
        fail: error => {
          console.error('初始化失败: ', json.stringify(error));
        },
      });
    },
    // 关闭蓝牙
    closebluetoothadapter() {
      my.closebluetoothadapter({
        success: () => {
          my.alert({ content: '关闭蓝牙成功！' });
        },
        fail: error => {
          console.error('关闭蓝牙失败: ', json.stringify(error));
        },
      });
    },
    // 获取本机蓝牙状态
    getbluetoothadapterstate() {
      my.getbluetoothadapterstate({
        success: res => {
          if (!res.available) {
            my.alert({ content: '抱歉，您的手机蓝牙暂不可用' });
            return;
          }
          my.alert({ content: json.stringify(res) });
        },
        fail: error => {
          console.error('获取蓝牙状态失败: ', json.stringify(error));
        },
      });
    },
    // 扫描蓝牙设备
    startbluetoothdevicesdiscovery() {
      my.startbluetoothdevicesdiscovery({
        allowduplicateskey: false,
        success: () => {
          my.onbluetoothdevicefound({
            success: res => {
              // my.alert({content:'监听新设备' json.stringify(res)});
              var devicearray = res.devices;
              for (var i = devicearray.length - 1; i >= 0; i--) {
                var deviceobj = devicearray[i];
                // 通过设备名称或者广播数据匹配目标设备，然后记录 deviceid 后面使用
                if (deviceobj.name == this.data.name) {
                  my.alert({ content: '目标设备被找到' });
                  my.offbluetoothdevicefound();
                  this.setdata({
                    deviceid: deviceobj.deviceid,
                  });
                  break;
                }
              }
            },
            fail: error => {
              console.error('监听新设备失败: ', json.stringify(error));
            },
          });
        },
        fail: error => {
          console.error('启动扫描失败: ', json.stringify(error));
        },
      });
    },
    // 停止扫描
    stopbluetoothdevicesdiscovery() {
      my.stopbluetoothdevicesdiscovery({
        success: res => {
          my.offbluetoothdevicefound();
          my.alert({ content: '操作成功！' });
        },
        fail: error => {
          console.error('停止扫描失败: ', json.stringify(error));
        },
      });
    },
    // 获取正在连接中的设备
    getconnectedbluetoothdevices() {
      my.getconnectedbluetoothdevices({
        success: res => {
          if (res.devices.length === 0) {
            my.alert({ content: '没有在连接中的设备！' });
            return;
          }
          my.alert({ content: json.stringify(res) });
          this.setdata({
            devid: res.devices[0].deviceid,
          });
        },
        fail: error => {
          console.error('获取信息失败: ', json.stringify(error));
        },
      });
    },
    // 获取所有搜索到的设备
    getbluetoothdevices() {
      my.getbluetoothdevices({
        success: res => {
          console.log('getbluetoothdevices', json.stringify(res));
          console.log('getbluetoothdevices', res);
          my.alert({ content: json.stringify(res) });
        },
        fail: error => {
          console.error('获取信息失败: ', json.stringify(error));
        },
      });
    },
   // "输入要连接的设备的 deviceid" input 框事件
    bindkeyinput(e) {
      this.setdata({
        devid: e.detail.value,
      });
    },
    // 连接设备
    connectbledevice() {
      my.connectbledevice({
        deviceid: this.data.devid,
        success: res => {
          my.alert({ content: '连接成功' });
        },
        fail: error => {
          console.error('连接设备失败: ', json.stringify(error));
        },
      });
    },
    // 断开连接
    disconnectbledevice() {
      my.disconnectbledevice({
        deviceid: this.data.devid,
        success: () => {
          my.alert({ content: '断开连接成功！' });
        },
        fail: error => {
          console.error('断开连接失败: ', json.stringify(error));
        },
      });
    },
    // 获取连接设备的 server，必须要再连接状态状态之下才能获取
    getbledeviceservices() {
      my.getconnectedbluetoothdevices({
        success: res => {
          if (res.devices.length === 0) {
            my.alert({ content: '没有已连接的设备' });
            return;
          }
          my.getbledeviceservices({
            deviceid: this.data.devid,
            success: res => {
              my.alert({ content: json.stringify(res) });
              this.setdata({
                serid: res.services[0].serviceid,
              });
            },
            fail: error => {
              console.error('获取信息失败: ', json.stringify(error));
            },
          });
        },
      });
    },
    // 获取连接设备的 charid，必须要再连接状态状态之下才能获取（这里分别筛选出读写特征字）
    getbledevicecharacteristics() {
      my.getconnectedbluetoothdevices({
        success: res => {
          if (res.devices.length === 0) {
            my.alert({ content: '没有已连接的设备' });
            return;
          }
          this.setdata({
            devid: res.devices[0].deviceid,
          });
          my.getbledevicecharacteristics({
            deviceid: this.data.devid,
            serviceid: this.data.serid,
            success: res => {
              my.alert({ content: json.stringify(res) });
              // 特征字对象属性见文档，根据属性匹配读写特征字并记录，然后后面读写使用
              this.setdata({
                charid: res.characteristics[0].characteristicid,
              });
            },
            fail: error => {
              console.error('获取信息失败: ', json.stringify(error));
            },
          });
        },
      });
    },
    // 读数据
    readblecharacteristicvalue() {
      my.getconnectedbluetoothdevices({
        success: res => {
          if (res.devices.length === 0) {
            my.alert({ content: '没有已连接的设备' });
            return;
          }
          my.alert({
            title: '使用的设备',
            content: json.stringify(res.devices[0]),
          });
          this.setdata({
            devid: res.devices[0].deviceid,
          });
          my.readblecharacteristicvalue({
            deviceid: this.data.devid,
            serviceid: this.data.serid,
            characteristicid: this.data.charid,
            success: res => {
              my.alert({ content: json.stringify(res) });
            },
            fail: error => {
              console.error('读取失败: ', json.stringify(error));
            },
          });
        },
      });
    },
    // 写数据
    writeblecharacteristicvalue() {
      my.getconnectedbluetoothdevices({
        success: res => {
          if (res.devices.length === 0) {
            my.alert({ content: '没有已连接的设备' });
            return;
          }
          this.setdata({
            devid: res.devices[0].deviceid,
          });
          // 向蓝牙设备发送一个 0x00 的 16 进制数据
          const buffer = new arraybuffer(1);
          const dataview = new dataview(buffer);
          dataview.setuint8(0, 0);
          my.writeblecharacteristicvalue({
            deviceid: this.data.devid,
            serviceid: this.data.serid,
            characteristicid: this.data.charid,
            value: buffer,
            success: res => {
              my.alert({ content: '写入数据成功！' });
            },
            fail: error => {
              console.error('写入数据失败: ', json.stringify(error));
            },
          });
        },
      });
    },
    // 监听特征值变化的事件
    notifyblecharacteristicvaluechange() {
      my.getconnectedbluetoothdevices({
        success: res => {
          if (res.devices.length === 0) {
            my.alert({ content: '没有已连接的设备' });
            return;
          }
          this.setdata({
            devid: res.devices[0].deviceid,
          });
  
          my.notifyblecharacteristicvaluechange({
            state: true,
            deviceid: this.data.devid,
            serviceid: this.data.serid,
            characteristicid: this.data.charid,
            success: () => {
              // 监听特征值变化的事件
              my.onblecharacteristicvaluechange({
                success: res => {
                  //  my.alert({content: '特征值变化：' json.stringify(res)});
                  my.alert({ content: '得到响应数据 = '  res.value });
                },
              });
              my.alert({ content: '监听成功' });
            },
            fail: error => {
              console.error('监听失败: ', json.stringify(error));
            },
          });
        },
      });
    },
    // 取消监听低功耗蓝牙设备的特征值变化
    offblecharacteristicvaluechange() {
      my.offblecharacteristicvaluechange();
    },
    // 监听本机蓝牙状态变化
    bluetoothadapterstatechange() {
      my.onbluetoothadapterstatechange(
        this.getbind('onbluetoothadapterstatechange')
      );
    },
    onbluetoothadapterstatechange(res) {
      if (res.error) {
        my.alert({ content: json.stringify(res.error) });
      } else {
        my.alert({ content: '本机蓝牙状态变化：'  json.stringify(res) });
      }
    },
    offbluetoothadapterstatechange() {
      my.offbluetoothadapterstatechange(
        this.getbind('onbluetoothadapterstatechange')
      );
    },
    getbind(name) {
      if (!this[`bind${name}`]) {
        this[`bind${name}`] = this[name].bind(this);
      }
      return this[`bind${name}`];
    },
    // 监听低功耗蓝牙连接的错误事件
    bleconnectionstatechanged() {
      my.onbleconnectionstatechanged(this.getbind('onbleconnectionstatechanged'));
    },
    onbleconnectionstatechanged(res) {
      if (res.error) {
        my.alert({ content: json.stringify(res.error) });
      } else {
        my.alert({ content: '连接状态变化：'  json.stringify(res) });
      }
    },
    // 取消监听低功耗蓝牙连接状态变化
    offbleconnectionstatechanged() {
      my.offbleconnectionstatechanged(
        this.getbind('onbleconnectionstatechanged')
      );
    },
    onunload() {
      this.offbleconnectionstatechanged();
      this.offblecharacteristicvaluechange();
      this.offbluetoothadapterstatechange();
      this.closebluetoothadapter();
    },
  });