chore: apply ktfmt formatting

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: naonak

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/tunnel/TunnelManager.kt

@@ -43,13 +43,13 @@ import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.flow.distinctUntilChangedBy
 import kotlinx.coroutines.flow.filterNot
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.flow.merge
 import kotlinx.coroutines.flow.shareIn
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.plus
 import kotlinx.coroutines.supervisorScope

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/tunnel/handler/HandshakeRestartHandler.kt

@@ -57,7 +57,8 @@ class HandshakeRestartHandler(
                     val knownIds = tunnelConfigs.map { it.id }.toSet()
 
                     // Cancel jobs for tunnels that left activeTunnels
-                    // Skip tunnels we're actively restarting (they leave temporarily during stop/start)
+                    // Skip tunnels we're actively restarting (they leave temporarily during
+                    // stop/start)
                     // BUT always cancel if the tunnel was deleted from DB
                     (jobs.keys - activeIds).forEach { id ->
                         if (restarting[id] != true || id !in knownIds) {
@@ -72,18 +73,15 @@ class HandshakeRestartHandler(
                     activeIds.forEach { id ->
                         if (jobs.containsKey(id)) return@forEach
                         val config = tunnelConfigs.find { it.id == id } ?: return@forEach
-                        jobs[id] = applicationScope.launch(ioDispatcher) {
-                            runRestartLoop(id, config)
-                        }
+                        jobs[id] =
+                            applicationScope.launch(ioDispatcher) { runRestartLoop(id, config) }
                     }
                 }
             }
         }
     }
 
