|
|
import Taro from "@tarojs/taro";
|
|
|
import dayjs from "dayjs";
|
|
|
import classnames from "classnames";
|
|
|
|
|
|
import { Component, PropsWithChildren, useEffect, useState } from "react";
|
|
|
import {
|
|
|
Block,
|
|
|
View,
|
|
|
Text,
|
|
|
Image,
|
|
|
Video,
|
|
|
Input,
|
|
|
Button,
|
|
|
} from "@tarojs/components";
|
|
|
|
|
|
/*** redux ***/
|
|
|
import { connect } from "react-redux";
|
|
|
/*** redux end ***/
|
|
|
|
|
|
/* 公共组件 */
|
|
|
import Navbar from "@/components/navbar/navbar";
|
|
|
import PopupCountdown from "@/components/popup/popup-countdown";
|
|
|
import PopupStepTips from "@/components/popup/popup-step-tips";
|
|
|
/* 公共组件 END */
|
|
|
|
|
|
/* 本页组件 */
|
|
|
import ModeListView from "./components/ModeList/index";
|
|
|
import ModeContent from "./components/ModeContent/index";
|
|
|
import Footer from "./components/Footer";
|
|
|
/* 本页组件 END */
|
|
|
|
|
|
import { getStorageSync, setStorageSync } from "@/utils/traoAPI";
|
|
|
import { InstrumentInfo } from "@/utils/Interface";
|
|
|
import "./iotCarePlan.less";
|
|
|
|
|
|
// import log from "@/utils/log";
|
|
|
// log.info("123456info", 123456, { sdfasdf: 123 });
|
|
|
|
|
|
import {
|
|
|
notifyBLECharacteristicValueChange,
|
|
|
sendCommand,
|
|
|
} from "@/utils/bluetoothWXAPI";
|
|
|
import {
|
|
|
deviceCommandSamples,
|
|
|
bleCommandSamples,
|
|
|
} from "@/components/bluetoot/connection/test";
|
|
|
import {
|
|
|
minSecToS,
|
|
|
s_to_h,
|
|
|
s_to_hs,
|
|
|
s_to_s,
|
|
|
isNeedToUpdate,
|
|
|
} from "@/utils/util";
|
|
|
import { DeviceToolKit as DeviceToolKitWE100 } from "@flossom-npm/iot-translater-we100";
|
|
|
import commandMap from "@/utils/commandMap";
|
|
|
const deviceToolKitInstanceWE100 = new DeviceToolKitWE100("WE100", "M01");
|
|
|
const deviceToolKitInstanceWL200 = new DeviceToolKitWE100("WE100", "WL200");
|
|
|
|
|
|
let timer: any = null;
|
|
|
let checkVersionTimeout: any = null;
|
|
|
let showTipsTimer: any = null;
|
|
|
let loadingTipsTimer: any = null; // 蓝牙连接提示
|
|
|
let switchModeStatus = "free"; // 用于标记是否在切换模式中, free: 空闲, switching: 切换中
|
|
|
//时间校准频率，每多少秒校准一次
|
|
|
const TIME_CALIBRATION_FREQUENCY = 5;
|
|
|
|
|
|
// 模式类型
|
|
|
const WORK_MODE_NAME_ENUM = {
|
|
|
POWERFULSOOTHING: "powerfulSoothing",
|
|
|
STABILITY: "Stability",
|
|
|
BRIGHTEN: "Brighten",
|
|
|
FIRMSKIN: "FirmSkin",
|
|
|
MaskCustom: "MaskCustom",
|
|
|
BrightenStand: "BrightenStand",
|
|
|
FirmSkinStand: "FirmSkinStand",
|
|
|
SmallpoxSoothingPro: "SmallpoxSoothingPro",
|
|
|
SmallpoxSoothing: "SmallpoxSoothing",
|
|
|
MixNursePro: "MixNursePro",
|
|
|
MixNurse: "MixNurse",
|
|
|
ScalpCare: "ScalpCare",
|
|
|
};
|
|
|
|
|
|
// 模式类型：英文名
|
|
|
const WORK_MODE_ENGLISH_NAME = {
|
|
|
6: "powerfulSoothing",
|
|
|
7: "Stability",
|
|
|
8: "Brighten",
|
|
|
9: "FirmSkin",
|
|
|
MaskCustom: "MaskCustom",
|
|
|
21: "BrightenStand",
|
|
|
22: "FirmSkinStand",
|
|
|
23: "SmallpoxSoothingPro",
|
|
|
24: "SmallpoxSoothing",
|
|
|
25: "MixNursePro",
|
|
|
26: "MixNurse",
|
|
|
27: "ScalpCare",
|
|
|
};
|
|
|
// 模式类型中文名
|
|
|
const WORK_MODE_Chinese_NAME = {
|
|
|
强效舒缓: "powerfulSoothing",
|
|
|
维稳修复: "Stability",
|
|
|
均色提亮: "Brighten",
|
|
|
紧致淡纹: "FirmSkin",
|
|
|
自定义: "MaskCustom",
|
|
|
均色提亮Pro: "BrightenStand",
|
|
|
紧致淡纹Pro: "FirmSkinStand",
|
|
|
痘肌舒缓Pro: "SmallpoxSoothingPro",
|
|
|
痘肌舒缓: "SmallpoxSoothing",
|
|
|
混合Pro: "MixNursePro",
|
|
|
混合: "MixNurse",
|
|
|
头皮护理: "ScalpCare",
|
|
|
};
|
|
|
|
|
|
const WORK_MODE_TYPE = {
|
|
|
powerfulSoothing: 6,
|
|
|
Stability: 7,
|
|
|
Brighten: 8,
|
|
|
FirmSkin: 9,
|
|
|
MaskCustom: "MaskCustom",
|
|
|
BrightenStand: 21,
|
|
|
FirmSkinStand: 22,
|
|
|
SmallpoxSoothingPro: 23,
|
|
|
SmallpoxSoothing: 24,
|
|
|
MixNursePro: 25,
|
|
|
MixNurse: 26,
|
|
|
ScalpCare: 27,
|
|
|
};
|
|
|
|
|
|
const MODE_WORKING_ENUM = {
|
|
|
STANDBY: "standby",
|
|
|
WORKING: "working",
|
|
|
PAUSE: "pause",
|
|
|
END: "end",
|
|
|
};
|
|
|
|
|
|
// 倒计时时间
|
|
|
let CountDownTime = {
|
|
|
powerfulSoothing: 6,
|
|
|
Stability: 4,
|
|
|
Brighten: 4,
|
|
|
FirmSkin: 4,
|
|
|
MaskCustom: 6,
|
|
|
BrightenStand: 6,
|
|
|
FirmSkinStand: 6,
|
|
|
SmallpoxSoothingPro: 6,
|
|
|
SmallpoxSoothing: 4,
|
|
|
MixNursePro: 6,
|
|
|
MixNurse: 4,
|
|
|
ScalpCare: 6,
|
|
|
};
|
|
|
|
|
|
let KeepCheckingLink = true;
|
|
|
let DeviceSyncData = {
|
|
|
totalWorkingMinutes: 0,
|
|
|
totalWorkingSeconds: 0,
|
|
|
};
|
|
|
let deviceToolKitInstance = deviceToolKitInstanceWE100; // we100
|
|
|
|
|
|
class IotCarePlan extends Component<any, any> {
|
|
|
constructor(props) {
|
|
|
super(props);
|
|
|
this.state = {
|
|
|
name: "iotCarePlan",
|
|
|
title: "美容仪名字",
|
|
|
instrument: "WE200",
|
|
|
|
|
|
/** 连接设备 */
|
|
|
hasVersion: false, // 是否已查询到版本号
|
|
|
curDeviceInfo: {}, // 当前设备信息
|
|
|
basicModeList: [], //模式列表
|
|
|
modelActiveIndex: 0, //模式下标
|
|
|
sliderProgress: 22,
|
|
|
isStandStatus: false, //支架开启状态(支架就是舱体)
|
|
|
workStatus: "", //工作状态
|
|
|
Electricity: 0, //fr200电量
|
|
|
matrixElectricity: 0, //matrix电量
|
|
|
workMode: "", //当前模式
|
|
|
showCombinationModeDialog: false, // 组合模式弹窗
|
|
|
combinationModeList: [], // 可选的组合模式列表
|
|
|
combinationList: [], // 选择的组合模式列表
|
|
|
combinationModeInfo: {}, // 组合模式缓存的信息
|
|
|
originCombinationList: [], // 原始组合模式列表
|
|
|
originCombinationModeInfo: {}, // 原始组合模式缓存的信息
|
|
|
isCurrentModeCombination: false, // 当前模式是否是组合模式
|
|
|
isSendModeCombination: false, // 当前是否在发送组合模式
|
|
|
gear: { gear: 1 },
|
|
|
currentShowDialog: "",
|
|
|
// countdown: 3, // 倒计时
|
|
|
step: 1, // 1:选择模式并播放视频, 2:护理中
|
|
|
facialMaskConnectStatus: 0, // 面膜连接状态
|
|
|
checkedMaskVersion: false, //是否检查过固件版本了
|
|
|
askedOta: false, //询问过用户是否需要OTA
|
|
|
showVideoPlayBtn: true, // 视频播放按钮
|
|
|
duration: 0, // 视频总时长
|
|
|
hadShowBreakTips: false, // 是否展示过支架断开提示
|
|
|
popupType: "", // enoughTimePopup: 时间达标提示, endPopup: 结束弹窗
|
|
|
safeAreaBottom: 0,
|
|
|
video_guide: "", // 指导视频
|
|
|
wl200CustomMode: [], // wl200所有的自定义模式
|
|
|
joinModeId: 0,
|
|
|
todayMode: 0, // 今日场景id
|
|
|
customModeData: {
|
|
|
hadCustom: false,
|
|
|
hadSetCustom: false, // 是否设置过 -- 代码逻辑使用
|
|
|
setCustomSuc: false, // 是否设置成功 -- 页面需要用于判断
|
|
|
}, // 自定义模式判断
|
|
|
|
|
|
/** 连接设备 End */
|
|
|
|
|
|
// isMuted: false, // 视频是否静音
|
|
|
isMusicPlay: false, // 声音播放状态
|
|
|
isShowStepTips: false, // 是否显示介绍步骤弹窗
|
|
|
isConnectionBlutoot: false, // 是否已连接蓝牙
|
|
|
isShowNurse: false, // 是否开始并显示护理
|
|
|
isStopNurse: false, // 是否暂停护理
|
|
|
isEndNurse: false, // 是否结束护理
|
|
|
errorTips: "", // 错误提示
|
|
|
|
|
|
// 模式列表
|
|
|
ModeList: [],
|
|
|
ModeType: "all", // all visor面罩 cabin舱体 yimeish医美
|
|
|
modeClass: "", // 1面罩 2舱体 3医美
|
|
|
ActiveModeItem: {}, // 当前选中模式
|
|
|
ModeStepIndex: 0, // 当前护理功效步骤：每个步骤时间不定，所以时间另外计算，根据步骤显示
|
|
|
|
|
|
// 倒计时
|
|
|
isShowCountdown: false, // 倒计时弹窗
|
|
|
countdown: 6,
|
|
|
// startSettingCountDown: false, // 是否开始倒计时
|
|
|
|
|
|
// 音乐
|
|
|
// innerAudioContext: null,
|
|
|
|
|
|
// 最后执行步骤位置
|
|
|
endPlace: "",
|
|
|
};
|
|
|
}
|
|
|
|
|
|
async onLoad() {
|
|
|
// 保持屏幕常亮
|
|
|
Taro.setKeepScreenOn({
|
|
|
keepScreenOn: true,
|
|
|
});
|
|
|
}
|
|
|
componentDidMount() {
|
|
|
this.setState({
|
|
|
videoContext: Taro.createVideoContext("myVideo"),
|
|
|
standVideoContext: null,
|
|
|
});
|
|
|
}
|
|
|
|
|
|
componentWillUnmount() {}
|
|
|
|
|
|
componentDidShow() {
|
|
|
this.initData();
|
|
|
}
|
|
|
|
|
|
componentDidHide() {}
|
|
|
|
|
|
async initData() {
|
|
|
let objStr = getStorageSync("instrument_detail");
|
|
|
if (objStr) {
|
|
|
let info = JSON.parse(objStr);
|
|
|
this.GetModeList(info.id);
|
|
|
console.log("info");
|
|
|
|
|
|
// 如果不存在设备模式值，则判断为首次进入，弹窗提示
|
|
|
let isFirstEntry = getStorageSync("isFirstEntry_" + info.model);
|
|
|
if (!isFirstEntry) {
|
|
|
// this.setState({ isShowStepTips: true });
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 初始化蓝牙
|
|
|
this.init();
|
|
|
}
|
|
|
|
|
|
async init() {
|
|
|
// 查询自定义设备指令
|
|
|
const queryInstructionParams = {
|
|
|
commandType: "InfoQuery",
|
|
|
infoQueryType: "customModeInfo",
|
|
|
};
|
|
|
let commandBuffer = deviceToolKitInstance.toBleCommand(
|
|
|
queryInstructionParams as any
|
|
|
);
|
|
|
sendCommand({ value: commandBuffer }).then((res) => {
|
|
|
console.log(
|
|
|
"查询自定义组合模式指令发送成功 参数为=>",
|
|
|
queryInstructionParams
|
|
|
);
|
|
|
});
|
|
|
Taro.onBLEConnectionStateChange(this.listener);
|
|
|
await this.notifyBLECharacteristicValueChange();
|
|
|
|
|
|
this.handleWorkStatus(null, MODE_WORKING_ENUM.STANDBY);
|
|
|
}
|
|
|
listener = (res) => {
|
|
|
console.log("listener res", res);
|
|
|
if (res?.connected) return;
|
|
|
Taro.offBLECharacteristicValueChange((res) => {
|
|
|
console.log("offBLECharacteristicValueChange", res);
|
|
|
});
|
|
|
clearTimeout(loadingTipsTimer);
|
|
|
// 断开蓝牙关闭倒计时
|
|
|
this.setState({
|
|
|
isShowCountdown: false,
|
|
|
});
|
|
|
console.log(commandMap.WL200Command, "监听到蓝牙断开, 打开断开提示");
|
|
|
// 显示蓝牙断开弹窗
|
|
|
// this.setState({
|
|
|
// workStatus: "",
|
|
|
// currentShowDialog: "connection_break",
|
|
|
// });
|
|
|
};
|
|
|
|
|
|
GetModeList = async (id) => {
|
|
|
let params = {
|
|
|
instrumentId: id,
|
|
|
};
|
|
|
let res = await InstrumentInfo.modeInfoList(params);
|
|
|
if (res.data.code === 200) {
|
|
|
if (res.data.data.length > 0) {
|
|
|
this.setState({
|
|
|
ActiveModeItem: res.data.data[0],
|
|
|
ModeList: res.data.data,
|
|
|
});
|
|
|
|
|
|
setTimeout(() => {
|
|
|
console.log("ActiveModeItem", this.state.ActiveModeItem);
|
|
|
});
|
|
|
} else {
|
|
|
this.setState({ ModeList: res.data.data });
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
changeMusicStatus = () => {
|
|
|
let { isMusicPlay } = this.state;
|
|
|
this.setState({ isMusicPlay: !isMusicPlay });
|
|
|
};
|
|
|
|
|
|
/** 开始护理按钮：点击开始，页面进行到下一步 */
|
|
|
onStartNurse = async () => {
|
|
|
this.stepNext();
|
|
|
return;
|
|
|
let { isConnectionBlutoot } = this.state;
|
|
|
if (isConnectionBlutoot) {
|
|
|
this.stepNext();
|
|
|
} else {
|
|
|
// todo 提示未连接蓝牙
|
|
|
}
|
|
|
};
|
|
|
/** 切换光照 */
|
|
|
onSwitchChange = async () => {
|
|
|
// todo
|
|
|
let { isStopNurse } = this.state;
|
|
|
let switchStatus = !isStopNurse;
|
|
|
if (switchStatus) {
|
|
|
// 开始光照逻辑
|
|
|
} else {
|
|
|
// 暂停光照逻辑
|
|
|
}
|
|
|
this.setState({ isStopNurse: switchStatus });
|
|
|
};
|
|
|
onEndPlan = async () => {
|
|
|
// todo
|
|
|
};
|
|
|
|
|
|
modeCurrentFun = async (data) => {
|
|
|
console.log("modeCurrentFun", data);
|
|
|
this.setState({ ActiveModeItem: data });
|
|
|
};
|
|
|
|
|
|
stepNext = () => {
|
|
|
// //0未定义（全部） 1面罩模式 2舱体模式 3医美术后
|
|
|
let modeArray = ["all", "visor", "cabin", "yimeish"];
|
|
|
let modeClass = this.state.ActiveModeItem.modeClass;
|
|
|
this.setState({ ModeType: modeArray[modeClass] });
|
|
|
this.setState({ isShowNurse: true });
|
|
|
};
|
|
|
|
|
|
closeStepTips = (data) => {
|
|
|
if (data.isLocal) {
|
|
|
setStorageSync("isFirstEntry_" + this.state.ActiveModeItem.model, true); // 关闭首次进入弹窗
|
|
|
}
|
|
|
this.setState({ isShowStepTips: false });
|
|
|
};
|
|
|
|
|
|
/** 蓝牙相关 */
|
|
|
switchBLEMatch = (jsonStatus: any) => {
|
|
|
switch (jsonStatus.bleCommandType) {
|
|
|
// 如果设备配对链接发送配对码的时候，设备应答小程序配对码是否正确。
|
|
|
case "SendMatchCode":
|
|
|
if (jsonStatus.matchedSuccess) {
|
|
|
// msg('配对成功')
|
|
|
console.log("配对成功");
|
|
|
// log.info(commandMap.WL200Command, "配对成功");
|
|
|
}
|
|
|
break;
|
|
|
//附属设备状态主动上报，这种指令是主机主动上报某个附属设备断开或者连上了
|
|
|
case "BleStatusSync":
|
|
|
switch (jsonStatus.connectMessage?.deviceName) {
|
|
|
case "WL200":
|
|
|
if (jsonStatus.connectMessage?.connectType == "CONNECTED") {
|
|
|
// 已连接WL200
|
|
|
this.setState({ isConnectionBlutoot: true });
|
|
|
if (
|
|
|
!this.state.customModeData.setCustomSuc &&
|
|
|
!this.state.customModeData.hadSetCustom
|
|
|
) {
|
|
|
// this.setCustomMaskData();
|
|
|
}
|
|
|
// that.setData({
|
|
|
// facialMaskConnectStatus: 1,
|
|
|
// });
|
|
|
// this.deviceToolKitInstance = deviceToolKitInstanceWL200;
|
|
|
// console.log(
|
|
|
// "checkedMaskVersion",
|
|
|
// this.data.checkedMaskVersion
|
|
|
// );
|
|
|
// if (!this.data.checkedMaskVersion) {
|
|
|
// this.checkVersion();
|
|
|
// }
|
|
|
} else {
|
|
|
// deviceToolKitInstance = deviceToolKitInstanceWE100;
|
|
|
// // TODO 护理中(step==2)时, 如果断开, 可能需要暂停
|
|
|
// that.setData({
|
|
|
// facialMaskConnectStatus: 0,
|
|
|
// });
|
|
|
}
|
|
|
break;
|
|
|
case "Stand":
|
|
|
// that.setData({
|
|
|
// isStandStatus:
|
|
|
// jsonStatus.connectMessage?.connectType == "CONNECTED",
|
|
|
// });
|
|
|
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
break;
|
|
|
//小程序主动问主机，现在链接了哪些附属设备，这时候主机给小程序的回复消息
|
|
|
case "QueryMatchStatus":
|
|
|
const isStandDevice =
|
|
|
jsonStatus?.subDeviceList?.includes("Stand") || false;
|
|
|
const isConnectedMask =
|
|
|
jsonStatus?.subDeviceList?.includes("WL200") || false;
|
|
|
deviceToolKitInstance = isConnectedMask
|
|
|
? deviceToolKitInstanceWL200
|
|
|
: deviceToolKitInstanceWE100;
|
|
|
console.log(isConnectedMask, "更改成功deviceToolKitInstance");
|
|
|
if (!this.state.checkedMaskVersion && isConnectedMask) {
|
|
|
this.checkVersion();
|
|
|
}
|
|
|
console.log("支架是否链接", isStandDevice);
|
|
|
console.log("面罩是否链接", isConnectedMask);
|
|
|
//这里bug 先注释掉 bug是拔掉支架之后启动面罩工作就会一直弹
|
|
|
// let { basicModeList, modelActiveIndex } = that.data;
|
|
|
// if (
|
|
|
// that.data.step == 2 &&
|
|
|
// !isStandDevice &&
|
|
|
// basicModeList[modelActiveIndex].isStandMode &&
|
|
|
// !that.data.hadShowBreakTips
|
|
|
// ) {
|
|
|
// that.data.hadShowBreakTips = true;
|
|
|
// that.onPauseTap();
|
|
|
// that.standVideoContext.seek(0);
|
|
|
// // that.showTips('检测到支架未连接成功，请确认面罩开机后与支架连接，并接通支架电源');
|
|
|
// that.showTips(
|
|
|
// `检测到${that.data.deviceChineseName.WL200Stand}未连接成功，请确认面罩开机后与${that.data.deviceChineseName.WL200Stand}连接，并接通${that.data.deviceChineseName.WL200Stand}电源`
|
|
|
// );
|
|
|
|
|
|
// 连上面罩后, 设置自定义模式 -- 不在这里设置自定义模式
|
|
|
if (
|
|
|
this.state.ActiveModeItem &&
|
|
|
isConnectedMask &&
|
|
|
!this.state.customModeData.setCustomSuc &&
|
|
|
!this.state.customModeData.hadSetCustom &&
|
|
|
this.state.ActiveModeItem.isCustomMode
|
|
|
) {
|
|
|
this.setCustomMaskData();
|
|
|
}
|
|
|
// 连上面罩后, 获取仪器记录, 与缓存信息对比,
|
|
|
// if (
|
|
|
// isConnectedMask &&
|
|
|
// !this.state.hadGotInstrumentHistoryData
|
|
|
// ) {
|
|
|
// // 如果不延时, 无法获取到仪器状态
|
|
|
// const queryDeviceArrayBuffer =
|
|
|
// deviceToolKitInstance.toBleCommand(
|
|
|
// bleCommandSamples.queryDeviceStatus as any
|
|
|
// );
|
|
|
// console.log("发送查询设备指令");
|
|
|
// sendCommand({
|
|
|
// value: queryDeviceArrayBuffer,
|
|
|
// });
|
|
|
// // 打开ota页面需要关闭
|
|
|
// // that.data.getInstrumentHistoryDataTimer = setTimeout(() => {
|
|
|
// // that.getInstrumentHistoryData();
|
|
|
// // }, 3000);
|
|
|
// }
|
|
|
// this.setData({
|
|
|
// isStandStatus: isStandDevice,
|
|
|
// facialMaskConnectStatus: `${isConnectedMask ? 1 : 0}`,
|
|
|
// // currentTime: this.data.standInfo.currentTime
|
|
|
// });
|
|
|
}
|
|
|
};
|
|
|
notifyBLECharacteristicValueChange = () => {
|
|
|
console.log("notifyBLECharacteristicValueChange deviceInfo 参数为=>");
|
|
|
const bluetoothInfo = this.props.bluetoothInfo;
|
|
|
notifyBLECharacteristicValueChange({
|
|
|
deviceId: bluetoothInfo.deviceId,
|
|
|
servicesuuid: bluetoothInfo.servicesuuid,
|
|
|
characteristicsuuid1: bluetoothInfo.characteristicsuuid1,
|
|
|
characteristicsuuid0: bluetoothInfo.characteristicsuuid0,
|
|
|
}).then((res) => {
|
|
|
Taro.onBLECharacteristicValueChange((value) => {
|
|
|
const jsonStatus: any = deviceToolKitInstance.toJsonStatus(value.value);
|
|
|
console.log(
|
|
|
"onBLECharacteristicValueChange jsonStatus => ",
|
|
|
jsonStatus
|
|
|
);
|
|
|
// log.info(commandMap.WL200Command, 'onBLECharacteristicValueChange jsonStatus =>', jsonStatus);
|
|
|
if (!jsonStatus || jsonStatus == null) {
|
|
|
return;
|
|
|
}
|
|
|
// end 和 endWork 都是护理结束, endWork不关机, end 关机, 对小程序而已处理流程都一样
|
|
|
if (jsonStatus.workStatus && jsonStatus.workStatus == "endWork") {
|
|
|
jsonStatus.workStatus = "end";
|
|
|
console.log(jsonStatus.workStatus, "护理结束");
|
|
|
}
|
|
|
|
|
|
// 指令类型判断
|
|
|
switch (jsonStatus?.commandType) {
|
|
|
case "BleMatch":
|
|
|
// 蓝牙相关指令
|
|
|
this.switchBLEMatch(jsonStatus);
|
|
|
break;
|
|
|
|
|
|
case "DeviceControl":
|
|
|
console.log("小程序控制设备，给设备发送指令", jsonStatus);
|
|
|
if (
|
|
|
jsonStatus.responseStatus == "OK" &&
|
|
|
this.state.isSendModeCombination
|
|
|
) {
|
|
|
// 发送启动指令
|
|
|
this.startCombinationMode();
|
|
|
const totalTime = this.state.combinationList.reduce(
|
|
|
(total, item) => {
|
|
|
return total + minSecToS(item.time);
|
|
|
},
|
|
|
0
|
|
|
);
|
|
|
|
|
|
// 设备启动后小程序操作
|
|
|
this.setState({
|
|
|
showCombinationModeDialog: false,
|
|
|
combinationModeInfo: {
|
|
|
time: s_to_hs(totalTime),
|
|
|
seconds: totalTime,
|
|
|
},
|
|
|
modelActiveIndex: -1,
|
|
|
currentTime: s_to_hs(totalTime),
|
|
|
isCurrentModeCombination: true,
|
|
|
isSendModeCombination: false,
|
|
|
});
|
|
|
setTimeout(() => {
|
|
|
console.log("currentTime", this.state.currentTime);
|
|
|
});
|
|
|
}
|
|
|
break;
|
|
|
//设备主动上报给小程序的指令 一般是工作状态改变
|
|
|
case "DeviceStatusSync":
|
|
|
console.log(
|
|
|
"设备主动上报给小程序的指令 一般是工作状态改变",
|
|
|
jsonStatus
|
|
|
);
|
|
|
this.setState({
|
|
|
Electricity: jsonStatus.battery,
|
|
|
matrixElectricity: jsonStatus.matrixBattery,
|
|
|
workStatus: jsonStatus.workStatus,
|
|
|
workMode: jsonStatus?.workMode,
|
|
|
});
|
|
|
this.setState({
|
|
|
fr200Electricity: jsonStatus.battery,
|
|
|
matrixElectricity: jsonStatus.matrixBattery,
|
|
|
workStatus: jsonStatus.workStatus,
|
|
|
workMode: jsonStatus?.workMode,
|
|
|
});
|
|
|
// 判断是否在step == 2(护理中)
|
|
|
if (
|
|
|
this.state.step == 2 &&
|
|
|
jsonStatus.workStatus !== MODE_WORKING_ENUM.END
|
|
|
) {
|
|
|
this.updateDeviceSyncData({
|
|
|
totalWorkingMinutes: jsonStatus.totalWorkingMinutes,
|
|
|
totalWorkingSeconds: jsonStatus.totalWorkingSeconds,
|
|
|
});
|
|
|
}
|
|
|
if (jsonStatus.workMode && this.state.step == 2) {
|
|
|
const { ActiveModeItem } = this.state;
|
|
|
const item = ActiveModeItem;
|
|
|
if (
|
|
|
jsonStatus.workMode !== WORK_MODE_ENGLISH_NAME[item.model_type]
|
|
|
) {
|
|
|
clearTimeout(loadingTipsTimer);
|
|
|
this.setState({
|
|
|
isShowCountdown: false,
|
|
|
});
|
|
|
}
|
|
|
}
|
|
|
// // 我忘记了为啥要这样传参... 埋坑了...
|
|
|
this.judgementWorkStatus(
|
|
|
jsonStatus.workStatus,
|
|
|
jsonStatus.workMode,
|
|
|
jsonStatus
|
|
|
);
|
|
|
if (jsonStatus.workMode && this.state.step == 2) {
|
|
|
// this.judgementModel(jsonStatus.workMode);
|
|
|
// that.data.startSettingCountDown = false;
|
|
|
}
|
|
|
break;
|
|
|
//设备信息查询返回
|
|
|
case "InfoQuery":
|
|
|
switch (jsonStatus.infoQueryType) {
|
|
|
// 自定义模式设置
|
|
|
case "customModeSet":
|
|
|
console.log(
|
|
|
"InfoQuery customModeSet responseStatus=====>",
|
|
|
jsonStatus
|
|
|
);
|
|
|
let { customModeData } = this.state;
|
|
|
|
|
|
if (jsonStatus.responseStatus == "OK") {
|
|
|
customModeData.setCustomSuc = true;
|
|
|
this.setState({
|
|
|
customModeData,
|
|
|
});
|
|
|
console.log("设置成功自定义模式");
|
|
|
} else {
|
|
|
customModeData.hadSetCustom = false;
|
|
|
customModeData.setCustomSuc = false;
|
|
|
this.setState({
|
|
|
customModeData,
|
|
|
});
|
|
|
}
|
|
|
break;
|
|
|
// 自定义模式信息
|
|
|
case "customModeInfo":
|
|
|
console.log(
|
|
|
"InfoQuery customModeInfo responseStatus=====>",
|
|
|
jsonStatus
|
|
|
);
|
|
|
break;
|
|
|
case "versionInfo":
|
|
|
console.log(
|
|
|
"InfoQuery versionInfo responseStatus=====>",
|
|
|
jsonStatus
|
|
|
);
|
|
|
if (jsonStatus.versionNo) {
|
|
|
// 清理计时器
|
|
|
if (checkVersionTimeout) clearTimeout(checkVersionTimeout);
|
|
|
if (this.state.hasVersion) return;
|
|
|
this.setState({
|
|
|
hasVersion: true,
|
|
|
});
|
|
|
this.checkOta(jsonStatus.versionNo);
|
|
|
}
|
|
|
break;
|
|
|
// 当前报告
|
|
|
case "currentMaskReportInfo":
|
|
|
console.log("currentMaskReportInfo", jsonStatus);
|
|
|
// if (!this.state.hadCheckReport) {
|
|
|
// this.state.hadCheckReport = true;
|
|
|
// that.checkInstrumentRecord(jsonStatus);
|
|
|
// } else {
|
|
|
// that.setWL200NursingHistory(jsonStatus);
|
|
|
// }
|
|
|
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
break;
|
|
|
// default:
|
|
|
// break;
|
|
|
}
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* 延迟500毫秒获取附属设备状态
|
|
|
*/
|
|
|
const querySubDeviceArrayBuffer = deviceToolKitInstance.toBleCommand({
|
|
|
...bleCommandSamples.querySubDevice,
|
|
|
queryType: "WL200",
|
|
|
} as any);
|
|
|
setTimeout(() => {
|
|
|
console.log("发送查询指令");
|
|
|
sendCommand({
|
|
|
value: querySubDeviceArrayBuffer,
|
|
|
});
|
|
|
}, 500);
|
|
|
|
|
|
/**
|
|
|
* 延迟500毫秒获取设备电量
|
|
|
*/
|
|
|
const queryDeviceArrayBuffer = deviceToolKitInstance.toBleCommand(
|
|
|
bleCommandSamples.queryDeviceStatus as any
|
|
|
);
|
|
|
setTimeout(() => {
|
|
|
console.log("发送查询设备指令");
|
|
|
sendCommand({
|
|
|
value: queryDeviceArrayBuffer,
|
|
|
});
|
|
|
}, 500);
|
|
|
});
|
|
|
};
|
|
|
|
|
|
// 检查版本
|
|
|
checkVersion = () => {
|
|
|
this.sendCheckVersion();
|
|
|
this.setState({
|
|
|
checkedMaskVersion: true,
|
|
|
});
|
|
|
if (checkVersionTimeout) clearTimeout(checkVersionTimeout);
|
|
|
checkVersionTimeout = setTimeout(() => {
|
|
|
if (this.state.hasVersion) {
|
|
|
if (checkVersionTimeout) clearTimeout(checkVersionTimeout);
|
|
|
} else {
|
|
|
this.sendCheckVersion();
|
|
|
}
|
|
|
}, 600);
|
|
|
};
|
|
|
// 检查版本指令
|
|
|
sendCheckVersion = () => {
|
|
|
deviceToolKitInstance.setDebug(true);
|
|
|
// 加定时器查询版本
|
|
|
const queryVersion = deviceToolKitInstance.toBleCommand({
|
|
|
commandType: "InfoQuery",
|
|
|
infoQueryType: "versionInfo",
|
|
|
otaDeviceType: "WL200",
|
|
|
});
|
|
|
sendCommand({
|
|
|
value: queryVersion,
|
|
|
});
|
|
|
};
|
|
|
|
|
|
checkOta = async (versionNo) => {
|
|
|
const { iot_versions } = this.state.curDeviceInfo;
|
|
|
let isNeedToUpdateBl = isNeedToUpdate(versionNo, iot_versions);
|
|
|
console.log(
|
|
|
`设备版本号: ${versionNo}`,
|
|
|
`后台版本号: ${iot_versions}`,
|
|
|
`是否需要升级: ${isNeedToUpdateBl}`
|
|
|
);
|
|
|
if (isNeedToUpdateBl) {
|
|
|
this.setState({
|
|
|
askedOta: true,
|
|
|
// currentShowDialog: 'offlineDialog',
|
|
|
});
|
|
|
// this.confirmOta();
|
|
|
}
|
|
|
};
|
|
|
|
|
|
// 发送启动组合模式指令
|
|
|
startCombinationMode() {
|
|
|
const jsonCommand = {
|
|
|
commandType: "DeviceControl",
|
|
|
workStatus: "working",
|
|
|
workMode: "MaskCustom",
|
|
|
};
|
|
|
let commandBuffer = deviceToolKitInstance.toBleCommand(jsonCommand as any);
|
|
|
sendCommand({
|
|
|
value: commandBuffer,
|
|
|
}).then(() => {
|
|
|
console.info("发送启动组合模式指令成功 参数为 =>", jsonCommand);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
//待完善，以后同步设备数据到小程序的事件,在这个事件里判断是否需要更新页面(是否需要触发setData)
|
|
|
updateDeviceSyncData = (newData) => {
|
|
|
DeviceSyncData = {
|
|
|
...DeviceSyncData,
|
|
|
...newData,
|
|
|
};
|
|
|
if (newData.hasOwnProperty("totalWorkingSeconds")) {
|
|
|
this.renderDeviceStatus.renderWorkTime();
|
|
|
}
|
|
|
};
|
|
|
|
|
|
// 待完善，以后更新页面状态的方法，在这里执行setData
|
|
|
renderDeviceStatus = {
|
|
|
renderWorkTime() {
|
|
|
// const that = this;
|
|
|
const { totalWorkingMinutes, totalWorkingSeconds } = DeviceSyncData;
|
|
|
const { ActiveModeItem, currentTime } = this.state;
|
|
|
const totalTime = totalWorkingMinutes * 60 + totalWorkingSeconds;
|
|
|
console.log("仪器上报的已经运行的总秒数", totalTime);
|
|
|
// console.log('时间校准频率，默认5秒一次',TIME_CALIBRATION_FREQUENCY)
|
|
|
//对比仪器上报运行的总秒数 和小程序页面运行的已经运行的总秒数，如果不一致就进行校准
|
|
|
const currentScene = ActiveModeItem; // 获取当前的场景
|
|
|
let sceneTime = minSecToS(currentScene.time); // 场景时间
|
|
|
|
|
|
const timeRemaining = sceneTime - minSecToS(currentTime); // 小程序上已运行的总秒数
|
|
|
if (
|
|
|
Math.abs(timeRemaining - totalTime) >= 2 &&
|
|
|
this.state.step == 2 &&
|
|
|
this.state.facialMaskConnectStatus == 1
|
|
|
) {
|
|
|
this.setTimer();
|
|
|
const t = sceneTime - totalTime; // 场景时间 - 已运行时间 = 剩余时间
|
|
|
let { ActiveModeItem } = this.state;
|
|
|
ActiveModeItem.seconds = t; //修复时间跳变的问题
|
|
|
this.setState({
|
|
|
currentTime: s_to_hs(t),
|
|
|
ActiveModeItem,
|
|
|
});
|
|
|
}
|
|
|
},
|
|
|
};
|
|
|
|
|
|
// 仪器开始倒计时
|
|
|
setLoadingTips(time) {
|
|
|
this.setState({
|
|
|
countdown: time,
|
|
|
});
|
|
|
if (time >= 0) {
|
|
|
loadingTipsTimer = setTimeout(() => {
|
|
|
this.setLoadingTips(--time);
|
|
|
}, 1000);
|
|
|
} else {
|
|
|
// 停止倒计时
|
|
|
// that.data.startSettingCountDown = false;
|
|
|
this.setState({
|
|
|
isShowCountdown: false,
|
|
|
});
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 设备上报不同状态
|
|
|
judgementWorkStatus(nWorkStatus, nWorkMode, jsonStatus) {
|
|
|
const {
|
|
|
workStatus,
|
|
|
step,
|
|
|
isStandStatus,
|
|
|
workMode,
|
|
|
ActiveModeItem,
|
|
|
ModeList,
|
|
|
} = this.state;
|
|
|
const opts: any = {};
|
|
|
// ActiveModeItem
|
|
|
const modeItem = ActiveModeItem;
|
|
|
let nowModeItem;
|
|
|
if (nWorkMode) {
|
|
|
const nowModeType = WORK_MODE_TYPE[nWorkMode];
|
|
|
nowModeItem = ModeList.find((item) => {
|
|
|
return item.model_type == nowModeType;
|
|
|
});
|
|
|
}
|
|
|
opts.workStatus = nWorkStatus;
|
|
|
const statusF = {
|
|
|
sleep: () => {
|
|
|
this.setState({
|
|
|
isShowCountdown: false,
|
|
|
});
|
|
|
},
|
|
|
standby: () => {
|
|
|
this.setState({
|
|
|
isShowCountdown: false,
|
|
|
});
|
|
|
if (nowModeItem?.isStandMode && step == 2) {
|
|
|
opts.currentTime = nowModeItem.time;
|
|
|
} else if (!nowModeItem?.isStandMode && step == 2) {
|
|
|
// fix: 启动非支架模式倒计时时，连上支架，仪器的状态变为standby
|
|
|
opts.step = 1;
|
|
|
}
|
|
|
if (loadingTipsTimer) {
|
|
|
clearTimeout(loadingTipsTimer);
|
|
|
}
|
|
|
// 本来用于更新时间的，但是产生了 ID1000367 bug，先移除
|
|
|
// if (nowModeItem) {
|
|
|
// opts.currentTime = nowModeItem.time;
|
|
|
// }
|
|
|
},
|
|
|
setting: () => {
|
|
|
// that.data.hadShowBreakTips = false;
|
|
|
this.setState({
|
|
|
hadShowBreakTips: false,
|
|
|
});
|
|
|
if (step != 2 && !modeItem.isStandMode) {
|
|
|
opts.step = 2;
|
|
|
this.setState({
|
|
|
title: "正在护理",
|
|
|
isStopNurse: false,
|
|
|
});
|
|
|
// Taro.setNavigationBarTitle({
|
|
|
// title: "正在护理",
|
|
|
// });
|
|
|
// 处理音乐
|
|
|
this.musicStatusChange();
|
|
|
} else if (step != 2 && modeItem.isStandMode) {
|
|
|
opts.step = 2;
|
|
|
// this.setState({
|
|
|
// title: "正在护理",
|
|
|
// });
|
|
|
this.setState({
|
|
|
title: "正在护理",
|
|
|
isStopNurse: false,
|
|
|
});
|
|
|
}
|
|
|
if (nowModeItem) {
|
|
|
opts.currentTime = nowModeItem.time;
|
|
|
}
|
|
|
// startSettingCountDown 用于标记打开了倒计时loading
|
|
|
if (!this.state.isShowCountdown) {
|
|
|
this.setState({
|
|
|
isShowCountdown: true,
|
|
|
});
|
|
|
this.setLoadingTips(CountDownTime[workMode] || 6);
|
|
|
}
|
|
|
},
|
|
|
working: () => {
|
|
|
if (this.state.facialMaskConnectStatus != 1) {
|
|
|
opts.workStatus = MODE_WORKING_ENUM.STANDBY;
|
|
|
opts.step = 1;
|
|
|
} else if (step != 2) {
|
|
|
opts.step = 2;
|
|
|
this.setState({
|
|
|
title: "正在护理",
|
|
|
isStopNurse: false,
|
|
|
});
|
|
|
// 处理音乐
|
|
|
// this.musicStatusChange();
|
|
|
}
|
|
|
// else if (modeItem?.isStandMode) {
|
|
|
// 支架模式也使用gif图, 不需要播放视频了, 所以注释
|
|
|
// that.onPlayTap();
|
|
|
// }
|
|
|
|
|
|
this.setState({
|
|
|
isShowCountdown: false,
|
|
|
hadShowBreakTips: false,
|
|
|
});
|
|
|
},
|
|
|
pause: () => {
|
|
|
this.setState({
|
|
|
isShowCountdown: false,
|
|
|
});
|
|
|
if (modeItem.isStandMode) {
|
|
|
// this.onPauseTap();
|
|
|
this.setState({
|
|
|
title: "暂停护理",
|
|
|
isStopNurse: true,
|
|
|
});
|
|
|
}
|
|
|
},
|
|
|
end: () => {
|
|
|
// 仪器返回护理结束, 支架模式不需要了
|
|
|
// if (modeItem.isStandMode) {
|
|
|
// that.onPauseTap();
|
|
|
// }
|
|
|
// 已进入了报告阶段, 防止重复进入, 主要防止在手动点击结束护理接收到仪器消息
|
|
|
if (this.state.endPlace) return;
|
|
|
// 获取仪器运行时间,更新currentTime, 判断仪器返回时间正常的情况下
|
|
|
const { totalWorkingSeconds, totalWorkingMinutes } = jsonStatus;
|
|
|
if (totalWorkingSeconds != 0 || totalWorkingMinutes != 0) {
|
|
|
const sceneTime = minSecToS(modeItem.currentTime); // 模式的总时长
|
|
|
const runTime = totalWorkingMinutes * 60 + totalWorkingSeconds; //仪器运行时长
|
|
|
const timeRemaining = sceneTime - runTime; // 剩余未运行时间
|
|
|
this.setState({
|
|
|
currentTime: s_to_hs(timeRemaining),
|
|
|
});
|
|
|
}
|
|
|
this.endnursing(null, true);
|
|
|
this.rmWL200NursingHistory(this.state.WL200NursingHistory);
|
|
|
},
|
|
|
};
|
|
|
statusF[nWorkStatus] && statusF[nWorkStatus]();
|
|
|
if (Object.keys(opts).length) {
|
|
|
this.setState(opts);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 保存护理报告
|
|
|
* 1.是否跳转 2.数据
|
|
|
* */
|
|
|
saveNurseReport = async (isJump = true, from) => {
|
|
|
const { isStandStatus, standInfo, ActiveModeItem, options } = this.state;
|
|
|
const currentScene = ActiveModeItem;
|
|
|
let sceneTime = minSecToS(currentScene.time);
|
|
|
const timeRemaining = sceneTime - minSecToS(this.state.currentTime);
|
|
|
const form = {
|
|
|
second: timeRemaining,
|
|
|
screne_id: currentScene.screne_id,
|
|
|
screne_name: currentScene.screne_name,
|
|
|
instrument_id: options?.devId,
|
|
|
report: JSON.stringify({
|
|
|
positionRatio: Math.floor((timeRemaining / sceneTime) * 100),
|
|
|
}),
|
|
|
};
|
|
|
// log.info(commandMap.WL200Command, '保存护理报告saveNurseReport', '来自方法from:' + from, '护理时间timeRemaining:'+timeRemaining);
|
|
|
console.log("timeRemaining=>", timeRemaining);
|
|
|
console.log("currentScene=>", currentScene);
|
|
|
console.log("form=>", form);
|
|
|
// const { data } = await UserNursingLogAdd(form)
|
|
|
// // 清除缓存
|
|
|
// that.rmWL200NursingHistory(that.data.WL200NursingHistory, true);
|
|
|
// if (data.code == 200 && isJump) {
|
|
|
// that.setData({
|
|
|
// showNurseSuccess: true
|
|
|
// });
|
|
|
// setTimeout(()=>{
|
|
|
// wx.redirectTo({ url: `/pages/MatrixWL200/pages/nursingRecord/nursingRecord?instrument_id=${options?.devId}&id=${data.data}` })
|
|
|
// }, 2000);
|
|
|
// }
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* 结束护理
|
|
|
* param isAuto 是否仪器自动结束
|
|
|
*/
|
|
|
endnursing(e, isAuto) {
|
|
|
if (isAuto == true) {
|
|
|
// 仪器自动上报完成, 直接上报并跳转报告页
|
|
|
clearInterval(timer);
|
|
|
const isEnough = this.checkTime();
|
|
|
if (isEnough && !this.state.endPlace) {
|
|
|
this.setState({
|
|
|
endPlace: "report",
|
|
|
});
|
|
|
this.saveNurseReport(true, "endnursing");
|
|
|
}
|
|
|
// this.handleTimeCheck(that.endNurseFun)
|
|
|
} else {
|
|
|
// 手动点击结束, 弹出弹窗, 看看是否需要结束
|
|
|
this.setState({
|
|
|
popupType: "endPopup",
|
|
|
});
|
|
|
/*showModal({
|
|
|
t2: "是否结束护理？",
|
|
|
}).then(async () => {
|
|
|
this.handleTimeCheck(that.endNurseFun)
|
|
|
});*/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
setCustomModeData() {
|
|
|
const { basicModeList, modelActiveIndex, currentTime } = that.data;
|
|
|
const modeItem = basicModeList[modelActiveIndex];
|
|
|
const group = modeItem.group;
|
|
|
if (group.length == 1) return; // 只有1项不用管
|
|
|
|
|
|
let inTimeScopeIndex = -1; // 选择的index
|
|
|
group.forEach((item, index) => {
|
|
|
let startMinute = item.scope[0];
|
|
|
let endMinute = item.scope[1];
|
|
|
let targetMinute = currentTime.split(":")[0];
|
|
|
let targetSecond = currentTime.split(":")[1];
|
|
|
const isInTime = this.isInTimeScope(
|
|
|
startMinute,
|
|
|
endMinute,
|
|
|
targetMinute,
|
|
|
targetSecond
|
|
|
);
|
|
|
if (isInTime) inTimeScopeIndex = index;
|
|
|
});
|
|
|
if (modeItem.timeScopeIndex !== inTimeScopeIndex) {
|
|
|
// this.setState({
|
|
|
// [`basicModeList[${modelActiveIndex}].timeScopeIndex`]: inTimeScopeIndex,
|
|
|
// [`basicModeList[${modelActiveIndex}].desc`]: group[inTimeScopeIndex].desc,
|
|
|
// [`basicModeList[${modelActiveIndex}].technique`]: group[inTimeScopeIndex].technique,
|
|
|
// [`basicModeList[${modelActiveIndex}].pause_img`]: group[inTimeScopeIndex].pause_img,
|
|
|
// [`basicModeList[${modelActiveIndex}].running_img`]: group[inTimeScopeIndex].running_img,
|
|
|
// })
|
|
|
}
|
|
|
}
|
|
|
isInTimeScope(start, end, targetMinute, targetSecond) {
|
|
|
const startTime = dayjs().set("minute", start).set("second", 0);
|
|
|
const endTime = dayjs().set("minute", end).set("second", 0);
|
|
|
const targetTime = dayjs()
|
|
|
.set("minute", targetMinute)
|
|
|
.set("second", targetSecond); // 要判断的时间，这里使用当前时间作为示例
|
|
|
let inTime = false;
|
|
|
if (
|
|
|
(targetTime.isAfter(startTime) && targetTime.isBefore(endTime)) ||
|
|
|
targetTime.isSame(startTime) ||
|
|
|
targetTime.isSame(endTime)
|
|
|
) {
|
|
|
inTime = true;
|
|
|
}
|
|
|
return inTime;
|
|
|
}
|
|
|
|
|
|
setTimer() {
|
|
|
// 切换模式后, 需要重新设置计时器, 以防进行中的计时器
|
|
|
timer && clearInterval(timer);
|
|
|
timer = setInterval(() => {
|
|
|
if (
|
|
|
this.state.workStatus == MODE_WORKING_ENUM.WORKING &&
|
|
|
this.state.step == 2 &&
|
|
|
this.state.facialMaskConnectStatus == 1
|
|
|
) {
|
|
|
/*if(that.data.workMode !== WORK_MODE_NAME_ENUM.POWERFULSOOTHING){*/
|
|
|
let currentSeconds;
|
|
|
if (this.state.isCurrentModeCombination) {
|
|
|
// 组合模式逻辑
|
|
|
// that.data.combinationModeInfo.seconds -= 1;
|
|
|
// that.setData({
|
|
|
// currentTime: s_to_hs(that.data.combinationModeInfo.seconds)
|
|
|
// })
|
|
|
// currentSeconds = that.data.combinationModeInfo.seconds
|
|
|
} else {
|
|
|
const { ActiveModeItem, currentTime } = this.state;
|
|
|
currentSeconds = minSecToS(currentTime);
|
|
|
this.setState({
|
|
|
currentTime: s_to_hs(--currentSeconds),
|
|
|
});
|
|
|
console.log(ActiveModeItem.isCustomMode);
|
|
|
if (ActiveModeItem.isCustomMode) {
|
|
|
this.setCustomModeData();
|
|
|
}
|
|
|
}
|
|
|
if (currentSeconds <= 0) {
|
|
|
clearInterval(timer);
|
|
|
// 统一接收仪器结束指令
|
|
|
// that.data.endPlace = 'report';
|
|
|
// that.saveNurseReport(true, 'setTimer');
|
|
|
}
|
|
|
/*} else {
|
|
|
that.data.standInfo.seconds -= 1;
|
|
|
that.setData({ currentTime: s_to_hs(that.data.standInfo.seconds) })
|
|
|
if(that.data.standInfo.seconds <= 0){
|
|
|
clearInterval(timer);
|
|
|
this.showNurseSuccessDialog()
|
|
|
}
|
|
|
}*/
|
|
|
}
|
|
|
}, 1000);
|
|
|
}
|
|
|
|
|
|
// 工作状态
|
|
|
handleWorkStatus = (_, workStatus) => {
|
|
|
const { facialMaskConnectStatus, isStandStatus, ActiveModeItem } =
|
|
|
this.state;
|
|
|
const modeItem = ActiveModeItem;
|
|
|
let newWorkStatus =
|
|
|
workStatus ||
|
|
|
(this.state.workStatus == MODE_WORKING_ENUM.WORKING
|
|
|
? "pause"
|
|
|
: "working");
|
|
|
if (_ && newWorkStatus == "working") {
|
|
|
if (modeItem.modeClass === 2 && !isStandStatus) {
|
|
|
this.showTips(
|
|
|
`检测到${this.state.deviceChineseName.WL200Stand}未连接成功，请确认面罩开机后与${this.state.deviceChineseName.WL200Stand}连接，并接通${this.state.deviceChineseName.WL200Stand}电源`
|
|
|
);
|
|
|
return;
|
|
|
}
|
|
|
if (!modeItem.isStandMode && facialMaskConnectStatus != 1) {
|
|
|
this.showTips("检测到面罩未连接成功，请确认面罩开机并佩戴");
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
const curModeData = ActiveModeItem;
|
|
|
const sendParams = {
|
|
|
...deviceCommandSamples.pause,
|
|
|
workMode: WORK_MODE_ENGLISH_NAME[curModeData.model_type],
|
|
|
workStatus: newWorkStatus,
|
|
|
};
|
|
|
const pauseArrayBuffer = deviceToolKitInstance.toBleCommand(
|
|
|
sendParams as any
|
|
|
);
|
|
|
sendCommand({
|
|
|
value: pauseArrayBuffer,
|
|
|
}).then(() => {
|
|
|
this.setState({
|
|
|
workStatus: newWorkStatus,
|
|
|
});
|
|
|
this.setTimer();
|
|
|
// 支架模式, 暂停, 需暂停视频播放
|
|
|
if (newWorkStatus == MODE_WORKING_ENUM.PAUSE && modeItem.isStandMode) {
|
|
|
this.onPauseTap();
|
|
|
}
|
|
|
// 支架模式, 开始播放, 需播放视频
|
|
|
if (newWorkStatus == MODE_WORKING_ENUM.WORKING && modeItem.isStandMode) {
|
|
|
this.onPlayTap();
|
|
|
}
|
|
|
console.info(
|
|
|
`handleWorkStatus 发送${newWorkStatus}指令成功 参数为 =>`,
|
|
|
sendParams
|
|
|
);
|
|
|
});
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* 点击开始护理
|
|
|
*/
|
|
|
onNursingTap() {
|
|
|
// 防止多次点击
|
|
|
if (this.state.hadClickStart) return;
|
|
|
this.setState({
|
|
|
hadClickStart: true,
|
|
|
});
|
|
|
setTimeout(() => {
|
|
|
this.setState({
|
|
|
hadClickStart: false,
|
|
|
});
|
|
|
}, 500);
|
|
|
const {
|
|
|
ActiveModeItem,
|
|
|
workStatus,
|
|
|
isStandStatus,
|
|
|
facialMaskConnectStatus,
|
|
|
customModeData,
|
|
|
} = this.state;
|
|
|
const modelActiveItem = ActiveModeItem;
|
|
|
// log.info(
|
|
|
// commandMap.WL200Command,
|
|
|
// "点击开始护理按钮",
|
|
|
// `当前模式: ${modelActiveIndex}`,
|
|
|
// `当前面罩状态:${facialMaskConnectStatus}`,
|
|
|
// `当前仪器模式:${workStatus}`
|
|
|
// );
|
|
|
console.info(
|
|
|
commandMap.WL200Command,
|
|
|
"点击开始护理按钮",
|
|
|
`当前模式: ${ActiveModeItem}`,
|
|
|
`当前面罩状态:${facialMaskConnectStatus}`,
|
|
|
`当前仪器模式:${workStatus}`
|
|
|
);
|
|
|
console.log(modelActiveItem);
|
|
|
console.log("isStandStatus:" + isStandStatus);
|
|
|
console.log(
|
|
|
workStatus !== MODE_WORKING_ENUM.WORKING &&
|
|
|
workStatus !== MODE_WORKING_ENUM.STANDBY &&
|
|
|
workStatus !== MODE_WORKING_ENUM.PAUSE
|
|
|
);
|
|
|
|
|
|
if (facialMaskConnectStatus != 1) {
|
|
|
this.showTips("检测到面罩未连接成功，请确认面罩开机并佩戴");
|
|
|
return;
|
|
|
}
|
|
|
if (
|
|
|
workStatus !== MODE_WORKING_ENUM.WORKING &&
|
|
|
workStatus !== MODE_WORKING_ENUM.STANDBY &&
|
|
|
workStatus !== MODE_WORKING_ENUM.PAUSE
|
|
|
) {
|
|
|
this.showTips("检测到面罩未连接成功，请确认面罩开机并佩戴");
|
|
|
return;
|
|
|
}
|
|
|
// 如果是强效舒缓,需要判断是否连接支架
|
|
|
if (modelActiveItem.isStandMode && !isStandStatus) {
|
|
|
this.showTips(
|
|
|
`检测到${this.state.deviceChineseName.WL200Stand}未连接成功，请确认面罩开机后与${this.state.deviceChineseName.WL200Stand}连接，并接通${this.state.deviceChineseName.WL200Stand}电源`
|
|
|
);
|
|
|
// that.showTips('检测到支架未连接成功，请确认面罩开机后与支架连接，并接通支架电源');
|
|
|
return;
|
|
|
} else if (!modelActiveItem.isStandMode && isStandStatus) {
|
|
|
this.showTips(
|
|
|
`检测到面罩仍和${this.state.deviceChineseName.WL200Stand}连接中，请分离后切换`
|
|
|
);
|
|
|
return;
|
|
|
}
|
|
|
if (modelActiveItem.isCustomMode && !customModeData.setCustomSuc) {
|
|
|
this.showTips(
|
|
|
`${modelActiveItem.nursing_name}模式设置失败，请联系小助手`
|
|
|
);
|
|
|
return;
|
|
|
}
|
|
|
// 开始执行护理
|
|
|
this.handleWorkStatus(null, MODE_WORKING_ENUM.WORKING);
|
|
|
}
|
|
|
|
|
|
// 结束护理？
|
|
|
endNurseFun() {
|
|
|
// this.handleWorkStatus(null, "end");
|
|
|
setTimeout(() => {
|
|
|
//TODO IOS关闭蓝牙太快导致关机指令没发出去，暂时这么解决
|
|
|
const isEnough = this.checkTime();
|
|
|
if (!isEnough) {
|
|
|
Taro.showModal({
|
|
|
title: "提示",
|
|
|
content: "护理时间不足，请重新连接护理",
|
|
|
showCancel: false,
|
|
|
success: (res) => {
|
|
|
if (!this.state.endPlace || this.state.endPlace !== "report") {
|
|
|
// back();
|
|
|
console.log("back");
|
|
|
}
|
|
|
// this.state.innerAudioContext.destroy();
|
|
|
Taro.closeBluetoothAdapter();
|
|
|
},
|
|
|
});
|
|
|
} else {
|
|
|
if (!this.state.endPlace || this.state.endPlace !== "report") {
|
|
|
// back();
|
|
|
console.log("back");
|
|
|
}
|
|
|
// this.state.innerAudioContext.destroy();
|
|
|
Taro.closeBluetoothAdapter();
|
|
|
}
|
|
|
}, 500);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 音乐暂停播放时间
|
|
|
*/
|
|
|
musicStatusChange() {
|
|
|
const { step, ActiveModeItem } = this.state;
|
|
|
const modeItem = ActiveModeItem;
|
|
|
this.setState({
|
|
|
musicStatus: !this.state.musicStatus,
|
|
|
});
|
|
|
// if (step == 2 && !modeItem.isStandMode) {
|
|
|
// if (this.state.musicStatus) {
|
|
|
// this.state.innerAudioContext?.play(); // 播放
|
|
|
// } else {
|
|
|
// this.state.innerAudioContext?.pause(); //暂停
|
|
|
// }
|
|
|
// }
|
|
|
}
|
|
|
// 检查时间是否达标
|
|
|
checkTime() {
|
|
|
const { curDeviceInfo, workStatus, ActiveModeItem } = this.state;
|
|
|
const currentScene = ActiveModeItem;
|
|
|
let sceneTime = minSecToS(currentScene.time);
|
|
|
const timeRemaining = sceneTime - minSecToS(this.state.currentTime);
|
|
|
if (timeRemaining >= Number(curDeviceInfo?.times) * 60) {
|
|
|
return true;
|
|
|
} else {
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 开始护理？
|
|
|
onPlayTap() {
|
|
|
const { ActiveModeItem, step } = this.state;
|
|
|
const modeItem = ActiveModeItem;
|
|
|
if (step == 1) {
|
|
|
this.state.videoContext.play();
|
|
|
this.setState({
|
|
|
showVideoPlayBtn: false,
|
|
|
});
|
|
|
} else if (modeItem.isStandMode && step == 2) {
|
|
|
this.setState({
|
|
|
standVideoContext: Taro.createVideoContext("standVideo"),
|
|
|
});
|
|
|
setTimeout(() => {
|
|
|
this.state.standVideoContext.play();
|
|
|
}, 100);
|
|
|
}
|
|
|
}
|
|
|
// 暂停护理？
|
|
|
onPauseTap() {
|
|
|
const { ActiveModeItem, step } = this.state;
|
|
|
const modeItem = ActiveModeItem;
|
|
|
if (step == 1) {
|
|
|
} else if (modeItem.isStandMode && step == 2) {
|
|
|
this.setState({
|
|
|
standVideoContext: Taro.createVideoContext("standVideo"),
|
|
|
});
|
|
|
setTimeout(() => {
|
|
|
this.state.standVideoContext.play();
|
|
|
}, 100);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 删除WL200护理历史
|
|
|
rmWL200NursingHistory(WL200NursingHistory, hard = false) {
|
|
|
const nowWL200NursingHistory = Taro.getStorageSync("WL200NursingHistory");
|
|
|
if (nowWL200NursingHistory.id == WL200NursingHistory.id) {
|
|
|
Taro.removeStorageSync("WL200NursingHistory");
|
|
|
} else if (hard) {
|
|
|
Taro.removeStorageSync("WL200NursingHistory");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//蓝牙断开连接处理
|
|
|
bluetoothDisconnectProcessing() {
|
|
|
clearInterval(timer);
|
|
|
Taro.offBLEConnectionStateChange(this.listener); // 需传入与监听时同一个的函数对象
|
|
|
// this.state.innerAudioContext.destroy();
|
|
|
Taro.offBLECharacteristicValueChange((res) => {
|
|
|
console.log("offBLECharacteristicValueChange", res);
|
|
|
});
|
|
|
if (!this.state.isToOTA) {
|
|
|
Taro.closeBluetoothAdapter();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* 组合模式 */
|
|
|
setCustomMaskData() {
|
|
|
console.log("================");
|
|
|
console.log("setCustomMaskData");
|
|
|
console.log("================");
|
|
|
const { customModeData, ActiveModeItem } = this.state;
|
|
|
const customItem = ActiveModeItem;
|
|
|
if (!customItem.isCustomMode) {
|
|
|
let { customModeData } = this.state;
|
|
|
customModeData.hadSetCustom = false;
|
|
|
customModeData.setCustomSuc = false;
|
|
|
this.setState({
|
|
|
customModeData,
|
|
|
});
|
|
|
return;
|
|
|
}
|
|
|
if (
|
|
|
!customModeData.setCustomSuc &&
|
|
|
customItem &&
|
|
|
!customModeData.hadSetCustom
|
|
|
) {
|
|
|
this.state.customModeData.hadSetCustom = true;
|
|
|
// 设置组
|
|
|
let customModeSetCommand = customItem.customModeSetCommand;
|
|
|
console.log("自定义模式:", customModeSetCommand);
|
|
|
// log.info('自定义模式:', customModeSetCommand);
|
|
|
let commandBuffer =
|
|
|
deviceToolKitInstanceWL200.toBleCommand(customModeSetCommand);
|
|
|
sendCommand({
|
|
|
value: commandBuffer,
|
|
|
}).then((res) => {
|
|
|
console.info("发送切换组合模式指令成功", res);
|
|
|
});
|
|
|
}
|
|
|
}
|
|
|
|
|
|
showTips(ctx) {
|
|
|
if (!ctx) return;
|
|
|
if (showTipsTimer) clearTimeout(showTipsTimer);
|
|
|
this.setState({
|
|
|
errorTips: ctx,
|
|
|
});
|
|
|
showTipsTimer = setTimeout(() => {
|
|
|
this.setState({
|
|
|
errorTips: "",
|
|
|
});
|
|
|
}, 2000);
|
|
|
}
|
|
|
|
|
|
render() {
|
|
|
let {
|
|
|
name,
|
|
|
title,
|
|
|
isMusicPlay,
|
|
|
isShowStepTips,
|
|
|
ModeList,
|
|
|
ModeType,
|
|
|
isConnectionBlutoot,
|
|
|
isShowNurse,
|
|
|
isStopNurse,
|
|
|
ActiveModeItem,
|
|
|
isShowCountdown,
|
|
|
countdown,
|
|
|
ModeStepIndex,
|
|
|
Electricity,
|
|
|
errorTips,
|
|
|
} = this.state;
|
|
|
return (
|
|
|
<Block>
|
|
|
<Navbar titleSlot={title} isBack={true} />
|
|
|
<PopupCountdown isShow={isShowCountdown} countdown={countdown} />
|
|
|
{ActiveModeItem.openSourceData && (
|
|
|
<PopupStepTips
|
|
|
isShow={isShowStepTips}
|
|
|
isLarge={true}
|
|
|
title={"" + "准备中"}
|
|
|
confirmButtonText="开始护理"
|
|
|
data={ActiveModeItem.openSourceData}
|
|
|
close={this.closeStepTips}
|
|
|
/>
|
|
|
)}
|
|
|
|
|
|
<View>
|
|
|
<View className="iot-main">
|
|
|
<View className="banner-box">
|
|
|
<View className="music-btn" onClick={this.changeMusicStatus}>
|
|
|
{isMusicPlay ? (
|
|
|
<Image
|
|
|
className="music-btn_icon"
|
|
|
src={require("../../img/iot/volume_icon.png")}
|
|
|
mode="aspectFill"
|
|
|
/>
|
|
|
) : (
|
|
|
<Image
|
|
|
className="music-btn_icon"
|
|
|
src={require("../../img/iot/mute_icon.png")}
|
|
|
mode="aspectFill"
|
|
|
/>
|
|
|
)}
|
|
|
</View>
|
|
|
<View>
|
|
|
{!isShowNurse && (
|
|
|
<Video
|
|
|
className="video-or-image"
|
|
|
src={ActiveModeItem.modeVideo}
|
|
|
muted={isMusicPlay}
|
|
|
/>
|
|
|
)}
|
|
|
|
|
|
{isShowNurse && (
|
|
|
<Block>
|
|
|
{isStopNurse ? (
|
|
|
<Image
|
|
|
className="video-or-image"
|
|
|
src={
|
|
|
ActiveModeItem.serviceData[ModeStepIndex].stopSource
|
|
|
}
|
|
|
/>
|
|
|
) : (
|
|
|
<Image
|
|
|
className="video-or-image"
|
|
|
src={
|
|
|
ActiveModeItem.serviceData[ModeStepIndex].startSource
|
|
|
}
|
|
|
/>
|
|
|
)}
|
|
|
</Block>
|
|
|
)}
|
|
|
|
|
|
{errorTips && (
|
|
|
<Block>
|
|
|
<View className="msg-tips">
|
|
|
<Image
|
|
|
className="msg-tips-img"
|
|
|
src={require("../../img/tips.png")}
|
|
|
/>
|
|
|
<View className="msg-tips-content">{{ errorTips }}</View>
|
|
|
</View>
|
|
|
</Block>
|
|
|
)}
|
|
|
</View>
|
|
|
|
|
|
<View className="iot-device">
|
|
|
<View className="item border-right">
|
|
|
<Text>护理时间：10:00</Text>
|
|
|
</View>
|
|
|
<View className="item">
|
|
|
<Text>WE200电量：</Text>
|
|
|
<View className="value flex aitems">
|
|
|
{Electricity === 4 && (
|
|
|
<Block>
|
|
|
<View className="v1 battery_icon"></View>
|
|
|
<View className="v1 battery_icon"></View>
|
|
|
<View className="v1 battery_icon"></View>
|
|
|
<View className="v1 battery_icon"></View>
|
|
|
</Block>
|
|
|
)}
|
|
|
{Electricity === 3 && (
|
|
|
<Block>
|
|
|
<View className="v1 battery_icon"></View>
|
|
|
<View className="v1 battery_icon"></View>
|
|
|
<View className="v1 battery_icon"></View>
|
|
|
<View className="v2 battery_icon"></View>
|
|
|
</Block>
|
|
|
)}
|
|
|
{Electricity === 2 && (
|
|
|
<Block>
|
|
|
<View className="v1 battery_icon"></View>
|
|
|
<View className="v1 battery_icon"></View>
|
|
|
<View className="v2 battery_icon"></View>
|
|
|
<View className="v2 battery_icon"></View>
|
|
|
</Block>
|
|
|
)}
|
|
|
{Electricity === 1 && (
|
|
|
<Block>
|
|
|
<View className="v1 battery_icon"></View>
|
|
|
<View className="v2 battery_icon"></View>
|
|
|
<View className="v2 battery_icon"></View>
|
|
|
<View className="v2 battery_icon"></View>
|
|
|
</Block>
|
|
|
)}
|
|
|
{Electricity === 1 && (
|
|
|
<Block>
|
|
|
<View className="v3 battery_icon"></View>
|
|
|
<View className="v2 battery_icon"></View>
|
|
|
<View className="v2 battery_icon"></View>
|
|
|
<View className="v2 battery_icon"></View>
|
|
|
</Block>
|
|
|
)}
|
|
|
</View>
|
|
|
</View>
|
|
|
</View>
|
|
|
</View>
|
|
|
|
|
|
{ModeList.length > 0 && (
|
|
|
<ModeListView
|
|
|
ModeList={ModeList}
|
|
|
ModeType={ModeType}
|
|
|
isShowNurse={isShowNurse}
|
|
|
ActiveModeItem={ActiveModeItem}
|
|
|
onEmit={this.modeCurrentFun}
|
|
|
/>
|
|
|
)}
|
|
|
|
|
|
<ModeContent
|
|
|
isShowNurse={isShowNurse}
|
|
|
ActiveModeItem={ActiveModeItem}
|
|
|
/>
|
|
|
</View>
|
|
|
|
|
|
<Footer
|
|
|
isConnectionBlutoot={isConnectionBlutoot}
|
|
|
isShowNurse={isShowNurse}
|
|
|
isStopNurse={isStopNurse}
|
|
|
onEmitStartNurse={this.onStartNurse}
|
|
|
onEmitSwitchChange={this.onSwitchChange}
|
|
|
onEmitEndPlan={this.onEndPlan}
|
|
|
/>
|
|
|
</View>
|
|
|
</Block>
|
|
|
);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const mapStateToProps = (state) => ({
|
|
|
bluetoothInfo: state.deviceInfo.bluetoothInfo,
|
|
|
});
|
|
|
const mapDispatchToProps = (dispatch) => ({
|
|
|
// userRefresh(data) {
|
|
|
// dispatch(userRefresh(data));
|
|
|
// },
|
|
|
});
|
|
|
export default connect(mapStateToProps, mapDispatchToProps)(IotCarePlan);
|