diff options
Diffstat (limited to 'app/src/main/java/foundation/e')
8 files changed, 177 insertions, 100 deletions
diff --git a/app/src/main/java/foundation/e/privacycentralapp/DependencyContainer.kt b/app/src/main/java/foundation/e/privacycentralapp/DependencyContainer.kt index 4a790c6..0a06708 100644 --- a/app/src/main/java/foundation/e/privacycentralapp/DependencyContainer.kt +++ b/app/src/main/java/foundation/e/privacycentralapp/DependencyContainer.kt @@ -78,7 +78,7 @@ class DependencyContainer(val app: Application) { // Usecases val getQuickPrivacyStateUseCase by lazy { - GetQuickPrivacyStateUseCase(localStateRepository) + GetQuickPrivacyStateUseCase(localStateRepository, GlobalScope) } private val ipScramblingStateUseCase by lazy { IpScramblingStateUseCase( diff --git a/app/src/main/java/foundation/e/privacycentralapp/common/QuickPrivacyDisabledSnackbar.kt b/app/src/main/java/foundation/e/privacycentralapp/common/QuickPrivacyDisabledSnackbar.kt new file mode 100644 index 0000000..705f65d --- /dev/null +++ b/app/src/main/java/foundation/e/privacycentralapp/common/QuickPrivacyDisabledSnackbar.kt @@ -0,0 +1,36 @@ +/* + * 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.privacycentralapp.common + +import android.view.View +import com.google.android.material.snackbar.BaseTransientBottomBar +import com.google.android.material.snackbar.Snackbar +import foundation.e.privacycentralapp.R + +fun initQuickPrivacySnackbar(view: View, onDismiss: () -> Unit): Snackbar { + val snackbar = Snackbar.make(view, R.string.quickprivacy_disabled_message, Snackbar.LENGTH_INDEFINITE) + snackbar.setAction(R.string.close) { onDismiss() } + + snackbar.addCallback(object : BaseTransientBottomBar.BaseCallback<Snackbar>() { + override fun onDismissed(transientBottomBar: Snackbar?, event: Int) { + super.onDismissed(transientBottomBar, event) + if (event == DISMISS_EVENT_SWIPE) onDismiss() + } + }) + return snackbar +} 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 136b20f..b4bca0b 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 @@ -22,6 +22,7 @@ import foundation.e.privacycentralapp.domain.entities.InternetPrivacyMode import foundation.e.privacycentralapp.domain.entities.LocationMode import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow class LocalStateRepository(context: Context) { companion object { @@ -84,6 +85,13 @@ class LocalStateRepository(context: Context) { val internetPrivacyMode: MutableStateFlow<InternetPrivacyMode> = MutableStateFlow(InternetPrivacyMode.REAL_IP) + private val _showQuickPrivacyDisabledMessage = MutableStateFlow(false) + val showQuickPrivacyDisabledMessage: StateFlow<Boolean> = _showQuickPrivacyDisabledMessage + + fun setShowQuickPrivacyDisabledMessage(show: Boolean) { + _showQuickPrivacyDisabledMessage.value = show + } + var firstBoot: Boolean get() = sharedPref.getBoolean(KEY_FIRST_BOOT, true) set(value) = set(KEY_FIRST_BOOT, value) diff --git a/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/FakeLocationStateUseCase.kt b/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/FakeLocationStateUseCase.kt index c07657a..fb773b2 100644 --- a/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/FakeLocationStateUseCase.kt +++ b/app/src/main/java/foundation/e/privacycentralapp/domain/usecases/FakeLocationStateUseCase.kt @@ -33,6 +33,7 @@ import foundation.e.privacymodules.permissions.data.AppOpModes import foundation.e.privacymodules.permissions.data.ApplicationDescription import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.collect import kotlinx.coroutines.launch import kotlin.random.Random @@ -46,8 +47,8 @@ class FakeLocationStateUseCase( private val appContext: Context, private val coroutineScope: CoroutineScope ) { - // private val _locationMode = MutableStateFlow(LocationMode.REAL_LOCATION) - // val locationMode: StateFlow<LocationMode> = _locationMode + private val _configuredLocationMode = MutableStateFlow<Triple<LocationMode, Float?, Float?>>(Triple(LocationMode.REAL_LOCATION, null, null)) + val configuredLocationMode: StateFlow<Triple<LocationMode, Float?, Float?>> = _configuredLocationMode init { coroutineScope.launch { @@ -60,44 +61,23 @@ class FakeLocationStateUseCase( private val locationManager: LocationManager get() = appContext.getSystemService(Context.LOCATION_SERVICE) as LocationManager - fun getLocationMode(): Triple<LocationMode, Float?, Float?> { - val fakeLocation = localStateRepository.fakeLocation - return if (fakeLocation != null && localStateRepository.locationMode.value == LocationMode.SPECIFIC_LOCATION) { - Triple( - LocationMode.SPECIFIC_LOCATION, - fakeLocation.first, - fakeLocation.second - ) - } else { - Triple(localStateRepository.locationMode.value, null, null) - } - } - private fun acquireLocationPermission() { permissionsModule.toggleDangerousPermission( appDesc, android.Manifest.permission.ACCESS_FINE_LOCATION, true ) - - // permissionsModule.setAppOpMode( - // appDesc, AppOpsManager.OPSTR_COARSE_LOCATION, - // AppOpModes.ALLOWED - // ) - // permissionsModule.setAppOpMode( - // appDesc, AppOpsManager.OPSTR_FINE_LOCATION, - // AppOpModes.ALLOWED - // ) } private fun applySettings(isQuickPrivacyEnabled: Boolean, fakeLocation: Pair<Float, Float>?) { + _configuredLocationMode.value = computeLocationMode(fakeLocation) + if (isQuickPrivacyEnabled && fakeLocation != null) { if (permissionsModule.getAppOpMode(appDesc, AppOpsManager.OPSTR_MOCK_LOCATION) != AppOpModes.ALLOWED) { permissionsModule.setAppOpMode(appDesc, AppOpsManager.OPSTR_MOCK_LOCATION, AppOpModes.ALLOWED) } fakeLocationModule.startFakeLocation() fakeLocationModule.setFakeLocation(fakeLocation.first.toDouble(), fakeLocation.second.toDouble()) - localStateRepository.locationMode.value = if (fakeLocation in citiesRepository.citiesLocationsList) LocationMode.RANDOM_LOCATION - else LocationMode.SPECIFIC_LOCATION + localStateRepository.locationMode.value = configuredLocationMode.value.first } else { fakeLocationModule.stopFakeLocation() localStateRepository.locationMode.value = LocationMode.REAL_LOCATION @@ -105,10 +85,18 @@ class FakeLocationStateUseCase( } fun setSpecificLocation(latitude: Float, longitude: Float) { + if (!localStateRepository.isQuickPrivacyEnabled) { + localStateRepository.setShowQuickPrivacyDisabledMessage(true) + } + setFakeLocation(latitude to longitude) } fun setRandomLocation() { + if (!localStateRepository.isQuickPrivacyEnabled) { + localStateRepository.setShowQuickPrivacyDisabledMessage(true) + } + val randomIndex = Random.nextInt(citiesRepository.citiesLocationsList.size) val location = citiesRepository.citiesLocationsList[randomIndex] @@ -117,12 +105,27 @@ class FakeLocationStateUseCase( private fun setFakeLocation(location: Pair<Float, Float>) { localStateRepository.fakeLocation = location - applySettings(true, location) + applySettings(localStateRepository.isQuickPrivacyEnabled, location) } fun stopFakeLocation() { + if (!localStateRepository.isQuickPrivacyEnabled) { + localStateRepository.setShowQuickPrivacyDisabledMessage(true) + } + localStateRepository.fakeLocation = null - applySettings(true, null) + applySettings(localStateRepository.isQuickPrivacyEnabled, null) + } + + private fun computeLocationMode(fakeLocation: Pair<Float, Float>?): Triple<LocationMode, Float?, Float?> { + return Triple( + when { + fakeLocation == null -> LocationMode.REAL_LOCATION + fakeLocation in citiesRepository.citiesLocationsList -> LocationMode.RANDOM_LOCATION + else -> LocationMode.SPECIFIC_LOCATION + }, + fakeLocation?.first, fakeLocation?.second + ) } val currentLocation = MutableStateFlow<Location?>(null) 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 fd9430c..6e2e7cf 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 @@ -21,10 +21,25 @@ import foundation.e.privacycentralapp.data.repositories.LocalStateRepository import foundation.e.privacycentralapp.domain.entities.InternetPrivacyMode import foundation.e.privacycentralapp.domain.entities.LocationMode import foundation.e.privacycentralapp.domain.entities.QuickPrivacyState +import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.collect import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.launch + +class GetQuickPrivacyStateUseCase( + private val localStateRepository: LocalStateRepository, + private val coroutineScope: CoroutineScope +) { + + init { + coroutineScope.launch { + localStateRepository.quickPrivacyEnabledFlow.collect { + if (it) resetQuickPrivacyDisabledMessage() + } + } + } -class GetQuickPrivacyStateUseCase(private val localStateRepository: LocalStateRepository) { val quickPrivacyEnabledFlow = localStateRepository.quickPrivacyEnabledFlow val isQuickPrivacyEnabled get() = localStateRepository.isQuickPrivacyEnabled @@ -77,4 +92,14 @@ class GetQuickPrivacyStateUseCase(private val localStateRepository: LocalStateRe val newState = !localStateRepository.isQuickPrivacyEnabled return localStateRepository.setQuickPrivacyReturnIsFirstActivation(newState) } + + val showQuickPrivacyDisabledMessage: StateFlow<Boolean> = localStateRepository.showQuickPrivacyDisabledMessage + + // fun setQuickPrivacyDisabledMessage() { + // localStateRepository.setShowQuickPrivacyDisabledMessage(true) + // } + + fun resetQuickPrivacyDisabledMessage() { + localStateRepository.setShowQuickPrivacyDisabledMessage(false) + } } diff --git a/app/src/main/java/foundation/e/privacycentralapp/features/location/FakeLocationFeature.kt b/app/src/main/java/foundation/e/privacycentralapp/features/location/FakeLocationFeature.kt index a7869ce..faac5a4 100644 --- a/app/src/main/java/foundation/e/privacycentralapp/features/location/FakeLocationFeature.kt +++ b/app/src/main/java/foundation/e/privacycentralapp/features/location/FakeLocationFeature.kt @@ -27,7 +27,6 @@ import foundation.e.privacycentralapp.domain.entities.LocationMode import foundation.e.privacycentralapp.domain.usecases.FakeLocationStateUseCase import foundation.e.privacycentralapp.domain.usecases.GetQuickPrivacyStateUseCase import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.flow.flow import kotlinx.coroutines.flow.flowOf import kotlinx.coroutines.flow.map import kotlinx.coroutines.flow.merge @@ -48,16 +47,17 @@ class FakeLocationFeature( singleEventProducer ) { data class State( - val isEnabled: Boolean, - val mode: LocationMode, - val currentLocation: Location?, + val isEnabled: Boolean = true, + val mode: LocationMode = LocationMode.REAL_LOCATION, + val currentLocation: Location? = null, val specificLatitude: Float? = null, val specificLongitude: Float? = null, - val forceRefresh: Boolean = false + val forceRefresh: Boolean = false, + val showQuickPrivacyDisabledMessage: Boolean = false ) sealed class SingleEvent { - data class LocationUpdatedEvent(val location: Location?) : SingleEvent() + data class LocationUpdatedEvent(val mode: LocationMode, val location: Location?) : SingleEvent() data class ErrorEvent(val error: String) : SingleEvent() } @@ -70,6 +70,7 @@ class FakeLocationFeature( val latitude: Float, val longitude: Float ) : Action() + object CloseQuickPrivacyDisabledMessage : Action() } sealed class Effect { @@ -81,17 +82,13 @@ class FakeLocationFeature( ) : Effect() data class LocationUpdatedEffect(val location: Location?) : Effect() data class ErrorEffect(val message: String) : Effect() - object QuickPrivacyDisabledWarningEffect : Effect() object NoEffect : Effect() + data class ShowQuickPrivacyDisabledMessageEffect(val show: Boolean) : Effect() } companion object { fun create( - initialState: State = State( - isEnabled = false, - mode = LocationMode.REAL_LOCATION, - currentLocation = null - ), + initialState: State = State(), getQuickPrivacyStateUseCase: GetQuickPrivacyStateUseCase, fakeLocationStateUseCase: FakeLocationStateUseCase, coroutineScope: CoroutineScope @@ -99,66 +96,58 @@ class FakeLocationFeature( initialState, coroutineScope, reducer = { state, effect -> when (effect) { - is Effect.QuickPrivacyUpdatedEffect -> state.copy(isEnabled = effect.isEnabled) is Effect.LocationModeUpdatedEffect -> state.copy( mode = effect.mode, specificLatitude = effect.latitude, specificLongitude = effect.longitude ) - Effect.QuickPrivacyDisabledWarningEffect -> state.copy(forceRefresh = !state.forceRefresh) + is Effect.ShowQuickPrivacyDisabledMessageEffect -> state.copy(showQuickPrivacyDisabledMessage = effect.show) else -> state } }, - actor = { state, action -> + actor = { _, action -> when (action) { - is Action.Init -> merge( - getQuickPrivacyStateUseCase.quickPrivacyEnabledFlow.map { Effect.QuickPrivacyUpdatedEffect(it) }, - flow { - fakeLocationStateUseCase.startListeningLocation() - val (mode, lat, lon) = fakeLocationStateUseCase.getLocationMode() - emit(Effect.LocationModeUpdatedEffect(mode = mode, latitude = lat, longitude = lon)) - }, - fakeLocationStateUseCase.currentLocation.map { Effect.LocationUpdatedEffect(it) } - ) + is Action.Init -> { + fakeLocationStateUseCase.startListeningLocation() + + merge( + getQuickPrivacyStateUseCase.quickPrivacyEnabledFlow.map { Effect.QuickPrivacyUpdatedEffect(it) }, + fakeLocationStateUseCase.configuredLocationMode.map { (mode, lat, lon) -> + Effect.LocationModeUpdatedEffect(mode = mode, latitude = lat, longitude = lon) + }, + fakeLocationStateUseCase.currentLocation.map { Effect.LocationUpdatedEffect(it) }, + getQuickPrivacyStateUseCase.showQuickPrivacyDisabledMessage.map { Effect.ShowQuickPrivacyDisabledMessageEffect(it) }, + ) + } is Action.LeaveScreen -> { fakeLocationStateUseCase.stopListeningLocation() flowOf(Effect.NoEffect) } is Action.SetSpecificLocationAction -> { - if (state.isEnabled) { - fakeLocationStateUseCase.setSpecificLocation( - action.latitude, - action.longitude - ) - flowOf( - Effect.LocationModeUpdatedEffect( - mode = LocationMode.SPECIFIC_LOCATION, - latitude = action.latitude, - longitude = action.longitude - ) - ) - } else flowOf(Effect.QuickPrivacyDisabledWarningEffect) + fakeLocationStateUseCase.setSpecificLocation( + action.latitude, + action.longitude + ) + flowOf(Effect.NoEffect) } is Action.UseRandomLocationAction -> { - if (state.isEnabled) { - fakeLocationStateUseCase.setRandomLocation() - flowOf(Effect.LocationModeUpdatedEffect(LocationMode.RANDOM_LOCATION)) - } else flowOf(Effect.QuickPrivacyDisabledWarningEffect) + fakeLocationStateUseCase.setRandomLocation() + flowOf(Effect.NoEffect) } is Action.UseRealLocationAction -> { - if (state.isEnabled) { - fakeLocationStateUseCase.stopFakeLocation() - flowOf(Effect.LocationModeUpdatedEffect(LocationMode.REAL_LOCATION)) - } else flowOf(Effect.QuickPrivacyDisabledWarningEffect) + fakeLocationStateUseCase.stopFakeLocation() + flowOf(Effect.NoEffect) + } + is Action.CloseQuickPrivacyDisabledMessage -> { + getQuickPrivacyStateUseCase.resetQuickPrivacyDisabledMessage() + flowOf(Effect.NoEffect) } } }, - singleEventProducer = { _, _, effect -> + singleEventProducer = { state, _, effect -> when (effect) { is Effect.LocationUpdatedEffect -> - SingleEvent.LocationUpdatedEvent(effect.location) - Effect.QuickPrivacyDisabledWarningEffect -> - SingleEvent.ErrorEvent("Enabled Quick Privacy to use functionalities") + SingleEvent.LocationUpdatedEvent(state.mode, effect.location) is Effect.ErrorEffect -> SingleEvent.ErrorEvent(effect.message) else -> null } diff --git a/app/src/main/java/foundation/e/privacycentralapp/features/location/FakeLocationFragment.kt b/app/src/main/java/foundation/e/privacycentralapp/features/location/FakeLocationFragment.kt index bc35521..2999eb6 100644 --- a/app/src/main/java/foundation/e/privacycentralapp/features/location/FakeLocationFragment.kt +++ b/app/src/main/java/foundation/e/privacycentralapp/features/location/FakeLocationFragment.kt @@ -22,6 +22,7 @@ import android.content.Context import android.location.Location import android.os.Bundle import android.text.Editable +import android.util.Log import android.view.View import android.widget.Toast import androidx.annotation.NonNull @@ -29,6 +30,7 @@ import androidx.core.view.isVisible import androidx.core.widget.addTextChangedListener import androidx.fragment.app.viewModels import androidx.lifecycle.lifecycleScope +import com.google.android.material.snackbar.Snackbar import com.google.android.material.textfield.TextInputEditText import com.google.android.material.textfield.TextInputLayout import com.google.android.material.textfield.TextInputLayout.END_ICON_CUSTOM @@ -48,6 +50,7 @@ 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.initQuickPrivacySnackbar import foundation.e.privacycentralapp.databinding.FragmentFakeLocationBinding import foundation.e.privacycentralapp.domain.entities.LocationMode import foundation.e.privacycentralapp.extensions.viewModelProviderFactoryOf @@ -78,6 +81,8 @@ class FakeLocationFragment : private var mapboxMap: MapboxMap? = null private var locationComponent: LocationComponent? = null + private var qpDisabledSnackbar: Snackbar? = null + private var inputJob: Job? = null companion object { @@ -97,18 +102,7 @@ class FakeLocationFragment : displayToast(event.error) } is FakeLocationFeature.SingleEvent.LocationUpdatedEvent -> { - if (isFirstLaunch && mapboxMap != null) { - mapboxMap?.moveCamera( - CameraUpdateFactory.newLatLng( - LatLng( - event.location?.latitude ?: 0.0, - event.location?.longitude ?: 0.0 - ) - ) - ) - isFirstLaunch = false - } - updateLocation(event.location) + updateLocation(event.location, event.mode) } } } @@ -151,8 +145,14 @@ class FakeLocationFragment : } // Bind click listeners once map is ready. bindClickListeners() + + render(viewModel.fakeLocationFeature.state.value) } } + + qpDisabledSnackbar = initQuickPrivacySnackbar(binding.root) { + viewModel.submitAction(Action.CloseQuickPrivacyDisabledMessage) + } } private fun getCoordinatesAfterTextChanged( @@ -232,6 +232,9 @@ class FakeLocationFragment : @SuppressLint("MissingPermission") override fun render(state: FakeLocationFeature.State) { + if (state.showQuickPrivacyDisabledMessage) qpDisabledSnackbar?.show() + else qpDisabledSnackbar?.dismiss() + binding.radioUseRandomLocation.apply { isChecked = state.mode == LocationMode.RANDOM_LOCATION isEnabled = state.isEnabled @@ -249,13 +252,14 @@ class FakeLocationFragment : binding.mapView.isEnabled = (state.mode == LocationMode.SPECIFIC_LOCATION) - if (state.mode != LocationMode.SPECIFIC_LOCATION) { + if (state.mode == LocationMode.REAL_LOCATION) { binding.centeredMarker.isVisible = false } else { binding.mapLoader.isVisible = false - binding.mapOverlay.isVisible = false + binding.mapOverlay.isVisible = state.mode != LocationMode.SPECIFIC_LOCATION binding.centeredMarker.isVisible = true + Log.d("LocationTest", "is mapboxMap null: ${mapboxMap == null}") mapboxMap?.moveCamera( CameraUpdateFactory.newLatLng( LatLng( @@ -276,7 +280,7 @@ class FakeLocationFragment : override fun actions(): Flow<Action> = viewModel.actions @SuppressLint("MissingPermission") - private fun updateLocation(lastLocation: Location?) { + private fun updateLocation(lastLocation: Location?, mode: LocationMode) { lastLocation?.let { location -> locationComponent?.isLocationComponentEnabled = true val locationUpdate = LocationUpdate.Builder() @@ -285,18 +289,24 @@ class FakeLocationFragment : .build() locationComponent?.forceLocationUpdate(locationUpdate) - if (!binding.mapView.isEnabled) { + if (mode == LocationMode.REAL_LOCATION) { binding.mapLoader.isVisible = false binding.mapOverlay.isVisible = false - mapboxMap?.animateCamera( - CameraUpdateFactory.newLatLng( - LatLng(location.latitude, location.longitude) - ) + + val update = CameraUpdateFactory.newLatLng( + LatLng(location.latitude, location.longitude) ) + + if (isFirstLaunch) { + mapboxMap?.moveCamera(update) + isFirstLaunch = false + } else { + mapboxMap?.animateCamera(update) + } } } ?: run { locationComponent?.isLocationComponentEnabled = false - if (!binding.mapView.isEnabled) { + if (mode == LocationMode.REAL_LOCATION) { binding.mapLoader.isVisible = true binding.mapOverlay.isVisible = true } diff --git a/app/src/main/java/foundation/e/privacycentralapp/main/MainActivity.kt b/app/src/main/java/foundation/e/privacycentralapp/main/MainActivity.kt index c0bdcf0..910385e 100644 --- a/app/src/main/java/foundation/e/privacycentralapp/main/MainActivity.kt +++ b/app/src/main/java/foundation/e/privacycentralapp/main/MainActivity.kt @@ -23,6 +23,7 @@ import android.os.Bundle import androidx.fragment.app.FragmentActivity import androidx.fragment.app.add import androidx.fragment.app.commit +import foundation.e.privacycentralapp.PrivacyCentralApplication import foundation.e.privacycentralapp.R import foundation.e.privacycentralapp.features.dashboard.DashboardFragment import kotlinx.coroutines.FlowPreview @@ -47,6 +48,11 @@ open class MainActivity : FragmentActivity(R.layout.activity_main) { override fun onNewIntent(intent: Intent) { super.onNewIntent(intent) + + (application as? PrivacyCentralApplication) + ?.dependencyContainer?.getQuickPrivacyStateUseCase + ?.resetQuickPrivacyDisabledMessage() + handleIntent(intent) } |