/* Copyright (C) 2024 Damien Gaignon, Martin.JM
|
|
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.service.devices.huawei.requests;
|
|
import android.bluetooth.BluetoothGattCharacteristic;
|
import android.content.Context;
|
import android.os.Handler;
|
import android.os.Looper;
|
import android.widget.Toast;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.io.IOException;
|
import java.nio.ByteBuffer;
|
import java.util.List;
|
|
import nodomain.freeyourgadget.gadgetbridge.devices.huawei.HuaweiConstants;
|
import nodomain.freeyourgadget.gadgetbridge.devices.huawei.HuaweiCrypto;
|
import nodomain.freeyourgadget.gadgetbridge.devices.huawei.HuaweiPacket;
|
import nodomain.freeyourgadget.gadgetbridge.impl.GBDevice;
|
import nodomain.freeyourgadget.gadgetbridge.service.devices.huawei.HuaweiSupportProvider;
|
import nodomain.freeyourgadget.gadgetbridge.service.devices.miband.operations.OperationStatus;
|
import nodomain.freeyourgadget.gadgetbridge.util.GB;
|
|
// Based on nodomain.freeyourgadget.gadgetbridge.service.devices.lefun.requests.Request
|
|
/**
|
* Add capacity to :
|
* - chain requests;
|
* - use data from a past request;
|
* - call a function after last request.
|
*/
|
|
public class Request {
|
private static final Logger LOG = LoggerFactory.getLogger(Request.class);
|
|
public static class RequestCreationException extends Exception {
|
public RequestCreationException(String message) {
|
super(message);
|
}
|
|
public RequestCreationException(HuaweiPacket.CryptoException e) {
|
super(e);
|
}
|
|
public RequestCreationException(String message, Exception e) {
|
super(message, e);
|
}
|
}
|
|
public static class ResponseParseException extends Exception {
|
public ResponseParseException(String message) {
|
super(message);
|
}
|
|
public ResponseParseException(Exception e) {
|
super(e);
|
}
|
|
public ResponseParseException(String message, Exception e) {
|
super(message, e);
|
}
|
}
|
|
public static class ResponseTypeMismatchException extends ResponseParseException {
|
public ResponseTypeMismatchException(HuaweiPacket a, Class<?> b) {
|
super("Response type mismatch, packet is of type " + a.getClass() + " but expected " + b);
|
}
|
|
public ResponseTypeMismatchException(HuaweiPacket a, Class<?> b, Class<?> c) {
|
super("Response type mismatch, packet is of type " + a.getClass() + " but expected " + b + " or " + c);
|
}
|
}
|
|
public static class WorkoutParseException extends ResponseParseException {
|
public WorkoutParseException(String message) {
|
super(message);
|
}
|
}
|
|
protected OperationStatus operationStatus = OperationStatus.INITIAL;
|
protected byte serviceId;
|
protected byte commandId;
|
protected HuaweiPacket receivedPacket = null;
|
protected HuaweiSupportProvider supportProvider;
|
protected HuaweiPacket.ParamsProvider paramsProvider;
|
private nodomain.freeyourgadget.gadgetbridge.service.btbr.TransactionBuilder builderBr;
|
private nodomain.freeyourgadget.gadgetbridge.service.btle.TransactionBuilder builderLe;
|
// Be able to autostart a request after this one
|
protected Request nextRequest = null;
|
protected boolean isSelfQueue = false;
|
// Callback function to start after the request
|
protected RequestCallback finalizeReq = null;
|
// Stop chaining requests and clean support.inProgressRequests from these requests
|
protected boolean stopChain = false;
|
protected HuaweiCrypto huaweiCrypto = null;
|
protected boolean addToResponse = true;
|
|
private final Handler handler;
|
private final Runnable timeoutRunner;
|
private Integer timeout = null;
|
|
public static class RequestCallback {
|
protected HuaweiSupportProvider support = null;
|
public RequestCallback() {}
|
public RequestCallback(HuaweiSupportProvider supportProvider) {
|
support = supportProvider;
|
}
|
public void call() {}
|
public void call(Request request) {
|
call(); // To keep everything working as it was as well
|
}
|
public void handleException(ResponseParseException e) {
|
LOG.error("Callback request exception", e);
|
}
|
public void timeout(Request request) {
|
request.handleNext();
|
}
|
}
|
|
private Runnable getTimeoutRunnable() {
|
return () -> {
|
LOG.debug("Timeout on Service {} command {}", Integer.toHexString(this.serviceId & 0xff), Integer.toHexString(this.commandId & 0xff));
|
if (finalizeReq != null)
|
finalizeReq.timeout(this);
|
else
|
this.handleNext();
|
};
|
}
|
|
public Request(HuaweiSupportProvider supportProvider, nodomain.freeyourgadget.gadgetbridge.service.btbr.TransactionBuilder builder) {
|
this.supportProvider = supportProvider;
|
this.paramsProvider = supportProvider.getParamsProvider();
|
assert !supportProvider.isBLE();
|
this.builderBr = builder;
|
|
this.isSelfQueue = true;
|
|
this.handler = new Handler(Looper.getMainLooper());
|
this.timeoutRunner = getTimeoutRunnable();
|
}
|
|
public Request(HuaweiSupportProvider supportProvider, nodomain.freeyourgadget.gadgetbridge.service.btle.TransactionBuilder builder) {
|
this.supportProvider = supportProvider;
|
this.paramsProvider = supportProvider.getParamsProvider();
|
assert supportProvider.isBLE();
|
this.builderLe = builder;
|
|
this.isSelfQueue = true;
|
|
this.handler = new Handler(Looper.getMainLooper());
|
this.timeoutRunner = getTimeoutRunnable();
|
}
|
|
public Request(HuaweiSupportProvider supportProvider) {
|
this.supportProvider = supportProvider;
|
this.paramsProvider = supportProvider.getParamsProvider();
|
|
if (!supportProvider.isBLE())
|
this.builderBr = supportProvider.createBrTransactionBuilder(getName());
|
else
|
this.builderLe = supportProvider.createLeTransactionBuilder(getName());
|
|
this.isSelfQueue = true;
|
|
this.handler = new Handler(Looper.getMainLooper());
|
this.timeoutRunner = getTimeoutRunnable();
|
}
|
|
protected boolean requestSupported() {
|
return true;
|
}
|
|
public void doPerform() throws IOException {
|
if (!requestSupported()) {
|
this.handleNext();
|
return;
|
}
|
|
if (this.addToResponse) {
|
supportProvider.addInProgressRequest(this);
|
}
|
try {
|
for (byte[] request : createRequest()) {
|
int mtu = paramsProvider.getMtu();
|
if (request.length >= mtu) {
|
ByteBuffer buffer = ByteBuffer.wrap(request);
|
byte[] data;
|
while (buffer.hasRemaining()) {
|
int delta = Math.min(mtu, buffer.remaining());
|
data = new byte[delta];
|
buffer.get(data, 0, delta);
|
builderWrite(data);
|
}
|
} else {
|
builderWrite(request);
|
}
|
}
|
builderWait(paramsProvider.getInterval()); // Need to wait a little to let some requests end correctly i.e. Battery Level on reconnection to not print correctly
|
if (isSelfQueue) {
|
performConnected();
|
}
|
} catch (RequestCreationException e) {
|
// We cannot throw the RequestCreationException, so we throw an IOException
|
throw new IOException("Request could not be created", e);
|
}
|
}
|
|
protected List<byte[]> createRequest() throws RequestCreationException {
|
return null;
|
}
|
|
protected void processResponse() throws ResponseParseException {}
|
|
public void handleResponse() {
|
// Stop timeout timer
|
this.handler.removeCallbacks(this.timeoutRunner);
|
|
try {
|
this.receivedPacket.parseTlv();
|
} catch (HuaweiPacket.ParseException e) {
|
LOG.error("Parse TLV exception", e);
|
if (finalizeReq != null)
|
finalizeReq.handleException(new ResponseParseException("Parse TLV exception", e));
|
return;
|
}
|
try {
|
processResponse();
|
} catch (ResponseParseException e) {
|
if (finalizeReq != null)
|
finalizeReq.handleException(e);
|
return;
|
}
|
handleNext();
|
}
|
|
public void handleNext() {
|
if (nextRequest != null && !stopChain) {
|
try {
|
nextRequest.doPerform();
|
} catch (IOException e) {
|
GB.toast(supportProvider.getContext(), "nextRequest failed", Toast.LENGTH_SHORT, GB.ERROR, e);
|
LOG.error("Next request failed", e);
|
if (finalizeReq != null)
|
finalizeReq.handleException(new ResponseParseException("Next request failed", e));
|
return;
|
}
|
}
|
if (nextRequest == null || stopChain) {
|
operationStatus = OperationStatus.FINISHED;
|
if (finalizeReq != null) {
|
finalizeReq.call(this);
|
}
|
}
|
nextRequest = null;
|
}
|
|
public void setSelfQueue() {
|
isSelfQueue = true;
|
}
|
|
public Request nextRequest(Request req) {
|
if (req != null) {
|
nextRequest = req;
|
nextRequest.setSelfQueue();
|
}
|
return this;
|
}
|
|
public void stopChain(Request req) {
|
req.stopChain();
|
Request next = req.nextRequest;
|
if (next != null) {
|
next.stopChain(next);
|
supportProvider.removeInProgressRequests(next);
|
}
|
}
|
|
public void stopChain() {
|
stopChain = true;
|
}
|
|
/**
|
* Handler for responses from the device
|
* @param response The response packet
|
* @return True if this request handles this response, false otherwise
|
*/
|
public boolean handleResponse(HuaweiPacket response) {
|
if (response.serviceId == serviceId && response.commandId == commandId) {
|
receivedPacket = response;
|
return true;
|
}
|
return false;
|
}
|
|
protected Context getContext() {
|
return supportProvider.getContext();
|
}
|
|
protected GBDevice getDevice() {
|
return supportProvider.getDevice();
|
}
|
|
public String getName() {
|
Class<?> thisClass = getClass();
|
while (thisClass.isAnonymousClass()) thisClass = thisClass.getSuperclass();
|
return thisClass.getSimpleName();
|
}
|
|
public void setFinalizeReq(RequestCallback finalizeReq) {
|
this.finalizeReq = finalizeReq;
|
}
|
|
private void builderWrite(byte[] data) {
|
if (!this.supportProvider.isBLE()) {
|
this.builderBr.write(data);
|
} else {
|
BluetoothGattCharacteristic characteristic = supportProvider
|
.getLeCharacteristic(HuaweiConstants.UUID_CHARACTERISTIC_HUAWEI_WRITE);
|
this.builderLe.write(characteristic, data);
|
}
|
}
|
|
private void builderWait(int millis) {
|
if (!this.supportProvider.isBLE())
|
this.builderBr.wait(millis);
|
else
|
this.builderLe.wait(millis);
|
}
|
|
private void performConnected() throws IOException {
|
LOG.debug("Perform connected");
|
|
// Start the timeout timer
|
if (this.timeout != null)
|
handler.postDelayed(this.timeoutRunner, this.timeout);
|
|
if (!this.supportProvider.isBLE()) {
|
nodomain.freeyourgadget.gadgetbridge.service.btbr.Transaction transaction = this.builderBr.getTransaction();
|
this.supportProvider.performConnected(transaction);
|
} else {
|
nodomain.freeyourgadget.gadgetbridge.service.btle.Transaction transaction = this.builderLe.getTransaction();
|
this.supportProvider.performConnected(transaction);
|
}
|
}
|
|
public boolean autoRemoveFromResponseHandler() {
|
return true;
|
}
|
|
public void setupTimeoutUntilNext(int timeout) {
|
this.timeout = timeout;
|
}
|
|
@Override
|
protected void finalize() throws Throwable {
|
// Stop timeout timer
|
this.handler.removeCallbacks(this.timeoutRunner);
|
|
super.finalize();
|
}
|
}
|
