Get value of data directory value at app startup

Remove `APP_PATH` from `mullvad-paths` on Android since it should
not be a constant value. Instead, it is passed down from the Android app
startup. As it turns out, it is really ever used for pointing to the RPC
socket in use.

23 files changed, 181 insertions, 154 deletions

diff --git a/README.md b/README.md
index 709ce3fa7a..e7162e81d5 100644
--- a/README.md
+++ b/README.md
@@ -332,7 +332,7 @@ The settings directory can be changed by setting the `MULLVAD_SETTINGS_DIR` envi
 | Linux | `/etc/mullvad-vpn/` |
 | macOS | `/etc/mullvad-vpn/` |
 | Windows | `%LOCALAPPDATA%\Mullvad VPN\` |
-| Android | `/data/data/net.mullvad.mullvadvpn/` |
+| Android | [`getFilesDir()`](https://developer.android.com/reference/android/content/Context#getFilesDir()) |
 
 #### Logs
 
@@ -343,7 +343,7 @@ The log directory can be changed by setting the `MULLVAD_LOG_DIR` environment va
 | Linux | `/var/log/mullvad-vpn/` + systemd |
 | macOS | `/var/log/mullvad-vpn/` |
 | Windows | `C:\ProgramData\Mullvad VPN\` |
-| Android | `/data/data/net.mullvad.mullvadvpn/` |
+| Android | [`getFilesDir()`](https://developer.android.com/reference/android/content/Context#getFilesDir()) |
 
 #### Cache
 
@@ -354,7 +354,7 @@ The cache directory can be changed by setting the `MULLVAD_CACHE_DIR` environmen
 | Linux | `/var/cache/mullvad-vpn/` |
 | macOS | `/Library/Caches/mullvad-vpn/` |
 | Windows | `C:\ProgramData\Mullvad VPN\cache` |
-| Android | `/data/data/net.mullvad.mullvadvpn/cache` |
+| Android | [`getCacheDir()`](https://developer.android.com/reference/android/content/Context#getCacheDir())  |
 
 #### RPC address file
 
@@ -366,7 +366,7 @@ environment variable.
 | Linux | `/var/run/mullvad-vpn` |
 | macOS | `/var/run/mullvad-vpn` |
 | Windows | `//./pipe/Mullvad VPN` |
