miniProgram/pages/index/index.js

// index.js
// 获取应用实例
import * as echarts from '../../ec-canvas/echarts';

// const { connect } = require("../../utils/mqtt4/mqtt");
/******************* 必须要改！！不然得不到天气！！ ******************/
const hefengKey = "	aa373d4025b0487196c15d8e6526cfcf"; //  和风天气Web api的key
/******************* 可能需要你修改的部分 ******************/
//const mqttHost = "broker.emqx.io"; //mqtt 服务器域名/IP
// const mqttHost = "www.nekolee.top";
const mqttHost = "haold.aidsleep.cn";
// const mqttHost = "192.168.3.65";
// const mqttPort = 8084; //mqtt 服务器域名/IP
const mqttPort = 8083; //mqtt 服务器域名/IP

const hefengVIP = false; //  和风天气是免费的api（false）还是付费api（true）

const deviceSubTopic_LED = "/NekoHome/sub_LED"; //  设备订阅topic（小程序发布命令topic）
const deviceSubTopic_BEEP = "/NekoHome/sub_BEEP";
const deviceSubTopic_CU = "/NekoHome/sub_CU";
const deviceSubTopic_DO = "/NekoHome/sub_DO";
const deviceSubTopic_SAN = "/NekoHome/sub_SAN";
const deviceSubTopic_Mode = "/NekoHome/sub_mode";
// const devicePubTopic_env = "/NekoHome/pub/Environment"; //  设备发布topic（订阅环境参数）
// const devicePubTopic_con = "/NekoHome/pub/Controll"; //  设备发布topic（订阅控制参数）
const devicePubTopic_env = "testtopic/1"; //  设备发布topic（订阅环境参数）
const devicePubTopic_con = "testtopic/1"; //  设备发布topic（订阅控制参数）
/********************* 一般不用动这些 ********************/

//小程序接收的主题
const mpSubTopic_env = devicePubTopic_env;
const mpSubTopic_con = devicePubTopic_con;

//小程序发送的主题
const mpPubTopic_LED = deviceSubTopic_LED;
const mpPubTopic_BEEP = deviceSubTopic_BEEP;
const mpPubTopic_CU = deviceSubTopic_CU;
const mpPubTopic_DO = deviceSubTopic_DO;
const mpPubTopic_SAN = deviceSubTopic_SAN;
const mpPubTopic_Mode = deviceSubTopic_Mode;


const mqttUrl = `wx://${mqttHost}:${mqttPort}/mqtt`; //  mqtt连接路径

const hefengApi = "https://api.qweather.com/v7"; //  和风天气付费API前缀
const hefengFreeApi = "https://devapi.qweather.com/v7"; //  和风天气免费API前缀

const hefengWeather = `${hefengVIP ? hefengApi : hefengFreeApi}/weather/now?`; //  和风天气实时天气api
const hefengAir = `${hefengVIP ? hefengApi : hefengFreeApi}/air/now?`; //  和风天气空气质量api

const geoApi = "https://geoapi.qweather.com/v2/city/lookup?" //  地理位置api（用来获取经纬度对应的城市/城区名字）
var homeApi = "http://haold.aidsleep.cn:8123/api";
var homeApiLater = "http://haold.aidsleep.cn:8123";
var homeApi_https = "https://haold.aidsleep.cn/api";
var homeApiLater_https = "https://haold.aidsleep.cn";
var entity = "";
// const token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJiN2JlOGE0MDExZjY0NjA2OGUxYjJiZTE4M2Y2NzU0NSIsImlhdCI6MTcxMTYxNDY2NCwiZXhwIjoyMDI2OTc0NjY0fQ.XJ73cXAoEsouTgvgpNVobq9oKdwlJr88TiAFLYlaahE";
var token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJlZGVjOWI3YWQ0MTQ0ZTIxYWQ1NTE1Nzc5NTkzNjBjNiIsImlhdCI6MTcxMjEzNTM2MywiZXhwIjoyMDI3NDk1MzYzfQ.IfrvdiaVuhCKsdy69JvUYhJ64bnhMT8MI1hN8R38whc";

const aipushApi = "https://aipush.aidsleep.cn";
const token_push = "b74fd5754c5ef24cf600c39194abdaeb";
				
const options = {
	connectTimeout:4000,//超时时间
	clientId:'emqx_ODAyNT',//随机生成ID
	username:'test1',
	password:'123456'
}

// let chart4;

// function flushChart4(data) {
// 	console.lg('111111112222222222222333333333');
//   var option = {
// 	  // title: {
// 	  // text: '睡眠与起床时间'
// 	  // },
// 	  title: {
// 	    text: '睡眠与清醒时间',
// 	    left: 'center',
// 	    textStyle: {
// 	                color: '#ffffff', // 字体颜色  
// 	                fontStyle: 'normal', // 字体风格  
// 	                // fontWeight: 'bold', // 字体粗细  
// 	                fontFamily: 'sans-serif', // 字体族  
// 	                fontSize: 18 // 字体大小  
// 	              },
// 	    backgroundColor: '#ff5246'
// 	  },
// 	  tooltip: {},
// 	  series: [{
// 	  type: 'gauge',
// 	  detail: {formatter: '{value} 小时'},
// 	  data: [{"name":"睡眠时间","value":7},{"name":"清醒时间","value":1}]
// 	  }]
// 	  };
//   chart4.setOption(option, true);
// }

function initChartHumidifier(canvas, width, height ,data) {//这里多加一个参数
  const chart = echarts.init(canvas, null, {
    width: width,
    height: height
  })
  canvas.setChart(chart);
  var option = {
	  //提示框组件。开发实际中去掉了指针，提示框可以不用设置。
	  tooltip: {
		formatter: "{a} <br/>{b} : {c}%"
	  },
	  //工具栏。刷新，下载
	 //  toolbox: {
		// feature: {
		//   restore: {},
		//   saveAsImage: {}
		// }
	 //  },
	  //下面属性才是仪表盘的核心！！反正我是这么认为的！！！
	  series: [{
		//类型
		type: 'gauge',
		//半径
		radius: 150,
		//起始角度。圆心 正右手侧为0度，正上方为90度，正左手侧为180度。
		startAngle: 200,
		//结束角度。
		endAngle: -20,
		center: ['50%', '65%'],
		min:data.min_humidity,
		max:data.max_humidity,
		//仪表盘轴线相关配置。
		axisLine: {
		  show: true,
		  color: '#333',
		  // 属性lineStyle控制线条样式
		  lineStyle: {
			width: 20,
			color: [[data.humidity?(data.humidity / data.max_humidity):'', '#b8b8b8'], [1, '#ebebeb']]

		  }
		},
		//分隔线样式。
		splitLine: {
		  show: false,
		},
		//刻度样式。
		axisTick: {
		  show: false,
		},
		//刻度标签。
		axisLabel: {
		  show: false,
		},
		// 结尾的圆圈图标  
		markPoint: {  
			silent: true,  
			data: [  
			{  
				name: '结束点',  
				coord: ['100%', '0%'],  
				itemStyle: {  
				normal: {  
				label: {  
				  show: false  
				},  
				borderRadius: 10,  
				borderColor: '#aa00ff',  
				borderWidth: 2,  
				color: 'rgba(255, 255, 255, 0.3)'  
				  }  
				}  
			  }  
			]  
		  },
		//仪表盘指针。
		pointer: {
		  show: false,
		  //指针长度
		  length: '90%',
		  width: 0,
		},
		//仪表盘标题。
		title: {
		  show: true,
		  offsetCenter: [0, '-40%'], // x, y，单位px
		  textStyle: {
			color: '#000',
			fontSize: 30
		  }
		},
		//仪表盘详情，用于显示数据。
		detail: {
		  show: true,
		  offsetCenter: [0, '-10%'],
		  formatter: data.humidity,

		  textStyle: {
			fontSize: 30,
			color: '#31e4f4'
		  }
		},
		data: [{
		  value: data.humidity?data.humidity:null,
		  name: '湿度'
		}]
	  }]
	};

  chart.setOption(option);
  return chart;
}

function initChartClimate(canvas, width, height ,data) {//这里多加一个参数
  const chart = echarts.init(canvas, null, {
    width: width,
    height: height
  })
  canvas.setChart(chart);
  var option = {
	  //提示框组件。开发实际中去掉了指针，提示框可以不用设置。
	  tooltip: {
		formatter: "{a} <br/>{b} : {c}%"
	  },
	  //工具栏。刷新，下载
	 //  toolbox: {
		// feature: {
		//   restore: {},
		//   saveAsImage: {}
		// }
	 //  },
	  series: [{
		//类型
		type: 'gauge',
		//半径
		radius: 150,
		//起始角度。圆心 正右手侧为0度，正上方为90度，正左手侧为180度。
		startAngle: 200,
		//结束角度。
		endAngle: -20,
		center: ['50%', '65%'],
		min:data.min_temp,
		max:data.max_temp,
		//仪表盘轴线相关配置。
		axisLine: {
		  show: true,
		  color: '#333',
		  // 属性lineStyle控制线条样式
		  lineStyle: {
			width: 20,
			color: [[data.max_temp?(data.temperature / data.max_temp):0, '#b8b8b8'], [1, '#ebebeb']]

		  }
		},
		//分隔线样式。
		splitLine: {
		  show: false,
		},
		//刻度样式。
		axisTick: {
		  show: false,
		},
		//刻度标签。
		axisLabel: {
		  show: false,
		},
		// 结尾的圆圈图标
		markPoint: {  
			silent: true,  
			data: [  
			{  
				name: '结束点',  
				coord: ['100%', '0%'],  
				itemStyle: {  
				normal: {  
				label: {  
				  show: false  
				},  
				borderRadius: 10,  
				borderColor: '#aa00ff',  
				borderWidth: 2,  
				color: 'rgba(255, 255, 255, 0.3)'  
				  }  
				}  
			  }  
			]  
		  },
		//仪表盘指针。
		pointer: {
		  show: false,
		  //指针长度
		  length: '90%',
		  width: 0,
		},
		//仪表盘标题。
		title: {
		  show: true,
		  offsetCenter: [0, '-40%'], // x, y，单位px
		  textStyle: {
			color: '#000',
			fontSize: 30
		  }
		},
		//仪表盘详情，用于显示数据。
		detail: {
		  show: true,
		  offsetCenter: [0, '-10%'],
		  formatter: data.temperature,

		  textStyle: {
			fontSize: 30,
			color: '#31e4f4'
		  }
		},
		data: [{
		  value: data.temperature,
		  name: '温度'
		}]
	  }]
	};

  chart.setOption(option);
  return chart;
}

