/*
|
Copyright (C) 2024 enoint
|
|
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 <http://www.gnu.org/licenses/>.
|
*/
|
|
package nodomain.freeyourgadget.gadgetbridge.devices.hama.fit6900;
|
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Calendar;
|
import java.util.HashMap;
|
import java.util.Map;
|
|
import nodomain.freeyourgadget.gadgetbridge.model.Alarm;
|
import nodomain.freeyourgadget.gadgetbridge.util.StringUtils;
|
|
public final class Message {
|
private static byte encodeBoolean(boolean value) {
|
return (byte) ((value) ? 1 : 0);
|
}
|
|
private static void encodeInt16(byte[] data, int offset, int value) {
|
data[offset + 0] = (byte) (value & 0xFF);
|
data[offset + 1] = (byte) ((value >> 8) & 0xFF);
|
}
|
|
private static void encodeInt32(byte[] data, int offset, int value) {
|
data[offset + 0] = (byte) (value & 0xFF);
|
data[offset + 1] = (byte) ((value >> 8) & 0xFF);
|
data[offset + 2] = (byte) ((value >> 16) & 0xFF);
|
data[offset + 3] = (byte) ((value >> 24) & 0xFF);
|
}
|
|
private static void encodeInt32Goal(byte[] data, int offset, int value) {
|
encodeInt32(data, offset, value);
|
data[offset + 3] = 0;
|
}
|
|
private static byte encodeTimeFormat(TimeFormat tf) {
|
return (byte) ((tf == TimeFormat.Format12H) ? 1 : 0);
|
}
|
|
public static int decodeInt32(byte[] data, int offset) {
|
return ((data[offset] & 0xFF) << 24) | ((data[offset + 1] & 0xFF) << 16) | ((data[offset + 2] & 0xFF) << 8) | (data[offset + 3] & 0xFF);
|
}
|
|
private static byte[] byteArrayAdd(byte[] b1, byte[] b2) {
|
if (b2 == null || b2.length == 0)
|
return b1;
|
|
byte[] result = new byte[b1.length + b2.length];
|
System.arraycopy(b1, 0, result, 0, b1.length);
|
System.arraycopy(b2, 0, result, b1.length, b2.length);
|
|
return result;
|
}
|
|
public static int calculateCrc(byte[] data) {
|
int crc = 0xFF;
|
for (byte b : data) {
|
crc ^= b & 0xFF;
|
for (int k = 0; k < 8; k++) {
|
if ((crc & 1) != 0) {
|
crc = (crc >> 1) ^ 184;
|
} else {
|
crc = (crc >> 1);
|
}
|
}
|
}
|
return crc;
|
}
|
|
private static final byte HEADER_MAGIC_NUMBER = (byte) 186;
|
private static final byte PROTOCOL_VERSION_0 = (byte) 0;
|
|
private static byte[] encodeMessage(byte[] commandData) {
|
// msgType | 1: single message or end of multi-part message, 3: one part of a multi-part message
|
byte msgType = 1;
|
byte unknown1 = 0; // 1 bit
|
byte unknown2 = 0; // 4 bits
|
int length = commandData.length;
|
int crc = calculateCrc(commandData);
|
int msgCounter = 0; // returned with the response
|
|
byte[] header = new byte[8];
|
header[0] = HEADER_MAGIC_NUMBER;
|
header[1] = (byte) ((msgType << 5) | (unknown1 << 4) | unknown2);
|
header[2] = (byte) ((length >> 8) & 0xFF);
|
header[3] = (byte) (length & 0xFF);
|
header[4] = (byte) ((crc >> 8) & 0xFF);
|
header[5] = (byte) (crc & 0xFF);
|
header[6] = (byte) ((msgCounter >> 8) & 0xFF);
|
header[7] = (byte) (msgCounter & 0xFF);
|
|
return byteArrayAdd(header, commandData);
|
}
|
|
|
private static byte[] encodeCommand(byte cmd, byte cmdKey, byte[] argsData) {
|
int length = (argsData != null) ? argsData.length : 0;
|
|
byte[] header = new byte[5];
|
header[0] = cmd;
|
header[1] = PROTOCOL_VERSION_0;
|
header[2] = cmdKey;
|
header[3] = (byte) ((length >> 8) & 1);
|
header[4] = (byte) (length & 0xFF);
|
|
return byteArrayAdd(header, argsData);
|
}
|
|
public static byte[] encodeCommandMessage(int cmd, int cmdKey, byte[] cmdArgsData) {
|
assert (cmd > 0);
|
assert (cmd <= 0xFF);
|
assert (cmdKey > 0);
|
assert (cmdKey <= 0xFF);
|
return encodeMessage(encodeCommand((byte) cmd, (byte) cmdKey, cmdArgsData));
|
}
|
|
public static class CommandMessage { // decoded message
|
public byte msgType;
|
|
public int cmd;
|
public int key;
|
public byte[] cmdArgs;
|
}
|
|
|
public static CommandMessage decodeCommandMessage(byte[] data) {
|
final int MESSAGE_HEADER_SIZE = 8;
|
final int COMMAND_HEADER_SIZE = 5;
|
|
if (data[0] != HEADER_MAGIC_NUMBER) {
|
return null;
|
}
|
|
byte messageType = (byte) (data[1] >> 5);
|
int messageLength = ((data[2] & 0xFF) << 8) | (data[3] & 0xFF);
|
int crcReceived = ((data[4] & 0xFF) << 8) | (data[5] & 0xFF);
|
//int msgCounter = ((data[6] & 0xFF) << 8) | (data[7] & 0xFF);
|
|
if (data.length != MESSAGE_HEADER_SIZE + messageLength) {
|
return null;
|
}
|
|
{
|
byte[] commandData = new byte[messageLength];
|
System.arraycopy(data, MESSAGE_HEADER_SIZE, commandData, 0, messageLength);
|
|
int crc = calculateCrc(commandData);
|
if (crc != crcReceived) {
|
return null;
|
}
|
}
|
|
int cmd = data[MESSAGE_HEADER_SIZE + 0] & 0xFF;
|
int version = data[MESSAGE_HEADER_SIZE + 1] & 0xFF;
|
int key = data[MESSAGE_HEADER_SIZE + 2] & 0xFF;
|
int commandLength = ((data[MESSAGE_HEADER_SIZE + 3] & 1) << 8) | (data[MESSAGE_HEADER_SIZE + 4] & 0xFF);
|
|
if (version != PROTOCOL_VERSION_0) {
|
return null;
|
}
|
|
if (data.length != MESSAGE_HEADER_SIZE + COMMAND_HEADER_SIZE + commandLength) {
|
return null;
|
}
|
|
byte[] commandArgs = new byte[commandLength];
|
System.arraycopy(data, MESSAGE_HEADER_SIZE + COMMAND_HEADER_SIZE, commandArgs, 0, commandLength);
|
|
CommandMessage result = new CommandMessage();
|
result.msgType = messageType;
|
result.cmd = cmd;
|
result.key = key;
|
result.cmdArgs = commandArgs;
|
|
return result;
|
}
|
|
public static byte[] encodeGetFirmwareVersion() {
|
return encodeCommandMessage(1, 18, null);
|
}
|
|
public static byte[] encodeGetBatteryStatus() {
|
return encodeCommandMessage(4, 64, null);
|
}
|
|
private static void encodeDateTime(byte[] data, int dataOffset, int year, int month, int day, int hour, int minute, int second) {
|
data[dataOffset + 0] = (byte) ((year % 100) & 0xFF);
|
data[dataOffset + 1] = (byte) (month & 0xFF);
|
data[dataOffset + 2] = (byte) (day & 0xFF);
|
data[dataOffset + 3] = (byte) (hour & 0xFF);
|
data[dataOffset + 4] = (byte) (minute & 0xFF);
|
data[dataOffset + 5] = (byte) (second & 0xFF);
|
}
|
|
public enum TimeFormat {
|
Format12H,
|
Format24H
|
}
|
|
public static byte[] encodeSetDateTime(Calendar dt, TimeFormat timeFormat) {
|
byte[] args = new byte[7];
|
encodeDateTime(args, 0, dt.get(Calendar.YEAR), dt.get(Calendar.MONTH) + 1,
|
dt.get(Calendar.DAY_OF_MONTH), dt.get(Calendar.HOUR_OF_DAY), dt.get(Calendar.MINUTE), dt.get(Calendar.SECOND));
|
// time format value is optional. shorter message is also accepted
|
args[6] = encodeTimeFormat(timeFormat);
|
return encodeCommandMessage(2, 32, args);
|
}
|
|
public enum Gender {
|
FEMALE,
|
MALE
|
}
|
|
public static byte[] encodeSetUserInfo(Gender gender, int age, int heightCm, int weightKg, int stepsGoal) {
|
byte[] args = new byte[8];
|
args[0] = (byte) ((gender == Gender.MALE) ? 1 : 0);
|
args[1] = (byte) (age & 0xFF);
|
args[2] = (byte) (heightCm & 0xFF);
|
args[3] = (byte) (weightKg & 0xFF);
|
encodeInt32Goal(args, 4, stepsGoal);
|
|
return encodeCommandMessage(2, 35, args);
|
}
|
|
public static byte[] encodeFindDevice() {
|
return encodeCommandMessage(5, 80, null);
|
}
|
|
public enum NotificationType {
|
INCOMING_CALL(0), // shows popup with hang up button
|
|
SMS(1),
|
MQQ(2),
|
WEIXIN(3),
|
FACEBOOK(4),
|
TWITTER(6),
|
WHATSAPP(7),
|
INSTAGRAM(8),
|
LINKEDIN(9),
|
|
CALL_REJECT(15), // closes INCOMING_CALL notification
|
CALL_ACCEPT(16), // closes INCOMING call notification
|
|
UNKNOWN(255);
|
|
private final byte value;
|
|
NotificationType(final int value) {
|
this.value = (byte) value;
|
}
|
|
public byte getValue() {
|
return this.value;
|
}
|
}
|
|
public static byte[] encodeShowNotification(NotificationType type, String text) {
|
final int TEXT_LENGTH_MAX = 64;
|
|
text = text.trim();
|
if (text.length() > TEXT_LENGTH_MAX) {
|
text = StringUtils.truncate(text, TEXT_LENGTH_MAX);
|
text = text.trim(); // trim again so text is centered on screen
|
}
|
|
byte[] args = byteArrayAdd(new byte[]{type.getValue()}, text.getBytes(StandardCharsets.UTF_16LE));
|
return encodeCommandMessage(6, 96, args);
|
}
|
|
public static byte[] encodeSetAlarms(ArrayList<? extends Alarm> alarms) {
|
final int ENTRY_COUNT = 5;
|
final int ENTRY_SIZE = 5;
|
|
byte[] args = new byte[ENTRY_COUNT * ENTRY_SIZE];
|
Arrays.fill(args, (byte) 0);
|
|
int offset = 0;
|
for (Alarm alarm : alarms) {
|
// When all properties of an alarm are 0, it will not be listed in the watch UI.
|
// Disabled alarms with non-0 properties will be shown in disabled state.
|
// Show only enabled:
|
if (alarm.getEnabled() && !alarm.getUnused()) {
|
args[offset + 0] = (byte) alarm.getHour();
|
args[offset + 1] = (byte) alarm.getMinute();
|
args[offset + 2] = (byte) alarm.getRepetition();
|
args[offset + 3] = (byte) 1;
|
args[offset + 4] = encodeBoolean(alarm.getEnabled());
|
|
offset += ENTRY_SIZE;
|
}
|
}
|
|
return encodeCommandMessage(2, 33, args);
|
}
|
|
private static final Map<String, Integer> LANGUAGES = new HashMap<String, Integer>() {{
|
put("en", 1);
|
put("es", 3);
|
put("de", 4);
|
put("it", 5);
|
put("fr", 6);
|
put("sv", 18);
|
|
put("ru", 2);
|
put("pt", 7);
|
put("pl", 8);
|
put("nl", 9);
|
put("el", 10);
|
put("tr", 11);
|
put("ro", 12);
|
put("ja", 13);
|
put("he", 15);
|
put("da", 16);
|
put("sr", 17);
|
put("cs", 19);
|
put("sk", 20);
|
put("hu", 21);
|
put("ar", 22);
|
put("bg", 23);
|
put("th", 24);
|
put("uk", 25);
|
put("fi", 26);
|
put("nb", 27);
|
put("ko", 28);
|
put("id", 29);
|
put("lv", 30);
|
put("lt", 31);
|
put("et", 32);
|
put("my", 33);
|
put("vi", 34);
|
put("hr", 35);
|
}};
|
|
private static int resolveLanguageId(String language_, String country_) {
|
String language = language_.toLowerCase();
|
String country = country_.toLowerCase();
|
|
if (language.equals("zh")) {
|
switch (country) {
|
case "cn":
|
return 0;
|
case "tw":
|
case "hk":
|
case "mo":
|
return 14;
|
}
|
} else if (language.equals("pt") && country.equals("br")) {
|
return 36;
|
} else {
|
Integer languageId = LANGUAGES.get(language);
|
if (languageId != null)
|
return languageId;
|
}
|
|
return LANGUAGES.get("en");
|
}
|
|
public static byte[] encodeSetSystemData(String lang, String country, TimeFormat timeFormat) {
|
byte[] args = new byte[4];
|
args[0] = (byte) resolveLanguageId(lang, country);
|
args[1] = encodeTimeFormat(timeFormat);
|
args[2] = (byte) 60; // screen. unclear
|
args[3] = (byte) 0; // pair. 1 has no effect
|
|
return encodeCommandMessage(2, 39, args);
|
}
|
|
public static byte[] encodeSetDoNotDisturb(boolean enable, int startHour, int startMinute, int endHour, int endMinute) {
|
byte[] args = new byte[5];
|
args[0] = encodeBoolean(enable);
|
args[1] = (byte) startHour;
|
args[2] = (byte) startMinute;
|
args[3] = (byte) endHour;
|
args[4] = (byte) endMinute;
|
|
return encodeCommandMessage(6, 100, args);
|
}
|
|
public static byte[] encodeSetUnit(boolean isMetric) {
|
byte[] args = new byte[2];
|
args[0] = args[1] = (byte) ((isMetric) ? 0 : 1); // 0: metric, 1: imperial
|
return encodeCommandMessage(2, 1, args);
|
}
|
|
public static byte[] encodeSetLiftWristDisplayOn(boolean enable) {
|
byte[] args = new byte[3];
|
args[0] = (byte) 1; // hand
|
args[1] = encodeBoolean(enable); // raise
|
args[2] = encodeBoolean(enable); // wrist
|
|
return encodeCommandMessage(4, 74, args);
|
}
|
|
public static byte[] encodeSetAutoHeartRate(boolean enable, int startHour, int startMinute, int endHour, int endMinute, int intervalMinutes) {
|
byte[] args = new byte[7];
|
args[0] = encodeBoolean(enable);
|
args[1] = (byte) startHour;
|
args[2] = (byte) startMinute;
|
args[3] = (byte) endHour;
|
args[4] = (byte) endMinute;
|
encodeInt16(args, 5, intervalMinutes);
|
|
return encodeCommandMessage(9, 146, args);
|
}
|
|
public static byte[] encodeSetHydrationReminder(boolean enable, int startHour, int startMinute, int endHour, int endMinute, int intervalMinutes) {
|
byte[] args = new byte[8];
|
args[0] = encodeBoolean(enable);
|
args[1] = (byte) startHour;
|
args[2] = (byte) startMinute;
|
args[3] = (byte) endHour;
|
args[4] = (byte) endMinute;
|
args[5] = (byte) 0x7F; // repeat: bitmask for days of week, bit 0=Monday
|
encodeInt16(args, 6, intervalMinutes);
|
|
return encodeCommandMessage(2, 40, args);
|
}
|
|
public static byte[] encodeFactoryReset() {
|
return encodeCommandMessage(2, 199, null);
|
}
|
}
|
