AggregatedStatisticsActivity: added filter option (by category, start and/or end date).

Fixes #1039.

src/main/java/de/dennisguse/opentracks/AggregatedStatisticsActivity.java

@@ -1,35 +1,61 @@
 package de.dennisguse.opentracks;
 
 import android.os.Bundle;
+import android.view.Menu;
+import android.view.MenuItem;
 import android.view.View;
 
+import androidx.annotation.NonNull;
 import androidx.lifecycle.ViewModelProvider;
 
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.util.ArrayList;
 import java.util.List;
 
 import de.dennisguse.opentracks.adapters.AggregatedStatisticsAdapter;
 import de.dennisguse.opentracks.content.data.Track;
+import de.dennisguse.opentracks.content.data.TrackSelection;
 import de.dennisguse.opentracks.databinding.AggregatedStatsBinding;
+import de.dennisguse.opentracks.fragments.FilterDialogFragment;
 import de.dennisguse.opentracks.viewmodels.AggregatedStatisticsModel;
 
-public class AggregatedStatisticsActivity extends AbstractActivity {
+public class AggregatedStatisticsActivity extends AbstractActivity implements FilterDialogFragment.FilterDialogListener {
 
     public static final String EXTRA_TRACK_IDS = "track_ids";
 
+    static final String STATE_ARE_FILTERS_APPLIED = "areFiltersApplied";
+
     private AggregatedStatsBinding viewBinding;
 
     private AggregatedStatisticsAdapter adapter;
 
+    private AggregatedStatisticsModel viewModel;
+    private final TrackSelection selection = new TrackSelection();
+
+    private boolean areFiltersApplied;
+    private MenuItem filterItem;
+    private MenuItem clearFilterItem;
+
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
         viewBinding.aggregatedStatsList.setEmptyView(viewBinding.aggregatedStatsEmptyView);
 
-        List<Track.Id> trackIds = getIntent().getParcelableArrayListExtra(EXTRA_TRACK_IDS);
+        areFiltersApplied = savedInstanceState != null && savedInstanceState.getBoolean(STATE_ARE_FILTERS_APPLIED);
 
-        final AggregatedStatisticsModel viewModel = new ViewModelProvider(this).get(AggregatedStatisticsModel.class);
-        viewModel.getAggregatedStats(trackIds).observe(this, aggregatedStatistics -> {
+        List<Track.Id> trackIds = getIntent().getParcelableArrayListExtra(EXTRA_TRACK_IDS);
+        if (trackIds != null && !trackIds.isEmpty()) {
+            trackIds.stream().forEach(selection::addTrackId);
+        }
+
+        viewModel = new ViewModelProvider(this).get(AggregatedStatisticsModel.class);
+        viewModel.getAggregatedStats(selection).observe(this, aggregatedStatistics -> {
+            if ((aggregatedStatistics == null || aggregatedStatistics.getCount() == 0) && !selection.isEmpty()) {
+                viewBinding.aggregatedStatsEmptyView.setText(getString(R.string.aggregated_stats_filter_no_results));
+            }
             if (aggregatedStatistics != null) {
                 adapter = new AggregatedStatisticsAdapter(this, aggregatedStatistics);
                 viewBinding.aggregatedStatsList.setAdapter(adapter);
@@ -38,9 +64,58 @@ public class AggregatedStatisticsActivity extends AbstractActivity {
         });
     }
 
+    @Override
+    public void onSaveInstanceState(@NonNull Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putBoolean(STATE_ARE_FILTERS_APPLIED, areFiltersApplied);
+    }
+
     @Override
     protected View getRootView() {
         viewBinding = AggregatedStatsBinding.inflate(getLayoutInflater());
         return viewBinding.getRoot();
     }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.aggregated_statistics, menu);
+        clearFilterItem = menu.findItem(R.id.aggregated_statistics_clear_filter);
+        filterItem = menu.findItem(R.id.aggregated_statistics_filter);
+        setMenuVisibility(areFiltersApplied);
+        return super.onCreateOptionsMenu(menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(@NonNull MenuItem item) {
+        if (item.getItemId() == R.id.aggregated_statistics_filter) {
+            ArrayList<FilterDialogFragment.FilterItem> filterItems = new ArrayList<>();
+            adapter.getCategories().stream().forEach(category -> filterItems.add(new FilterDialogFragment.FilterItem(category, category, true)));
+            FilterDialogFragment.showDialog(getSupportFragmentManager(), filterItems);
+            return true;
+        }
+
+        if (item.getItemId() == R.id.aggregated_statistics_clear_filter) {
+            setMenuVisibility(false);
+            viewModel.clearSelection();
+            return true;
+        }
+
+        return super.onOptionsItemSelected(item);
+    }
+
+    private void setMenuVisibility(boolean areFiltersApplied) {
+        this.areFiltersApplied = areFiltersApplied;
+        if (clearFilterItem != null && filterItem != null) {
+            clearFilterItem.setVisible(this.areFiltersApplied);
+            filterItem.setVisible(!this.areFiltersApplied);
+        }
+    }
+
+    @Override
+    public void onFilterDone(ArrayList<FilterDialogFragment.FilterItem> filterItems, LocalDateTime from, LocalDateTime to) {
+        setMenuVisibility(true);
+        selection.addDateRange(from.atZone(ZoneId.systemDefault()).toInstant(), to.atZone(ZoneId.systemDefault()).toInstant());
+        filterItems.stream().filter(fi -> fi.isChecked).forEach(fi -> selection.addCategory(fi.value));
+        viewModel.updateSelection(selection);
+    }
 }

src/main/java/de/dennisguse/opentracks/adapters/AggregatedStatisticsAdapter.java

@@ -9,6 +9,9 @@ import android.widget.BaseAdapter;
 import android.widget.ImageView;
 import android.widget.TextView;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import de.dennisguse.opentracks.R;
 import de.dennisguse.opentracks.settings.PreferencesUtils;
 import de.dennisguse.opentracks.util.StringUtils;
@@ -17,7 +20,7 @@ import de.dennisguse.opentracks.viewmodels.AggregatedStatistics;
 
 public class AggregatedStatisticsAdapter extends BaseAdapter {
 
-    private final AggregatedStatistics aggregatedStatistics;
+    private AggregatedStatistics aggregatedStatistics;
     private final Context context;
 
     public AggregatedStatisticsAdapter(Context context, AggregatedStatistics aggregatedStatistics) {
@@ -66,6 +69,20 @@ public class AggregatedStatisticsAdapter extends BaseAdapter {
         return convertView;
     }
 
+    public AggregatedStatistics swapData(AggregatedStatistics aggregatedStatistics) {
+        this.aggregatedStatistics = aggregatedStatistics;
+        this.notifyDataSetChanged();
+        return aggregatedStatistics;
+    }
+
+    public List<String> getCategories() {
+        List<String> categories = new ArrayList<>();
+        for (int i = 0; i < aggregatedStatistics.getCount(); i++) {
+            categories.add(aggregatedStatistics.getItem(i).getCategory());
+        }
+        return categories;
+    }
+
     private class ViewHolder {
         private final ImageView sportIcon;
         private final TextView typeLabel;

src/main/java/de/dennisguse/opentracks/content/data/TrackSelection.java

@@ -0,0 +1,77 @@
+package de.dennisguse.opentracks.content.data;
+
+import android.text.TextUtils;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
+import de.dennisguse.opentracks.content.provider.SelectionData;
+
+public class TrackSelection implements ContentProviderUtils.ContentProviderSelectionInterface {
+    private final List<Track.Id> trackIds = new ArrayList<>();
+    private final List<String> categories = new ArrayList<>();
+    private Instant from;
+    private Instant to;
+
+    public TrackSelection addDateRange(Instant from, Instant to) {
+        this.from = from;
+        this.to = to;
+        return this;
+    }
+
+    public TrackSelection addTrackId(Track.Id trackId) {
+        if (!this.trackIds.contains(trackId)) {
+            this.trackIds.add(trackId);
+        }
+        return this;
+    }
+
+    public TrackSelection addCategory(String category) {
+        if (!this.categories.contains(category)) {
+            this.categories.add(category);
+        }
+        return this;
+    }
+
+    public boolean isEmpty() {
+        return trackIds.isEmpty() && categories.isEmpty() && from == null && to == null;
+    }
+
+    @Override
+    public SelectionData buildSelection() {
+        String selection = "";
+        String[] selectionArgs;
+        ArrayList<String> fromToArgs = new ArrayList<>();
+
+        // Builds selection.
+        if (!trackIds.isEmpty()) {
+            selection = String.format(TracksColumns._ID + " IN (%s)", TextUtils.join(",", Collections.nCopies(trackIds.size(), "?")));
+        }
+        if (!categories.isEmpty()) {
+            selection += selection.isEmpty() ? "" : " AND ";
+            selection += String.format(TracksColumns.CATEGORY + " IN (%s)", TextUtils.join(",", Collections.nCopies(categories.size(), "?")));
+        }
+        if (from != null && to != null) {
+            selection += selection.isEmpty() ? "" : " AND ";
+            selection += TracksColumns.STARTTIME + " BETWEEN ? AND ?";
+            fromToArgs.add(Long.toString(from.toEpochMilli()));
+            fromToArgs.add(Long.toString(to.toEpochMilli()));
+        }
+
+        if (selection.isEmpty()) {
+            return new SelectionData();
+        }
+
+        // Builds selection arguments.
+        ArrayList<String> args = trackIds.stream().map(id -> Long.toString(id.getId())).collect(Collectors.toCollection(ArrayList::new));
+        args.addAll(categories);
+        args.addAll(fromToArgs);
+        selectionArgs = args.stream().toArray(String[]::new);
+
+        return new SelectionData(selection, selectionArgs);
+    }
+}

src/main/java/de/dennisguse/opentracks/content/provider/ContentProviderUtils.java

@@ -73,6 +73,10 @@ public class ContentProviderUtils {
 
     private final ContentResolver contentResolver;
 
+    public interface ContentProviderSelectionInterface {
+        SelectionData buildSelection();
+    }
+
     public ContentProviderUtils(Context context) {
         contentResolver = context.getContentResolver();
     }
@@ -205,15 +209,10 @@ public class ContentProviderUtils {
         return tracks;
     }
 
-    public List<Track> getTracks(List<Track.Id> trackIds) {
-        if (trackIds == null || trackIds.isEmpty()) {
-            return getTracks();
-        }
-
-        String selection = String.format(TracksColumns._ID + " IN (%s)", TextUtils.join(",", Collections.nCopies(trackIds.size(), "?")));
-        String[] selectionArgs = trackIds.stream().map(id -> Long.toString(id.getId())).toArray(String[]::new);
+    public List<Track> getTracks(ContentProviderSelectionInterface selection) {
+        SelectionData selectionData = selection.buildSelection();
         ArrayList<Track> tracks = new ArrayList<>();
-        try (Cursor cursor = getTrackCursor(selection, selectionArgs, TracksColumns._ID)) {
+        try (Cursor cursor = getTrackCursor(selectionData.getSelection(), selectionData.getSelectionArgs(), TracksColumns._ID)) {
             if (cursor != null && cursor.moveToFirst()) {
                 tracks.ensureCapacity(cursor.getCount());
                 do {

src/main/java/de/dennisguse/opentracks/content/provider/SelectionData.java

@@ -0,0 +1,24 @@
+package de.dennisguse.opentracks.content.provider;
+
+public class SelectionData {
+    private final String selection;
+    private final String[] selectionArgs;
+
+    public SelectionData() {
+        selection = null;
+        selectionArgs = null;
+    }
+
+    public SelectionData(String selection, String[] selectionArgs) {
+        this.selection = selection;
+        this.selectionArgs = selectionArgs;
+    }
+
+    public String getSelection() {
+        return selection;
+    }
+
+    public String[] getSelectionArgs() {
+        return selectionArgs;
+    }
+}

src/main/java/de/dennisguse/opentracks/fragments/FilterDialogFragment.java

@@ -0,0 +1,188 @@
+package de.dennisguse.opentracks.fragments;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.CheckBox;
+import android.widget.DatePicker;
+import android.widget.GridLayout;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AlertDialog;
+import androidx.fragment.app.DialogFragment;
+import androidx.fragment.app.FragmentManager;
+
+import com.google.android.material.textfield.TextInputEditText;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.time.temporal.WeekFields;
+import java.util.ArrayList;
+import java.util.Locale;
+
+import de.dennisguse.opentracks.R;
+import de.dennisguse.opentracks.util.StringUtils;
+
+public class FilterDialogFragment extends DialogFragment {
+
+    private static final String TAG = FilterDialogFragment.class.getSimpleName();
+    public static final String KEY_FILTER_ITEMS = "filterItems";
+
+    private FilterDialogListener filterDialogListener;
+    private ArrayList<FilterItem> filterItems = new ArrayList<>();
+
+    public static void showDialog(FragmentManager fragmentManager) {
+        FilterDialogFragment filterDialogFragment = new FilterDialogFragment();
+        filterDialogFragment.show(fragmentManager, TAG);
+    }
+
+    public static void showDialog(FragmentManager fragmentManager, ArrayList<FilterItem> items) {
+        Bundle bundle = new Bundle();
+        bundle.putParcelableArrayList(KEY_FILTER_ITEMS, items);
+
+        FilterDialogFragment filterDialogFragment = new FilterDialogFragment();
+        filterDialogFragment.setArguments(bundle);
+        filterDialogFragment.show(fragmentManager, TAG);
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
+        filterItems = getArguments().getParcelableArrayList(KEY_FILTER_ITEMS);
+
+        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+        builder.setTitle(getString(R.string.generic_filter));
+
+        LayoutInflater inflater = LayoutInflater.from(getActivity());
+        View layout = inflater.inflate(R.layout.fragment_filter_dialog, null, false);
+        GridLayout itemsLayout = layout.findViewById(R.id.filter_items);
+        builder.setView(layout);
+
+        for (FilterItem item : filterItems) {
+            View view = inflater.inflate(R.layout.fragment_filter_dialog_item, null);
+
+            CheckBox checkBox = view.findViewById(R.id.filter_dialog_check_button);
+            checkBox.setText(item.value);
+            checkBox.setChecked(item.isChecked);
+            checkBox.setTag(item.id);
+            checkBox.setOnClickListener(v -> item.isChecked = !item.isChecked);
+
+            itemsLayout.addView(view);
+        }
+
+        DatePicker datePickerFrom = layout.findViewById(R.id.filter_date_picker_from);
+        DatePicker datePickerTo = layout.findViewById(R.id.filter_date_picker_to);
+        TextInputEditText dateFrom = layout.findViewById(R.id.filter_date_edit_text_from);
+        TextInputEditText dateTo = layout.findViewById(R.id.filter_date_edit_text_to);
+
+        LocalDateTime firstDayThisWeek = LocalDate.now().with(WeekFields.of(Locale.getDefault()).getFirstDayOfWeek()).atStartOfDay();
+        dateFrom.setText(StringUtils.formatDate(getActivity(), firstDayThisWeek));
+        datePickerFrom.init(firstDayThisWeek.getYear(), firstDayThisWeek.getMonthValue() - 1, firstDayThisWeek.getDayOfMonth(), (view, year, monthOfYear, dayOfMonth) -> {
+            LocalDateTime localDateTime = LocalDateTime.of(year, monthOfYear + 1, dayOfMonth, 0, 0, 0);
+            dateFrom.setText(StringUtils.formatDate(getActivity(), localDateTime));
+            datePickerFrom.setVisibility(View.GONE);
+            datePickerTo.setMinDate(localDateTime.toInstant(ZoneOffset.ofTotalSeconds(0)).toEpochMilli());
+            if (localDateTime.isAfter(LocalDateTime.of(datePickerTo.getYear(), datePickerTo.getMonth() + 1, datePickerTo.getDayOfMonth(), 23, 59, 59))) {
+                datePickerTo.updateDate(year, monthOfYear, dayOfMonth);
+            }
+        });
+
+        LocalDateTime lastDayThisWeek = firstDayThisWeek.plusDays(6).withHour(23).withMinute(59).withSecond(59);
+        dateTo.setText(StringUtils.formatDate(getActivity(), lastDayThisWeek));
+        datePickerTo.init(lastDayThisWeek.getYear(), lastDayThisWeek.getMonthValue() - 1, lastDayThisWeek.getDayOfMonth(), (view, year, monthOfYear, dayOfMonth) -> {
+            LocalDateTime localDateTime = LocalDateTime.of(year, monthOfYear + 1, dayOfMonth, 23, 59, 59);
+            dateTo.setText(StringUtils.formatDate(getActivity(), localDateTime));
+            datePickerTo.setVisibility(View.GONE);
+        });
+
+        dateFrom.setOnClickListener(v -> {
+            datePickerFrom.setVisibility(View.VISIBLE);
+            datePickerTo.setVisibility(View.GONE);
+        });
+
+        dateTo.setOnClickListener(v -> {
+            datePickerFrom.setVisibility(View.GONE);
+            datePickerTo.setVisibility(View.VISIBLE);
+        });
+
+        builder.setPositiveButton(android.R.string.ok, (dialog, which) -> {
+            filterDialogListener.onFilterDone(
+                    filterItems,
+                    LocalDateTime.of(datePickerFrom.getYear(), datePickerFrom.getMonth() + 1, datePickerFrom.getDayOfMonth(), 0, 0, 0),
+                    LocalDateTime.of(datePickerTo.getYear(), datePickerTo.getMonth() + 1, datePickerTo.getDayOfMonth(), 23, 59, 59)
+            );
+        });
+
+        builder.setNegativeButton(android.R.string.cancel, null);
+
+        return builder.create();
+    }
+
+    @Override
+    public void onAttach(@NonNull Context context) {
+        super.onAttach(context);
+        try {
+            filterDialogListener = (FilterDialogListener) context;
+        } catch (ClassCastException e) {
+            throw new ClassCastException(context + " must implement " + FilterDialogListener.class.getSimpleName());
+        }
+    }
+
+    public interface FilterDialogListener {
+        void onFilterDone(ArrayList<FilterItem> filters, LocalDateTime from, LocalDateTime to);
+    }
+
+    public static class FilterItem implements Parcelable {
+        public final String id;
+        public final String value;
+        public boolean isChecked;
+
+        public FilterItem(String id, String value) {
+            this.id = id;
+            this.value = value;
+            this.isChecked = true;
+        }
+
+        public FilterItem(String id, String value, boolean isChecked) {
+            this.id = id;
+            this.value = value;
+            this.isChecked = isChecked;
+        }
+
+        protected FilterItem(Parcel in) {
+            id = in.readString();
+            value = in.readString();
+            isChecked = in.readByte() != 0;
+        }
+
+        public static final Creator<FilterItem> CREATOR = new Creator<FilterItem>() {
+            @Override
+            public FilterItem createFromParcel(Parcel in) {
+                return new FilterItem(in);
+            }
+
+            @Override
+            public FilterItem[] newArray(int size) {
+                return new FilterItem[size];
+            }
+        };
+
+        @Override
+        public int describeContents() {
+            return 0;
+        }
+
+        @Override
+        public void writeToParcel(Parcel dest, int flags) {
+            dest.writeString(id);
+            dest.writeString(value);
+            dest.writeByte((byte) (isChecked ? 1 : 0));
+        }
+    }
+}

src/main/java/de/dennisguse/opentracks/util/StringUtils.java

@@ -29,6 +29,7 @@ import java.text.DecimalFormat;
 import java.time.Duration;
 import java.time.Instant;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
@@ -61,6 +62,13 @@ public class StringUtils {
                 + " " + DateUtils.formatDateTime(context, time.toEpochMilli(), DateUtils.FORMAT_SHOW_TIME);
     }
 
+    /**
+     * Formats the date and time based on user's phone date/time preferences.
+     */
+    public static String formatDate(Context context, LocalDateTime localDateTime) {
+        return DateUtils.formatDateTime(context, localDateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(), DateUtils.FORMAT_SHOW_DATE);
+    }
+
     /**
      * Formats the time using the ISO 8601 date time format with fractional seconds in UTC time zone.
      */

src/main/java/de/dennisguse/opentracks/viewmodels/AggregatedStatisticsModel.java

@@ -11,6 +11,7 @@ import androidx.lifecycle.MutableLiveData;
 import java.util.List;
 
 import de.dennisguse.opentracks.content.data.Track;
+import de.dennisguse.opentracks.content.data.TrackSelection;
 import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
 
 public class AggregatedStatisticsModel extends AndroidViewModel {
@@ -21,18 +22,26 @@ public class AggregatedStatisticsModel extends AndroidViewModel {
         super(application);
     }
 
-    public LiveData<AggregatedStatistics> getAggregatedStats(@Nullable List<Track.Id> trackIds) {
+    public LiveData<AggregatedStatistics> getAggregatedStats(@Nullable TrackSelection selection) {
         if (aggregatedStats == null) {
             aggregatedStats = new MutableLiveData<>();
-            loadAggregatedStats(trackIds);
+            loadAggregatedStats(selection);
         }
         return aggregatedStats;
     }
 
-    private void loadAggregatedStats(@Nullable List<Track.Id> trackIds) {
+    public void updateSelection(TrackSelection selection) {
+        loadAggregatedStats(selection);
+    }
+
+    public void clearSelection() {
+        loadAggregatedStats(new TrackSelection());
+    }
+
+    private void loadAggregatedStats(TrackSelection selection) {
         new Thread(() -> {
             ContentProviderUtils contentProviderUtils = new ContentProviderUtils(getApplication().getApplicationContext());
-            List<Track> tracks = contentProviderUtils.getTracks(trackIds);
+            List<Track> tracks = selection != null ? contentProviderUtils.getTracks(selection) : contentProviderUtils.getTracks();
 
             AggregatedStatistics aggregatedStatistics = new AggregatedStatistics(tracks);