2: organise module with clean archi, use Koin for injection.

8 files changed, 98 insertions, 154 deletions

diff --git a/app/src/main/java/foundation/e/advancedprivacy/domain/entities/AppWithCounts.kt b/app/src/main/java/foundation/e/advancedprivacy/domain/entities/AppWithCounts.kt
index 4169ecc..344e689 100644
--- a/app/src/main/java/foundation/e/advancedprivacy/domain/entities/AppWithCounts.kt
+++ b/app/src/main/java/foundation/e/advancedprivacy/domain/entities/AppWithCounts.kt
@@ -19,7 +19,6 @@
 package foundation.e.advancedprivacy.domain.entities
 
 import android.graphics.drawable.Drawable
-import foundation.e.privacymodules.permissions.data.ApplicationDescription
 
 data class AppWithCounts(
     val appDesc: ApplicationDescription,
diff --git a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/AppListUseCase.kt b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/AppListUseCase.kt
index 8d38ee8..dfd32b6 100644
--- a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/AppListUseCase.kt
+++ b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/AppListUseCase.kt
@@ -18,7 +18,7 @@
 package foundation.e.advancedprivacy.domain.usecases
 
 import foundation.e.advancedprivacy.data.repositories.AppListsRepository
-import foundation.e.privacymodules.permissions.data.ApplicationDescription
+import foundation.e.advancedprivacy.domain.entities.ApplicationDescription
 import kotlinx.coroutines.flow.Flow
 
 class AppListUseCase(
diff --git a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/FakeLocationStateUseCase.kt b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/FakeLocationStateUseCase.kt
index 8831fff..30c8e6b 100644
--- a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/FakeLocationStateUseCase.kt
+++ b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/FakeLocationStateUseCase.kt
@@ -26,12 +26,12 @@ import android.location.LocationListener
 import android.location.LocationManager
 import android.os.Bundle
 import foundation.e.advancedprivacy.data.repositories.LocalStateRepository
+import foundation.e.advancedprivacy.domain.entities.AppOpModes
+import foundation.e.advancedprivacy.domain.entities.ApplicationDescription
 import foundation.e.advancedprivacy.domain.entities.LocationMode
 import foundation.e.advancedprivacy.dummy.CityDataSource
-import foundation.e.privacymodules.fakelocation.IFakeLocationModule
-import foundation.e.privacymodules.permissions.PermissionsPrivacyModule
-import foundation.e.privacymodules.permissions.data.AppOpModes
-import foundation.e.privacymodules.permissions.data.ApplicationDescription
+import foundation.e.advancedprivacy.externalinterfaces.permissions.IPermissionsPrivacyModule
+import foundation.e.advancedprivacy.fakelocation.domain.usecases.FakeLocationModule
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -41,8 +41,8 @@ import timber.log.Timber
 import kotlin.random.Random
 
 class FakeLocationStateUseCase(
-    private val fakeLocationModule: IFakeLocationModule,
-    private val permissionsModule: PermissionsPrivacyModule,
+    private val fakeLocationModule: FakeLocationModule,
+    private val permissionsModule: IPermissionsPrivacyModule,
     private val localStateRepository: LocalStateRepository,
     private val citiesRepository: CityDataSource,
     private val appDesc: ApplicationDescription,
diff --git a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/GetQuickPrivacyStateUseCase.kt b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/GetQuickPrivacyStateUseCase.kt
index b82918e..bc4871a 100644
--- a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/GetQuickPrivacyStateUseCase.kt
+++ b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/GetQuickPrivacyStateUseCase.kt
@@ -18,11 +18,11 @@
 package foundation.e.advancedprivacy.domain.usecases
 
 import foundation.e.advancedprivacy.data.repositories.LocalStateRepository
+import foundation.e.advancedprivacy.domain.entities.ApplicationDescription
 import foundation.e.advancedprivacy.domain.entities.InternetPrivacyMode
 import foundation.e.advancedprivacy.domain.entities.LocationMode
 import foundation.e.advancedprivacy.domain.entities.QuickPrivacyState
 import foundation.e.advancedprivacy.domain.entities.TrackerMode
-import foundation.e.privacymodules.permissions.data.ApplicationDescription
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -30,7 +30,7 @@ import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.map
 
 class GetQuickPrivacyStateUseCase(
-    private val localStateRepository: LocalStateRepository
+    private val localStateRepository: LocalStateRepository,
 ) {
     val quickPrivacyState: Flow<QuickPrivacyState> = combine(
         localStateRepository.blockTrackers,
diff --git a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/IpScramblingStateUseCase.kt b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/IpScramblingStateUseCase.kt
index 70607cf..a7ed660 100644
--- a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/IpScramblingStateUseCase.kt
+++ b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/IpScramblingStateUseCase.kt
@@ -19,14 +19,14 @@ package foundation.e.advancedprivacy.domain.usecases
 
 import foundation.e.advancedprivacy.data.repositories.AppListsRepository
 import foundation.e.advancedprivacy.data.repositories.LocalStateRepository
+import foundation.e.advancedprivacy.domain.entities.ApplicationDescription
 import foundation.e.advancedprivacy.domain.entities.InternetPrivacyMode
 import foundation.e.advancedprivacy.domain.entities.InternetPrivacyMode.HIDE_IP
 import foundation.e.advancedprivacy.domain.entities.InternetPrivacyMode.HIDE_IP_LOADING
 import foundation.e.advancedprivacy.domain.entities.InternetPrivacyMode.REAL_IP
 import foundation.e.advancedprivacy.domain.entities.InternetPrivacyMode.REAL_IP_LOADING
-import foundation.e.privacymodules.ipscrambler.IIpScramblerModule
-import foundation.e.privacymodules.permissions.IPermissionsPrivacyModule
-import foundation.e.privacymodules.permissions.data.ApplicationDescription
+import foundation.e.advancedprivacy.externalinterfaces.permissions.IPermissionsPrivacyModule
+import foundation.e.advancedprivacy.ipscrambler.IpScramblerModule
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.channels.awaitClose
@@ -38,7 +38,7 @@ import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 
 class IpScramblingStateUseCase(
-    private val ipScramblerModule: IIpScramblerModule,
+    private val ipScramblerModule: IpScramblerModule,
     private val permissionsPrivacyModule: IPermissionsPrivacyModule,
     private val appDesc: ApplicationDescription,
     private val localStateRepository: LocalStateRepository,
@@ -46,8 +46,8 @@ class IpScramblingStateUseCase(
     private val coroutineScope: CoroutineScope
 ) {
     val internetPrivacyMode: StateFlow<InternetPrivacyMode> = callbackFlow {
-        val listener = object : IIpScramblerModule.Listener {
-            override fun onStatusChanged(newStatus: IIpScramblerModule.Status) {
+        val listener = object : IpScramblerModule.Listener {
+            override fun onStatusChanged(newStatus: IpScramblerModule.Status) {
                 trySend(map(newStatus))
             }
 
@@ -169,13 +169,13 @@ class IpScramblingStateUseCase(
         }
     }
 
-    private fun map(status: IIpScramblerModule.Status): InternetPrivacyMode {
+    private fun map(status: IpScramblerModule.Status): InternetPrivacyMode {
         return when (status) {
-            IIpScramblerModule.Status.OFF -> REAL_IP
-            IIpScramblerModule.Status.ON -> HIDE_IP
-            IIpScramblerModule.Status.STARTING -> HIDE_IP_LOADING
-            IIpScramblerModule.Status.STOPPING,
-            IIpScramblerModule.Status.START_DISABLED -> REAL_IP_LOADING
+            IpScramblerModule.Status.OFF -> REAL_IP
+            IpScramblerModule.Status.ON -> HIDE_IP
+            IpScramblerModule.Status.STARTING -> HIDE_IP_LOADING
+            IpScramblerModule.Status.STOPPING,
+            IpScramblerModule.Status.START_DISABLED -> REAL_IP_LOADING
         }
     }
 }
diff --git a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/TrackersStateUseCase.kt b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/TrackersStateUseCase.kt
index 882d53f..ed15a41 100644
--- a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/TrackersStateUseCase.kt
+++ b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/TrackersStateUseCase.kt
@@ -19,87 +19,68 @@ package foundation.e.advancedprivacy.domain.usecases
 
 import foundation.e.advancedprivacy.data.repositories.AppListsRepository
 import foundation.e.advancedprivacy.data.repositories.LocalStateRepository
-import foundation.e.advancedprivacy.data.repositories.TrackersRepository
-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.domain.entities.ApplicationDescription
+import foundation.e.advancedprivacy.trackers.data.WhitelistRepository
+import foundation.e.advancedprivacy.trackers.domain.entities.Tracker
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 
 class TrackersStateUseCase(
-    private val blockTrackersPrivacyModule: IBlockTrackersPrivacyModule,
-    private val trackersPrivacyModule: ITrackTrackersPrivacyModule,
+    private val whitelistRepository: WhitelistRepository,
     private val localStateRepository: LocalStateRepository,
-    private val trackersRepository: TrackersRepository,
     private val appListsRepository: AppListsRepository,
-    private val coroutineScope: CoroutineScope
+    coroutineScope: CoroutineScope
 ) {
     init {
-        trackersPrivacyModule.start(
-            trackers = trackersRepository.trackers,
-            getAppByAPId = appListsRepository::getApp,
-            getAppByUid = appListsRepository::getApp,
-            enableNotification = false
-        )
         coroutineScope.launch {
             localStateRepository.blockTrackers.collect { enabled ->
-                if (enabled) {
-                    blockTrackersPrivacyModule.enableBlocking()
-                } else {
-                    blockTrackersPrivacyModule.disableBlocking()
-                }
+                whitelistRepository.isBlockingEnabled = enabled
                 updateAllTrackersBlockedState()
             }
         }
     }
 
     private fun updateAllTrackersBlockedState() {
-        localStateRepository.areAllTrackersBlocked.value = blockTrackersPrivacyModule.isBlockingEnabled() &&
-            blockTrackersPrivacyModule.isWhiteListEmpty()
+        localStateRepository.areAllTrackersBlocked.value = whitelistRepository.isBlockingEnabled &&
+            whitelistRepository.areWhiteListEmpty()
     }
 
     fun isWhitelisted(app: ApplicationDescription): Boolean {
-        return isWhitelisted(app, appListsRepository, blockTrackersPrivacyModule)
+        return isWhitelisted(app, appListsRepository, whitelistRepository)
     }
 
     fun toggleAppWhitelist(app: ApplicationDescription, isWhitelisted: Boolean) {
         appListsRepository.applyForHiddenApps(app) {
-            blockTrackersPrivacyModule.setWhiteListed(it, isWhitelisted)
+            whitelistRepository.setWhiteListed(it.apId, isWhitelisted)
         }
         updateAllTrackersBlockedState()
     }
 
     fun blockTracker(app: ApplicationDescription, tracker: Tracker, isBlocked: Boolean) {
         appListsRepository.applyForHiddenApps(app) {
-            blockTrackersPrivacyModule.setWhiteListed(tracker, it, !isBlocked)
+            whitelistRepository.setWhiteListed(tracker, it.apId, !isBlocked)
         }
         updateAllTrackersBlockedState()
     }
 
     fun clearWhitelist(app: ApplicationDescription) {
         appListsRepository.applyForHiddenApps(
-            app,
-            blockTrackersPrivacyModule::clearWhiteList
-        )
+            app
+        ) {
+            whitelistRepository.clearWhiteList(it.apId)
+        }
         updateAllTrackersBlockedState()
     }
-
-    fun updateTrackers() = coroutineScope.launch {
-        trackersRepository.update()
-        trackersPrivacyModule.start(
-            trackers = trackersRepository.trackers,
-            getAppByAPId = appListsRepository::getApp,
-            getAppByUid = appListsRepository::getApp,
-            enableNotification = false
-        )
-    }
 }
 
 fun isWhitelisted(
     app: ApplicationDescription,
     appListsRepository: AppListsRepository,
-    blockTrackersPrivacyModule: IBlockTrackersPrivacyModule
+    whitelistRepository: WhitelistRepository
+
 ): Boolean {
-    return appListsRepository.anyForHiddenApps(app, blockTrackersPrivacyModule::isWhitelisted)
+    return appListsRepository.anyForHiddenApps(
+        app,
+        whitelistRepository::isAppWhiteListed
+    )
 }
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 {
diff --git a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/UpdateWidgetUseCase.kt b/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/UpdateWidgetUseCase.kt
deleted file mode 100644
index 94c734c..0000000
--- a/app/src/main/java/foundation/e/advancedprivacy/domain/usecases/UpdateWidgetUseCase.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (C) 2022 E FOUNDATION
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package foundation.e.advancedprivacy.domain.usecases
-
-import foundation.e.advancedprivacy.data.repositories.LocalStateRepository
-import foundation.e.privacymodules.trackers.api.ITrackTrackersPrivacyModule
-
-class UpdateWidgetUseCase(
-    private val localStateRepository: LocalStateRepository,
-    private val trackTrackersPrivacyModule: ITrackTrackersPrivacyModule,
-) {
-    init {
-        trackTrackersPrivacyModule.addListener(object : ITrackTrackersPrivacyModule.Listener {
-            override fun onNewData() {
-            }
-        })
-    }
-}