Fix no permission disconnected notification

mullvad · Nov 22, 2024 · 3d8ecdf · 3d8ecdf
1 parent 2f2d4ce
commit 3d8ecdf
Show file tree

Hide file tree

Showing 9 changed files with 51 additions and 15 deletions.
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/compose/screen/MullvadApp.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/compose/screen/MullvadApp.kt
@@ -7,6 +7,7 @@ import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.semantics.testTagsAsResourceId
 import androidx.navigation.NavHostController
@@ -18,6 +19,8 @@ import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import com.ramcosta.composedestinations.rememberNavHostEngine
 import com.ramcosta.composedestinations.utils.rememberDestinationsNavigator
 import net.mullvad.mullvadvpn.compose.util.CreateVpnProfile
+import net.mullvad.mullvadvpn.lib.common.util.prepareVpnSafe
+import net.mullvad.mullvadvpn.lib.model.PrepareError
 import net.mullvad.mullvadvpn.viewmodel.DaemonScreenEvent
 import net.mullvad.mullvadvpn.viewmodel.NoDaemonViewModel
 import net.mullvad.mullvadvpn.viewmodel.VpnPermissionSideEffect
@@ -65,11 +68,22 @@ fun MullvadApp() {
     // Ask for VPN Permission
     val launchVpnPermission =
         rememberLauncherForActivityResult(CreateVpnProfile()) { _ -> permissionVm.connect() }
+    val context = LocalContext.current
     LaunchedEffect(Unit) {
         permissionVm.uiSideEffect.collect {
-            if (it is VpnPermissionSideEffect.ShowDialog) {
-                // TODO fix this
-                //                launchVpnPermission.launch(Unit)
+            if (it is VpnPermissionSideEffect.RequestVpnProfile) {
+                context
+                    .prepareVpnSafe()
+                    .fold(
+                        {
+                            if (it is PrepareError.NotPrepared) {
+                                launchVpnPermission.launch(it.prepareIntent)
+                            } else {
+                                permissionVm.connect()
+                            }
+                        },
+                        { permissionVm.connect() },
+                    )
             }
         }
     }

diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/viewmodel/VpnPermissionViewModel.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/viewmodel/VpnPermissionViewModel.kt
@@ -21,7 +21,7 @@ class VpnPermissionViewModel(
         intentProvider.intents
             .filter { it?.action == KEY_REQUEST_VPN_PERMISSION }
             .distinctUntilChanged()
-            .map { VpnPermissionSideEffect.ShowDialog }
+            .map { VpnPermissionSideEffect.RequestVpnProfile }
             .shareIn(viewModelScope, SharingStarted.WhileSubscribed())
 
     fun connect() {
@@ -30,5 +30,5 @@ class VpnPermissionViewModel(
 }
 
 sealed interface VpnPermissionSideEffect {
-    data object ShowDialog : VpnPermissionSideEffect
+    data object RequestVpnProfile : VpnPermissionSideEffect
 }
diff --git a/android/lib/model/src/main/kotlin/net/mullvad/mullvadvpn/lib/model/NotificationAction.kt b/android/lib/model/src/main/kotlin/net/mullvad/mullvadvpn/lib/model/NotificationAction.kt
@@ -1,5 +1,7 @@
 package net.mullvad.mullvadvpn.lib.model
 
+import android.content.Intent
+
 sealed interface NotificationAction {
 
     sealed interface AccountExpiry : NotificationAction {
@@ -15,6 +17,6 @@ sealed interface NotificationAction {
 
         data object Dismiss : Tunnel
 
-        data object RequestPermission : Tunnel
+        data class RequestPermission(val prepareIntent: Intent) : Tunnel
     }
 }
diff --git a/...net/mullvad/mullvadvpn/service/notifications/tunnelstate/TunnelStateNotificationAction.kt b/...net/mullvad/mullvadvpn/service/notifications/tunnelstate/TunnelStateNotificationAction.kt
@@ -71,6 +71,7 @@ internal fun NotificationAction.Tunnel.toCompatAction(context: Context): Notific
                     addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
                     addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
                     setAction(KEY_REQUEST_VPN_PERMISSION)
+                    putExtra("intent", prepareIntent)
                 }
 
             PendingIntent.getActivity(context, 1, intent, SdkUtils.getSupportedPendingIntentFlags())
@@ -90,15 +91,15 @@ fun NotificationAction.Tunnel.titleResource() =
     when (this) {
         NotificationAction.Tunnel.Cancel -> R.string.cancel
         NotificationAction.Tunnel.Connect,
-        NotificationAction.Tunnel.RequestPermission -> R.string.connect
+        is NotificationAction.Tunnel.RequestPermission -> R.string.connect
         NotificationAction.Tunnel.Disconnect -> R.string.disconnect
         NotificationAction.Tunnel.Dismiss -> R.string.dismiss
     }
 
 fun NotificationAction.Tunnel.toKey() =
     when (this) {
         NotificationAction.Tunnel.Connect -> KEY_CONNECT_ACTION
-        NotificationAction.Tunnel.RequestPermission -> KEY_REQUEST_VPN_PERMISSION
+        is NotificationAction.Tunnel.RequestPermission -> KEY_REQUEST_VPN_PERMISSION
         NotificationAction.Tunnel.Cancel,
         NotificationAction.Tunnel.Disconnect,
         NotificationAction.Tunnel.Dismiss -> KEY_DISCONNECT_ACTION

diff --git a/...t/mullvad/mullvadvpn/service/notifications/tunnelstate/TunnelStateNotificationProvider.kt b/...t/mullvad/mullvadvpn/service/notifications/tunnelstate/TunnelStateNotificationProvider.kt
@@ -122,11 +122,12 @@ class TunnelStateNotificationProvider(
     private fun NotificationTunnelState.toAction(): NotificationAction.Tunnel =
         when (this) {
             is NotificationTunnelState.Disconnected -> {
-                when (prepareError) {
+                when (val error = prepareError) {
                     is PrepareError.OtherAlwaysOnApp,
                     is PrepareError.LegacyLockdown,
                     null -> NotificationAction.Tunnel.Connect
-                    is PrepareError.NotPrepared -> NotificationAction.Tunnel.RequestPermission
+                    is PrepareError.NotPrepared ->
+                        NotificationAction.Tunnel.RequestPermission(error.prepareIntent)
                 }
             }
             NotificationTunnelState.Disconnecting -> NotificationAction.Tunnel.Connect

diff --git a/mullvad-daemon/src/access_method.rs b/mullvad-daemon/src/access_method.rs
@@ -150,6 +150,7 @@ impl Daemon {
     /// different kinds of testing contexts, such as testing
     /// [`AccessMethodSetting`]s or on the fly testing of
     /// [`talpid_types::net::proxy::CustomProxy`]s.
+    #[cfg(not(target_os = "android"))]
     pub(crate) async fn test_access_method(
         proxy: talpid_types::net::AllowedEndpoint,
         access_method_selector: api::AccessModeSelectorHandle,
@@ -177,6 +178,19 @@ impl Daemon {
         result
     }
 
+    #[cfg(target_os = "android")]
+    pub(crate) async fn test_access_method(
+        _: talpid_types::net::AllowedEndpoint,
+        _: api::AccessModeSelectorHandle,
+        _: crate::DaemonEventSender<(
+            api::AccessMethodEvent,
+            futures::channel::oneshot::Sender<()>,
+        )>,
+        api_proxy: ApiProxy,
+    ) -> Result<bool, Error> {
+        Self::perform_api_request(api_proxy).await
+    }
+
     /// Create an [`ApiProxy`] which will perform all REST requests against one
     /// specific endpoint `connection_mode`.
     pub fn create_limited_api_proxy(&mut self, connection_mode: ApiConnectionMode) -> ApiProxy {

diff --git a/mullvad-daemon/src/api.rs b/mullvad-daemon/src/api.rs
@@ -52,6 +52,7 @@ pub enum AccessMethodEvent {
         setting: AccessMethodSetting,
         /// The endpoint which represents how to connect to the Mullvad API and
         /// which clients are allowed to initiate such a connection.
+        #[cfg(not(target_os = "android"))]
         endpoint: AllowedEndpoint,
     },
     /// Emitted when the the firewall should be updated.
@@ -63,6 +64,7 @@ pub enum AccessMethodEvent {
     /// should be opaque to any client, it should not produce any unwanted noise
     /// and as such it is *not* broadcasted after the daemon is done processing
     /// this [`AccessMethodEvent::Allow`].
+    #[cfg(not(target_os = "android"))]
     Allow { endpoint: AllowedEndpoint },
 }
 
@@ -419,10 +421,13 @@ impl AccessModeSelector {
         // created from this `AccessModeSelector` instance. As such, the
         // completion channel is discarded in this instance.
         let setting = resolved.setting.clone();
+        #[cfg(not(target_os = "android"))]
         let endpoint = resolved.endpoint.clone();
         let daemon_sender = self.access_method_event_sender.clone();
         tokio::spawn(async move {
-            let _ = AccessMethodEvent::New { setting, endpoint }
+            let _ = AccessMethodEvent::New { setting,
+                #[cfg(not(target_os = "android"))]
+                endpoint }
                 .send(daemon_sender)
                 .await;
         });

diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
@@ -1418,10 +1418,7 @@ impl Daemon {
 
         #[cfg(target_os = "android")]
         match event {
-            AccessMethodEvent::Allow { endpoint } => {
-                let _ = endpoint_active_tx.send(());
-            }
-            AccessMethodEvent::New { setting, endpoint } => {
+            AccessMethodEvent::New { setting, .. } => {
                 // Announce to all clients listening for updates of the
                 // currently active access method. The announcement should be
                 // made after the firewall policy has been updated, since the

diff --git a/talpid-core/src/tunnel_state_machine/error_state.rs b/talpid-core/src/tunnel_state_machine/error_state.rs
@@ -4,6 +4,7 @@ use super::{
 };
 #[cfg(target_os = "macos")]
 use crate::dns::DnsConfig;
+#[cfg(not(target_os = "android"))]
 use crate::firewall::FirewallPolicy;
 use futures::StreamExt;
 #[cfg(target_os = "macos")]
@@ -73,6 +74,7 @@ impl ErrorState {
         )
     }
 
+    #[cfg(not(target_os = "android"))]
     fn set_firewall_policy(
         shared_values: &mut SharedTunnelStateValues,
     ) -> Result<(), FirewallPolicyError> {