Service builder

    class SecureVpnServiceBuilder {
        val upstreamDnsServers = mutableListOf<InetAddress>()

        fun configure(
            context: Context,
            builder: Builder,
        ): VpnService.Builder {
            log("Configuring secure service")
            val dnsServers = getDnsServers(context)
            log("Received dns servers: $dnsServers")

            var format: String = EmptyString

            for (prefix in TEST_NET_PREFIX_LIST) {
                try {
                    builder.addAddress(prefix + TEST_NET_POSTFIX, TEST_NET_PREFIX_LENGTH)
                } catch (e: IllegalArgumentException) {
                    continue
                }
                format = "$prefix.%d"
                break
            }

            if (format.isEmpty()) {
                log("Cannot use test prefixes, using DNS servers")
                builder.addAddress(DEFAULT_ADDRESS, DEFAULT_PREFIX_LENGTH)
            }

            upstreamDnsServers.clear()

            CLOUDFLARE_DNS.forEach { addrString ->
                val address = InetAddress.getByName(addrString)
                upstreamDnsServers.add(address)
                address.hostAddress?.let { builder.addRoute(it, 32) }
                builder.addDnsServer(address)
            }

            builder.setBlocking(true)
            builder.allowBypass()

            builder.allowFamily(OsConstants.AF_INET)
            builder.allowFamily(OsConstants.AF_INET6)

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) builder.setMetered(false)

            builder.addRoute("0.0.0.0", 0) // catch all ipv4
            builder.addRoute("::", 0) // catch all ipv6
            return builder
        }

        private fun getDnsServers(context: Context): List<InetAddress> {
            val result = hashSetOf<InetAddress>()
            val connectivityManager = context.getSystemService(VpnService.CONNECTIVITY_SERVICE) as ConnectivityManager
            val activeInfo = connectivityManager.activeNetworkInfo ?: return listOf()

            for (network in connectivityManager.allNetworks) {
                val networkInfo = connectivityManager.getNetworkInfo(network)
                networkInfo?.let {
                    if (networkInfo.isConnected && networkInfo.type == activeInfo.type && networkInfo.subtype == activeInfo.subtype) {
                        for (address in connectivityManager.getLinkProperties(network)?.dnsServers ?: listOf()) {
                            result.add(address)
                        }
                    }
                }
            }

            return result.toList()
        }

        private fun log(text: String) {
            Timber.i("$TAG$text")
        }

        private companion object {
            const val TAG = "SecureBuilder:: "
            val TEST_NET_PREFIX_LIST =
                listOf(
                    "192.0.2", // TEST-NET-1
                    "198.51.100", // TEST-NET-2
                    "203.0.113", // TEST-NET-3
                )
            const val TEST_NET_POSTFIX = ".1"
            const val TEST_NET_PREFIX_LENGTH = 24

            const val DEFAULT_ADDRESS = "192.168.50.1"
            const val DEFAULT_PREFIX_LENGTH = 24

            val CLOUDFLARE_DNS = listOf("1.1.1.1", "1.0.0.1")
        }
    }