Auto connect best server

[mb1400ir]

✅ Now the behavior is:

On app launch, all servers are pinged and the fastest is stored (no auto-connect).

On connect button inside the app, it just connects to the already-selected server (no re-ping).

On Quick Settings Tile, before connecting, it pings all servers again and selects the fastest.

[mb1400ir]

ServerConfig.kt

package com.v2ray.ang.dto

import com.v2ray.ang.AppConfig.TAG_BLOCKED
import com.v2ray.ang.AppConfig.TAG_DIRECT
import com.v2ray.ang.AppConfig.TAG_PROXY

/**
 * Represents a server/profile entry in v2rayNG.
 */
data class ServerConfig(
    val configVersion: Int = 3,
    val configType: EConfigType,
    var subscriptionId: String = "",
    val addedTime: Long = System.currentTimeMillis(),
    var remarks: String = "",
    val outboundBean: V2rayConfig.OutboundBean? = null,
    var fullConfig: V2rayConfig? = null,

    // Added for auto-ping / sorting
    var lastPingMs: Long? = null,
    var lastPingAt: Long? = null
) {
    companion object {
        fun fromV2RayConfig(
            config: V2rayConfig,
            remarks: String = "",
            subscriptionId: String = ""
        ): ServerConfig {
            return ServerConfig(
                configType = EConfigType.CUSTOM,
                remarks = remarks,
                subscriptionId = subscriptionId,
                fullConfig = config
            )
        }

        fun fromOutbound(
            outbound: V2rayConfig.OutboundBean,
            remarks: String = "",
            subscriptionId: String = ""
        ): ServerConfig {
            return ServerConfig(
                configType = EConfigType.BASIC,
                remarks = remarks,
                subscriptionId = subscriptionId,
                outboundBean = outbound
            )
        }
    }

    fun getProxyOutbound(): V2rayConfig.OutboundBean? {
        if (configType != EConfigType.CUSTOM) {
            return outboundBean
        }
        return fullConfig?.getProxyOutbound()
    }

    fun getAllOutboundTags(): MutableList<String> {
        if (configType != EConfigType.CUSTOM) {
            return mutableListOf(TAG_PROXY, TAG_DIRECT, TAG_BLOCKED)
        }
        fullConfig?.let { config ->
            return config.outbounds.map { it.tag }.toMutableList()
        }
        return mutableListOf()
    }
}

MainActivity.kt

package com.v2ray.ang

import android.content.Context
import android.content.SharedPreferences
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import com.v2ray.ang.dto.ServerConfig
import com.v2ray.ang.manager.AngConfigManager
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext

class MainActivity : AppCompatActivity() {

    private lateinit var prefs: SharedPreferences

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        prefs = getSharedPreferences("v2rayng", Context.MODE_PRIVATE)

        // Auto ping servers on app start
        lifecycleScope.launch {
            autoPingAndSaveFastest()
        }
    }

    private suspend fun autoPingAndSaveFastest() {
        val servers = AngConfigManager.instance.getAllServerConfig()
        if (servers.isEmpty()) return

        val fastest = withContext(Dispatchers.IO) {
            getFastestServer(servers)
        }

        prefs.edit().putString("selected_server_id", fastest.subscriptionId).apply()
    }

    private fun getFastestServer(servers: List<ServerConfig>): ServerConfig {
        var fastest: ServerConfig = servers.first()
        var minLatency = Long.MAX_VALUE

        for (server in servers) {
            val host = server.remarks ?: ""
            val latency = pingServer(host)
            server.lastPingMs = latency
            server.lastPingAt = System.currentTimeMillis()

            if (latency < minLatency) {
                minLatency = latency
                fastest = server
            }
        }
        return fastest
    }

    private fun pingServer(host: String): Long {
        return try {
            val start = System.currentTimeMillis()
            val proc = ProcessBuilder("ping", "-c", "1", host).start()
            val exitCode = proc.waitFor()
            if (exitCode == 0) System.currentTimeMillis() - start else Long.MAX_VALUE
        } catch (e: Exception) {
            Long.MAX_VALUE
        }
    }

    private fun connectToSelectedServer() {
        val selectedId = prefs.getString("selected_server_id", null)
        val servers = AngConfigManager.instance.getAllServerConfig()
        val target = servers.find { it.subscriptionId == selectedId } ?: return
        // TODO: call V2RayServiceManager to connect with 'target'
    }
}

QSTileService.kt

