Fix building for Android

Author: buggmagnet

mullvad-api/src/api.rs

@@ -4,6 +4,8 @@
 //! [`ApiConnectionMode`], which in turn is used by `mullvad-api` for
 //! establishing connections when performing API requests.
 
+#[cfg(feature = "api-override")]
+use crate::ApiEndpoint;
 use crate::{
     proxy::{AllowedClientsProvider, ApiConnectionMode, ConnectionModeProvider, ProxyConfig},
     AddressCache,
@@ -12,17 +14,13 @@ use futures::{
     channel::{mpsc, oneshot},
     StreamExt,
 };
-#[cfg(feature = "api-override")]
-use mullvad_api::ApiEndpoint;
 use mullvad_encrypted_dns_proxy::state::EncryptedDnsProxyState;
 use mullvad_relay_selector::RelaySelector;
 use mullvad_types::access_method::{
     AccessMethod, AccessMethodSetting, BuiltInAccessMethod, Id, Settings,
 };
 use std::{net::SocketAddr, path::PathBuf};
-use talpid_types::net::{
-    proxy::CustomProxy, AllowedEndpoint, Endpoint, TransportProtocol,
-};
+use talpid_types::net::{proxy::CustomProxy, AllowedEndpoint, Endpoint, TransportProtocol};
 
 pub enum Message {
     Get(ResponseTx<ResolvedConnectionMode>),
@@ -306,6 +304,8 @@ impl AccessModeSelector {
         let api_connection_mode = initial_connection_mode.connection_mode.clone();
 
         let selector = AccessModeSelector {
+            #[cfg(feature = "api-override")]
+            api_endpoint,
             cmd_rx,
             cache_dir,
             relay_selector,
@@ -317,8 +317,6 @@ impl AccessModeSelector {
             current: initial_connection_mode,
             index,
             provider,
-            #[cfg(feature = "api-override")]
-            api_endpoint,
         };
 
         tokio::spawn(selector.into_future());

mullvad-api/src/bin/relay_list.rs

@@ -2,13 +2,20 @@
 //! Used by the installer artifact packer to bundle the latest available
 //! relay list at the time of creating the installer.
 
+#[cfg(not(target_os = "android"))]
 use mullvad_api::{
     proxy::ApiConnectionMode, rest::Error as RestError, ApiEndpoint, RelayListProxy,
 };
+#[cfg(not(target_os = "android"))]
 use std::process;
+#[cfg(not(target_os = "android"))]
 use talpid_types::ErrorExt;
 
 #[tokio::main]
+#[cfg(target_os = "android")]
+async fn main() {}
+#[tokio::main]
+#[cfg(not(target_os = "android"))]
 async fn main() {
     let runtime = mullvad_api::Runtime::new(
         tokio::runtime::Handle::current(),

mullvad-daemon/src/access_method.rs

@@ -1,6 +1,5 @@
 use crate::{settings, Daemon};
-use mullvad_api::{api, rest};
-use mullvad_api::{proxy::ApiConnectionMode, ApiProxy};
+use mullvad_api::{api, proxy::ApiConnectionMode, rest, ApiProxy};
 use mullvad_types::{
     access_method::{self, AccessMethod, AccessMethodSetting},
     settings::Settings,
@@ -154,7 +153,7 @@ impl Daemon {
     #[cfg(not(target_os = "android"))]
     pub(crate) async fn test_access_method(
         proxy: talpid_types::net::AllowedEndpoint,
-        access_method_selector: mullvad_api::api::AccessModeSelectorHandle,
+        access_method_selector: api::AccessModeSelectorHandle,
         daemon_event_sender: crate::DaemonEventSender<(
             mullvad_api::api::AccessMethodEvent,
             futures::channel::oneshot::Sender<()>,

mullvad-daemon/src/api.rs

@@ -1,33 +1,15 @@
 #[cfg(target_os = "android")]
 use crate::DaemonCommand;
-use futures::channel::mpsc;
-use futures::StreamExt;
-use mullvad_api::availability::ApiAvailability;
-use mullvad_api::proxy::AllowedClientsProvider;
-use mullvad_api::proxy::ApiConnectionMode;
-use mullvad_api::proxy::ProxyConfig;
-use talpid_types::net::AllowedClients;
-use talpid_types::net::Connectivity;
-
 #[cfg(target_os = "android")]
-pub(crate) fn create_bypass_tx(
-    event_sender: &DaemonEventSender,
-) -> Option<mpsc::Sender<mullvad_api::SocketBypassRequest>> {
-    let (bypass_tx, mut bypass_rx) = mpsc::channel(1);
-    let daemon_tx = event_sender.to_specialized_sender();
-    tokio::spawn(async move {
-        while let Some((raw_fd, done_tx)) = bypass_rx.next().await {
-            if daemon_tx
-                .send(DaemonCommand::BypassSocket(raw_fd, done_tx))
-                .is_err()
-            {
-                log::error!("Can't send socket bypass request to daemon");
-                break;
-            }
-        }
-    });
-    Some(bypass_tx)
-}
+use crate::DaemonEventSender;
+use futures::{channel::mpsc, StreamExt};
+use mullvad_api::{
+    availability::ApiAvailability,
+    proxy::{AllowedClientsProvider, ApiConnectionMode, ProxyConfig},
+};
+#[cfg(target_os = "android")]
+use talpid_core::mpsc::Sender;
+use talpid_types::net::{AllowedClients, Connectivity};
 
 #[derive(Clone, Copy)]
 pub struct AllowedClientsSelector {}
@@ -60,6 +42,26 @@ impl AllowedClientsProvider for AllowedClientsSelector {
     }
 }
 
+#[cfg(target_os = "android")]
+pub(crate) fn create_bypass_tx(
+    event_sender: &DaemonEventSender,
+) -> Option<mpsc::Sender<mullvad_api::SocketBypassRequest>> {
+    let (bypass_tx, mut bypass_rx) = mpsc::channel(1);
+    let daemon_tx = event_sender.to_specialized_sender();
+    tokio::spawn(async move {
+        while let Some((raw_fd, done_tx)) = bypass_rx.next().await {
+            if daemon_tx
+                .send(DaemonCommand::BypassSocket(raw_fd, done_tx))
+                .is_err()
+            {
+                log::error!("Can't send socket bypass request to daemon");
+                break;
+            }
+        }
+    });
+    Some(bypass_tx)
+}
+
 /// Forwards the received values from `offline_state_rx` to the [`ApiAvailability`].
 pub(crate) fn forward_offline_state(
     api_availability: ApiAvailability,

mullvad-jni/Cargo.toml

@@ -12,7 +12,7 @@ workspace = true
 
 [features]
 # Allow the API server to use to be configured
-api-override = ["mullvad-api/api-override"]
+api-override = ["mullvad-api/api-override", "mullvad-daemon/api-override"]
 
 [lib]
 crate-type = ["cdylib"]