Centralise activate IPScrambling funcitonnality

12 files changed, 272 insertions, 83 deletions

diff --git a/app/src/main/java/foundation/e/privacycentralapp/DependencyContainer.kt b/app/src/main/java/foundation/e/privacycentralapp/DependencyContainer.kt
index 17967db..094ec3e 100644
--- a/app/src/main/java/foundation/e/privacycentralapp/DependencyContainer.kt
+++ b/app/src/main/java/foundation/e/privacycentralapp/DependencyContainer.kt
@@ -22,6 +22,7 @@ import android.content.Context
 import android.os.Process
 import foundation.e.privacycentralapp.data.repositories.LocalStateRepository
 import foundation.e.privacycentralapp.domain.usecases.GetQuickPrivacyStateUseCase
+import foundation.e.privacycentralapp.domain.usecases.IpScramblingStateUseCase
 import foundation.e.privacycentralapp.features.dashboard.DashBoardViewModelFactory
 import foundation.e.privacycentralapp.features.internetprivacy.InternetPrivacyViewModelFactory
 import foundation.e.privacycentralapp.features.location.FakeLocationViewModelFactory
@@ -32,6 +33,7 @@ import foundation.e.privacymodules.location.FakeLocation
 import foundation.e.privacymodules.location.IFakeLocation
 import foundation.e.privacymodules.permissions.PermissionsPrivacyModule
 import foundation.e.privacymodules.permissions.data.ApplicationDescription
