package nodomain.freeyourgadget.gadgetbridge.service.devices.garmin.fit;
|
|
import androidx.annotation.NonNull;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.io.ByteArrayOutputStream;
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.nio.ByteOrder;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import nodomain.freeyourgadget.gadgetbridge.service.devices.garmin.ChecksumCalculator;
|
import nodomain.freeyourgadget.gadgetbridge.service.devices.garmin.GarminByteBufferReader;
|
import nodomain.freeyourgadget.gadgetbridge.service.devices.garmin.fit.messages.FitRecordDataFactory;
|
import nodomain.freeyourgadget.gadgetbridge.service.devices.garmin.messages.MessageWriter;
|
|
public class FitFile {
|
protected static final Logger LOG = LoggerFactory.getLogger(FitFile.class);
|
private final Header header;
|
private final List<RecordData> dataRecords;
|
private final boolean canGenerateOutput;
|
|
public FitFile(Header header, List<RecordData> dataRecords) {
|
this.header = header;
|
this.dataRecords = dataRecords;
|
this.canGenerateOutput = false;
|
}
|
|
public FitFile(List<RecordData> dataRecords) {
|
this.dataRecords = dataRecords;
|
this.header = new Header(true, 16, 21117);
|
this.canGenerateOutput = true;
|
}
|
|
private static byte[] readFileToByteArray(File file) throws IOException {
|
try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); InputStream inputStream = new FileInputStream(file)) {
|
byte[] buffer = new byte[1024];
|
int length;
|
while ((length = inputStream.read(buffer)) != -1) {
|
outputStream.write(buffer, 0, length);
|
}
|
return outputStream.toByteArray();
|
}
|
}
|
|
public static FitFile parseIncoming(File file) throws IOException {
|
return parseIncoming(readFileToByteArray(file));
|
}
|
|
//TODO: process file in chunks??
|
public static FitFile parseIncoming(byte[] fileContents) {
|
|
final GarminByteBufferReader garminByteBufferReader = new GarminByteBufferReader(fileContents);
|
garminByteBufferReader.setByteOrder(ByteOrder.LITTLE_ENDIAN);
|
|
final Header header = Header.parseIncomingHeader(garminByteBufferReader);
|
|
// needed because the headers can be redefined in the file. The last header for a local message number wins
|
Map<Integer, RecordDefinition> recordDefinitionMap = new HashMap<>();
|
List<RecordData> dataRecords = new ArrayList<>();
|
Long referenceTimestamp = null;
|
|
while (garminByteBufferReader.getPosition() < header.getHeaderSize() + header.getDataSize()) {
|
byte rawRecordHeader = (byte) garminByteBufferReader.readByte();
|
RecordHeader recordHeader = new RecordHeader(rawRecordHeader);
|
final Integer timeOffset = recordHeader.getTimeOffset();
|
if (timeOffset != null) {
|
if (referenceTimestamp == null) {
|
throw new IllegalArgumentException("Got compressed timestamp without knowing current timestamp");
|
}
|
|
if (timeOffset >= (referenceTimestamp & 0x1FL)) {
|
referenceTimestamp = (referenceTimestamp & ~0x1FL) + timeOffset;
|
} else if (timeOffset < (referenceTimestamp & 0x1FL)) {
|
referenceTimestamp = (referenceTimestamp & ~0x1FL) + timeOffset + 0x20;
|
}
|
}
|
if (recordHeader.isDefinition()) {
|
final RecordDefinition recordDefinition = RecordDefinition.parseIncoming(garminByteBufferReader, recordHeader);
|
if (recordDefinition != null) {
|
if (recordHeader.isDeveloperData())
|
for (RecordData rd : dataRecords) {
|
if (GlobalFITMessage.FIELD_DESCRIPTION.equals(rd.getGlobalFITMessage()))
|
recordDefinition.populateDevFields(rd);
|
}
|
recordDefinitionMap.put(recordHeader.getLocalMessageType(), recordDefinition);
|
}
|
} else {
|
final RecordDefinition referenceRecordDefinition = recordDefinitionMap.get(recordHeader.getLocalMessageType());
|
if (referenceRecordDefinition != null) {
|
final RecordData runningData = FitRecordDataFactory.create(referenceRecordDefinition, recordHeader);
|
dataRecords.add(runningData);
|
Long newTimestamp = runningData.parseDataMessage(garminByteBufferReader, referenceTimestamp);
|
if (newTimestamp != null)
|
referenceTimestamp = newTimestamp;
|
}
|
}
|
}
|
garminByteBufferReader.setByteOrder(ByteOrder.LITTLE_ENDIAN);
|
int fileCrc = garminByteBufferReader.readShort();
|
if (fileCrc != ChecksumCalculator.computeCrc(fileContents, header.getHeaderSize(), fileContents.length - header.getHeaderSize() - 2)) {
|
throw new IllegalArgumentException("Wrong CRC for FIT file");
|
}
|
return new FitFile(header, dataRecords);
|
}
|
|
public List<RecordData> getRecordsByGlobalMessage(GlobalFITMessage globalFITMessage) {
|
final List<RecordData> filtered = new ArrayList<>();
|
for (RecordData rd : dataRecords) {
|
if (globalFITMessage.equals(rd.getGlobalFITMessage()))
|
filtered.add(rd);
|
}
|
return filtered;
|
}
|
|
public List<RecordData> getRecords() {
|
return dataRecords;
|
}
|
|
public void generateOutgoingDataPayload(MessageWriter writer) {
|
if (!canGenerateOutput)
|
throw new IllegalArgumentException("Generation of previously parsed FIT file not supported.");
|
|
MessageWriter temporary = new MessageWriter(writer.getLimit());
|
temporary.setByteOrder(ByteOrder.LITTLE_ENDIAN);
|
RecordDefinition prevDefinition = null;
|
for (final RecordData rd : dataRecords) {
|
if (!rd.getRecordDefinition().equals(prevDefinition)) {
|
rd.getRecordDefinition().generateOutgoingPayload(temporary);
|
prevDefinition = rd.getRecordDefinition();
|
}
|
|
rd.generateOutgoingDataPayload(temporary);
|
}
|
this.header.setDataSize(temporary.getSize());
|
|
this.header.generateOutgoingDataPayload(writer);
|
writer.writeBytes(temporary.getBytes());
|
writer.writeShort(ChecksumCalculator.computeCrc(writer.getBytes(), this.header.getHeaderSize(), writer.getBytes().length - this.header.getHeaderSize()));
|
}
|
|
public byte[] getOutgoingMessage() {
|
// Compute the worst case scenario buffer size for the fit file
|
// A ~1.6MB gpx file with ~16k points results in a ~320KB buffer, ~150KB of which get actually used
|
final int dataRecordsSize = dataRecords.stream()
|
.mapToInt(r -> {
|
// Worst case scenario, for each data record
|
|
// one distinct record definition: 5 bytes + (number of field definitions * 3 + 1)
|
final List<FieldDefinition> definitions = r.getRecordDefinition().getFieldDefinitions();
|
final int recordDefinitionOverhead = 5 + (definitions != null ? definitions.size() * 3 + 1 : 0);
|
|
// 1 + size of the value holder
|
final int dataRecordOverhead = 1 + r.valueHolder.limit();
|
|
return recordDefinitionOverhead + dataRecordOverhead;
|
}).sum();
|
|
// Final size = 14b header + data records + 2b crc
|
final MessageWriter writer = new MessageWriter(14 + dataRecordsSize + 2);
|
this.generateOutgoingDataPayload(writer);
|
return writer.getBytes();
|
}
|
|
@NonNull
|
@Override
|
public String toString() {
|
return dataRecords.toString();
|
}
|
|
public static class Header {
|
public static final int MAGIC = 0x5449462E;
|
|
private final int headerSize;
|
private final int protocolVersion;
|
private final int profileVersion;
|
private final boolean hasCRC;
|
private int dataSize;
|
|
public Header(boolean hasCRC, int protocolVersion, int profileVersion) {
|
this(hasCRC, protocolVersion, profileVersion, 0);
|
}
|
|
public Header(boolean hasCRC, int protocolVersion, int profileVersion, int dataSize) {
|
this.hasCRC = hasCRC;
|
headerSize = hasCRC ? 14 : 12;
|
this.protocolVersion = protocolVersion;
|
this.profileVersion = profileVersion;
|
this.dataSize = dataSize;
|
}
|
|
static Header parseIncomingHeader(GarminByteBufferReader garminByteBufferReader) {
|
int headerSize = garminByteBufferReader.readByte();
|
if (headerSize < 12) {
|
throw new IllegalArgumentException("Too short header in FIT file.");
|
}
|
boolean hasCRC = headerSize == 14;
|
int protocolVersion = garminByteBufferReader.readByte();
|
int profileVersion = garminByteBufferReader.readShort();
|
int dataSize = garminByteBufferReader.readInt();
|
int magic = garminByteBufferReader.readInt();
|
if (magic != MAGIC) {
|
throw new IllegalArgumentException("Wrong magic header in FIT file");
|
}
|
if (hasCRC) {
|
int incomingCrc = garminByteBufferReader.readShort();
|
|
if (incomingCrc != 0 && incomingCrc != ChecksumCalculator.computeCrc(garminByteBufferReader.asReadOnlyBuffer(), 0, headerSize - 2)) {
|
throw new IllegalArgumentException("Wrong CRC for header in FIT file");
|
}
|
// LOG.info("Fit File Header didn't have CRC, no check performed.");
|
}
|
return new Header(hasCRC, protocolVersion, profileVersion, dataSize);
|
}
|
|
public int getHeaderSize() {
|
return headerSize;
|
}
|
|
public int getDataSize() {
|
return dataSize;
|
}
|
|
public void setDataSize(int dataSize) {
|
this.dataSize = dataSize;
|
}
|
|
public void generateOutgoingDataPayload(MessageWriter writer) {
|
writer.setByteOrder(ByteOrder.LITTLE_ENDIAN);
|
writer.writeByte(headerSize);
|
writer.writeByte(protocolVersion);
|
writer.writeShort(profileVersion);
|
writer.writeInt(dataSize);
|
writer.writeInt(MAGIC);//magic
|
if (hasCRC)
|
writer.writeShort(ChecksumCalculator.computeCrc(writer.getBytes(), 0, writer.getBytes().length));
|
}
|
|
}
|
}
|
