/* Copyright (C) 2020-2024 José Rebelo, Petr Vaněk, Reiner Herrmann,
|
Sebastian Krey
|
|
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.model;
|
|
import static nodomain.freeyourgadget.gadgetbridge.model.ActivitySummaryEntries.*;
|
|
import org.apache.commons.lang3.tuple.Pair;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.util.Arrays;
|
import java.util.Iterator;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedList;
|
import java.util.List;
|
import java.util.Map;
|
|
import nodomain.freeyourgadget.gadgetbridge.activities.workouts.entries.ActivitySummaryEntry;
|
import nodomain.freeyourgadget.gadgetbridge.entities.BaseActivitySummary;
|
|
public class ActivitySummaryJsonSummary {
|
private static final Logger LOG = LoggerFactory.getLogger(ActivitySummaryJsonSummary.class);
|
private Map<String, List<String>> groupData;
|
private ActivitySummaryData summaryData;
|
private Map<String, List<Pair<String, ActivitySummaryEntry>>> summaryGroupedList;
|
private final ActivitySummaryParser summaryParser;
|
private final BaseActivitySummary baseActivitySummary;
|
|
public ActivitySummaryJsonSummary(final ActivitySummaryParser summaryParser, BaseActivitySummary baseActivitySummary) {
|
this.summaryParser = summaryParser;
|
this.baseActivitySummary = baseActivitySummary;
|
}
|
|
private ActivitySummaryData setSummaryData(BaseActivitySummary item, final boolean forDetails) {
|
final ActivitySummaryData summary = ActivitySummaryData.fromJson(getCorrectSummary(item, forDetails));
|
if (summary == null) {
|
return null;
|
}
|
|
//add additionally computed values here
|
if (item.getBaseAltitude() != null && item.getBaseAltitude() != -20000 && !summary.has("baseAltitude")) {
|
summary.add("baseAltitude", item.getBaseAltitude(), UNIT_METERS);
|
}
|
|
if (!summary.has("averageSpeed") && summary.has("distanceMeters") && summary.has("activeSeconds")) {
|
double distance = summary.getNumber("distanceMeters", 0).doubleValue();
|
double duration = summary.getNumber("activeSeconds", 1).doubleValue();
|
summary.add("averageSpeed", distance / duration, UNIT_METERS_PER_SECOND);
|
}
|
|
if (!summary.has(STEP_RATE_AVG) && summary.has(STEPS) && summary.has(ACTIVE_SECONDS)) {
|
double stepcount = summary.getNumber(STEPS, 0).doubleValue();
|
double duration = summary.getNumber(ACTIVE_SECONDS, 1).doubleValue();
|
summary.add(STEP_RATE_AVG, (double)((int)(((stepcount / duration) * 60)+0.5)), UNIT_SPM);
|
}
|
|
return summary;
|
}
|
|
public ActivitySummaryData getSummaryData(final boolean forDetails) {
|
//returns json with summaryData
|
if (summaryData == null) summaryData = setSummaryData(baseActivitySummary, forDetails);
|
return summaryData;
|
}
|
|
private String getCorrectSummary(BaseActivitySummary item, final boolean forDetails) {
|
if (summaryParser == null) {
|
return item.getSummaryData();
|
}
|
try {
|
item = summaryParser.parseBinaryData(item, forDetails);
|
} catch (final Exception e) {
|
LOG.error("Failed to re-parse corrected summary", e);
|
}
|
return item.getSummaryData();
|
}
|
|
public Map<String, List<Pair<String, ActivitySummaryEntry>>> getSummaryGroupedList() {
|
//returns list grouped by activity groups as per createActivitySummaryGroups
|
if (summaryData == null) summaryData = setSummaryData(baseActivitySummary, true);
|
if (summaryGroupedList == null) summaryGroupedList = setSummaryGroupedList(summaryData);
|
return summaryGroupedList;
|
}
|
|
private Map<String, List<Pair<String, ActivitySummaryEntry>>> setSummaryGroupedList(ActivitySummaryData activitySummaryData) {
|
this.groupData = createActivitySummaryGroups(); //structure for grouping activities into groups, when visualizing
|
|
if (activitySummaryData == null) return null;
|
Iterator<String> keys = activitySummaryData.getKeys().iterator();
|
|
final Map<String, List<Pair<String, ActivitySummaryEntry>>> activeGroups = new LinkedHashMap<>();
|
// Initialize activeGroups with the initial expected order and empty arrays
|
for (final String key : this.groupData.keySet()) {
|
activeGroups.put(key, new LinkedList<>());
|
}
|
|
while (keys.hasNext()) {
|
String key = keys.next();
|
if (key.startsWith("internal")) {
|
continue;
|
}
|
ActivitySummaryEntry item = activitySummaryData.get(key);
|
// Use the group if specified in the entry, otherwise fallback to the array below
|
String groupName = item.getGroup() != null ? item.getGroup() : getDefaultGroup(key);
|
|
List<Pair<String, ActivitySummaryEntry>> group = activeGroups.get(groupName);
|
if (group == null) {
|
// This group is not defined in createActivitySummaryGroups - add it to the end
|
group = new LinkedList<>();
|
activeGroups.put(groupName, group);
|
}
|
|
group.add(Pair.of(key, item));
|
}
|
|
// Convert activeGroups to the expected JSONObject
|
// activeGroups is already ordered
|
final Map<String, List<Pair<String, ActivitySummaryEntry>>> grouped = new LinkedHashMap<>();
|
for (final Map.Entry<String, List<Pair<String, ActivitySummaryEntry>>> entry : activeGroups.entrySet()) {
|
if (entry.getValue().isEmpty()) {
|
// empty group
|
continue;
|
}
|
grouped.put(entry.getKey(), entry.getValue());
|
}
|
return grouped;
|
}
|
|
private String getDefaultGroup(final String searchItem) {
|
final String defaultGroup = GROUP_ACTIVITY;
|
if (groupData == null) return defaultGroup;
|
for (final String groupKey : groupData.keySet()) {
|
final List<String> itemList = groupData.get(groupKey);
|
if (itemList == null) {
|
continue;
|
}
|
for (final String itemKey : itemList) {
|
if (itemKey.equals(searchItem)) {
|
return groupKey;
|
}
|
}
|
}
|
|
// NB: Default group must be present in group JSONObject created by createActivitySummaryGroups
|
return defaultGroup;
|
}
|
|
/**
|
* @noinspection ArraysAsListWithZeroOrOneArgument
|
*/
|
private static Map<String, List<String>> createActivitySummaryGroups() {
|
return new LinkedHashMap<String, List<String>>() {{
|
// NB: Default group Activity must be present in this definition, otherwise it wouldn't
|
// be shown.
|
put(GROUP_ACTIVITY, Arrays.asList(
|
DISTANCE_METERS, STEPS, STEP_RATE_SUM, ACTIVE_SECONDS, CALORIES_BURNT,
|
STRIDE_TOTAL, HR_AVG, HR_MAX, HR_MIN, STRIDE_AVG, STRIDE_MAX, STRIDE_MIN,
|
STEP_LENGTH_AVG
|
));
|
put(GROUP_SPEED, Arrays.asList(
|
SPEED_AVG, SPEED_MAX, SPEED_MIN, PACE_AVG_SECONDS_KM, PACE_MIN,
|
PACE_MAX, "averageSpeed2", CADENCE_AVG, CADENCE_MAX, CADENCE_MIN,
|
STEP_RATE_AVG, STEP_RATE_MAX
|
));
|
put(GROUP_ELEVATION, Arrays.asList(
|
ASCENT_METERS, DESCENT_METERS, ALTITUDE_MAX, ALTITUDE_MIN, ALTITUDE_AVG,
|
ALTITUDE_BASE, ASCENT_SECONDS, DESCENT_SECONDS, FLAT_SECONDS, ASCENT_DISTANCE,
|
DESCENT_DISTANCE, FLAT_DISTANCE, ELEVATION_GAIN, ELEVATION_LOSS
|
));
|
put(GROUP_STROKES, Arrays.asList(
|
STROKE_DISTANCE_AVG, STROKE_AVG_PER_SECOND, STROKES,
|
STROKE_RATE_AVG, STROKE_RATE_MAX
|
));
|
put(GROUP_JUMPS, Arrays.asList(
|
JUMPS, JUMP_RATE_AVG, JUMP_RATE_MAX
|
));
|
put(GROUP_SWIMMING, Arrays.asList(
|
SWOLF_INDEX, SWOLF_AVG, SWOLF_MAX, SWOLF_MIN, SWIM_STYLE
|
));
|
put(GROUP_TRAINING_EFFECT, Arrays.asList(
|
TRAINING_EFFECT_AEROBIC, TRAINING_EFFECT_ANAEROBIC, WORKOUT_LOAD,
|
MAXIMUM_OXYGEN_UPTAKE, RECOVERY_TIME, LACTATE_THRESHOLD_HR
|
));
|
put(GROUP_LAPS, Arrays.asList(
|
LAP_PACE_AVERAGE, LAPS, LANE_LENGTH
|
));
|
put(GROUP_PACE, Arrays.asList(
|
));
|
put(GROUP_RUNNING_FORM, Arrays.asList(
|
GROUND_CONTACT_TIME_AVG, IMPACT_AVG, IMPACT_MAX, SWING_ANGLE_AVG,
|
FORE_FOOT_LANDINGS, MID_FOOT_LANDINGS, BACK_FOOT_LANDINGS,
|
EVERSION_ANGLE_AVG, EVERSION_ANGLE_MAX
|
));
|
put(GROUP_HEART_RATE_ZONES, Arrays.asList(
|
HR_ZONE_NA, HR_ZONE_WARM_UP, HR_ZONE_FAT_BURN, HR_ZONE_EASY, HR_ZONE_AEROBIC, HR_ZONE_ANAEROBIC,
|
HR_ZONE_THRESHOLD, HR_ZONE_EXTREME, HR_ZONE_MAXIMUM
|
));
|
put(SETS, Arrays.asList(
|
));
|
}};
|
}
|
}
|
