package com.jsbogang.womp.health;
|
|
import android.content.Context;
|
import android.os.Handler;
|
import android.os.Looper;
|
import android.util.Log;
|
|
import com.jsbogang.womp.ble.AlarmPrefs;
|
import com.jsbogang.womp.ble.DevicePrefs;
|
import com.jsbogang.womp.ble.VeepooBleManager;
|
import com.veepoo.protocol.VPOperateManager;
|
import com.veepoo.protocol.listener.base.IBleWriteResponse;
|
import com.veepoo.protocol.listener.data.AbsBloodGlucoseChangeListener;
|
import com.veepoo.protocol.listener.data.IBPDetectDataListener;
|
import com.veepoo.protocol.listener.data.IHeartDataListener;
|
import com.veepoo.protocol.listener.data.ISpo2hDataListener;
|
import com.veepoo.protocol.model.datas.BpData;
|
import com.veepoo.protocol.model.datas.HeartData;
|
import com.veepoo.protocol.model.datas.Spo2hData;
|
import com.veepoo.protocol.model.enums.EBPDetectModel;
|
import com.veepoo.protocol.model.enums.EBPDetectStatus;
|
import com.veepoo.protocol.model.enums.EBloodGlucoseRiskLevel;
|
import com.veepoo.protocol.model.enums.EBloodGlucoseStatus;
|
import com.veepoo.protocol.model.enums.EHeartStatus;
|
|
/**
|
* 每 30 分钟主动触发心率/血压/血氧/血糖测量。手表端用户自行测量时设备会 busy，此时跳过本轮。
|
*/
|
public final class ActiveMeasureRunner {
|
private static final String TAG = "ActiveMeasure";
|
private static final ActiveMeasureRunner INSTANCE = new ActiveMeasureRunner();
|
private static final IBleWriteResponse WR = code -> {};
|
|
private Context app;
|
private final Handler handler = new Handler(Looper.getMainLooper());
|
private volatile boolean measuring;
|
private int lastHr;
|
private int lastBpHigh;
|
private int lastBpLow;
|
private float lastSpo2;
|
private float lastGlucose;
|
private Runnable timeoutTask;
|
|
private ActiveMeasureRunner() {}
|
|
public static ActiveMeasureRunner get() {
|
return INSTANCE;
|
}
|
|
public void attach(Context context) {
|
app = context.getApplicationContext();
|
}
|
|
public boolean isMeasuring() {
|
return measuring;
|
}
|
|
public void startCycle() {
|
if (app == null || measuring || !VeepooBleManager.get().isReady()) {
|
return;
|
}
|
if (HealthSyncer.get().isSyncing()) {
|
handler.postDelayed(this::startCycle, 15_000);
|
return;
|
}
|
measuring = true;
|
lastHr = 0;
|
lastBpHigh = 0;
|
lastBpLow = 0;
|
lastSpo2 = 0;
|
lastGlucose = 0;
|
startHeart();
|
}
|
|
private void startHeart() {
|
HealthSyncer.get().notifyUi("正在测量心率…");
|
try {
|
VPOperateManager.getInstance().startDetectHeart(WR, new IHeartDataListener() {
|
@Override
|
public void onDataChange(HeartData heart) {
|
if (heart == null) {
|
return;
|
}
|
if (heart.getHeartStatus() == EHeartStatus.STATE_HEART_BUSY) {
|
abortBusy();
|
return;
|
}
|
int v = heart.getData();
|
if (v >= 30 && v <= 220) {
|
lastHr = v;
|
}
|
}
|
});
|
} catch (Exception e) {
|
Log.w(TAG, "start heart fail", e);
|
handler.postDelayed(this::startBp, 800);
|
return;
|
}
|
armTimeout(() -> {
|
stopHeart();
|
if (lastHr > 0) {
|
saveMetric(lastHr, 0, 0, 0, 0);
|
}
|
startBp();
|
}, 25_000);
|
}
|
|
private void stopHeart() {
|
try {
|
VPOperateManager.getInstance().stopDetectHeart(WR);
|
} catch (Exception ignored) {
|
}
|
}
|
|
private void startBp() {
|
if (!stillOn()) {
|
return;
|
}
|
HealthSyncer.get().notifyUi("正在测量血压…");
|
try {
|
VPOperateManager.getInstance().startDetectBP(WR, new IBPDetectDataListener() {
|
@Override
|
public void onDataChange(BpData bpData) {
|
if (bpData == null) {
|
return;
|
}
|
if (bpData.getStatus() == EBPDetectStatus.STATE_BP_BUSY) {
|
abortBusy();
|
return;
|
}
|
if (bpData.getHighPressure() > 0 && bpData.getLowPressure() > 0) {
|
lastBpHigh = bpData.getHighPressure();
|
lastBpLow = bpData.getLowPressure();
|
}
|
if (bpData.getProgress() >= 100 && lastBpHigh > 0) {
|
finishBp();
|
}
|
}
|
}, EBPDetectModel.DETECT_MODEL_PUBLIC);
|
} catch (Exception e) {
|
Log.w(TAG, "start bp fail", e);
|
handler.postDelayed(this::startSpo2, 800);
|
return;
|
}
|
armTimeout(this::finishBp, 55_000);
|
}
|
|
private void finishBp() {
|
clearTimeout();
|
try {
|
VPOperateManager.getInstance().stopDetectBP(WR, EBPDetectModel.DETECT_MODEL_PUBLIC);
|
} catch (Exception ignored) {
|
}
|
if (lastBpHigh > 0) {
|
saveMetric(0, lastBpHigh, lastBpLow, 0, 0);
|
}
|
handler.postDelayed(this::startSpo2, 1200);
|
}
|
|
private void startSpo2() {
|
if (!stillOn()) {
|
return;
|
}
|
HealthSyncer.get().notifyUi("正在测量血氧…");
|
try {
|
VPOperateManager.getInstance().startDetectSPO2H(WR, new ISpo2hDataListener() {
|
@Override
|
public void onSpO2HADataChange(Spo2hData data) {
|
if (data == null) {
|
return;
|
}
|
int v = data.getValue();
|
if (v >= 70 && v <= 100) {
|
lastSpo2 = v;
|
}
|
if (data.getCheckingProgress() >= 100 && lastSpo2 > 0) {
|
finishSpo2();
|
}
|
}
|
});
|
} catch (Exception e) {
|
Log.w(TAG, "start spo2 fail", e);
|
handler.postDelayed(this::startGlucose, 800);
|
return;
|
}
|
armTimeout(this::finishSpo2, 50_000);
|
}
|
|
private void finishSpo2() {
|
clearTimeout();
|
try {
|
VPOperateManager.getInstance().stopDetectSPO2H(WR, data -> {});
|
} catch (Exception ignored) {
|
}
|
if (lastSpo2 > 0) {
|
saveMetric(0, 0, 0, lastSpo2, 0);
|
}
|
handler.postDelayed(this::startGlucose, 1200);
|
}
|
|
private void startGlucose() {
|
if (!stillOn()) {
|
return;
|
}
|
HealthSyncer.get().notifyUi("正在测量血糖…");
|
try {
|
VPOperateManager.getInstance().startBloodGlucoseDetect(WR, new AbsBloodGlucoseChangeListener() {
|
@Override
|
public void onDetectError(int opt, EBloodGlucoseStatus status) {
|
finishGlucose();
|
}
|
|
@Override
|
public void onBloodGlucoseDetect(int progress, float bloodGlucose, EBloodGlucoseRiskLevel level) {
|
if (bloodGlucose > 0) {
|
lastGlucose = bloodGlucose;
|
}
|
if (progress >= 100) {
|
finishGlucose();
|
}
|
}
|
|
@Override
|
public void onBloodGlucoseStopDetect() {
|
finishGlucose();
|
}
|
});
|
} catch (Exception e) {
|
Log.w(TAG, "start glucose fail", e);
|
done();
|
return;
|
}
|
armTimeout(this::finishGlucose, 45_000);
|
}
|
|
private void finishGlucose() {
|
clearTimeout();
|
try {
|
VPOperateManager.getInstance().stopBloodGlucoseDetect(WR, new AbsBloodGlucoseChangeListener() {});
|
} catch (Exception ignored) {
|
}
|
if (lastGlucose > 0) {
|
saveMetric(0, 0, 0, 0, lastGlucose);
|
}
|
done();
|
}
|
|
private void abortBusy() {
|
clearTimeout();
|
stopHeart();
|
try {
|
VPOperateManager.getInstance().stopDetectBP(WR, EBPDetectModel.DETECT_MODEL_PUBLIC);
|
} catch (Exception ignored) {
|
}
|
try {
|
VPOperateManager.getInstance().stopDetectSPO2H(WR, data -> {});
|
} catch (Exception ignored) {
|
}
|
measuring = false;
|
HealthSyncer.get().syncSleep();
|
HealthSyncer.get().notifyUi("手表正忙，本次测量已跳过");
|
}
|
|
private void done() {
|
clearTimeout();
|
measuring = false;
|
HealthUploader.get().flush();
|
HealthSyncer.get().syncSleep();
|
HealthSyncer.get().notifyUi("测量完成");
|
}
|
|
private boolean stillOn() {
|
if (!measuring) {
|
return false;
|
}
|
if (!VeepooBleManager.get().isReady()) {
|
measuring = false;
|
return false;
|
}
|
return true;
|
}
|
|
private void armTimeout(Runnable r, long ms) {
|
clearTimeout();
|
timeoutTask = r;
|
handler.postDelayed(timeoutTask, ms);
|
}
|
|
private void clearTimeout() {
|
if (timeoutTask != null) {
|
handler.removeCallbacks(timeoutTask);
|
timeoutTask = null;
|
}
|
}
|
|
private void saveMetric(int hr, int bpHigh, int bpLow, float spo2, float glucose) {
|
if (app == null || AppDatabase.get() == null || !DevicePrefs.isBound(app)) {
|
return;
|
}
|
HealthSample s = new HealthSample();
|
s.timestamp = System.currentTimeMillis();
|
s.deviceMac = DevicePrefs.getMac(app);
|
s.dataType = "周期";
|
s.uploaded = 0;
|
s.stepValue = 0;
|
s.heartRate = hr;
|
s.bpHigh = bpHigh;
|
s.bpLow = bpLow;
|
s.spo2 = spo2;
|
s.glucose = glucose;
|
if (AlarmPrefs.isAbnormal(app, hr, bpHigh, bpLow, spo2)) {
|
s.dataType = "异常";
|
}
|
AppDatabase.dao().upsertSample(s);
|
HealthSyncer.get().notifyUi("测量数据已更新");
|
}
|
}
|
