Implemented route mode

1 files changed, 158 insertions, 53 deletions

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 114b5ca..27a2104 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
@@ -34,6 +34,7 @@ import foundation.e.advancedprivacy.dummy.CityDataSource
 import foundation.e.advancedprivacy.externalinterfaces.permissions.IPermissionsPrivacyModule
 import foundation.e.advancedprivacy.fakelocation.domain.usecases.FakeLocationModule
 import foundation.e.advancedprivacy.features.location.FakeLocationState
+import foundation.e.advancedprivacy.domain.entities.FakeLocationCoordinate
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -52,15 +53,22 @@ class FakeLocationStateUseCase(
     coroutineScope: CoroutineScope
 ) {
     private val _configuredLocationMode = MutableStateFlow<FakeLocationState>(
-        FakeLocationState(LocationMode.REAL_LOCATION, null, null, null, null, false, null, null, false)
+        FakeLocationState(LocationMode.REAL_LOCATION, null, null, null, null, null, null, false, null, false, false)
     )
 
     val configuredLocationMode: StateFlow<FakeLocationState> = _configuredLocationMode
 
     init {
         coroutineScope.launch {
-            localStateRepository.fakeLocationEnabled.collect {
-                applySettings(it, it)
+            localStateRepository.locationMode.collect {
+                if(it == LocationMode.REAL_LOCATION)
+                    useRealLocation()
+                if(it == LocationMode.RANDOM_LOCATION)
+                    useRandomLocation()
+                if(it == LocationMode.SPECIFIC_LOCATION)
+                    useFakeLocation(localStateRepository.fakeLocation)
+                if(it == LocationMode.ROUTE)
+                    useRoute(localStateRepository.route)
             }
         }
     }
@@ -73,81 +81,178 @@ class FakeLocationStateUseCase(
             permissionsModule.toggleDangerousPermission(appDesc, android.Manifest.permission.ACCESS_FINE_LOCATION, true)
     }
 
-    private fun applySettings(isEnabled: Boolean, isSpecificLocation: Boolean = false) {
-        _configuredLocationMode.value = computeLocationMode(isEnabled, localStateRepository.fakeAltitude, localStateRepository.fakeSpeed, localStateRepository.fakeJitter, localStateRepository.fakeLocation, isSpecificLocation)
+    // private fun applySettings(isEnabled: Boolean, isSpecificLocation: Boolean = false) {
+    //     _configuredLocationMode.value = computeLocationMode(isEnabled,
+    //         localStateRepository.locationMode,
+    //         localStateRepository.fakeAltitude,
+    //         localStateRepository.fakeSpeed,
+    //         localStateRepository.fakeJitter,
+    //         localStateRepository.fakeLocation,
+    //         localStateRepository.routeLoopEnabled,
+    //         isSpecificLocation)
 
-        if (isEnabled && hasAcquireMockLocationPermission()) {
-            fakeLocationModule.startFakeLocation()
-            fakeLocationModule.setFakeLocation(localStateRepository.fakeAltitude.toDouble(),
-                localStateRepository.fakeSpeed,
-                localStateRepository.fakeJitter,
-                localStateRepository.fakeLocation.first.toDouble(),
-                localStateRepository.fakeLocation.second.toDouble())
-            localStateRepository.locationMode.value = configuredLocationMode.value.mode
-        } else {
-            fakeLocationModule.stopFakeLocation()
-            localStateRepository.locationMode.value = LocationMode.REAL_LOCATION
-        }
-    }
+    //     if (isEnabled && hasAcquireMockLocationPermission()) {
+    //         fakeLocationModule.startFakeLocation()
+    //         localStateRepository.setLocationMode(configuredLocationMode.value.mode)
+    //         fakeLocationModule.setFakeLocation(localStateRepository.fakeAltitude.toDouble(),
+    //             localStateRepository.fakeSpeed,
+    //             localStateRepository.fakeJitter,
+    //             localStateRepository.fakeLocation.first.toDouble(),
+    //             localStateRepository.fakeLocation.second.toDouble())
+    //     } else {
+    //         fakeLocationModule.stopFakeLocation()
+    //         localStateRepository.setLocationMode(LocationMode.REAL_LOCATION)
+    //     }
+    // }
 
     private fun hasAcquireMockLocationPermission(): Boolean {
         return (permissionsModule.getAppOpMode(appDesc, AppOpsManager.OPSTR_MOCK_LOCATION) == AppOpModes.ALLOWED) ||
             permissionsModule.setAppOpMode(appDesc, AppOpsManager.OPSTR_MOCK_LOCATION, AppOpModes.ALLOWED)
     }
 
+    fun setRouteLoopEnabled(isEnabled: Boolean) {
+        _configuredLocationMode.value = FakeLocationState(
+            LocationMode.ROUTE,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            false,
+            localStateRepository.route,
+            isEnabled,
+            false
+        )
+
+        localStateRepository.routeLoopEnabled = isEnabled
+    }
+
     fun setFakeLocationParameters(altitude: Float, speed: Float, jitter: Float) {
+        _configuredLocationMode.value = FakeLocationState(
+            LocationMode.SPECIFIC_LOCATION,
+            null,
+            altitude,
+            speed,
+            jitter,
+            localStateRepository.fakeLocation.first,
+            localStateRepository.fakeLocation.second,
+            false,
+            null,
+            false,
+            false
+        )
+
         localStateRepository.fakeAltitude = altitude
         localStateRepository.fakeSpeed = speed
         localStateRepository.fakeJitter = jitter
-        applySettings(localStateRepository.fakeLocationEnabled.value, localStateRepository.fakeLocationEnabled.value)
     }
 
-    fun setSpecificLocation(latitude: Float, longitude: Float) {
-        setFakeLocation(latitude to longitude, true)
+    fun useRealLocation() {
+        _configuredLocationMode.value = FakeLocationState(
+            LocationMode.REAL_LOCATION,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            false,
+            null,
+            false,
+            false
+        )
+
+        fakeLocationModule.stopFakeLocation()
+        localStateRepository.setLocationMode(LocationMode.REAL_LOCATION)
     }
 
-    fun setRandomLocation() {
+    fun useRandomLocation() {
         val randomIndex = Random.nextInt(citiesRepository.citiesLocationsList.size)
         val location = citiesRepository.citiesLocationsList[randomIndex]
 
-        setFakeLocation(location)
+        useFakeLocation(location)
     }
 
-    private fun setFakeLocation(location: Pair<Float, Float>, isSpecificLocation: Boolean = false) {
+    fun useFakeLocation(location: Pair<Float,Float>) {
         localStateRepository.fakeLocation = location
-        localStateRepository.setFakeLocationEnabled(true)
-        applySettings(true, isSpecificLocation)
-    }
-
-    fun stopFakeLocation() {
-        localStateRepository.setFakeLocationEnabled(false)
-        applySettings(false, false)
-    }
-
-    private fun computeLocationMode(
-        isFakeLocationEnabled: Boolean,
-        altitude: Float,
-        speed: Float,
-        jitter: Float,
-        fakeLocation: Pair<Float, Float>,
-        isSpecificLocation: Boolean = false,
-    ): FakeLocationState {
-        return FakeLocationState(
-            when {
-                !isFakeLocationEnabled -> LocationMode.REAL_LOCATION
-                (fakeLocation in citiesRepository.citiesLocationsList && !isSpecificLocation) ->
-                    LocationMode.RANDOM_LOCATION
-                else -> LocationMode.SPECIFIC_LOCATION
-            },
+
+        _configuredLocationMode.value = FakeLocationState(
+            LocationMode.SPECIFIC_LOCATION,
             null,
-            altitude,
-            speed,
-            jitter,
+            localStateRepository.fakeAltitude,
+            localStateRepository.fakeSpeed,
+            localStateRepository.fakeJitter,
+            location.first,
+            location.second,
+            false,
+            null,
+            false,
+            false
+        )
+
+        if (hasAcquireMockLocationPermission()) {
+            fakeLocationModule.startFakeLocation()
+            localStateRepository.setLocationMode(LocationMode.SPECIFIC_LOCATION)
+            fakeLocationModule.setFakeLocation(localStateRepository.fakeAltitude.toDouble(),
+                localStateRepository.fakeSpeed,
+                localStateRepository.fakeJitter,
+                localStateRepository.fakeLocation.first.toDouble(),
+                localStateRepository.fakeLocation.second.toDouble())
+        } else {
+            fakeLocationModule.stopFakeLocation()
+            localStateRepository.setLocationMode(LocationMode.REAL_LOCATION)
+        }
+    }
+
+    fun useRoute(route: List<FakeLocationCoordinate>? = null) {
+        _configuredLocationMode.value = FakeLocationState(
+            LocationMode.ROUTE,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            false,
+            route,
             false,
-            fakeLocation.first,
-            fakeLocation.second,
             false
         )
+
+        localStateRepository.setLocationMode(LocationMode.ROUTE)
+    }
+
+    fun setRoute(route: List<FakeLocationCoordinate>) {
+        _configuredLocationMode.value = FakeLocationState(
+            LocationMode.ROUTE,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            false,
+            route,
+            false,
+            false
+        )
+    }
+
+    fun routeStart() {
+        if (hasAcquireMockLocationPermission()) {
+            fakeLocationModule.routeStart(localStateRepository.route, localStateRepository.routeLoopEnabled)
+        } else {
+            useRealLocation()
+        }
+    }
+
+    fun routeStop() {
+        if (hasAcquireMockLocationPermission()) {
+            fakeLocationModule.routeStop()
+        } else {
+            useRealLocation()
+        }
     }
 
     val currentLocation = MutableStateFlow<Location?>(null)