320 lines
12 KiB
Java
320 lines
12 KiB
Java
/* Copyright (C) 2023 José Rebelo, Yoran Vulker
|
|
|
|
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.service.devices.xiaomi;
|
|
|
|
import static nodomain.freeyourgadget.gadgetbridge.service.devices.xiaomi.XiaomiSppPacket.CHANNEL_FITNESS;
|
|
import static nodomain.freeyourgadget.gadgetbridge.service.devices.xiaomi.XiaomiSppPacket.CHANNEL_MASS;
|
|
import static nodomain.freeyourgadget.gadgetbridge.service.devices.xiaomi.XiaomiSppPacket.CHANNEL_PROTO_RX;
|
|
import static nodomain.freeyourgadget.gadgetbridge.service.devices.xiaomi.XiaomiSppPacket.DATA_TYPE_ENCRYPTED;
|
|
import static nodomain.freeyourgadget.gadgetbridge.service.devices.xiaomi.XiaomiSppPacket.PACKET_PREAMBLE;
|
|
|
|
import android.bluetooth.BluetoothAdapter;
|
|
import android.bluetooth.BluetoothSocket;
|
|
import android.content.Context;
|
|
|
|
import androidx.annotation.Nullable;
|
|
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.ByteOrder;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.UUID;
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
|
|
import nodomain.freeyourgadget.gadgetbridge.impl.GBDevice;
|
|
import nodomain.freeyourgadget.gadgetbridge.proto.xiaomi.XiaomiProto;
|
|
import nodomain.freeyourgadget.gadgetbridge.service.btbr.AbstractBTBRDeviceSupport;
|
|
import nodomain.freeyourgadget.gadgetbridge.service.btbr.TransactionBuilder;
|
|
import nodomain.freeyourgadget.gadgetbridge.service.btbr.actions.PlainAction;
|
|
import nodomain.freeyourgadget.gadgetbridge.service.btbr.actions.SetDeviceStateAction;
|
|
import nodomain.freeyourgadget.gadgetbridge.service.btbr.actions.SetProgressAction;
|
|
|
|
public class XiaomiSppSupport extends XiaomiConnectionSupport {
|
|
private static final Logger LOG = LoggerFactory.getLogger(XiaomiSppSupport.class);
|
|
|
|
AbstractBTBRDeviceSupport commsSupport = new AbstractBTBRDeviceSupport(LOG) {
|
|
@Override
|
|
public boolean useAutoConnect() {
|
|
return mXiaomiSupport.useAutoConnect();
|
|
}
|
|
|
|
@Override
|
|
public void onSocketRead(byte[] data) {
|
|
XiaomiSppSupport.this.onSocketRead(data);
|
|
}
|
|
|
|
@Override
|
|
public boolean getAutoReconnect() {
|
|
return mXiaomiSupport.getAutoReconnect();
|
|
}
|
|
|
|
@Override
|
|
protected TransactionBuilder initializeDevice(TransactionBuilder builder) {
|
|
// FIXME unsetDynamicState unsets the fw version, which causes problems..
|
|
if (getDevice().getFirmwareVersion() == null) {
|
|
getDevice().setFirmwareVersion(mXiaomiSupport.getCachedFirmwareVersion() != null ?
|
|
mXiaomiSupport.getCachedFirmwareVersion() :
|
|
"N/A");
|
|
}
|
|
|
|
builder.add(new SetDeviceStateAction(getDevice(), GBDevice.State.INITIALIZING, getContext()));
|
|
builder.add(new SetDeviceStateAction(getDevice(), GBDevice.State.AUTHENTICATING, getContext()));
|
|
builder.add(new PlainAction() {
|
|
@Override
|
|
public boolean run(BluetoothSocket socket) {
|
|
mXiaomiSupport.getAuthService().startEncryptedHandshake();
|
|
return true;
|
|
}
|
|
});
|
|
|
|
return builder;
|
|
}
|
|
|
|
@Override
|
|
protected UUID getSupportedService() {
|
|
return XiaomiUuids.UUID_SERVICE_SERIAL_PORT_PROFILE;
|
|
}
|
|
};
|
|
|
|
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
|
|
private final AtomicInteger frameCounter = new AtomicInteger(0);
|
|
private final AtomicInteger encryptionCounter = new AtomicInteger(0);
|
|
private final XiaomiSupport mXiaomiSupport;
|
|
private final Map<Integer, XiaomiChannelHandler> mChannelHandlers = new HashMap<>();
|
|
|
|
public XiaomiSppSupport(final XiaomiSupport xiaomiSupport) {
|
|
this.mXiaomiSupport = xiaomiSupport;
|
|
|
|
mChannelHandlers.put(CHANNEL_PROTO_RX, this.mXiaomiSupport::handleCommandBytes);
|
|
mChannelHandlers.put(CHANNEL_FITNESS, this.mXiaomiSupport.getHealthService().getActivityFetcher()::addChunk);
|
|
}
|
|
|
|
@Override
|
|
public boolean connect() {
|
|
return commsSupport.connect();
|
|
}
|
|
|
|
@Override
|
|
public void onAuthSuccess() {
|
|
// Do nothing.
|
|
}
|
|
|
|
@Override
|
|
public void onUploadProgress(final int textRsrc, final int progressPercent, final boolean ongoing) {
|
|
try {
|
|
final TransactionBuilder builder = commsSupport.createTransactionBuilder("send data upload progress");
|
|
builder.add(new SetProgressAction(
|
|
commsSupport.getContext().getString(textRsrc),
|
|
ongoing,
|
|
progressPercent,
|
|
commsSupport.getContext()
|
|
));
|
|
builder.queue(commsSupport.getQueue());
|
|
} catch (final Exception e) {
|
|
LOG.error("Failed to update progress notification", e);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void runOnQueue(String taskName, Runnable runnable) {
|
|
if (commsSupport == null) {
|
|
LOG.error("commsSupport is null, unable to queue task");
|
|
return;
|
|
}
|
|
|
|
final TransactionBuilder b = commsSupport.createTransactionBuilder("run task " + taskName + " on queue");
|
|
b.add(new PlainAction() {
|
|
@Override
|
|
public boolean run(BluetoothSocket socket) {
|
|
runnable.run();
|
|
return true;
|
|
}
|
|
});
|
|
b.queue(commsSupport.getQueue());
|
|
}
|
|
|
|
@Override
|
|
public void setContext(GBDevice device, BluetoothAdapter adapter, Context context) {
|
|
this.commsSupport.setContext(device, adapter, context);
|
|
}
|
|
|
|
@Override
|
|
public void disconnect() {
|
|
this.commsSupport.disconnect();
|
|
}
|
|
|
|
private int findNextPossiblePreamble(final byte[] haystack) {
|
|
for (int i = 1; i + 2 < haystack.length; i++) {
|
|
// check if first byte matches
|
|
if (haystack[i] == PACKET_PREAMBLE[0]) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
// did not find preamble
|
|
return -1;
|
|
}
|
|
|
|
private void processBuffer() {
|
|
// wait until at least an empty packet is in the buffer
|
|
while (buffer.size() >= 11) {
|
|
// start preamble compare
|
|
byte[] bufferState = buffer.toByteArray();
|
|
ByteBuffer headerBuffer = ByteBuffer.wrap(bufferState, 0, 7).order(ByteOrder.LITTLE_ENDIAN);
|
|
byte[] preamble = new byte[PACKET_PREAMBLE.length];
|
|
headerBuffer.get(preamble);
|
|
|
|
if (!Arrays.equals(PACKET_PREAMBLE, preamble)) {
|
|
int preambleOffset = findNextPossiblePreamble(bufferState);
|
|
|
|
if (preambleOffset == -1) {
|
|
LOG.debug("Buffer did not contain a valid (start of) preamble, resetting");
|
|
buffer.reset();
|
|
} else {
|
|
LOG.debug("Found possible preamble at offset {}, dumping preceeding bytes", preambleOffset);
|
|
byte[] remaining = new byte[bufferState.length - preambleOffset];
|
|
System.arraycopy(bufferState, preambleOffset, remaining, 0, remaining.length);
|
|
buffer.reset();
|
|
try {
|
|
buffer.write(remaining);
|
|
} catch (IOException ex) {
|
|
LOG.error("Failed to write bytes from found preamble offset back to buffer: ", ex);
|
|
}
|
|
}
|
|
|
|
// continue processing at beginning of new buffer
|
|
continue;
|
|
}
|
|
|
|
headerBuffer.getShort(); // skip flags and channel ID
|
|
int payloadSize = headerBuffer.getShort() & 0xffff;
|
|
int packetSize = payloadSize + 8; // payload size includes payload header
|
|
|
|
if (bufferState.length < packetSize) {
|
|
LOG.debug("Packet buffer not yet satisfied: buffer size {} < expected packet size {}", bufferState.length, packetSize);
|
|
return;
|
|
}
|
|
|
|
LOG.debug("Full packet in buffer (buffer size: {}, packet size: {})", bufferState.length, packetSize);
|
|
XiaomiSppPacket receivedPacket = XiaomiSppPacket.decode(bufferState); // remaining bytes unaffected
|
|
|
|
onPacketReceived(receivedPacket);
|
|
|
|
// extract remaining bytes from buffer
|
|
byte[] remaining = new byte[bufferState.length - packetSize];
|
|
System.arraycopy(bufferState, packetSize, remaining, 0, remaining.length);
|
|
|
|
buffer.reset();
|
|
|
|
try {
|
|
buffer.write(remaining);
|
|
} catch (IOException ex) {
|
|
LOG.error("Failed to write remaining packet bytes back to buffer: ", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void dispose() {
|
|
commsSupport.dispose();
|
|
}
|
|
|
|
public void onSocketRead(byte[] data) {
|
|
try {
|
|
buffer.write(data);
|
|
} catch (IOException ex) {
|
|
LOG.error("Exception while writing buffer: ", ex);
|
|
}
|
|
|
|
processBuffer();
|
|
}
|
|
|
|
private void onPacketReceived(final XiaomiSppPacket packet) {
|
|
if (packet == null) {
|
|
// likely failed to parse the packet
|
|
LOG.warn("Received null packet, did we fail to decode?");
|
|
return;
|
|
}
|
|
|
|
LOG.debug("Packet received: {}", packet);
|
|
// TODO send response if needsResponse is set
|
|
byte[] payload = packet.getPayload();
|
|
|
|
if (packet.getDataType() == 1) {
|
|
payload = mXiaomiSupport.getAuthService().decrypt(payload);
|
|
}
|
|
|
|
int channel = packet.getChannel();
|
|
if (mChannelHandlers.containsKey(channel)) {
|
|
XiaomiChannelHandler handler = mChannelHandlers.get(channel);
|
|
|
|
if (handler != null)
|
|
handler.handle(payload);
|
|
}
|
|
|
|
LOG.warn("Unhandled SppPacket on channel {}", packet.getChannel());
|
|
}
|
|
|
|
@Override
|
|
public void sendCommand(String taskName, XiaomiProto.Command command) {
|
|
try {
|
|
XiaomiSppPacket packet = XiaomiSppPacket.fromXiaomiCommand(command, frameCounter.getAndIncrement(), false);
|
|
LOG.debug("sending packet: {}", packet);
|
|
TransactionBuilder builder = this.commsSupport.createTransactionBuilder("send " + taskName);
|
|
builder.write(packet.encode(mXiaomiSupport.getAuthService(), encryptionCounter));
|
|
builder.queue(this.commsSupport.getQueue());
|
|
} catch (final Exception ex) {
|
|
LOG.error("Caught unexpected exception while sending command, device may not have been informed!: {}", ex, ex);
|
|
}
|
|
}
|
|
|
|
public void sendCommand(final TransactionBuilder builder, final XiaomiProto.Command command) {
|
|
XiaomiSppPacket packet = XiaomiSppPacket.fromXiaomiCommand(command, frameCounter.getAndIncrement(), false);
|
|
LOG.debug("sending packet: {}", packet);
|
|
|
|
builder.write(packet.encode(mXiaomiSupport.getAuthService(), encryptionCounter));
|
|
// do not queue here, that's the job of the caller
|
|
}
|
|
|
|
public void sendDataChunk(final String taskName, final byte[] chunk, @Nullable final XiaomiCharacteristic.SendCallback callback) {
|
|
XiaomiSppPacket packet = XiaomiSppPacket.newBuilder()
|
|
.channel(CHANNEL_MASS)
|
|
.needsResponse(false)
|
|
.flag(true)
|
|
.opCode(2)
|
|
.frameSerial(frameCounter.getAndIncrement())
|
|
.dataType(DATA_TYPE_ENCRYPTED)
|
|
.payload(chunk)
|
|
.build();
|
|
LOG.debug("sending data packet: {}", packet);
|
|
TransactionBuilder b = this.commsSupport.createTransactionBuilder("send " + taskName);
|
|
b.write(packet.encode(mXiaomiSupport.getAuthService(), encryptionCounter));
|
|
b.queue(commsSupport.getQueue());
|
|
|
|
if (callback != null) {
|
|
// callback puts a SetProgressAction onto the queue
|
|
callback.onSend();
|
|
}
|
|
}
|
|
}
|