1 files changed, 41 insertions, 61 deletions

diff --git a/app/src/main/java/foundation/e/advancedprivacy/features/trackers/apptrackers/AppTrackersViewModel.kt b/app/src/main/java/foundation/e/advancedprivacy/features/trackers/apptrackers/AppTrackersViewModel.kt
index 8740779..00ad365 100644
--- a/app/src/main/java/foundation/e/advancedprivacy/features/trackers/apptrackers/AppTrackersViewModel.kt
+++ b/app/src/main/java/foundation/e/advancedprivacy/features/trackers/apptrackers/AppTrackersViewModel.kt
@@ -24,9 +24,11 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import foundation.e.advancedprivacy.domain.entities.ApplicationDescription
 import foundation.e.advancedprivacy.domain.entities.TrackerMode
+import foundation.e.advancedprivacy.domain.usecases.AppTrackersUseCase
 import foundation.e.advancedprivacy.domain.usecases.GetQuickPrivacyStateUseCase
 import foundation.e.advancedprivacy.domain.usecases.TrackersStateUseCase
 import foundation.e.advancedprivacy.domain.usecases.TrackersStatisticsUseCase
+import foundation.e.advancedprivacy.features.trackers.URL_LEARN_MORE_ABOUT_TRACKERS
 import foundation.e.advancedprivacy.trackers.domain.entities.Tracker
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableSharedFlow
@@ -41,6 +43,7 @@ import kotlinx.coroutines.withContext
 
 class AppTrackersViewModel(
     private val app: ApplicationDescription,
+    private val appTrackersUseCase: AppTrackersUseCase,
     private val trackersStateUseCase: TrackersStateUseCase,
     private val trackersStatisticsUseCase: TrackersStatisticsUseCase,
     private val getQuickPrivacyStateUseCase: GetQuickPrivacyStateUseCase
@@ -56,17 +59,10 @@ class AppTrackersViewModel(
     val singleEvents = _singleEvents.asSharedFlow()
 
     init {
-        viewModelScope.launch(Dispatchers.IO) {
-            _state.update {
-                it.copy(
-                    appDesc = app,
-                    isBlockingActivated = !trackersStateUseCase.isWhitelisted(app),
-                    trackersWithWhiteList = trackersStatisticsUseCase.getTrackersWithWhiteList(
-                        app
-                    ),
-                    isWhitelistEmpty = trackersStatisticsUseCase.isWhiteListEmpty(app)
-                )
-            }
+        _state.update {
+            it.copy(
+                appDesc = app,
+            )
         }
     }
 
@@ -79,80 +75,71 @@ class AppTrackersViewModel(
         ).collect { }
     }
 
-    fun submitAction(action: Action) = viewModelScope.launch {
-        when (action) {
-            is Action.BlockAllToggleAction -> blockAllToggleAction(action)
-            is Action.ToggleTrackerAction -> toggleTrackerAction(action)
-            is Action.ClickTracker -> actionClickTracker(action)
-            is Action.ResetAllTrackers -> resetAllTrackers()
+    fun onClickLearnMore() {
+        viewModelScope.launch {
+            _singleEvents.emit(SingleEvent.OpenUrl(Uri.parse(URL_LEARN_MORE_ABOUT_TRACKERS)))
         }
     }
 
-    private suspend fun blockAllToggleAction(action: Action.BlockAllToggleAction) {
-        withContext(Dispatchers.IO) {
+    fun onToggleBlockAll(isBlocked: Boolean) {
+        viewModelScope.launch(Dispatchers.IO) {
             if (!state.value.isTrackersBlockingEnabled) {
                 _singleEvents.emit(SingleEvent.ToastTrackersControlDisabled)
             }
-            trackersStateUseCase.toggleAppWhitelist(app, !action.isBlocked)
-            _state.update {
-                it.copy(
-                    isBlockingActivated = !trackersStateUseCase.isWhitelisted(app)
-                )
-            }
+            appTrackersUseCase.toggleAppWhitelist(app, isBlocked)
+            updateWhitelist()
         }
     }
 
-    private suspend fun toggleTrackerAction(action: Action.ToggleTrackerAction) {
-        withContext(Dispatchers.IO) {
+    fun onToggleTracker(tracker: Tracker, isBlocked: Boolean) {
+        viewModelScope.launch(Dispatchers.IO) {
             if (!state.value.isTrackersBlockingEnabled) {
                 _singleEvents.emit(SingleEvent.ToastTrackersControlDisabled)
             }
 
-            if (state.value.isBlockingActivated) {
-                trackersStateUseCase.blockTracker(app, action.tracker, action.isBlocked)
-                updateWhitelist()
-            }
+            trackersStateUseCase.blockTracker(app, tracker, isBlocked)
+            updateWhitelist()
         }
     }
 
-    private suspend fun actionClickTracker(action: Action.ClickTracker) {
-        withContext(Dispatchers.IO) {
-            action.tracker.exodusId?.let {
-                try {
-                    _singleEvents.emit(
-                        SingleEvent.OpenUrl(
-                            Uri.parse(exodusBaseUrl + it)
-                        )
-                    )
-                } catch (e: Exception) {
-                }
-            }
+    fun onClickTracker(tracker: Tracker) {
+        viewModelScope.launch(Dispatchers.IO) {
+            tracker.exodusId?.let {
+                runCatching { Uri.parse(exodusBaseUrl + it) }.getOrNull()
+            }?.let { _singleEvents.emit(SingleEvent.OpenUrl(it)) }
         }
     }
 
-    private suspend fun resetAllTrackers() {
-        withContext(Dispatchers.IO) {
-            trackersStateUseCase.clearWhitelist(app)
+    fun onClickResetAllTrackers() {
+        viewModelScope.launch(Dispatchers.IO) {
+            appTrackersUseCase.clearWhitelist(app)
             updateWhitelist()
         }
     }
-    private fun fetchStatistics() {
-        val (blocked, leaked) = trackersStatisticsUseCase.getCalls(app)
-        return _state.update { s ->
+
+    private suspend fun fetchStatistics() = withContext(Dispatchers.IO) {
+        val (blocked, leaked) = appTrackersUseCase.getCalls(app)
+        val trackersWithBlockedList = appTrackersUseCase.getTrackersWithBlockedList(app)
+
+        _state.update { s ->
             s.copy(
-                trackersWithWhiteList = trackersStatisticsUseCase.getTrackersWithWhiteList(app),
                 leaked = leaked,
                 blocked = blocked,
-                isWhitelistEmpty = trackersStatisticsUseCase.isWhiteListEmpty(app)
+                isBlockingActivated = !trackersStateUseCase.isWhitelisted(app),
+                isWhitelistEmpty = trackersStatisticsUseCase.isWhiteListEmpty(app),
+                trackersWithBlockedList = trackersWithBlockedList
             )
         }
     }
 
-    private fun updateWhitelist() {
+    private suspend fun updateWhitelist() = withContext(Dispatchers.IO) {
         _state.update { s ->
             s.copy(
-                trackersWithWhiteList = trackersStatisticsUseCase.getTrackersWithWhiteList(app),
-                isWhitelistEmpty = trackersStatisticsUseCase.isWhiteListEmpty(app)
+                isBlockingActivated = !trackersStateUseCase.isWhitelisted(app),
+                trackersWithBlockedList = appTrackersUseCase.enrichWithBlockedState(
+                    app, s.trackersWithBlockedList.map { it.first }
+                ),
+                isWhitelistEmpty = trackersStatisticsUseCase.isWhiteListEmpty(app),
             )
         }
     }
@@ -162,11 +149,4 @@ class AppTrackersViewModel(
         data class OpenUrl(val url: Uri) : SingleEvent()
         object ToastTrackersControlDisabled : SingleEvent()
     }
-
-    sealed class Action {
-        data class BlockAllToggleAction(val isBlocked: Boolean) : Action()
-        data class ToggleTrackerAction(val tracker: Tracker, val isBlocked: Boolean) : Action()
-        data class ClickTracker(val tracker: Tracker) : Action()
-        object ResetAllTrackers : Action()
-    }
 }