/* Copyright (C) 2017-2024 Carsten Pfeiffer, Daniel Dakhno, Daniele Gobbetti,
|
José Rebelo, Petr Vaněk
|
|
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.adapter;
|
|
import android.content.Context;
|
import android.view.LayoutInflater;
|
import android.view.Menu;
|
import android.view.View;
|
import android.view.ViewGroup;
|
import android.widget.ImageView;
|
import android.widget.TextView;
|
import android.widget.Toast;
|
|
import org.apache.commons.lang3.StringUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.text.DecimalFormat;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.concurrent.TimeUnit;
|
|
import de.greenrobot.dao.query.QueryBuilder;
|
import nodomain.freeyourgadget.gadgetbridge.GBApplication;
|
import nodomain.freeyourgadget.gadgetbridge.R;
|
import nodomain.freeyourgadget.gadgetbridge.database.DBHandler;
|
import nodomain.freeyourgadget.gadgetbridge.database.DBHelper;
|
import nodomain.freeyourgadget.gadgetbridge.devices.DeviceCoordinator;
|
import nodomain.freeyourgadget.gadgetbridge.entities.BaseActivitySummary;
|
import nodomain.freeyourgadget.gadgetbridge.entities.BaseActivitySummaryDao;
|
import nodomain.freeyourgadget.gadgetbridge.entities.Device;
|
import nodomain.freeyourgadget.gadgetbridge.impl.GBDevice;
|
import nodomain.freeyourgadget.gadgetbridge.model.ActivityKind;
|
import nodomain.freeyourgadget.gadgetbridge.model.ActivityListItem;
|
import nodomain.freeyourgadget.gadgetbridge.model.ActivitySummaryData;
|
import nodomain.freeyourgadget.gadgetbridge.model.ActivitySummaryEntries;
|
import nodomain.freeyourgadget.gadgetbridge.model.ActivitySummaryJsonSummary;
|
import nodomain.freeyourgadget.gadgetbridge.model.ActivitySummaryParser;
|
import nodomain.freeyourgadget.gadgetbridge.util.DateTimeUtils;
|
import nodomain.freeyourgadget.gadgetbridge.util.FormatUtils;
|
import nodomain.freeyourgadget.gadgetbridge.util.GB;
|
|
import static nodomain.freeyourgadget.gadgetbridge.activities.ActivitySummariesFilter.ALL_DEVICES;
|
import static nodomain.freeyourgadget.gadgetbridge.model.ActivitySummaryEntries.INTERNAL_HAS_GPS;
|
|
import androidx.annotation.NonNull;
|
|
import com.google.gson.Gson;
|
import com.google.gson.GsonBuilder;
|
|
public class ActivitySummariesAdapter extends AbstractActivityListingAdapter<BaseActivitySummary> {
|
protected static final Logger LOG = LoggerFactory.getLogger(ActivitySummariesAdapter.class);
|
private final GBDevice device;
|
long dateFromFilter = 0;
|
long dateToFilter = 0;
|
long deviceFilter;
|
String nameContainsFilter;
|
List<Long> itemsFilter;
|
private int activityKindFilter;
|
|
public ActivitySummariesAdapter(Context context, GBDevice device, int activityKindFilter, long dateFromFilter, long dateToFilter, String nameContainsFilter, long deviceFilter, List itemsFilter) {
|
super(context);
|
this.device = device;
|
this.activityKindFilter = activityKindFilter;
|
this.dateFromFilter = dateFromFilter;
|
this.dateToFilter = dateToFilter;
|
this.nameContainsFilter = nameContainsFilter;
|
this.deviceFilter = deviceFilter;
|
this.itemsFilter = itemsFilter;
|
loadItems();
|
}
|
|
@Override
|
public void loadItems() {
|
try (DBHandler handler = GBApplication.acquireDB()) {
|
BaseActivitySummaryDao summaryDao = handler.getDaoSession().getBaseActivitySummaryDao();
|
Device dbDevice = DBHelper.findDevice(device, handler.getDaoSession());
|
|
QueryBuilder<BaseActivitySummary> qb = summaryDao.queryBuilder();
|
|
if (deviceFilter == ALL_DEVICES) {
|
qb.orderDesc(BaseActivitySummaryDao.Properties.StartTime);
|
} else if (deviceFilter != 0) {
|
qb.where(
|
BaseActivitySummaryDao.Properties.DeviceId.eq(
|
deviceFilter)).orderDesc(BaseActivitySummaryDao.Properties.StartTime);
|
} else {
|
qb.where(
|
BaseActivitySummaryDao.Properties.DeviceId.eq(
|
dbDevice.getId())).orderDesc(BaseActivitySummaryDao.Properties.StartTime);
|
}
|
|
if (activityKindFilter != 0) {
|
qb.where(
|
BaseActivitySummaryDao.Properties.ActivityKind.eq(activityKindFilter));
|
}
|
|
if (dateFromFilter != 0) {
|
qb.where(
|
BaseActivitySummaryDao.Properties.StartTime.gt(new Date(dateFromFilter)));
|
}
|
if (dateToFilter != 0) {
|
qb.where(
|
BaseActivitySummaryDao.Properties.EndTime.lt(new Date(dateToFilter)));
|
}
|
if (nameContainsFilter != null && !nameContainsFilter.isEmpty()) {
|
qb.where(
|
BaseActivitySummaryDao.Properties.Name.like("%" + nameContainsFilter + "%"));
|
}
|
if (itemsFilter != null) {
|
qb.where(
|
BaseActivitySummaryDao.Properties.Id.in(itemsFilter));
|
}
|
|
|
List<BaseActivitySummary> allSummaries = new ArrayList<>();
|
// HACK: Populate json in a dummy summary, so stats load faster
|
BaseActivitySummary dashboardSummary = new BaseActivitySummary();
|
final List<BaseActivitySummary> summaries = qb.build().list();
|
dashboardSummary.setSummaryData(StatsContainer.from(
|
device.getDeviceCoordinator().getActivitySummaryParser(device, getContext()),
|
summaries
|
).toJson());
|
allSummaries.add(dashboardSummary); // dashboard
|
allSummaries.addAll(summaries);
|
allSummaries.add(new BaseActivitySummary()); // empty
|
setItems(allSummaries, true);
|
} catch (Exception e) {
|
GB.toast("Error loading activity summaries.", Toast.LENGTH_SHORT, GB.ERROR, e);
|
}
|
}
|
|
@NonNull
|
@Override
|
public AbstractActivityListingViewHolder<BaseActivitySummary> onCreateViewHolder(@NonNull final ViewGroup parent, final int viewType) {
|
switch (viewType) {
|
case 0: // dashboard
|
return new DashboardViewHolder(LayoutInflater.from(getContext()).inflate(R.layout.activity_summary_dashboard_item, parent, false));
|
case 2: // item
|
return new ActivityItemViewHolder(LayoutInflater.from(getContext()).inflate(R.layout.activity_list_item, parent, false));
|
}
|
|
return super.onCreateViewHolder(parent, viewType);
|
}
|
|
public void setActivityKindFilter(int filter) {
|
this.activityKindFilter = filter;
|
}
|
|
public void setDateFromFilter(long date) {
|
this.dateFromFilter = date;
|
}
|
|
public void setDateToFilter(long date) {
|
this.dateToFilter = date;
|
}
|
|
public void setNameContainsFilter(String name) {
|
this.nameContainsFilter = name;
|
}
|
|
public void setItemsFilter(List<Long> items) {
|
this.itemsFilter = items;
|
}
|
|
public void setDeviceFilter(long device) {
|
this.deviceFilter = device;
|
}
|
|
public int gettActivityKindFilter() {
|
return this.activityKindFilter;
|
}
|
|
public static class ActivityItemViewHolder extends AbstractActivityListingViewHolder<BaseActivitySummary> {
|
final View rootView;
|
final ActivityListItem activityListItem;
|
|
public ActivityItemViewHolder(@NonNull final View itemView) {
|
super(itemView);
|
this.rootView = itemView;
|
this.activityListItem = new ActivityListItem(itemView);
|
}
|
|
@Override
|
public void fill(final int position, final BaseActivitySummary summary, final boolean selected) {
|
final boolean hasGps;
|
|
if (summary.getGpxTrack() != null) {
|
hasGps = true;
|
} else if (summary.getSummaryData() != null && summary.getSummaryData().contains(ActivitySummaryEntries.INTERNAL_HAS_GPS)) {
|
final ActivitySummaryData summaryData = ActivitySummaryData.fromJson(summary.getSummaryData());
|
hasGps = summaryData != null && summaryData.getBoolean(INTERNAL_HAS_GPS, false);
|
} else {
|
hasGps = false;
|
}
|
|
this.activityListItem.update(
|
null,
|
null,
|
ActivityKind.fromCode(summary.getActivityKind()),
|
summary.getName(),
|
-1,
|
-1,
|
-1,
|
-1,
|
summary.getEndTime().getTime() - summary.getStartTime().getTime(),
|
hasGps,
|
summary.getStartTime(),
|
position % 2 == 1,
|
selected
|
);
|
}
|
}
|
|
public class DashboardViewHolder extends AbstractActivityListingViewHolder<BaseActivitySummary> {
|
final TextView durationSumView;
|
final TextView caloriesBurntSumView;
|
final TextView distanceSumView;
|
final TextView activeSecondsSumView;
|
final TextView timeStartView;
|
final TextView timeEndView;
|
final TextView activitiesCountView;
|
final TextView activityKindView;
|
final ImageView activityIconView;
|
final ImageView activityIconBigView;
|
|
public DashboardViewHolder(@NonNull final View itemView) {
|
super(itemView);
|
|
durationSumView = itemView.findViewById(R.id.summary_dashboard_layout_duration_label);
|
caloriesBurntSumView = itemView.findViewById(R.id.summary_dashboard_layout_calories_label);
|
distanceSumView = itemView.findViewById(R.id.summary_dashboard_layout_distance_label);
|
activeSecondsSumView = itemView.findViewById(R.id.summary_dashboard_layout_active_duration_label);
|
timeStartView = itemView.findViewById(R.id.summary_dashboard_layout_from_label);
|
timeEndView = itemView.findViewById(R.id.summary_dashboard_layout_to_label);
|
activitiesCountView = itemView.findViewById(R.id.summary_dashboard_layout_count_label);
|
activityKindView = itemView.findViewById(R.id.summary_dashboard_layout_activity_label);
|
activityIconView = itemView.findViewById(R.id.summary_dashboard_layout_activity_icon);
|
activityIconBigView = itemView.findViewById(R.id.summary_dashboard_layout_big_activity_icon);
|
}
|
|
@Override
|
public void fill(final int position, final BaseActivitySummary summary, final boolean selected) {
|
int activitiesCount = getItemCount() - 2; // remove dashboard and end spacer
|
|
final DeviceCoordinator coordinator = device.getDeviceCoordinator();
|
|
String summaryData = summary.getSummaryData();
|
final StatsContainer stats;
|
if (StringUtils.isNotBlank(summaryData)) {
|
stats = StatsContainer.fromJson(summaryData);
|
} else {
|
stats = StatsContainer.from(
|
coordinator.getActivitySummaryParser(device, getContext()),
|
getItems()
|
);
|
}
|
|
DecimalFormat df = new DecimalFormat("#.##");
|
durationSumView.setText(String.format("%s", DateTimeUtils.formatDurationHoursMinutes((long) stats.durationSum, TimeUnit.MILLISECONDS)));
|
caloriesBurntSumView.setText(String.format("%s %s", (long) stats.caloriesBurntSum, getContext().getString(R.string.calories_unit)));
|
distanceSumView.setText(String.format("%s %s", df.format(stats.distanceSum / 1000), getContext().getString(R.string.km)));
|
distanceSumView.setText(FormatUtils.getFormattedDistanceLabel(stats.distanceSum));
|
|
activeSecondsSumView.setText(String.format("%s", DateTimeUtils.formatDurationHoursMinutes((long) stats.activeSecondsSum, TimeUnit.SECONDS)));
|
activitiesCountView.setText(String.valueOf(activitiesCount));
|
String activityName = getContext().getString(R.string.activity_summaries_all_activities);
|
if (gettActivityKindFilter() != 0) {
|
ActivityKind activityKind = ActivityKind.fromCode(gettActivityKindFilter());
|
activityName = activityKind.getLabel(getContext());
|
activityIconView.setImageResource(activityKind.getIcon());
|
activityIconBigView.setImageResource(activityKind.getIcon());
|
} else if (stats.activityIcon != 0) {
|
ActivityKind activityKind = ActivityKind.fromCode(stats.activityIcon);
|
activityIconView.setImageResource(activityKind.getIcon());
|
activityIconBigView.setImageResource(activityKind.getIcon());
|
} else {
|
activityIconView.setImageResource(R.drawable.ic_activity_unknown_small);
|
activityIconBigView.setImageResource(R.drawable.ic_activity_unknown_small);
|
}
|
|
activityKindView.setText(activityName);
|
|
//start and end are inverted when filer not applied, because items are sorted the other way
|
timeStartView.setText((dateFromFilter != 0) ? DateTimeUtils.formatDate(new Date(dateFromFilter)) : DateTimeUtils.formatDate(new Date((long) stats.lastItemDate)));
|
timeEndView.setText((dateToFilter != 0) ? DateTimeUtils.formatDate(new Date(dateToFilter)) : DateTimeUtils.formatDate(new Date((long) stats.firstItemDate)));
|
}
|
}
|
|
private static class StatsContainer {
|
private static final Gson GSON = new GsonBuilder().create();
|
|
private final double durationSum;
|
private final double caloriesBurntSum;
|
private final double distanceSum;
|
private final double activeSecondsSum;
|
private final double firstItemDate;
|
private final double lastItemDate;
|
private final int activityIcon;
|
|
public StatsContainer(final double durationSum,
|
final double caloriesBurntSum,
|
final double distanceSum,
|
final double activeSecondsSum,
|
final double firstItemDate,
|
final double lastItemDate,
|
final int activityIcon) {
|
this.durationSum = durationSum;
|
this.caloriesBurntSum = caloriesBurntSum;
|
this.distanceSum = distanceSum;
|
this.activeSecondsSum = activeSecondsSum;
|
this.firstItemDate = firstItemDate;
|
this.lastItemDate = lastItemDate;
|
this.activityIcon = activityIcon;
|
}
|
|
private static StatsContainer from(final ActivitySummaryParser summaryParser,
|
final List<BaseActivitySummary> activities) {
|
double durationSum = 0;
|
double caloriesBurntSum = 0;
|
double distanceSum = 0;
|
double activeSecondsSum = 0;
|
double firstItemDate = 0;
|
double lastItemDate = 0;
|
int activityIcon = 0;
|
boolean activitySame = true;
|
|
for (BaseActivitySummary summary : activities) {
|
if (summary.getStartTime() == null) continue; //first item is empty, for dashboard
|
|
if (firstItemDate == 0) firstItemDate = summary.getStartTime().getTime();
|
lastItemDate = summary.getEndTime().getTime();
|
durationSum += summary.getEndTime().getTime() - summary.getStartTime().getTime();
|
|
if (activityIcon == 0) {
|
activityIcon = summary.getActivityKind();
|
} else {
|
if (activityIcon != summary.getActivityKind()) {
|
activitySame = false;
|
}
|
}
|
|
final ActivitySummaryJsonSummary activitySummaryJsonSummary = new ActivitySummaryJsonSummary(summaryParser, summary);
|
ActivitySummaryData summarySubdata = activitySummaryJsonSummary.getSummaryData(false);
|
|
if (summarySubdata != null) {
|
if (summarySubdata.has("caloriesBurnt")) {
|
caloriesBurntSum += summarySubdata.getNumber("caloriesBurnt", 0).doubleValue();
|
}
|
if (summarySubdata.has("distanceMeters")) {
|
distanceSum += summarySubdata.getNumber("distanceMeters", 0).doubleValue();
|
}
|
if (summarySubdata.has("activeSeconds")) {
|
activeSecondsSum += summarySubdata.getNumber("activeSeconds", 0).doubleValue();
|
}
|
}
|
}
|
|
return new StatsContainer(
|
durationSum,
|
caloriesBurntSum,
|
distanceSum,
|
activeSecondsSum,
|
firstItemDate,
|
lastItemDate,
|
activitySame ? activityIcon : 0
|
);
|
}
|
|
public static StatsContainer fromJson(final String json) {
|
return GSON.fromJson(json, StatsContainer.class);
|
}
|
|
public String toJson() {
|
return GSON.toJson(this);
|
}
|
}
|
}
|