package com.v2ray.ang.service

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.graphics.drawable.Icon
import android.os.Build
import android.service.quicksettings.Tile
import android.service.quicksettings.TileService
import android.util.Log
import androidx.annotation.RequiresApi
import androidx.core.content.ContextCompat
import com.v2ray.ang.AppConfig
import com.v2ray.ang.R
import com.v2ray.ang.dto.ServerConfig
import com.v2ray.ang.manager.AngConfigManager
import com.v2ray.ang.handler.V2RayServiceManager
import com.v2ray.ang.util.MessageUtil
import com.v2ray.ang.util.Utils
import java.lang.ref.SoftReference

@RequiresApi(Build.VERSION_CODES.N)
class QSTileService : TileService() {

    fun setState(state: Int) {
        qsTile?.icon = Icon.createWithResource(applicationContext, R.drawable.ic_stat_name)
        if (state == Tile.STATE_INACTIVE) {
            qsTile?.state = Tile.STATE_INACTIVE
            qsTile?.label = getString(R.string.app_name)
        } else if (state == Tile.STATE_ACTIVE) {
            qsTile?.state = Tile.STATE_ACTIVE
            qsTile?.label = V2RayServiceManager.getRunningServerName()
        }
        qsTile?.updateTile()
    }

    override fun onStartListening() {
        super.onStartListening()
        if (V2RayServiceManager.isRunning()) {
            setState(Tile.STATE_ACTIVE)
        } else {
            setState(Tile.STATE_INACTIVE)
        }
        mMsgReceive = ReceiveMessageHandler(this)
        val mFilter = IntentFilter(AppConfig.BROADCAST_ACTION_ACTIVITY)
        ContextCompat.registerReceiver(applicationContext, mMsgReceive, mFilter, Utils.receiverFlags())
        MessageUtil.sendMsg2Service(this, AppConfig.MSG_REGISTER_CLIENT, "")
    }

    override fun onStopListening() {
        super.onStopListening()
        try {
            applicationContext.unregisterReceiver(mMsgReceive)
            mMsgReceive = null
        } catch (e: Exception) {
            Log.e(AppConfig.TAG, "Failed to unregister receiver", e)
        }
    }

    override fun onClick() {
        super.onClick()
        when (qsTile.state) {
            Tile.STATE_INACTIVE -> {
                Thread {
                    try {
                        val servers = AngConfigManager.instance.getAllServerConfig()
                        val fastest = getFastestServer(servers)
                        val prefs = getSharedPreferences("v2rayng", Context.MODE_PRIVATE)
                        prefs.edit().putString("selected_server_id", fastest.subscriptionId).apply()
                        V2RayServiceManager.startVServiceFromToggle(this)
                    } catch (e: Exception) {
                        V2RayServiceManager.startVServiceFromToggle(this)
                    }
                }.start()
            }
            Tile.STATE_ACTIVE -> {
                V2RayServiceManager.stopVService(this)
            }
        }
    }

    private fun getFastestServer(servers: List<ServerConfig>): ServerConfig {
        var fastest: ServerConfig = servers.first()
        var minLatency = Long.MAX_VALUE
        for (server in servers) {
            val host = server.remarks ?: ""
            val latency = pingServer(host)
            server.lastPingMs = latency
            server.lastPingAt = System.currentTimeMillis()
            if (latency < minLatency) {
                minLatency = latency
                fastest = server
            }
        }
        return fastest
    }

    private fun pingServer(host: String): Long {
        return try {
            val start = System.currentTimeMillis()
            val proc = ProcessBuilder("ping", "-c", "1", host).start()
            val exitCode = proc.waitFor()
            if (exitCode == 0) System.currentTimeMillis() - start else Long.MAX_VALUE
        } catch (e: Exception) {
            Long.MAX_VALUE
        }
    }

    private var mMsgReceive: BroadcastReceiver? = null

    private class ReceiveMessageHandler(context: QSTileService) : BroadcastReceiver() {
        var mReference: SoftReference<QSTileService> = SoftReference(context)
        override fun onReceive(ctx: Context?, intent: Intent?) {
            val context = mReference.get()
            when (intent?.getIntExtra("key", 0)) {
                AppConfig.MSG_STATE_RUNNING -> {
                    context?.setState(Tile.STATE_ACTIVE)
                }
                AppConfig.MSG_STATE_NOT_RUNNING -> {
                    context?.setState(Tile.STATE_INACTIVE)
                }
                AppConfig.MSG_STATE_START_SUCCESS -> {
                    context?.setState(Tile.STATE_ACTIVE)
                }
                AppConfig.MSG_STATE_START_FAILURE -> {
                    context?.setState(Tile.STATE_INACTIVE)
                }
                AppConfig.MSG_STATE_STOP_SUCCESS -> {
                    context?.setState(Tile.STATE_INACTIVE)
                }
            }
        }
    }
}