import Notify from '../../@vant/weapp/notify/notify';
import Dialog from '../../@vant/weapp/dialog/dialog';
import Toast from '../../@vant/weapp/toast/toast';
Page({
  data: {
    //单选框
     radio_select: '10',
     radio_switch: '10',
    //倒计时时间
    Time: 0,
    //火灾时的呼吸效果变量
    breathNum:0,

    //火灾头顶警示
    topTips: true,
    hide: false,

    //火灾弹窗显示
    fire_show:false,

    //设备控制弹窗参数 开始
    show_led: false,
    show_beep: false,
    show_curtain:false,
    show_san:false,
    show_door:false,
    show_time: false,
    actions_led: [
      {
        name: '打开',
        subname: '打开客厅灯',
        id:1,
		url:'',
		entity_id:'',
      },
      {
        name: '关闭',
        subname: '关闭客厅灯',
        id:0,
		url:'',
		entity_id:'',
      },
      
    ],
    actions_beep: [
      {
        name: '打开',
        subname: '打开警报器',
        id:1,
		url:'/services/switch/turn_on',
		entity_id:'switch.deerma_jsq2g_392f_alarm',
      },
      {
        name: '关闭',
        subname: '关闭警报器',
        id:0,
		url:'/services/switch/turn_off',
		entity_id:'switch.deerma_jsq2g_392f_alarm',
      },
      
    ],
    actions_curtain: [
      {
        name: '打开',
        subname: '打开香薰机',
        id:90,
		url:'',
		entity_id:'',
      },
      {
        name: '关闭',
        subname: '关闭香薰机',
        id:0,
		url:'',
		entity_id:'',
      },
      
    ],
    actions_san: [
      {
        name: '打开',
        subname: '打开音响',
        id:1,
		url:'',
		entity_id:'',
      },
      {
        name: '关闭',
        subname: '关闭音响',
        id:0,
		url:'',
		entity_id:'',
      },
      
    ],
    actions_door: [
      {
        name: '打开',
        subname: '打开智能开关',
        id:90,
		url:'',
		entity_id:'',
      },
      {
        name: '关闭',
        subname: '关闭智能开关',
        id:0,
		url:'',
		entity_id:'',
      },
      
    ],
//设备控制弹窗参数 结束



    client: {},

    //设备状态参数 开始
    status_beep: 0,
    status_led: 0,
    status_san: 0,
    status_curtain: 0,
    status_door: 0,
    status_fire: 0,
    status_light: 0,
    status_mode: 0,
  //设备状态参数 结束

    //设备环境参数 开始
    Temp: 0,
    Humi: 0,
    Voltage1: 0,
    Voltage2: 0,
    //设备环境参数 结束
	
	//香薰机参数 开始
	Light: 0,
	LiquidLevel: 0,
    //香薰机参数 开始
	
    area: "请求中", //城区
    city: "请求中", //城市
    airText: "请求中", //空气优良
    airValue: 0, //空气指数
    weather: "请求中", //天气
    //weatherAdvice: "今天天气不错", //天气建议
    time: 30 * 60 * 60 * 1000,
    gradientColor: {
      '0%': '#ffd01e',
      '100%': '#ee0a24',
    },
    value: 25,
	pickerValue: [0], // picker-view 的当前值，数组形式，表示选择器的当前位置
	array: ['0%', '10%', '20%', '30%', '40%', '50%', '60%', '70%', '80%', '90%', '100%'], // 滑动块可选的值
	items: ['0%', '10%', '20%', '30%', '40%', '50%', '60%', '70%', '80%', '90%', '100%'], // 滑动块可选的值
	
	scaleTextStyle:{
	  show:true,
	  size:12,
	  color:''
	},
	indicatorTextStyle:{
	  show:true,
	  size:16,
	  text:'湿度'
	},
	indicatorTextStyleClimate:{
	  show:true,
	  size:16,
	  text:'温度'
	},
	indicatorValueStyle: {
	  show: true,
	  size: 55,
	  color:''
	},
	indicatorCircleStyle:{
	  show:true,
	  boderColor:[
	    {
	      progress:0,
	      value:"#4575e8"
	   },
	    {
	      progress: 1,
	      value: "#fff"
	    }
	  ]
	},
	listCover: [],//窗帘开关
	listSwitch: [],//开关
	listScroll: [],//滚动条
	listUnit: [],//rgb、%、minutes、w等
	listConversation: [],//智能音响
	listConversation1: [],//智能音响
	listHumidity: [],//加湿器
	listButton: [],//按钮 '按下'
	listSelect: [],//下拉框的
	listClimate: [],//空调控制 图像
	
	listMiotMediaPlayer: [],//智能音箱 图像
	listMitvMediaPlayer: [],//电视 图像
	
	listHumidifier: [],//加湿器 图像
	listSensor: [],//文字描述的
	
	listText: [],//文本框填写的
	
	isPlaying: false,  
	currentTime: 0, 
	currentIndex: 0, 
	duration: 0,  
	currentSongTitle: '--',  
	currentSongArtist: '--',  
	canPrev: true,  
	canNext: true,
	songs: [], // 歌曲列表
	scrollValue: [],
	selectedIndex: 0, // 默认选中第一个选项
	home_room: [
		'company_laboratory',
        '2802',
		],
	climateMode: '',//空调模式：加热还是除湿。在空调增加按钮和减少按钮 时使用
	
	canvasWidth: 300, // 画布宽度
	canvasHeight: 150, // 画布高度
	value:60 , // 当前得分
	total:100, // 总分值
	tvEntityId:'',// 电视实体Id
	tvEntityIds:[],// 电视实体
	entityName:'',//
	sleep_duration:'50',
	ecHumidifier: {
	      onInit: initChartHumidifier
	    },
	ecClimate: {
	      onInit: initChartClimate
	    },
	itemList:[
	  { name: '1', data: [{ value: 10 }, { value: 1 }] },
	  { name: '2', data: [{ value: 10 }, { value: 4 }] },
	  { name: '3', data: [{ value: 10 }, { value: 7 }] },
	],
	blackList:[
	  // '指示灯','电视模式','电视音量','空调遥控','智能音箱','电视控制码','传感器模式','开关模式','耗电量','智能音箱会话'
		'加湿器','空调','音箱','窗帘','纱帘'
	],
	temperatureHumidifyName:'温度',
	isButtonPressedHumidityUp:false,
	isButtonPressedHumidityDown:false,
	isButtonPressedClimateUp:false,
	isButtonPressedClimateDown:false,
	tcp: '',
	w_temp: '',//温度
	w_humidity: '',//湿度
	imgSrc: '',//图片地址
	isLoading: false,
	observer: '',
	hotelcode: '',//酒店编码
	roomcode: '',//房间编码
	isClickedPrevSong: false,
	isClickedTogglePlayPause: false,
	isClickedNextSong: false,
	isClickedOnHumidifierUp: false,
	isClickedOnHumidifierDown: false,
	isClickedOnClimateAuto: false,
	isClickedOnClimateUp: false,
	isClickedToggleAromlight: false,//香薰机灯光
	intervalId1: null,  
	intervalId2: null,
	
  },
   replaceAll: function(str, find, replace) {  
    return str.replace(new RegExp(find, 'g'), replace);  
  },
	checkFuzzyMatch: function(data) {
		var searchString = data.attributes.friendly_name
		var domain = data.entity_id.split(".")[0]	
		var isMatched = true;
		var list = this.data.blackList;
		if(!searchString || !list) return false;
	    for (var i = 0; i < list.length; i++) {  
	      if (searchString.indexOf(list[i]) !== -1) {  
	        isMatched = false;  
	        break;
	      }  
	    }    
	    return isMatched;
	  },
	onChange: function (e) {
	    this.setData({
	      pickerValue: e.detail.value, // 更新picker-view的值
	    });
	    // 在这里添加点击事件的处理逻辑
	    // 根据pickerValue的变化执行相应的操作
	  },
	  swiperTap(e) {
	      // 处理整个swiper的点击事件
	    },
	    itemTap(e) {
	      // 处理swiper-item的点击事件
	      const index = e.currentTarget.dataset.index;
	      // 根据index执行其他操作
	    },
  //定时组件
  

  start() {
    const countDown = this.selectComponent('.control-count-down');
    countDown.start();
  },

  pause() {
    const countDown = this.selectComponent('.control-count-down');
    countDown.pause();
  },

  reset() {
    const countDown = this.selectComponent('.control-count-down');
    countDown.reset();
  },
  set(){
    this.setData({
      show_time:true,
    })
  },
  onClose_TimeSet() {
    this.setData({ show_time: false });
  },
  onChange_Silder(event) {
    wx.showToast({
      icon: 'none',
      title: `定时：${event.detail}s`,
    });
    this.setData({
      Time:event.detail,
    })
  },

  onChange_Select(event) {
    this.setData({
      radio_select: event.detail,
    });
  },

  onChange_Switch(event) {
    this.setData({
      radio_switch: event.detail,
    });
  },


  finished() {
    var that = this;
    //定时开关哪个设备？
    if(that.data.radio_select == 2)
    {
      if(that.data.radio_switch == 1){
        console.log("选择了开");
        that.data.client.publish(mpPubTopic_LED, '{"target":"LED","value":1}', function (err) {
          if (!err) {
            console.log("成功下发命令——打开客厅灯");
          }
        });
      }else{
        console.log("选择了关");
        that.data.client.publish(mpPubTopic_LED, '{"target":"LED","value":0}', function (err) {
          if (!err) {
            console.log("成功下发命令——关闭客厅灯");
          }
        });
      }
    }else if(that.data.radio_select == 3){
      console.log("选择了BEEP");
      if(that.data.radio_switch == 1){
        console.log("选择了开");
        that.data.client.publish(mpPubTopic_BEEP, '{"target":"BEEP","value":1}', function (err) {
          if (!err) {
            console.log("成功下发命令——打开报警器");
          }
        });
      }else{
        console.log("选择了关");
        that.data.client.publish(mpPubTopic_BEEP, '{"target":"BEEP","value":0}', function (err) {
          if (!err) {
            console.log("成功下发命令——关闭报警器");
          }
        });
      }
    }else if(that.data.radio_select == 4){
      console.log("选择了CU");
      if(that.data.radio_switch == 1){
        console.log("选择了开");
        that.data.client.publish(mpPubTopic_CU, '{"target":"CU","value":1}', function (err) {
          if (!err) {
            console.log("成功下发命令——开窗帘");
          }
        });
      }else{
        console.log("选择了关");
        that.data.client.publish(mpPubTopic_CU, '{"target":"CU","value":0}', function (err) {
          if (!err) {
            console.log("成功下发命令——关窗帘");
          }
        });
      }
    }else if(that.data.radio_select == 5){
      console.log("选择了SAN");
      if(that.data.radio_switch == 1){
        console.log("选择了开");
        that.data.client.publish(mpPubTopic_SAN, '{"target":"SAN","value":1}', function (err) {
          if (!err) {
            console.log("成功下发命令——开风扇");
          }
        });
      }else{
        console.log("选择了关");
        that.data.client.publish(mpPubTopic_SAN, '{"target":"SAN","value":0}', function (err) {
          if (!err) {
            console.log("成功下发命令——关风扇");
          }
        });
      }
    }
   
    Toast('倒计时结束');
  },

  setTextBreathing: function(cls,e) {
    //使用记录呼吸效果
    var transparency = 10;
    var reduce = true;  //记录当前做透明度增加或降低操作
    setInterval(function(){
      if (reduce === true){
        transparency -= 1;
        if (transparency === 0){
            reduce = false;
        }
      } else if (reduce === false){
          transparency += 1;
        if (transparency === 10){
            reduce = true;
        }
      }
      cls._defaultComponent.setData({
        breathNum:transparency/10
      })
      //通过setData的方式，设置breathNum的值
    },80)
  },


  // 各个设备弹窗逻辑 
  onOpen_led() {
    this.setData({ show_led: true });
  },
  onClose_led(){
      this.setData({
        show_led:false
      })
  },
  onSelect_led(event) {
    console.log(event.detail.id);
    this.onLedChange(event.detail.id);
  },

  onOpen_beep() {
    this.setData({ show_beep: true });
  },
  onClose_beep(){
      this.setData({
        show_beep:false
      })
  },
  onSelect_beep(event) {
    console.log(event.detail.id);
    this.onBeepChange(event.detail.id,event.detail.url,event.detail.entity_id);
  },
  getRealApi(){
	  // if(wx.getStorageSync('res').result && wx.getStorageSync('res').result.includes('辰悦颐养斋')){
	  // 	  homeApi = "http://zhh.aidsleep.cn:9123/api";
	  // 	  homeApiLater = "http://zhh.aidsleep.cn:9123";
		 //  homeApi_https = "https://zhh.aidsleep.cn/api";
		 //  homeApiLater_https = "https://zhh.aidsleep.cn";
	  // 	  entity = wx.getStorageSync('res').result=='company_laboratory'?'公司实验室':wx.getStorageSync('res').result
	  // 	  if(entity && entity.includes('-')){
	  // 		  entity = entity.slice(entity.indexOf('-')+1)
	  // 	  }
		 //  if(entity && entity.includes('|')){
		 //  	 entity = entity.slice(entity.indexOf('|')+1)
		 //  }
	  // }else if(wx.getStorageSync('res').result && (!wx.getStorageSync('res').result.includes('辰悦颐养斋'))){
	  // 	  homeApi = "http://haold.aidsleep.cn:8123/api";
	  // 	  homeApiLater = "http://haold.aidsleep.cn:8123";
		 //  homeApi_https = "https://haold.aidsleep.cn/api";
		 //  homeApiLater_https = "https://haold.aidsleep.cn";
		 //  entity = wx.getStorageSync('res').result=='company_laboratory'?'公司实验室':wx.getStorageSync('res').result
	  // 	  if(entity && entity.includes('-')){
	  // 		  entity = str.slice(str.indexOf('-')+1)
	  // 	  }
		 //  if(entity && entity.includes('|')){
			//   entity = str.slice(str.indexOf('|')+1)
		 //  }
	  // }
	  
  },
onSelect_vangrid(url,entity_id) {
    // this.setData({
    //   status_beep: Number(param4)
    // })
	
	wx.request({
	  url: `${homeApi_https}`+url, 
	  method: 'POST',
	  data: {
	      "entity_id":entity_id
	    },
	   header: {
		  'content-type': 'application/json', // 默认值
	      'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
	    },
	  success(res) {
	  },
	});
	
  },

tvFanChange(e) {	
	var that = this;
	// 获取绑定的参数
	var entity_id = e.currentTarget.dataset.id;
	//模式
	var fan = e.currentTarget.dataset.fan;
	wx.request({
	  url: `${homeApi_https}`+'/services/media_player/select_source', 
	  method: 'POST',
	  data: {
	      "entity_id":entity_id,
		  "source": fan
	    },
	   header: {
		  'content-type': 'application/json', // 默认值
	      'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
	    },
	  success(res) {
		// if(res.data){
		// 	that.getSwitch(res.data,that)
		// }
	  },
	});
	
  },
  
onSelect_All(e) {	
	var that = this;
	// 获取绑定的参数
	var param0 = e.currentTarget.dataset.param0;
	var param1 = e.currentTarget.dataset.param1;
	var param2 = e.currentTarget.dataset.param2;
	// var param3 = e.currentTarget.dataset.param3;
	// var param4 = e.currentTarget.dataset.param4;
	var param5 = e.currentTarget.dataset.param5;
	console.log('param1='+param1);
	console.log('param2='+param2);
	// console.log('param3='+param3);
	// console.log('param4='+param4);
	console.log('param5='+param5);
    // this.setData({
    //   status_beep: Number(param4)
    // })
	// if(param3 == "/turn_on"){
	// 	that.data.listSwitch[param0].state = "off";
	// 	that.data.listSwitch[param0].service = "turn_off";
	// }else if(param3 == "/turn_off"){
	// 	that.data.listSwitch[param0].state = "on";
	// 	that.data.listSwitch[param0].service = "turn_on";
	// }
	 console.log('switch 发生 change 事件，携带值为', e.detail.value)
	wx.request({
	  url: `${homeApi_https}`+param1+param2+(e.detail.value?'/turn_on':'/turn_off'), 
	  method: 'POST',
	  data: {
	      "entity_id":param5
	    },
	   header: {
		  'content-type': 'application/json', // 默认值
	      'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
	    },
	  success(res) {
		// if(res.data){
		// 	that.getSwitch(res.data,that)
		// }
	  },
	});
	
  },
//香薰机灯光控制
onSelect_All_aromlight(e) {	
	var that = this;
	this.setData({
	  isClickedToggleAromlight: true  
	});
	// 获取绑定的参数
	var param0 = e.currentTarget.dataset.param0;
	var param1 = e.currentTarget.dataset.param1;
	var param2 = e.currentTarget.dataset.param2;
	// var param3 = e.currentTarget.dataset.param3;
	// var param4 = e.currentTarget.dataset.param4;
	var param5 = e.currentTarget.dataset.param5;
	console.log('param1='+param1);
	console.log('param2='+param2);
	// console.log('param3='+param3);
	// console.log('param4='+param4);
	console.log('param5='+param5);
    // this.setData({
    //   status_beep: Number(param4)
    // })
	// if(param3 == "/turn_on"){
	// 	that.data.listSwitch[param0].state = "off";
	// 	that.data.listSwitch[param0].service = "turn_off";
	// }else if(param3 == "/turn_off"){
	// 	that.data.listSwitch[param0].state = "on";
	// 	that.data.listSwitch[param0].service = "turn_on";
	// }
	 console.log('switch 发生 change 事件，携带值为', e.detail.value)
	wx.request({
	  url: `${homeApi_https}`+param1+param2+'/turn_on', 
	  method: 'POST',
	  data: {
	      "entity_id":param5
	    },
	   header: {
		  'content-type': 'application/json', // 默认值
	      'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
	    },
	  success(res) {
		// if(res.data){
		// 	that.getSwitch(res.data,that)
		// }
	  },
	});
	
  },
  onSelect_Cover(e) {
  	var that = this;
  	// 获取绑定的参数
  	var param0 = e.currentTarget.dataset.param0;
  	var param1 = e.currentTarget.dataset.param1;
  	var param2 = e.currentTarget.dataset.param2;
  	// var param3 = e.currentTarget.dataset.param3;
  	// var param4 = e.currentTarget.dataset.param4;
  	var param5 = e.currentTarget.dataset.param5;
  	console.log('param1='+param1);
  	console.log('param2='+param2);
  	// console.log('param3='+param3);
  	// console.log('param4='+param4);
  	console.log('param5='+param5);
      // this.setData({
      //   status_beep: Number(param4)
      // })
  	// if(param3 == "/turn_on"){
  	// 	that.data.listSwitch[param0].state = "off";
  	// 	that.data.listSwitch[param0].service = "turn_off";
  	// }else if(param3 == "/turn_off"){
  	// 	that.data.listSwitch[param0].state = "on";
  	// 	that.data.listSwitch[param0].service = "turn_on";
  	// }
  	 console.log('switch 发生 change 事件，携带值为', e.detail.value)
  	wx.request({
  	  url: `${homeApi_https}`+param1+param2+(e.detail.value?'/open_cover':'/close_cover'), 
  	  method: 'POST',
  	  data: {
  	      "entity_id":param5
  	    },
  	   header: {
  		  'content-type': 'application/json', // 默认值
  	      'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
  	    },
  	  success(res) {
  		// if(res.data){
  		// 	that.getSwitch(res.data,that)
  		// }
  	  },
  	});
  	
    },
	onStop_Cover(e) {
		var that = this;
		// 获取绑定的参数
		var param0 = e.currentTarget.dataset.param0;
		var param1 = e.currentTarget.dataset.param1;
		var param2 = e.currentTarget.dataset.param2;
		// var param3 = e.currentTarget.dataset.param3;
		// var param4 = e.currentTarget.dataset.param4;
		var param5 = e.currentTarget.dataset.param5;
		console.log('param1='+param1);
		console.log('param2='+param2);
		// console.log('param3='+param3);
		// console.log('param4='+param4);
		console.log('param5='+param5);
	    // this.setData({
	    //   status_beep: Number(param4)
	    // })
		// if(param3 == "/turn_on"){
		// 	that.data.listSwitch[param0].state = "off";
		// 	that.data.listSwitch[param0].service = "turn_off";
		// }else if(param3 == "/turn_off"){
		// 	that.data.listSwitch[param0].state = "on";
		// 	that.data.listSwitch[param0].service = "turn_on";
		// }
		 console.log('switch 发生 change 事件，携带值为', e.detail.value)
		wx.request({
		  url: `${homeApi_https}`+param1+param2+'/stop_cover', 
		  method: 'POST',
		  data: {
		      "entity_id":param5
		    },
		   header: {
			  'content-type': 'application/json', // 默认值
		      'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
		    },
		  success(res) {
			// if(res.data){
			// 	that.getSwitch(res.data,that)
			// }
		  },
		});
		
	  },
  onPressButton(e) {
  	var that = this;
  	// 获取绑定的参数
  	var param = e.currentTarget.dataset.param;
  	console.log("sliderChange-param="+param);
  	// wx.request({
  	//   url: `${homeApi_https}`+param1+param2+param3, 
  	//   method: 'POST',
  	//   data: {
  	//       "entity_id":param5
  	//     },
  	//    header: {
  	// 	  'content-type': 'application/json', // 默认值
  	//       'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
  	//     },
  	//   success(res) {
  	// 	// if(res.data){
  	// 	// 	that.getSwitch(res.data,that)
  	// 	// }
  	//     console.log('res.data====='+JSON.stringify(res.data));
  	//   },
  	// });
	let domain = e.currentTarget.dataset.domain;
	let entity_id = e.currentTarget.dataset.id;	
	let data = {
	  "entity_id":entity_id,
	  // "value":newValue
	  }
	this.getService("/services","/"+domain,"/press","POST",data);
    },
	
onSelect_beep1(e) {
	// 获取绑定的参数
	var param1 = e.currentTarget.dataset.param1;
	var param2 = e.currentTarget.dataset.param2;
	var param3 = e.currentTarget.dataset.param3;
	var param4 = e.currentTarget.dataset.param4;
	var param5 = e.currentTarget.dataset.param5;
	console.log('param1='+param1);
	console.log('param2='+param2);
	console.log('param3='+param3);
	console.log('param4='+param4);
	console.log('param5='+param5);
    this.setData({
      status_beep: Number(param4)
    })
	
	wx.request({
	  url: `${homeApi_https}`+param1+param2+param3, 
	  method: 'POST',
	  data: {
	      "entity_id":param5
	    },
	   header: {
		  'content-type': 'application/json', // 默认值
	      'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
	    },
	  success(res) {
	    console.log('res.data====='+JSON.stringify(res.data));
	  },
	});
	
  },
  status_led1(e) {
  	// 获取绑定的参数
  	var param1 = e.currentTarget.dataset.param1;
  	var param2 = e.currentTarget.dataset.param2;
  	var param3 = e.currentTarget.dataset.param3;
  	var param4 = e.currentTarget.dataset.param4;
  	var param5 = e.currentTarget.dataset.param5;
      this.setData({
        status_led: Number(param4)
      })
  	
  	wx.request({
  	  url: `${homeApi_https}`+param1+param2+param3, 
  	  method: 'POST',
  	  data: {
  	      "entity_id":param5
  	    },
  	   header: {
  		  'content-type': 'application/json', // 默认值
  	      'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
  	    },
  	  success(res) {
  	    console.log('res.data====='+JSON.stringify(res.data));
  	  },
  	});
  	
    },
	status_san1(e) {
		// 获取绑定的参数
		var param1 = e.currentTarget.dataset.param1;
		var param2 = e.currentTarget.dataset.param2;
		var param3 = e.currentTarget.dataset.param3;
		var param4 = e.currentTarget.dataset.param4;
		var param5 = e.currentTarget.dataset.param5;
	    this.setData({
	      status_san: Number(param4)
	    })
		
		wx.request({
		  url: `${homeApi_https}`+param1+param2+param3, 
		  method: 'POST',
		  data: {
		      "entity_id":param5
		    },
		   header: {
			  'content-type': 'application/json', // 默认值
		      'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
		    },
		  success(res) {
		    console.log('res.data====='+JSON.stringify(res.data));
		  },
		});
		
	  },
	  status_curtain1(e) {
	  	// 获取绑定的参数
	  	var param1 = e.currentTarget.dataset.param1;
	  	var param2 = e.currentTarget.dataset.param2;
	  	var param3 = e.currentTarget.dataset.param3;
	  	var param4 = e.currentTarget.dataset.param4;
	  	var param5 = e.currentTarget.dataset.param5;
	      this.setData({
	        status_curtain: Number(param4)
	      })
	  	
	  	wx.request({
	  	  url: `${homeApi_https}`+param1+param2+param3, 
	  	  method: 'POST',
	  	  data: {
	  	      "entity_id":param5
	  	    },
	  	   header: {
	  		  'content-type': 'application/json', // 默认值
	  	      'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
	  	    },
	  	  success(res) {
	  	    console.log('res.data====='+JSON.stringify(res.data));
	  	  },
	  	});
	  	
	    },
		status_door1(e) {
			// 获取绑定的参数
			var param1 = e.currentTarget.dataset.param1;
			var param2 = e.currentTarget.dataset.param2;
			var param3 = e.currentTarget.dataset.param3;
			var param4 = e.currentTarget.dataset.param4;
			var param5 = e.currentTarget.dataset.param5;
		    this.setData({
		      status_door: Number(param4)
		    })
			
			wx.request({
			  url: `${homeApi_https}`+param1+param2+param3, 
			  method: 'POST',
			  data: {
			      "entity_id":param5
			    },
			   header: {
				  'content-type': 'application/json', // 默认值
			      'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
			    },
			  success(res) {
			    console.log('res.data====='+JSON.stringify(res.data));
			  },
			});
			
		  },
  onOpen_curtain() {
    this.setData({ show_curtain: true });
  },
  onClose_curtain(){
    this.setData({
      show_curtain:false
    })
},
  onSelect_curtain(event) {
    console.log(event.detail.id);
    this.onCurtainChange(event.detail.id);
  },
  onOpen_san() {
    this.setData({ show_san: true });
  },
  onClose_san(){
    this.setData({
      show_san:false
    })
},
  onSelect_san(event) {
    console.log(event.detail.id);
    this.onSanChange(event.detail.id);
  },

  onOpen_door() {
    this.setData({ show_door: true });
  },
  onClose_door(){
    this.setData({
      show_door:false
    })
},
  onSelect_door(event) {
    console.log(event.detail.id);
    this.onDoorChange(event.detail.id);
  },
  

  // 各个设备弹窗逻辑 结束



  //设备控制函数 开始
  onFireChange(event){
    var that = this;
    console.log(event);
    let sw = event;
    that.setData({
      status_led: sw
    })
    
    if (sw) {
      that.data.client.publish(mpPubTopic_LED, '{"target":"LED","value":1}', function (err) {
        if (!err) {
          console.log("成功下发命令——打开客厅灯");
        }
      });
    } else {
      that.data.client.publish(mpPubTopic_LED, '{"target":"LED","value":0}', function (err) {
        if (!err) {
          console.log("成功下发命令——关闭客厅灯");
        }
      });
    }
  },


  onLedChange(event) {
    var that = this;
    console.log(event);
    let sw = event;
    that.setData({
      status_led: sw
    })
    
    if (sw) {
      that.data.client.publish(mpPubTopic_LED, '{"target":"LED","value":1}', function (err) {
        if (!err) {
          console.log("成功下发命令——打开客厅灯");
        }
      });
    } else {
      that.data.client.publish(mpPubTopic_LED, '{"target":"LED","value":0}', function (err) {
        if (!err) {
          console.log("成功下发命令——关闭客厅灯");
        }
      });
    }
  },

  onBeepChange(event,url,entity_id) {
    var that = this;
    console.log(event);
    let sw = event;
    that.setData({
      status_beep: sw
    })
	console.log("event="+event);
	console.log("url="+url);
	console.log("entity_id="+entity_id);
    if (sw) {
      // that.data.client.publish(mpPubTopic_BEEP, '{"target":"BEEP","value":1}', function (err) {
      //   if (!err) {
      //     console.log("成功下发命令——打开报警器");
      //   }
      // });
	  this.onSelect_vangrid(url,entity_id);
    } else {
      // that.data.client.publish(mpPubTopic_BEEP, '{"target":"BEEP","value":0}', function (err) {
      //   if (!err) {
      //     console.log("成功下发命令——关闭报警器");
      //   }
      // });
	  this.onSelect_vangrid(url,entity_id);
    }
  },

  onCurtainChange(event) {
    var that = this;
    console.log(event);
    let sw = event;
    that.setData({
      status_curtain: sw
    })
    if (sw) {
      that.data.client.publish(mpPubTopic_CU, '{"target":"CU","value":1}', function (err) {
        if (!err) {
          console.log("成功下发命令——开窗帘");
        }
      });
    } else{
      that.data.client.publish(mpPubTopic_CU, '{"target":"CU","value":0}', function (err) {
        if (!err) {
          console.log("成功下发命令——关窗帘");
        }
      });
    }
  },


  onSanChange(event) {
    var that = this;
    console.log(event);
    let sw = event;
    that.setData({
      status_san: sw
    })
    if (sw) {
      that.data.client.publish(mpPubTopic_SAN, '{"target":"SAN","value":1}', function (err) {
        if (!err) {
          console.log("成功下发命令——开风扇");
        }
      });
    } else{
      that.data.client.publish(mpPubTopic_SAN, '{"target":"SAN","value":0}', function (err) {
        if (!err) {
          console.log("成功下发命令——关风扇");
        }
      });
    }
  },

  onDoorChange(event) {
    var that = this;
    console.log(event);
    let sw = event;
    that.setData({
      status_door: sw
    })
    if (sw) {
      that.data.client.publish(mpPubTopic_DO, '{"target":"DO","value":1}', function (err) {
        if (!err) {
          console.log("成功下发命令——开门");
        }
      });
    } else{
      that.data.client.publish(mpPubTopic_DO, '{"target":"DO","value":0}', function (err) {
        if (!err) {
          console.log("成功下发命令——关门");
        }
      });
    }
  },

  onModeChange(event) {
    var that = this;
    console.log(event);
    let sw = event.detail.value;
    console.log(sw);
    that.setData({
      status_mode: sw
    })
    if (sw) {
      that.data.client.publish(mpPubTopic_Mode, '{"target":"OUT","value":1}', function (err) {
        if (!err) {
          console.log("成功下发命令——离家模式");
        }
      });
    } else{
      that.data.client.publish(mpPubTopic_Mode, '{"target":"OUT","value":0}', function (err) {
        if (!err) {
          console.log("成功下发命令——居家模式");
        }
      });
    }
  },

	getEntityState(list,entity_id) {
		if(list==null) return null;
		var obj = list.find(function (obj) {
			return obj.entity_id === entity_id
		})
		console.log('getEntityState=='+obj?(obj.state=='on'?1:0):null);
		return obj?(obj.state=='on'?1:0):null;
	},
	getEntityStateValue(list,entity_id) {
		if(list==null) return null;
		var obj = list.find(function (obj) {
			return obj.entity_id === entity_id
		})
		console.log('getEntityStateValue=='+obj?obj.state:null);
		return obj?obj.state:null;
	},
  
  //扫码
  tapScan(){
          wx.scanCode({
              success: function(res) {
                  console.log('扫码获取的参数',res)
              }
          })
      },
	  getSwitch(resData,that) {
	  	try {		  
	  		var listSwitchTemp = [];
	  		var entityIdList = [];
	  		const res = wx.getStorageSync('res');
	  		const home_room = wx.getStorageSync('res').home_room;
	  		for(let i=0;i<resData.length;i++){
	  		  if(resData[i].attributes && resData[i].attributes.home_room && resData[i].attributes.home_room.includes((entity))){
	  			entityIdList.push(resData[i].entity_id)
	  		  }
	  		}
	  		console.log('entityIdList====='+JSON.stringify(entityIdList));
	  		for(let i=0;i<resData.length;i++){
	  		  if((resData[i].attributes && resData[i].attributes.home_room && resData[i].attributes.home_room.includes((entity)))
	  			  || (resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id))
	  		  ){
	  		  var obj={};
	  			  obj.entity_id = resData[i].entity_id;//实体ID
	  			  obj.parent_entity_id = resData[i].parent_entity_id;//父实体ID
	  			  //api/services/<domain>/<service>
	  			  if(resData[i].entity_id){
	  				obj.domain = resData[i].entity_id.split(".")[0];
	  			  }
	  			  obj.state = (resData[i].state=='unknown'?"未知":resData[i].state);
	  			  if(resData[i].attributes && resData[i].attributes.friendly_name){
	  				obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name); //设备名称
	  			  }
	  			  if(resData[i].attributes && resData[i].attributes.home_room){
	  				obj.home_room = resData[i].attributes.home_room.split(' ')[1]; //房间号
	  			  }
	  			  if((resData[i].state && (resData[i].state=='on' || resData[i].state=='off'))||
	  				(resData[i].state && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList 
	  				&& entityIdList.includes(resData[i].attributes.parent_entity_id) && (resData[i].state=='on' || resData[i].state=='off'))
	  			  ){
	  				  if(resData[i].state=='on'){
	  					  obj.service = 'turn_on';
	  				  }else if(resData[i].state=='off'){
	  					  obj.service = 'turn_off';
	  				  }
					  //是否 是香薰机灯光
					  obj.isAromlight = obj.friendly_name.includes('香薰机灯光')
	  				  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
	  					  listSwitchTemp.push(obj)
	  				  }
	  			  }
	  			   }
	  		  }
	  		  console.log('listSwitchTemp='+JSON.stringify(listSwitchTemp));	
	  		  that.setData({
	  		  listSwitch:listSwitchTemp,
	  		  })
	  		  } catch (error) {
	  		  console.error(error);
	  	}
	  },
 //设备控制函数 结束
  sliderChange(e){
		let list = this.data.listScroll;//这里是将需要循环的数组赋值给list
		let indexS = Number(e.currentTarget.dataset.index);
		let domain = e.currentTarget.dataset.domain;
		let entity_id = e.currentTarget.dataset.id;
		  // 将本地缓存数据渲染到对应修改的案例
		list.forEach(function (value,index, array){
		  
		  if (index == indexS) {
		     array[index].state = e.detail.value;
		    }
		})
		this.setData({
		  listScroll: list
		})
		let data = {
	  	      "entity_id":entity_id,
			  "value":e.detail.value,
	  	    }
		this.getService("/services","/"+domain,"/set_value","POST",data);
		// 设置两秒（2000毫秒）后的延迟
		// setTimeout(() => {  
		//   this.getMiotMediaPlayer(this); 
		// }, 2000);  
  },
  onArrowUp(e) {
      // 在这里处理向上箭头的点击事件  
      // 例如，你可以增加文本框的值  
      let currentValue = e.currentTarget.dataset.state;  
      let newValue = parseInt(currentValue) + 1; // 假设文本框中的是数字  
      // this.setData({  
      //   inputValue: newValue.toString()  
      // });  
	  
	  let list = this.data.listUnit;//这里是将需要循环的数组赋值给list
	  let indexS = Number(e.currentTarget.dataset.index)
	  let domain = e.currentTarget.dataset.domain;
	  let entity_id = e.currentTarget.dataset.id;
	    // 将本地缓存数据渲染到对应修改的案例
	  list.forEach(function (value,index, array){
	    if (index == indexS) {
	       array[index].state = newValue;
	      }
	  })
	  this.setData({
	    listUnit: list
	  })
	  let data = {
	      "entity_id":entity_id,
	  	  "value":newValue
	      }
	  this.getService("/services","/"+domain,"/set_value","POST",data);
    },  
	changeHumidity(e){
			let list = this.data.listHumidifier;//这里是将需要循环的数组赋值给list
			let indexS = Number(e.currentTarget.dataset.index);
			let domain = e.currentTarget.dataset.domain;
			let entity_id = e.currentTarget.dataset.id;
			  // 将本地缓存数据渲染到对应修改的案例
			list.forEach(function (value,index, array){
			  
			  if (index == indexS) {
			     array[index].humidity = e.detail.value;
			    }
			})
			this.setData({
			  listHumidifier: list
			})
			let data = {
			      "entity_id":entity_id,
			  	  "humidity":e.detail.value
			      }
			  this.getService("/services","/"+domain,"/set_humidity","POST",data); 
	  },
    onHumidifierDown(e) {
	  var that = this;
	  this.setData({
	    isClickedOnHumidifierDown: true  
	  });
      // 在这里处理向下箭头的点击事件  
      // 例如，你可以减少文本框的值  
      let currentValue = e.currentTarget.dataset.humidity; 
	  let min = e.currentTarget.dataset.min;
	  let max = e.currentTarget.dataset.max;
      let newValue = parseInt(currentValue) - 1; // 假设文本框中的是数字 
	   if(newValue<min){
		   newValue = min;
	   }
      // this.setData({  
      //   inputValue: newValue.toString()  
      // });  
	  
	  let list = this.data.listHumidifier;//这里是将需要循环的数组赋值给list
	  let indexS = Number(e.currentTarget.dataset.index)
	  let domain = e.currentTarget.dataset.domain;
	  let entity_id = e.currentTarget.dataset.id;
	    // 将本地缓存数据渲染到对应修改的案例
	  list.forEach(function (value,index, array){
	    if (index == indexS) {
	       array[index].humidity = newValue;
	      }
	  })
	  this.setData({
	    listHumidifier: list,
		// isButtonPressedHumidityDown:!that.data.isButtonPressedHumidityDown
	  })
	  let data = {
	        "entity_id":entity_id,
	  	    "humidity":newValue
	      }
	  this.getService("/services","/"+domain,"/set_humidity","POST",data);
    },
	onHumidifierUp(e) {
		var that = this;
		this.setData({
		  isClickedOnHumidifierUp: true  
		});
	    // 在这里处理向上箭头的点击事件  
	    // 例如，你可以增加文本框的值  
	    let currentValue = e.currentTarget.dataset.humidity;  
		let min = e.currentTarget.dataset.min;
		let max = e.currentTarget.dataset.max;
	    let newValue = parseInt(currentValue) + 1; // 假设文本框中的是数字  
		if(newValue>max){
			newValue = max;
		}
	    // this.setData({  
	    //   inputValue: newValue.toString()  
	    // });  
		  
		  let list = this.data.listHumidifier;//这里是将需要循环的数组赋值给list
		  let indexS = Number(e.currentTarget.dataset.index)
		  let domain = e.currentTarget.dataset.domain;
		  let entity_id = e.currentTarget.dataset.id;
		    // 将本地缓存数据渲染到对应修改的案例
		  list.forEach(function (value,index, array){
		    if (index == indexS) {
		       array[index].humidity = newValue;
		      }
		  })
		  this.setData({
		    listHumidifier: list,
			// isButtonPressedHumidityUp:!that.data.isButtonPressedHumidityUp
		  })
		  let data = {
		      "entity_id":entity_id,
		  	  "humidity":newValue
		      }
		  this.getService("/services","/"+domain,"/set_humidity","POST",data);
	  },  
	  onHumidifierOn(e) {
	    let domain = e.currentTarget.dataset.domain;
	    let entity_id = e.currentTarget.dataset.id;
	    let data = {
	          "entity_id":entity_id,
	        }
	    this.getService("/services","/"+domain,"/turn_on","POST",data);
	  },
	  onHumidifierOff(e) {
	    let domain = e.currentTarget.dataset.domain;
	    let entity_id = e.currentTarget.dataset.id;
		let min = e.currentTarget.dataset.min;
		let max = e.currentTarget.dataset.max;
	    let data = {
	          "entity_id":entity_id,
	        }
	    this.getService("/services","/"+domain,"/turn_off","POST",data);
	  },
	  
	  changeClimate(e) {
	  		  var that = this;
	  		  this.setData({
	  		    isClickedOnClimateUp: true  
	  		  });
	  		  console.log('that.data.climateMode=='+that.data.climateMode);
	  		  if(!that.data.climateMode){
	  		  	wx.showToast({
	  		  	  title: '请先选择模式',  
	  		  	  icon: 'none'  
	  		  	});  
	  		  	return;
	  		  }
	  	      let currentValue = e.currentTarget.dataset.temperature;  
	  		  let fanMode = e.currentTarget.dataset.fanMode;  
	  	       
	  		  let min = e.currentTarget.dataset.min;
	  		  let max = e.currentTarget.dataset.max;
	  	  	  let domain = e.currentTarget.dataset.domain;
	  	  	  let entity_id = e.currentTarget.dataset.id;
	  	  	  let data = {};
	  	  	  if(that.data.climateMode=='heat' ||that.data.climateMode=='cool'){
	  	  	  	let newValue = parseInt(currentValue) + 1; // 假设文本框中的是数字 
	  	  	  	 if(newValue>max) newValue = max;
	  			 let list = this.data.listClimate;//这里是将需要循环的数组赋值给list
	  			  let indexS = Number(e.currentTarget.dataset.index);
	  			   // 将本地缓存数据渲染到对应修改的案例
	  			  list.forEach(function (value,index, array){
	  				if (index == indexS) {
	  				   array[index].temperature = e.detail.value;
	  				  }
	  			  })
	  			  this.setData({
	  				listClimate: list
	  			  })
	  	  	  	data = {
	  	  	  	  "entity_id":entity_id,
	  	  	  		"temperature":e.detail.value,
	  				"hvac_mode":that.data.climateMode
	  	  	  	}
	  	  	  	this.getService("/services","/"+domain,"/set_temperature","POST",data);
	  	  	  }else if(that.data.climateMode=='dry'){
	  	  	  	let newValue = parseInt(currentValue) + 1; // 假设文本框中的是数字 
	  	  	  	 if(newValue>max) newValue = max;
	  	  	  	data = {
	  	  	  	  "entity_id":entity_id,
	  	  	  		"temperature":e.detail.value,
	  				"hvac_mode":that.data.climateMode
	  	  	  	}
	  	  	  	this.getService("/services","/"+domain,"/set_temperature","POST",data);
	  	  	  }else if(that.data.climateMode=='fan_only'){
	  		   let newValue = parseInt(currentValue) + 1; // 假设文本框中的是数字
	  		   if(newValue>max) newValue = max;
	  	  	  	data = {
	  	  	  	  "entity_id":entity_id,
	  	  	  	  // "fan_mode":(fanMode=='Fan Speed Up')?'Fan Speed Down':'Fan Speed Up',
	  	  	  		"temperature":e.detail.value,
	  				"hvac_mode":that.data.climateMode
	  	  	  	}
	  	  	  	this.getService("/services","/"+domain,"/set_temperature","POST",data);
	  	  	  }
	  	    },
	  onClimateDown(e) {
		  var that = this;
		if(!that.data.climateMode){
			wx.showToast({
			  title: '请先选择模式',  
			  icon: 'none'  
			});  
			return;
		}
		console.log('that.data.climateMode=='+that.data.climateMode);
	    let currentValue = e.currentTarget.dataset.temperature; 
		let fanMode = e.currentTarget.dataset.fanMode; 
	    // let list = this.data.listClimate;
	    // this.setData({  
	    //   inputValue: newValue.toString()  
	    // });  
	    
	    
	    let domain = e.currentTarget.dataset.domain;
	    let entity_id = e.currentTarget.dataset.id;
		let min = e.currentTarget.dataset.min;
		let max = e.currentTarget.dataset.max;
		// this.setData({
		// 	isButtonPressedClimateDown: !that.data.isButtonPressedClimateDown
		// })
	      // 将本地缓存数据渲染到对应修改的案例
	    // list.forEach(function (value,index, array){
	    //   if (index == indexS) {
	    //      array[index].temperature = newValue;
	    //     }
	    // })
	    // this.setData({
	    //   listClimate: list
	    // })
	    let data = {};
	    if(that.data.climateMode=='heat' ||that.data.climateMode=='cool'){
	    	let newValue = parseInt(currentValue) - 1; // 假设文本框中的是数字 
	    	 if(newValue<min) newValue = min;
			 let list = this.data.listClimate;//这里是将需要循环的数组赋值给list
			  let indexS = Number(e.currentTarget.dataset.index);
			   // 将本地缓存数据渲染到对应修改的案例
			  list.forEach(function (value,index, array){
				if (index == indexS) {
				   array[index].temperature = newValue;
				  }
			  })
			  this.setData({
				listClimate: list
			  })
			  console.log('onClimateDown-entity_id='+entity_id);
	    	data = {
	    	  "entity_id":entity_id,
	    		"temperature":newValue,
				"hvac_mode":that.data.climateMode
	    	}
	    	this.getService("/services","/"+domain,"/set_temperature","POST",data);
	    }else if(that.data.climateMode=='dry'){
	    	let newValue = parseInt(currentValue) - 1; // 假设文本框中的是数字 
	    	 if(newValue<min) newValue = min;
	    	data = {
	    	  "entity_id":entity_id,
	    		"temperature":newValue,
				"hvac_mode":that.data.climateMode
	    	}
	    	this.getService("/services","/"+domain,"/set_temperature","POST",data);
	    }else if(that.data.climateMode=='fan_only'){
			let newValue = parseInt(currentValue) - 1; // 假设文本框中的是数字
			 if(newValue<min) newValue = min;
	    	data = {
	    	  "entity_id":entity_id,
	    	  // "fan_mode":(fanMode=='Fan Speed Up')?'Fan Speed Down':'Fan Speed Up',
	    		"temperature":newValue,
				"hvac_mode":that.data.climateMode
	    	}
	    	this.getService("/services","/"+domain,"/set_temperature","POST",data);
	    }
	  },
	  onClimateUp(e) {
		  var that = this;
		  this.setData({
		    isClickedOnClimateUp: true  
		  });
		  console.log('that.data.climateMode=='+that.data.climateMode);
		  if(!that.data.climateMode){
		  	wx.showToast({
		  	  title: '请先选择模式',  
		  	  icon: 'none'  
		  	});  
		  	return;
		  }
	      let currentValue = e.currentTarget.dataset.temperature;  
		  let fanMode = e.currentTarget.dataset.fanMode;  
	       
		  let min = e.currentTarget.dataset.min;
		  let max = e.currentTarget.dataset.max;
	      // this.setData({  
	      //   inputValue: newValue.toString()  
	      // });  
	  	  
	  	  // let list = this.data.listClimate;//这里是将需要循环的数组赋值给list
	  	  // let indexS = Number(e.currentTarget.dataset.index)
	  	  let domain = e.currentTarget.dataset.domain;
	  	  let entity_id = e.currentTarget.dataset.id;
		  // this.setData({
		  // 	isButtonPressedClimateUp: !that.data.isButtonPressedClimateUp
		  // })
	  	    // 将本地缓存数据渲染到对应修改的案例
	  	  // list.forEach(function (value,index, array){
	  	  //   if (index == indexS) {
	  	  //      array[index].temperature = newValue;
	  	  //     }
	  	  // })
	  	  // this.setData({
	  	  //   listClimate: list
	  	  // })
	  	  let data = {};
	  	  if(that.data.climateMode=='heat' ||that.data.climateMode=='cool'){
	  	  	let newValue = parseInt(currentValue) + 1; // 假设文本框中的是数字 
	  	  	 if(newValue>max) newValue = max;
			 let list = this.data.listClimate;//这里是将需要循环的数组赋值给list
			  let indexS = Number(e.currentTarget.dataset.index);
			   // 将本地缓存数据渲染到对应修改的案例
			  list.forEach(function (value,index, array){
				if (index == indexS) {
				   array[index].temperature = newValue;
				  }
			  })
			  this.setData({
				listClimate: list
			  })
	  	  	data = {
	  	  	  "entity_id":entity_id,
	  	  		"temperature":newValue,
				"hvac_mode":that.data.climateMode
	  	  	}
	  	  	this.getService("/services","/"+domain,"/set_temperature","POST",data);
	  	  }else if(that.data.climateMode=='dry'){
	  	  	let newValue = parseInt(currentValue) + 1; // 假设文本框中的是数字 
	  	  	 if(newValue>max) newValue = max;
	  	  	data = {
	  	  	  "entity_id":entity_id,
	  	  		"temperature":newValue,
				"hvac_mode":that.data.climateMode
	  	  	}
	  	  	this.getService("/services","/"+domain,"/set_temperature","POST",data);
	  	  }else if(that.data.climateMode=='fan_only'){
		   let newValue = parseInt(currentValue) + 1; // 假设文本框中的是数字
		   if(newValue>max) newValue = max;
	  	  	data = {
	  	  	  "entity_id":entity_id,
	  	  	  // "fan_mode":(fanMode=='Fan Speed Up')?'Fan Speed Down':'Fan Speed Up',
	  	  		"temperature":newValue,
				"hvac_mode":that.data.climateMode
	  	  	}
	  	  	this.getService("/services","/"+domain,"/set_temperature","POST",data);
	  	  }
	    },  
	  onClimateAuto(e) {
		this.setData({
		  isClickedOnClimateAuto: true  
		});  
	    let domain = e.currentTarget.dataset.domain;
	    let entity_id = e.currentTarget.dataset.id;
		let list = this.data.listClimate;//这里是将需要循环的数组赋值给list
		let indexS = Number(e.currentTarget.dataset.index);
		// 将本地缓存数据渲染到对应修改的案例
		list.forEach(function (value,index, array){
		if (index == indexS) {
		   array[index].state = newValue;
		  }
		})
		this.setData({
			temperatureHumidifyName:'自动',
			climateMode:'auto',
			listClimate: list
		})
	    let data = {
	          "entity_id":entity_id,
			  "hvac_mode":'auto',
	        }
	    this.getService("/services","/"+domain,"/set_hvac_mode","POST",data);
	  },
	  onClimateHeat(e) {
	    let domain = e.currentTarget.dataset.domain;
	    let entity_id = e.currentTarget.dataset.id;
		let list = this.data.listClimate;//这里是将需要循环的数组赋值给list
		let indexS = Number(e.currentTarget.dataset.index);
		// 将本地缓存数据渲染到对应修改的案例
		list.forEach(function (value,index, array){
		if (index == indexS) {
		   array[index].state = newValue;
		  }
		})
		this.setData({
			temperatureHumidifyName:'制热',
			climateMode:'heat',
			listClimate: list
		})
	    let data = {
	          "entity_id":entity_id,
	    	  "hvac_mode":'heat',
	        }
	    this.getService("/services","/"+domain,"/set_hvac_mode","POST",data);
	  },
	  onClimateCool(e) {
	    let domain = e.currentTarget.dataset.domain;
	    let entity_id = e.currentTarget.dataset.id;
		let list = this.data.listClimate;//这里是将需要循环的数组赋值给list
		let indexS = Number(e.currentTarget.dataset.index);
		// 将本地缓存数据渲染到对应修改的案例
		list.forEach(function (value,index, array){
		if (index == indexS) {
		   array[index].state = newValue;
		  }
		})
		this.setData({
			temperatureHumidifyName:'制冷',
			climateMode:'cool',
			listClimate: list
		})
	    let data = {
	          "entity_id":entity_id,
	    	  "hvac_mode":'cool',
	        }
	    this.getService("/services","/"+domain,"/set_hvac_mode","POST",data);
	  },
	  onClimateDehumidify(e) {
	    let domain = e.currentTarget.dataset.domain;
	    let entity_id = e.currentTarget.dataset.id;
		let list = this.data.listClimate;//这里是将需要循环的数组赋值给list
		let indexS = Number(e.currentTarget.dataset.index);
		// 将本地缓存数据渲染到对应修改的案例
		list.forEach(function (value,index, array){
		if (index == indexS) {
		   array[index].state = newValue;
		  }
		})
		this.setData({
			temperatureHumidifyName:'除湿',
			climateMode:'dry',
			listClimate: list
		})
	    let data = {
	          "entity_id":entity_id,
	    	  "hvac_mode":'dry',
	        }
	    this.getService("/services","/"+domain,"/set_hvac_mode","POST",data);
	  },
	  onClimateAirSupply(e) {
	    let domain = e.currentTarget.dataset.domain;
	    let entity_id = e.currentTarget.dataset.id;
		let list = this.data.listClimate;//这里是将需要循环的数组赋值给list
		let indexS = Number(e.currentTarget.dataset.index);
		// 将本地缓存数据渲染到对应修改的案例
		list.forEach(function (value,index, array){
		if (index == indexS) {
		   array[index].state = newValue;
		  }
		})
		this.setData({
			temperatureHumidifyName:'送风',
			climateMode:'fan_only',
			listClimate: list
		})
	    let data = {
	          "entity_id":entity_id,
	    	  "hvac_mode":'fan_only',
	        }
	    this.getService("/services","/"+domain,"/set_hvac_mode","POST",data);
	  },
	  onClimateOff(e) {
	    let domain = e.currentTarget.dataset.domain;
	    let entity_id = e.currentTarget.dataset.id;
		let list = this.data.listClimate;//这里是将需要循环的数组赋值给list
		let indexS = Number(e.currentTarget.dataset.index);
		// 将本地缓存数据渲染到对应修改的案例
		list.forEach(function (value,index, array){
		if (index == indexS) {
		   array[index].state = newValue;
		  }
		})
		this.setData({
			temperatureHumidifyName:'关闭',
			climateMode:'off',
			listClimate: list
		})
	    let data = {
	          "entity_id":entity_id,
	        }
	    this.getService("/services","/"+domain,"/turn_off","POST",data);
	  },
	  handleInput: function(e) {
	      // 这里你需要自己实现歌曲列表和切换逻辑  
	      // 例如，如果你有一个歌曲列表，你可以通过修改当前播放歌曲的索引来切换歌曲  
	      // 假设你有一个歌曲列表`songs`和一个当前歌曲索引`currentIndex`  
	      // if (this.data.currentIndex > 0) {
	      //   this.data.currentIndex--;  
	      //   // 加载新歌曲并播放  
	      //   this.loadAndPlaySong(this.data.currentIndex);  
	      // }
		let min = e.currentTarget.dataset.min;
		let max = e.currentTarget.dataset.max;
		if(e.detail.value && (e.detail.value.length>max || e.detail.value.length<min)){
			wx.showModal({
			  title: '提示',
			  content: '文本长度介于'+min+'~'+max+'长度之间',
			  showCancel: false
			});
			return;
		}
	  	let domain = e.currentTarget.dataset.domain;
	  	let entity_id = e.currentTarget.dataset.id;	
	  	let data = {
	  	    "entity_id":entity_id,
			"value":e.detail.value,
	  	    }
	  	this.getService("/services","/"+domain,"/set_value","POST",data);
	    }, 
	  onArrowDown(e) {
	    // 在这里处理向下箭头的点击事件  
	    // 例如，你可以减少文本框的值  
	    let currentValue = e.currentTarget.dataset.state; 
	    let newValue = parseInt(currentValue) - 1; // 假设文本框中的是数字  
	    // this.setData({  
	    //   inputValue: newValue.toString()  
	    // });  
		  
		  let list = this.data.listUnit;//这里是将需要循环的数组赋值给list
		  let indexS = Number(e.currentTarget.dataset.index)
		  let domain = e.currentTarget.dataset.domain;
		  let entity_id = e.currentTarget.dataset.id;
		    // 将本地缓存数据渲染到对应修改的案例
		  list.forEach(function (value,index, array){
		    if (index == indexS) {
		       array[index].state = newValue;
		      }
		  })
		  this.setData({
		    listUnit: list
		  })
		  let data = {
		      "entity_id":entity_id,
		  	  "value":newValue
		      }
		  this.getService("/services","/"+domain,"/set_value","POST",data);
	  },
	prevSong: function(e) {
	    // 这里你需要自己实现歌曲列表和切换逻辑  
	    // 例如，如果你有一个歌曲列表，你可以通过修改当前播放歌曲的索引来切换歌曲  
	    // 假设你有一个歌曲列表`songs`和一个当前歌曲索引`currentIndex`  
	    // if (this.data.currentIndex > 0) {
	    //   this.data.currentIndex--;  
	    //   // 加载新歌曲并播放  
	    //   this.loadAndPlaySong(this.data.currentIndex);  
	    // }
		this.setData({  
		  isClickedPrevSong: true  
		});
		let domain = e.currentTarget.dataset.domain;
		let entity_id = e.currentTarget.dataset.id;	
		let data = {
		    "entity_id":entity_id,
		    }
		this.getService("/services","/"+domain,"/media_previous_track","POST",data);
		// setTimeout(() => {
		//   this.getMiotMediaPlayer(this); 
		// }, 8000); 
	  }, 
	  
	  tvTurnOn: function(e) {
	  	let domain = e.currentTarget.dataset.domain;
	  	let entity_id = e.currentTarget.dataset.id;	
	  	let data = {
	  	    "entity_id":entity_id,
	  	    }
	  	this.getService("/services","/"+domain,"/turn_on","POST",data);
	    }, 
		tvTurnOff: function(e) {
			let domain = e.currentTarget.dataset.domain;
			let entity_id = e.currentTarget.dataset.id;	
			let data = {
			    "entity_id":entity_id,
			    }
			this.getService("/services","/"+domain,"/turn_off","POST",data);
		  }, 
		
	  // 切换播放/暂停  
	  togglePlayPause: function(e) {  
		// console.log("this.data.isPlaying="+this.data.isPlaying);
	 //    if (this.data.isPlaying) {  
	 //      this.innerAudioContext.pause();  
		//   this.setData({ isPlaying: false });
		//   this.getService("/services","/"+domain,"/media_pause","POST",null);
	 //    } else {  
	 //      this.innerAudioContext.play();  
		//   this.setData({ isPlaying: true });
		//   this.getService("/services","/"+domain,"/media_play","POST",null);
	 //    }  
	    // let list = this.data.listMiotMediaPlayer;//这里是将需要循环的数组赋值给list
		this.setData({
		  isClickedTogglePlayPause: true  
		});
	    let indexS = Number(e.currentTarget.dataset.index)
	    let domain = e.currentTarget.dataset.domain;
	    let entity_id = e.currentTarget.dataset.id;
		let state = e.currentTarget.dataset.state;
	      // 将本地缓存数据渲染到对应修改的案例
	    // list.forEach(function (value,index, array){
	    //   if (index == indexS) {
	    //      array[index].state = (state=='playing'?'idle':'playing');
	    //     }
	    // })
	    // this.setData({
	    //   listMiotMediaPlayer: list
	    // })
		let data = {
		    "entity_id":entity_id,
		    }
		this.getService("/services","/"+domain,"/media_play_pause","POST",data);
		
		// 设置两秒（2000毫秒）后的延迟  
		    // setTimeout(() => {  
		    //   this.getMiotMediaPlayer(this); 
		    // }, 8000);  
		
	  },  
	  
	  // 切换下一首歌曲  
	  nextSong: function(e) {  
	    // 和prevSong类似，你需要实现歌曲列表和切换逻辑  
	    // 假设歌曲列表为`songs`，当前歌曲索引为`currentIndex`  
	    // if (this.data.currentIndex < songs.length - 1) {  
	    //   this.data.currentIndex++;  
	    //   // 加载新歌曲并播放  
	    //   this.loadAndPlaySong(this.data.currentIndex);  
	    // }
		this.setData({
		  isClickedNextSong: true  
		});
		let domain = e.currentTarget.dataset.domain;
		let entity_id = e.currentTarget.dataset.id;	
		let data = {
		    "entity_id":entity_id,
		    }
		this.getService("/services","/"+domain,"/media_next_track","POST",data);
		// setTimeout(() => {
		//   this.getMiotMediaPlayer(this); 
		// }, 8000); 
	  },  
	  
	  // 加载并播放指定索引的歌曲  
	  loadAndPlaySong: function(index) {
	    // 假设你有一个歌曲列表`songs`，每个歌曲对象有`url`属性表示音频链接  
	    const song = songs[index];  
	    this.innerAudioContext.src = song.url;  
	    this.innerAudioContext.play();  
	    // 更新当前播放的歌曲信息（例如标题和艺术家）  
	    this.setData({  
	      currentSongTitle: song.title,  
	      currentSongArtist: song.artist  
	    });  
	  },
	   base64Decode:function(input) {  
	      const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';  
	      let str = '';  
	      let output = '';  
	      let chr1, chr2, chr3;  
	      let enc1, enc2, enc3, enc4;  
	      let i = 0;  
	    
	      input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");  
	    
	      while (i < input.length) {  
	          enc1 = chars.indexOf(input.charAt(i++));  
	          enc2 = chars.indexOf(input.charAt(i++));  
	          enc3 = chars.indexOf(input.charAt(i++));  
	          enc4 = chars.indexOf(input.charAt(i++));  
	    
	          chr1 = (enc1 << 2) | (enc2 >> 4);  
	          chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);  
	          chr3 = ((enc3 & 3) << 6) | enc4;  
	    
	          str += String.fromCharCode(chr1);  
	    
	          if (enc3 != 64) {  
	              str += String.fromCharCode(chr2);  
	          }  
	          if (enc4 != 64) {  
	              str += String.fromCharCode(chr3);  
	          }  
	      }  
	    
	      return str;  
	  },
	  onPickerChange: function(e) {
	   //    this.setData({  
	   //      selectedIndex: e.detail.value  
	   //    });  
	   //    // 可以在这里处理选中值的变化，比如发送请求等  
	   //    console.log('选中的值是：', this.data.options[e.detail.value].value);  
		  
		  let list = this.data.listSelect;//这里是将需要循环的数组赋值给list
		  let indexS = Number(e.currentTarget.dataset.index)
		  let domain = e.currentTarget.dataset.domain;
		  let entity_id = e.currentTarget.dataset.id;
		    // 将本地缓存数据渲染到对应修改的案例
		  list.forEach(function (value,index, array){
		    if (index == indexS) {
		       array[index].selectedIndex = e.detail.value;
		      }
		  })
		  this.setData({
		    listSelect: list
		  })
		  let data = {
		      "entity_id":entity_id,
		  	  "option":e.detail.value,
		      }
		  this.getService("/services","/"+domain,"/select_option","POST",data);
	    },
		getService(services,domain,service,method,data) {
			wx.request({
			  url: `${homeApi_https}`+services+domain+service, 
			  method: method,
			  data: data,
			   header: {
				  'content-type': 'application/json', // 默认值
				  'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
				},
			  success(res) {
				console.log('res.data====='+JSON.stringify(res.data));
			  },
			});
		},
		// 初始化时调用即可
	  showCanvasRing() {
		  try {
			//作画
			var ctx = wx.createCanvasContext("circleBar", this); //canvas组建封装，需要后加个this
			ctx.clearRect(0, 0, this.data.canvasWidth, this.data.canvasHeight); // 清除画布
	
			var circle_r = this.data.canvasWidth / 2 - 10; //画布的一半，用来找中心点和半径
			var scoreText = this.data.value; // 当前得分
			var total = this.data.total;// 总分值
	
			var score = (100 * scoreText) / total; // 满分为100时对应的值
			let that = this;
	
			//定义起始点
			ctx.translate(this.data.canvasWidth / 2, this.data.canvasWidth / 2 + 5);
			//  白边圆弧
			ctx.beginPath();
			ctx.setStrokeStyle("#FFFFFF");
			ctx.setLineWidth(16);
			ctx.setLineCap("round");
			ctx.arc(0, 0, circle_r - 15, 1 * Math.PI, 0, false);
			ctx.stroke();
			ctx.closePath();
	
			//灰色圆弧
			ctx.beginPath();
			ctx.setStrokeStyle("#D6E4FF");
			ctx.setLineWidth(12);
			ctx.setLineCap("round"); //线条结束端点样式 butt 平直 round 圆形 square 正方形
			ctx.arc(0, 0, circle_r - 15, 1 * Math.PI, 0, false);
			ctx.stroke();
			ctx.closePath();
	
			// 蓝色圆弧
			ctx.beginPath();
			ctx.setStrokeStyle("#3366FF");
			ctx.setLineWidth(16);
			ctx.arc(
			  0,
			  0,
			  circle_r - 15,
			  1 * Math.PI,
			  (score / 100 + 1) * Math.PI,
			  false
			);
			ctx.stroke();
			ctx.closePath();
			// 指示器-外层
			let deg = 270 - score * 1.8;
			const xAxis = Math.sin(((2 * Math.PI) / 360) * deg) * (circle_r - 15);
			const yAxis = Math.cos(((2 * Math.PI) / 360) * deg) * (circle_r - 15);
			ctx.beginPath();
			ctx.arc(xAxis, yAxis, 11, 0, 2 * Math.PI);
			ctx.setFillStyle("#FFFFFF");
			ctx.fill();
			// 指示器-内层
			const xAxis2 = Math.sin(((2 * Math.PI) / 360) * deg) * (circle_r - 15);
			const yAxis2 = Math.cos(((2 * Math.PI) / 360) * deg) * (circle_r - 15); // circle_r - 10
			ctx.beginPath();
			ctx.arc(xAxis2, yAxis2, 6, 0, 2 * Math.PI);
			ctx.setFillStyle("#3366FF");
			ctx.fill();
	
			// 文字-总得分
			ctx.setTextAlign("center"); // 字体位置
			ctx.setFillStyle("#333333");
			ctx.font = "normal normal 16px Arial,sans-serif";
			ctx.fillText("总得分", 0, -30);
			// 文字-具体分数
			ctx.setTextAlign("center"); // 字体位置
			ctx.setFillStyle("#000000");
			ctx.font = "normal bold 36px Arial,sans-serif";
			ctx.fillText(scoreText, 0, 13);
	
			// 最低分
			ctx.setFillStyle("#666666");
			ctx.font = "normal normal 13px Arial,sans-serif";
			ctx.fillText(0, -circle_r + 10, 25);
			// 最高分
			ctx.setFillStyle("#666666");
			ctx.font = "normal normal 13px Arial,sans-serif";
			ctx.fillText(total, circle_r - 15, 25);
			
			// 绘图
			ctx.draw(false, function () {
			  //将生成好的图片保存到本地
			  wx.canvasToTempFilePath(
				{
				  canvasId: "circleBar",
				  success: function (res) {
					var tempFilePath = res.tempFilePath;
					that.setData({
					  loadImagePath: tempFilePath,
					});
				  },
				  fail: function (res) {},
				},
			  );
			});
		  } catch (error) {
		  }
	  }, 
	  
	  getHAData(that,hotelcode,roomcode){
		  let start = Date.now(); // 获取当前时间（毫秒）
		  // console.log('start=='+start);
		  
		  
		  
		  wx.request({
			  url: `${aipushApi}/getha`, //
			  method: 'POST',
			 //   header: {
				// 	  'content-type': 'application/json', // 默认值
				// 	  'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
				// },
				data:{
				     "locations":hotelcode,"room":(hotelcode && hotelcode.includes('hotel'))?roomcode:"","token":token_push
				 },
			  success(ress) {
				  if(!ress || !ress.data){
					  console.error("getha(),没有获取到数据");
					  return;
				  }
				var resData = ress.data
				console.log("resData-=="+JSON.stringify(resData));
				console.log("resData.loc-=="+JSON.stringify(resData.loc));
				homeApi_https = resData.loc+"/api";
				homeApiLater_https = resData.loc;
				token = resData.token;
				// console.log('res.data='+JSON.stringify(resData));
				if (ress.data.code == "400") {
				  console.error("400错误！");
				  return;
				}
				if (ress.data.code == "401") {
				  console.error("401错误！");
				  return;
				}
				try {
					
					//获取HA 设备状态数据
				// wx.request({
				//   url: `${homeApi_https}/states`, //获取空气数据
				//   method: 'GET',
				//    header: {
				// 		  'content-type': 'application/json', // 默认值
				// 	  'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
				// 	},
				//   success(res) {
				// 	  if(!res || !res.data){
				// 		  return;
				// 	  }
				// 	var resData = res.data
				// 	// console.log('res.data='+JSON.stringify(resData));
				// 	if (res.data.code == "400") {
				// 	  console.error("400错误！");
				// 	  return;
				// 	}
				// 	if (res.data.code == "401") {
				// 	  console.error("401错误 --- 请检查你的API或Key是否正确！");
				// 	  return;
				// 	}
				// 	try {
						
						
					  // const {
					  //   now
					  // } = res.data;
					 //  console.log('res.data1='+JSON.stringify(resData));
					 //  res.data.find(function (obj) {
						//   console.log('obj='+obj); 
					 //  })
					 //  res.data.forEach((item, index) => {
						// console.log(index, item); 
					 //  });
					  var listCoverTemp = [];
					  var listSwitchTemp = [];
					  var listScrollTemp = [];
					  var listUnitTemp = [];
					  var listConversationTemp = [];
					  var listConversation1Temp = [];
					  var listHumidityTemp = [];
					  var listButtonTemp = [];
					  var listSelectTemp = [];
					  var listClimateTemp = [];
					  var listMiotMediaPlayerTemp = [];
					  var listMitvMediaPlayerTemp = [];
					  var listHumidifierTemp = [];
					  var listSensorTemp = [];
					  var listTextTemp = [];
					  
					  var tvEntityIdTemp = '';
					  var tvEntityIdsTemp = [];
					  var climateModeTemp = '';
					  var temperatureHumidifyNameTemp = '温度';
					  
					  var entityIdList = [];
					  const res = wx.getStorageSync('res');
					  const home_room = wx.getStorageSync('res').home_room;
					  // console.log('entity=====@==='+entity);
					  wx.request({
						url: `${homeApi_https}/aidsleep/entity`, //获取空气数据
						method: 'POST',
						 header: {
								  'content-type': 'application/json', // 默认值
								  'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
						  },
						  //
						  data:{
							  "template": "{{ label_entities('"+(entity)+"') }}"
							  },
						success(resTemplate) {
							let mid = Date.now(); // 再次获取当前时间（毫秒）
							// console.log('mid=='+mid);
							if(!resTemplate || !resTemplate.data){
								console.log('no data:'+mid);
								return;
							}
							let resData = resTemplate.data;
							// resData = resData.filter(item1 => {
							//   return JSON.parse(that.replaceAll(resTemplate.data,'\'','\"')).find(item2 => item2 === item1.entity_id) !== undefined;  
							// });
							// console.log('entityIdList-resTemplate====='+JSON.stringify(resTemplate.data));
							for(let i=0;i<resData.length;i++){
						  // if(resTemplate.data.includes(resData[i].entity_id) && that.checkFuzzyMatch(resData[i])){
							  var obj={};
							  obj.entity_id = resData[i].entity_id;//实体ID
							  obj.parent_entity_id = resData[i].parent_entity_id;//父实体ID
							  //api/services/<domain>/<service>
							  if(resData[i].entity_id){
								obj.domain = resData[i].entity_id.split(".")[0];
							  }
							  obj.state = (resData[i].state=='unknown'?"未知":resData[i].state);
							  if(resData[i].attributes && resData[i].attributes.friendly_name){
								obj.friendly_name = resData[i].attributes.friendly_name; //设备名称
								
								if(obj.friendly_name.includes("灯")){
									obj.imgSrc = '/static/images/led.png';
								}else if(obj.friendly_name.includes("加湿器")){
									obj.imgSrc = '/static/images/hum.png';
								}else if(obj.friendly_name.includes("香薰机")){
									obj.imgSrc = '/static/images/light.png';
								}else if(obj.friendly_name.includes("排气扇")){
									obj.imgSrc = '/static/images/temp.png';
								}else if(obj.friendly_name.includes("空调")){
									obj.imgSrc = '/static/images/alarm.png';
								}else if(obj.friendly_name.includes("电视")){
									obj.imgSrc = '/static/images/light.png';
								}else{
									obj.imgSrc = '/static/images/temp.png';
								}
							  }
							  if(resData[i].attributes && resData[i].attributes.home_room){
								obj.home_room = resData[i].attributes.home_room.split(' ')[1]; //房间号
							  }
							  if((resData[i].state && (resData[i].state=='on' || resData[i].state=='off')) && that.checkFuzzyMatch(resData[i])
							  ){
								  if(resData[i].state=='on'){
									  obj.service = 'turn_on';
								  }else if(resData[i].state=='off'){
									  obj.service = 'turn_off';
								  }
								  //截取字符串，防止开关设备名称过长
								  obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); 
								  //是否 是香薰机灯光
								  obj.isAromlight = obj.friendly_name.includes('香薰机灯光')
								  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
									  listSwitchTemp.push(obj)
								  }
							  }
							  
							  if((resData[i].state && obj.domain && obj.domain=='cover') && that.checkFuzzyMatch(resData[i])
							  ){
								  obj.current_position = resData[i].attributes.current_position;
								  obj.target_position = resData[i].attributes.target_position;
								  obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); 
								  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
									  listCoverTemp.push(obj)
								  }
							  }
							  
							 //  if((resData[i].state && obj.domain && obj.domain=='number')||
								// (resData[i].state && obj.domain && obj.domain=='number' && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
								//  )
							 //  ){
								//   obj.min = resData[i].attributes.min;
								//   obj.max = resData[i].attributes.max;
								//   obj.step = resData[i].attributes.step;
								//   obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); 
								//   if(resData[i].state!='unknown'){
								// 	  obj.unit_of_measurement = resData[i].attributes.unit_of_measurement;
								//   }
								//   if((resData[i].attributes.min || resData[i].attributes.max) && resData[i].attributes.unit_of_measurement!='rgb' && resData[i].attributes.unit_of_measurement!='minutes'){
								// 	  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								// 	  	listScrollTemp.push(obj);
								// 	  }
								//   }else if((resData[i].attributes.min || resData[i].attributes.max) && (resData[i].attributes.unit_of_measurement=='rgb' || resData[i].attributes.unit_of_measurement=='minutes')){
								// 	  if(resData[i].state!='unknown'){
								// 	  	obj.unit_of_measurement = resData[i].attributes.unit_of_measurement;
								// 	  }
								// 	  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								// 	  	listUnitTemp.push(obj);
								// 	  }
								//   }
							 //  }
							 //  if((resData[i].state && obj.domain && obj.domain=='button')||
								// (resData[i].state && obj.domain && obj.domain=='button' && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
								//  )
							 //  ){
								//   obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); 
								//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								// 	listButtonTemp.push(obj);
								//   }
							 //  }
							 //  if((resData[i].state && obj.domain && obj.domain=='select')||
								// (resData[i].state && obj.domain && obj.domain=='select' && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
								//  )
							 //  ){
								//   obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); 
								//   obj.options = resData[i].attributes.options;
								//   obj.selectedIndex = 0;
								//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								// 	listSelectTemp.push(obj);
								//   }
							 //  }
							  if((resData[i].state && obj.domain && obj.domain=='climate' && resData[i].attributes.entity_class=='MiirClimateEntity')
							  ){
								  climateModeTemp = obj.state;
								  obj.temperature = resData[i].attributes.temperature;
								  obj.min_temp = resData[i].attributes.min_temp;
								  obj.max_temp = resData[i].attributes.max_temp;
								  obj.hvac_modes = resData[i].attributes.hvac_modes;
								  obj.fan_modes = resData[i].attributes.fan_modes;
								  obj.fan_mode = resData[i].attributes.fan_mode;
								  obj.target_temp_step = resData[i].attributes.target_temp_step;
								  if(obj.state=='auto'){
									temperatureHumidifyNameTemp = '自动';  
								  }
								  
								  if(obj.state=='heat'){
									temperatureHumidifyNameTemp = '制热';  
								  }
								  if(obj.state=='cool'){
									temperatureHumidifyNameTemp = '制冷';  
								  }
								  if(obj.state=='dry'){
									temperatureHumidifyNameTemp = '除湿';  
								  }
								  if(obj.state=='fan_only'){
									temperatureHumidifyNameTemp = '送风';  
								  }
								  if(obj.state=='off'){
									temperatureHumidifyNameTemp = '关闭';  
								  }
								  
								  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
									listClimateTemp.push(obj);
								  }
							  }
							  if((resData[i].state && obj.domain && obj.domain=='media_player' && resData[i].attributes.entity_class=='MiotMediaPlayerEntity') && that.checkFuzzyMatch(resData[i])
							  ){
								  // obj["speaker.volume"] = resData[i].attribute["speaker.volume"];
								  obj.repeat = resData[i].attributes.repeat;
								  obj.entity_picture = resData[i].attributes.entity_picture?"background-image: url('"+`${homeApiLater_https}`+resData[i].attributes.entity_picture+"');width: 100%; height: 100%;background-size: cover;background-repeat: no-repeat;background-position: center;":"background: radial-gradient(circle at center, #ff0000, #0000ff);border-radius: 30rpx;";
								  obj.media_title = resData[i].attributes.media_title;
								  obj.media_artist = resData[i].attributes.media_artist;
								  obj.volume_level = resData[i].attributes.volume_level?(resData[i].attributes.volume_level * 100):0;
								  obj.media_duration = resData[i].attributes.media_duration;
								  obj.media_position = resData[i].attributes.media_position;
								  obj.media_late = resData[i].attributes.media_position + '/' + resData[i].attributes.media_duration;
								  // obj.microphone.mute = resData[i].attributes.microphone.mute;
								  // obj.speaker.mute = resData[i].attributes.speaker.mute;
								  // console.log('media-player-miot-obj=='+obj);
								  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
									listMiotMediaPlayerTemp.push(obj);
								  }
							  }
							  
							 //  if((resData[i].state && obj.domain && obj.domain=='media_player' && resData[i].attributes.entity_class=='MitvMediaPlayerEntity')||
								// (resData[i].state && obj.domain && obj.domain=='media_player' && resData[i].attributes.entity_class=='MitvMediaPlayerEntity' && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
								//  )
							 //  ){
								//   obj.volume_level = resData[i].attributes.volume_level;
								//   obj.is_volume_muted = resData[i].attributes.is_volume_muted;
								//   obj.source = resData[i].attributes.source;
								//   obj.entity_picture = resData[i].attributes.entity_picture?"background-image: url('"+`${homeApiLater_https}`+resData[i].attributes.entity_picture+"');width: 100%; height: 100%;background-size: cover;background-repeat: no-repeat;background-position: center;":"background: radial-gradient(circle at center, #ff0000, #0000ff);border-radius: 30rpx;";
								//   obj.media_title = resData[i].attributes.media_title;
								//   obj.media_artist = resData[i].attributes.media_artist;
								//   obj.volume_level = resData[i].attributes.volume_level?(resData[i].attributes.volume_level * 100):0;
								//   obj.media_duration = resData[i].attributes.media_duration;
								//   obj.media_position = resData[i].attributes.media_position;
								//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								// 	listMitvMediaPlayerTemp.push(obj);
								//   }
							 //  }
							  
							  if((resData[i].state && obj.domain && obj.domain=='media_player') && that.checkFuzzyMatch(resData[i])
							  ){
								  
								  obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode);
								  if(obj.entity_id.includes('teevee') || (obj.entity_id.includes('media_player') && obj.entity_id.includes('tv_dlna_') && obj.friendly_name && obj.friendly_name.includes('电视'))){
									  obj.volume_level = resData[i].attributes.volume_level;
									  obj.is_volume_muted = resData[i].attributes.is_volume_muted;
									  obj.source = resData[i].attributes.source;
									  obj.entity_picture = resData[i].attributes.entity_picture?"background-image: url('"+`${homeApiLater_https}`+resData[i].attributes.entity_picture+"');width: 100%; height: 100%;background-size: cover;background-repeat: no-repeat;background-position: center;":"background: radial-gradient(circle at center, #ff0000, #0000ff);border-radius: 30rpx;";
									  obj.media_title = resData[i].attributes.media_title;
									  obj.media_artist = resData[i].attributes.media_artist;
									  obj.volume_level = resData[i].attributes.volume_level?(resData[i].attributes.volume_level * 100):0;
									  obj.media_duration = resData[i].attributes.media_duration;
									  obj.media_position = resData[i].attributes.media_position;
									  obj.media_late = resData[i].attributes.media_position + '/' + resData[i].attributes.media_duration;
									  // obj["speaker.volume"] = resData[i].attributes["speaker.volume"];
									  // console.log('media-player-mitv-obj=='+obj);
									  obj.device_class = resData[i].attributes.device_class;
									  obj.app_id = resData[i].attributes.app_id;
									  obj.app_name = resData[i].attributes.app_name;
									  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
											listMitvMediaPlayerTemp.push(obj);
									  }
									  obj.friendly_name1 = resData[i].attributes.friendly_name;
									  tvEntityIdsTemp.push(obj);
									  tvEntityIdTemp = obj.entity_id;
									  // console.log('obj===='+obj);
									  // console.log('tvEntityIdTemp='+tvEntityIdTemp);
									  wx.setStorageSync('tvEntityId',tvEntityIdTemp);
								  }
							  }
							  
							  if((resData[i].state && obj.domain && obj.domain=='humidifier')
							  ){
								  obj.min_humidity = resData[i].attributes.min_humidity;
								  obj.max_humidity = resData[i].attributes.max_humidity;
								  obj.humidity = resData[i].attributes.humidity;
								  obj.min = resData[i].attributes.min_humidity;
								  obj.max = resData[i].attributes.max_humidity;
								  // console.log('humidifier-obj=='+JSON.stringify(obj));
								  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
									listHumidifierTemp.push(obj);
								  }
							  }
							  
							 //  if((resData[i].state && obj.domain && obj.domain=='sensor')||
								// (resData[i].state && obj.domain && obj.domain=='sensor' && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
								//  )
							 //  ){
								//   obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); 
								//   obj.unit_of_measurement = resData[i].attributes.unit_of_measurement;
								//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								// 	listSensorTemp.push(obj);
								//   }
							 //  }
							  
							 //  if((resData[i].state && obj.domain && obj.domain=='text')||
								// (resData[i].state && obj.domain && obj.domain=='text' && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
								//  )
							 //  ){
								//   obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode);
								//   obj.min = resData[i].attributes.min;
								//   obj.max = resData[i].attributes.max;
								//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								// 	listTextTemp.push(obj);
								//   }
							 //  }
							  
							 //  if((resData[i].state && obj.friendly_name && obj.friendly_name.includes("智能音箱"))
								// || (resData[i].state && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
								//  && obj.friendly_name && obj.friendly_name.includes("智能音箱"))
							 //  ){
								//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								// 	  listConversationTemp.push(obj)
								//   }
							 //  }
							 //  if((resData[i].state && resData[i].attributes && resData[i].attributes.speaker && resData[i].attributes.speaker.volume && obj.friendly_name && obj.friendly_name.includes("智能音箱"))||
								// (resData[i].state && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
								//  && resData[i].attributes.speaker && resData[i].attributes.speaker.volume && obj.friendly_name && obj.friendly_name.includes("智能音箱"))
							 //  ){
								//   obj.volume = resData[i].attributes.speaker.volume;//音量
								//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								// 	  listConversation1Temp.push(obj)
								//   }
							 //  }
							  //加湿器单独拿出来
							  // if((obj.friendly_name && obj.friendly_name.includes("加湿器"))||
							  // (resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
							  // && obj.friendly_name && obj.friendly_name.includes("加湿器"))
							  // ){
								 //  listHumidityTemp.push(obj)
							  // }
						  // }
					  }
								  
					  that.setData({
						  // status_beep: that.getEntityState(res.data,'switch.xiaomi_pro3_02bd_left_switch_service'), //实验室主灯
						  // status_led: that.getEntityState(res.data,'light.deerma_jsq2g_392f_indicator_light'), //加湿器 Indicator Light
						  // status_san: that.getEntityState(res.data,'switch.xwhzp_xwxfj_a441_diffuser'), //香薰机 Diffuser
						  // status_curtain: that.getEntityState(res.data,'switch.xiaomi_pro3_02bd_middle_switch_service'), //实验室侧灯
						  // status_door: that.getEntityState(res.data,'remote.xiaomi_lx06_f593_wifispeaker_4'), //智能音箱
						  // Temp: that.getEntityStateValue(res.data,'sensor.deerma_jsq2g_392f_temperature'), //加湿器温度
						  // Humi: that.getEntityStateValue(res.data,'sensor.deerma_jsq2g_392f_relative_humidity'), //加湿器湿度
						  // Light: that.getEntityStateValue(res.data,'number.xwhzp_xwxfj_a441_brightness'), //香薰机亮度
						  // LiquidLevel: that.getEntityStateValue(res.data,'sensor.xwhzp_xwxfj_a441_fragrance_liquid_left_level'), //香薰液浓度
						  listSwitch:listSwitchTemp,
						  listUnit:listUnitTemp,
						  listScroll:listScrollTemp,
						  listConversation:listConversationTemp,
						  listConversation1:listConversation1Temp,
						  listHumidity:listHumidityTemp,
						  listButton:listButtonTemp,
						  listSelect:listSelectTemp,
						  listClimate:listClimateTemp,
						  listMiotMediaPlayer:listMiotMediaPlayerTemp,
						  listMitvMediaPlayer:listMitvMediaPlayerTemp,
						  listHumidifier:listHumidifierTemp,
						  listSensor:listSensorTemp,
						  listText:listTextTemp,
						  tvEntityId:tvEntityIdTemp,
						  tvEntityIds:tvEntityIdsTemp,
						  climateMode:climateModeTemp,
						  temperatureHumidifyName:temperatureHumidifyNameTemp,
						  listCover:listCoverTemp,
					  })
					  wx.setStorageSync('tvEntityIds',tvEntityIdsTemp);
					  // console.log('listMiotMediaPlayerTemp='+JSON.stringify(listMiotMediaPlayerTemp));
						// console.log('listHumidityTemp='+JSON.stringify(listHumidityTemp));
						// console.log('listClimateTemp='+JSON.stringify(listClimateTemp));
						// console.log('listSwitchTemp='+JSON.stringify(listSwitchTemp));
						console.log('tvEntityIdsTemp='+JSON.stringify(tvEntityIdsTemp));
						// console.log('listMitvMediaPlayerTemp='+JSON.stringify(listMitvMediaPlayerTemp));
						console.log('listHumidifierTemp='+JSON.stringify(listHumidifierTemp));
						},
						});
				
					
					
					
					
				// 	} catch (error) {
				// 	  console.error(error);
				// 	}
				
				//   },
				// });
					
				} catch (error) {
				  console.error(error);
				}
			
			  },
			  fail: function (error) {
				  console.error('error', error);  
				  that.setData({
					isLoading: false,  
				  });
				} 
			});
		
		
		
		let end = Date.now(); // 再次获取当前时间（毫秒）
		// console.log('end=='+end);
		let executionTime = end - start;
		// console.log(`myFunctionToTest 执行时间为: ${executionTime} 毫秒`);
		return true;
	  },
	  getHADataStart(that,hotelcode,roomcode){
	  		  let start = Date.now(); // 获取当前时间（毫秒）
	  		  console.log('start=='+start);
	  		var that = this;
			
			wx.request({
			  url: `${aipushApi}/getha`, //
			  method: 'POST',
			 //   header: {
				// 	  'content-type': 'application/json', // 默认值
				// 	  'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
				// },
				data:{
				     "locations":hotelcode,"room":(hotelcode && hotelcode.includes('hotel'))?roomcode:"","token":token_push
				 },
			  success(ress) {
				  if(!ress || !ress.data){
					  console.error("getha(),没有获取到数据");
					  return;
				  }
				var resData = ress.data
				console.log("resData-=="+JSON.stringify(resData));
				console.log("resData.loc-=="+JSON.stringify(resData.loc));
				homeApi_https = resData.loc+"/api";
				homeApiLater_https = resData.loc;
				token = resData.token;
				// console.log('res.data='+JSON.stringify(resData));
				if (ress.data.code == "400") {
				  console.error("400错误！");
				  return;
				}
				if (ress.data.code == "401") {
				  console.error("401错误！");
				  return;
				}
				try {
					//获取HA 设备状态数据
				// 	wx.request({
				// 	  url: `${homeApi_https}/states`,
				// 	  method: 'GET',
				// 	   header: {
				// 			  'content-type': 'application/json', // 默认值
				// 		  'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
				// 		},
				// 	  success(res) {
				// 	  if(!res || !res.data){
				// 		  that.setData({
				// 			isLoading: false,  
				// 		  });
				// 		  return;
				// 	  }
				  
				// var resData = res.data
				// // console.log('res.data='+JSON.stringify(resData));
				// if (res.data.code == "400") {
				//   console.error("400错误！");
				//   return;
				// }
				// if (res.data.code == "401") {
				//   console.error("401错误 --- 请检查你的API或Key是否正确！");
				//   return;
				// }
				// try {
					
					
					
					
					
				  // const {
				  //   now
				  // } = res.data;
				 //  console.log('res.data1='+JSON.stringify(resData));
				 //  res.data.find(function (obj) {
					//   console.log('obj='+obj); 
				 //  })
				 //  res.data.forEach((item, index) => {
					// console.log(index, item); 
				 //  });
				  var listCoverTemp = [];
				  var listSwitchTemp = [];
				  var listScrollTemp = [];
				  var listUnitTemp = [];
				  var listConversationTemp = [];
				  var listConversation1Temp = [];
				  var listHumidityTemp = [];
				  var listButtonTemp = [];
				  var listSelectTemp = [];
				  var listClimateTemp = [];
				  var listMiotMediaPlayerTemp = [];
				  var listMitvMediaPlayerTemp = [];
				  var listHumidifierTemp = [];
				  var listSensorTemp = [];
				  var listTextTemp = [];
				  
				  var tvEntityIdTemp = '';
				  var tvEntityIdsTemp = [];
				  
				  var climateModeTemp = '';
				  var temperatureHumidifyNameTemp = '温度';
				  
				  var entityIdList = [];
				  const res = wx.getStorageSync('res');
				  const home_room = wx.getStorageSync('res').home_room;
				  // console.log('entity=====@==='+entity);
				  wx.request({
					url: `${homeApi_https}/aidsleep/entity`, //获取空气数据
					method: 'POST',
					 header: {
							  'content-type': 'application/json', // 默认值
							  'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
					  },
					  //
					  data:{
						  "template": "{{ label_entities('"+(entity)+"') }}"
						  },
					success(resTemplate) {
						let mid = Date.now(); // 再次获取当前时间（毫秒）
						// console.log('mid=='+mid);
						if(!resTemplate || !resTemplate.data){
							console.log('no data:'+mid);
							return;
						}
						let resData = resTemplate.data;
						// resData = resData.filter(item1 => {  
						//   return JSON.parse(that.replaceAll(resTemplate.data,'\'','\"')).find(item2 => item2 === item1.entity_id) !== undefined;  
						// });
						console.log("resData-union="+JSON.stringify(resData));
						// console.log('entityIdList-resTemplate====='+JSON.stringify(resTemplate.data));
						for(let i=0;i<resData.length;i++){
					  // if(resTemplate.data.includes(resData[i].entity_id) && that.checkFuzzyMatch(resData[i])){
						  var obj={};
						  obj.entity_id = resData[i].entity_id;//实体ID
						  obj.parent_entity_id = resData[i].parent_entity_id;//父实体ID
						  //api/services/<domain>/<service>
						  if(resData[i].entity_id){
							obj.domain = resData[i].entity_id.split(".")[0];
						  }
						  obj.state = (resData[i].state=='unknown'?"未知":resData[i].state);
						  if(resData[i].attributes && resData[i].attributes.friendly_name){
							obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); //设备名称
							
							if(obj.friendly_name.includes("灯")){
								obj.imgSrc = '/static/images/led.png';
							}else if(obj.friendly_name.includes("加湿器")){
								obj.imgSrc = '/static/images/hum.png';
							}else if(obj.friendly_name.includes("香薰机")){
								obj.imgSrc = '/static/images/light.png';
							}else if(obj.friendly_name.includes("排气扇")){
								obj.imgSrc = '/static/images/temp.png';
							}else if(obj.friendly_name.includes("空调")){
								obj.imgSrc = '/static/images/alarm.png';
							}else if(obj.friendly_name.includes("电视")){
									obj.imgSrc = '/static/images/light.png';
							}else{
								obj.imgSrc = '/static/images/temp.png';
							}
						  }
						  if(resData[i].attributes && resData[i].attributes.home_room){
							obj.home_room = resData[i].attributes.home_room.split(' ')[1]; //房间号
						  }
						  if((resData[i].state && (resData[i].state=='on' || resData[i].state=='off')) && that.checkFuzzyMatch(resData[i])
						  ){
							  if(resData[i].state=='on'){
								  obj.service = 'turn_on';
							  }else if(resData[i].state=='off'){
								  obj.service = 'turn_off';
							  }
							  //截取字符串，防止开关设备名称过长
							  obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); 
							  //是否 是香薰机灯光
							  obj.isAromlight = obj.friendly_name.includes('香薰机灯光')
							  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								  listSwitchTemp.push(obj)
							  }
						  }
						  
						  if((resData[i].state && obj.domain && obj.domain=='cover') && that.checkFuzzyMatch(resData[i])
						  ){
							  obj.current_position = resData[i].attributes.current_position;
							  obj.target_position = resData[i].attributes.target_position;
							  obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); 
							  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								  listCoverTemp.push(obj)
							  }
						  }
						  
						 //  if((resData[i].state && obj.domain && obj.domain=='number')||
							// (resData[i].state && obj.domain && obj.domain=='number' && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
							//  )
						 //  ){
							//   obj.min = resData[i].attributes.min;
							//   obj.max = resData[i].attributes.max;
							//   obj.step = resData[i].attributes.step;
							//   obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); 
							//   if(resData[i].state!='unknown'){
							// 	  obj.unit_of_measurement = resData[i].attributes.unit_of_measurement;
							//   }
							//   if((resData[i].attributes.min || resData[i].attributes.max) && resData[i].attributes.unit_of_measurement!='rgb' && resData[i].attributes.unit_of_measurement!='minutes'){
							// 	  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
							// 	  	listScrollTemp.push(obj);
							// 	  }
							//   }else if((resData[i].attributes.min || resData[i].attributes.max) && (resData[i].attributes.unit_of_measurement=='rgb' || resData[i].attributes.unit_of_measurement=='minutes')){
							// 	  if(resData[i].state!='unknown'){
							// 	  	obj.unit_of_measurement = resData[i].attributes.unit_of_measurement;
							// 	  }
							// 	  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
							// 	  	listUnitTemp.push(obj);
							// 	  }
							//   }
						 //  }
						 //  if((resData[i].state && obj.domain && obj.domain=='button')||
							// (resData[i].state && obj.domain && obj.domain=='button' && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
							//  )
						 //  ){
							//   obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); 
							//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
							// 	listButtonTemp.push(obj);
							//   }
						 //  }
						 //  if((resData[i].state && obj.domain && obj.domain=='select')||
							// (resData[i].state && obj.domain && obj.domain=='select' && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
							//  )
						 //  ){
							//   obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); 
							//   obj.options = resData[i].attributes.options;
							//   obj.selectedIndex = 0;
							//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
							// 	listSelectTemp.push(obj);
							//   }
						 //  }
						  if((resData[i].state && obj.domain && obj.domain=='climate' && resData[i].attributes.entity_class=='MiirClimateEntity')
						  ){
							  climateModeTemp = obj.state;
							  obj.temperature = resData[i].attributes.temperature;
							  obj.min_temp = resData[i].attributes.min_temp;
							  obj.max_temp = resData[i].attributes.max_temp;
							  obj.hvac_modes = resData[i].attributes.hvac_modes;
							  obj.fan_modes = resData[i].attributes.fan_modes;
							  obj.fan_mode = resData[i].attributes.fan_mode;
							  obj.target_temp_step = resData[i].attributes.target_temp_step;
							  if(obj.state=='auto'){
								temperatureHumidifyNameTemp = '自动';  
							  }
							  
							  if(obj.state=='heat'){
								temperatureHumidifyNameTemp = '制热';  
							  }
							  if(obj.state=='cool'){
								temperatureHumidifyNameTemp = '制冷';  
							  }
							  if(obj.state=='dry'){
								temperatureHumidifyNameTemp = '除湿';  
							  }
							  if(obj.state=='fan_only'){
								temperatureHumidifyNameTemp = '送风';  
							  }
							  if(obj.state=='off'){
								temperatureHumidifyNameTemp = '关闭';  
							  }
							  
							  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								listClimateTemp.push(obj);
							  }
						  }
						  if((resData[i].state && obj.domain && obj.domain=='media_player' && resData[i].attributes.entity_class=='MiotMediaPlayerEntity') && that.checkFuzzyMatch(resData[i])
						  ){
							  // obj["speaker.volume"] = resData[i].attribute["speaker.volume"];
							  obj.repeat = resData[i].attributes.repeat;
							  obj.entity_picture = resData[i].attributes.entity_picture?"background-image: url('"+`${homeApiLater_https}`+resData[i].attributes.entity_picture+"');width: 100%; height: 100%;background-size: cover;background-repeat: no-repeat;background-position: center;":"background: radial-gradient(circle at center, #ff0000, #0000ff);border-radius: 30rpx;";
							  obj.media_title = resData[i].attributes.media_title;
							  obj.media_artist = resData[i].attributes.media_artist;
							  obj.volume_level = resData[i].attributes.volume_level?(resData[i].attributes.volume_level * 100):0;
							  obj.media_duration = resData[i].attributes.media_duration;
							  obj.media_position = resData[i].attributes.media_position;
							  obj.media_late = resData[i].attributes.media_position + '/' + resData[i].attributes.media_duration;
							  // obj.microphone.mute = resData[i].attributes.microphone.mute;
							  // obj.speaker.mute = resData[i].attributes.speaker.mute;
							  // console.log('media-player-miot-obj=='+obj);
							  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								listMiotMediaPlayerTemp.push(obj);
							  }
						  }
						  
						 //  if((resData[i].state && obj.domain && obj.domain=='media_player' && resData[i].attributes.entity_class=='MitvMediaPlayerEntity')||
							// (resData[i].state && obj.domain && obj.domain=='media_player' && resData[i].attributes.entity_class=='MitvMediaPlayerEntity' && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
							//  )
						 //  ){
							//   obj.volume_level = resData[i].attributes.volume_level;
							//   obj.is_volume_muted = resData[i].attributes.is_volume_muted;
							//   obj.source = resData[i].attributes.source;
							//   obj.entity_picture = resData[i].attributes.entity_picture?"background-image: url('"+`${homeApiLater_https}`+resData[i].attributes.entity_picture+"');width: 100%; height: 100%;background-size: cover;background-repeat: no-repeat;background-position: center;":"background: radial-gradient(circle at center, #ff0000, #0000ff);border-radius: 30rpx;";
							//   obj.media_title = resData[i].attributes.media_title;
							//   obj.media_artist = resData[i].attributes.media_artist;
							//   obj.volume_level = resData[i].attributes.volume_level?(resData[i].attributes.volume_level * 100):0;
							//   obj.media_duration = resData[i].attributes.media_duration;
							//   obj.media_position = resData[i].attributes.media_position;
							//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
							// 	listMitvMediaPlayerTemp.push(obj);
							//   }
						 //  }
						  
						  if((resData[i].state && obj.domain && obj.domain=='media_player') && that.checkFuzzyMatch(resData[i])
						  ){ 
							  obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode);
							  if(obj.entity_id.includes('teevee') || (obj.friendly_name && obj.friendly_name.includes('电视'))){
								  obj.volume_level = resData[i].attributes.volume_level;
								  obj.is_volume_muted = resData[i].attributes.is_volume_muted;
								  obj.source = resData[i].attributes.source;
								  obj.entity_picture = resData[i].attributes.entity_picture?"background-image: url('"+`${homeApiLater_https}`+resData[i].attributes.entity_picture+"');width: 100%; height: 100%;background-size: cover;background-repeat: no-repeat;background-position: center;":"background: radial-gradient(circle at center, #ff0000, #0000ff);border-radius: 30rpx;";
								  obj.media_title = resData[i].attributes.media_title;
								  obj.media_artist = resData[i].attributes.media_artist;
								  obj.volume_level = resData[i].attributes.volume_level?(resData[i].attributes.volume_level * 100):0;
								  obj.media_duration = resData[i].attributes.media_duration;
								  obj.media_position = resData[i].attributes.media_position;
								  obj.media_late = resData[i].attributes.media_position + '/' + resData[i].attributes.media_duration;
								  // obj["speaker.volume"] = resData[i].attributes["speaker.volume"];
								  // console.log('media-player-mitv-obj=='+obj);
								  obj.device_class = resData[i].attributes.device_class;
								  obj.app_id = resData[i].attributes.app_id;
								  obj.app_name = resData[i].attributes.app_name;
								  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
										listMitvMediaPlayerTemp.push(obj);
								  }
								  obj.friendly_name1 = resData[i].attributes.friendly_name;
								  tvEntityIdsTemp.push(obj);
								  tvEntityIdTemp = obj.entity_id;
								  // console.log('obj===='+obj);
								  // console.log('tvEntityIdTemp='+tvEntityIdTemp);
								  wx.setStorageSync('tvEntityId',tvEntityIdTemp);
							  }
						  }
						  
						  if((resData[i].state && obj.domain && obj.domain=='humidifier')
						  ){
							  obj.min_humidity = resData[i].attributes.min_humidity;
							  obj.max_humidity = resData[i].attributes.max_humidity;
							  obj.humidity = resData[i].attributes.humidity;
							  obj.min = resData[i].attributes.min_humidity;
							  obj.max = resData[i].attributes.max_humidity;
							  // console.log('humidifier-obj=='+JSON.stringify(obj));
							  if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
								listHumidifierTemp.push(obj);
							  }
						  }
						  
						 //  if((resData[i].state && obj.domain && obj.domain=='sensor')||
							// (resData[i].state && obj.domain && obj.domain=='sensor' && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
							//  )
						 //  ){
							//   obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode); 
							//   obj.unit_of_measurement = resData[i].attributes.unit_of_measurement;
							//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
							// 	listSensorTemp.push(obj);
							//   }
						 //  }
						  
						 //  if((resData[i].state && obj.domain && obj.domain=='text')||
							// (resData[i].state && obj.domain && obj.domain=='text' && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
							//  )
						 //  ){
							//   obj.friendly_name = that.truncateString(resData[i].attributes.friendly_name,roomcode);
							//   obj.min = resData[i].attributes.min;
							//   obj.max = resData[i].attributes.max;
							//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
							// 	listTextTemp.push(obj);
							//   }
						 //  }
						  
						 //  if((resData[i].state && obj.friendly_name && obj.friendly_name.includes("智能音箱"))
							// || (resData[i].state && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
							//  && obj.friendly_name && obj.friendly_name.includes("智能音箱"))
						 //  ){
							//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
							// 	  listConversationTemp.push(obj)
							//   }
						 //  }
						 //  if((resData[i].state && resData[i].attributes && resData[i].attributes.speaker && resData[i].attributes.speaker.volume && obj.friendly_name && obj.friendly_name.includes("智能音箱"))||
							// (resData[i].state && resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
							//  && resData[i].attributes.speaker && resData[i].attributes.speaker.volume && obj.friendly_name && obj.friendly_name.includes("智能音箱"))
						 //  ){
							//   obj.volume = resData[i].attributes.speaker.volume;//音量
							//   if(obj.entity_id && obj.state && obj.friendly_name && obj.domain){
							// 	  listConversation1Temp.push(obj)
							//   }
						 //  }
						  //加湿器单独拿出来
						  // if((obj.friendly_name && obj.friendly_name.includes("加湿器"))||
						  // (resData[i].attributes && resData[i].attributes.parent_entity_id && entityIdList && entityIdList.includes(resData[i].attributes.parent_entity_id)
						  // && obj.friendly_name && obj.friendly_name.includes("加湿器"))
						  // ){
							 //  listHumidityTemp.push(obj)
						  // }
					  // }
				  }
							  
				  that.setData({
					  // status_beep: that.getEntityState(res.data,'switch.xiaomi_pro3_02bd_left_switch_service'), //实验室主灯
					  // status_led: that.getEntityState(res.data,'light.deerma_jsq2g_392f_indicator_light'), //加湿器 Indicator Light
					  // status_san: that.getEntityState(res.data,'switch.xwhzp_xwxfj_a441_diffuser'), //香薰机 Diffuser
					  // status_curtain: that.getEntityState(res.data,'switch.xiaomi_pro3_02bd_middle_switch_service'), //实验室侧灯
					  // status_door: that.getEntityState(res.data,'remote.xiaomi_lx06_f593_wifispeaker_4'), //智能音箱
					  // Temp: that.getEntityStateValue(res.data,'sensor.deerma_jsq2g_392f_temperature'), //加湿器温度
					  // Humi: that.getEntityStateValue(res.data,'sensor.deerma_jsq2g_392f_relative_humidity'), //加湿器湿度
					  // Light: that.getEntityStateValue(res.data,'number.xwhzp_xwxfj_a441_brightness'), //香薰机亮度
					  // LiquidLevel: that.getEntityStateValue(res.data,'sensor.xwhzp_xwxfj_a441_fragrance_liquid_left_level'), //香薰液浓度
					  listSwitch:listSwitchTemp,
					  listUnit:listUnitTemp,
					  listScroll:listScrollTemp,
					  listConversation:listConversationTemp,
					  listConversation1:listConversation1Temp,
					  listHumidity:listHumidityTemp,
					  listButton:listButtonTemp,
					  listSelect:listSelectTemp,
					  listClimate:listClimateTemp,
					  listMiotMediaPlayer:listMiotMediaPlayerTemp,
					  listMitvMediaPlayer:listMitvMediaPlayerTemp,
					  listHumidifier:listHumidifierTemp,
					  listSensor:listSensorTemp,
					  listText:listTextTemp,
					  tvEntityId:tvEntityIdTemp,
					  tvEntityIds:tvEntityIdsTemp,
					  climateMode:climateModeTemp,
					  temperatureHumidifyName:temperatureHumidifyNameTemp,
					  listCover:listCoverTemp,
					  isLoading: false,
				  })
				  wx.setStorageSync('tvEntityIds',tvEntityIdsTemp);
					},
					});
					let mid = Date.now(); // 获取当前时间（毫秒）
					  console.log('mid=='+mid);
					  console.log('start=='+start);
					  console.log('mid-start=='+(mid-start));
					  // that.setData({
					  // 	isLoading: true, 
					  //   });
					  
					  
					  
					  
			// 	} catch (error) {
			// 	  console.error(error);
			// 	}
			
			//   },
			//   fail: function (error) {
			// 	  console.error('error', error);  
			// 	  that.setData({
			// 		isLoading: false,  
			// 	  });
			// 	} 
			// });
					
					
				} catch (error) {
				  console.error(error);
				  that.setData({
					isLoading: false,  
				  });
				}
			
			  },
			  fail: function (error) {
				  console.error('error', error);  
				  that.setData({
					isLoading: false,  
				  });
				} 
			});
			
			
	  		
	  		let end = Date.now(); // 再次获取当前时间（毫秒）
	  		console.log('end=='+end);
	  		let executionTime = end - start;
	  		console.log(`myFunctionToTest 执行时间为: ${executionTime} 毫秒`);
	  		return true;
	  },
	  imageLoad: function () {
		 this.setData({  
		       isLoading: false,  
		     });
		 console.log('图片渲染完成');
	  },
	startInterval: function () {  
    // 使用 setInterval 创建定时任务，每8秒执行一次 this.myMethod 方法 
	 var that = this;
    // this.intervalId = setInterval(() => {  
    //   that.getHAData(that,that.data.hotelcode,that.data.roomcode);  
    // }, 6000);
	this.data.intervalId1 = setInterval(() => {  
	      that.getHAData(that,that.data.hotelcode,that.data.roomcode); 
	    }, 6000);  
	  
	    // 第二个定时器，每2秒执行一次  
	    this.data.intervalId2 = setInterval(() => {  
	      // 这里执行你的代码  
	      that.setData({  
	              isClickedPrevSong: false,
				  isClickedTogglePlayPause: false,
				  isClickedNextSong: false,
				  isClickedOnHumidifierUp: false,
				  isClickedOnHumidifierDown: false,
				  isClickedOnClimateAuto: false,
				  isClickedOnClimateUp: false,
				  isClickedToggleAromlight: false,//香薰机灯光
	            });
	    }, 300);
  },
   clearInterval: function () {  
       // 清除定时任务  
       // if (this.intervalId) {  
       //   clearInterval(this.intervalId);  
       //   this.intervalId = null;  
       // }  
	   if (this.data.intervalId1) {  
	         clearInterval(this.data.intervalId1);  
	         this.data.intervalId1 = null; // 可选，但建议清除以避免潜在的错误  
	       }  
	     
	       // 停止第二个定时器  
	       if (this.data.intervalId2) {  
	         clearInterval(this.data.intervalId2);  
	         this.data.intervalId2 = null; // 可选，但建议清除以避免潜在的错误  
	       } 
     },
	 stopTouchMove: function(e) {
	     return false;
	   },
	   truncateString: function(str,roomcode) {
		if(!str) return ''
		let strR = str.replace(roomcode, '')
	     if (strR.length <= 6) {  
	       // 如果字符串长度小于等于5，直接返回原字符串  
	       return strR;  
	     } else{  
	       // 如果字符串长度在6到9之间，返回后6个字符（此时没有前部分可拼接）  
	       return strR.slice(-6);  
	     }  
	   },
