/* Copyright (C) 2024 José Rebelo
|
|
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;
|
|
import androidx.annotation.NonNull;
|
import androidx.annotation.Nullable;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.stream.Collectors;
|
|
import de.greenrobot.dao.query.QueryBuilder;
|
import nodomain.freeyourgadget.gadgetbridge.GBApplication;
|
import nodomain.freeyourgadget.gadgetbridge.database.DBHelper;
|
import nodomain.freeyourgadget.gadgetbridge.entities.BaseActivitySummary;
|
import nodomain.freeyourgadget.gadgetbridge.entities.BaseActivitySummaryDao;
|
import nodomain.freeyourgadget.gadgetbridge.entities.DaoSession;
|
import nodomain.freeyourgadget.gadgetbridge.entities.Device;
|
import nodomain.freeyourgadget.gadgetbridge.impl.GBDevice;
|
import nodomain.freeyourgadget.gadgetbridge.model.ActivityKind;
|
import nodomain.freeyourgadget.gadgetbridge.model.ActivitySummaryData;
|
import nodomain.freeyourgadget.gadgetbridge.model.ActivitySummaryEntries;
|
import nodomain.freeyourgadget.gadgetbridge.model.ActivitySummaryParser;
|
import nodomain.freeyourgadget.gadgetbridge.model.Vo2MaxSample;
|
|
/**
|
* An implementation of {@link Vo2MaxSampleProvider} that extracts VO2 Max values from
|
* workouts, for devices that provide them as part of the workout data.
|
*/
|
public class WorkoutVo2MaxSampleProvider implements Vo2MaxSampleProvider<Vo2MaxSample> {
|
private static final Logger LOG = LoggerFactory.getLogger(WorkoutVo2MaxSampleProvider.class);
|
|
private final GBDevice device;
|
private final DaoSession session;
|
|
public WorkoutVo2MaxSampleProvider(final GBDevice device, final DaoSession session) {
|
this.device = device;
|
this.session = session;
|
}
|
|
@NonNull
|
@Override
|
public List<Vo2MaxSample> getAllSamples(final long timestampFrom, final long timestampTo) {
|
final BaseActivitySummaryDao summaryDao = session.getBaseActivitySummaryDao();
|
final Device dbDevice = DBHelper.findDevice(device, session);
|
if (dbDevice == null) {
|
// no device, no samples
|
return Collections.emptyList();
|
}
|
|
final DeviceCoordinator coordinator = device.getDeviceCoordinator();
|
|
final QueryBuilder<BaseActivitySummary> qb = summaryDao.queryBuilder();
|
qb.where(BaseActivitySummaryDao.Properties.DeviceId.eq(dbDevice.getId()))
|
.where(BaseActivitySummaryDao.Properties.StartTime.gt(new Date(timestampFrom)))
|
.where(BaseActivitySummaryDao.Properties.StartTime.lt(new Date(timestampTo)))
|
.orderAsc(BaseActivitySummaryDao.Properties.StartTime);
|
|
final List<BaseActivitySummary> samples = qb.build().list();
|
summaryDao.detachAll();
|
fillSummaryData(coordinator, samples);
|
|
return samples.stream()
|
.map(GarminVo2maxSample::fromActivitySummary)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toList());
|
}
|
|
@Override
|
public void addSample(final Vo2MaxSample timeSample) {
|
throw new UnsupportedOperationException("Read-only sample provider");
|
}
|
|
@Override
|
public void addSamples(final List<Vo2MaxSample> timeSamples) {
|
throw new UnsupportedOperationException("Read-only sample provider");
|
}
|
|
@Override
|
public Vo2MaxSample createSample() {
|
throw new UnsupportedOperationException("Read-only sample provider");
|
}
|
|
@Nullable
|
@Override
|
public Vo2MaxSample getLatestSample(final Vo2MaxSample.Type type, final long until) {
|
final BaseActivitySummaryDao summaryDao = session.getBaseActivitySummaryDao();
|
final Device dbDevice = DBHelper.findDevice(device, session);
|
if (dbDevice == null) {
|
// no device, no samples
|
return null;
|
}
|
|
final DeviceCoordinator coordinator = device.getDeviceCoordinator();
|
final QueryBuilder<BaseActivitySummary> qb = summaryDao.queryBuilder();
|
|
addWhereFilter(coordinator, qb, type);
|
|
if (until != 0) {
|
qb.where(BaseActivitySummaryDao.Properties.StartTime.le(new Date(until)));
|
}
|
|
qb.where(BaseActivitySummaryDao.Properties.DeviceId.eq(dbDevice.getId()))
|
.orderDesc(BaseActivitySummaryDao.Properties.StartTime)
|
.limit(1);
|
|
final List<BaseActivitySummary> samples = qb.build().list();
|
summaryDao.detachAll();
|
fillSummaryData(coordinator, samples);
|
|
return !samples.isEmpty() ? GarminVo2maxSample.fromActivitySummary(samples.get(0)) : null;
|
}
|
|
private static void addWhereFilter(final DeviceCoordinator coordinator,
|
final QueryBuilder<BaseActivitySummary> qb,
|
final Vo2MaxSample.Type type) {
|
final List<Integer> codes = new ArrayList<>();
|
|
if (coordinator.supportsVO2MaxRunning()) {
|
if (type == Vo2MaxSample.Type.ANY || type == Vo2MaxSample.Type.RUNNING) {
|
codes.addAll(Arrays.asList(
|
ActivityKind.INDOOR_RUNNING.getCode(),
|
ActivityKind.OUTDOOR_RUNNING.getCode(),
|
ActivityKind.CROSS_COUNTRY_RUNNING.getCode(),
|
ActivityKind.RUNNING.getCode()
|
));
|
}
|
}
|
if (coordinator.supportsVO2MaxCycling()) {
|
if (type == Vo2MaxSample.Type.ANY || type == Vo2MaxSample.Type.CYCLING) {
|
codes.addAll(Arrays.asList(
|
ActivityKind.CYCLING.getCode(),
|
ActivityKind.INDOOR_CYCLING.getCode(),
|
ActivityKind.HANDCYCLING.getCode(),
|
ActivityKind.HANDCYCLING_INDOOR.getCode(),
|
ActivityKind.OUTDOOR_CYCLING.getCode()
|
));
|
}
|
}
|
|
qb.where(BaseActivitySummaryDao.Properties.ActivityKind.in(codes));
|
}
|
|
private void fillSummaryData(final DeviceCoordinator coordinator,
|
final Collection<BaseActivitySummary> summaries) {
|
ActivitySummaryParser activitySummaryParser = coordinator.getActivitySummaryParser(device, GBApplication.getContext());
|
for (final BaseActivitySummary summary : summaries) {
|
if (summary.getSummaryData() == null) {
|
activitySummaryParser.parseBinaryData(summary, true);
|
}
|
}
|
}
|
|
@Nullable
|
@Override
|
public Vo2MaxSample getLatestSample() {
|
return getLatestSample(Vo2MaxSample.Type.ANY, 0);
|
}
|
|
@Nullable
|
@Override
|
public Vo2MaxSample getFirstSample() {
|
final BaseActivitySummaryDao summaryDao = session.getBaseActivitySummaryDao();
|
final Device dbDevice = DBHelper.findDevice(device, session);
|
if (dbDevice == null) {
|
// no device, no samples
|
return null;
|
}
|
|
final QueryBuilder<BaseActivitySummary> qb = summaryDao.queryBuilder();
|
qb.where(BaseActivitySummaryDao.Properties.DeviceId.eq(dbDevice.getId()))
|
.orderAsc(BaseActivitySummaryDao.Properties.StartTime)
|
.limit(1);
|
|
final List<BaseActivitySummary> samples = qb.build().list();
|
summaryDao.detachAll();
|
|
return !samples.isEmpty() ? GarminVo2maxSample.fromActivitySummary(samples.get(0)) : null;
|
}
|
|
|
public static class GarminVo2maxSample implements Vo2MaxSample {
|
private final long timestamp;
|
private final Type type;
|
private final float value;
|
|
public GarminVo2maxSample(final long timestamp, final Type type, final float value) {
|
this.timestamp = timestamp;
|
this.type = type;
|
this.value = value;
|
}
|
|
@Override
|
public long getTimestamp() {
|
return timestamp;
|
}
|
|
@Override
|
public Type getType() {
|
return type;
|
}
|
|
@Override
|
public float getValue() {
|
return value;
|
}
|
|
@Nullable
|
public static GarminVo2maxSample fromActivitySummary(final BaseActivitySummary summary) {
|
final String summaryDataJson = summary.getSummaryData();
|
if (summaryDataJson == null) {
|
return null;
|
}
|
|
if (!summaryDataJson.contains(ActivitySummaryEntries.MAXIMUM_OXYGEN_UPTAKE)) {
|
return null;
|
}
|
|
final ActivitySummaryData summaryData = ActivitySummaryData.fromJson(summaryDataJson);
|
if (summaryData == null) {
|
return null;
|
}
|
|
final double value = summaryData.getNumber(ActivitySummaryEntries.MAXIMUM_OXYGEN_UPTAKE, 0).doubleValue();
|
if (value == 0) {
|
return null;
|
}
|
|
final Vo2MaxSample.Type type;
|
switch (ActivityKind.fromCode(summary.getActivityKind())) {
|
case INDOOR_RUNNING:
|
case OUTDOOR_RUNNING:
|
case CROSS_COUNTRY_RUNNING:
|
case RUNNING:
|
type = Vo2MaxSample.Type.RUNNING;
|
break;
|
case CYCLING:
|
case INDOOR_CYCLING:
|
case HANDCYCLING:
|
case HANDCYCLING_INDOOR:
|
case MOTORCYCLING:
|
case OUTDOOR_CYCLING:
|
type = Vo2MaxSample.Type.CYCLING;
|
break;
|
default:
|
type = Vo2MaxSample.Type.ANY;
|
}
|
return new GarminVo2maxSample(summary.getStartTime().getTime(), type, (float) value);
|
}
|
}
|
}
|
