/* Copyright (C) 2024 Damien Gaignon, Martin.JM, Vitalii Tomin
|
|
This file is part of Gadgetbridge.
|
|
Gadgetbridge is free software: you can redistribute it and/or modify
|
it under the terms of the GNU Affero General Public License as published
|
by the Free Software Foundation, either version 3 of the License, or
|
(at your option) any later version.
|
|
Gadgetbridge is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU Affero General Public License for more details.
|
|
You should have received a copy of the GNU Affero General Public License
|
along with this program. If not, see <https://www.gnu.org/licenses/>. */
|
package nodomain.freeyourgadget.gadgetbridge.devices.huawei.packets;
|
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.List;
|
|
import nodomain.freeyourgadget.gadgetbridge.devices.huawei.HeartRateZonesConfig;
|
import nodomain.freeyourgadget.gadgetbridge.devices.huawei.HuaweiPacket;
|
import nodomain.freeyourgadget.gadgetbridge.devices.huawei.HuaweiReportThreshold;
|
import nodomain.freeyourgadget.gadgetbridge.devices.huawei.HuaweiRunPaceConfig;
|
import nodomain.freeyourgadget.gadgetbridge.devices.huawei.HuaweiTLV;
|
|
public class FitnessData {
|
|
public static final byte id = 0x07;
|
|
public static class MotionGoal {
|
public static final byte id = 0x01;
|
|
public static class Request extends HuaweiPacket {
|
public Request(ParamsProvider paramsProvider,
|
byte goalType,
|
byte frameType,
|
int stepGoal,
|
int calorieGoal,
|
short durationGoal) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
frameType = (frameType == 0x01) ? 0x01 : Type.motion;
|
HuaweiTLV subTlv = new HuaweiTLV()
|
.put(0x03, goalType)
|
.put(0x04, frameType);
|
stepGoal = ((Type.data & 0x01) != 0x00) ? stepGoal : 0xffffffff;
|
if (stepGoal != 0xffffffff)
|
subTlv.put(0x05, stepGoal);
|
int calorieGoalFinal = ((Type.data & 0x02) != 0x00) ? calorieGoal : 0xffffffff;
|
if (calorieGoalFinal != 0xffffffff) {
|
subTlv.put(0x06, calorieGoalFinal);
|
} else if (frameType == 0x01) {
|
subTlv.put(0x06, stepGoal / 0x1e);
|
}
|
int distanceGoal = ((Type.data & 0x04) != 0x00) ? durationGoal : 0xffffffff;
|
if (distanceGoal != 0xffffffff) {
|
subTlv.put(0x07, distanceGoal);
|
} else if (frameType == 0x01) {
|
subTlv.put(0x06, stepGoal);
|
}
|
short durationGoalFinal = ((Type.data & 0x08) != 0x00) ? durationGoal : 0xffffffff;
|
if (durationGoalFinal != 0xffffffff) {
|
subTlv.put(0x08, durationGoalFinal);
|
}
|
HuaweiTLV containerTlv = new HuaweiTLV().put(0x82, subTlv);
|
this.tlv = new HuaweiTLV()
|
.put(0x81, containerTlv);
|
}
|
}
|
}
|
|
public static class UserInfo {
|
public static final byte id = 0x02;
|
|
public static class UserInfoData {
|
public static final int GENDER_MALE = 1;
|
public static final int GENDER_FEMALE = 2;
|
public static final int GENDER_UNKNOWN = 3;
|
|
private static final float RUN_CF = 0.83f;
|
private static final float WALK_CF = 0.42f;
|
|
public static final int DEFAULT_HEIGHT = 175;
|
public static final int DEFAULT_WEIGHT = 65;
|
|
private final int height;
|
private final float weight;
|
private final int age;
|
private final int birthday;
|
private final byte gender;
|
|
private final boolean unknownGenderSupported;
|
|
private final boolean vo2Supported;
|
private final int vo2Max;
|
private final int vo2Time;
|
|
private final boolean precisionWeightSupported;
|
|
public UserInfoData(int height, float weight, int age, int birthday, byte gender, boolean unknownGenderSupported, boolean vo2Supported, int vo2Max, int vo2Time, boolean precisionWeightSupported) {
|
this.height = height;
|
this.weight = weight;
|
this.age = age;
|
this.birthday = birthday;
|
this.gender = gender;
|
this.unknownGenderSupported = unknownGenderSupported;
|
this.vo2Supported = vo2Supported;
|
this.vo2Max = vo2Max;
|
this.vo2Time = vo2Time;
|
this.precisionWeightSupported = precisionWeightSupported;
|
}
|
|
public int getHeight() {
|
if (this.height > 0)
|
return this.height;
|
return DEFAULT_HEIGHT;
|
}
|
|
public float getWeight() {
|
if (this.weight > 0)
|
return this.weight;
|
return DEFAULT_WEIGHT;
|
}
|
|
public int getAge() {
|
return age;
|
}
|
|
public int getBirthday() {
|
return birthday;
|
}
|
|
public byte getGender() {
|
return gender;
|
}
|
|
public boolean isUnknownGenderSupported() {
|
return unknownGenderSupported;
|
}
|
|
public boolean isVo2Supported() {
|
return vo2Supported;
|
}
|
|
public int getVo2Max() {
|
return vo2Max;
|
}
|
|
public int getVo2Time() {
|
return vo2Time;
|
}
|
|
public boolean isPrecisionWeightSupported() {
|
return precisionWeightSupported;
|
}
|
|
public boolean isGenderValid() {
|
return this.gender == GENDER_MALE || this.gender == GENDER_FEMALE || this.gender == GENDER_UNKNOWN;
|
}
|
|
public boolean isBirthdayValid() {
|
return this.birthday > 0;
|
}
|
|
}
|
|
public static class Request extends HuaweiPacket {
|
public Request(ParamsProvider paramsProvider, UserInfoData info) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
int height = info.getHeight();
|
float weight = info.getWeight();
|
|
byte bmiWalk = (byte) Math.round(UserInfoData.WALK_CF * height);
|
byte bmiRun = (byte) Math.round(UserInfoData.RUN_CF * height);
|
|
this.tlv = new HuaweiTLV()
|
.put(0x01, (byte) height)
|
.put(0x02, (byte) weight)
|
.put(0x03, (byte) info.getAge());
|
if (info.isBirthdayValid())
|
this.tlv.put(0x04, info.getBirthday());
|
if (info.isGenderValid()) {
|
if (info.unknownGenderSupported || info.gender != UserInfoData.GENDER_UNKNOWN)
|
this.tlv.put(0x05, info.gender);
|
}
|
this.tlv.put(0x06, bmiWalk);
|
this.tlv.put(0x07, bmiRun);
|
|
if (info.vo2Supported) {
|
this.tlv.put(0x08, info.getVo2Max());
|
this.tlv.put(0x09, info.getVo2Time());
|
}
|
|
if (info.precisionWeightSupported) {
|
int precisionWeight = Math.round(weight * 100f);
|
this.tlv.put(0x0b, precisionWeight);
|
}
|
|
}
|
}
|
}
|
|
public static class MessageCount {
|
public static final byte sleepId = 0x0C;
|
public static final byte stepId = 0x0A;
|
|
public static class Request extends HuaweiPacket {
|
public Request(
|
ParamsProvider paramsProvider,
|
byte commandId,
|
int start,
|
int end
|
) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = commandId;
|
|
this.tlv = new HuaweiTLV()
|
.put(0x81)
|
.put(0x03, start)
|
.put(0x04, end);
|
|
this.complete = true;
|
}
|
}
|
|
public static class Response extends HuaweiPacket {
|
public short count;
|
|
public Response(ParamsProvider paramsProvider) {
|
super(paramsProvider);
|
}
|
|
@Override
|
public void parseTlv() throws ParseException {
|
this.count = this.tlv.getObject(0x81).getShort(0x02);
|
this.complete = true;
|
}
|
}
|
}
|
|
public static class MessageData {
|
public static final byte sleepId = 0x0D;
|
public static final byte stepId = 0x0B;
|
|
public static class Request extends HuaweiPacket {
|
public Request(ParamsProvider paramsProvider, byte commandId, short count) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = commandId;
|
|
this.tlv = new HuaweiTLV()
|
.put(0x81, new HuaweiTLV()
|
.put(0x02, count)
|
);
|
|
this.complete = true;
|
}
|
}
|
|
public static class SleepResponse extends HuaweiPacket {
|
public static class SubContainer {
|
public byte type;
|
public byte[] timestamp;
|
|
@Override
|
public String toString() {
|
return "SubContainer{" +
|
"type=" + type +
|
", timestamp=" + Arrays.toString(timestamp) +
|
'}';
|
}
|
}
|
|
public short number;
|
public List<SubContainer> containers;
|
|
public SleepResponse(ParamsProvider paramsProvider) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = sleepId;
|
}
|
|
@Override
|
public void parseTlv() throws ParseException {
|
HuaweiTLV container = this.tlv.getObject(0x81);
|
List<HuaweiTLV> subContainers = container.getObjects(0x83);
|
|
this.number = container.getShort(0x02);
|
this.containers = new ArrayList<>();
|
for (HuaweiTLV subContainerTlv : subContainers) {
|
SubContainer subContainer = new SubContainer();
|
subContainer.type = subContainerTlv.getByte(0x04);
|
subContainer.timestamp = subContainerTlv.getBytes(0x05);
|
this.containers.add(subContainer);
|
}
|
}
|
}
|
|
public static class StepResponse extends HuaweiPacket {
|
public static class SubContainer {
|
public static class TV {
|
public final byte bitmap;
|
public final byte tag;
|
public final short value;
|
|
public TV(byte bitmap, byte tag, short value) {
|
this.bitmap = bitmap;
|
this.tag = tag;
|
this.value = value;
|
}
|
|
@Override
|
public String toString() {
|
return "TV{" +
|
"bitmap=" + bitmap +
|
", tag=" + tag +
|
", value=" + value +
|
'}';
|
}
|
}
|
|
/*
|
* Data directly from packet
|
*/
|
public byte timestampOffset;
|
public byte[] data;
|
|
/*
|
* Inferred data
|
*/
|
public int timestamp;
|
|
public List<TV> parsedData = null;
|
public String parsedDataError = "";
|
|
public int steps = -1;
|
public int calories = -1;
|
public int distance = -1;
|
public int heartrate = -1;
|
|
public int spo = -1;
|
|
public List<TV> unknownTVs = null;
|
|
@Override
|
public String toString() {
|
return "SubContainer{" +
|
"timestampOffset=" + timestampOffset +
|
", data=" + Arrays.toString(data) +
|
", timestamp=" + timestamp +
|
", parsedData=" + parsedData +
|
", parsedDataError='" + parsedDataError + '\'' +
|
", steps=" + steps +
|
", calories=" + calories +
|
", distance=" + distance +
|
", spo=" + spo +
|
", unknownTVs=" + unknownTVs +
|
'}';
|
}
|
}
|
|
public short number;
|
public int timestamp;
|
public List<SubContainer> containers;
|
|
private static final List<Byte> singleByteTagListBitmap1 = new ArrayList<>();
|
|
static {
|
singleByteTagListBitmap1.add((byte) 0x20);
|
singleByteTagListBitmap1.add((byte) 0x40);
|
}
|
|
public StepResponse(ParamsProvider paramsProvider) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = stepId;
|
}
|
|
@Override
|
public void parseTlv() throws ParseException {
|
HuaweiTLV container = this.tlv.getObject(0x81);
|
List<HuaweiTLV> subContainers = container.getObjects(0x84);
|
|
this.number = container.getShort(0x02);
|
this.timestamp = container.getInteger(0x03);
|
this.containers = new ArrayList<>();
|
for (HuaweiTLV subContainerTlv : subContainers) {
|
SubContainer subContainer = new SubContainer();
|
subContainer.timestampOffset = subContainerTlv.getByte(0x05);
|
subContainer.timestamp = this.timestamp + 60 * subContainer.timestampOffset;
|
subContainer.data = subContainerTlv.getBytes(0x06);
|
parseData(subContainer, subContainer.data);
|
this.containers.add(subContainer);
|
}
|
}
|
|
private static void parseData(SubContainer returnValue, byte[] data) {
|
int i = 0;
|
|
if (data.length <= 0) {
|
returnValue.parsedData = null;
|
returnValue.parsedDataError = "Data is missing feature bitmap.";
|
return;
|
}
|
byte featureBitmap1 = data[i++];
|
|
byte featureBitmap2 = 0;
|
if ((featureBitmap1 & 128) != 0) {
|
if (data.length <= i) {
|
returnValue.parsedData = null;
|
returnValue.parsedDataError = "Data is missing second feature bitmap.";
|
return;
|
}
|
featureBitmap2 = data[i++];
|
}
|
|
returnValue.parsedData = new ArrayList<>();
|
returnValue.unknownTVs = new ArrayList<>();
|
|
// The greater than zero check is because Java is always signed, so we only check 7 bits
|
for (byte bitToCheck = 1; bitToCheck > 0; bitToCheck <<= 1) {
|
if ((featureBitmap1 & bitToCheck) != 0) {
|
short value;
|
|
if (singleByteTagListBitmap1.contains(bitToCheck)) {
|
if (data.length - 1 < i) {
|
returnValue.parsedData = null;
|
returnValue.parsedDataError = "Data is too short for selected features.";
|
return;
|
}
|
|
value = data[i++];
|
} else {
|
if (data.length - 2 < i) {
|
returnValue.parsedData = null;
|
returnValue.parsedDataError = "Data is too short for selected features.";
|
return;
|
}
|
|
value = (short) ((data[i++] & 0xFF) << 8 | (data[i++] & 0xFF));
|
}
|
|
// The bitToCheck is used as tag, which may not be optimal, but works
|
SubContainer.TV tv = new SubContainer.TV((byte) 1, bitToCheck, value);
|
returnValue.parsedData.add(tv);
|
|
if (bitToCheck == 0x02)
|
returnValue.steps = value;
|
else if (bitToCheck == 0x04)
|
returnValue.calories = value;
|
else if (bitToCheck == 0x08)
|
returnValue.distance = value;
|
else if (bitToCheck == 0x40)
|
returnValue.heartrate = value;
|
else
|
returnValue.unknownTVs.add(tv);
|
}
|
}
|
|
if (featureBitmap2 != 0) {
|
// We want to check 8 bits here, and java is java, so we use a short
|
for (short bitToCheck = 1; bitToCheck < 0x0100; bitToCheck <<= 1) {
|
if ((featureBitmap2 & bitToCheck) != 0) {
|
if (data.length - 1 < i) {
|
returnValue.parsedData = null;
|
returnValue.parsedDataError = "Data is too short for selected features.";
|
return;
|
}
|
|
byte value = data[i++];
|
|
SubContainer.TV tv = new SubContainer.TV((byte) 2, (byte) bitToCheck, value);
|
returnValue.parsedData.add(tv);
|
|
if (bitToCheck == 0x01)
|
returnValue.spo = value;
|
else
|
returnValue.unknownTVs.add(tv);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
public static class FitnessTotals {
|
public static final byte id = 0x03;
|
|
public static class Request extends HuaweiPacket {
|
public Request(ParamsProvider paramsProvider) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
this.tlv = new HuaweiTLV()
|
.put(0x01);
|
|
this.complete = true;
|
}
|
}
|
|
public static class Response extends HuaweiPacket {
|
|
public int totalSteps = 0;
|
public int totalCalories = 0;
|
public int totalDistance = 0;
|
|
public Response(ParamsProvider paramsProvider) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
}
|
|
@Override
|
public void parseTlv() throws ParseException {
|
HuaweiTLV container = this.tlv.getObject(0x81);
|
List<HuaweiTLV> containers = container.getObjects(0x83);
|
|
for (HuaweiTLV tlv : containers) {
|
if (tlv.contains(0x05))
|
totalSteps += tlv.getInteger(0x05);
|
if (tlv.contains(0x06))
|
totalCalories += tlv.getShort(0x06);
|
if (tlv.contains(0x07))
|
totalDistance += tlv.getInteger(0x07);
|
}
|
|
this.complete = true;
|
}
|
}
|
}
|
|
public static class ActivityReminder {
|
public static final byte id = 0x07;
|
|
public static class Request extends HuaweiPacket {
|
public Request(
|
ParamsProvider paramsProvider,
|
boolean longSitSwitch,
|
byte longSitInterval,
|
byte[] longSitStart,
|
byte[] longSitEnd,
|
byte cycle
|
) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
this.tlv = new HuaweiTLV()
|
.put(0x81, new HuaweiTLV()
|
.put(0x02, longSitSwitch)
|
.put(0x03, longSitInterval)
|
.put(0x04, longSitStart)
|
.put(0x05, longSitEnd)
|
.put(0x06, cycle)
|
);
|
|
this.complete = true;
|
}
|
}
|
}
|
|
public static class DeviceReportThreshold {
|
public static final byte id = 0xe;
|
|
public static class Request extends HuaweiPacket {
|
public Request(ParamsProvider paramsProvider, List<HuaweiReportThreshold> thresholds) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
|
HuaweiTLV subTlv = new HuaweiTLV();
|
for (HuaweiReportThreshold th : thresholds) {
|
subTlv.put(0x02, th.getBytes());
|
}
|
this.tlv = new HuaweiTLV().put(0x81, subTlv);
|
this.complete = true;
|
}
|
}
|
}
|
|
public static class HeartRateZoneConfigPacket {
|
// It can use two IDs with basically the same format.
|
public static final byte id_simple = 0x13;
|
public static final byte id_extended = 0x21;
|
|
public static class Request extends HuaweiPacket {
|
private Request(
|
ParamsProvider paramsProvider,
|
byte id,
|
HeartRateZonesConfig heartRateZonesConfig
|
) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
HuaweiTLV subTlv = new HuaweiTLV().
|
put(0x08, heartRateZonesConfig.getWarningEnable());
|
|
if (
|
heartRateZonesConfig.hasValidMHRData() &&
|
heartRateZonesConfig.getWarningHRLimit() > 0 &&
|
heartRateZonesConfig.getMaxHRThreshold() > 0
|
) {
|
subTlv
|
.put(0x09, (byte) heartRateZonesConfig.getWarningHRLimit())
|
.put(0x02, (byte) heartRateZonesConfig.getMHRWarmUp())
|
.put(0x03, (byte) heartRateZonesConfig.getMHRFatBurning())
|
.put(0x04, (byte) heartRateZonesConfig.getMHRAerobic())
|
.put(0x05, (byte) heartRateZonesConfig.getMHRAnaerobic())
|
.put(0x06, (byte) heartRateZonesConfig.getMHRExtreme())
|
.put(0x07, (byte) heartRateZonesConfig.getMaxHRThreshold())
|
.put(0x0b, (byte) heartRateZonesConfig.getMaxHRThreshold());
|
}
|
|
if (id == id_extended && heartRateZonesConfig.hasValidHRRData()) {
|
subTlv
|
.put(0x0d, (byte) heartRateZonesConfig.getHRRBasicAerobic())
|
.put(0x0e, (byte) heartRateZonesConfig.getHRRAdvancedAerobic())
|
.put(0x0f, (byte) heartRateZonesConfig.getHRRLactate())
|
.put(0x10, (byte) heartRateZonesConfig.getHRRBasicAnaerobic())
|
.put(0x11, (byte) heartRateZonesConfig.getHRRAdvancedAnaerobic());
|
}
|
|
if (id == id_extended && heartRateZonesConfig.getRestHeartRate() > 0) {
|
subTlv
|
.put(0x0a, (byte) heartRateZonesConfig.getCalculateMethod())
|
.put(0x0c, (byte) heartRateZonesConfig.getRestHeartRate());
|
}
|
|
this.tlv = new HuaweiTLV().put(0x81, subTlv);
|
|
this.complete = true;
|
}
|
|
public static Request requestSimple(ParamsProvider paramsProvider, HeartRateZonesConfig heartRateZonesConfig) {
|
return new Request(paramsProvider, id_simple, heartRateZonesConfig);
|
}
|
|
public static Request requestExtended(ParamsProvider paramsProvider, HeartRateZonesConfig heartRateZonesConfig) {
|
return new Request(paramsProvider, id_extended, heartRateZonesConfig);
|
}
|
}
|
}
|
|
public static class TruSleep {
|
public static final byte id = 0x16;
|
|
public static class Request extends HuaweiPacket {
|
public Request(ParamsProvider paramsProvider, boolean truSleepSwitch) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
this.tlv = new HuaweiTLV()
|
.put(0x01, truSleepSwitch);
|
|
this.complete = true;
|
}
|
}
|
}
|
|
public static class EnableAutomaticHeartrate {
|
public static final byte id = 0x17;
|
|
public static class Request extends HuaweiPacket {
|
public Request(ParamsProvider paramsProvider, boolean enableAutomaticHeartrate) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
this.tlv = new HuaweiTLV()
|
.put(0x01, enableAutomaticHeartrate);
|
|
this.isEncrypted = true;
|
this.complete = true;
|
}
|
}
|
}
|
|
public static class NotifyRestHeartRate {
|
public static final byte id = 0x23;
|
|
public static class Request extends HuaweiPacket {
|
public Request(ParamsProvider paramsProvider) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
this.tlv = new HuaweiTLV()
|
.put(0x01, 0x01);
|
|
this.complete = true;
|
}
|
}
|
}
|
|
public static class EnableAutomaticSpo {
|
public static final byte id = 0x24;
|
|
public static class Request extends HuaweiPacket {
|
public Request(ParamsProvider paramsProvider, boolean enableAutomaticSpo) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
this.tlv = new HuaweiTLV()
|
.put(0x01, enableAutomaticSpo);
|
|
this.isEncrypted = true;
|
this.complete = true;
|
}
|
}
|
}
|
|
public static class RunPaceConfig {
|
public static final byte id = 0x28;
|
|
public static class Request extends HuaweiPacket {
|
public Request(ParamsProvider paramsProvider, final HuaweiRunPaceConfig runPaceConfig) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
this.tlv = new HuaweiTLV()
|
.put(0x01, (short) runPaceConfig.getZone1JogMin())
|
.put(0x02, (short) runPaceConfig.getZone2MarathonMin())
|
.put(0x03, (short) runPaceConfig.getZone3LactateThresholdMin())
|
.put(0x04, (short) runPaceConfig.getZone4AnaerobicMin())
|
.put(0x05, (short) runPaceConfig.getZone5HIITRunMin())
|
.put(0x06, (short) runPaceConfig.getZone5HIITRunMax());
|
this.complete = true;
|
}
|
}
|
|
public static class Response extends HuaweiPacket {
|
|
public boolean isOk;
|
|
public Response(ParamsProvider paramsProvider) {
|
super(paramsProvider);
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
}
|
|
@Override
|
public void parseTlv() throws ParseException {
|
isOk = this.tlv.getInteger(0x7f) == 0x000186A0;
|
}
|
}
|
|
}
|
|
public static class MediumToStrengthThreshold {
|
public static final byte id = 0x29;
|
|
public static class Request extends HuaweiPacket {
|
public Request(ParamsProvider paramsProvider,
|
byte walkRun,
|
byte climb,
|
byte heartRate,
|
byte cycleSpeed,
|
byte sample,
|
byte countLength,
|
int walkRunSpeed,
|
int walkRunWithHeartRate) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
if (walkRun < 0x00 || walkRun > 0xc8) walkRun = 0x6E;
|
if (climb < 0x0 || climb > 0xc8) climb = 0x3c;
|
if (heartRate < 0x0 || heartRate > 0x64) heartRate = 0x40;
|
if (cycleSpeed < 0x0 || cycleSpeed > 0xff) cycleSpeed = 0x50;
|
if (sample < 0x1 || sample > 0xa) sample = 0x3;
|
if (countLength < 0x1 || countLength > 0xa) countLength = 0x5;
|
if (countLength < sample) countLength = sample;
|
|
this.tlv = new HuaweiTLV()
|
.put(0x01, walkRun)
|
.put(0x02, climb)
|
.put(0x03, heartRate)
|
.put(0x04, cycleSpeed)
|
.put(0x05, sample)
|
.put(0x06, countLength);
|
if (walkRunSpeed != -1) {
|
this.tlv.put(0x07, (byte) walkRunSpeed);
|
}
|
if (walkRunWithHeartRate != -1) {
|
this.tlv.put(0x08, (byte) walkRunWithHeartRate);
|
}
|
this.complete = true;
|
}
|
}
|
}
|
|
public static class SkinTemperatureMeasurement {
|
public static final byte id = 0x2a;
|
|
public static class Request extends HuaweiPacket {
|
public Request(ParamsProvider paramsProvider, boolean temperatureSwitch) {
|
super(paramsProvider);
|
|
this.serviceId = FitnessData.id;
|
this.commandId = id;
|
|
this.tlv = new HuaweiTLV()
|
.put(0x01, (byte) 0x01)
|
.put(0x02, temperatureSwitch);
|
|
this.complete = true;
|
}
|
}
|
}
|
|
public static class Type {
|
// TODO: enum?
|
|
public static final byte goal = 0x01;
|
public static final byte motion = 0x00;
|
public static final byte data = 0x01;
|
}
|
}
|