onLoad(option){
	console.log("index页面");
  // wx.clearStorage();
  // this.setTextBreathing(wx.createSelectorQuery(".header-title-fire"),this);
  //console.log('option.res='+JSON.stringify(wx.getStorageSync('res')));
  if(!wx.getStorageSync('res') || !wx.getStorageSync('res').result){
	  wx.showModal({
	    title: '提示',
	    content: '请先扫描房间二维码',
	    showCancel: false
	  });

	  setTimeout(function() {
	      wx.reLaunch({
	      		url: '/pages/scan/scan',
	      })
	    }, 2000) // 设置延时时间，单位为毫秒
  }else{
	  
	  
	  var that = this;
	 //  wx.request({
		// url: `${aipushApi}`+'/getbigreport', 
		// method: 'POST',
		//  header: {
		// 		  'content-type': 'application/json', // 默认值
		// 		  'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
		//   },
		// data:{
		//     "sn":'',"tokens":token_push
		// },
		// success(ress) {
		// 	if(ress && ress.data){
				// wx.request({
				//   url: `${homeApi_https}/states`, //获取空气数据
				//   method: 'GET',
				//    header: {
				// 		  'content-type': 'application/json', // 默认值
				// 		  'Authorization': 'Bearer ' + token // 在头部设置认证信息，例如使用Bearer Token
				// 	},
				//   success(res) {
				// 	if(!res || !res.data){
				// 		wx.showModal({
				// 				title: '提示',
				// 				content: '请先连接房间wi-fi，再次扫描',
				// 				showCancel: false
				// 			  });
						
				// 		setTimeout(function() {
				// 		  wx.reLaunch({
				// 				url: '/pages/scan/scan',
				// 		  })
				// 		}, 2000) // 设置延时时间，单位为毫秒
				// 	}else{
				// 		// console.log("res.data====="+JSON.stringify(res.data));
				// 	}
				//   },
				// }); 
	// 		}else{
	// 			wx.showModal({
	// 					title: '提示',
	// 					content: '请先连接房间wi-fi，再次扫描',
	// 					showCancel: false
	// 				  });
				
	// 			setTimeout(function() {
	// 			  wx.reLaunch({
	// 					url: '/pages/scan/scan',
	// 			  })
	// 			}, 2000) // 设置延时时间，单位为毫秒
	// 		}
	// 	},
	// });
	
	// const socketUrl = 'http://192.168.3.65:8123';
	// wx.connectSocket({
	// 	url: socketUrl,  
	// 	success: function (res) {  
	// 	  console.log('WebSocket连接成功', res);  
	// 	},  
	// 	fail: function (error) {  
	// 	  console.error('WebSocket连接打开失败', error);  
	// 	}  
	//   });
			//wi-fi判断
			// wx.startWifi({
	  //         fail(error) {
	  //           console.log('初始化wifi-失败', error)
	  //         },
	  //         success(res) {
	  //           console.log('初始化wifi-成功', res)
	  //         },
			// });
	  let hotelcodeTemp = '';
	  let roomcodeTemp = '';
	  if(wx.getStorageSync('res').result.split('|').length != 2){
	  	  wx.showModal({
	  	    title: '提示',
	  	    content: '房间二维码不正确，请重新扫码',
	  	    showCancel: false
	  	  });
	  	  
	  	  setTimeout(function() {
	  	      wx.reLaunch({
	  	      		url: '/pages/scan/scan',
	  	      })
	  	    }, 2000) // 设置延时时间，单位为毫秒
	  }
	  hotelcodeTemp = wx.getStorageSync('res').result.split('|')[0];
	  roomcodeTemp = wx.getStorageSync('res').result.split('|')[1];
	  entity = roomcodeTemp;
	  if(entity == 'labs'){
		  entity = '公司实验室';
		  wx.setStorageSync('roomname','604');
	  }else{
		 wx.setStorageSync('roomname',entity); 
	  }
	  this.setData({
	    isLoading: true,
		hotelcode: hotelcodeTemp,
		roomcode: roomcodeTemp,
	  });
	  if(this.getHADataStart(this,hotelcodeTemp,roomcodeTemp)){
	  	// 页面加载时开始定时任务  
		// this.startInterval();
	  }
		  
  }
  
  
  
  // else if(!this.data.home_room.includes(wx.getStorageSync('res').result)){
  // 	  wx.showModal({
  // 	    title: '提示',
  // 	    content: '房间二维码不正确，请重新扫描',
  // 	    showCancel: false
  // 	  });
  
  // 	  setTimeout(function() {
  // 	      wx.reLaunch({
  // 	      		url: '/pages/scan/scan',
  // 	      })
  // 	    }, 2000) // 设置延时时间，单位为毫秒
  // }
  
  // this.showCanvasRing();
  
  // 创建音频上下文  
 //      this.innerAudioContext = wx.createInnerAudioContext();  
        
 //      // 设置音频源  
 //      this.innerAudioContext.src = '你的音频文件链接'; // 替换为你的音频文件链接  
        
 //      // 监听播放状态  
 //      this.innerAudioContext.onPlay(() => {  
 //        this.setData({ isPlaying: true });  
 //      });  
 //      this.innerAudioContext.onPause(() => {  
 //        this.setData({ isPlaying: false });  
 //      });  
 //      this.innerAudioContext.onStop(() => {  
 //        this.setData({ isPlaying: false });  
 //      });  
 //      this.innerAudioContext.onError((res) => {
 //        console.log('res.errorCode='+res.errorCode);  
 //        console.log('res.errorMsg='+res.errorMsg);  
 //      });  
        
 //      // 监听播放进度  
 //      this.innerAudioContext.onTimeUpdate(() => {  
 //        this.setData({  
 //          currentTime: this.innerAudioContext.currentTime,  
 //          duration: this.innerAudioContext.duration  
 //        });  
 //      });
	// // 初始化歌曲列表
	//     this.setData({
	//       songs: [
	//         { id: 1, title: '歌曲1', artist: '歌手1', url: 'song1.mp3' },
	//         { id: 2, title: '歌曲2', artist: '歌手2', url: 'song2.mp3' },
	//         { id: 3, title: '歌曲3', artist: '歌手3', url: 'song3.mp3' }
	//       ]
	//     });
  
},
mounted() {
	
},
onHide(){
	// wx.clearStorage();
	// 页面卸载时清除定时任务
	this.clearInterval();
	// if(this.tcp){
	// 	this.tcp.onClose(() => {
	//   // this.infoList.push('关闭')
	//   console.log('tcp关闭');
	//   this.tcp.close()
	// })
	// }
},
onUnload(){
	//wx.clearStorage();
	// 页面卸载时清除定时任务  
	this.clearInterval(); 
	// if(this.tcp){
	// 	this.tcp.onClose(() => {
	//   // this.infoList.push('关闭')
	//   console.log('tcp关闭');
	//   this.tcp.close()
	// })
	// }
	// if (this.data.observer) {  
	//   this.data.observer.disconnect();  
	// } 
},
onReady(){
	console.log('页面渲染完成')
},
showLoading:function(){
	wx.showToast({
		title:'加载中',
		icon:'loading',
		})
	},
