Centralise activate IPScrambling funcitonnality

6 files changed, 127 insertions, 70 deletions

diff --git a/app/src/main/java/foundation/e/privacycentralapp/features/dashboard/DashboardFeature.kt b/app/src/main/java/foundation/e/privacycentralapp/features/dashboard/DashboardFeature.kt
index a461b65..9d439ec 100644
--- a/app/src/main/java/foundation/e/privacycentralapp/features/dashboard/DashboardFeature.kt
+++ b/app/src/main/java/foundation/e/privacycentralapp/features/dashboard/DashboardFeature.kt
@@ -25,8 +25,11 @@ import foundation.e.flowmvi.feature.BaseFeature
 import foundation.e.privacycentralapp.domain.entities.InternetPrivacyMode
 import foundation.e.privacycentralapp.domain.entities.LocationMode
 import foundation.e.privacycentralapp.domain.usecases.GetQuickPrivacyStateUseCase
+import foundation.e.privacycentralapp.domain.usecases.IpScramblingStateUseCase
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.merge
 
 // Define a state machine for Dashboard Feature
 class DashboardFeature(
@@ -70,6 +73,8 @@ class DashboardFeature(
     }
 
     sealed class Action {
+        object InitAction : Action()
+
         object TogglePrivacyAction : Action()
         // object ShowQuickPrivacyProtectionInfoAction : Action()
         // object ObserveDashboardAction : Action()
@@ -81,7 +86,9 @@ class DashboardFeature(
     }
 
     sealed class Effect {
+        object NoEffect : Effect()
         data class UpdateStateEffect(val isEnabled: Boolean) : Effect()
+        data class IpScramblingModeUpdatedEffect(val mode: InternetPrivacyMode) : Effect()
 
         object OpenQuickPrivacyProtectionEffect : Effect()
         data class OpenDashboardEffect(
@@ -110,7 +117,8 @@ class DashboardFeature(
     companion object {
         fun create(
             coroutineScope: CoroutineScope,
-            getPrivacyStateUseCase: GetQuickPrivacyStateUseCase
+            getPrivacyStateUseCase: GetQuickPrivacyStateUseCase,
+            ipScramblingStateUseCase: IpScramblingStateUseCase
         ): DashboardFeature =
             DashboardFeature(
                 initialState = State.DisabledState(),
@@ -138,6 +146,8 @@ class DashboardFeature(
                             )
                             else -> state
                         }
+                        is Effect.IpScramblingModeUpdatedEffect -> if (state is State.EnabledState) state.copy(internetPrivacyMode = effect.mode)
+                        else state
 
                         /*is Effect.OpenDashboardEffect -> State.DashboardState(
                             effect.trackersCount,
@@ -191,13 +201,23 @@ class DashboardFeature(
                     when (action) {
                         Action.TogglePrivacyAction -> {
                             if (state != State.LoadingState) {
-                                flowOf(Effect.UpdateStateEffect(getPrivacyStateUseCase.toggle()))
-                            } else {
-                                flowOf(Effect.UpdateStateEffect(getPrivacyStateUseCase.isQuickPrivacyEnabled))
+                                getPrivacyStateUseCase.toggle()
                             }
+                            flowOf(Effect.NoEffect)
                         }
 
-                        /*Action.ObserveDashboardAction -> merge(
+                        Action.InitAction -> merge(
+                            getPrivacyStateUseCase.quickPrivacyEnabledFlow.map {
+
+                                Effect.UpdateStateEffect(it)
+                            },
+                            ipScramblingStateUseCase.internetPrivacyMode.map {
+                                Effect.IpScramblingModeUpdatedEffect(it)
+                            }
+                        )
+                        /*
+                            Action.ObserveDashboardAction -> {
+                            merge(
                             TrackersDataSource.trackers.map {
                                 var activeTrackersCount: Int = 0
                                 outer@ for (tracker in it) {
diff --git a/app/src/main/java/foundation/e/privacycentralapp/features/dashboard/DashboardFragment.kt b/app/src/main/java/foundation/e/privacycentralapp/features/dashboard/DashboardFragment.kt
index 3e47a18..fade14b 100644
--- a/app/src/main/java/foundation/e/privacycentralapp/features/dashboard/DashboardFragment.kt
+++ b/app/src/main/java/foundation/e/privacycentralapp/features/dashboard/DashboardFragment.kt
@@ -105,10 +105,11 @@ class DashboardFragment :
                 }
             }
         }
-        // lifecycleScope.launchWhenStarted {
-        // viewModel.submitAction(DashboardFeature.Action.ShowDashboardAction)
-        // viewModel.submitAction(DashboardFeature.Action.ObserveDashboardAction)
-        // }
+        lifecycleScope.launchWhenStarted {
+            viewModel.submitAction(DashboardFeature.Action.InitAction)
+            // viewModel.submitAction(DashboardFeature.Action.ShowDashboardAction)
+            // viewModel.submitAction(DashboardFeature.Action.ObserveDashboardAction)
+        }
     }
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
@@ -195,10 +196,18 @@ class DashboardFragment :
         )
 
         val ipAddressEnabled = state is EnabledState && state.internetPrivacyMode != InternetPrivacyMode.REAL_IP
+        val isLoading = state is EnabledState && state.internetPrivacyMode in listOf(
+            InternetPrivacyMode.HIDE_IP_LOADING,
+            InternetPrivacyMode.REAL_IP_LOADING
+        )
         binding.stateIpAddress.text = getString(
             if (ipAddressEnabled) R.string.dashboard_state_ipaddress_on
             else R.string.dashboard_state_ipaddress_off
         )
+
+        binding.stateIpAddressLoader.visibility = if (isLoading) View.VISIBLE else View.GONE
+        binding.stateIpAddress.visibility = if (!isLoading) View.VISIBLE else View.GONE
+
         binding.stateIpAddress.setTextColor(
             getColor(
                 requireContext(),
@@ -233,11 +242,11 @@ class DashboardFragment :
         )
 
         binding.internetActivityPrivacy.subtitle.text = getString(
-            if (state is DashboardFeature.State.EnabledState &&
+            if (state is EnabledState &&
                 state.internetPrivacyMode != InternetPrivacyMode.REAL_IP
             )
                 R.string.dashboard_internet_activity_privacy_subtitle_on
-            else R.string.dashboard_internet_activity_privacy_subtitle_on
+            else R.string.dashboard_internet_activity_privacy_subtitle_off
         )
     }
 
diff --git a/app/src/main/java/foundation/e/privacycentralapp/features/dashboard/DashboardViewModel.kt b/app/src/main/java/foundation/e/privacycentralapp/features/dashboard/DashboardViewModel.kt
index c25f215..67801eb 100644
--- a/app/src/main/java/foundation/e/privacycentralapp/features/dashboard/DashboardViewModel.kt
+++ b/app/src/main/java/foundation/e/privacycentralapp/features/dashboard/DashboardViewModel.kt
@@ -21,12 +21,14 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import foundation.e.privacycentralapp.common.Factory
 import foundation.e.privacycentralapp.domain.usecases.GetQuickPrivacyStateUseCase
+import foundation.e.privacycentralapp.domain.usecases.IpScramblingStateUseCase
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.launch
 
 class DashboardViewModel(
-    private val getPrivacyStateUseCase: GetQuickPrivacyStateUseCase
+    private val getPrivacyStateUseCase: GetQuickPrivacyStateUseCase,
+    private val ipScramblingStateUseCase: IpScramblingStateUseCase
 ) : ViewModel() {
 
     private val _actions = MutableSharedFlow<DashboardFeature.Action>()
@@ -35,7 +37,8 @@ class DashboardViewModel(
     val dashboardFeature: DashboardFeature by lazy {
         DashboardFeature.create(
             coroutineScope = viewModelScope,
-            getPrivacyStateUseCase = getPrivacyStateUseCase
+            getPrivacyStateUseCase = getPrivacyStateUseCase,
+            ipScramblingStateUseCase = ipScramblingStateUseCase
         )
     }
 
@@ -47,9 +50,10 @@ class DashboardViewModel(
 }
 
 class DashBoardViewModelFactory(
-    private val getPrivacyStateUseCase: GetQuickPrivacyStateUseCase
+    private val getPrivacyStateUseCase: GetQuickPrivacyStateUseCase,
+    private val ipScramblingStateUseCase: IpScramblingStateUseCase
 ) : Factory<DashboardViewModel> {
     override fun create(): DashboardViewModel {
-        return DashboardViewModel(getPrivacyStateUseCase)
+        return DashboardViewModel(getPrivacyStateUseCase, ipScramblingStateUseCase)
     }
 }
diff --git a/app/src/main/java/foundation/e/privacycentralapp/features/internetprivacy/InternetPrivacyFeature.kt b/app/src/main/java/foundation/e/privacycentralapp/features/internetprivacy/InternetPrivacyFeature.kt
index cbe0a04..d8254b8 100644
--- a/app/src/main/java/foundation/e/privacycentralapp/features/internetprivacy/InternetPrivacyFeature.kt
+++ b/app/src/main/java/foundation/e/privacycentralapp/features/internetprivacy/InternetPrivacyFeature.kt
@@ -25,16 +25,18 @@ import foundation.e.flowmvi.Actor
 import foundation.e.flowmvi.Reducer
 import foundation.e.flowmvi.SingleEventProducer
 import foundation.e.flowmvi.feature.BaseFeature
+import foundation.e.privacycentralapp.domain.entities.InternetPrivacyMode
+import foundation.e.privacycentralapp.domain.usecases.GetQuickPrivacyStateUseCase
+import foundation.e.privacycentralapp.domain.usecases.IpScramblingStateUseCase
 import foundation.e.privacymodules.ipscramblermodule.IIpScramblerModule
 import foundation.e.privacymodules.permissions.PermissionsPrivacyModule
 import foundation.e.privacymodules.permissions.data.ApplicationDescription
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.channels.awaitClose
-import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.merge
 
 // Define a state machine for Internet privacy feature
@@ -53,11 +55,12 @@ class InternetPrivacyFeature(
     singleEventProducer
 ) {
     data class State(
-        val mode: IIpScramblerModule.Status,
+        val mode: InternetPrivacyMode,
         val availableApps: List<ApplicationDescription>,
         val ipScrambledApps: Collection<String>,
         val selectedLocation: String,
-        val availableLocationIds: List<String>
+        val availableLocationIds: List<String>,
+        val forceRedraw: Boolean = false
     ) {
 
         val isAllAppsScrambled get() = ipScrambledApps.isEmpty()
@@ -93,8 +96,10 @@ class InternetPrivacyFeature(
     }
 
     sealed class Effect {
-        data class ModeUpdatedEffect(val mode: IIpScramblerModule.Status) : Effect()
         object NoEffect : Effect()
+        data class ModeUpdatedEffect(val mode: InternetPrivacyMode) : Effect()
+        data class QuickPrivacyUpdatedEffect(val enabled: Boolean) : Effect()
+        object QuickPrivacyDisabledWarningEffect : Effect()
         data class ShowAndroidVpnDisclaimerEffect(val intent: Intent) : Effect()
         data class IpScrambledAppsUpdatedEffect(val ipScrambledApps: Collection<String>) : Effect()
         data class AvailableAppsListEffect(val apps: List<ApplicationDescription>) : Effect()
@@ -106,7 +111,7 @@ class InternetPrivacyFeature(
     companion object {
         fun create(
             initialState: State = State(
-                IIpScramblerModule.Status.STOPPING,
+                mode = InternetPrivacyMode.REAL_IP,
                 availableApps = emptyList(),
                 ipScrambledApps = emptyList(),
                 availableLocationIds = emptyList(),
@@ -114,7 +119,9 @@ class InternetPrivacyFeature(
             ),
             coroutineScope: CoroutineScope,
             ipScramblerModule: IIpScramblerModule,
-            permissionsModule: PermissionsPrivacyModule
+            permissionsModule: PermissionsPrivacyModule,
+            getQuickPrivacyStateUseCase: GetQuickPrivacyStateUseCase,
+            ipScramblingStateUseCase: IpScramblingStateUseCase
         ) = InternetPrivacyFeature(
             initialState, coroutineScope,
             reducer = { state, effect ->
@@ -124,25 +131,15 @@ class InternetPrivacyFeature(
                     is Effect.AvailableAppsListEffect -> state.copy(availableApps = effect.apps)
                     is Effect.AvailableCountriesEffect -> state.copy(availableLocationIds = effect.availableLocationsIds)
                     is Effect.LocationSelectedEffect -> state.copy(selectedLocation = effect.locationId)
+                    Effect.QuickPrivacyDisabledWarningEffect -> state.copy(forceRedraw = !state.forceRedraw)
                     else -> state
                 }
             },
             actor = { state, action ->
                 when {
                     action is Action.LoadInternetModeAction -> merge(
-                        callbackFlow {
-                            val listener = object : IIpScramblerModule.Listener {
-                                override fun onStatusChanged(newStatus: IIpScramblerModule.Status) {
-                                    offer(Effect.ModeUpdatedEffect(newStatus))
-                                }
-
-                                override fun log(message: String) {}
-                                override fun onTrafficUpdate(upload: Long, download: Long, read: Long, write: Long) {}
-                            }
-                            ipScramblerModule.addListener(listener)
-                            ipScramblerModule.requestStatus()
-                            awaitClose { ipScramblerModule.removeListener(listener) }
-                        },
+                        getQuickPrivacyStateUseCase.quickPrivacyEnabledFlow.map { Effect.QuickPrivacyUpdatedEffect(it) },
+                        ipScramblingStateUseCase.internetPrivacyMode.map { Effect.ModeUpdatedEffect(it) },
                         flow {
                             // TODO: filter deactivated apps"
                             val apps = permissionsModule.getInstalledApplications()
@@ -179,12 +176,12 @@ class InternetPrivacyFeature(
                     action is Action.AndroidVpnActivityResultAction ->
                         if (action.resultCode == Activity.RESULT_OK) {
                             if (state.mode in listOf(
-                                    IIpScramblerModule.Status.OFF,
-                                    IIpScramblerModule.Status.STOPPING
+                                    InternetPrivacyMode.REAL_IP,
+                                    InternetPrivacyMode.REAL_IP_LOADING
                                 )
                             ) {
-                                ipScramblerModule.start()
-                                flowOf(Effect.ModeUpdatedEffect(IIpScramblerModule.Status.STARTING))
+                                ipScramblingStateUseCase.toggle(hideIp = true)
+                                flowOf(Effect.ModeUpdatedEffect(InternetPrivacyMode.HIDE_IP_LOADING))
                             } else {
                                 flowOf(Effect.ErrorEffect("Vpn already started"))
                             }
@@ -193,23 +190,30 @@ class InternetPrivacyFeature(
                         }
 
                     action is Action.UseRealIPAction && state.mode in listOf(
-                        IIpScramblerModule.Status.ON,
-                        IIpScramblerModule.Status.STARTING,
-                        IIpScramblerModule.Status.STOPPING
+                        InternetPrivacyMode.HIDE_IP,
+                        InternetPrivacyMode.HIDE_IP_LOADING,
+                        InternetPrivacyMode.REAL_IP_LOADING
                     ) -> {
-                        ipScramblerModule.stop()
-                        flowOf(Effect.ModeUpdatedEffect(IIpScramblerModule.Status.STOPPING))
+                        if (getQuickPrivacyStateUseCase.isQuickPrivacyEnabled) {
+                            ipScramblingStateUseCase.toggle(hideIp = false)
+                            flowOf(Effect.ModeUpdatedEffect(InternetPrivacyMode.REAL_IP_LOADING))
+                        } else {
+                            flowOf(Effect.QuickPrivacyDisabledWarningEffect)
+                        }
                     }
                     action is Action.UseHiddenIPAction
                         && state.mode in listOf(
-                            IIpScramblerModule.Status.OFF,
-                            IIpScramblerModule.Status.STOPPING
+                            InternetPrivacyMode.REAL_IP,
+                            InternetPrivacyMode.REAL_IP_LOADING
                         ) -> {
-                        ipScramblerModule.prepareAndroidVpn()?.let {
-                            flowOf(Effect.ShowAndroidVpnDisclaimerEffect(it))
-                        } ?: run {
-                            ipScramblerModule.start()
-                            flowOf(Effect.ModeUpdatedEffect(IIpScramblerModule.Status.STARTING))
+                        if (getQuickPrivacyStateUseCase.isQuickPrivacyEnabled) {
+                            ipScramblingStateUseCase.toggle(hideIp = true)?.let {
+                                flowOf(Effect.ShowAndroidVpnDisclaimerEffect(it))
+                            } ?: run {
+                                flowOf(Effect.ModeUpdatedEffect(InternetPrivacyMode.HIDE_IP_LOADING))
+                            }
+                        } else {
+                            flowOf(Effect.QuickPrivacyDisabledWarningEffect)
                         }
                     }
 
@@ -235,6 +239,7 @@ class InternetPrivacyFeature(
             singleEventProducer = { _, action, effect ->
                 when {
                     effect is Effect.ErrorEffect -> SingleEvent.ErrorEvent(effect.message)
+                    effect == Effect.QuickPrivacyDisabledWarningEffect -> SingleEvent.ErrorEvent("Enabled Quick Privacy to use functionalities")
 
                     action is Action.UseHiddenIPAction
                         && effect is Effect.ShowAndroidVpnDisclaimerEffect ->
diff --git a/app/src/main/java/foundation/e/privacycentralapp/features/internetprivacy/InternetPrivacyFragment.kt b/app/src/main/java/foundation/e/privacycentralapp/features/internetprivacy/InternetPrivacyFragment.kt
index c2be7b1..3799349 100644
--- a/app/src/main/java/foundation/e/privacycentralapp/features/internetprivacy/InternetPrivacyFragment.kt
+++ b/app/src/main/java/foundation/e/privacycentralapp/features/internetprivacy/InternetPrivacyFragment.kt
@@ -18,6 +18,7 @@
 package foundation.e.privacycentralapp.features.internetprivacy
 
 import android.os.Bundle
+import android.util.Log
 import android.view.View
 import android.widget.AdapterView
 import android.widget.ArrayAdapter
@@ -35,16 +36,17 @@ import foundation.e.flowmvi.MVIView
 import foundation.e.privacycentralapp.DependencyContainer
 import foundation.e.privacycentralapp.PrivacyCentralApplication
 import foundation.e.privacycentralapp.R
+import foundation.e.privacycentralapp.common.NavToolbarFragment
 import foundation.e.privacycentralapp.common.ToggleAppsAdapter
-import foundation.e.privacycentralapp.common.ToolbarFragment
+import foundation.e.privacycentralapp.databinding.FragmentInternetActivityPolicyBinding
+import foundation.e.privacycentralapp.domain.entities.InternetPrivacyMode
 import foundation.e.privacycentralapp.extensions.viewModelProviderFactoryOf
-import foundation.e.privacymodules.ipscramblermodule.IIpScramblerModule
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.collect
 import java.util.Locale
 
 class InternetPrivacyFragment :
-    ToolbarFragment(R.layout.fragment_internet_activity_policy),
+    NavToolbarFragment(R.layout.fragment_internet_activity_policy),
     MVIView<InternetPrivacyFeature.State, InternetPrivacyFeature.Action> {
 
     private val dependencyContainer: DependencyContainer by lazy {
@@ -55,6 +57,8 @@ class InternetPrivacyFragment :
         viewModelProviderFactoryOf { dependencyContainer.internetPrivacyViewModelFactory.create() }
     }
 
+    private lateinit var binding: FragmentInternetActivityPolicyBinding
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         lifecycleScope.launchWhenStarted {
@@ -63,9 +67,15 @@ class InternetPrivacyFragment :
         lifecycleScope.launchWhenStarted {
             viewModel.internetPrivacyFeature.singleEvents.collect { event ->
                 when (event) {
-                    is InternetPrivacyFeature.SingleEvent.ErrorEvent -> displayToast(event.error)
-                    is InternetPrivacyFeature.SingleEvent.StartAndroidVpnActivityEvent ->
+                    is InternetPrivacyFeature.SingleEvent.ErrorEvent -> {
+                        displayToast(event.error)
+                        viewModel
+                    }
+                    is InternetPrivacyFeature.SingleEvent.StartAndroidVpnActivityEvent -> {
+                        Log.d("TestsVPN", event.intent.toString())
+                        Log.d("TestsVPN", event.intent.action.toString())
                         launchAndroidVpnDisclaimer.launch(event.intent)
+                    }
                     InternetPrivacyFeature.SingleEvent.HiddenIPSelectedEvent -> displayToast("Your IP is hidden")
                     InternetPrivacyFeature.SingleEvent.RealIPSelectedEvent -> displayToast("Your IP is visible to internet")
                 }
@@ -87,6 +97,7 @@ class InternetPrivacyFragment :
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
+        binding = FragmentInternetActivityPolicyBinding.bind(view)
 
         listOf(R.id.recycler_view_scrambled, R.id.recycler_view_to_select).forEach { viewId ->
             view.findViewById<RecyclerView>(viewId)?.apply {
@@ -125,26 +136,26 @@ class InternetPrivacyFragment :
         view?.let {
             it.findViewById<RadioButton>(R.id.radio_use_hidden_ip).apply {
                 isChecked = state.mode in listOf(
-                    IIpScramblerModule.Status.ON,
-                    IIpScramblerModule.Status.STARTING
+                    InternetPrivacyMode.HIDE_IP,
+                    InternetPrivacyMode.HIDE_IP_LOADING
                 )
-                isEnabled = state.mode != IIpScramblerModule.Status.STARTING
+                isEnabled = state.mode != InternetPrivacyMode.HIDE_IP_LOADING
             }
             it.findViewById<RadioButton>(R.id.radio_use_real_ip)?.apply {
                 isChecked =
                     state.mode in listOf(
-                    IIpScramblerModule.Status.OFF,
-                    IIpScramblerModule.Status.STOPPING
+                    InternetPrivacyMode.REAL_IP,
+                    InternetPrivacyMode.REAL_IP_LOADING
                 )
-                isEnabled = state.mode != IIpScramblerModule.Status.STOPPING
+                isEnabled = state.mode != InternetPrivacyMode.REAL_IP_LOADING
             }
             it.findViewById<TextView>(R.id.ipscrambling_tor_status)?.apply {
                 when (state.mode) {
-                    IIpScramblerModule.Status.STARTING -> {
+                    InternetPrivacyMode.HIDE_IP_LOADING -> {
                         text = getString(R.string.ipscrambling_is_starting)
                         visibility = View.VISIBLE
                     }
-                    IIpScramblerModule.Status.STOPPING -> {
+                    InternetPrivacyMode.REAL_IP_LOADING -> {
                         text = getString(R.string.ipscrambling_is_stopping)
                         visibility = View.VISIBLE
                     }
@@ -205,8 +216,8 @@ class InternetPrivacyFragment :
 
             when {
                 state.mode in listOf(
-                    IIpScramblerModule.Status.STARTING,
-                    IIpScramblerModule.Status.STOPPING
+                    InternetPrivacyMode.HIDE_IP_LOADING,
+                    InternetPrivacyMode.REAL_IP_LOADING
                 )
                     || state.availableApps.isEmpty() -> {
                     progressBar?.visibility = View.VISIBLE
diff --git a/app/src/main/java/foundation/e/privacycentralapp/features/internetprivacy/InternetPrivacyViewModel.kt b/app/src/main/java/foundation/e/privacycentralapp/features/internetprivacy/InternetPrivacyViewModel.kt
index a6455ee..6f3c200 100644
--- a/app/src/main/java/foundation/e/privacycentralapp/features/internetprivacy/InternetPrivacyViewModel.kt
+++ b/app/src/main/java/foundation/e/privacycentralapp/features/internetprivacy/InternetPrivacyViewModel.kt
@@ -20,6 +20,8 @@ package foundation.e.privacycentralapp.features.internetprivacy
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import foundation.e.privacycentralapp.common.Factory
+import foundation.e.privacycentralapp.domain.usecases.GetQuickPrivacyStateUseCase
+import foundation.e.privacycentralapp.domain.usecases.IpScramblingStateUseCase
 import foundation.e.privacymodules.ipscramblermodule.IIpScramblerModule
 import foundation.e.privacymodules.permissions.PermissionsPrivacyModule
 import kotlinx.coroutines.flow.MutableSharedFlow
@@ -28,7 +30,9 @@ import kotlinx.coroutines.launch
 
 class InternetPrivacyViewModel(
     private val ipScramblerModule: IIpScramblerModule,
-    private val permissionsModule: PermissionsPrivacyModule
+    private val permissionsModule: PermissionsPrivacyModule,
+    private val getQuickPrivacyStateUseCase: GetQuickPrivacyStateUseCase,
+    private val ipScramblingStateUseCase: IpScramblingStateUseCase
 ) : ViewModel() {
 
     private val _actions = MutableSharedFlow<InternetPrivacyFeature.Action>()
@@ -38,7 +42,9 @@ class InternetPrivacyViewModel(
         InternetPrivacyFeature.create(
             coroutineScope = viewModelScope,
             ipScramblerModule = ipScramblerModule,
-            permissionsModule = permissionsModule
+            permissionsModule = permissionsModule,
+            getQuickPrivacyStateUseCase = getQuickPrivacyStateUseCase,
+            ipScramblingStateUseCase = ipScramblingStateUseCase
         )
     }
 
@@ -51,10 +57,12 @@ class InternetPrivacyViewModel(
 
 class InternetPrivacyViewModelFactory(
     private val ipScramblerModule: IIpScramblerModule,
-    private val permissionsModule: PermissionsPrivacyModule
+    private val permissionsModule: PermissionsPrivacyModule,
+    private val getQuickPrivacyStateUseCase: GetQuickPrivacyStateUseCase,
+    private val ipScramblingStateUseCase: IpScramblingStateUseCase
 ) :
     Factory<InternetPrivacyViewModel> {
     override fun create(): InternetPrivacyViewModel {
-        return InternetPrivacyViewModel(ipScramblerModule, permissionsModule)
+        return InternetPrivacyViewModel(ipScramblerModule, permissionsModule, getQuickPrivacyStateUseCase, ipScramblingStateUseCase)
     }
 }