-    /**
-     * Top-level loop for a single tunnel. Restarts whenever monitoring settings change.
-     */
+    /** Top-level loop for a single tunnel. Restarts whenever monitoring settings change. */
     private suspend fun runRestartLoop(tunnelId: Int, config: TunnelConfig) {
         monitoringSettingsRepository.flow.collectLatest { settings ->
             if (!settings.isAutoRestartActive()) {
@@ -102,8 +100,8 @@ class HandshakeRestartHandler(
     }
 
     /**
-     * Monitoring state machine for one tunnel with fixed settings snapshot.
-     * Exits when max attempts are reached or the coroutine is cancelled.
+     * Monitoring state machine for one tunnel with fixed settings snapshot. Exits when max attempts
+     * are reached or the coroutine is cancelled.
      */
     private suspend fun monitorTunnel(
         tunnelId: Int,
@@ -124,7 +122,9 @@ class HandshakeRestartHandler(
             attempt++
 
             if (attempt > maxAttempts) {
-                Timber.d("HandshakeRestartHandler: tunnel $tunnelId gave up after $maxAttempts attempts")
+                Timber.d(
+                    "HandshakeRestartHandler: tunnel $tunnelId gave up after $maxAttempts attempts"
+                )
                 updateProgress(
                     tunnelId,
                     TunnelRestartProgress(
@@ -165,7 +165,9 @@ class HandshakeRestartHandler(
             }
 
             // RESTARTING
-            Timber.d("HandshakeRestartHandler: restarting tunnel $tunnelId (attempt $attempt/$maxAttempts)")
+            Timber.d(
+                "HandshakeRestartHandler: restarting tunnel $tunnelId (attempt $attempt/$maxAttempts)"
+            )
             updateProgress(
                 tunnelId,
                 TunnelRestartProgress(
@@ -179,13 +181,17 @@ class HandshakeRestartHandler(
             )
             mutex.withLock { restarting[tunnelId] = true }
             runCatching { stopTunnel(tunnelId) }
-                .onFailure { Timber.e(it, "HandshakeRestartHandler: stop failed for tunnel $tunnelId") }
+                .onFailure {
+                    Timber.e(it, "HandshakeRestartHandler: stop failed for tunnel $tunnelId")
+                }
             delay(RESTART_SETTLE_DELAY_MS)
 
             // Abort if another tunnel took over while we were stopped (e.g. auto-tunnel switched)
             val currentActive = activeTunnels.value
             if (currentActive.isNotEmpty() && !currentActive.containsKey(tunnelId)) {
-                Timber.d("HandshakeRestartHandler: tunnel $tunnelId superseded by another tunnel, aborting restart")
+                Timber.d(
+                    "HandshakeRestartHandler: tunnel $tunnelId superseded by another tunnel, aborting restart"
+                )
                 mutex.withLock { restarting[tunnelId] = false }
                 updateProgress(tunnelId, null)
                 return
@@ -194,12 +200,15 @@ class HandshakeRestartHandler(
             // Fetch fresh config in case tunnel was modified since handler started
             val freshConfig = tunnelsRepository.getById(tunnelId) ?: config
             runCatching { startTunnel(freshConfig) }
-                .onFailure { Timber.e(it, "HandshakeRestartHandler: start failed for tunnel $tunnelId") }
+                .onFailure {
+                    Timber.e(it, "HandshakeRestartHandler: start failed for tunnel $tunnelId")
+                }
 
             // Wait for tunnel to come back UP (30s safety timeout)
-            val cameUp = withTimeoutOrNull(TUNNEL_UP_TIMEOUT_MS) {
-                activeTunnels.mapNotNull { it[tunnelId] }.first { it.status is TunnelStatus.Up }
-            }
+            val cameUp =
+                withTimeoutOrNull(TUNNEL_UP_TIMEOUT_MS) {
+                    activeTunnels.mapNotNull { it[tunnelId] }.first { it.status is TunnelStatus.Up }
+                }
             mutex.withLock { restarting[tunnelId] = false }
             totalRestarts++
 
@@ -224,31 +233,38 @@ class HandshakeRestartHandler(
                 ),
             )
 
-            val timeout = settings.tunnelPingTimeoutSeconds?.toMillis()
-                ?: (settings.tunnelPingAttempts * 2000L)
+            val timeout =
+                settings.tunnelPingTimeoutSeconds?.toMillis()
+                    ?: (settings.tunnelPingAttempts * 2000L)
             val pingResult = runCatching {
                 networkUtils.pingWithStats(pingTarget, settings.tunnelPingAttempts, timeout)
             }
             val recovered = pingResult.getOrNull()?.isReachable == true
 
             if (recovered) {
-                Timber.d("HandshakeRestartHandler: tunnel $tunnelId recovered after attempt $attempt")
+                Timber.d(
+                    "HandshakeRestartHandler: tunnel $tunnelId recovered after attempt $attempt"
+                )
                 emitMessage(config.name, BackendMessage.ConnectionRestored)
                 // Reset attempt counter but keep totalRestarts visible
                 attempt = 0
-                updateProgress(
-                    tunnelId,
-                    TunnelRestartProgress(totalRestarts = totalRestarts),
-                )
+                updateProgress(tunnelId, TunnelRestartProgress(totalRestarts = totalRestarts))
                 pingTarget = awaitPingFailures(tunnelId, settings)
                 continue
             }
 
             // COOLDOWN — only if there are remaining attempts
             if (attempt < maxAttempts) {
-                val cooldownMs = computeCooldown(settings.restartCooldownSeconds, attempt, settings.isBackoffEnabled) * 1000L
+                val cooldownMs =
+                    computeCooldown(
+                        settings.restartCooldownSeconds,
+                        attempt,
+                        settings.isBackoffEnabled,
+                    ) * 1000L
                 val cooldownEnd = System.currentTimeMillis() + cooldownMs
-                Timber.d("HandshakeRestartHandler: cooldown ${cooldownMs / 1000}s before next restart for tunnel $tunnelId")
+                Timber.d(
+                    "HandshakeRestartHandler: cooldown ${cooldownMs / 1000}s before next restart for tunnel $tunnelId"
+                )
                 updateProgress(
                     tunnelId,
                     TunnelRestartProgress(
@@ -264,22 +280,28 @@ class HandshakeRestartHandler(
                 // If cooldown is longer than ping interval, race against periodic ping recovery
                 val pingIntervalMs = settings.tunnelPingIntervalSeconds.toMillis()
                 if (cooldownMs > pingIntervalMs) {
-                    val recoveredDuringCooldown = withTimeoutOrNull(cooldownMs) {
-                        activeTunnels
-                            .mapNotNull { it[tunnelId]?.pingStates }
-                            .distinctUntilChanged()
-                            .first { pingStates ->
-                                pingStates.values.isNotEmpty() &&
-                                    pingStates.values.all { it.isReachable }
-                            }
-                        true
-                    } != null
+                    val recoveredDuringCooldown =
+                        withTimeoutOrNull(cooldownMs) {
+                            activeTunnels
+                                .mapNotNull { it[tunnelId]?.pingStates }
+                                .distinctUntilChanged()
+                                .first { pingStates ->
+                                    pingStates.values.isNotEmpty() &&
+                                        pingStates.values.all { it.isReachable }
+                                }
+                            true
+                        } != null
 
                     if (recoveredDuringCooldown) {
-                        Timber.d("HandshakeRestartHandler: tunnel $tunnelId recovered during cooldown")
+                        Timber.d(
+                            "HandshakeRestartHandler: tunnel $tunnelId recovered during cooldown"
+                        )
                         emitMessage(config.name, BackendMessage.ConnectionRestored)
                         attempt = 0
-                        updateProgress(tunnelId, TunnelRestartProgress(totalRestarts = totalRestarts))
+                        updateProgress(
+                            tunnelId,
+                            TunnelRestartProgress(totalRestarts = totalRestarts),
+                        )
                         pingTarget = awaitPingFailures(tunnelId, settings)
                         continue
                     }
@@ -292,26 +314,24 @@ class HandshakeRestartHandler(
     }
 
     /**
-     * Suspends until [MonitoringSettings.pingFailuresBeforeRestart] consecutive ping cycles
-     * all report unreachable. Returns the ping target of the failing peer.
+     * Suspends until [MonitoringSettings.pingFailuresBeforeRestart] consecutive ping cycles all
+     * report unreachable. Returns the ping target of the failing peer.
      */
-    private suspend fun awaitPingFailures(
-        tunnelId: Int,
-        settings: MonitoringSettings,
-    ): String {
+    private suspend fun awaitPingFailures(tunnelId: Int, settings: MonitoringSettings): String {
         var consecutive = 0
         var target = CLOUDFLARE_IPV4_IP
 
         activeTunnels
             .mapNotNull { it[tunnelId]?.pingStates }
             .distinctUntilChanged()
             .first { pingStates ->
-                val allFailing = pingStates.values.isNotEmpty() &&
-                    pingStates.values.all { !it.isReachable }
+                val allFailing =
+                    pingStates.values.isNotEmpty() && pingStates.values.all { !it.isReachable }
                 if (allFailing) {
-                    pingStates.values.firstOrNull { !it.isReachable }?.pingTarget?.let {
-                        target = it
-                    }
+                    pingStates.values
+                        .firstOrNull { !it.isReachable }
+                        ?.pingTarget
+                        ?.let { target = it }
                     consecutive++
                 } else {
                     consecutive = 0
@@ -326,7 +346,8 @@ class HandshakeRestartHandler(
         isRestartOnHandshakeTimeoutEnabled && isPingEnabled
 
     private fun computeCooldown(baseSec: Int, attempt: Int, isBackoff: Boolean): Long =
-        if (isBackoff) baseSec.toLong() * (1L shl (attempt - 1).coerceAtMost(MAX_BACKOFF_SHIFT)) else baseSec.toLong()
+        if (isBackoff) baseSec.toLong() * (1L shl (attempt - 1).coerceAtMost(MAX_BACKOFF_SHIFT))
+        else baseSec.toLong()
 
     companion object {
         private const val TUNNEL_UP_TIMEOUT_MS = 30_000L

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/tunnel/handler/TunnelMonitoringHandler.kt

@@ -325,9 +325,10 @@ class TunnelMonitorHandler(
 
                 while (isActive) {
                     ensureActive()
-                    val activeRestart = restartProgress.value[tunnelConfig.id]?.let {
-                        it.isRestarting || it.isVerifying
-                    } ?: false
+                    val activeRestart =
+                        restartProgress.value[tunnelConfig.id]?.let {
+                            it.isRestarting || it.isVerifying
+                        } ?: false
                     if (!powerManager.isDeviceIdleMode && !activeRestart) {
                         if (isNetworkConnected.value) {
                             performPing()

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/AppDatabase.kt

@@ -138,7 +138,11 @@ class DonationMigration : AutoMigrationSpec
 @DeleteColumn(tableName = "monitoring_settings", columnName = "backoff_max_attempts")
 class DropBackoffMaxAttemptsMigration : AutoMigrationSpec
 
-@RenameColumn(tableName = "monitoring_settings", fromColumnName = "max_handshake_restart_attempts", toColumnName = "max_restart_attempts")
+@RenameColumn(
+    tableName = "monitoring_settings",
+    fromColumnName = "max_handshake_restart_attempts",
+    toColumnName = "max_restart_attempts",
+)
 class RenameMaxRestartAttemptsMigration : AutoMigrationSpec
 
 @DeleteColumn(tableName = "monitoring_settings", columnName = "startup_grace_seconds")

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/DatabaseConverters.kt

@@ -66,7 +66,8 @@ class DatabaseConverters {
 
     @TypeConverter fun fromDnsProtocol(mode: DnsProtocol): Int = mode.value
 
-    @TypeConverter fun toMaxAttemptsAction(value: Int): MaxAttemptsAction = MaxAttemptsAction.fromValue(value)
+    @TypeConverter
+    fun toMaxAttemptsAction(value: Int): MaxAttemptsAction = MaxAttemptsAction.fromValue(value)
 
     @TypeConverter fun fromMaxAttemptsAction(action: MaxAttemptsAction): Int = action.value
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/entity/MonitoringSettings.kt

@@ -21,8 +21,7 @@ data class MonitoringSettings(
     val isLocalLogsEnabled: Boolean = false,
     @ColumnInfo(name = "is_restart_on_handshake_timeout_enabled", defaultValue = "0")
     val isRestartOnHandshakeTimeoutEnabled: Boolean = false,
-    @ColumnInfo(name = "max_restart_attempts", defaultValue = "5")
-    val maxRestartAttempts: Int = 5,
+    @ColumnInfo(name = "max_restart_attempts", defaultValue = "5") val maxRestartAttempts: Int = 5,
     @ColumnInfo(name = "restart_cooldown_seconds", defaultValue = "30")
     val restartCooldownSeconds: Int = 30,
     @ColumnInfo(name = "max_attempts_action", defaultValue = "0")

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/model/MaxAttemptsAction.kt

@@ -5,6 +5,7 @@ enum class MaxAttemptsAction(val value: Int) {
     STOP_TUNNEL(1);
 
     companion object {
-        fun fromValue(value: Int): MaxAttemptsAction = entries.find { it.value == value } ?: DO_NOTHING
+        fun fromValue(value: Int): MaxAttemptsAction =
+            entries.find { it.value == value } ?: DO_NOTHING
     }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/events/BackendMessage.kt

@@ -5,30 +5,50 @@ import com.zaneschepke.wireguardautotunnel.util.StringValue
 
 sealed class BackendMessage {
 
-    enum class RestartReason { PING_FAILURE }
+    enum class RestartReason {
+        PING_FAILURE
+    }
 
     data object DynamicDnsSuccess : BackendMessage()
 
-    data class ConnectionDegrading(val reason: RestartReason, val attempt: Int, val maxAttempts: Int) : BackendMessage()
+    data class ConnectionDegrading(
+        val reason: RestartReason,
+        val attempt: Int,
+        val maxAttempts: Int,
+    ) : BackendMessage()
 
     data object ConnectionRestored : BackendMessage()
 
-    data class ConnectionPermanentlyLost(val reason: RestartReason, val totalAttempts: Int, val isTunnelStopped: Boolean = false) : BackendMessage()
+    data class ConnectionPermanentlyLost(
+        val reason: RestartReason,
+        val totalAttempts: Int,
+        val isTunnelStopped: Boolean = false,
+    ) : BackendMessage()
 
     data object ConnectionCancelled : BackendMessage()
 
     fun toStringValue(): StringValue? =
         when (this) {
             DynamicDnsSuccess -> StringValue.StringResource(R.string.ddns_success_message)
-            is ConnectionDegrading -> StringValue.StringResource(
-                R.string.snackbar_connection_degrading, attempt.toString(), maxAttempts.toString(),
-            )
+            is ConnectionDegrading ->
+                StringValue.StringResource(
+                    R.string.snackbar_connection_degrading,
+                    attempt.toString(),
+                    maxAttempts.toString(),
+                )
             ConnectionRestored -> StringValue.StringResource(R.string.snackbar_connection_restored)
-            is ConnectionPermanentlyLost -> if (isTunnelStopped) {
-                StringValue.StringResource(R.string.snackbar_connection_lost_stopped, totalAttempts.toString())
-            } else {
-                StringValue.StringResource(R.string.snackbar_connection_lost, totalAttempts.toString())
-            }
+            is ConnectionPermanentlyLost ->
+                if (isTunnelStopped) {
+                    StringValue.StringResource(
+                        R.string.snackbar_connection_lost_stopped,
+                        totalAttempts.toString(),
+                    )
+                } else {
+                    StringValue.StringResource(
+                        R.string.snackbar_connection_lost,
+                        totalAttempts.toString(),
+                    )
+                }
             ConnectionCancelled -> null
         }
 }