cancelLoading:function(){
	wx.hideToast()
},
  onShow() {
    
    var that = this;
	that.startInterval();
	//mqtt程序，保留
    /* wx.showToast({
      title: "连接服务器....",
      icon: "loading",
      duration: 10000,
      mask: true,
    });
    let second = 10;
    var toastTimer = setInterval(() => {
      second--;
      if (second) {
        wx.showToast({
          title: `连接服务器...${second}`,
          icon: "loading",
          duration: 1000,
          mask: true,
        });
      } else {
        clearInterval(toastTimer);
        wx.showToast({
          title: "连接失败",
          icon: "error",
          mask: true,
        });
      }
    }, 1000);
    that.setData({
      client: connect(mqttUrl,options)
    })

    that.data.client.on("connect", function () {
      console.log("成功连接mqtt服务器！");
      clearInterval(toastTimer);
      wx.showToast({
        title: "连接成功",
        icon: "success",
        mask: true,
      });
      // 一秒后订阅主题
      setTimeout(() => {
        that.data.client.subscribe(mpSubTopic_env, function (err) {
          if (!err) {
            console.log("成功订阅设备上行数据环境Topic!");
            wx.showToast({
              title: "订阅成功",
              icon: "success",
              mask: true,
            });
          }
        });
      }, 500);
    });
    setTimeout(() => {
      that.data.client.subscribe(mpSubTopic_con, function (err) {
        if (!err) {
          console.log("成功订阅设备上行数据控制Topic!");
          wx.showToast({
            title: "订阅成功",
            icon: "success",
            mask: true,
          });
         
        }
      });
    }, 200);
    
    that.data.client.on("message", function (topic, message) {
      console.log(topic);
      // message是16进制的Buffer字节流
      let dataFromDev = {};
	  console.log('message='+message);
      // 尝试进行JSON解析
      try {
        dataFromDev = JSON.parse(message);
        console.log(dataFromDev);
        that.setData({
          //环境状态
          Temp: dataFromDev.Temp,
          Humi: dataFromDev.Humi,
          Voltage1: dataFromDev.Voltage1,
          Voltage2: dataFromDev.Voltage2,

          //设备状态
          status_beep: dataFromDev.Beep_Flag,
          status_led: dataFromDev.Led_Flag,
          status_curtain: dataFromDev.Angle1,
          status_san: dataFromDev.San_Flag,
          status_door: dataFromDev.Angle2,
          status_fire: dataFromDev.Fire_Flag,
          status_light: dataFromDev.Light_Flag,
          status_mode: dataFromDev.Mode_Flag
        })
      } catch (error) {
        // 解析失败错误捕获并打印（错误捕获之后不会影响程序继续运行）
        console.log(error);
      }
    }) */
	// if(this.tcp){
	// 	this.tcp.onClose(() => {
	//   // this.infoList.push('关闭')
	//   console.log('tcp关闭');
	//   this.tcp.close()
	//   this.tcp = '';
	// })
	// }
	// // 初始化TCP实例
	// this.tcp = wx.createTCPSocket()
	// // tcp实例向服务端发起连接
	// this.tcp.connect({ address: '192.168.3.65', port: '81231' })
	// // this.infoList.push(`向${this.ip}:${~~this.port}建立链接`)
		
	
	// this.tcp.offClose(() => {
	// })
	// this.tcp.onConnect(() => {
	//   // this.infoList.push('连接成功')
	//   console.log('tcp连接成功');
	// })
	// this.tcp.offConnect(() => {
	//   // this.infoList.push('offConnect')
	//   console.log('tcp-offConnect');
	// })
	// this.tcp.onError(error => {
	//   // this.infoList.push('异常:' + error)
	//   console.log('tcp异常:' + error);
	  
	//   wx.showModal({
	// 	title: '提示',
	// 	content: '请先连接房间wi-fi，再次扫描',
	// 	showCancel: false
	//   });
			
	//  setTimeout(function() {
	//    wx.reLaunch({
	// 		url: '/pages/scan/scan',
	// 	   })
	// 	 }, 2000) // 设置延时时间，单位为毫秒
	//  })
	// this.tcp.onMessage(data => {
	//   // this.infoList.push('tcp接收到数据: ' + transitionArrayBufferToString(data.message))
	//   console.log('tcp接收到数据: ' + JSON.stringify(data.message));
	// })
	
	wx.getLocation({
	  type: "wgs84",
	  success(res) {
	    const latitude = res.latitude;
	    const longitude = res.longitude;
	    const key = hefengKey;
	    wx.request({
	      url: `${geoApi}location=${longitude},${latitude}&key=${key}`, //获取地理位置
	      success(res) {
	        console.log('getLocation='+JSON.stringify(res.data));
	        if (res.data.code == "401") {
	          console.error("HUAQING --- 请检查你的和风天气API或Key是否正确！");
	          return;
	        }
	        try {
	          const {
	            location
	          } = res.data;
	          that.setData({
	            area: location[0].name, //城区
	            city: location[0].adm2 //城市
	          })
	        } catch (error) {
	          console.error(error);
	        }
	      },
	    });
	    wx.request({
	      url: `${hefengWeather}location=${longitude},${latitude}&key=${key}`, //获取实时天气数据
	      success(res) {
	        console.log("实时天气=="+JSON.stringify(res.data));
	        if (res.data.code == "401") {
	          console.error("HUAQING --- 请检查你的和风天气API或Key是否正确！");
	          return;
	        }
	        try {
	          const {
	            now
	          } = res.data;
	          that.setData({
	            weather: now.text, // 天气
				w_temp: now.temp, // 温度
				w_humidity: now.humidity, // 湿度
	          })
	        } catch (error) {
	          console.error(error);
	        }
	
	      },
	    });
	    wx.request({
	      url: `${hefengAir}location=${longitude},${latitude}&key=${key}`, //获取空气数据
	      success(res) {
	        console.log("空气数据=="+JSON.stringify(res.data));
	        if (res.data.code == "401") {
	          console.error("HUAQING --- 请检查你的和风天气API或Key是否正确！");
	          return;
	        }
	        try {
	          const {
	            now
	          } = res.data;
	          that.setData({
	            airText: now.category, //空气质量
	            airValue: now.aqi //空气指数
	          })
	        } catch (error) {
	          console.error(error);
	        }
	
	      },
	    });
	  },
	});
    // 获取天气相关数据
    
	// wx.scanCode({
	//   success: (res) => {
	//     console.log('扫描结果:'+res.result) // 扫描结果
	//   }
	// });
  }
})