1 files changed, 60 insertions, 34 deletions
diff --git a/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/TrackersStatisticsUseCase.kt b/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/TrackersStatisticsUseCase.kt
index 2ed1077..1e1728c 100644
--- a/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/TrackersStatisticsUseCase.kt
+++ b/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/TrackersStatisticsUseCase.kt
@@ -22,7 +22,15 @@ import foundation.e.privacymodules.trackers.Tracker
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.callbackFlow
+import java.time.ZonedDateTime
+import java.time.format.DateTimeFormatter
+import java.time.temporal.ChronoUnit
 
+data class TrackersPeriodicStatistics(
+    val calls: List<Int>,
+    val periods: List<String>,
+    val trackersCount: Int
+)
 class TrackersStatisticsUseCase(
     private val trackTrackersPrivacyModule: ITrackTrackersPrivacyModule
 ) {
@@ -36,35 +44,66 @@ class TrackersStatisticsUseCase(
         awaitClose { trackTrackersPrivacyModule.removeListener(listener) }
     }
 
-    fun listenDayStatistics(): Flow<Triple<List<Int>, Int, Int>> = callbackFlow {
-        val listener = object : ITrackTrackersPrivacyModule.Listener {
-            override fun onNewData() {
-                offer(getDayStatistics())
-            }
+    fun getDayStatistics(): Pair<TrackersPeriodicStatistics, Int> {
+        return TrackersPeriodicStatistics(
+            calls = trackTrackersPrivacyModule.getPastDayTrackersCalls(),
+            periods = buildDayLabels(),
+            trackersCount = trackTrackersPrivacyModule.getPastDayTrackersCount()
+        ) to trackTrackersPrivacyModule.getTrackersCount()
+    }
+
+    private fun buildDayLabels(): List<String> {
+        val formater = DateTimeFormatter.ofPattern("HH:mm")
+        val periods = mutableListOf<String>()
+        var end = ZonedDateTime.now()
+        for (i in 1..24) {
+            val start = end.truncatedTo(ChronoUnit.HOURS)
+            periods.add("${formater.format(start)} - ${formater.format(end)}")
+            end = start.minus(1, ChronoUnit.MINUTES)
         }
+        return periods.reversed()
+    }
 
-        offer(getDayStatistics())
-        trackTrackersPrivacyModule.addListener(listener)
-        awaitClose { trackTrackersPrivacyModule.removeListener(listener) }
+    private fun buildMonthLabels(): List<String> {
+        val formater = DateTimeFormatter.ofPattern("MMM d - EEE")
+        val periods = mutableListOf<String>()
+        var day = ZonedDateTime.now().truncatedTo(ChronoUnit.DAYS)
+        for (i in 1..30) {
+            periods.add(formater.format(day))
+            day = day.minus(1, ChronoUnit.DAYS)
+        }
+        return periods.reversed()
     }
 
-    fun getDayStatistics(): Triple<List<Int>, Int, Int> {
-        return Triple(
-            trackTrackersPrivacyModule.getPastDayTrackersCalls(),
-            trackTrackersPrivacyModule.getPastDayTrackersCount(),
-            trackTrackersPrivacyModule.getTrackersCount()
-        )
+    private fun buildYearLabels(): List<String> {
+        val formater = DateTimeFormatter.ofPattern("MMM yyyy")
+        val periods = mutableListOf<String>()
+        var month = ZonedDateTime.now().truncatedTo(ChronoUnit.DAYS).withDayOfMonth(1)
+        for (i in 1..12) {
+            periods.add(formater.format(month))
+            month = month.minus(1, ChronoUnit.MONTHS)
+        }
+        return periods.reversed()
     }
 
-    fun getDayMonthYearStatistics(): Triple<
-        Pair<List<Int>, Int>,
-        Pair<List<Int>, Int>,
-        Pair<List<Int>, Int>> {
+    fun getDayMonthYearStatistics(): Triple<TrackersPeriodicStatistics, TrackersPeriodicStatistics, TrackersPeriodicStatistics> {
         return with(trackTrackersPrivacyModule) {
             Triple(
-                getPastDayTrackersCalls() to getPastDayTrackersCount(),
-                getPastMonthTrackersCalls() to getPastMonthTrackersCount(),
-                getPastYearTrackersCalls() to getPastYearTrackersCount()
+                TrackersPeriodicStatistics(
+                    calls = getPastDayTrackersCalls(),
+                    periods = buildDayLabels(),
+                    trackersCount = getPastDayTrackersCount()
+                ),
+                TrackersPeriodicStatistics(
+                    calls = getPastMonthTrackersCalls(),
+                    periods = buildMonthLabels(),
+                    trackersCount = getPastMonthTrackersCount()
+                ),
+                TrackersPeriodicStatistics(
+                    calls = getPastYearTrackersCalls(),
+                    periods = buildYearLabels(),
+                    trackersCount = getPastYearTrackersCount()
+                )
             )
         }
     }
@@ -72,17 +111,4 @@ class TrackersStatisticsUseCase(
     fun getTrackers(appUid: Int): List<Tracker> {
         return trackTrackersPrivacyModule.getTrackersForApp(appUid)
     }
-
-    private fun List<Int>.pruneEmptyHistoric(): List<Int> {
-        val result = mutableListOf<Int>()
-        reversed().forEach {
-            if (result.isNotEmpty() || it != 0) {
-                result.add(it)
-            }
-        }
-        if (result.isEmpty() && !isEmpty()) {
-            result.add(last())
-        }
-        return result
-    }
 }