Move vpn service classes to service module

23 files changed, 0 insertions, 2514 deletions

diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/di/VpnServiceModule.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/di/VpnServiceModule.kt
deleted file mode 100644
index 431023caa2..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/di/VpnServiceModule.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-package net.mullvad.mullvadvpn.di
-
-import androidx.core.app.NotificationManagerCompat
-import org.koin.android.ext.koin.androidContext
-import org.koin.dsl.module
-
-val vpnServiceModule = module { single { NotificationManagerCompat.from(androidContext()) } }
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/DaemonInstance.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/DaemonInstance.kt
deleted file mode 100644
index 4e121bc693..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/DaemonInstance.kt
+++ /dev/null
@@ -1,85 +0,0 @@
-package net.mullvad.mullvadvpn.service
-
-import kotlin.properties.Delegates.observable
-import kotlin.reflect.KClass
-import kotlin.reflect.safeCast
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.ClosedReceiveChannelException
-import kotlinx.coroutines.channels.ReceiveChannel
-import kotlinx.coroutines.channels.actor
-import kotlinx.coroutines.channels.trySendBlocking
-import net.mullvad.mullvadvpn.lib.common.util.Intermittent
-import net.mullvad.mullvadvpn.lib.endpoint.ApiEndpointConfiguration
-
-class DaemonInstance(private val vpnService: MullvadVpnService) {
-    sealed class Command {
-        data class Start(val apiEndpointConfiguration: ApiEndpointConfiguration) : Command()
-        object Stop : Command()
-    }
-
-    private val commandChannel = spawnActor()
-
-    private var daemon by
-        observable<MullvadDaemon?>(null) { _, oldInstance, _ -> oldInstance?.onDestroy() }
-
-    val intermittentDaemon = Intermittent<MullvadDaemon>()
-
-    fun start(apiEndpointConfiguration: ApiEndpointConfiguration) {
-        commandChannel.trySendBlocking(Command.Start(apiEndpointConfiguration))
-    }
-
-    fun stop() {
-        commandChannel.trySendBlocking(Command.Stop)
-    }
-
-    fun onDestroy() {
-        commandChannel.close()
-        intermittentDaemon.onDestroy()
-    }
-
-    private fun spawnActor() =
-        GlobalScope.actor(Dispatchers.Default, Channel.UNLIMITED) {
-            var isRunning = true
-
-            while (isRunning) {
-                val startCommand = waitForCommand(channel, Command.Start::class) ?: break
-                startDaemon(startCommand.apiEndpointConfiguration)
-                isRunning = waitForCommand(channel, Command.Stop::class) is Command.Stop
-                stopDaemon()
-            }
-        }
-
-    private suspend fun <T : Command> waitForCommand(
-        channel: ReceiveChannel<Command>,
-        command: KClass<T>
-    ): T? {
-        return try {
-            var receivedCommand: T?
-            do {
-                receivedCommand = command.safeCast(channel.receive())
-            } while (receivedCommand == null)
-            receivedCommand
-        } catch (exception: ClosedReceiveChannelException) {
-            null
-        }
-    }
-
-    private suspend fun startDaemon(apiEndpointConfiguration: ApiEndpointConfiguration) {
-        val newDaemon =
-            MullvadDaemon(vpnService, apiEndpointConfiguration).apply {
-                onDaemonStopped = {
-                    intermittentDaemon.spawnUpdate(null)
-                    daemon = null
-                }
-            }
-
-        daemon = newDaemon
-        intermittentDaemon.update(newDaemon)
-    }
-
-    private fun stopDaemon() {
-        daemon?.shutdown()
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/ForegroundNotificationManager.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/ForegroundNotificationManager.kt
deleted file mode 100644
index 36d640c719..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/ForegroundNotificationManager.kt
+++ /dev/null
@@ -1,117 +0,0 @@
-package net.mullvad.mullvadvpn.service
-
-import android.app.Service
-import kotlin.properties.Delegates.observable
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.actor
-import kotlinx.coroutines.channels.trySendBlocking
-import kotlinx.coroutines.flow.collect
-import kotlinx.coroutines.flow.onStart
-import net.mullvad.mullvadvpn.lib.common.util.Intermittent
-import net.mullvad.mullvadvpn.lib.common.util.JobTracker
-import net.mullvad.mullvadvpn.model.DeviceState
-import net.mullvad.mullvadvpn.model.TunnelState
-import net.mullvad.mullvadvpn.service.endpoint.ConnectionProxy
-import net.mullvad.mullvadvpn.service.notifications.TunnelStateNotification
-
-class ForegroundNotificationManager(
-    val service: MullvadVpnService,
-    val connectionProxy: ConnectionProxy,
-    val intermittentDaemon: Intermittent<MullvadDaemon>
-) {
-    private sealed class UpdaterMessage {
-        class UpdateNotification : UpdaterMessage()
-        class UpdateAction : UpdaterMessage()
-        class NewTunnelState(val newState: TunnelState) : UpdaterMessage()
-    }
-
-    private val jobTracker = JobTracker()
-    private val updater = runUpdater()
-
-    private val tunnelStateNotification = TunnelStateNotification(service)
-
-    private var loggedIn by
-        observable(false) { _, _, _ -> updater.trySendBlocking(UpdaterMessage.UpdateAction()) }
-
-    private val tunnelState
-        get() = connectionProxy.onStateChange.latestEvent
-
-    private val shouldBeOnForeground
-        get() = lockedToForeground || !(tunnelState is TunnelState.Disconnected)
-
-    var onForeground = false
-        private set
-
-    var lockedToForeground by
-        observable(false) { _, _, _ ->
-            updater.trySendBlocking(UpdaterMessage.UpdateNotification())
-        }
-
-    init {
-        connectionProxy.onStateChange.subscribe(this) { newState ->
-            updater.trySendBlocking(UpdaterMessage.NewTunnelState(newState))
-        }
-
-        intermittentDaemon.registerListener(this) { daemon ->
-            jobTracker.newBackgroundJob("notificationLoggedInJob") {
-                daemon
-                    ?.deviceStateUpdates
-                    ?.onStart { emit(daemon.getAndEmitDeviceState()) }
-                    ?.collect { deviceState -> loggedIn = deviceState is DeviceState.LoggedIn }
-            }
-        }
-
-        updater.trySendBlocking(UpdaterMessage.UpdateNotification())
-    }
-
-    fun onDestroy() {
-        jobTracker.cancelAllJobs()
-        intermittentDaemon.unregisterListener(this)
-        connectionProxy.onStateChange.unsubscribe(this)
-        updater.close()
-    }
-
-    private fun runUpdater() =
-        GlobalScope.actor<UpdaterMessage>(Dispatchers.Main, Channel.UNLIMITED) {
-            for (message in channel) {
-                when (message) {
-                    is UpdaterMessage.UpdateNotification -> updateNotification()
-                    is UpdaterMessage.UpdateAction -> updateNotificationAction()
-                    is UpdaterMessage.NewTunnelState -> {
-                        tunnelStateNotification.tunnelState = message.newState
-                        updateNotification()
-                    }
-                }
-            }
-        }
-
-    fun showOnForeground() {
-        service.startForeground(
-            TunnelStateNotification.NOTIFICATION_ID,
-            tunnelStateNotification.build()
-        )
-
-        onForeground = true
-    }
-
-    fun updateNotification() {
-        if (shouldBeOnForeground != onForeground) {
-            if (shouldBeOnForeground) {
-                showOnForeground()
-            } else {
-                service.stopForeground(Service.STOP_FOREGROUND_DETACH)
-                onForeground = false
-            }
-        }
-    }
-
-    fun cancelNotification() {
-        tunnelStateNotification.visible = false
-    }
-
-    private fun updateNotificationAction() {
-        tunnelStateNotification.showAction = loggedIn
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadDaemon.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadDaemon.kt
deleted file mode 100644
index 089e13ef31..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadDaemon.kt
+++ /dev/null
@@ -1,295 +0,0 @@
-package net.mullvad.mullvadvpn.service
-
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.asSharedFlow
-import net.mullvad.mullvadvpn.lib.endpoint.ApiEndpoint
-import net.mullvad.mullvadvpn.lib.endpoint.ApiEndpointConfiguration
-import net.mullvad.mullvadvpn.model.AppVersionInfo
-import net.mullvad.mullvadvpn.model.Device
-import net.mullvad.mullvadvpn.model.DeviceEvent
-import net.mullvad.mullvadvpn.model.DeviceListEvent
-import net.mullvad.mullvadvpn.model.DeviceState
-import net.mullvad.mullvadvpn.model.DnsOptions
-import net.mullvad.mullvadvpn.model.GeoIpLocation
-import net.mullvad.mullvadvpn.model.GetAccountDataResult
-import net.mullvad.mullvadvpn.model.LoginResult
-import net.mullvad.mullvadvpn.model.ObfuscationSettings
-import net.mullvad.mullvadvpn.model.QuantumResistantState
-import net.mullvad.mullvadvpn.model.RelayList
-import net.mullvad.mullvadvpn.model.RelaySettingsUpdate
-import net.mullvad.mullvadvpn.model.RemoveDeviceEvent
-import net.mullvad.mullvadvpn.model.RemoveDeviceResult
-import net.mullvad.mullvadvpn.model.Settings
-import net.mullvad.mullvadvpn.model.TunnelState
-import net.mullvad.mullvadvpn.model.VoucherSubmissionResult
-import net.mullvad.talpid.util.EventNotifier
-
-class MullvadDaemon(
-    vpnService: MullvadVpnService,
-    apiEndpointConfiguration: ApiEndpointConfiguration
-) {
-    protected var daemonInterfaceAddress = 0L
-
-    val onSettingsChange = EventNotifier<Settings?>(null)
-    var onTunnelStateChange = EventNotifier<TunnelState>(TunnelState.Disconnected)
-
-    var onAppVersionInfoChange: ((AppVersionInfo) -> Unit)? = null
-    var onRelayListChange: ((RelayList) -> Unit)? = null
-    var onDaemonStopped: (() -> Unit)? = null
-
-    private val _deviceStateUpdates = MutableSharedFlow<DeviceState>(extraBufferCapacity = 1)
-    val deviceStateUpdates = _deviceStateUpdates.asSharedFlow()
-
-    private val _deviceListUpdates = MutableSharedFlow<DeviceListEvent>(extraBufferCapacity = 1)
-    val deviceListUpdates = _deviceListUpdates.asSharedFlow()
-
-    init {
-        System.loadLibrary("mullvad_jni")
-
-        initialize(
-            vpnService = vpnService,
-            cacheDirectory = vpnService.cacheDir.absolutePath,
-            resourceDirectory = vpnService.filesDir.absolutePath,
-            apiEndpoint = apiEndpointConfiguration.apiEndpoint()
-        )
-
-        onSettingsChange.notify(getSettings())
-
-        onTunnelStateChange.notify(getState() ?: TunnelState.Disconnected)
-    }
-
-    fun connect() {
-        connect(daemonInterfaceAddress)
-    }
-
-    fun createNewAccount(): String? {
-        return createNewAccount(daemonInterfaceAddress)
-    }
-
-    fun disconnect() {
-        disconnect(daemonInterfaceAddress)
-    }
-
-    fun getAccountData(accountToken: String): GetAccountDataResult {
-        return getAccountData(daemonInterfaceAddress, accountToken)
-    }
-
-    fun getAccountHistory(): String? {
-        return getAccountHistory(daemonInterfaceAddress)
-    }
-
-    fun getWwwAuthToken(): String {
-        return getWwwAuthToken(daemonInterfaceAddress) ?: ""
-    }
-
-    fun getCurrentLocation(): GeoIpLocation? {
-        return getCurrentLocation(daemonInterfaceAddress)
-    }
-
-    fun getCurrentVersion(): String? {
-        return getCurrentVersion(daemonInterfaceAddress)
-    }
-
-    fun getRelayLocations(): RelayList? {
-        return getRelayLocations(daemonInterfaceAddress)
-    }
-
-    fun getSettings(): Settings? {
-        return getSettings(daemonInterfaceAddress)
-    }
-
-    fun getState(): TunnelState? {
-        return getState(daemonInterfaceAddress)
-    }
-
-    fun getVersionInfo(): AppVersionInfo? {
-        return getVersionInfo(daemonInterfaceAddress)
-    }
-
-    fun reconnect() {
-        reconnect(daemonInterfaceAddress)
-    }
-
-    fun clearAccountHistory() {
-        clearAccountHistory(daemonInterfaceAddress)
-    }
-
-    fun loginAccount(accountToken: String): LoginResult {
-        return loginAccount(daemonInterfaceAddress, accountToken)
-    }
-
-    fun logoutAccount() = logoutAccount(daemonInterfaceAddress)
-
-    fun getAndEmitDeviceList(accountToken: String): List<Device>? {
-        return listDevices(daemonInterfaceAddress, accountToken).also { deviceList ->
-            _deviceListUpdates.tryEmit(
-                if (deviceList == null) {
-                    DeviceListEvent.Error
-                } else {
-                    DeviceListEvent.Available(accountToken, deviceList)
-                }
-            )
-        }
-    }
-
-    fun getAndEmitDeviceState(): DeviceState {
-        return getDevice(daemonInterfaceAddress).also { deviceState ->
-            _deviceStateUpdates.tryEmit(deviceState)
-        }
-    }
-
-    fun refreshDevice() {
-        updateDevice(daemonInterfaceAddress)
-        getAndEmitDeviceState()
-    }
-
-    fun removeDevice(accountToken: String, deviceId: String): RemoveDeviceResult {
-        return removeDevice(daemonInterfaceAddress, accountToken, deviceId)
-    }
-
-    fun setAllowLan(allowLan: Boolean) {
-        setAllowLan(daemonInterfaceAddress, allowLan)
-    }
-
-    fun setAutoConnect(autoConnect: Boolean) {
-        setAutoConnect(daemonInterfaceAddress, autoConnect)
-    }
-
-    fun setDnsOptions(dnsOptions: DnsOptions) {
-        setDnsOptions(daemonInterfaceAddress, dnsOptions)
-    }
-
-    fun setWireguardMtu(wireguardMtu: Int?) {
-        setWireguardMtu(daemonInterfaceAddress, wireguardMtu)
-    }
-
-    fun shutdown() {
-        shutdown(daemonInterfaceAddress)
-    }
-
-    fun submitVoucher(voucher: String): VoucherSubmissionResult {
-        return submitVoucher(daemonInterfaceAddress, voucher)
-    }
-
-    fun updateRelaySettings(update: RelaySettingsUpdate) {
-        updateRelaySettings(daemonInterfaceAddress, update)
-    }
-
-    fun setObfuscationSettings(settings: ObfuscationSettings?) {
-        setObfuscationSettings(daemonInterfaceAddress, settings)
-    }
-
-    fun setQuantumResistant(quantumResistant: QuantumResistantState) {
-        setQuantumResistantTunnel(daemonInterfaceAddress, quantumResistant)
-    }
-
-    fun onDestroy() {
-        onSettingsChange.unsubscribeAll()
-        onTunnelStateChange.unsubscribeAll()
-
-        onAppVersionInfoChange = null
-        onRelayListChange = null
-        onDaemonStopped = null
-
-        deinitialize()
-    }
-
-    private external fun initialize(
-        vpnService: MullvadVpnService,
-        cacheDirectory: String,
-        resourceDirectory: String,
-        apiEndpoint: ApiEndpoint?
-    )
-
-    private external fun deinitialize()
-
-    private external fun connect(daemonInterfaceAddress: Long)
-    private external fun createNewAccount(daemonInterfaceAddress: Long): String?
-    private external fun disconnect(daemonInterfaceAddress: Long)
-    private external fun getAccountData(
-        daemonInterfaceAddress: Long,
-        accountToken: String
-    ): GetAccountDataResult
-
-    private external fun getAccountHistory(daemonInterfaceAddress: Long): String?
-    private external fun getWwwAuthToken(daemonInterfaceAddress: Long): String?
-    private external fun getCurrentLocation(daemonInterfaceAddress: Long): GeoIpLocation?
-    private external fun getCurrentVersion(daemonInterfaceAddress: Long): String?
-    private external fun getRelayLocations(daemonInterfaceAddress: Long): RelayList?
-    private external fun getSettings(daemonInterfaceAddress: Long): Settings?
-    private external fun getState(daemonInterfaceAddress: Long): TunnelState?
-    private external fun getVersionInfo(daemonInterfaceAddress: Long): AppVersionInfo?
-    private external fun reconnect(daemonInterfaceAddress: Long)
-    private external fun clearAccountHistory(daemonInterfaceAddress: Long)
-    private external fun loginAccount(
-        daemonInterfaceAddress: Long,
-        accountToken: String?
-    ): LoginResult
-
-    private external fun logoutAccount(daemonInterfaceAddress: Long)
-    private external fun listDevices(
-        daemonInterfaceAddress: Long,
-        accountToken: String?
-    ): List<Device>?
-
-    private external fun getDevice(daemonInterfaceAddress: Long): DeviceState
-    private external fun updateDevice(daemonInterfaceAddress: Long)
-    private external fun removeDevice(
-        daemonInterfaceAddress: Long,
-        accountToken: String?,
-        deviceId: String
-    ): RemoveDeviceResult
-
-    private external fun setAllowLan(daemonInterfaceAddress: Long, allowLan: Boolean)
-    private external fun setAutoConnect(daemonInterfaceAddress: Long, alwaysOn: Boolean)
-    private external fun setDnsOptions(daemonInterfaceAddress: Long, dnsOptions: DnsOptions)
-    private external fun setWireguardMtu(daemonInterfaceAddress: Long, wireguardMtu: Int?)
-    private external fun shutdown(daemonInterfaceAddress: Long)
-    private external fun submitVoucher(
-        daemonInterfaceAddress: Long,
-        voucher: String
-    ): VoucherSubmissionResult
-
-    private external fun updateRelaySettings(
-        daemonInterfaceAddress: Long,
-        update: RelaySettingsUpdate
-    )
-
-    private external fun setObfuscationSettings(
-        daemonInterfaceAddress: Long,
-        settings: ObfuscationSettings?
-    )
-
-    private external fun setQuantumResistantTunnel(
-        daemonInterfaceAddress: Long,
-        quantumResistant: QuantumResistantState
-    )
-
-    private fun notifyAppVersionInfoEvent(appVersionInfo: AppVersionInfo) {
-        onAppVersionInfoChange?.invoke(appVersionInfo)
-    }
-
-    private fun notifyRelayListEvent(relayList: RelayList) {
-        onRelayListChange?.invoke(relayList)
-    }
-
-    private fun notifySettingsEvent(settings: Settings) {
-        onSettingsChange.notify(settings)
-    }
-
-    private fun notifyTunnelStateEvent(event: TunnelState) {
-        onTunnelStateChange.notify(event)
-    }
-
-    private fun notifyDaemonStopped() {
-        onDaemonStopped?.invoke()
-    }
-
-    private fun notifyDeviceEvent(event: DeviceEvent) {
-        _deviceStateUpdates.tryEmit(event.newState)
-    }
-
-    private fun notifyRemoveDeviceEvent(event: RemoveDeviceEvent) {
-        _deviceListUpdates.tryEmit(DeviceListEvent.Available(event.accountToken, event.newDevices))
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadVpnService.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadVpnService.kt
deleted file mode 100644
index 0058b09e4f..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/MullvadVpnService.kt
+++ /dev/null
@@ -1,275 +0,0 @@
-package net.mullvad.mullvadvpn.service
-
-import android.app.KeyguardManager
-import android.content.Context
-import android.content.Intent
-import android.net.VpnService
-import android.os.IBinder
-import android.os.Looper
-import android.util.Log
-import kotlin.properties.Delegates.observable
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.launch
-import net.mullvad.mullvadvpn.BuildConfig
-import net.mullvad.mullvadvpn.di.vpnServiceModule
-import net.mullvad.mullvadvpn.lib.endpoint.ApiEndpointConfiguration
-import net.mullvad.mullvadvpn.lib.endpoint.DefaultApiEndpointConfiguration
-import net.mullvad.mullvadvpn.lib.endpoint.getApiEndpointConfigurationExtras
-import net.mullvad.mullvadvpn.model.Settings
-import net.mullvad.mullvadvpn.model.TunnelState
-import net.mullvad.mullvadvpn.service.endpoint.ServiceEndpoint
-import net.mullvad.mullvadvpn.service.notifications.AccountExpiryNotification
-import net.mullvad.mullvadvpn.ui.MainActivity
-import net.mullvad.talpid.TalpidVpnService
-import org.koin.core.context.loadKoinModules
-
-class MullvadVpnService : TalpidVpnService() {
-    companion object {
-        private val TAG = "mullvad"
-
-        val KEY_CONNECT_ACTION = "net.mullvad.mullvadvpn.connect_action"
-        val KEY_DISCONNECT_ACTION = "net.mullvad.mullvadvpn.disconnect_action"
-        val KEY_QUIT_ACTION = "net.mullvad.mullvadvpn.quit_action"
-
-        init {
-            System.loadLibrary("mullvad_jni")
-        }
-    }
-
-    private enum class PendingAction {
-        Connect,
-        Disconnect,
-    }
-
-    private enum class State {
-        Running,
-        Stopping,
-        Stopped,
-    }
-
-    private val connectionProxy
-        get() = endpoint.connectionProxy
-
-    private var state = State.Running
-
-    private var setUpDaemonJob: Job? = null
-
-    private lateinit var accountExpiryNotification: AccountExpiryNotification
-    private lateinit var daemonInstance: DaemonInstance
-    private lateinit var endpoint: ServiceEndpoint
-    private lateinit var keyguardManager: KeyguardManager
-    private lateinit var notificationManager: ForegroundNotificationManager
-
-    private var pendingAction by
-        observable<PendingAction?>(null) { _, _, _ ->
-            endpoint.settingsListener.settings?.let { settings -> handlePendingAction(settings) }
-        }
-
-    private var apiEndpointConfiguration: ApiEndpointConfiguration =
-        DefaultApiEndpointConfiguration()
-
-    override fun onCreate() {
-        super.onCreate()
-        Log.d(TAG, "Initializing service")
-
-        loadKoinModules(vpnServiceModule)
-
-        daemonInstance = DaemonInstance(this)
-        keyguardManager = getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
-
-        endpoint =
-            ServiceEndpoint(
-                Looper.getMainLooper(),
-                daemonInstance.intermittentDaemon,
-                connectivityListener,
-                this
-            )
-
-        endpoint.splitTunneling.onChange.subscribe(this@MullvadVpnService) { excludedApps ->
-            disallowedApps = excludedApps
-            markTunAsStale()
-            connectionProxy.reconnect()
-        }
-
-        notificationManager =
-            ForegroundNotificationManager(this, connectionProxy, daemonInstance.intermittentDaemon)
-
-        accountExpiryNotification =
-            AccountExpiryNotification(
-                this,
-                daemonInstance.intermittentDaemon,
-                endpoint.accountCache
-            )
-
-        // Remove any leftover tunnel state persistence data
-        getSharedPreferences("tunnel_state", MODE_PRIVATE).edit().clear().commit()
-    }
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        Log.d(TAG, "Starting service")
-
-        if (BuildConfig.DEBUG) {
-            intent?.getApiEndpointConfigurationExtras()?.let { apiEndpointConfiguration = it }
-        }
-
-        daemonInstance.apply {
-            intermittentDaemon.registerListener(this@MullvadVpnService) { daemon ->
-                handleDaemonInstance(daemon)
-            }
-
-            start(apiEndpointConfiguration)
-        }
-
-        val startResult = super.onStartCommand(intent, flags, startId)
-        var quitCommand = false
-
-        // Always promote to foreground if connect/disconnect actions are provided to mitigate cases
-        // where the service would potentially otherwise be too slow running `startForeground`.
-        if (intent?.action == KEY_CONNECT_ACTION || intent?.action == KEY_DISCONNECT_ACTION) {
-            notificationManager.showOnForeground()
-        }
-
-        notificationManager.updateNotification()
-
-        if (!keyguardManager.isDeviceLocked) {
-            val action = intent?.action
-
-            if (action == VpnService.SERVICE_INTERFACE || action == KEY_CONNECT_ACTION) {
-                pendingAction = PendingAction.Connect
-            } else if (action == KEY_DISCONNECT_ACTION) {
-                pendingAction = PendingAction.Disconnect
-            } else if (action == KEY_QUIT_ACTION && !notificationManager.onForeground) {
-                quitCommand = true
-                stop()
-            }
-        }
-
-        if (state == State.Stopping && !quitCommand) {
-            restart()
-        }
-
-        return startResult
-    }
-
-    override fun onBind(intent: Intent): IBinder {
-        Log.d(TAG, "New connection to service")
-        return super.onBind(intent) ?: endpoint.messenger.binder
-    }
-
-    override fun onRebind(intent: Intent) {
-        Log.d(TAG, "Connection to service restored")
-        if (state == State.Stopping) {
-            restart()
-        }
-    }
-
-    override fun onRevoke() {
-        pendingAction = PendingAction.Disconnect
-    }
-
-    override fun onUnbind(intent: Intent): Boolean {
-        Log.d(TAG, "Closed all connections to service")
-
-        if (state != State.Running) {
-            stop()
-        }
-
-        return true
-    }
-
-    override fun onDestroy() {
-        Log.d(TAG, "Service has stopped")
-        state = State.Stopped
-        accountExpiryNotification.onDestroy()
-        notificationManager.onDestroy()
-        daemonInstance.onDestroy()
-        super.onDestroy()
-    }
-
-    override fun onTaskRemoved(rootIntent: Intent?) {
-        connectionProxy.onStateChange.latestEvent.let { tunnelState ->
-            Log.d(TAG, "Task removed (tunnelState=$tunnelState)")
-            if (tunnelState == TunnelState.Disconnected) {
-                notificationManager.cancelNotification()
-                stop()
-            }
-        }
-    }
-
-    private fun handleDaemonInstance(daemon: MullvadDaemon?) {
-        setUpDaemonJob?.cancel()
-
-        if (daemon != null) {
-            setUpDaemonJob = setUpDaemon(daemon)
-        } else {
-            Log.d(TAG, "Daemon has stopped")
-
-            if (state == State.Running) {
-                restart()
-            }
-        }
-    }
-
-    private fun setUpDaemon(daemon: MullvadDaemon) =
-        GlobalScope.launch(Dispatchers.Main) {
-            if (state != State.Stopped) {
-                val settings = daemon.getSettings()
-
-                if (settings != null) {
-                    handlePendingAction(settings)
-                } else {
-                    restart()
-                }
-            }
-        }
-
-    private fun stop() {
-        Log.d(TAG, "Stopping service")
-        state = State.Stopping
-        daemonInstance.stop()
-        stopSelf()
-    }
-
-    private fun restart() {
-        if (state != State.Stopped) {
-            Log.d(TAG, "Restarting service")
-
-            state = State.Running
-
-            daemonInstance.apply {
-                stop()
-                start(apiEndpointConfiguration)
-            }
-        } else {
-            Log.d(TAG, "Ignoring restart because onDestroy has executed")
-        }
-    }
-
-    private fun handlePendingAction(settings: Settings) {
-        when (pendingAction) {
-            PendingAction.Connect -> {
-                if (settings != null) {
-                    connectionProxy.connect()
-                } else {
-                    openUi()
-                }
-            }
-            PendingAction.Disconnect -> connectionProxy.disconnect()
-            null -> return
-        }
-
-        pendingAction = null
-    }
-
-    private fun openUi() {
-        val intent =
-            Intent(this, MainActivity::class.java).apply {
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
-            }
-
-        startActivity(intent)
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/AccountCache.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/AccountCache.kt
deleted file mode 100644
index ad8b96f9a5..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/AccountCache.kt
+++ /dev/null
@@ -1,180 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.ClosedReceiveChannelException
-import kotlinx.coroutines.channels.actor
-import kotlinx.coroutines.channels.trySendBlocking
-import net.mullvad.mullvadvpn.lib.common.util.JobTracker
-import net.mullvad.mullvadvpn.lib.common.util.parseAsDateTime
-import net.mullvad.mullvadvpn.lib.ipc.Event
-import net.mullvad.mullvadvpn.lib.ipc.Request
-import net.mullvad.mullvadvpn.model.AccountCreationResult
-import net.mullvad.mullvadvpn.model.AccountExpiry
-import net.mullvad.mullvadvpn.model.AccountHistory
-import net.mullvad.mullvadvpn.model.GetAccountDataResult
-import net.mullvad.talpid.util.EventNotifier
-
-class AccountCache(private val endpoint: ServiceEndpoint) {
-    companion object {
-        private sealed class Command {
-            object CreateAccount : Command()
-            data class Login(val account: String) : Command()
-            object Logout : Command()
-        }
-    }
-
-    private val commandChannel = spawnActor()
-
-    private val daemon
-        get() = endpoint.intermittentDaemon
-
-    val onAccountExpiryChange = EventNotifier<AccountExpiry>(AccountExpiry.Missing)
-    val onAccountHistoryChange = EventNotifier<AccountHistory>(AccountHistory.Missing)
-
-    private val jobTracker = JobTracker()
-
-    private var accountExpiry by onAccountExpiryChange.notifiable()
-    private var accountHistory by onAccountHistoryChange.notifiable()
-
-    private var cachedAccountToken: String? = null
-    private var cachedCreatedAccountToken: String? = null
-
-    val isNewAccount: Boolean
-        get() = cachedAccountToken == cachedCreatedAccountToken
-
-    init {
-        jobTracker.newBackgroundJob("autoFetchAccountExpiry") {
-            daemon.await().deviceStateUpdates.collect { deviceState ->
-                accountExpiry =
-                    deviceState
-                        .token()
-                        .also { cachedAccountToken = it }
-                        ?.let { fetchAccountExpiry(it) }
-                        ?: AccountExpiry.Missing
-            }
-        }
-
-        onAccountHistoryChange.subscribe(this) { history ->
-            endpoint.sendEvent(Event.AccountHistoryEvent(history))
-        }
-
-        onAccountExpiryChange.subscribe(this) { endpoint.sendEvent(Event.AccountExpiryEvent(it)) }
-
-        endpoint.dispatcher.apply {
-            registerHandler(Request.CreateAccount::class) { _ ->
-                commandChannel.trySendBlocking(Command.CreateAccount)
-            }
-
-            registerHandler(Request.Login::class) { request ->
-                request.account?.let { account ->
-                    commandChannel.trySendBlocking(Command.Login(account))
-                }
-            }
-
-            registerHandler(Request.Logout::class) { _ ->
-                commandChannel.trySendBlocking(Command.Logout)
-            }
-
-            registerHandler(Request.FetchAccountExpiry::class) { _ ->
-                jobTracker.newBackgroundJob("fetchAccountExpiry") {
-                    accountExpiry =
-                        cachedAccountToken?.let { fetchAccountExpiry(it) } ?: AccountExpiry.Missing
-                }
-            }
-
-            registerHandler(Request.FetchAccountHistory::class) { _ ->
-                jobTracker.newBackgroundJob("fetchAccountHistory") {
-                    accountHistory = fetchAccountHistory()
-                }
-            }
-
-            registerHandler(Request.ClearAccountHistory::class) { _ ->
-                jobTracker.newBackgroundJob("clearAccountHistory") { clearAccountHistory() }
-            }
-        }
-    }
-
-    fun onDestroy() {
-        jobTracker.cancelAllJobs()
-
-        onAccountExpiryChange.unsubscribeAll()
-        onAccountHistoryChange.unsubscribeAll()
-
-        commandChannel.close()
-    }
-
-    private fun spawnActor() =
-        GlobalScope.actor<Command>(Dispatchers.Default, Channel.UNLIMITED) {
-            try {
-                for (command in channel) {
-                    when (command) {
-                        is Command.CreateAccount -> doCreateAccount()
-                        is Command.Login -> doLogin(command.account)
-                        is Command.Logout -> doLogout()
-                    }
-                }
-            } catch (exception: ClosedReceiveChannelException) {
-                // Command channel was closed, stop the actor
-            }
-        }
-
-    private suspend fun clearAccountHistory() {
-        daemon.await().clearAccountHistory()
-        accountHistory = fetchAccountHistory()
-    }
-
-    private suspend fun doCreateAccount() {
-        daemon
-            .await()
-            .createNewAccount()
-            .also { newAccountToken -> cachedCreatedAccountToken = newAccountToken }
-            .let { newAccountToken ->
-                if (newAccountToken != null) {
-                    AccountCreationResult.Success(newAccountToken)
-                } else {
-                    AccountCreationResult.Failure
-                }
-            }
-            .also { result -> endpoint.sendEvent(Event.AccountCreationEvent(result)) }
-    }
-
-    private suspend fun doLogin(account: String) {
-        daemon.await().loginAccount(account).also { result ->
-            endpoint.sendEvent(Event.LoginEvent(result))
-        }
-    }
-
-    private suspend fun doLogout() {
-        daemon.await().logoutAccount()
-        accountHistory = fetchAccountHistory()
-    }
-
-    private suspend fun fetchAccountHistory(): AccountHistory {
-        return daemon.await().getAccountHistory().let { history ->
-            if (history != null) {
-                AccountHistory.Available(history)
-            } else {
-                AccountHistory.Missing
-            }
-        }
-    }
-
-    private suspend fun fetchAccountExpiry(accountToken: String): AccountExpiry {
-        return fetchAccountData(accountToken).let { result ->
-            if (result is GetAccountDataResult.Ok) {
-                result.accountData.expiry.parseAsDateTime()?.let { parsedDateTime ->
-                    AccountExpiry.Available(parsedDateTime)
-                }
-                    ?: AccountExpiry.Missing
-            } else {
-                AccountExpiry.Missing
-            }
-        }
-    }
-
-    private suspend fun fetchAccountData(accountToken: String): GetAccountDataResult {
-        return daemon.await().getAccountData(accountToken)
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/AppVersionInfoCache.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/AppVersionInfoCache.kt
deleted file mode 100644
index 767ac3e251..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/AppVersionInfoCache.kt
+++ /dev/null
@@ -1,56 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import kotlin.properties.Delegates.observable
-import net.mullvad.mullvadvpn.lib.ipc.Event
-import net.mullvad.mullvadvpn.model.AppVersionInfo
-import net.mullvad.mullvadvpn.service.MullvadDaemon
-
-class AppVersionInfoCache(endpoint: ServiceEndpoint) {
-    private val daemon = endpoint.intermittentDaemon
-
-    var appVersionInfo by
-        observable<AppVersionInfo?>(null) { _, _, info ->
-            endpoint.sendEvent(Event.AppVersionInfo(info))
-        }
-        private set
-
-    var currentVersion by
-        observable<String?>(null) { _, _, version ->
-            endpoint.sendEvent(Event.CurrentVersion(version))
-        }
-        private set
-
-    init {
-        daemon.registerListener(this) { newDaemon ->
-            newDaemon?.let { daemon ->
-                initializeCurrentVersion(daemon)
-                registerVersionInfoListener(daemon)
-                fetchInitialVersionInfo(daemon)
-            }
-        }
-    }
-
-    fun onDestroy() {
-        daemon.unregisterListener(this)
-    }
-
-    private fun initializeCurrentVersion(daemon: MullvadDaemon) {
-        if (currentVersion == null) {
-            currentVersion = daemon.getCurrentVersion()
-        }
-    }
-
-    private fun registerVersionInfoListener(daemon: MullvadDaemon) {
-        daemon.onAppVersionInfoChange = { newAppVersionInfo ->
-            synchronized(this@AppVersionInfoCache) { appVersionInfo = newAppVersionInfo }
-        }
-    }
-
-    private fun fetchInitialVersionInfo(daemon: MullvadDaemon) {
-        synchronized(this@AppVersionInfoCache) {
-            if (appVersionInfo == null) {
-                appVersionInfo = daemon.getVersionInfo()
-            }
-        }
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/AuthTokenCache.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/AuthTokenCache.kt
deleted file mode 100644
index 6506c0469d..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/AuthTokenCache.kt
+++ /dev/null
@@ -1,49 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import kotlin.properties.Delegates.observable
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.ClosedReceiveChannelException
-import kotlinx.coroutines.channels.actor
-import kotlinx.coroutines.channels.trySendBlocking
-import net.mullvad.mullvadvpn.lib.ipc.Event
-import net.mullvad.mullvadvpn.lib.ipc.Request
-
-class AuthTokenCache(endpoint: ServiceEndpoint) {
-    companion object {
-        private enum class Command {
-            Fetch
-        }
-    }
-
-    private val daemon = endpoint.intermittentDaemon
-    private val requestQueue = spawnActor()
-
-    var authToken by
-        observable<String?>(null) { _, _, token -> endpoint.sendEvent(Event.AuthToken(token)) }
-        private set
-
-    init {
-        endpoint.dispatcher.registerHandler(Request.FetchAuthToken::class) { _ ->
-            requestQueue.trySendBlocking(Command.Fetch)
-        }
-    }
-
-    fun onDestroy() {
-        requestQueue.close()
-    }
-
-    private fun spawnActor() =
-        GlobalScope.actor<Command>(Dispatchers.Default, Channel.UNLIMITED) {
-            try {
-                for (command in channel) {
-                    when (command) {
-                        Command.Fetch -> authToken = daemon.await().getWwwAuthToken()
-                    }
-                }
-            } catch (exception: ClosedReceiveChannelException) {
-                // Closed sender, so stop the actor
-            }
-        }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/ConnectionProxy.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/ConnectionProxy.kt
deleted file mode 100644
index a2c97a05bd..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/ConnectionProxy.kt
+++ /dev/null
@@ -1,85 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.ClosedReceiveChannelException
-import kotlinx.coroutines.channels.actor
-import kotlinx.coroutines.channels.trySendBlocking
-import net.mullvad.mullvadvpn.lib.ipc.Event
-import net.mullvad.mullvadvpn.lib.ipc.Request
-import net.mullvad.mullvadvpn.model.TunnelState
-import net.mullvad.talpid.util.EventNotifier
-
-class ConnectionProxy(val vpnPermission: VpnPermission, endpoint: ServiceEndpoint) {
-    private enum class Command {
-        CONNECT,
-        RECONNECT,
-        DISCONNECT,
-    }
-
-    private val commandChannel = spawnActor()
-    private val daemon = endpoint.intermittentDaemon
-    private val initialState = TunnelState.Disconnected
-
-    var onStateChange = EventNotifier<TunnelState>(initialState)
-
-    var state by onStateChange.notifiable()
-        private set
-
-    init {
-        daemon.registerListener(this) { newDaemon ->
-            newDaemon?.onTunnelStateChange?.subscribe(this@ConnectionProxy) { newState ->
-                state = newState
-            }
-        }
-
-        onStateChange.subscribe(this) { tunnelState ->
-            endpoint.sendEvent(Event.TunnelStateChange(tunnelState))
-        }
-
-        endpoint.dispatcher.apply {
-            registerHandler(Request.Connect::class) { _ -> connect() }
-            registerHandler(Request.Reconnect::class) { _ -> reconnect() }
-            registerHandler(Request.Disconnect::class) { _ -> disconnect() }
-        }
-    }
-
-    fun connect() {
-        commandChannel.trySendBlocking(Command.CONNECT)
-    }
-
-    fun reconnect() {
-        commandChannel.trySendBlocking(Command.RECONNECT)
-    }
-
-    fun disconnect() {
-        commandChannel.trySendBlocking(Command.DISCONNECT)
-    }
-
-    fun onDestroy() {
-        commandChannel.close()
-        onStateChange.unsubscribeAll()
-        daemon.unregisterListener(this)
-    }
-
-    private fun spawnActor() =
-        GlobalScope.actor<Command>(Dispatchers.Default, Channel.UNLIMITED) {
-            try {
-                while (true) {
-                    val command = channel.receive()
-
-                    when (command) {
-                        Command.CONNECT -> {
-                            vpnPermission.request()
-                            daemon.await().connect()
-                        }
-                        Command.RECONNECT -> daemon.await().reconnect()
-                        Command.DISCONNECT -> daemon.await().disconnect()
-                    }
-                }
-            } catch (exception: ClosedReceiveChannelException) {
-                // Closed sender, so stop the actor
-            }
-        }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/CustomDns.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/CustomDns.kt
deleted file mode 100644
index fe8f55a66d..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/CustomDns.kt
+++ /dev/null
@@ -1,133 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import java.net.InetAddress
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.ClosedReceiveChannelException
-import kotlinx.coroutines.channels.actor
-import kotlinx.coroutines.channels.trySendBlocking
-import net.mullvad.mullvadvpn.lib.ipc.Request
-import net.mullvad.mullvadvpn.model.CustomDnsOptions
-import net.mullvad.mullvadvpn.model.DefaultDnsOptions
-import net.mullvad.mullvadvpn.model.DnsOptions
-import net.mullvad.mullvadvpn.model.DnsState
-
-class CustomDns(private val endpoint: ServiceEndpoint) {
-    private sealed class Command {
-        @Deprecated("Use SetDnsOptions") class AddDnsServer(val server: InetAddress) : Command()
-        @Deprecated("Use SetDnsOptions") class RemoveDnsServer(val server: InetAddress) : Command()
-        @Deprecated("Use SetDnsOptions")
-        class ReplaceDnsServer(val oldServer: InetAddress, val newServer: InetAddress) : Command()
-        @Deprecated("Use SetDnsOptions") class SetEnabled(val enabled: Boolean) : Command()
-
-        class SetDnsOptions(val dnsOptions: DnsOptions) : Command()
-    }
-
-    private val commandChannel = spawnActor()
-    private val dnsServers = ArrayList<InetAddress>()
-
-    private val daemon
-        get() = endpoint.intermittentDaemon
-
-    private var enabled = false
-
-    init {
-        endpoint.settingsListener.dnsOptionsNotifier.subscribe(this) { maybeDnsOptions ->
-            maybeDnsOptions?.let { dnsOptions ->
-                enabled = dnsOptions.state == DnsState.Custom
-                dnsServers.clear()
-                dnsServers.addAll(dnsOptions.customOptions.addresses)
-            }
-        }
-
-        endpoint.dispatcher.apply {
-            registerHandler(Request.AddCustomDnsServer::class) { request ->
-                commandChannel.trySendBlocking(Command.AddDnsServer(request.address))
-            }
-
-            registerHandler(Request.RemoveCustomDnsServer::class) { request ->
-                commandChannel.trySendBlocking(Command.RemoveDnsServer(request.address))
-            }
-
-            registerHandler(Request.ReplaceCustomDnsServer::class) { request ->
-                commandChannel.trySendBlocking(
-                    Command.ReplaceDnsServer(request.oldAddress, request.newAddress)
-                )
-            }
-
-            registerHandler(Request.SetEnableCustomDns::class) { request ->
-                commandChannel.trySendBlocking(Command.SetEnabled(request.enable))
-            }
-
-            registerHandler(Request.SetDnsOptions::class) { request ->
-                commandChannel.trySendBlocking(Command.SetDnsOptions(request.dnsOptions))
-            }
-        }
-    }
-
-    fun onDestroy() {
-        endpoint.settingsListener.dnsOptionsNotifier.unsubscribe(this)
-        commandChannel.close()
-    }
-
-    private fun spawnActor() =
-        GlobalScope.actor<Command>(Dispatchers.Default, Channel.UNLIMITED) {
-            try {
-                while (true) {
-                    val command = channel.receive()
-
-                    when (command) {
-                        is Command.AddDnsServer -> doAddDnsServer(command.server)
-                        is Command.RemoveDnsServer -> doRemoveDnsServer(command.server)
-                        is Command.ReplaceDnsServer -> {
-                            doReplaceDnsServer(command.oldServer, command.newServer)
-                        }
-                        is Command.SetEnabled -> changeDnsOptions(command.enabled)
-                        is Command.SetDnsOptions -> setDnsOptions(command.dnsOptions)
-                    }
-                }
-            } catch (exception: ClosedReceiveChannelException) {
-                // Closed sender, so stop the actor
-            }
-        }
-
-    private suspend fun doAddDnsServer(server: InetAddress) {
-        if (!dnsServers.contains(server)) {
-            dnsServers.add(server)
-            changeDnsOptions(enabled)
-        }
-    }
-
-    private suspend fun doReplaceDnsServer(oldServer: InetAddress, newServer: InetAddress) {
-        if (oldServer != newServer && !dnsServers.contains(newServer)) {
-            val index = dnsServers.indexOf(oldServer)
-
-            if (index >= 0) {
-                dnsServers.removeAt(index)
-                dnsServers.add(index, newServer)
-                changeDnsOptions(enabled)
-            }
-        }
-    }
-
-    private suspend fun doRemoveDnsServer(server: InetAddress) {
-        if (dnsServers.remove(server)) {
-            changeDnsOptions(enabled)
-        }
-    }
-
-    private suspend fun changeDnsOptions(enable: Boolean) {
-        val options =
-            DnsOptions(
-                state = if (enable) DnsState.Custom else DnsState.Default,
-                customOptions = CustomDnsOptions(dnsServers),
-                defaultOptions = DefaultDnsOptions()
-            )
-        daemon.await().setDnsOptions(options)
-    }
-
-    private suspend fun setDnsOptions(dnsOptions: DnsOptions) {
-        daemon.await().setDnsOptions(dnsOptions)
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/DaemonDeviceDataSource.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/DaemonDeviceDataSource.kt
deleted file mode 100644
index db264ed1fe..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/DaemonDeviceDataSource.kt
+++ /dev/null
@@ -1,62 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import kotlinx.coroutines.flow.collect
-import net.mullvad.mullvadvpn.lib.common.util.JobTracker
-import net.mullvad.mullvadvpn.lib.ipc.Event
-import net.mullvad.mullvadvpn.lib.ipc.Request
-import net.mullvad.mullvadvpn.service.MullvadDaemon
-
-class DaemonDeviceDataSource(val endpoint: ServiceEndpoint) {
-    private val tracker = JobTracker()
-
-    init {
-        endpoint.intermittentDaemon.registerListener(this) { daemon ->
-            if (daemon != null) {
-                launchDeviceEndpointJobs(daemon)
-            } else {
-                tracker.cancelAllJobs()
-            }
-        }
-    }
-
-    private fun launchDeviceEndpointJobs(daemon: MullvadDaemon) {
-        tracker.newBackgroundJob("propagateDeviceUpdatesJob") {
-            daemon.deviceStateUpdates.collect { newState ->
-                endpoint.sendEvent(Event.DeviceStateEvent(newState))
-            }
-        }
-
-        tracker.newBackgroundJob("propagateDeviceListUpdatesJob") {
-            daemon.deviceListUpdates.collect { newState ->
-                endpoint.sendEvent(Event.DeviceListUpdate(newState))
-            }
-        }
-
-        endpoint.dispatcher.registerHandler(Request.GetDevice::class) {
-            tracker.newBackgroundJob("getDeviceJob") { daemon.getAndEmitDeviceState() }
-        }
-
-        endpoint.dispatcher.registerHandler(Request.RefreshDeviceState::class) {
-            tracker.newBackgroundJob("refreshDeviceJob") { daemon.refreshDevice() }
-        }
-
-        endpoint.dispatcher.registerHandler(Request.RemoveDevice::class) { request ->
-            tracker.newBackgroundJob("removeDeviceJob") {
-                daemon.removeDevice(request.accountToken, request.deviceId).also { result ->
-                    endpoint.sendEvent(Event.DeviceRemovalEvent(request.deviceId, result))
-                }
-            }
-        }
-
-        endpoint.dispatcher.registerHandler(Request.GetDeviceList::class) { request ->
-            tracker.newBackgroundJob("getDeviceListJob") {
-                daemon.getAndEmitDeviceList(request.accountToken)
-            }
-        }
-    }
-
-    fun onDestroy() {
-        tracker.cancelAllJobs()
-        endpoint.intermittentDaemon.unregisterListener(this)
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/LocationInfoCache.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/LocationInfoCache.kt
deleted file mode 100644
index 68d6b56f6e..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/LocationInfoCache.kt
+++ /dev/null
@@ -1,136 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import kotlin.properties.Delegates.observable
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.ClosedReceiveChannelException
-import kotlinx.coroutines.channels.ReceiveChannel
-import kotlinx.coroutines.channels.actor
-import kotlinx.coroutines.channels.trySendBlocking
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.flow.receiveAsFlow
-import net.mullvad.mullvadvpn.lib.common.util.toGeographicLocationConstraint
-import net.mullvad.mullvadvpn.lib.ipc.Event
-import net.mullvad.mullvadvpn.model.Constraint
-import net.mullvad.mullvadvpn.model.GeoIpLocation
-import net.mullvad.mullvadvpn.model.RelaySettings
-import net.mullvad.mullvadvpn.model.TunnelState
-import net.mullvad.mullvadvpn.util.ExponentialBackoff
-import net.mullvad.talpid.tunnel.ActionAfterDisconnect
-
-class LocationInfoCache(private val endpoint: ServiceEndpoint) {
-    companion object {
-        private enum class RequestFetch {
-            ForRealLocation,
-            ForRelayLocation,
-        }
-    }
-
-    private val fetchRetryDelays =
-        ExponentialBackoff().apply {
-            scale = 50
-            cap = 30 /* min */ * 60 /* s */ * 1000 /* ms */
-            count = 17 // ceil(log2(cap / scale) + 1)
-        }
-
-    private val fetchRequestChannel = runFetcher()
-
-    private val daemon
-        get() = endpoint.intermittentDaemon
-
-    private var lastKnownRealLocation: GeoIpLocation? = null
-    private var selectedRelayLocation: GeoIpLocation? = null
-
-    var location: GeoIpLocation? by
-        observable(null) { _, _, newLocation -> endpoint.sendEvent(Event.NewLocation(newLocation)) }
-
-    var state by
-        observable<TunnelState>(TunnelState.Disconnected) { _, _, newState ->
-            when (newState) {
-                is TunnelState.Disconnected -> {
-                    location = lastKnownRealLocation
-                    fetchRequestChannel.trySendBlocking(RequestFetch.ForRealLocation)
-                }
-                is TunnelState.Connecting -> location = newState.location
-                is TunnelState.Connected -> {
-                    location = newState.location
-                    fetchRequestChannel.trySendBlocking(RequestFetch.ForRelayLocation)
-                }
-                is TunnelState.Disconnecting -> {
-                    when (newState.actionAfterDisconnect) {
-                        ActionAfterDisconnect.Nothing -> location = lastKnownRealLocation
-                        ActionAfterDisconnect.Block -> location = null
-                        ActionAfterDisconnect.Reconnect -> location = selectedRelayLocation
-                    }
-                }
-                is TunnelState.Error -> location = null
-            }
-        }
-
-    init {
-        endpoint.connectionProxy.onStateChange.subscribe(this) { newState -> state = newState }
-
-        endpoint.connectivityListener.connectivityNotifier.subscribe(this) { isConnected ->
-            if (isConnected && state is TunnelState.Disconnected) {
-                fetchRequestChannel.trySendBlocking(RequestFetch.ForRealLocation)
-            }
-        }
-
-        endpoint.settingsListener.relaySettingsNotifier.subscribe(this, ::updateSelectedLocation)
-    }
-
-    fun onDestroy() {
-        endpoint.connectionProxy.onStateChange.unsubscribe(this)
-        endpoint.connectivityListener.connectivityNotifier.unsubscribe(this)
-        endpoint.settingsListener.relaySettingsNotifier.unsubscribe(this)
-
-        fetchRequestChannel.close()
-    }
-
-    private fun runFetcher() =
-        GlobalScope.actor<RequestFetch>(Dispatchers.Default, Channel.CONFLATED) {
-            try {
-                fetcherLoop(channel)
-            } catch (exception: ClosedReceiveChannelException) {}
-        }
-
-    private suspend fun fetcherLoop(channel: ReceiveChannel<RequestFetch>) {
-        channel
-            .receiveAsFlow()
-            .flatMapLatest(::fetchCurrentLocation)
-            .collect(::handleFetchedLocation)
-    }
-
-    private fun fetchCurrentLocation(fetchType: RequestFetch) = flow {
-        var newLocation = daemon.await().getCurrentLocation()
-
-        fetchRetryDelays.reset()
-
-        while (newLocation == null) {
-            delay(fetchRetryDelays.next())
-            newLocation = daemon.await().getCurrentLocation()
-        }
-
-        emit(Pair(newLocation, fetchType))
-    }
-
-    private suspend fun handleFetchedLocation(pairItem: Pair<GeoIpLocation, RequestFetch>) {
-        val (newLocation, fetchType) = pairItem
-
-        if (fetchType == RequestFetch.ForRealLocation) {
-            lastKnownRealLocation = newLocation
-        }
-
-        location = newLocation
-    }
-
-    private fun updateSelectedLocation(relaySettings: RelaySettings?) {
-        val settings = relaySettings as? RelaySettings.Normal
-        val constraint = settings?.relayConstraints?.location as? Constraint.Only
-
-        selectedRelayLocation = constraint?.value?.toGeographicLocationConstraint()?.location
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/RelayListListener.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/RelayListListener.kt
deleted file mode 100644
index 1abf64907c..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/RelayListListener.kt
+++ /dev/null
@@ -1,108 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import kotlin.properties.Delegates.observable
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.ClosedReceiveChannelException
-import kotlinx.coroutines.channels.actor
-import kotlinx.coroutines.channels.trySendBlocking
-import net.mullvad.mullvadvpn.lib.ipc.Event
-import net.mullvad.mullvadvpn.lib.ipc.Request
-import net.mullvad.mullvadvpn.model.Constraint
-import net.mullvad.mullvadvpn.model.GeographicLocationConstraint
-import net.mullvad.mullvadvpn.model.LocationConstraint
-import net.mullvad.mullvadvpn.model.RelayConstraintsUpdate
-import net.mullvad.mullvadvpn.model.RelayList
-import net.mullvad.mullvadvpn.model.RelaySettingsUpdate
-import net.mullvad.mullvadvpn.model.WireguardConstraints
-import net.mullvad.mullvadvpn.service.MullvadDaemon
-
-class RelayListListener(endpoint: ServiceEndpoint) {
-    companion object {
-        private enum class Command {
-            SetRelayLocation,
-            SetWireguardConstraints
-        }
-    }
-
-    private val commandChannel = spawnActor()
-    private val daemon = endpoint.intermittentDaemon
-
-    private var selectedRelayLocation by
-        observable<GeographicLocationConstraint?>(null) { _, _, _ ->
-            commandChannel.trySendBlocking(Command.SetRelayLocation)
-        }
-    private var selectedWireguardConstraints by
-        observable<WireguardConstraints?>(null) { _, _, _ ->
-            commandChannel.trySendBlocking(Command.SetWireguardConstraints)
-        }
-
-    var relayList by
-        observable<RelayList?>(null) { _, _, relays ->
-            endpoint.sendEvent(Event.NewRelayList(relays))
-        }
-        private set
-
-    init {
-        daemon.registerListener(this) { newDaemon ->
-            newDaemon?.let { daemon ->
-                setUpListener(daemon)
-                fetchInitialRelayList(daemon)
-            }
-        }
-
-        endpoint.dispatcher.registerHandler(Request.SetRelayLocation::class) { request ->
-            selectedRelayLocation = request.relayLocation
-        }
-
-        endpoint.dispatcher.registerHandler(Request.SetWireguardConstraints::class) { request ->
-            selectedWireguardConstraints = request.wireguardConstraints
-        }
-    }
-
-    fun onDestroy() {
-        commandChannel.close()
-        daemon.unregisterListener(this)
-    }
-
-    private fun setUpListener(daemon: MullvadDaemon) {
-        daemon.onRelayListChange = { relayLocations -> relayList = relayLocations }
-    }
-
-    private fun fetchInitialRelayList(daemon: MullvadDaemon) {
-        synchronized(this) {
-            if (relayList == null) {
-                relayList = daemon.getRelayLocations()
-            }
-        }
-    }
-
-    private fun spawnActor() =
-        GlobalScope.actor<Command>(Dispatchers.Default, Channel.CONFLATED) {
-            try {
-                for (command in channel) {
-                    when (command) {
-                        Command.SetRelayLocation,
-                        Command.SetWireguardConstraints -> updateRelayConstraints()
-                    }
-                }
-            } catch (exception: ClosedReceiveChannelException) {
-                // Closed sender, so stop the actor
-            }
-        }
-
-    private suspend fun updateRelayConstraints() {
-        val location: Constraint<LocationConstraint> =
-            selectedRelayLocation?.let { location ->
-                Constraint.Only(LocationConstraint.Location(location))
-            }
-                ?: Constraint.Any()
-        val wireguardConstraints: WireguardConstraints? = selectedWireguardConstraints
-
-        val update =
-            RelaySettingsUpdate.Normal(RelayConstraintsUpdate(location, wireguardConstraints))
-
-        daemon.await().updateRelaySettings(update)
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/ServiceEndpoint.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/ServiceEndpoint.kt
deleted file mode 100644
index 1d6cb9f9a7..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/ServiceEndpoint.kt
+++ /dev/null
@@ -1,167 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import android.content.Context
-import android.os.Looper
-import android.os.Messenger
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.ClosedReceiveChannelException
-import kotlinx.coroutines.channels.SendChannel
-import kotlinx.coroutines.channels.actor
-import kotlinx.coroutines.channels.trySendBlocking
-import net.mullvad.mullvadvpn.lib.common.util.Intermittent
-import net.mullvad.mullvadvpn.lib.ipc.DispatchingHandler
-import net.mullvad.mullvadvpn.lib.ipc.Event
-import net.mullvad.mullvadvpn.lib.ipc.Request
-import net.mullvad.mullvadvpn.lib.ipc.extensions.trySendEvent
-import net.mullvad.mullvadvpn.service.MullvadDaemon
-import net.mullvad.mullvadvpn.service.persistence.SplitTunnelingPersistence
-import net.mullvad.talpid.ConnectivityListener
-
-const val SHOULD_LOG_DEAD_OBJECT_EXCEPTION = true
-
-class ServiceEndpoint(
-    looper: Looper,
-    internal val intermittentDaemon: Intermittent<MullvadDaemon>,
-    val connectivityListener: ConnectivityListener,
-    context: Context
-) {
-    companion object {
-        sealed class Command {
-            data class RegisterListener(val listener: Messenger) : Command()
-            data class UnregisterListener(val listenerId: Int) : Command()
-        }
-    }
-
-    private val listeners = mutableMapOf<Int, Messenger>()
-    private val commands: SendChannel<Command> = startRegistrator()
-
-    internal val dispatcher = DispatchingHandler(looper) { message -> Request.fromMessage(message) }
-
-    private var listenerIdCounter = 0
-
-    val messenger = Messenger(dispatcher)
-
-    val vpnPermission = VpnPermission(context, this)
-
-    val connectionProxy = ConnectionProxy(vpnPermission, this)
-    val settingsListener = SettingsListener(this)
-
-    val accountCache = AccountCache(this)
-    val appVersionInfoCache = AppVersionInfoCache(this)
-    val authTokenCache = AuthTokenCache(this)
-    val customDns = CustomDns(this)
-    val locationInfoCache = LocationInfoCache(this)
-    val relayListListener = RelayListListener(this)
-    val splitTunneling = SplitTunneling(SplitTunnelingPersistence(context), this)
-    val voucherRedeemer = VoucherRedeemer(this)
-
-    private val deviceRepositoryBackend = DaemonDeviceDataSource(this)
-
-    init {
-        dispatcher.apply {
-            registerHandler(Request.RegisterListener::class) { request ->
-                commands.trySendBlocking(Command.RegisterListener(request.listener))
-            }
-
-            registerHandler(Request.UnregisterListener::class) { request ->
-                commands.trySendBlocking(Command.UnregisterListener(request.listenerId))
-            }
-        }
-    }
-
-    fun onDestroy() {
-        dispatcher.onDestroy()
-        commands.close()
-
-        accountCache.onDestroy()
-        appVersionInfoCache.onDestroy()
-        authTokenCache.onDestroy()
-        connectionProxy.onDestroy()
-        customDns.onDestroy()
-        deviceRepositoryBackend.onDestroy()
-        locationInfoCache.onDestroy()
-        relayListListener.onDestroy()
-        settingsListener.onDestroy()
-        splitTunneling.onDestroy()
-        voucherRedeemer.onDestroy()
-    }
-
-    internal fun sendEvent(event: Event) {
-        synchronized(this) {
-            val deadListeners = mutableSetOf<Int>()
-
-            for ((id, listener) in listeners) {
-                if (!listener.trySendEvent(event, SHOULD_LOG_DEAD_OBJECT_EXCEPTION)) {
-                    deadListeners.add(id)
-                }
-            }
-            deadListeners.forEach { listeners.remove(it) }
-        }
-    }
-
-    private fun startRegistrator() =
-        GlobalScope.actor<Command>(Dispatchers.Default, Channel.UNLIMITED) {
-            try {
-                for (command in channel) {
-                    when (command) {
-                        is Command.RegisterListener -> {
-                            intermittentDaemon.await()
-
-                            registerListener(command.listener)
-                        }
-                        is Command.UnregisterListener -> unregisterListener(command.listenerId)
-                    }
-                }
-            } catch (exception: ClosedReceiveChannelException) {
-                // Registration queue closed; stop registrator
-            }
-        }
-
-    private fun registerListener(listener: Messenger) {
-        synchronized(this) {
-            val listenerId = newListenerId()
-
-            listeners.put(listenerId, listener)
-
-            val initialEvents =
-                mutableListOf(
-                    Event.TunnelStateChange(connectionProxy.state),
-                    Event.AccountHistoryEvent(accountCache.onAccountHistoryChange.latestEvent),
-                    Event.SettingsUpdate(settingsListener.settings),
-                    Event.NewLocation(locationInfoCache.location),
-                    Event.SplitTunnelingUpdate(splitTunneling.onChange.latestEvent),
-                    Event.CurrentVersion(appVersionInfoCache.currentVersion),
-                    Event.AppVersionInfo(appVersionInfoCache.appVersionInfo),
-                    Event.NewRelayList(relayListListener.relayList),
-                    Event.AuthToken(authTokenCache.authToken),
-                    Event.ListenerReady(messenger, listenerId)
-                )
-
-            if (vpnPermission.waitingForResponse) {
-                initialEvents.add(Event.VpnPermissionRequest)
-            }
-
-            val didSuccessfullySendAllMessages =
-                initialEvents.all { event ->
-                    listener.trySendEvent(event, SHOULD_LOG_DEAD_OBJECT_EXCEPTION)
-                }
-            if (didSuccessfullySendAllMessages.not()) {
-                listeners.remove(listenerId)
-            }
-        }
-    }
-
-    private fun unregisterListener(listenerId: Int) {
-        synchronized(this) { listeners.remove(listenerId) }
-    }
-
-    private fun newListenerId(): Int {
-        val listenerId = listenerIdCounter
-
-        listenerIdCounter += 1
-
-        return listenerId
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/SettingsListener.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/SettingsListener.kt
deleted file mode 100644
index 2863594cb9..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/SettingsListener.kt
+++ /dev/null
@@ -1,139 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.ClosedReceiveChannelException
-import kotlinx.coroutines.channels.actor
-import kotlinx.coroutines.channels.trySendBlocking
-import net.mullvad.mullvadvpn.lib.ipc.Event
-import net.mullvad.mullvadvpn.lib.ipc.Request
-import net.mullvad.mullvadvpn.model.*
-import net.mullvad.mullvadvpn.service.MullvadDaemon
-import net.mullvad.talpid.util.EventNotifier
-
-class SettingsListener(endpoint: ServiceEndpoint) {
-    private sealed class Command {
-        class SetAllowLan(val allow: Boolean) : Command()
-        class SetAutoConnect(val autoConnect: Boolean) : Command()
-        class SetWireGuardMtu(val mtu: Int?) : Command()
-        class SetObfuscationSettings(val settings: ObfuscationSettings?) : Command()
-        class SetQuantumResistant(val quantumResistant: QuantumResistantState) : Command()
-    }
-
-    private val commandChannel = spawnActor()
-    private val daemon = endpoint.intermittentDaemon
-
-    val dnsOptionsNotifier = EventNotifier<DnsOptions?>(null)
-    val relaySettingsNotifier = EventNotifier<RelaySettings?>(null)
-    val obfuscationSettingsNotifier = EventNotifier<ObfuscationSettings?>(null)
-    val settingsNotifier = EventNotifier<Settings?>(null)
-
-    var settings by settingsNotifier.notifiable()
-        private set
-
-    init {
-        daemon.registerListener(this) { newDaemon ->
-            if (newDaemon != null) {
-                registerListener(newDaemon)
-                fetchInitialSettings(newDaemon)
-            }
-        }
-
-        settingsNotifier.subscribe(this) { settings ->
-            endpoint.sendEvent(Event.SettingsUpdate(settings))
-        }
-
-        endpoint.dispatcher.apply {
-            registerHandler(Request.SetAllowLan::class) { request ->
-                commandChannel.trySendBlocking(Command.SetAllowLan(request.allow))
-            }
-
-            registerHandler(Request.SetAutoConnect::class) { request ->
-                commandChannel.trySendBlocking(Command.SetAutoConnect(request.autoConnect))
-            }
-
-            registerHandler(Request.SetWireGuardMtu::class) { request ->
-                commandChannel.trySendBlocking(Command.SetWireGuardMtu(request.mtu))
-            }
-
-            registerHandler(Request.SetObfuscationSettings::class) { request ->
-                commandChannel.trySendBlocking(Command.SetObfuscationSettings(request.settings))
-            }
-
-            registerHandler(Request.SetWireGuardQuantumResistant::class) { request ->
-                commandChannel.trySendBlocking(
-                    Command.SetQuantumResistant(request.quantumResistant)
-                )
-            }
-        }
-    }
-
-    fun onDestroy() {
-        commandChannel.close()
-        daemon.unregisterListener(this)
-
-        dnsOptionsNotifier.unsubscribeAll()
-        relaySettingsNotifier.unsubscribeAll()
-        obfuscationSettingsNotifier.unsubscribeAll()
-        settingsNotifier.unsubscribeAll()
-    }
-
-    fun subscribe(id: Any, listener: (Settings) -> Unit) {
-        settingsNotifier.subscribe(id) { maybeSettings ->
-            maybeSettings?.let { settings -> listener(settings) }
-        }
-    }
-
-    fun unsubscribe(id: Any) {
-        settingsNotifier.unsubscribe(id)
-    }
-
-    private fun registerListener(daemon: MullvadDaemon) {
-        daemon.onSettingsChange.subscribe(this, ::handleNewSettings)
-    }
-
-    private fun fetchInitialSettings(daemon: MullvadDaemon) {
-        synchronized(this) { handleNewSettings(daemon.getSettings()) }
-    }
-
-    private fun handleNewSettings(newSettings: Settings?) {
-        if (newSettings != null) {
-            synchronized(this) {
-                if (settings?.tunnelOptions?.dnsOptions != newSettings.tunnelOptions.dnsOptions) {
-                    dnsOptionsNotifier.notify(newSettings.tunnelOptions.dnsOptions)
-                }
-
-                if (settings?.relaySettings != newSettings.relaySettings) {
-                    relaySettingsNotifier.notify(newSettings.relaySettings)
-                }
-
-                if (settings?.obfuscationSettings != newSettings.obfuscationSettings) {
-                    obfuscationSettingsNotifier.notify(newSettings.obfuscationSettings)
-                }
-
-                settings = newSettings
-            }
-        }
-    }
-
-    private fun spawnActor() =
-        GlobalScope.actor<Command>(Dispatchers.Default, Channel.UNLIMITED) {
-            try {
-                for (command in channel) {
-                    when (command) {
-                        is Command.SetAllowLan -> daemon.await().setAllowLan(command.allow)
-                        is Command.SetAutoConnect ->
-                            daemon.await().setAutoConnect(command.autoConnect)
-                        is Command.SetWireGuardMtu -> daemon.await().setWireguardMtu(command.mtu)
-                        is Command.SetObfuscationSettings ->
-                            daemon.await().setObfuscationSettings(command.settings)
-                        is Command.SetQuantumResistant ->
-                            daemon.await().setQuantumResistant(command.quantumResistant)
-                    }
-                }
-            } catch (exception: ClosedReceiveChannelException) {
-                // Closed sender, so stop the actor
-            }
-        }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/SplitTunneling.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/SplitTunneling.kt
deleted file mode 100644
index a683b1e4bf..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/SplitTunneling.kt
+++ /dev/null
@@ -1,59 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import kotlin.properties.Delegates.observable
-import net.mullvad.mullvadvpn.lib.ipc.Event
-import net.mullvad.mullvadvpn.lib.ipc.Request
-import net.mullvad.mullvadvpn.service.persistence.SplitTunnelingPersistence
-import net.mullvad.talpid.util.EventNotifier
-
-class SplitTunneling(persistence: SplitTunnelingPersistence, endpoint: ServiceEndpoint) {
-    private val excludedApps = persistence.excludedApps.toMutableSet()
-
-    private var enabled by
-        observable(persistence.enabled) { _, wasEnabled, isEnabled ->
-            if (wasEnabled != isEnabled) {
-                persistence.enabled = isEnabled
-                update()
-            }
-        }
-
-    val onChange = EventNotifier<List<String>?>(excludedApps.toList())
-
-    init {
-        onChange.subscribe(this) { excludedApps ->
-            endpoint.sendEvent(Event.SplitTunnelingUpdate(excludedApps))
-        }
-
-        endpoint.dispatcher.apply {
-            registerHandler(Request.IncludeApp::class) { request ->
-                excludedApps.remove(request.packageName)
-                update()
-            }
-
-            registerHandler(Request.ExcludeApp::class) { request ->
-                excludedApps.add(request.packageName)
-                update()
-            }
-
-            registerHandler(Request.SetEnableSplitTunneling::class) { request ->
-                enabled = request.enable
-            }
-
-            registerHandler(Request.PersistExcludedApps::class) { _ ->
-                persistence.excludedApps = excludedApps
-            }
-        }
-    }
-
-    fun onDestroy() {
-        onChange.unsubscribeAll()
-    }
-
-    private fun update() {
-        if (enabled) {
-            onChange.notify(excludedApps.toList())
-        } else {
-            onChange.notify(null)
-        }
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/VoucherRedeemer.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/VoucherRedeemer.kt
deleted file mode 100644
index a7003d6888..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/VoucherRedeemer.kt
+++ /dev/null
@@ -1,40 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.ClosedReceiveChannelException
-import kotlinx.coroutines.channels.actor
-import kotlinx.coroutines.channels.trySendBlocking
-import net.mullvad.mullvadvpn.lib.ipc.Event
-import net.mullvad.mullvadvpn.lib.ipc.Request
-
-class VoucherRedeemer(private val endpoint: ServiceEndpoint) {
-    private val daemon
-        get() = endpoint.intermittentDaemon
-
-    private val voucherChannel = spawnActor()
-
-    init {
-        endpoint.dispatcher.registerHandler(Request.SubmitVoucher::class) { request ->
-            voucherChannel.trySendBlocking(request.voucher)
-        }
-    }
-
-    fun onDestroy() {
-        voucherChannel.close()
-    }
-
-    private fun spawnActor() =
-        GlobalScope.actor<String>(Dispatchers.Default, Channel.UNLIMITED) {
-            try {
-                for (voucher in channel) {
-                    val result = daemon.await().submitVoucher(voucher)
-
-                    endpoint.sendEvent(Event.VoucherSubmissionResult(voucher, result))
-                }
-            } catch (exception: ClosedReceiveChannelException) {
-                // Voucher channel was closed, stop the actor
-            }
-        }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/VpnPermission.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/VpnPermission.kt
deleted file mode 100644
index d94d1d6b60..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/endpoint/VpnPermission.kt
+++ /dev/null
@@ -1,45 +0,0 @@
-package net.mullvad.mullvadvpn.service.endpoint
-
-import android.content.Context
-import android.content.Intent
-import android.net.VpnService
-import net.mullvad.mullvadvpn.lib.common.util.Intermittent
-import net.mullvad.mullvadvpn.lib.ipc.Event
-import net.mullvad.mullvadvpn.lib.ipc.Request
-import net.mullvad.mullvadvpn.ui.MainActivity
-
-class VpnPermission(private val context: Context, private val endpoint: ServiceEndpoint) {
-    private val isGranted = Intermittent<Boolean>()
-
-    var waitingForResponse = false
-        private set
-
-    init {
-        endpoint.dispatcher.registerHandler(Request.VpnPermissionResponse::class) { request ->
-            waitingForResponse = false
-            isGranted.spawnUpdate(request.isGranted)
-        }
-    }
-
-    suspend fun request(): Boolean {
-        val intent = VpnService.prepare(context)
-
-        if (intent == null) {
-            isGranted.update(true)
-        } else {
-            val activityIntent =
-                Intent(context, MainActivity::class.java).apply {
-                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                    addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
-                }
-
-            isGranted.update(null)
-            waitingForResponse = true
-
-            context.startActivity(activityIntent)
-            endpoint.sendEvent(Event.VpnPermissionRequest)
-        }
-
-        return isGranted.await()
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/notifications/AccountExpiryNotification.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/notifications/AccountExpiryNotification.kt
deleted file mode 100644
index b66c668972..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/notifications/AccountExpiryNotification.kt
+++ /dev/null
@@ -1,142 +0,0 @@
-package net.mullvad.mullvadvpn.service.notifications
-
-import android.app.Notification
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.net.Uri
-import androidx.core.app.NotificationCompat
-import kotlin.properties.Delegates.observable
-import kotlinx.coroutines.delay
-import net.mullvad.mullvadvpn.BuildConfig
-import net.mullvad.mullvadvpn.R
-import net.mullvad.mullvadvpn.lib.common.constant.BuildTypes
-import net.mullvad.mullvadvpn.lib.common.util.Intermittent
-import net.mullvad.mullvadvpn.lib.common.util.JobTracker
-import net.mullvad.mullvadvpn.lib.common.util.SdkUtils
-import net.mullvad.mullvadvpn.lib.common.util.SdkUtils.isNotificationPermissionGranted
-import net.mullvad.mullvadvpn.model.AccountExpiry
-import net.mullvad.mullvadvpn.service.MullvadDaemon
-import net.mullvad.mullvadvpn.service.endpoint.AccountCache
-import net.mullvad.mullvadvpn.ui.MainActivity
-import org.joda.time.DateTime
-import org.joda.time.Duration
-
-class AccountExpiryNotification(
-    val context: Context,
-    val daemon: Intermittent<MullvadDaemon>,
-    val accountCache: AccountCache
-) {
-    companion object {
-        val NOTIFICATION_ID: Int = 2
-        val REMAINING_TIME_FOR_REMINDERS = Duration.standardDays(2)
-        val TIME_BETWEEN_CHECKS: Long = 12 /* h */ * 60 /* min */ * 60 /* s */ * 1000 /* ms */
-    }
-
-    private val jobTracker = JobTracker()
-    private val resources = context.resources
-
-    private val buyMoreTimeUrl = resources.getString(R.string.account_url)
-
-    private val channel =
-        NotificationChannel(
-            context,
-            "mullvad_account_time",
-            NotificationCompat.VISIBILITY_PRIVATE,
-            R.string.account_time_notification_channel_name,
-            R.string.account_time_notification_channel_description,
-            NotificationManager.IMPORTANCE_HIGH,
-            true,
-            true
-        )
-
-    var accountExpiry by
-        observable<AccountExpiry>(AccountExpiry.Missing) { _, oldValue, newValue ->
-            if (oldValue != newValue) {
-                jobTracker.newUiJob("update") { update(newValue) }
-            }
-        }
-
-    init {
-        accountCache.onAccountExpiryChange.subscribe(this) { expiry -> accountExpiry = expiry }
-    }
-
-    fun onDestroy() {
-        accountCache.onAccountExpiryChange.unsubscribe(this)
-    }
-
-    private suspend fun update(expiry: AccountExpiry) {
-        val expiryDate = expiry.date()
-        val durationUntilExpiry = expiryDate?.remainingTime()
-
-        if (accountCache.isNewAccount.not() && durationUntilExpiry?.isCloseToExpiry() == true) {
-            if (context.isNotificationPermissionGranted()) {
-                val notification = build(expiryDate, durationUntilExpiry)
-                channel.notificationManager.notify(NOTIFICATION_ID, notification)
-            }
-            jobTracker.newUiJob("scheduleUpdate") { scheduleUpdate() }
-        } else {
-            channel.notificationManager.cancel(NOTIFICATION_ID)
-            jobTracker.cancelJob("scheduleUpdate")
-        }
-    }
-
-    private fun DateTime.remainingTime(): Duration {
-        return Duration(DateTime.now(), this)
-    }
-
-    private fun Duration.isCloseToExpiry(): Boolean {
-        return isShorterThan(REMAINING_TIME_FOR_REMINDERS)
-    }
-
-    private suspend fun scheduleUpdate() {
-        delay(TIME_BETWEEN_CHECKS)
-        update(accountExpiry)
-    }
-
-    private suspend fun build(expiry: DateTime, remainingTime: Duration): Notification {
-        val url =
-            jobTracker.runOnBackground {
-                Uri.parse("$buyMoreTimeUrl?token=${daemon.await().getWwwAuthToken()}")
-            }
-        val intent =
-            if (BuildTypes.RELEASE == BuildConfig.BUILD_TYPE) {
-                Intent(context, MainActivity::class.java)
-                    .setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-                    .setAction(Intent.ACTION_MAIN)
-            } else {
-                Intent(Intent.ACTION_VIEW, url)
-            }
-        val pendingIntent =
-            PendingIntent.getActivity(context, 1, intent, SdkUtils.getSupportedPendingIntentFlags())
-
-        return channel.buildNotification(pendingIntent, format(expiry, remainingTime))
-    }
-
-    private fun format(expiry: DateTime, remainingTime: Duration): String {
-        if (remainingTime.isShorterThan(Duration.ZERO)) {
-            return resources.getString(R.string.account_credit_has_expired)
-        } else {
-            val remainingTimeInfo = remainingTime.toPeriodTo(expiry)
-
-            if (remainingTimeInfo.days >= 1) {
-                return getRemainingText(
-                    R.plurals.account_credit_expires_in_days,
-                    remainingTime.standardDays.toInt()
-                )
-            } else if (remainingTimeInfo.hours >= 1) {
-                return getRemainingText(
-                    R.plurals.account_credit_expires_in_hours,
-                    remainingTime.standardHours.toInt()
-                )
-            } else {
-                return resources.getString(R.string.account_credit_expires_in_a_few_minutes)
-            }
-        }
-    }
-
-    private fun getRemainingText(pluralId: Int, quantity: Int): String {
-        return resources.getQuantityString(pluralId, quantity, quantity)
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/notifications/NotificationChannel.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/notifications/NotificationChannel.kt
deleted file mode 100644
index de557aaf22..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/notifications/NotificationChannel.kt
+++ /dev/null
@@ -1,97 +0,0 @@
-package net.mullvad.mullvadvpn.service.notifications
-
-import android.app.Notification
-import android.app.PendingIntent
-import android.content.Context
-import androidx.core.app.NotificationChannelCompat
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
-import net.mullvad.mullvadvpn.R
-
-class NotificationChannel(
-    val context: Context,
-    val id: String,
-    val visibility: Int,
-    name: Int,
-    description: Int,
-    importance: Int,
-    isVibrationEnabled: Boolean,
-    isBadgeEnabled: Boolean
-) {
-    private val badgeColor by lazy { context.getColor(R.color.colorPrimary) }
-
-    val notificationManager = NotificationManagerCompat.from(context)
-
-    init {
-        val channelName = context.getString(name)
-        val channelDescription = context.getString(description)
-
-        val channel =
-            NotificationChannelCompat.Builder(id, importance)
-                .setName(channelName)
-                .setDescription(channelDescription)
-                .setShowBadge(isBadgeEnabled)
-                .setVibrationEnabled(isVibrationEnabled)
-                .build()
-
-        notificationManager.createNotificationChannel(channel)
-    }
-
-    fun buildNotification(
-        intent: PendingIntent,
-        title: String,
-        deleteIntent: PendingIntent? = null,
-        isOngoing: Boolean = false
-    ): Notification {
-        return buildNotification(intent, title, emptyList(), deleteIntent, isOngoing)
-    }
-
-    fun buildNotification(
-        intent: PendingIntent,
-        title: Int,
-        deleteIntent: PendingIntent? = null,
-        isOngoing: Boolean = false
-    ): Notification {
-        return buildNotification(intent, title, emptyList(), deleteIntent, isOngoing)
-    }
-
-    fun buildNotification(
-        pendingIntent: PendingIntent,
-        title: Int,
-        actions: List<NotificationCompat.Action>,
-        deleteIntent: PendingIntent? = null,
-        isOngoing: Boolean = false
-    ): Notification {
-        return buildNotification(
-            pendingIntent,
-            context.getString(title),
-            actions,
-            deleteIntent,
-            isOngoing
-        )
-    }
-
-    private fun buildNotification(
-        pendingIntent: PendingIntent,
-        title: String,
-        actions: List<NotificationCompat.Action>,
-        deleteIntent: PendingIntent? = null,
-        isOngoing: Boolean = false
-    ): Notification {
-        val builder =
-            NotificationCompat.Builder(context, id)
-                .setSmallIcon(R.drawable.small_logo_black)
-                .setColor(badgeColor)
-                .setContentTitle(title)
-                .setContentIntent(pendingIntent)
-                .setVisibility(visibility)
-                .setOngoing(isOngoing)
-        for (action in actions) {
-            builder.addAction(action)
-        }
-
-        deleteIntent?.let { intent -> builder.setDeleteIntent(intent) }
-
-        return builder.build()
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/notifications/TunnelStateNotification.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/notifications/TunnelStateNotification.kt
deleted file mode 100644
index b25d1a2056..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/notifications/TunnelStateNotification.kt
+++ /dev/null
@@ -1,142 +0,0 @@
-package net.mullvad.mullvadvpn.service.notifications
-
-import android.app.Notification
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import androidx.core.app.NotificationCompat
-import kotlin.properties.Delegates.observable
-import net.mullvad.mullvadvpn.R
-import net.mullvad.mullvadvpn.lib.common.util.SdkUtils
-import net.mullvad.mullvadvpn.lib.common.util.getErrorNotificationResources
-import net.mullvad.mullvadvpn.model.TunnelState
-import net.mullvad.mullvadvpn.ui.MainActivity
-import net.mullvad.talpid.tunnel.ActionAfterDisconnect
-import net.mullvad.talpid.tunnel.ErrorStateCause
-
-class TunnelStateNotification(val context: Context) {
-    companion object {
-        val NOTIFICATION_ID: Int = 1
-    }
-
-    private val channel =
-        NotificationChannel(
-            context,
-            "vpn_tunnel_status",
-            NotificationCompat.VISIBILITY_SECRET,
-            R.string.foreground_notification_channel_name,
-            R.string.foreground_notification_channel_description,
-            NotificationManager.IMPORTANCE_MIN,
-            false,
-            false
-        )
-
-    private val notificationText: Int
-        get() =
-            when (val state = tunnelState) {
-                is TunnelState.Disconnected -> R.string.unsecured
-                is TunnelState.Connecting -> {
-                    if (reconnecting) {
-                        R.string.reconnecting
-                    } else {
-                        R.string.connecting
-                    }
-                }
-                is TunnelState.Connected -> R.string.secured
-                is TunnelState.Disconnecting -> {
-                    when (state.actionAfterDisconnect) {
-                        ActionAfterDisconnect.Reconnect -> R.string.reconnecting
-                        else -> R.string.disconnecting
-                    }
-                }
-                is TunnelState.Error -> {
-                    if (state.isDeviceOffline()) {
-                        R.string.blocking_internet_device_offline
-                    } else {
-                        state.errorState.getErrorNotificationResources(context).titleResourceId
-                    }
-                }
-            }
-
-    private fun TunnelState.isDeviceOffline(): Boolean {
-        return (this as? TunnelState.Error)?.errorState?.cause is ErrorStateCause.IsOffline
-    }
-
-    private val shouldDisplayOngoingNotification: Boolean
-        get() =
-            when (tunnelState) {
-                is TunnelState.Connected -> true
-                is TunnelState.Disconnected,
-                is TunnelState.Connecting,
-                is TunnelState.Disconnecting,
-                is TunnelState.Error -> false
-            }
-
-    private var reconnecting = false
-    private var showingReconnecting = false
-
-    var showAction by observable(false) { _, _, _ -> update() }
-
-    var tunnelState by
-        observable<TunnelState>(TunnelState.Disconnected) { _, _, newState ->
-            val isReconnecting = newState is TunnelState.Connecting && reconnecting
-            val shouldBeginReconnecting =
-                (newState as? TunnelState.Disconnecting)?.actionAfterDisconnect ==
-                    ActionAfterDisconnect.Reconnect
-            reconnecting = isReconnecting || shouldBeginReconnecting
-            update()
-        }
-
-    var visible by
-        observable(true) { _, _, newValue ->
-            if (newValue == true) {
-                update()
-            } else {
-                channel.notificationManager.cancel(NOTIFICATION_ID)
-            }
-        }
-
-    private fun update() {
-        if (visible && (!reconnecting || !showingReconnecting)) {
-            channel.notificationManager.notify(NOTIFICATION_ID, build())
-        }
-    }
-
-    fun build(): Notification {
-        val intent =
-            Intent(context, MainActivity::class.java)
-                .setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-                .setAction(Intent.ACTION_MAIN)
-        val pendingIntent =
-            PendingIntent.getActivity(context, 1, intent, SdkUtils.getSupportedPendingIntentFlags())
-        val actions =
-            if (showAction) {
-                listOf(buildAction())
-            } else {
-                emptyList()
-            }
-
-        return channel.buildNotification(
-            pendingIntent,
-            notificationText,
-            actions,
-            isOngoing = shouldDisplayOngoingNotification
-        )
-    }
-
-    private fun buildAction(): NotificationCompat.Action {
-        val action = TunnelStateNotificationAction.from(tunnelState)
-        val label = context.getString(action.text)
-        val intent = Intent(action.key).setPackage("net.mullvad.mullvadvpn")
-        val pendingIntent =
-            PendingIntent.getForegroundService(
-                context,
-                1,
-                intent,
-                SdkUtils.getSupportedPendingIntentFlags()
-            )
-
-        return NotificationCompat.Action(action.icon, label, pendingIntent)
-    }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/notifications/TunnelStateNotificationAction.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/notifications/TunnelStateNotificationAction.kt
deleted file mode 100644
index 9ed9998054..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/notifications/TunnelStateNotificationAction.kt
+++ /dev/null
@@ -1,58 +0,0 @@
-package net.mullvad.mullvadvpn.service.notifications
-
-import net.mullvad.mullvadvpn.R
-import net.mullvad.mullvadvpn.model.TunnelState
-import net.mullvad.mullvadvpn.service.MullvadVpnService
-import net.mullvad.talpid.tunnel.ActionAfterDisconnect
-
-enum class TunnelStateNotificationAction {
-    Connect,
-    Disconnect,
-    Cancel,
-    Dismiss;
-
-    companion object {
-        fun from(tunnelState: TunnelState) =
-            when (tunnelState) {
-                is TunnelState.Disconnected -> Connect
-                is TunnelState.Connecting -> Cancel
-                is TunnelState.Connected -> Disconnect
-                is TunnelState.Disconnecting -> {
-                    when (tunnelState.actionAfterDisconnect) {
-                        ActionAfterDisconnect.Reconnect -> Cancel
-                        else -> Connect
-                    }
-                }
-                is TunnelState.Error -> {
-                    if (tunnelState.errorState.isBlocking) {
-                        Disconnect
-                    } else {
-                        Dismiss
-                    }
-                }
-            }
-    }
-
-    val text
-        get() =
-            when (this) {
-                Connect -> R.string.connect
-                Disconnect -> R.string.disconnect
-                Cancel -> R.string.cancel
-                Dismiss -> R.string.dismiss
-            }
-
-    val key
-        get() =
-            when (this) {
-                Connect -> MullvadVpnService.KEY_CONNECT_ACTION
-                else -> MullvadVpnService.KEY_DISCONNECT_ACTION
-            }
-
-    val icon
-        get() =
-            when (this) {
-                Connect -> R.drawable.icon_notification_connect
-                else -> R.drawable.icon_notification_disconnect
-            }
-}
diff --git a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/persistence/SplitTunnelingPersistence.kt b/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/persistence/SplitTunnelingPersistence.kt
deleted file mode 100644
index 264304ab3f..0000000000
--- a/android/app/src/main/kotlin/net/mullvad/mullvadvpn/service/persistence/SplitTunnelingPersistence.kt
+++ /dev/null
@@ -1,37 +0,0 @@
-package net.mullvad.mullvadvpn.service.persistence
-
-import android.content.Context
-import java.io.File
-import kotlin.properties.Delegates.observable
-
-// The spelling of the shared preferences location can't be changed to American English without
-// either having users lose their preferences on update or implementing some migration code.
-private const val SHARED_PREFERENCES = "split_tunnelling"
-private const val KEY_ENABLED = "enabled"
-
-class SplitTunnelingPersistence(context: Context) {
-    // The spelling of the app list file name can't be changed to American English without either
-    // having users lose their preferences on update or implementing some migration code.
-    private val appListFile = File(context.filesDir, "split-tunnelling.txt")
-    private val preferences = context.getSharedPreferences(SHARED_PREFERENCES, Context.MODE_PRIVATE)
-
-    var enabled by
-        observable(preferences.getBoolean(KEY_ENABLED, false)) { _, _, isEnabled ->
-            preferences.edit().apply {
-                putBoolean(KEY_ENABLED, isEnabled)
-                apply()
-            }
-        }
-
-    var excludedApps by
-        observable(loadExcludedApps()) { _, _, excludedAppsSet ->
-            appListFile.writeText(excludedAppsSet.joinToString(separator = "\n"))
-        }
-
-    private fun loadExcludedApps(): Set<String> {
-        return when {
-            appListFile.exists() -> appListFile.readLines().toSet()
-            else -> emptySet()
-        }
-    }
-}