/* Copyright (C) 2020-2024 Yukai Li
|
|
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.lefun.commands;
|
|
import java.nio.ByteBuffer;
|
import java.nio.ByteOrder;
|
|
import nodomain.freeyourgadget.gadgetbridge.devices.lefun.LefunConstants;
|
|
/**
|
* Base class for Lefun Bluetooth commands and responses
|
*/
|
public abstract class BaseCommand {
|
// Common constants
|
/**
|
* Common get operation type
|
*/
|
public static final byte OP_GET = 0;
|
/**
|
* Common set operation type
|
*/
|
public static final byte OP_SET = 1;
|
|
/**
|
* Calculates command checksum
|
*
|
* @param data the data to generate checksum from
|
* @param offset the offset in data to start calculating from
|
* @param length the number of bytes to include in calculation
|
* @return the computed checksum
|
*/
|
public static byte calculateChecksum(byte[] data, int offset, int length) {
|
int checksum = 0;
|
for (int i = offset; i < offset + length; ++i) {
|
byte b = data[i];
|
for (int j = 0; j < 8; ++j) {
|
if (((b ^ checksum) & 1) == 0) {
|
checksum >>= 1;
|
} else {
|
checksum = (checksum ^ 0x18) >> 1 | 0x80;
|
}
|
b >>= 1;
|
}
|
}
|
return (byte) checksum;
|
}
|
|
/**
|
* When implemented in a subclass, parses the response from a device
|
*
|
* @param id the command ID
|
* @param params the params buffer
|
*/
|
abstract protected void deserializeParams(byte id, ByteBuffer params);
|
|
/**
|
* When implemented in a subclass, provides the arguments to send in the command
|
*
|
* @param params the params buffer to write to
|
* @return the command ID
|
*/
|
abstract protected byte serializeParams(ByteBuffer params);
|
|
/**
|
* Deserialize a response from the device
|
*
|
* @param response the response data to deserialize
|
*/
|
public void deserialize(byte[] response) {
|
if (response.length < LefunConstants.CMD_HEADER_LENGTH || response.length < response[1])
|
throw new IllegalArgumentException("Response is too short");
|
if (calculateChecksum(response, 0, response[1] - 1) != response[response[1] - 1])
|
throw new IllegalArgumentException("Incorrect message checksum");
|
ByteBuffer buffer = ByteBuffer.wrap(response, LefunConstants.CMD_HEADER_LENGTH - 1,
|
response[1] - LefunConstants.CMD_HEADER_LENGTH);
|
buffer.order(ByteOrder.BIG_ENDIAN);
|
deserializeParams(response[2], buffer);
|
}
|
|
/**
|
* Serializes a command to send to the device
|
*
|
* @return the data to send to the device
|
*/
|
public byte[] serialize() {
|
ByteBuffer buffer = ByteBuffer.allocate(LefunConstants.CMD_MAX_LENGTH - LefunConstants.CMD_HEADER_LENGTH);
|
buffer.order(ByteOrder.BIG_ENDIAN);
|
byte id = serializeParams(buffer);
|
return makeCommand(id, buffer);
|
}
|
|
/**
|
* Builds a command given ID and parameters buffer.
|
*
|
* @param id the command ID
|
* @param params the parameters buffer
|
* @return the assembled command buffer
|
*/
|
protected byte[] makeCommand(byte id, ByteBuffer params) {
|
if (params.position() > LefunConstants.CMD_MAX_LENGTH - LefunConstants.CMD_HEADER_LENGTH)
|
throw new IllegalArgumentException("params is too long to fit");
|
|
int paramsLength = params.position();
|
byte[] request = new byte[paramsLength + LefunConstants.CMD_HEADER_LENGTH];
|
request[0] = LefunConstants.CMD_REQUEST_ID;
|
request[1] = (byte) request.length;
|
request[2] = id;
|
params.flip();
|
params.get(request, LefunConstants.CMD_HEADER_LENGTH - 1, paramsLength);
|
request[request.length - 1] = calculateChecksum(request, 0, request.length - 1);
|
return request;
|
}
|
|
/**
|
* Throws a standard parameters length exception
|
*/
|
protected void throwUnexpectedLength() {
|
throw new IllegalArgumentException("Unexpected parameters length");
|
}
|
|
/**
|
* Checks for valid command ID and throws if wrong ID provided
|
*
|
* @param id command ID from device
|
* @param expectedId expected command ID
|
*/
|
protected void validateId(byte id, byte expectedId) {
|
if (id != expectedId)
|
throw new IllegalArgumentException("Wrong command ID");
|
}
|
|
/**
|
* Checks for valid command ID and command length
|
*
|
* @param id command ID from device
|
* @param params params buffer from device
|
* @param expectedId expected command ID
|
* @param expectedLength expected params length
|
*/
|
protected void validateIdAndLength(byte id, ByteBuffer params, byte expectedId, int expectedLength) {
|
validateId(id, expectedId);
|
if (params.limit() - params.position() != expectedLength)
|
throwUnexpectedLength();
|
}
|
|
/**
|
* Gets whether a bit is set
|
*
|
* @param value the value to check against
|
* @param mask the bitmask
|
* @return whether the bits indicated by the bitmask are set
|
*/
|
protected boolean getBit(int value, int mask) {
|
return (value & mask) != 0;
|
}
|
|
/**
|
* Sets a bit in a value
|
*
|
* @param value the value to modify
|
* @param mask the bitmask
|
* @param set whether to set or clear the bits
|
* @return the modified value
|
*/
|
protected int setBit(int value, int mask, boolean set) {
|
if (set) {
|
return value | mask;
|
} else {
|
return value & ~mask;
|
}
|
}
|
|
/**
|
* Sets a bit in a value
|
*
|
* @param value the value to modify
|
* @param mask the bitmask
|
* @param set whether to set or clear the bits
|
* @return the modified value
|
*/
|
protected short setBit(short value, int mask, boolean set) {
|
if (set) {
|
return (short) (value | mask);
|
} else {
|
return (short) (value & ~mask);
|
}
|
}
|
|
/**
|
* Sets a bit in a value
|
*
|
* @param value the value to modify
|
* @param mask the bitmask
|
* @param set whether to set or clear the bits
|
* @return the modified value
|
*/
|
protected byte setBit(byte value, int mask, boolean set) {
|
if (set) {
|
return (byte) (value | mask);
|
} else {
|
return (byte) (value & ~mask);
|
}
|
}
|
|
/**
|
* Find index of first bit that is set
|
*
|
* @param value the value to look at
|
* @return the index of the lowest set bit, starting at 0 for least significant bit; -1 if no bits set
|
*/
|
protected int getLowestSetBitIndex(int value) {
|
if (value == 0) return -1;
|
|
int i = 0;
|
while ((value & 1) == 0) {
|
++i;
|
value >>= 1;
|
}
|
return i;
|
}
|
}
|
