diff --git a/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WatcherState.kt b/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WatcherState.kt
index 8b7f52d..eea2217 100644
--- a/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WatcherState.kt
+++ b/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WatcherState.kt
@@ -2,83 +2,75 @@ package com.zaneschepke.wireguardautotunnel.service.foreground
 
 import com.zaneschepke.wireguardautotunnel.data.domain.Settings
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 
 data class WatcherState(
     val isWifiConnected: Boolean = false,
     val config: TunnelConfig? = null,
-    val vpnStatus: TunnelState = TunnelState.DOWN,
+    //val vpnStatus: TunnelState = TunnelState.DOWN,
     val isEthernetConnected: Boolean = false,
     val isMobileDataConnected: Boolean = false,
     val currentNetworkSSID: String = "",
     val settings: Settings = Settings()
 ) {
 
-    private fun isVpnConnected() = vpnStatus == TunnelState.UP
+    //private fun isVpnConnected() = vpnStatus == TunnelState.UP
     fun isEthernetConditionMet(): Boolean {
         return (isEthernetConnected &&
-            settings.isTunnelOnEthernetEnabled &&
-            !isVpnConnected())
+            settings.isTunnelOnEthernetEnabled)
     }
 
     fun isMobileDataConditionMet(): Boolean {
         return (!isEthernetConnected &&
             settings.isTunnelOnMobileDataEnabled &&
             !isWifiConnected &&
-            isMobileDataConnected &&
-            !isVpnConnected())
+            isMobileDataConnected)
     }
 
-    fun isTunnelNotMobileDataPreferredConditionMet(): Boolean {
+    fun isTunnelOnMobileDataPreferredConditionMet(): Boolean {
         return (!isEthernetConnected &&
             settings.isTunnelOnMobileDataEnabled &&
             !isWifiConnected &&
             isMobileDataConnected &&
-            config?.isMobileDataTunnel == false && isVpnConnected())
+            config?.isMobileDataTunnel == false)
     }
 
     fun isTunnelOffOnMobileDataConditionMet(): Boolean {
         return (!isEthernetConnected &&
             !settings.isTunnelOnMobileDataEnabled &&
             isMobileDataConnected &&
-            !isWifiConnected &&
-            isVpnConnected())
+            !isWifiConnected)
     }
 
     fun isUntrustedWifiConditionMet(): Boolean {
         return (!isEthernetConnected &&
             isWifiConnected &&
             !settings.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
-            settings.isTunnelOnWifiEnabled
-            && !isVpnConnected())
+            settings.isTunnelOnWifiEnabled)
     }
 
     fun isTunnelNotWifiNamePreferredMet(ssid: String): Boolean {
         return (!isEthernetConnected &&
             isWifiConnected &&
             !settings.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
-            settings.isTunnelOnWifiEnabled && config?.tunnelNetworks?.contains(ssid) == false && isVpnConnected())
+            settings.isTunnelOnWifiEnabled && config?.tunnelNetworks?.contains(ssid) == false)
     }
 
     fun isTrustedWifiConditionMet(): Boolean {
         return (!isEthernetConnected &&
             (isWifiConnected &&
-                settings.trustedNetworkSSIDs.contains(currentNetworkSSID)) &&
-            (isVpnConnected()))
+                settings.trustedNetworkSSIDs.contains(currentNetworkSSID)))
     }
 
     fun isTunnelOffOnWifiConditionMet(): Boolean {
         return (!isEthernetConnected &&
             (isWifiConnected &&
-                !settings.isTunnelOnWifiEnabled &&
-                (isVpnConnected())))
+                !settings.isTunnelOnWifiEnabled))
     }
 
     fun isTunnelOffOnNoConnectivityMet(): Boolean {
         return (!isEthernetConnected &&
             !isWifiConnected &&
-            !isMobileDataConnected &&
-            (isVpnConnected()))
+            !isMobileDataConnected)
     }
 }
 
diff --git a/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WireGuardConnectivityWatcherService.kt b/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WireGuardConnectivityWatcherService.kt
index 3749c44..bbf1d37 100644
--- a/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WireGuardConnectivityWatcherService.kt
+++ b/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WireGuardConnectivityWatcherService.kt
@@ -25,7 +25,6 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import timber.log.Timber
 import java.net.InetAddress
 import javax.inject.Inject
@@ -237,7 +236,7 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
                             Timber.i("Restarting VPN for ping failure")
                             serviceManager.stopVpnServiceForeground(this)
                             delay(Constants.VPN_RESTART_DELAY)
-                            serviceManager.startVpnServiceForeground(this)
+                            serviceManager.startVpnServiceForeground(this, it.id)
                             delay(Constants.PING_COOLDOWN)
                         }
                     }
