package nodomain.freeyourgadget.gadgetbridge.service.devices.garmin.fit;
|
|
import androidx.annotation.NonNull;
|
|
import java.nio.ByteBuffer;
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Date;
|
import java.util.List;
|
|
import nodomain.freeyourgadget.gadgetbridge.service.devices.garmin.GarminByteBufferReader;
|
import nodomain.freeyourgadget.gadgetbridge.service.devices.garmin.messages.MessageWriter;
|
import nodomain.freeyourgadget.gadgetbridge.util.ArrayUtils;
|
import nodomain.freeyourgadget.gadgetbridge.util.GBToStringBuilder;
|
|
import static nodomain.freeyourgadget.gadgetbridge.service.devices.garmin.fit.baseTypes.BaseType.STRING;
|
|
import org.apache.commons.lang3.StringUtils;
|
|
public class RecordData {
|
|
private final RecordDefinition recordDefinition;
|
private final RecordHeader recordHeader;
|
private final GlobalFITMessage globalFITMessage;
|
private final List<FieldData> fieldDataList;
|
protected ByteBuffer valueHolder;
|
|
/**
|
* The computed timestamp consists of the running timestamp for this record, which may come from
|
* a timestamp field 253, or from a compressed timestamp, or simply be the same timestamp as the
|
* previously seen sample. This does not take into account sample-specific timestamps such as
|
* timestamp16.
|
*/
|
public Long computedTimestamp = null;
|
|
public RecordData(final RecordDefinition recordDefinition, final RecordHeader recordHeader) {
|
if (null == recordDefinition.getFieldDefinitions())
|
throw new IllegalArgumentException("Cannot create record data without FieldDefinitions " + recordDefinition);
|
|
fieldDataList = new ArrayList<>();
|
|
this.recordDefinition = recordDefinition;
|
this.recordHeader = recordHeader;
|
this.globalFITMessage = recordDefinition.getGlobalFITMessage();
|
|
int totalSize = 0;
|
|
for (FieldDefinition fieldDef :
|
recordDefinition.getFieldDefinitions()) {
|
fieldDataList.add(new FieldData(fieldDef, totalSize));
|
totalSize += fieldDef.getSize();
|
}
|
|
if (recordDefinition.getDevFieldDefinitions() != null) {
|
for (DevFieldDefinition fieldDef :
|
recordDefinition.getDevFieldDefinitions()) {
|
FieldDefinition temp = new FieldDefinition(fieldDef.getFieldDefinitionNumber(), fieldDef.getSize(), fieldDef.getBaseType(), fieldDef.getName());
|
fieldDataList.add(new FieldData(temp, totalSize));
|
totalSize += fieldDef.getSize();
|
}
|
}
|
|
this.valueHolder = ByteBuffer.allocate(totalSize);
|
valueHolder.order(recordDefinition.getByteOrder());
|
|
for (FieldData fieldData :
|
fieldDataList) {
|
fieldData.invalidate();
|
}
|
|
}
|
|
public GlobalFITMessage getGlobalFITMessage() {
|
return globalFITMessage;
|
}
|
|
public RecordDefinition getRecordDefinition() {
|
return recordDefinition;
|
}
|
|
public Long parseDataMessage(final GarminByteBufferReader garminByteBufferReader, final Long currentTimestamp) {
|
garminByteBufferReader.setByteOrder(valueHolder.order());
|
computedTimestamp = currentTimestamp;
|
Long referenceTimestamp = null;
|
for (FieldData fieldData : fieldDataList) {
|
Long runningTimestamp = fieldData.parseDataMessage(garminByteBufferReader);
|
if (runningTimestamp != null) {
|
computedTimestamp = runningTimestamp;
|
referenceTimestamp = runningTimestamp;
|
}
|
}
|
return referenceTimestamp;
|
}
|
|
public void generateOutgoingDataPayload(MessageWriter writer) {
|
writer.writeByte(recordHeader.generateOutgoingDataPayload());
|
writer.writeBytes(valueHolder.array());
|
}
|
|
public void setFieldByNumber(int number, Object... value) {
|
boolean found = false;
|
for (FieldData fieldData :
|
fieldDataList) {
|
if (fieldData.getNumber() == number) {
|
fieldData.encode(value);
|
found = true;
|
break;
|
}
|
}
|
if (!found) {
|
throw new IllegalArgumentException("Unknown field number " + number);
|
}
|
}
|
|
public void setFieldByName(String name, Object... value) {
|
boolean found = false;
|
for (FieldData fieldData :
|
fieldDataList) {
|
if (fieldData.getName().equals(name)) {
|
fieldData.encode(value);
|
found = true;
|
break;
|
}
|
}
|
if (!found) {
|
throw new IllegalArgumentException("Unknown field name " + name);
|
}
|
}
|
|
public Object getFieldByNumber(int number) {
|
for (FieldData fieldData :
|
fieldDataList) {
|
if (fieldData.getNumber() == number) {
|
return fieldData.decode();
|
}
|
}
|
return null;
|
}
|
|
public Object getFieldByName(String name) {
|
for (FieldData fieldData :
|
fieldDataList) {
|
if (fieldData.getName().equals(name)) {
|
return fieldData.decode();
|
}
|
}
|
return null;
|
}
|
|
public int[] getFieldsNumbers() {
|
int[] arr = new int[fieldDataList.size()];
|
int count = 0;
|
for (FieldData fieldData : fieldDataList) {
|
int number = fieldData.getNumber();
|
arr[count++] = number;
|
}
|
return arr;
|
}
|
|
public Long getComputedTimestamp() {
|
return computedTimestamp;
|
}
|
|
@NonNull
|
@Override
|
public String toString() {
|
final GBToStringBuilder tsb = new GBToStringBuilder(this);
|
|
if (this.getClass().getName().equals(RecordData.class.getName())) {
|
tsb.append(globalFITMessage.name());
|
}
|
|
if (getComputedTimestamp() != null) {
|
tsb.append(new Date(getComputedTimestamp() * 1000L));
|
}
|
|
for (FieldData fieldData : fieldDataList) {
|
final String fieldName;
|
if (!StringUtils.isBlank(fieldData.getName())) {
|
fieldName = fieldData.getName();
|
} else {
|
fieldName = "unknown_" + fieldData.getNumber() + fieldData;
|
}
|
Object o = fieldData.decode();
|
final String fieldValueString;
|
if (o == null) {
|
fieldValueString = null;
|
} else if (o instanceof Object[]) {
|
fieldValueString = "[" + StringUtils.join((Object[]) o, ",") + "]";
|
} else {
|
fieldValueString = o.toString();
|
}
|
tsb.append(fieldName, fieldValueString);
|
}
|
return tsb.build();
|
}
|
|
private class FieldData {
|
private final FieldDefinition fieldDefinition;
|
private final int position;
|
private final int size;
|
private final int baseSize;
|
|
public FieldData(FieldDefinition fieldDefinition, int position) {
|
this.fieldDefinition = fieldDefinition;
|
this.position = position;
|
this.size = fieldDefinition.getSize();
|
this.baseSize = fieldDefinition.getBaseType().getSize();
|
}
|
|
private String getName() {
|
return fieldDefinition.getName();
|
}
|
|
private int getNumber() {
|
return fieldDefinition.getNumber();
|
}
|
|
private void invalidate() {
|
goToPosition();
|
if (STRING.equals(fieldDefinition.getBaseType())) {
|
for (int i = 0; i < size; i++) {
|
valueHolder.put((byte) 0);
|
}
|
return;
|
}
|
for (int i = 0; i < (size / baseSize); i++) {
|
fieldDefinition.invalidate(valueHolder);
|
}
|
}
|
|
private void goToPosition() {
|
valueHolder.position(position);
|
}
|
|
private Long parseDataMessage(GarminByteBufferReader garminByteBufferReader) {
|
goToPosition();
|
valueHolder.put(garminByteBufferReader.readBytes(size));
|
if (fieldDefinition.getNumber() == 253)
|
return (Long) decode();
|
return null;
|
}
|
|
private void encode(Object... objects) {
|
if (objects[0] instanceof boolean[] || objects[0] instanceof short[] || objects[0] instanceof int[] || objects[0] instanceof long[] || objects[0] instanceof float[] || objects[0] instanceof double[]) {
|
throw new IllegalArgumentException("Array of primitive types not supported, box them to objects");
|
}
|
goToPosition();
|
final int slots = size / baseSize;
|
int i = 0;
|
for (Object o : objects) {
|
if (i++ >= slots) {
|
throw new IllegalArgumentException("Number of elements in array was too big for the field");
|
}
|
if (STRING.equals(fieldDefinition.getBaseType())) {
|
final byte[] bytes = ((String) o).getBytes(StandardCharsets.UTF_8);
|
valueHolder.put(Arrays.copyOf(bytes, Math.min(this.size - 1, bytes.length)));
|
valueHolder.put((byte) 0);
|
return;
|
}
|
fieldDefinition.encode(valueHolder, o);
|
}
|
}
|
|
private Object decode() {
|
goToPosition();
|
if (STRING.equals(fieldDefinition.getBaseType())) {
|
final byte[] bytes = new byte[size];
|
valueHolder.get(bytes);
|
final int zero = ArrayUtils.indexOf((byte) 0, bytes);
|
if (zero < 0) {
|
return new String(bytes, StandardCharsets.UTF_8);
|
}
|
return new String(bytes, 0, zero, StandardCharsets.UTF_8);
|
}
|
if (size > baseSize) {
|
Object[] arr = new Object[size / baseSize];
|
for (int i = 0; i < arr.length; i++) {
|
arr[i] = fieldDefinition.decode(valueHolder);
|
}
|
return arr;
|
}
|
return fieldDefinition.decode(valueHolder);
|
}
|
|
public String toString() {
|
return "(" + fieldDefinition.getBaseType().name() + "/" + size + ")";
|
}
|
}
|
}
|