+import kotlinx.coroutines.GlobalScope
 import lineageos.blockers.BlockerInterface
 
 /**
@@ -68,9 +70,12 @@ class DependencyContainer constructor(val app: Application) {
     private val getQuickPrivacyStateUseCase by lazy {
         GetQuickPrivacyStateUseCase(localStateRepository)
     }
+    private val ipScramblingStateUseCase by lazy {
+        IpScramblingStateUseCase(ipScramblerModule, localStateRepository, GlobalScope)
+    }
 
     val dashBoardViewModelFactory by lazy {
-        DashBoardViewModelFactory(getQuickPrivacyStateUseCase)
+        DashBoardViewModelFactory(getQuickPrivacyStateUseCase, ipScramblingStateUseCase)
     }
 
     val fakeLocationViewModelFactory by lazy {
@@ -80,6 +85,6 @@ class DependencyContainer constructor(val app: Application) {
     val blockerService = BlockerInterface.getInstance(context)
 
     val internetPrivacyViewModelFactory by lazy {
-        InternetPrivacyViewModelFactory(ipScramblerModule, permissionsModule)
+        InternetPrivacyViewModelFactory(ipScramblerModule, permissionsModule, getQuickPrivacyStateUseCase, ipScramblingStateUseCase)
     }
 }
diff --git a/app/src/main/java/foundation/e/privacycentralapp/data/repositories/LocalStateRepository.kt b/app/src/main/java/foundation/e/privacycentralapp/data/repositories/LocalStateRepository.kt
index 3cabae7..5f22c96 100644
--- a/app/src/main/java/foundation/e/privacycentralapp/data/repositories/LocalStateRepository.kt
+++ b/app/src/main/java/foundation/e/privacycentralapp/data/repositories/LocalStateRepository.kt
@@ -18,18 +18,31 @@
 package foundation.e.privacycentralapp.data.repositories
 
 import android.content.Context
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
 
 class LocalStateRepository(context: Context) {
     companion object {
         private const val SHARED_PREFS_FILE = "localState"
         private const val KEY_QUICK_PRIVACY = "quickPrivacy"
+        private const val KEY_IP_SCRAMBLING = "ipScrambling"
     }
 
-    val sharedPref = context.getSharedPreferences(SHARED_PREFS_FILE, Context.MODE_PRIVATE)
+    private val sharedPref = context.getSharedPreferences(SHARED_PREFS_FILE, Context.MODE_PRIVATE)
 
+    private val quickPrivacyEnabledMutableFlow = MutableStateFlow<Boolean>(sharedPref.getBoolean(KEY_QUICK_PRIVACY, false))
     var isQuickPrivacyEnabled: Boolean
-        get() = sharedPref.getBoolean(KEY_QUICK_PRIVACY, false)
-        set(value) = set(KEY_QUICK_PRIVACY, value)
+        get() = quickPrivacyEnabledMutableFlow.value
+        set(value) {
+            set(KEY_QUICK_PRIVACY, value)
+            quickPrivacyEnabledMutableFlow.value = value
+        }
+
+    var quickPrivacyEnabledFlow: Flow<Boolean> = quickPrivacyEnabledMutableFlow
+
+    var isIpScramblingEnabled: Boolean
+        get() = sharedPref.getBoolean(KEY_IP_SCRAMBLING, false)
+        set(value) = set(KEY_IP_SCRAMBLING, value)
 
     private fun set(key: String, value: Boolean) {
         sharedPref.edit().putBoolean(key, value).commit()
diff --git a/app/src/main/java/foundation/e/privacycentralapp/domain/entities/InternetPrivacyMode.kt b/app/src/main/java/foundation/e/privacycentralapp/domain/entities/InternetPrivacyMode.kt
index 879c435..534bb2f 100644
--- a/app/src/main/java/foundation/e/privacycentralapp/domain/entities/InternetPrivacyMode.kt
+++ b/app/src/main/java/foundation/e/privacycentralapp/domain/entities/InternetPrivacyMode.kt
@@ -18,5 +18,8 @@
 package foundation.e.privacycentralapp.domain.entities
 
 enum class InternetPrivacyMode {
-    REAL_IP, HIDE_IP
+    REAL_IP,
+    HIDE_IP,
+    HIDE_IP_LOADING,
+    REAL_IP_LOADING
 }
diff --git a/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/GetQuickPrivacyStateUseCase.kt b/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/GetQuickPrivacyStateUseCase.kt
index 20ac0d9..db6f312 100644
--- a/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/GetQuickPrivacyStateUseCase.kt
+++ b/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/GetQuickPrivacyStateUseCase.kt
@@ -20,7 +20,8 @@ package foundation.e.privacycentralapp.domain.usecases
 import foundation.e.privacycentralapp.data.repositories.LocalStateRepository
 
 class GetQuickPrivacyStateUseCase(private val localStateRepository: LocalStateRepository) {
-    val isQuickPrivacyEnabled = localStateRepository.isQuickPrivacyEnabled
+    val quickPrivacyEnabledFlow = localStateRepository.quickPrivacyEnabledFlow
+    val isQuickPrivacyEnabled get() = localStateRepository.isQuickPrivacyEnabled
 
     fun toggle(): Boolean {
         val newState = !localStateRepository.isQuickPrivacyEnabled
diff --git a/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/IpScramblingStateUseCase.kt b/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/IpScramblingStateUseCase.kt
new file mode 100644
index 0000000..a6bf50b
--- /dev/null
+++ b/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/IpScramblingStateUseCase.kt
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2021 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.privacycentralapp.domain.usecases
+
+import android.content.Intent
+import android.util.Log
+import foundation.e.privacycentralapp.data.repositories.LocalStateRepository
+import foundation.e.privacycentralapp.domain.entities.InternetPrivacyMode
+import foundation.e.privacymodules.ipscramblermodule.IIpScramblerModule
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+
+class IpScramblingStateUseCase(
+    private val ipScramblerModule: IIpScramblerModule,
+    private val localStateRepository: LocalStateRepository,
+    private val coroutineScope: CoroutineScope
+) {
+
+    // private val internetPrivacyModeMutableFlow = MutableStateFlow(InternetPrivacyMode.REAL_IP)
+    val internetPrivacyMode: StateFlow<InternetPrivacyMode> = callbackFlow {
+        val listener = object : IIpScramblerModule.Listener {
+            override fun onStatusChanged(newStatus: IIpScramblerModule.Status) {
+                offer(map(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) }
+    }.stateIn(
+        scope = coroutineScope,
+        started = SharingStarted.Eagerly,
+        initialValue = InternetPrivacyMode.REAL_IP
+    )
+
+    init {
+        coroutineScope.launch {
+            localStateRepository.quickPrivacyEnabledFlow.collect {
+                Log.d("testQPFlow", "QuickPrivacy enabled: $it")
+                applySettings(it, localStateRepository.isIpScramblingEnabled)
+            }
+        }
+    }
+
+    fun toggle(hideIp: Boolean): Intent? {
+        if (!localStateRepository.isQuickPrivacyEnabled) return null
+
+        localStateRepository.isIpScramblingEnabled = hideIp
+        return applySettings(true, hideIp)
+    }
+
+    private fun applySettings(isQuickPrivacyEnabled: Boolean, isIpScramblingEnabled: Boolean): Intent? {
+        when {
+            isQuickPrivacyEnabled && isIpScramblingEnabled -> when (internetPrivacyMode.value) {
+                InternetPrivacyMode.REAL_IP, InternetPrivacyMode.REAL_IP_LOADING -> {
+                    val intent = ipScramblerModule.prepareAndroidVpn()
+                    if (intent != null) {
+                        return intent
+                    } else {
+                        ipScramblerModule.start()
+                    }
+                }
+                else -> {
+                    Log.d("testQPFlow", "Not starting tor, already in started state")
+                }
+            }
+            else -> when (internetPrivacyMode.value) {
+                InternetPrivacyMode.HIDE_IP, InternetPrivacyMode.HIDE_IP_LOADING -> ipScramblerModule.stop()
+
+                else -> {
+                    Log.d("testQPFlow", "Not stoping tor, already in stop or stoping state")
+                }
+            }
+        }
+        return null
+    }
+
+    private fun map(status: IIpScramblerModule.Status): InternetPrivacyMode {
+        return when (status) {
+            IIpScramblerModule.Status.OFF -> InternetPrivacyMode.REAL_IP
+            IIpScramblerModule.Status.ON -> InternetPrivacyMode.HIDE_IP
+            IIpScramblerModule.Status.STARTING -> InternetPrivacyMode.HIDE_IP_LOADING
+            IIpScramblerModule.Status.STOPPING,
+            IIpScramblerModule.Status.START_DISABLED -> InternetPrivacyMode.REAL_IP_LOADING
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/privacycentralapp/dummy/Extensions.kt b/app/src/main/java/foundation/e/privacycentralapp/dummy/Extensions.kt
index 91a52ca..04ee5bf 100644
--- a/app/src/main/java/foundation/e/privacycentralapp/dummy/Extensions.kt
+++ b/app/src/main/java/foundation/e/privacycentralapp/dummy/Extensions.kt
@@ -19,7 +19,6 @@ package foundation.e.privacycentralapp.dummy
 
 import android.content.Context
 import foundation.e.privacycentralapp.R
-import foundation.e.privacycentralapp.domain.entities.InternetPrivacyMode
 import foundation.e.privacycentralapp.domain.entities.LocationMode
 
 fun LocationMode.mapToString(context: Context): String = when (this) {
@@ -27,8 +26,3 @@ fun LocationMode.mapToString(context: Context): String = when (this) {
     LocationMode.RANDOM_LOCATION -> context.getString(R.string.random_location_mode)
     LocationMode.CUSTOM_LOCATION -> context.getString(R.string.fake_location_mode)
 }
-
-fun InternetPrivacyMode.mapToString(context: Context): String = when (this) {
-    InternetPrivacyMode.REAL_IP -> context.getString(R.string.i_am_exposing)
-    InternetPrivacyMode.HIDE_IP -> context.getString(R.string.i_am_anonymous)
-}
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)
     }
 }