-| Android | `/data/data/net.mullvad.mullvadvpn/rpc-socket` |
+| Android | [`getNoBackupFilesDir()`](https://developer.android.com/reference/android/content/ContextWrapper#getNoBackupFilesDir()) |
 
 ### GUI
 
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/constant/PathConstant.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/constant/PathConstant.kt
deleted file mode 100644
index 755e076721..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/constant/PathConstant.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package net.mullvad.mullvadvpn.constant
-
-const val GRPC_SOCKET_FILE_NAME = "rpc-socket"
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/di/AppModule.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/di/AppModule.kt
index a9853250f2..6af9ff57cb 100644
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/di/AppModule.kt
+++ b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/di/AppModule.kt
@@ -1,8 +1,10 @@
 package net.mullvad.mullvadvpn.di
 
+import java.io.File
 import kotlinx.coroutines.MainScope
 import net.mullvad.mullvadvpn.BuildConfig
-import net.mullvad.mullvadvpn.constant.GRPC_SOCKET_FILE_NAME
+import net.mullvad.mullvadvpn.lib.common.constant.GRPC_SOCKET_FILE_NAME
+import net.mullvad.mullvadvpn.lib.common.constant.GRPC_SOCKET_FILE_NAMED_ARGUMENT
 import net.mullvad.mullvadvpn.lib.daemon.grpc.ManagementService
 import net.mullvad.mullvadvpn.lib.intent.IntentProvider
 import net.mullvad.mullvadvpn.lib.model.BuildVersion
@@ -15,10 +17,12 @@ import org.koin.core.qualifier.named
 import org.koin.dsl.module
 
 val appModule = module {
-    single(named(RPC_SOCKET_PATH)) { "${androidContext().dataDir.path}/$GRPC_SOCKET_FILE_NAME" }
+    single(named(GRPC_SOCKET_FILE_NAMED_ARGUMENT)) {
+        File(androidContext().noBackupFilesDir, GRPC_SOCKET_FILE_NAME)
+    }
     single {
         ManagementService(
-            rpcSocketPath = get(named(RPC_SOCKET_PATH)),
+            rpcSocketFile = get(named(GRPC_SOCKET_FILE_NAMED_ARGUMENT)),
             extensiveLogging = BuildConfig.DEBUG,
             scope = MainScope(),
         )
@@ -30,5 +34,3 @@ val appModule = module {
     single { VpnPermissionRepository(androidContext()) }
     single { ConnectionProxy(get(), get()) }
 }
-
-const val RPC_SOCKET_PATH = "RPC_SOCKET"
diff --git a/android/lib/common/src/main/kotlin/net/mullvad/mullvadvpn/lib/common/constant/DiConstant.kt b/android/lib/common/src/main/kotlin/net/mullvad/mullvadvpn/lib/common/constant/DiConstant.kt
new file mode 100644
index 0000000000..0acd41c7ec
--- /dev/null
+++ b/android/lib/common/src/main/kotlin/net/mullvad/mullvadvpn/lib/common/constant/DiConstant.kt
@@ -0,0 +1,3 @@
+package net.mullvad.mullvadvpn.lib.common.constant
+
+const val GRPC_SOCKET_FILE_NAMED_ARGUMENT = "RPC_SOCKET"
diff --git a/android/lib/common/src/main/kotlin/net/mullvad/mullvadvpn/lib/common/constant/PathConstant.kt b/android/lib/common/src/main/kotlin/net/mullvad/mullvadvpn/lib/common/constant/PathConstant.kt
new file mode 100644
index 0000000000..4ad0471c86
--- /dev/null
+++ b/android/lib/common/src/main/kotlin/net/mullvad/mullvadvpn/lib/common/constant/PathConstant.kt
@@ -0,0 +1,3 @@
+package net.mullvad.mullvadvpn.lib.common.constant
+
+const val GRPC_SOCKET_FILE_NAME = "rpc-socket"
diff --git a/android/lib/daemon-grpc/src/main/kotlin/net/mullvad/mullvadvpn/lib/daemon/grpc/ManagementService.kt b/android/lib/daemon-grpc/src/main/kotlin/net/mullvad/mullvadvpn/lib/daemon/grpc/ManagementService.kt
index 987b7e56ea..10c2406850 100644
--- a/android/lib/daemon-grpc/src/main/kotlin/net/mullvad/mullvadvpn/lib/daemon/grpc/ManagementService.kt
+++ b/android/lib/daemon-grpc/src/main/kotlin/net/mullvad/mullvadvpn/lib/daemon/grpc/ManagementService.kt
@@ -16,6 +16,7 @@ import io.grpc.ConnectivityState
 import io.grpc.Status
 import io.grpc.StatusException
 import io.grpc.android.UdsChannelBuilder
+import java.io.File
 import java.net.InetAddress
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -127,14 +128,19 @@ import net.mullvad.mullvadvpn.lib.model.wireguardConstraints
 
 @Suppress("TooManyFunctions")
 class ManagementService(
-    rpcSocketPath: String,
+    rpcSocketFile: File,
     private val extensiveLogging: Boolean,
     private val scope: CoroutineScope,
 ) {
     private var job: Job? = null
 
+    // We expect daemon to create the rpc socket file on the path provided on initialisation
     private val channel =
-        UdsChannelBuilder.forPath(rpcSocketPath, LocalSocketAddress.Namespace.FILESYSTEM).build()
+        UdsChannelBuilder.forPath(
+                rpcSocketFile.absolutePath,
+                LocalSocketAddress.Namespace.FILESYSTEM
+            )
+            .build()
 
     val connectionState: StateFlow<GrpcConnectivityState> =
         channel
diff --git a/android/service/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadDaemon.kt b/android/service/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadDaemon.kt
index aa6f07e9bb..2c441483f6 100644
--- a/android/service/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadDaemon.kt
+++ b/android/service/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadDaemon.kt
@@ -17,6 +17,7 @@ private const val RELAYS_FILE = "relays.json"
 @SuppressLint("SdCardPath")
 class MullvadDaemon(
     vpnService: MullvadVpnService,
+    rpcSocketFile: File,
     apiEndpointConfiguration: ApiEndpointConfiguration,
     migrateSplitTunneling: MigrateSplitTunneling
 ) {
@@ -34,8 +35,9 @@ class MullvadDaemon(
 
         initialize(
             vpnService = vpnService,
+            rpcSocketPath = rpcSocketFile.absolutePath,
+            filesDirectory = vpnService.filesDir.absolutePath,
             cacheDirectory = vpnService.cacheDir.absolutePath,
-            resourceDirectory = vpnService.filesDir.absolutePath,
             apiEndpoint = apiEndpointConfiguration.apiEndpoint()
         )
     }
@@ -69,8 +71,9 @@ class MullvadDaemon(
 
     private external fun initialize(
         vpnService: MullvadVpnService,
+        rpcSocketPath: String,
+        filesDirectory: String,
         cacheDirectory: String,
-        resourceDirectory: String,
         apiEndpoint: ApiEndpoint?
     )
 
diff --git a/android/service/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadVpnService.kt b/android/service/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadVpnService.kt
index e3940c8166..87f6076c3f 100644
--- a/android/service/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadVpnService.kt
+++ b/android/service/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadVpnService.kt
@@ -9,6 +9,7 @@ import android.util.Log
 import androidx.core.content.getSystemService
 import androidx.lifecycle.lifecycleScope
 import arrow.atomic.AtomicInt
+import java.io.File
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -17,6 +18,7 @@ import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
+import net.mullvad.mullvadvpn.lib.common.constant.GRPC_SOCKET_FILE_NAMED_ARGUMENT
 import net.mullvad.mullvadvpn.lib.common.constant.KEY_CONNECT_ACTION
 import net.mullvad.mullvadvpn.lib.common.constant.KEY_DISCONNECT_ACTION
 import net.mullvad.mullvadvpn.lib.common.constant.TAG
@@ -36,6 +38,7 @@ import net.mullvad.mullvadvpn.service.notifications.ShouldBeOnForegroundProvider
 import net.mullvad.talpid.TalpidVpnService
 import org.koin.android.ext.android.getKoin
 import org.koin.core.context.loadKoinModules
+import org.koin.core.qualifier.named
 
 class MullvadVpnService : TalpidVpnService(), ShouldBeOnForegroundProvider {
     private val _shouldBeOnForeground = MutableStateFlow(false)
@@ -49,6 +52,7 @@ class MullvadVpnService : TalpidVpnService(), ShouldBeOnForegroundProvider {
     private lateinit var migrateSplitTunneling: MigrateSplitTunneling
     private lateinit var intentProvider: IntentProvider
     private lateinit var connectionProxy: ConnectionProxy
+    private lateinit var rpcSocketFile: File
 
     private lateinit var foregroundNotificationHandler: ForegroundNotificationManager
 
@@ -75,6 +79,7 @@ class MullvadVpnService : TalpidVpnService(), ShouldBeOnForegroundProvider {
             migrateSplitTunneling = get()
             intentProvider = get()
             connectionProxy = get()
+            rpcSocketFile = get(named(GRPC_SOCKET_FILE_NAMED_ARGUMENT))
         }
 
         keyguardManager = getSystemService<KeyguardManager>()!!
@@ -88,6 +93,7 @@ class MullvadVpnService : TalpidVpnService(), ShouldBeOnForegroundProvider {
             daemonInstance =
                 MullvadDaemon(
                     vpnService = this@MullvadVpnService,
+                    rpcSocketFile = rpcSocketFile,
                     apiEndpointConfiguration =
                         intentProvider.getLatestIntent()?.getApiEndpointConfigurationExtras()
                             ?: apiEndpointConfiguration,
diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
index 47e72e07cb..0395983d22 100644
--- a/mullvad-daemon/src/lib.rs
+++ b/mullvad-daemon/src/lib.rs
@@ -2894,8 +2894,8 @@ fn oneshot_map<T1: Send + 'static, T2: Send + 'static>(
 
 /// Remove any old RPC socket (if it exists).
 #[cfg(not(windows))]
-pub async fn cleanup_old_rpc_socket() {
-    if let Err(err) = tokio::fs::remove_file(mullvad_paths::get_rpc_socket_path()).await {
+pub async fn cleanup_old_rpc_socket(rpc_socket_path: impl AsRef<std::path::Path>) {
+    if let Err(err) = tokio::fs::remove_file(rpc_socket_path).await {
         if err.kind() != std::io::ErrorKind::NotFound {
             log::error!("Failed to remove old RPC socket: {}", err);
         }
diff --git a/mullvad-daemon/src/main.rs b/mullvad-daemon/src/main.rs
index 510127fd05..64396f4f6f 100644
--- a/mullvad-daemon/src/main.rs
+++ b/mullvad-daemon/src/main.rs
@@ -5,7 +5,11 @@ use mullvad_daemon::{
     management_interface::{ManagementInterfaceEventBroadcaster, ManagementInterfaceServer},
     rpc_uniqueness_check, runtime, version, Daemon, DaemonCommandChannel, DaemonCommandSender,
 };
-use std::{path::PathBuf, thread, time::Duration};
+use std::{
+    path::{Path, PathBuf},
+    thread,
+    time::Duration,
+};
 use talpid_types::ErrorExt;
 
 mod cli;
@@ -163,7 +167,7 @@ fn get_log_dir(config: &cli::Config) -> Result<Option<PathBuf>, String> {
 
 async fn run_standalone(log_dir: Option<PathBuf>) -> Result<(), String> {
     #[cfg(not(windows))]
-    cleanup_old_rpc_socket().await;
+    cleanup_old_rpc_socket(mullvad_paths::get_rpc_socket_path()).await;
 
     if !running_as_admin() {
         log::warn!("Running daemon as a non-administrator user, clients might refuse to connect");
@@ -192,6 +196,7 @@ async fn run_standalone(log_dir: Option<PathBuf>) -> Result<(), String> {
 async fn create_daemon(
     log_dir: Option<PathBuf>,
 ) -> Result<Daemon<ManagementInterfaceEventBroadcaster>, String> {
+    let rpc_socket_path = mullvad_paths::get_rpc_socket_path();
     let resource_dir = mullvad_paths::get_resource_dir();
     let settings_dir = mullvad_paths::settings_dir()
         .map_err(|e| e.display_chain_with_msg("Unable to get settings dir"))?;
@@ -199,7 +204,7 @@ async fn create_daemon(
         .map_err(|e| e.display_chain_with_msg("Unable to get cache dir"))?;
 
     let command_channel = DaemonCommandChannel::new();
-    let event_listener = spawn_management_interface(command_channel.sender())?;
+    let event_listener = spawn_management_interface(command_channel.sender(), rpc_socket_path)?;
 
     Daemon::start(
         log_dir,
@@ -215,13 +220,17 @@ async fn create_daemon(
 
 fn spawn_management_interface(
     command_sender: DaemonCommandSender,
+    rpc_socket_path: impl AsRef<Path>,
 ) -> Result<ManagementInterfaceEventBroadcaster, String> {
-    let (socket_path, event_broadcaster) = ManagementInterfaceServer::start(command_sender)
+    let event_broadcaster = ManagementInterfaceServer::start(command_sender, &rpc_socket_path)
         .map_err(|error| {
             error.display_chain_with_msg("Unable to start management interface server")
         })?;
 
-    log::info!("Management interface listening on {}", socket_path);
+    log::info!(
+        "Management interface listening on {}",
+        rpc_socket_path.as_ref().display()
+    );
 
     Ok(event_broadcaster)
 }
diff --git a/mullvad-daemon/src/management_interface.rs b/mullvad-daemon/src/management_interface.rs
index d8f18b5732..269432be30 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -21,6 +21,7 @@ use mullvad_types::{
     wireguard::{RotationInterval, RotationIntervalError},
 };
 use std::{
+    path::Path,
     str::FromStr,
     sync::{Arc, Mutex},
     time::Duration,
@@ -1024,21 +1025,22 @@ pub struct ManagementInterfaceServer(());
 impl ManagementInterfaceServer {
     pub fn start(
         tunnel_tx: DaemonCommandSender,
-    ) -> Result<(String, ManagementInterfaceEventBroadcaster), Error> {
+        rpc_socket_path: impl AsRef<Path>,
+    ) -> Result<ManagementInterfaceEventBroadcaster, Error> {
         let subscriptions = Arc::<Mutex<Vec<EventsListenerSender>>>::default();
 
-        let socket_path = mullvad_paths::get_rpc_socket_path()
-            .to_string_lossy()
-            .to_string();
-
         let (server_abort_tx, server_abort_rx) = mpsc::channel(0);
         let server = ManagementServiceImpl {
             daemon_tx: tunnel_tx,
             subscriptions: subscriptions.clone(),
         };
-        let join_handle = mullvad_management_interface::spawn_rpc_server(server, async move {
-            server_abort_rx.into_future().await;
-        })
+        let join_handle = mullvad_management_interface::spawn_rpc_server(
+            server,
+            async move {
+                server_abort_rx.into_future().await;
+            },
+            rpc_socket_path,
+        )
         .map_err(Error::SetupError)?;
 
         tokio::spawn(async move {
@@ -1048,13 +1050,10 @@ impl ManagementInterfaceServer {
             log::info!("Management interface shut down");
         });
 
-        Ok((
-            socket_path,
-            ManagementInterfaceEventBroadcaster {
-                subscriptions,
-                _close_handle: server_abort_tx,
-            },
-        ))
+        Ok(ManagementInterfaceEventBroadcaster {
+            subscriptions,
+            _close_handle: server_abort_tx,
+        })
     }
 }
 
diff --git a/mullvad-jni/Cargo.toml b/mullvad-jni/Cargo.toml
index f1432d49d4..c964c3adc9 100644
--- a/mullvad-jni/Cargo.toml
+++ b/mullvad-jni/Cargo.toml
@@ -27,9 +27,9 @@ log-panics = "2"
 nix = "0.23"
 rand = "0.8.5"
 
+mullvad-api = { path = "../mullvad-api" }
 mullvad-daemon = { path = "../mullvad-daemon" }
 mullvad-problem-report = { path = "../mullvad-problem-report" }
 mullvad-types = { path = "../mullvad-types" }
-mullvad-api = { path = "../mullvad-api" }
 talpid-tunnel = { path = "../talpid-tunnel" }
 talpid-types = { path = "../talpid-types" }
diff --git a/mullvad-jni/src/lib.rs b/mullvad-jni/src/lib.rs
index 66588d603a..67e40ea534 100644
--- a/mullvad-jni/src/lib.rs
+++ b/mullvad-jni/src/lib.rs
@@ -65,13 +65,15 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_service_MullvadDaemon_initial
     env: JNIEnv<'_>,
     this: JObject<'_>,
     vpnService: JObject<'_>,
+    rpcSocketPath: JObject<'_>,
+    filesDirectory: JObject<'_>,
     cacheDirectory: JObject<'_>,
-    resourceDirectory: JObject<'_>,
     apiEndpoint: JObject<'_>,
 ) {
     let env = JnixEnv::from(env);
+    let rpc_socket = PathBuf::from(String::from_java(&env, rpcSocketPath));
+    let files_dir = PathBuf::from(String::from_java(&env, filesDirectory));
     let cache_dir = PathBuf::from(String::from_java(&env, cacheDirectory));
-    let resource_dir = PathBuf::from(String::from_java(&env, resourceDirectory));
 
     let api_endpoint = if !apiEndpoint.is_null() {
         #[cfg(feature = "api-override")]
@@ -87,7 +89,7 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_service_MullvadDaemon_initial
         None
     };
 
-    match start_logging(&resource_dir) {
+    match start_logging(&files_dir) {
         Ok(()) => {
             version::log_version();
 
@@ -97,8 +99,9 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_service_MullvadDaemon_initial
                 &env,
                 &this,
                 &vpnService,
+                rpc_socket,
+                files_dir,
                 cache_dir,
-                resource_dir,
                 api_endpoint,
             ) {
                 log::error!("{}", error.display_chain());
@@ -224,8 +227,9 @@ fn initialize(
     env: &JnixEnv<'_>,
     this: &JObject<'_>,
     vpn_service: &JObject<'_>,
+    rpc_socket: PathBuf,
+    files_dir: PathBuf,
     cache_dir: PathBuf,
-    resource_dir: PathBuf,
     api_endpoint: Option<mullvad_api::ApiEndpoint>,
 ) -> Result<(), Error> {
     let android_context = create_android_context(env, *vpn_service)?;
@@ -235,8 +239,9 @@ fn initialize(
     spawn_daemon(
         env,
         this,
+        rpc_socket,
+        files_dir,
         cache_dir,
-        resource_dir,
         api_endpoint,
         daemon_command_channel,
         android_context,
@@ -259,11 +264,13 @@ fn create_android_context(
     })
 }
 
+#[allow(clippy::too_many_arguments)]
 fn spawn_daemon(
     env: &JnixEnv<'_>,
     this: &JObject<'_>,
+    rpc_socket: PathBuf,
+    files_dir: PathBuf,
     cache_dir: PathBuf,
-    resource_dir: PathBuf,
     #[cfg_attr(not(feature = "api-override"), allow(unused_variables))] api_endpoint: Option<
         mullvad_api::ApiEndpoint,
     >,
@@ -298,10 +305,10 @@ fn spawn_daemon(
             }
         }
 
-        runtime.block_on(cleanup_old_rpc_socket());
+        runtime.block_on(cleanup_old_rpc_socket(&rpc_socket));
 
         let event_listener = match runtime
-            .block_on(async { spawn_management_interface(command_channel.sender()) })
+            .block_on(async { spawn_management_interface(command_channel.sender(), &rpc_socket) })
         {
             Ok(event_listener) => event_listener,
             Err(error) => {
@@ -311,9 +318,9 @@ fn spawn_daemon(
         };
 
         let daemon = runtime.block_on(Daemon::start(
-            Some(resource_dir.clone()),
-            resource_dir.clone(),
-            resource_dir,
+            Some(files_dir.clone()),
+            files_dir.clone(),
+            files_dir,
             cache_dir,
             event_listener,
             command_channel,
@@ -348,8 +355,9 @@ use mullvad_daemon::{
 
 fn spawn_management_interface(
     command_sender: DaemonCommandSender,
+    rpc_socket_path: impl AsRef<Path>,
 ) -> Result<ManagementInterfaceEventBroadcaster, Error> {
-    let (socket_path, event_broadcaster) = ManagementInterfaceServer::start(command_sender)
+    let event_broadcaster = ManagementInterfaceServer::start(command_sender, &rpc_socket_path)
         .map_err(|error| {
             log::error!(
                 "{}",
@@ -358,7 +366,10 @@ fn spawn_management_interface(
             Error::SpawnManagementInterface(error)
         })?;
 
-    log::info!("Management interface listening on {}", socket_path);
+    log::info!(
+        "Management interface listening on {}",
+        rpc_socket_path.as_ref().display()
+    );
 
     Ok(event_broadcaster)
 }
diff --git a/mullvad-management-interface/src/client.rs b/mullvad-management-interface/src/client.rs
index 35ffb57622..6a3b794b39 100644
--- a/mullvad-management-interface/src/client.rs
+++ b/mullvad-management-interface/src/client.rs
@@ -1,32 +1,43 @@
 //! Client that returns and takes mullvad types as arguments instead of prost-generated types
 
 use crate::types;
+#[cfg(not(target_os = "android"))]
 use futures::{Stream, StreamExt};
 #[cfg(target_os = "windows")]
 use mullvad_types::wireguard::DaitaSettings;
 use mullvad_types::{
-    access_method::{self, AccessMethod, AccessMethodSetting},
+    access_method::AccessMethodSetting,
+    device::{DeviceEvent, RemoveDeviceEvent},
+    relay_list::RelayList,
+    settings::Settings,
+    states::TunnelState,
+    version::AppVersionInfo,
+};
+
+#[cfg(not(target_os = "android"))]
+use mullvad_types::{
+    access_method::{self, AccessMethod},
     account::{AccountData, AccountToken, VoucherSubmission},
     custom_list::{CustomList, Id},
-    device::{Device, DeviceEvent, DeviceId, DeviceState, RemoveDeviceEvent},
+    device::{Device, DeviceId, DeviceState},
     relay_constraints::{
         BridgeSettings, BridgeState, ObfuscationSettings, RelayOverride, RelaySettings,
     },
-    relay_list::RelayList,
-    settings::{DnsOptions, Settings},
-    states::TunnelState,
-    version::AppVersionInfo,
+    settings::DnsOptions,
     wireguard::{PublicKey, QuantumResistantState, RotationInterval},
 };
+#[cfg(not(target_os = "android"))]
 use std::{path::Path, str::FromStr};
 #[cfg(target_os = "windows")]
 use talpid_types::split_tunnel::ExcludedProcess;
+#[cfg(not(target_os = "android"))]
 use tonic::{Code, Status};
 
 type Error = super::Error;
 
 pub type Result<T> = std::result::Result<T, super::Error>;
 
+#[cfg(not(target_os = "android"))]
 #[derive(Debug, Clone)]
 pub struct MullvadProxyClient(crate::ManagementServiceClient);
 
@@ -73,6 +84,7 @@ impl TryFrom<types::daemon_event::Event> for DaemonEvent {
     }
 }
 
+#[cfg(not(target_os = "android"))]
 impl MullvadProxyClient {
     pub async fn new() -> Result<Self> {
         #[allow(deprecated)]
@@ -712,6 +724,7 @@ impl MullvadProxyClient {
     }
 }
 
+#[cfg(not(target_os = "android"))]
 fn map_device_error(status: Status) -> Error {
     match status.code() {
         Code::ResourceExhausted => Error::TooManyDevices,
@@ -722,6 +735,7 @@ fn map_device_error(status: Status) -> Error {
     }
 }
 
+#[cfg(not(target_os = "android"))]
 fn map_custom_list_error(status: Status) -> Error {
     match status.code() {
         Code::NotFound => {
diff --git a/mullvad-management-interface/src/lib.rs b/mullvad-management-interface/src/lib.rs
index 763d2474ec..43b9974d59 100644
--- a/mullvad-management-interface/src/lib.rs
+++ b/mullvad-management-interface/src/lib.rs
@@ -11,7 +11,10 @@ use std::{
     task::{Context, Poll},
 };
 use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-use tonic::transport::{server::Connected, Endpoint, Server, Uri};
+use tonic::transport::{server::Connected, Server};
+#[cfg(not(target_os = "android"))]
+use tonic::transport::{Endpoint, Uri};
+#[cfg(not(target_os = "android"))]
 use tower::service_fn;
 
 pub use tonic::{async_trait, transport::Channel, Code, Request, Response, Status};
@@ -111,6 +114,7 @@ pub enum Error {
     ApiAccessMethodNotFound,
 }
 
+#[cfg(not(target_os = "android"))]
 #[deprecated(note = "Prefer MullvadProxyClient")]
 pub async fn new_rpc_client() -> Result<ManagementServiceClient, Error> {
     let ipc_path = mullvad_paths::get_rpc_socket_path();
@@ -126,6 +130,7 @@ pub async fn new_rpc_client() -> Result<ManagementServiceClient, Error> {
     Ok(ManagementServiceClient::new(channel))
 }
 
+#[cfg(not(target_os = "android"))]
 pub use client::MullvadProxyClient;
 
 pub type ServerJoinHandle = tokio::task::JoinHandle<Result<(), Error>>;
@@ -133,13 +138,12 @@ pub type ServerJoinHandle = tokio::task::JoinHandle<Result<(), Error>>;
 pub fn spawn_rpc_server<T: ManagementService, F: Future<Output = ()> + Send + 'static>(
     service: T,
     abort_rx: F,
+    rpc_socket_path: impl AsRef<std::path::Path>,
 ) -> std::result::Result<ServerJoinHandle, Error> {
     use futures::stream::TryStreamExt;
     use parity_tokio_ipc::SecurityAttributes;
 
-    let socket_path = mullvad_paths::get_rpc_socket_path();
-
-    let mut endpoint = IpcEndpoint::new(socket_path.to_string_lossy().to_string());
+    let mut endpoint = IpcEndpoint::new(rpc_socket_path.as_ref().to_string_lossy().to_string());
     endpoint.set_security_attributes(
         SecurityAttributes::allow_everyone_create()
             .map_err(Error::SecurityAttributes)?
@@ -153,8 +157,9 @@ pub fn spawn_rpc_server<T: ManagementService, F: Future<Output = ()> + Send + 's
         let group = nix::unistd::Group::from_name(group_name)
             .map_err(Error::ObtainGidError)?
             .ok_or(Error::NoGidError)?;
-        nix::unistd::chown(&socket_path, None, Some(group.gid)).map_err(Error::SetGidError)?;
-        fs::set_permissions(&socket_path, PermissionsExt::from_mode(0o760))
+        nix::unistd::chown(rpc_socket_path.as_ref(), None, Some(group.gid))
+            .map_err(Error::SetGidError)?;
+        fs::set_permissions(rpc_socket_path, PermissionsExt::from_mode(0o760))
             .map_err(Error::PermissionsError)?;
     }
 
diff --git a/mullvad-paths/Cargo.toml b/mullvad-paths/Cargo.toml
index 32f47efdaa..4a62bedde7 100644
--- a/mullvad-paths/Cargo.toml
+++ b/mullvad-paths/Cargo.toml
@@ -12,8 +12,6 @@ workspace = true
 
 [dependencies]
 thiserror = { workspace = true }
-
-[target.'cfg(not(target_os="android"))'.dependencies]
 log = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
diff --git a/mullvad-paths/src/cache.rs b/mullvad-paths/src/cache.rs
index cbd110cd59..dfd7a46cae 100644
--- a/mullvad-paths/src/cache.rs
+++ b/mullvad-paths/src/cache.rs
@@ -20,28 +20,22 @@ pub fn get_cache_dir() -> Result<PathBuf> {
     }
 }
 
+#[cfg(target_os = "linux")]
 pub fn get_default_cache_dir() -> Result<PathBuf> {
-    #[cfg(not(target_os = "android"))]
-    {
-        let dir;
-        #[cfg(target_os = "linux")]
-        {
-            dir = PathBuf::from("/var/cache").join(crate::PRODUCT_NAME);
-        }
-        #[cfg(windows)]
-        {
-            dir = crate::get_allusersprofile_dir()?
-                .join(crate::PRODUCT_NAME)
-                .join("cache");
-        }
-        #[cfg(target_os = "macos")]
-        {
-            dir = std::path::Path::new("/Library/Caches").join(crate::PRODUCT_NAME);
-        }
-        Ok(dir)
-    }
-    #[cfg(target_os = "android")]
-    {
-        Ok(std::path::Path::new(crate::APP_PATH).join("cache"))
-    }
+    let dir = PathBuf::from("/var/cache").join(crate::PRODUCT_NAME);
+    Ok(dir)
+}
+
+#[cfg(windows)]
+pub fn get_default_cache_dir() -> Result<PathBuf> {
+    let dir = crate::get_allusersprofile_dir()?
+        .join(crate::PRODUCT_NAME)
+        .join("cache");
+    Ok(dir)
+}
+
+#[cfg(target_os = "macos")]
+pub fn get_default_cache_dir() -> Result<PathBuf> {
+    let dir = std::path::Path::new("/Library/Caches").join(crate::PRODUCT_NAME);
+    Ok(dir)
 }
diff --git a/mullvad-paths/src/lib.rs b/mullvad-paths/src/lib.rs
index 3cd58a6a51..05641360c0 100644
--- a/mullvad-paths/src/lib.rs
+++ b/mullvad-paths/src/lib.rs
@@ -1,4 +1,6 @@
-#[cfg(not(target_os = "windows"))]
+#![cfg(not(target_os = "android"))]
+
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 use std::fs;
 use std::{io, path::PathBuf};
 
@@ -26,6 +28,9 @@ pub enum Error {
     #[cfg(windows)]
     #[error("Failed to create security attributes")]
     GetSecurityAttributes(#[source] io::Error),
+
+    #[error("Device data directory has not been set")]
+    NoDataDir,
 }
 
 #[cfg(any(target_os = "linux", target_os = "macos"))]
@@ -34,9 +39,6 @@ const PRODUCT_NAME: &str = "mullvad-vpn";
 #[cfg(windows)]
 pub const PRODUCT_NAME: &str = "Mullvad VPN";
 
-#[cfg(target_os = "android")]
-const APP_PATH: &str = "/data/data/net.mullvad.mullvadvpn";
-
 #[cfg(windows)]
 fn get_allusersprofile_dir() -> Result<PathBuf> {
     match std::env::var_os("ALLUSERSPROFILE") {
@@ -45,7 +47,7 @@ fn get_allusersprofile_dir() -> Result<PathBuf> {
     }
 }
 
-#[cfg(not(target_os = "windows"))]
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 fn create_and_return(
     dir_fn: fn() -> Result<PathBuf>,
     permissions: Option<fs::Permissions>,
diff --git a/mullvad-paths/src/logs.rs b/mullvad-paths/src/logs.rs
index d7f2c58f95..53f7763589 100644
--- a/mullvad-paths/src/logs.rs
+++ b/mullvad-paths/src/logs.rs
@@ -1,7 +1,4 @@
 use crate::Result;
-
-#[cfg(unix)]
-use std::os::unix::fs::PermissionsExt;
 use std::{env, path::PathBuf};
 
 /// Creates and returns the logging directory pointed to by `MULLVAD_LOG_DIR`, or the default
@@ -9,6 +6,7 @@ use std::{env, path::PathBuf};
 pub fn log_dir() -> Result<PathBuf> {
     #[cfg(unix)]
     {
+        use std::os::unix::fs::PermissionsExt;
         let permissions = Some(PermissionsExt::from_mode(0o755));
         crate::create_and_return(get_log_dir, permissions)
     }
@@ -26,22 +24,14 @@ pub fn get_log_dir() -> Result<PathBuf> {
     }
 }
 
+#[cfg(unix)]
 pub fn get_default_log_dir() -> Result<PathBuf> {
-    #[cfg(not(target_os = "android"))]
-    {
-        let dir;
-        #[cfg(unix)]
-        {
-            dir = Ok(PathBuf::from("/var/log"));
-        }
-        #[cfg(windows)]
-        {
-            dir = crate::get_allusersprofile_dir();
-        }
-        dir.map(|dir| dir.join(crate::PRODUCT_NAME))
-    }
-    #[cfg(target_os = "android")]
-    {
-        Ok(PathBuf::from(crate::APP_PATH))
-    }
+    let dir = PathBuf::from("/var/log").join(crate::PRODUCT_NAME);
+    Ok(dir)
+}
+
+#[cfg(windows)]
+pub fn get_default_log_dir() -> Result<PathBuf> {
+    let dir = crate::get_allusersprofile_dir()?.join(crate::PRODUCT_NAME);
+    Ok(dir)
 }
diff --git a/mullvad-paths/src/resources.rs b/mullvad-paths/src/resources.rs
index ed6845bdf0..533e252171 100644
--- a/mullvad-paths/src/resources.rs
+++ b/mullvad-paths/src/resources.rs
@@ -8,24 +8,17 @@ pub fn get_resource_dir() -> PathBuf {
 }
 
 pub fn get_default_resource_dir() -> PathBuf {
-    #[cfg(not(target_os = "android"))]
-    {
-        match env::current_exe() {
-            Ok(mut path) => {
-                path.pop();
-                path
-            }
-            Err(e) => {
-                log::error!(
-                    "Failed finding the install directory. Using working directory: {}",
-                    e
-                );
-                PathBuf::from(".")
-            }
+    match env::current_exe() {
+        Ok(mut path) => {
+            path.pop();
+            path
+        }
+        Err(e) => {
+            log::error!(
+                "Failed finding the install directory. Using working directory: {}",
+                e
+            );
+            PathBuf::from(".")
         }
-    }
-    #[cfg(target_os = "android")]
-    {
-        PathBuf::from(crate::APP_PATH)
     }
 }
diff --git a/mullvad-paths/src/rpc_socket.rs b/mullvad-paths/src/rpc_socket.rs
index 8d8bf395f3..80eb4360d2 100644
--- a/mullvad-paths/src/rpc_socket.rs
+++ b/mullvad-paths/src/rpc_socket.rs
@@ -1,7 +1,7 @@
-use std::{env, path::PathBuf};
+use std::path::PathBuf;
 
 pub fn get_rpc_socket_path() -> PathBuf {
-    match env::var_os("MULLVAD_RPC_SOCKET_PATH") {
+    match std::env::var_os("MULLVAD_RPC_SOCKET_PATH") {
         Some(path) => PathBuf::from(path),
         None => get_default_rpc_socket_path(),
     }
@@ -16,8 +16,3 @@ pub fn get_default_rpc_socket_path() -> PathBuf {
 pub fn get_default_rpc_socket_path() -> PathBuf {
     PathBuf::from("//./pipe/Mullvad VPN")
 }
-
-#[cfg(target_os = "android")]
-pub fn get_default_rpc_socket_path() -> PathBuf {
-    PathBuf::from(format!("{}/rpc-socket", crate::APP_PATH))
-}
diff --git a/mullvad-paths/src/settings.rs b/mullvad-paths/src/settings.rs
index 2667211406..d6ebabe6e7 100644
--- a/mullvad-paths/src/settings.rs
+++ b/mullvad-paths/src/settings.rs
@@ -22,24 +22,19 @@ fn get_settings_dir() -> Result<PathBuf> {
     }
 }
 
-#[cfg(not(target_os = "android"))]
+#[cfg(windows)]
 pub fn get_default_settings_dir() -> Result<PathBuf> {
-    let dir;
-    #[cfg(unix)]
-    {
-        dir = Ok(PathBuf::from("/etc"));
-    }
-    #[cfg(windows)]
-    {
-        dir = crate::windows::get_system_service_appdata().map_err(|error| {
+    let dir = crate::windows::get_system_service_appdata()
+        .map_err(|error| {
             log::error!("Failed to obtain system app data path: {error}");
             crate::Error::FindDirError
-        })
-    }
-    dir.map(|dir| dir.join(crate::PRODUCT_NAME))
+        })?
+        .join(crate::PRODUCT_NAME);
+    Ok(dir)
 }
 
-#[cfg(target_os = "android")]
+#[cfg(unix)]
 pub fn get_default_settings_dir() -> Result<PathBuf> {
-    Ok(PathBuf::from(crate::APP_PATH))
+    let dir = PathBuf::from("/etc").join(crate::PRODUCT_NAME);
+    Ok(dir)
 }
diff --git a/mullvad-problem-report/src/lib.rs b/mullvad-problem-report/src/lib.rs
index fc8306a8f1..74076a8b5a 100644
--- a/mullvad-problem-report/src/lib.rs
+++ b/mullvad-problem-report/src/lib.rs
@@ -72,6 +72,7 @@ pub enum Error {
     #[error("Unable to spawn Tokio runtime")]
     CreateRuntime(#[source] io::Error),
 
+    #[cfg(not(target_os = "android"))]
     #[error("Unable to find cache directory")]
     ObtainCacheDirectory(#[source] mullvad_paths::Error),
 }
@@ -81,6 +82,7 @@ pub enum Error {
 /// instead of whatever content was supposed to be there.
 #[derive(thiserror::Error, Debug)]
 pub enum LogError {
+    #[cfg(not(target_os = "android"))]
     #[error("Unable to get log directory")]
     GetLogDir(#[source] mullvad_paths::Error),