summaryrefslogtreecommitdiff
path: root/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/TrackersStatisticsUseCase.kt
diff options
context:
space:
mode:
Diffstat (limited to 'app/src/main/java/foundation/e/advancedprivacy/domain/usecases/TrackersStatisticsUseCase.kt')
-rw-r--r--app/src/main/java/foundation/e/advancedprivacy/domain/usecases/TrackersStatisticsUseCase.kt115
1 files changed, 56 insertions, 59 deletions
diff --git a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/TrackersStatisticsUseCase.kt b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/TrackersStatisticsUseCase.kt
index 43e4496..b0c9f39 100644
--- a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/TrackersStatisticsUseCase.kt
+++ b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/TrackersStatisticsUseCase.kt
@@ -22,15 +22,14 @@ import foundation.e.advancedprivacy.R
import foundation.e.advancedprivacy.common.throttleFirst
import foundation.e.advancedprivacy.data.repositories.AppListsRepository
import foundation.e.advancedprivacy.domain.entities.AppWithCounts
+import foundation.e.advancedprivacy.domain.entities.ApplicationDescription
import foundation.e.advancedprivacy.domain.entities.TrackersPeriodicStatistics
-import foundation.e.privacymodules.permissions.data.ApplicationDescription
-import foundation.e.privacymodules.trackers.api.IBlockTrackersPrivacyModule
-import foundation.e.privacymodules.trackers.api.ITrackTrackersPrivacyModule
-import foundation.e.privacymodules.trackers.api.Tracker
+import foundation.e.advancedprivacy.trackers.data.TrackersRepository
+import foundation.e.advancedprivacy.trackers.data.WhitelistRepository
+import foundation.e.advancedprivacy.trackers.domain.entities.Tracker
+import foundation.e.advancedprivacy.trackers.domain.usecases.StatisticsUseCase
import kotlinx.coroutines.FlowPreview
-import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.onStart
@@ -41,8 +40,9 @@ import kotlin.time.Duration
import kotlin.time.Duration.Companion.seconds
class TrackersStatisticsUseCase(
- private val trackTrackersPrivacyModule: ITrackTrackersPrivacyModule,
- private val blockTrackersPrivacyModule: IBlockTrackersPrivacyModule,
+ private val statisticsUseCase: StatisticsUseCase,
+ private val whitelistRepository: WhitelistRepository,
+ private val trackersRepository: TrackersRepository,
private val appListsRepository: AppListsRepository,
private val resources: Resources
) {
@@ -50,54 +50,45 @@ class TrackersStatisticsUseCase(
appListsRepository.apps()
}
- private fun rawUpdates(): Flow<Unit> = callbackFlow {
- val listener = object : ITrackTrackersPrivacyModule.Listener {
- override fun onNewData() {
- trySend(Unit)
- }
- }
- trackTrackersPrivacyModule.addListener(listener)
- awaitClose { trackTrackersPrivacyModule.removeListener(listener) }
- }
-
@OptIn(FlowPreview::class)
- fun listenUpdates(debounce: Duration = 1.seconds) = rawUpdates()
- .throttleFirst(windowDuration = debounce)
- .onStart { emit(Unit) }
+ fun listenUpdates(debounce: Duration = 1.seconds) =
+ statisticsUseCase.newDataAvailable
+ .throttleFirst(windowDuration = debounce)
+ .onStart { emit(Unit) }
fun getDayStatistics(): Pair<TrackersPeriodicStatistics, Int> {
return TrackersPeriodicStatistics(
- callsBlockedNLeaked = trackTrackersPrivacyModule.getPastDayTrackersCalls(),
+ callsBlockedNLeaked = statisticsUseCase.getTrackersCallsOnPeriod(24, ChronoUnit.HOURS),
periods = buildDayLabels(),
- trackersCount = trackTrackersPrivacyModule.getPastDayTrackersCount(),
+ trackersCount = statisticsUseCase.getActiveTrackersByPeriod(24, ChronoUnit.HOURS),
graduations = buildDayGraduations(),
- ) to trackTrackersPrivacyModule.getTrackersCount()
+ ) to statisticsUseCase.getContactedTrackersCount()
}
fun getNonBlockedTrackersCount(): Flow<Int> {
- return if (blockTrackersPrivacyModule.isBlockingEnabled())
+ return if (whitelistRepository.isBlockingEnabled)
appListsRepository.allApps().map { apps ->
val whiteListedTrackers = mutableSetOf<Tracker>()
- val whiteListedApps = blockTrackersPrivacyModule.getWhiteListedApp()
+ val whiteListedApps = whitelistRepository.getWhiteListedApp()
apps.forEach { app ->
if (app in whiteListedApps) {
- whiteListedTrackers.addAll(trackTrackersPrivacyModule.getTrackersForApp(app))
+ whiteListedTrackers.addAll(statisticsUseCase.getTrackers(listOf(app)))
} else {
- whiteListedTrackers.addAll(blockTrackersPrivacyModule.getWhiteList(app))
+ whiteListedTrackers.addAll(getWhiteList(app))
}
}
whiteListedTrackers.size
}
- else flowOf(trackTrackersPrivacyModule.getTrackersCount())
+ else flowOf(statisticsUseCase.getContactedTrackersCount())
}
fun getMostLeakedApp(): ApplicationDescription? {
- return trackTrackersPrivacyModule.getPastDayMostLeakedApp()
+ return statisticsUseCase.getMostLeakedApp(24, ChronoUnit.HOURS)
}
- fun getDayTrackersCalls() = trackTrackersPrivacyModule.getPastDayTrackersCalls()
+ fun getDayTrackersCalls() = statisticsUseCase.getTrackersCallsOnPeriod(24, ChronoUnit.HOURS)
- fun getDayTrackersCount() = trackTrackersPrivacyModule.getPastDayTrackersCount()
+ fun getDayTrackersCount() = statisticsUseCase.getActiveTrackersByPeriod(24, ChronoUnit.HOURS)
private fun buildDayGraduations(): List<String?> {
val formatter = DateTimeFormatter.ofPattern(
@@ -155,25 +146,23 @@ class TrackersStatisticsUseCase(
}
fun getDayMonthYearStatistics(): Triple<TrackersPeriodicStatistics, TrackersPeriodicStatistics, TrackersPeriodicStatistics> {
- return with(trackTrackersPrivacyModule) {
- Triple(
- TrackersPeriodicStatistics(
- callsBlockedNLeaked = getPastDayTrackersCalls(),
- periods = buildDayLabels(),
- trackersCount = getPastDayTrackersCount()
- ),
- TrackersPeriodicStatistics(
- callsBlockedNLeaked = getPastMonthTrackersCalls(),
- periods = buildMonthLabels(),
- trackersCount = getPastMonthTrackersCount()
- ),
- TrackersPeriodicStatistics(
- callsBlockedNLeaked = getPastYearTrackersCalls(),
- periods = buildYearLabels(),
- trackersCount = getPastYearTrackersCount()
- )
+ return Triple(
+ TrackersPeriodicStatistics(
+ callsBlockedNLeaked = statisticsUseCase.getTrackersCallsOnPeriod(24, ChronoUnit.HOURS),
+ periods = buildDayLabels(),
+ trackersCount = statisticsUseCase.getActiveTrackersByPeriod(24, ChronoUnit.HOURS)
+ ),
+ TrackersPeriodicStatistics(
+ callsBlockedNLeaked = statisticsUseCase.getTrackersCallsOnPeriod(30, ChronoUnit.DAYS),
+ periods = buildMonthLabels(),
+ trackersCount = statisticsUseCase.getActiveTrackersByPeriod(30, ChronoUnit.DAYS)
+ ),
+ TrackersPeriodicStatistics(
+ callsBlockedNLeaked = statisticsUseCase.getTrackersCallsOnPeriod(12, ChronoUnit.MONTHS),
+ periods = buildYearLabels(),
+ trackersCount = statisticsUseCase.getActiveTrackersByPeriod(12, ChronoUnit.MONTHS)
)
- }
+ )
}
fun getTrackersWithWhiteList(app: ApplicationDescription): List<Pair<Tracker, Boolean>> {
@@ -181,8 +170,8 @@ class TrackersStatisticsUseCase(
app = app,
map = { appDesc: ApplicationDescription ->
(
- trackTrackersPrivacyModule.getTrackersForApp(appDesc) to
- blockTrackersPrivacyModule.getWhiteList(appDesc)
+ statisticsUseCase.getTrackers(listOf(appDesc)) to
+ getWhiteList(appDesc)
)
},
reduce = { lists ->
@@ -200,7 +189,7 @@ class TrackersStatisticsUseCase(
return appListsRepository.mapReduceForHiddenApps(
app = app,
map = { appDesc: ApplicationDescription ->
- blockTrackersPrivacyModule.getWhiteList(appDesc).isEmpty()
+ getWhiteList(appDesc).isEmpty()
},
reduce = { areEmpty -> areEmpty.all { it } }
)
@@ -209,7 +198,9 @@ class TrackersStatisticsUseCase(
fun getCalls(app: ApplicationDescription): Pair<Int, Int> {
return appListsRepository.mapReduceForHiddenApps(
app = app,
- map = trackTrackersPrivacyModule::getPastDayTrackersCallsForApp,
+ map = {
+ statisticsUseCase.getCalls(it, 24, ChronoUnit.HOURS)
+ },
reduce = { zip ->
zip.unzip().let { (blocked, leaked) ->
blocked.sum() to leaked.sum()
@@ -219,7 +210,7 @@ class TrackersStatisticsUseCase(
}
fun getAppsWithCounts(): Flow<List<AppWithCounts>> {
- val trackersCounts = trackTrackersPrivacyModule.getTrackersCountByApp()
+ val trackersCounts = statisticsUseCase.getContactedTrackersCountByApp()
val hiddenAppsTrackersWithWhiteList =
getTrackersWithWhiteList(appListsRepository.dummySystemApp)
val acAppsTrackersWithWhiteList =
@@ -227,7 +218,7 @@ class TrackersStatisticsUseCase(
return appListsRepository.apps()
.map { apps ->
- val callsByApp = trackTrackersPrivacyModule.getPastDayTrackersCallsByApps()
+ val callsByApp = statisticsUseCase.getCallsByApps(24, ChronoUnit.HOURS)
apps.map { app ->
val calls = appListsRepository.mapReduceForHiddenApps(
app = app,
@@ -241,8 +232,8 @@ class TrackersStatisticsUseCase(
AppWithCounts(
app = app,
- isWhitelisted = !blockTrackersPrivacyModule.isBlockingEnabled() ||
- isWhitelisted(app, appListsRepository, blockTrackersPrivacyModule),
+ isWhitelisted = !whitelistRepository.isBlockingEnabled ||
+ isWhitelisted(app, appListsRepository, whitelistRepository),
trackersCount = when (app) {
appListsRepository.dummySystemApp ->
hiddenAppsTrackersWithWhiteList.size
@@ -256,7 +247,7 @@ class TrackersStatisticsUseCase(
appListsRepository.dummyCompatibilityApp ->
acAppsTrackersWithWhiteList.count { it.second }
else ->
- blockTrackersPrivacyModule.getWhiteList(app).size
+ getWhiteList(app).size
},
blockedLeaks = calls.first,
leaks = calls.second
@@ -266,6 +257,12 @@ class TrackersStatisticsUseCase(
}
}
+ private fun getWhiteList(app: ApplicationDescription): List<Tracker> {
+ return whitelistRepository.getWhiteListForApp(app).mapNotNull {
+ trackersRepository.getTracker(it)
+ }
+ }
+
private val mostLeakedAppsComparator: Comparator<AppWithCounts> = Comparator { o1, o2 ->
val leaks = o2.leaks - o1.leaks
if (leaks != 0) leaks else {
generated by cgit v1.2.1 (git 2.18.0) at 2024-09-19 23:16:30 +0000