@@ -268,7 +267,6 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
         vpnService.vpnState.collect {
             networkEventsFlow.value =
                 networkEventsFlow.value.copy(
-                    vpnStatus = it.status,
                     config = it.tunnelConfig,
                 )
         }
@@ -353,6 +351,10 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
         return appDataRepository.tunnels.findByTunnelNetworksName(ssid).firstOrNull()
     }
 
+    private fun isTunnelDown() : Boolean {
+        return vpnService.vpnState.value.status == TunnelState.DOWN
+    }
+
     private suspend fun manageVpn() {
         networkEventsFlow.collectLatest { watcherState ->
             val autoTunnel = "Auto-tunnel watcher"
@@ -362,18 +364,18 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
                 when {
                     watcherState.isEthernetConditionMet() -> {
                         Timber.i("$autoTunnel - tunnel on on ethernet condition met")
-                        serviceManager.startVpnServiceForeground(this)
+                        if(isTunnelDown()) serviceManager.startVpnServiceForeground(this)
                     }
 
                     watcherState.isMobileDataConditionMet() -> {
                         Timber.i("$autoTunnel - tunnel on on mobile data condition met")
-                        serviceManager.startVpnServiceForeground(this, getMobileDataTunnel()?.id)
+                        if(isTunnelDown()) serviceManager.startVpnServiceForeground(this, getMobileDataTunnel()?.id)
                     }
 
-                    watcherState.isTunnelNotMobileDataPreferredConditionMet() -> {
+                    watcherState.isTunnelOnMobileDataPreferredConditionMet() -> {
                         getMobileDataTunnel()?.let {
                             Timber.i("$autoTunnel - tunnel connected on mobile data is not preferred condition met, switching to preferred")
-                            serviceManager.startVpnServiceForeground(
+                            if(isTunnelDown()) serviceManager.startVpnServiceForeground(
                                 this,
                                 getMobileDataTunnel()?.id,
                             )
@@ -382,25 +384,25 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 
                     watcherState.isTunnelOffOnMobileDataConditionMet() -> {
                         Timber.i("$autoTunnel - tunnel off on mobile data met, turning vpn off")
-                        serviceManager.stopVpnServiceForeground(this)
+                        if(!isTunnelDown()) serviceManager.stopVpnServiceForeground(this)
                     }
 
                     watcherState.isTunnelNotWifiNamePreferredMet(watcherState.currentNetworkSSID) -> {
                         Timber.i("$autoTunnel - tunnel on ssid not associated with current tunnel condition met")
                         getSsidTunnel(watcherState.currentNetworkSSID)?.let {
                             Timber.i("Found tunnel associated with this SSID, bringing tunnel up")
-                            serviceManager.startVpnServiceForeground(this, it.id)
+                            if(isTunnelDown()) serviceManager.startVpnServiceForeground(this, it.id)
                         } ?: suspend {
                             Timber.i("No tunnel associated with this SSID, using defaults")
                             if (appDataRepository.getPrimaryOrFirstTunnel()?.name != vpnService.name) {
-                                serviceManager.startVpnServiceForeground(this)
+                                if(isTunnelDown()) serviceManager.startVpnServiceForeground(this)
                             }
                         }.invoke()
                     }
 
                     watcherState.isUntrustedWifiConditionMet() -> {
                         Timber.i("$autoTunnel - tunnel on untrusted wifi condition met")
-                        serviceManager.startVpnServiceForeground(
+                        if(isTunnelDown()) serviceManager.startVpnServiceForeground(
                             this,
                             getSsidTunnel(watcherState.currentNetworkSSID)?.id,
                         )
@@ -408,17 +410,17 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 
                     watcherState.isTrustedWifiConditionMet() -> {
                         Timber.i("$autoTunnel - tunnel off on trusted wifi condition met, turning vpn off")
-                        serviceManager.stopVpnServiceForeground(this)
+                        if(!isTunnelDown()) serviceManager.stopVpnServiceForeground(this)
                     }
 
                     watcherState.isTunnelOffOnWifiConditionMet() -> {
                         Timber.i("$autoTunnel - tunnel off on wifi condition met, turning vpn off")
-                        serviceManager.stopVpnServiceForeground(this)
+                        if(!isTunnelDown()) serviceManager.stopVpnServiceForeground(this)
                     }
 
                     watcherState.isTunnelOffOnNoConnectivityMet() -> {
                         Timber.i("$autoTunnel - tunnel off on no connectivity met, turning vpn off")
-                        serviceManager.stopVpnServiceForeground(this)
+                        if(!isTunnelDown()) serviceManager.stopVpnServiceForeground(this)
                     }
 
                     else -> {