管理端全部功能跑通

EdgeHttpDNS/sdk/flutter/aliyun_httpdns/README.md

@@ -1,532 +1,73 @@
-# Aliyun HTTPDNS Flutter Plugin
+# HTTPDNS Flutter SDK (SNI Hidden v1.0.0)
 
-阿里云EMAS HTTPDNS Flutter插件，提供基于原生SDK的域名解析能力。
-
-一、快速入门 
------------------------
-
-### 1.1 开通服务 
-
-请参考[快速入门文档](https://help.aliyun.com/document_detail/2867674.html)开通HTTPDNS。
-
-### 1.2 获取配置 
-
-请参考开发配置文档在EMAS控制台开发配置中获取AccountId/SecretKey/AESSecretKey等信息，用于初始化SDK。
-
-## 二、安装
-
-在`pubspec.yaml`中加入dependencies：
-```yaml
-dependencies:
-  aliyun_httpdns: ^1.0.1
-```
-添加依赖之后需要执行一次 `flutter pub get`。
-
-### 原生SDK版本说明
-
-插件已集成了对应平台的HTTPDNS原生SDK，当前版本：
-
-- **Android**: `com.aliyun.ams:alicloud-android-httpdns:2.6.7`
-- **iOS**: `AlicloudHTTPDNS:3.3.0`
-
-
-
-三、配置和使用 
-------------------------
-
-### 3.1 初始化配置 
-
-应用启动后，需要先初始化插件，才能调用HTTPDNS能力。
-初始化主要是配置AccountId/SecretKey等信息及功能开关。
-示例代码如下：
+## 1. Initialization
 
 ```dart
-// 初始化 HTTPDNS
-await AliyunHttpdns.init(
-  accountId: '您的AccountId',
-  secretKey: '您的SecretKey',
-);
-
-// 设置功能选项
-await AliyunHttpdns.setHttpsRequestEnabled(true);
-await AliyunHttpdns.setLogEnabled(true);
-await AliyunHttpdns.setPersistentCacheIPEnabled(true);
-await AliyunHttpdns.setReuseExpiredIPEnabled(true);
-
-// 构建服务
-await AliyunHttpdns.build();
-
-// 设置预解析域名
-await AliyunHttpdns.setPreResolveHosts(['www.aliyun.com'], ipType: 'both');
-print("init success");
-```
-
-
-
-#### 3.1.1 日志配置 
-
-应用开发过程中，如果要输出HTTPDNS的日志，可以调用日志输出控制方法，开启日志，示例代码如下：
-
-```dart
-await AliyunHttpdns.setLogEnabled(true);
-print("enableLog success");
-```
-
-
-
-#### 3.1.2 sessionId记录 
-
-应用在运行过程中，可以调用获取SessionId方法获取sessionId，记录到应用的数据采集系统中。
-sessionId用于表示标识一次应用运行，线上排查时，可以用于查询应用一次运行过程中的解析日志，示例代码如下：
-
-```dart
-final sessionId = await AliyunHttpdns.getSessionId();
-print("SessionId = $sessionId");
-```
-
-
-
-### 3.2 域名解析 
-
-#### 3.2.1 预解析 
-
-当需要提前解析域名时，可以调用预解析域名方法，示例代码如下：
-
-```dart
-await AliyunHttpdns.setPreResolveHosts(["www.aliyun.com", "www.example.com"], ipType: 'both');
-print("preResolveHosts success");
-```
-
-
-
-调用之后，插件会发起域名解析，并把结果缓存到内存，用于后续请求时直接使用。
-
-### 3.2.2 域名解析 
-
-当需要解析域名时，可以通过调用域名解析方法解析域名获取IP，示例代码如下：
-
-```dart
-Future<void> _resolve() async {
-  final res = await AliyunHttpdns.resolveHostSyncNonBlocking('www.aliyun.com', ipType: 'both');
-  final ipv4List = res['ipv4'] ?? [];
-  final ipv6List = res['ipv6'] ?? [];
-  print('IPv4: $ipv4List');
-  print('IPv6: $ipv6List');
-}
-```
-
-
-
-四、Flutter最佳实践 
-------------------------------
-
-### 4.1 原理说明 
-
-本示例展示了一种更直接的集成方式，通过自定义HTTP客户端适配器来实现HTTPDNS集成：
-
-1. 创建自定义的HTTP客户端适配器，拦截网络请求
-2. 在适配器中调用HTTPDNS插件解析域名为IP地址
-3. 使用解析得到的IP地址创建直接的Socket连接
-4. 对于HTTPS连接，确保正确设置SNI（Server Name Indication）为原始域名
-
-这种方式避免了创建本地代理服务的复杂性，直接在HTTP客户端层面集成HTTPDNS功能。
-
-### 4.2 示例说明 
-
-完整应用示例请参考插件包中example应用。
-
-#### 4.2.1 自定义HTTP客户端适配器实现 
-
-自定义适配器的实现请参考插件包中example/lib/net/httpdns_http_client_adapter.dart文件。本方案由EMAS团队设计实现，参考请注明出处。
-适配器内部会拦截HTTP请求，调用HTTPDNS进行域名解析，并使用解析后的IP创建socket连接。
-
-本示例支持三种网络库：Dio、HttpClient、http包。代码如下：
-
-```dart
-import 'dart:io';
-import 'package:dio/io.dart';
-import 'package:http/http.dart' as http;
-import 'package:http/io_client.dart';
-import 'package:flutter/foundation.dart';
 import 'package:aliyun_httpdns/aliyun_httpdns.dart';
 
-// Dio 适配器
-IOHttpClientAdapter buildHttpdnsHttpClientAdapter() {
-  final HttpClient client = HttpClient();
-  _configureHttpClient(client);
-  _configureConnectionFactory(client);
-
-  final IOHttpClientAdapter adapter = IOHttpClientAdapter(createHttpClient: () => client)
-    ..validateCertificate = (cert, host, port) => true;
-  return adapter;
-}
-
-// 原生 HttpClient
-HttpClient buildHttpdnsNativeHttpClient() {
-  final HttpClient client = HttpClient();
-  _configureHttpClient(client);
-  _configureConnectionFactory(client);
-  return client;
-}
-
-// http 包适配器
-http.Client buildHttpdnsHttpPackageClient() {
-  final HttpClient httpClient = buildHttpdnsNativeHttpClient();
-  return IOClient(httpClient);
-}
-
-// HttpClient 基础配置
-void _configureHttpClient(HttpClient client) {
-  client.findProxy = (Uri _) => 'DIRECT';
-  client.idleTimeout = const Duration(seconds: 90);
-  client.maxConnectionsPerHost = 8;
-}
-
-// 配置基于 HTTPDNS 的连接工厂
-// 本方案由EMAS团队设计实现，参考请注明出处。
-void _configureConnectionFactory(HttpClient client) {
-  client.connectionFactory = (Uri uri, String? proxyHost, int? proxyPort) async {
-    final String domain = uri.host;
-    final bool https = uri.scheme.toLowerCase() == 'https';
-    final int port = uri.port == 0 ? (https ? 443 : 80) : uri.port;
-
-    final List<InternetAddress> targets = await _resolveTargets(domain);
-    final Object target = targets.isNotEmpty ? targets.first : domain;
-
-    if (!https) {
-      return Socket.startConnect(target, port);
-    }
-
-    // HTTPS：先 TCP，再 TLS（SNI=域名），并保持可取消
-    bool cancelled = false;
-    final Future<ConnectionTask<Socket>> rawStart = Socket.startConnect(target, port);
-    final Future<Socket> upgraded = rawStart.then((task) async {
-      final Socket raw = await task.socket;
-      if (cancelled) {
-        raw.destroy();
-        throw const SocketException('Connection cancelled');
-      }
-      final SecureSocket secure = await SecureSocket.secure(
-        raw,
-        host: domain, // 重要：使用原始域名作为SNI
-      );
-      if (cancelled) {
-        secure.destroy();
-        throw const SocketException('Connection cancelled');
-      }
-      return secure;
-    });
-    return ConnectionTask.fromSocket(
-      upgraded,
-      () {
-        cancelled = true;
-        try {
-          rawStart.then((t) => t.cancel());
-        } catch (_) {}
-      },
-    );
-  };
-}
-
-// 通过 HTTPDNS 解析目标 IP 列表
-Future<List<InternetAddress>> _resolveTargets(String domain) async {
-  try {
-    final res = await AliyunHttpdns.resolveHostSyncNonBlocking(domain, ipType: 'both');
-    final List<String> ipv4 = res['ipv4'] ?? [];
-    final List<String> ipv6 = res['ipv6'] ?? [];
-    final List<InternetAddress> targets = [
-      ...ipv4.map(InternetAddress.tryParse).whereType<InternetAddress>(),
-      ...ipv6.map(InternetAddress.tryParse).whereType<InternetAddress>(),
-    ];
-    if (targets.isEmpty) {
-      debugPrint('[dio] HTTPDNS no result for $domain, fallback to system DNS');
-    } else {
-      debugPrint('[dio] HTTPDNS resolved $domain -> ${targets.first.address}');
-    }
-    return targets;
-  } catch (e) {
-    debugPrint('[dio] HTTPDNS resolve failed: $e, fallback to system DNS');
-    return const <InternetAddress>[];
-  }
-}
-```
-
-
-
-#### 4.2.2 适配器集成和使用 
-
-适配器的集成请参考插件包中example/lib/main.dart文件。
-首先需要初始化HTTPDNS，然后配置网络库使用自定义适配器，示例代码如下：
-
-```dart
-class _MyHomePageState extends State<MyHomePage> {
-  late final Dio _dio;
-  late final HttpClient _httpClient;
-  late final http.Client _httpPackageClient;
-
-  @override
-  void initState() {
-    super.initState();
-    
-    // 初始化 HTTPDNS
-    _initHttpDnsOnce();
-    
-    // 配置网络库使用 HTTPDNS 适配器
-    _dio = Dio();
-    _dio.httpClientAdapter = buildHttpdnsHttpClientAdapter();
-    _dio.options.headers['Connection'] = 'keep-alive';
-    
-    _httpClient = buildHttpdnsNativeHttpClient();
-    _httpPackageClient = buildHttpdnsHttpPackageClient();
-  }
-
-  Future<void> _initHttpDnsOnce() async {
-    try {
-      await AliyunHttpdns.init(
-        accountId: 000000,
-        secretKey: '您的SecretKey',
-      );
-      await AliyunHttpdns.setHttpsRequestEnabled(true);
-      await AliyunHttpdns.setLogEnabled(true);
-      await AliyunHttpdns.setPersistentCacheIPEnabled(true);
-      await AliyunHttpdns.setReuseExpiredIPEnabled(true);
-      await AliyunHttpdns.build();
-      
-      // 设置预解析域名
-      await AliyunHttpdns.setPreResolveHosts(['www.aliyun.com'], ipType: 'both');
-    } catch (e) {
-      debugPrint('[httpdns] init failed: $e');
-    }
-  }
-}
-```
-
-
-
-使用配置好的网络库发起请求时，会自动使用HTTPDNS进行域名解析：
-
-```dart
-// 使用 Dio
-final response = await _dio.get('https://www.aliyun.com');
-
-// 使用 HttpClient
-final request = await _httpClient.getUrl(Uri.parse('https://www.aliyun.com'));
-final response = await request.close();
-
-// 使用 http 包
-final response = await _httpPackageClient.get(Uri.parse('https://www.aliyun.com'));
-```
-
-#### 4.2.3 资源清理 
-
-在组件销毁时，记得清理相关资源：
-
-```dart
-@override
-void dispose() {
-  _urlController.dispose();
-  _httpClient.close();
-  _httpPackageClient.close();
-  super.dispose();
-}
-```
-
-
-
-五、API 
-----------------------
-
-### 5.1 日志输出控制 
-
-控制是否打印Log。
-
-```dart
-await AliyunHttpdns.setLogEnabled(true);
-print("enableLog success");
-```
-
-
-
-### 5.2 初始化 
-
-初始化配置, 在应用启动时调用。
-
-```dart
-// 基础初始化
 await AliyunHttpdns.init(
-  accountId: 000000,
-  secretKey: 'your_secret_key',
-  aesSecretKey: 'your_aes_secret_key', // 可选
+  appId: 'app1f1ndpo9',
+  primaryServiceHost: 'httpdns-a.example.com',
+  backupServiceHost: 'httpdns-b.example.com', // optional
+  servicePort: 443,
+  secretKey: 'your-sign-secret', // optional if sign is enabled
 );
 
-// 配置功能选项
 await AliyunHttpdns.setHttpsRequestEnabled(true);
-await AliyunHttpdns.setLogEnabled(true);
-await AliyunHttpdns.setPersistentCacheIPEnabled(true);
-await AliyunHttpdns.setReuseExpiredIPEnabled(true);
-
-// 构建服务实例
 await AliyunHttpdns.build();
-
-print("init success");
 ```
 
-
-
-初始化参数:
-
-| 参数名          | 类型     | 是否必须 | 功能         | 支持平台        |
-|-------------|--------|------|------------|-------------|
-| accountId   | int    | 必选参数 | Account ID | Android/iOS |
-| secretKey   | String | 可选参数 | 加签密钥       | Android/iOS |
-| aesSecretKey| String | 可选参数 | 加密密钥       | Android/iOS |
-
-功能配置方法:
-
-- `setHttpsRequestEnabled(bool)` - 设置是否使用HTTPS解析链路
-- `setLogEnabled(bool)` - 设置是否开启日志
-- `setPersistentCacheIPEnabled(bool)` - 设置是否开启持久化缓存
-- `setReuseExpiredIPEnabled(bool)` - 设置是否允许复用过期IP
-- `setPreResolveAfterNetworkChanged(bool)` - 设置网络切换时是否自动刷新解析
-
-
-
-### 5.3 域名解析 
-
-解析指定域名。
+## 2. Resolve
 
 ```dart
-Future<void> _resolve() async {
-  final res = await AliyunHttpdns.resolveHostSyncNonBlocking(
-    'www.aliyun.com', 
-    ipType: 'both',  // 'auto', 'ipv4', 'ipv6', 'both'
-  );
-  
-  final ipv4List = res['ipv4'] ?? [];
-  final ipv6List = res['ipv6'] ?? [];
-  print('IPv4: $ipv4List');
-  print('IPv6: $ipv6List');
-}
-```
-
-
-
-参数:
-
-| 参数名        | 类型                  | 是否必须 | 功能                                      |
-|------------|---------------------|------|----------------------------------------|
-| hostname   | String              | 必选参数 | 要解析的域名                                 |
-| ipType     | String              | 可选参数 | 请求IP类型: 'auto', 'ipv4', 'ipv6', 'both' |
-
-
-
-返回数据结构:
-
-| 字段名  | 类型           | 功能                               |
-|------|--------------|----------------------------------|
-| ipv4 | List<String> | IPv4地址列表，如: ["1.1.1.1", "2.2.2.2"] |
-| ipv6 | List<String> | IPv6地址列表，如: ["::1", "::2"]         |
-
-
-
-### 5.4 预解析域名 
-
-预解析域名, 解析后缓存在SDK中,下次解析时直接从缓存中获取,提高解析速度。
-
-```dart
-await AliyunHttpdns.setPreResolveHosts(
-  ["www.aliyun.com", "www.example.com"], 
-  ipType: 'both'
+final result = await AliyunHttpdns.resolveHostSyncNonBlocking(
+  'api.business.com',
+  ipType: 'both',
 );
-print("preResolveHosts success");
+
+final ipv4 = result['ipv4'] ?? <String>[];
+final ipv6 = result['ipv6'] ?? <String>[];
 ```
 
-
-
-参数:
-
-| 参数名    | 类型           | 是否必须 | 功能                                      |
-|--------|--------------|------|----------------------------------------|
-| hosts  | List<String> | 必选参数 | 预解析域名列表                                |
-| ipType | String       | 可选参数 | 请求IP类型: 'auto', 'ipv4', 'ipv6', 'both' |
-
-
-
-### 5.5 获取SessionId 
-
-获取SessionId, 用于排查追踪问题。
+## 3. Official HTTP Adapter (IP + Host)
 
 ```dart
-final sessionId = await AliyunHttpdns.getSessionId();
-print("SessionId = $sessionId");
-```
-
-
-
-无需参数，直接返回当前会话ID。
-
-### 5.6 清除缓存 
-
-清除所有DNS解析缓存。
-
-```dart
-await AliyunHttpdns.cleanAllHostCache();
-print("缓存清除成功");
-```
-
-### 5.7 持久化缓存配置 
-
-设置是否开启持久化缓存功能。开启后，SDK 会将解析结果保存到本地，App 重启后可以从本地加载缓存，提升首屏加载速度。
-
-```dart
-// 基础用法：开启持久化缓存
-await AliyunHttpdns.setPersistentCacheIPEnabled(true);
-
-// 高级用法：开启持久化缓存并设置过期时间阈值
-await AliyunHttpdns.setPersistentCacheIPEnabled(
-  true, 
-  discardExpiredAfterSeconds: 86400  // 1天，单位：秒
+final adapter = AliyunHttpdns.createHttpAdapter(
+  options: const AliyunHttpdnsAdapterOptions(
+    ipType: 'auto',
+    connectTimeoutMs: 3000,
+    readTimeoutMs: 5000,
+    allowInsecureCertificatesForDebugOnly: false,
+  ),
 );
-print("持久化缓存已开启");
+
+final resp = await adapter.request(
+  Uri.parse('https://api.business.com/v1/ping'),
+  method: 'GET',
+  headers: {'Accept': 'application/json'},
+);
+
+print(resp.statusCode);
+print(resp.usedIp);
 ```
 
-参数:
+Behavior is fixed:
+- Resolve host by `/resolve`.
+- Connect to resolved IP over HTTPS.
+- Keep `Host` header as the real business domain.
+- No fallback to domain direct request.
 
-| 参数名                        | 类型   | 是否必须 | 功能                                      |
-|----------------------------|------|------|------------------------------------------|
-| enabled                    | bool | 必选参数 | 是否开启持久化缓存                              |
-| discardExpiredAfterSeconds | int  | 可选参数 | 过期时间阈值（秒），App 启动时会丢弃过期超过此时长的缓存记录，建议设置为 1 天（86400 秒） |
-
-注意事项:
-- 持久化缓存仅影响第一次域名解析结果，后续解析仍会请求 HTTPDNS 服务器
-- 如果业务服务器 IP 变化频繁，建议谨慎开启此功能
-- 建议在 `build()` 之前调用此接口
-
-### 5.8 网络变化时自动刷新预解析 
-
-设置在网络环境变化时是否自动刷新预解析域名的缓存。
-
-```dart
-await AliyunHttpdns.setPreResolveAfterNetworkChanged(true);
-print("网络变化自动刷新已启用");
-```
-
-### 5.9 IP 优选 
-
-设置需要进行 IP 优选的域名列表。开启后，SDK 会对解析返回的 IP 列表进行 TCP 测速并排序，优先返回连接速度最快的 IP。
-
-```dart
-await AliyunHttpdns.setIPRankingList({
-  'www.aliyun.com': 443,
-});
-print("IP 优选配置成功");
-```
-
-参数:
-
-| 参数名         | 类型              | 是否必须 | 功能                          |
-|-------------|-----------------|------|------------------------------|
-| hostPortMap | Map<String, int> | 必选参数 | 域名和端口的映射，例如：{'www.aliyun.com': 443} |
+## 4. Public Errors
 
+- `NO_IP_AVAILABLE`
+- `TLS_EMPTY_SNI_FAILED`
+- `HOST_ROUTE_REJECTED`
+- `RESOLVE_SIGN_INVALID`
 
+## 5. Deprecated Params Removed
 
+The public init API no longer accepts:
+- `accountId`
+- `serviceDomain`
+- `endpoint`
+- `aesSecretKey`

EdgeHttpDNS/sdk/flutter/aliyun_httpdns/android/src/main/kotlin/com/aliyun/ams/httpdns/AliyunHttpDnsPlugin.kt

@@ -3,7 +3,6 @@ package com.aliyun.ams.httpdns
 import android.content.Context
 import android.util.Log
 import androidx.annotation.NonNull
-
 import com.alibaba.sdk.android.httpdns.HttpDns
 import com.alibaba.sdk.android.httpdns.HttpDnsService
 import com.alibaba.sdk.android.httpdns.InitConfig
@@ -15,18 +14,18 @@ import io.flutter.plugin.common.MethodChannel
 import io.flutter.plugin.common.MethodChannel.MethodCallHandler
 import io.flutter.plugin.common.MethodChannel.Result
 
-
 class AliyunHttpDnsPlugin : FlutterPlugin, MethodCallHandler {
     private lateinit var channel: MethodChannel
     private var appContext: Context? = null
 
-    // Cached service keyed by accountId to avoid re-creating
     private var service: HttpDnsService? = null
-    private var accountId: String? = null
-    private var secretKey: String? = null
-    private var aesSecretKey: String? = null
 
-    // Desired states collected before build()
+    private var appId: String? = null
+    private var secretKey: String? = null
+    private var primaryServiceHost: String? = null
+    private var backupServiceHost: String? = null
+    private var servicePort: Int? = null
+
     private var desiredPersistentCacheEnabled: Boolean? = null
     private var desiredDiscardExpiredAfterSeconds: Int? = null
     private var desiredReuseExpiredIPEnabled: Boolean? = null
@@ -35,10 +34,6 @@ class AliyunHttpDnsPlugin : FlutterPlugin, MethodCallHandler {
     private var desiredPreResolveAfterNetworkChanged: Boolean? = null
     private var desiredIPRankingMap: Map<String, Int>? = null
 
-
-
-
-
     override fun onAttachedToEngine(@NonNull flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
         appContext = flutterPluginBinding.applicationContext
         channel = MethodChannel(flutterPluginBinding.binaryMessenger, "aliyun_httpdns")
@@ -46,14 +41,7 @@ class AliyunHttpDnsPlugin : FlutterPlugin, MethodCallHandler {
     }
 
     override fun onMethodCall(@NonNull call: MethodCall, @NonNull result: Result) {
-        // Log every incoming call with method name and raw arguments
-        try {
-            Log.i("AliyunHttpDns", "invoke method=${call.method}, args=${call.arguments}")
-        } catch (_: Throwable) {
-            Log.i("AliyunHttpDns", "invoke method=${call.method}, args=<unprintable>")
-        }
         when (call.method) {
-            // Dart: init(accountId, secretKey?, aesSecretKey?) — only save states here
             "initialize" -> {
                 val args = call.arguments as? Map<*, *> ?: emptyMap<String, Any>()
                 val ctx = appContext
@@ -61,261 +49,315 @@ class AliyunHttpDnsPlugin : FlutterPlugin, MethodCallHandler {
                     result.error("no_context", "Android context not attached", null)
                     return
                 }
-                val accountAny = args["accountId"]
-                val account = when (accountAny) {
-                    is Int -> accountAny.toString()
-                    is Long -> accountAny.toString()
-                    is String -> accountAny
-                    else -> null
-                }
-                val secret = (args["secretKey"] as? String)?.takeIf { it.isNotBlank() }
-                val aes = (args["aesSecretKey"] as? String)?.takeIf { it.isNotBlank() }
 
-                if (account.isNullOrBlank()) {
-                    Log.i("AliyunHttpDns", "initialize missing accountId")
+                val appIdAny = args["appId"]
+                val parsedAppId = when (appIdAny) {
+                    is Int -> appIdAny.toString()
+                    is Long -> appIdAny.toString()
+                    is String -> appIdAny.trim()
+                    else -> ""
+                }
+                if (parsedAppId.isBlank()) {
+                    Log.i("AliyunHttpDns", "initialize missing appId")
                     result.success(false)
                     return
                 }
-                // Save desired states only; actual build happens on 'build'
-                accountId = account
+
+                val primaryHostArg = (args["primaryServiceHost"] as? String)?.trim()
+                if (primaryHostArg.isNullOrBlank()) {
+                    Log.i("AliyunHttpDns", "initialize missing primaryServiceHost")
+                    result.success(false)
+                    return
+                }
+
+                val secret = (args["secretKey"] as? String)?.takeIf { it.isNotBlank() }
+                val backup = (args["backupServiceHost"] as? String)?.trim()
+                val port = when (val portAny = args["servicePort"]) {
+                    is Int -> portAny
+                    is Long -> portAny.toInt()
+                    is String -> portAny.toIntOrNull()
+                    else -> null
+                }
+
+                appId = parsedAppId
                 secretKey = secret
-                aesSecretKey = aes
-                Log.i("AliyunHttpDns", "initialize saved state, account=$account")
+                primaryServiceHost = primaryHostArg
+                backupServiceHost = backup?.trim()?.takeIf { it.isNotEmpty() }
+                servicePort = if (port != null && port > 0) port else null
+
+                Log.i(
+                    "AliyunHttpDns",
+                    "initialize appId=$appId, primaryServiceHost=$primaryServiceHost, backupServiceHost=$backupServiceHost, servicePort=$servicePort"
+                )
                 result.success(true)
             }
 
-
-
-            // Dart: setLogEnabled(enabled) — save desired
             "setLogEnabled" -> {
                 val enabled = call.argument<Boolean>("enabled") == true
                 desiredLogEnabled = enabled
-                Log.i("AliyunHttpDns", "setLogEnabled desired=$enabled")
                 result.success(null)
             }
 
-            // Dart: setHttpsRequestEnabled(enabled)
             "setHttpsRequestEnabled" -> {
                 val enabled = call.argument<Boolean>("enabled") == true
                 desiredHttpsEnabled = enabled
-                Log.i("AliyunHttpDns", "https request desired=$enabled")
                 result.success(null)
             }
 
-            // Dart: setPersistentCacheIPEnabled(enabled, discardExpiredAfterSeconds?) — save desired
             "setPersistentCacheIPEnabled" -> {
                 val enabled = call.argument<Boolean>("enabled") == true
                 val discard = call.argument<Int>("discardExpiredAfterSeconds")
                 desiredPersistentCacheEnabled = enabled
                 desiredDiscardExpiredAfterSeconds = discard
-                Log.i("AliyunHttpDns", "persistent cache desired=$enabled discard=$discard")
                 result.success(null)
             }
 
-            // Dart: setReuseExpiredIPEnabled(enabled) — save desired
             "setReuseExpiredIPEnabled" -> {
                 val enabled = call.argument<Boolean>("enabled") == true
                 desiredReuseExpiredIPEnabled = enabled
-                Log.i("AliyunHttpDns", "reuse expired ip desired=$enabled")
                 result.success(null)
             }
 
-            // Dart: setPreResolveAfterNetworkChanged(enabled) — save desired (applied at build via InitConfig)
             "setPreResolveAfterNetworkChanged" -> {
                 val enabled = call.argument<Boolean>("enabled") == true
                 desiredPreResolveAfterNetworkChanged = enabled
-                Log.i("AliyunHttpDns", "preResolveAfterNetworkChanged desired=$enabled")
                 result.success(null)
             }
 
-            // Dart: setIPRankingList(hostPortMap) — save desired
             "setIPRankingList" -> {
                 val hostPortMap = call.argument<Map<String, Int>>("hostPortMap")
                 desiredIPRankingMap = hostPortMap
-                Log.i("AliyunHttpDns", "IP ranking list desired, hosts=${hostPortMap?.keys?.joinToString()}")
                 result.success(null)
             }
 
-            // Dart: setPreResolveHosts(hosts, ipType)
             "setPreResolveHosts" -> {
                 val hosts = call.argument<List<String>>("hosts") ?: emptyList()
-                val ipTypeStr = call.argument<String>("ipType") ?: "auto"
-                val type = when (ipTypeStr.lowercase()) {
-                    "ipv4", "v4" -> RequestIpType.v4
-                    "ipv6", "v6" -> RequestIpType.v6
-                    "both", "64" -> RequestIpType.both
-                    else -> RequestIpType.auto
-                }
+                val type = mapIpType(call.argument<String>("ipType") ?: "auto")
                 try {
                     service?.setPreResolveHosts(hosts, type)
-                    Log.i("AliyunHttpDns", "preResolve set for ${hosts.size} hosts, type=$type")
-                } catch (t: Throwable) {
-                    Log.i("AliyunHttpDns", "setPreResolveHosts failed: ${t.message}")
+                } catch (_: Throwable) {
                 }
                 result.success(null)
             }
 
-            // Dart: getSessionId
             "getSessionId" -> {
-                val sid = try { service?.getSessionId() } catch (_: Throwable) { null }
+                val sid = try {
+                    service?.getSessionId()
+                } catch (_: Throwable) {
+                    null
+                }
                 result.success(sid)
             }
 
-            // Dart: cleanAllHostCache
             "cleanAllHostCache" -> {
                 try {
-                    // Best-effort: empty list to clear all
                     service?.cleanHostCache(ArrayList())
-                } catch (t: Throwable) {
-                    Log.i("AliyunHttpDns", "cleanAllHostCache failed: ${t.message}")
+                } catch (_: Throwable) {
                 }
                 result.success(null)
             }
 
-            // Dart: build() — construct InitConfig and acquire service using desired states
             "build" -> {
                 val ctx = appContext
-                val account = accountId
-                if (ctx == null || account.isNullOrBlank()) {
+                val currentAppId = appId
+                if (ctx == null || currentAppId.isNullOrBlank()) {
                     result.success(false)
                     return
                 }
-                try {
-                    desiredLogEnabled?.let { enabled ->
-                        try {
-                            HttpDnsLog.enable(enabled)
-                            Log.i("AliyunHttpDns", "HttpDnsLog.enable($enabled)")
-                        } catch (t: Throwable) {
-                            Log.w("AliyunHttpDns", "HttpDnsLog.enable failed: ${t.message}")
-                        }
-                    }
-                    
-                    val builder = InitConfig.Builder()
 
-                    // Optional builder params
-                    try { builder.javaClass.getMethod("setContext", Context::class.java).invoke(builder, ctx) } catch (_: Throwable) {}
+                try {
+                    desiredLogEnabled?.let { HttpDnsLog.enable(it) }
+
+                    val builder = InitConfig.Builder()
+                    var hostConfigApplied = false
+                    try {
+                        builder.javaClass.getMethod("setContext", Context::class.java)
+                            .invoke(builder, ctx)
+                    } catch (_: Throwable) {
+                    }
                     try {
                         if (!secretKey.isNullOrBlank()) {
-                            builder.javaClass.getMethod("setSecretKey", String::class.java).invoke(builder, secretKey)
+                            builder.javaClass.getMethod("setSecretKey", String::class.java)
+                                .invoke(builder, secretKey)
                         }
-                    } catch (_: Throwable) {}
+                    } catch (_: Throwable) {
+                    }
                     try {
-                        if (!aesSecretKey.isNullOrBlank()) {
-                            builder.javaClass.getMethod("setAesSecretKey", String::class.java).invoke(builder, aesSecretKey)
-                        }
-                    } catch (_: Throwable) {}
-                    // Prefer HTTPS if requested
+                        val enableHttps = desiredHttpsEnabled ?: true
+                        builder.javaClass.getMethod("setEnableHttps", Boolean::class.javaPrimitiveType)
+                            .invoke(builder, enableHttps)
+                    } catch (_: Throwable) {
+                    }
+
                     try {
-                        desiredHttpsEnabled?.let { en ->
-                            builder.javaClass.getMethod("setEnableHttps", Boolean::class.javaPrimitiveType).invoke(builder, en)
+                        builder.javaClass.getMethod("setPrimaryServiceHost", String::class.java)
+                            .invoke(builder, primaryServiceHost)
+                        hostConfigApplied = true
+                    } catch (t: Throwable) {
+                        Log.w("AliyunHttpDns", "setPrimaryServiceHost failed: ${t.message}")
+                    }
+                    try {
+                        backupServiceHost?.let {
+                            builder.javaClass.getMethod("setBackupServiceHost", String::class.java)
+                                .invoke(builder, it)
                         }
-                    } catch (_: Throwable) {}
+                    } catch (_: Throwable) {
+                    }
+                    try {
+                        servicePort?.let {
+                            builder.javaClass.getMethod("setServicePort", Int::class.javaPrimitiveType)
+                                .invoke(builder, it)
+                        }
+                    } catch (_: Throwable) {
+                    }
+
                     try {
                         desiredPersistentCacheEnabled?.let { enabled ->
                             val discardSeconds = desiredDiscardExpiredAfterSeconds
                             if (discardSeconds != null && discardSeconds >= 0) {
-                                val expiredThresholdMillis = discardSeconds.toLong() * 1000L
-                                builder.javaClass.getMethod("setEnableCacheIp", Boolean::class.javaPrimitiveType, Long::class.javaPrimitiveType)
-                                    .invoke(builder, enabled, expiredThresholdMillis)
+                                val thresholdMillis = discardSeconds.toLong() * 1000L
+                                builder.javaClass.getMethod(
+                                    "setEnableCacheIp",
+                                    Boolean::class.javaPrimitiveType,
+                                    Long::class.javaPrimitiveType
+                                ).invoke(builder, enabled, thresholdMillis)
                             } else {
-                                builder.javaClass.getMethod("setEnableCacheIp", Boolean::class.javaPrimitiveType)
-                                    .invoke(builder, enabled)
+                                builder.javaClass.getMethod(
+                                    "setEnableCacheIp",
+                                    Boolean::class.javaPrimitiveType
+                                ).invoke(builder, enabled)
                             }
                         }
-                    } catch (_: Throwable) { }
+                    } catch (_: Throwable) {
+                    }
+
                     try {
-                        desiredReuseExpiredIPEnabled?.let { enabled ->
+                        desiredReuseExpiredIPEnabled?.let {
                             builder.javaClass.getMethod("setEnableExpiredIp", Boolean::class.javaPrimitiveType)
-                                .invoke(builder, enabled)
+                                .invoke(builder, it)
                         }
-                    } catch (_: Throwable) { }
-                    // Apply preResolve-after-network-changed
+                    } catch (_: Throwable) {
+                    }
+
                     try {
-                        desiredPreResolveAfterNetworkChanged?.let { en ->
-                            builder.javaClass.getMethod("setPreResolveAfterNetworkChanged", Boolean::class.javaPrimitiveType).invoke(builder, en)
+                        desiredPreResolveAfterNetworkChanged?.let {
+                            builder.javaClass.getMethod("setPreResolveAfterNetworkChanged", Boolean::class.javaPrimitiveType)
+                                .invoke(builder, it)
                         }
-                    } catch (_: Throwable) {}
-                    
-                    // Apply IP ranking list
+                    } catch (_: Throwable) {
+                    }
+
                     try {
                         desiredIPRankingMap?.let { map ->
                             if (map.isNotEmpty()) {
-                                // Create List<IPRankingBean>
-                                val ipRankingBeanClass = Class.forName("com.alibaba.sdk.android.httpdns.ranking.IPRankingBean")
-                                val constructor = ipRankingBeanClass.getConstructor(String::class.java, Int::class.javaPrimitiveType)
+                                val beanClass = Class.forName("com.alibaba.sdk.android.httpdns.ranking.IPRankingBean")
+                                val ctor = beanClass.getConstructor(String::class.java, Int::class.javaPrimitiveType)
                                 val list = ArrayList<Any>()
                                 map.forEach { (host, port) ->
-                                    val bean = constructor.newInstance(host, port)
-                                    list.add(bean)
+                                    list.add(ctor.newInstance(host, port))
                                 }
-                                val m = builder.javaClass.getMethod("setIPRankingList", List::class.java)
-                                m.invoke(builder, list)
-                                Log.i("AliyunHttpDns", "setIPRankingList applied with ${list.size} hosts")
+                                builder.javaClass.getMethod("setIPRankingList", List::class.java)
+                                    .invoke(builder, list)
                             }
                         }
-                    } catch (t: Throwable) {
-                        Log.w("AliyunHttpDns", "setIPRankingList failed: ${t.message}")
+                    } catch (_: Throwable) {
                     }
 
-                    builder.buildFor(account)
+                    if (!hostConfigApplied) {
+                        Log.w("AliyunHttpDns", "build failed: sdk core does not support primaryServiceHost")
+                        result.success(false)
+                        return
+                    }
+
+                    builder.buildFor(currentAppId)
 
                     service = if (!secretKey.isNullOrBlank()) {
-                        HttpDns.getService(ctx, account, secretKey)
+                        HttpDns.getService(ctx, currentAppId, secretKey)
                     } else {
-                        HttpDns.getService(ctx, account)
+                        HttpDns.getService(ctx, currentAppId)
                     }
-                    
-                    Log.i("AliyunHttpDns", "build completed for account=$account")
+
                     result.success(true)
                 } catch (t: Throwable) {
-                    Log.i("AliyunHttpDns", "build failed: ${t.message}")
+                    Log.w("AliyunHttpDns", "build failed: ${t.message}")
                     result.success(false)
                 }
             }
 
-            // Dart: resolveHostSyncNonBlocking(hostname, ipType, sdnsParams?, cacheKey?)
             "resolveHostSyncNonBlocking" -> {
                 val hostname = call.argument<String>("hostname")
                 if (hostname.isNullOrBlank()) {
                     result.success(mapOf("ipv4" to emptyList<String>(), "ipv6" to emptyList<String>()))
                     return
                 }
-                val ipTypeStr = call.argument<String>("ipType") ?: "auto"
-                val type = when (ipTypeStr.lowercase()) {
-                    "ipv4", "v4" -> RequestIpType.v4
-                    "ipv6", "v6" -> RequestIpType.v6
-                    "both", "64" -> RequestIpType.both
-                    else -> RequestIpType.auto
-                }
+
+                val type = mapIpType(call.argument<String>("ipType") ?: "auto")
                 try {
                     val svc = service ?: run {
                         val ctx = appContext
-                        val acc = accountId
-                        if (ctx != null && !acc.isNullOrBlank()) HttpDns.getService(ctx, acc) else null
+                        val currentAppId = appId
+                        if (ctx != null && !currentAppId.isNullOrBlank()) {
+                            HttpDns.getService(ctx, currentAppId)
+                        } else {
+                            null
+                        }
                     }
                     val r = svc?.getHttpDnsResultForHostSyncNonBlocking(hostname, type)
                     val v4 = r?.ips?.toList() ?: emptyList()
                     val v6 = r?.ipv6s?.toList() ?: emptyList()
-                    // 记录解析结果，便于排查：包含 host、请求类型以及返回的 IPv4/IPv6 列表
-                    Log.d(
-                        "HttpdnsPlugin",
-                        "resolve result host=" + hostname + ", type=" + type +
-                            ", ipv4=" + v4.joinToString(prefix = "[", postfix = "]") +
-                            ", ipv6=" + v6.joinToString(prefix = "[", postfix = "]")
-                    )
                     result.success(mapOf("ipv4" to v4, "ipv6" to v6))
-                } catch (t: Throwable) {
-                    Log.i("AliyunHttpDns", "resolveHostSyncNonBlocking failed: ${t.message}")
+                } catch (_: Throwable) {
                     result.success(mapOf("ipv4" to emptyList<String>(), "ipv6" to emptyList<String>()))
                 }
             }
-
-            // Legacy methods removed: preResolve / clearCache handled at app layer if needed
+            "resolveHostV1" -> {
+                val hostname = call.argument<String>("hostname")
+                if (hostname.isNullOrBlank()) {
+                    result.success(mapOf("ipv4" to emptyList<String>(), "ipv6" to emptyList<String>(), "ttl" to 0))
+                    return
+                }
+                val qtype = (call.argument<String>("qtype") ?: "A").uppercase()
+                val cip = call.argument<String>("cip")?.trim()
+                val requestType = if (qtype == "AAAA") RequestIpType.v6 else RequestIpType.v4
+                try {
+                    val svc = service ?: run {
+                        val ctx = appContext
+                        val currentAppId = appId
+                        if (ctx != null && !currentAppId.isNullOrBlank()) {
+                            HttpDns.getService(ctx, currentAppId)
+                        } else {
+                            null
+                        }
+                    }
+                    val params = if (!cip.isNullOrEmpty()) mapOf("cip" to cip) else null
+                    val r = svc?.getHttpDnsResultForHostSyncNonBlocking(hostname, requestType, params, hostname)
+                    val v4 = r?.ips?.toList() ?: emptyList()
+                    val v6 = r?.ipv6s?.toList() ?: emptyList()
+                    result.success(
+                        mapOf(
+                            "ipv4" to v4,
+                            "ipv6" to v6,
+                            "ttl" to (r?.ttl ?: 0),
+                        )
+                    )
+                } catch (_: Throwable) {
+                    result.success(mapOf("ipv4" to emptyList<String>(), "ipv6" to emptyList<String>(), "ttl" to 0))
+                }
+            }
 
             else -> result.notImplemented()
         }
     }
 
+    private fun mapIpType(ipType: String): RequestIpType {
+        return when (ipType.lowercase()) {
+            "ipv4", "v4" -> RequestIpType.v4
+            "ipv6", "v6" -> RequestIpType.v6
+            "both", "64" -> RequestIpType.both
+            else -> RequestIpType.auto
+        }
+    }
+
     override fun onDetachedFromEngine(@NonNull binding: FlutterPlugin.FlutterPluginBinding) {
         channel.setMethodCallHandler(null)
         service = null

EdgeHttpDNS/sdk/flutter/aliyun_httpdns/example/README.md

@@ -16,11 +16,14 @@ This example demonstrates:
 
 ## Getting Started
 
-1. Replace the `accountId` and `secretKey` in `lib/main.dart` with your own credentials:
+1. Replace the SDK init parameters in `lib/main.dart` with your own values:
    ```dart
    await AliyunHttpdns.init(
-     accountId: YOUR_ACCOUNT_ID,  // Replace with your account ID
-     secretKey: 'YOUR_SECRET_KEY', // Replace with your secret key
+     appId: 'YOUR_APP_ID',
+     primaryServiceHost: 'httpdns-a.example.com',
+     backupServiceHost: 'httpdns-b.example.com',
+     servicePort: 443,
+     secretKey: 'YOUR_SIGN_SECRET', // optional if sign is enabled
    );
    ```
 
@@ -48,4 +51,4 @@ The example uses a modern approach with `HttpClient.connectionFactory` to integr
 
 ## Note
 
-The credentials in this example are placeholders. Please obtain your own credentials from the [Aliyun HTTPDNS Console](https://help.aliyun.com/document_detail/2867674.html).
+The values in this example are placeholders. Use your own platform app configuration.

EdgeHttpDNS/sdk/flutter/aliyun_httpdns/example/lib/main.dart

@@ -64,8 +64,11 @@ class _MyHomePageState extends State<MyHomePage> {
     _httpdnsIniting = true;
     try {
       await AliyunHttpdns.init(
-        accountId: 000000, // 请替换为您的 Account ID
-        secretKey: 'your_secret_key_here', // 请替换为您的 Secret Key
+        appId: 'app1f1ndpo9', // 请替换为您的应用 AppId
+        primaryServiceHost: 'httpdns-a.example.com', // 请替换为主服务域名
+        backupServiceHost: 'httpdns-b.example.com', // 可选：备服务域名
+        servicePort: 443,
+        secretKey: 'your_sign_secret_here', // 可选：仅验签开启时需要
       );
       await AliyunHttpdns.setHttpsRequestEnabled(true);
       await AliyunHttpdns.setLogEnabled(true);

EdgeHttpDNS/sdk/flutter/aliyun_httpdns/ios/Classes/HttpdnsPlugin.swift

@@ -1,203 +1,324 @@
 import Flutter
+import Foundation
 import UIKit
-import AlicloudHTTPDNS
+import CommonCrypto
 
 public class AliyunHttpDnsPlugin: NSObject, FlutterPlugin {
-  private var channel: FlutterMethodChannel!
+  private var appId: String?
+  private var secretKey: String?
+  private var primaryServiceHost: String?
+  private var backupServiceHost: String?
+  private var servicePort: Int = 443
 
-  // Desired states saved until build()
-  private var desiredAccountId: Int?
-  private var desiredSecretKey: String?
-  private var desiredAesSecretKey: String?
-
-  private var desiredPersistentCacheEnabled: Bool?
-  private var desiredDiscardExpiredAfterSeconds: Int?
-  private var desiredReuseExpiredIPEnabled: Bool?
   private var desiredLogEnabled: Bool?
   private var desiredHttpsEnabled: Bool?
-  private var desiredPreResolveAfterNetworkChanged: Bool?
-  private var desiredIPRankingMap: [String: NSNumber]?
-
+  private var desiredConnectTimeoutSeconds: TimeInterval = 3
+  private var desiredReadTimeoutSeconds: TimeInterval = 5
 
+  private lazy var sessionId: String = {
+    UUID().uuidString.replacingOccurrences(of: "-", with: "")
+  }()
 
   public static func register(with registrar: FlutterPluginRegistrar) {
     let channel = FlutterMethodChannel(name: "aliyun_httpdns", binaryMessenger: registrar.messenger())
     let instance = AliyunHttpDnsPlugin()
-    instance.channel = channel
     registrar.addMethodCallDelegate(instance, channel: channel)
   }
 
   public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
     switch call.method {
-    // Dart: init(accountId, secretKey?, aesSecretKey?) — only save desired state
     case "initialize":
       let options = call.arguments as? [String: Any] ?? [:]
-      let accountIdAny = options["accountId"]
-      let secretKey = options["secretKey"] as? String
-      let aesSecretKey = options["aesSecretKey"] as? String
-
-      guard let accountId = (accountIdAny as? Int) ?? Int((accountIdAny as? String) ?? "") else {
-        NSLog("AliyunHttpDns: initialize missing accountId")
+      guard let rawAppId = options["appId"] as? String,
+            let rawPrimaryHost = options["primaryServiceHost"] as? String else {
         result(false)
         return
       }
-      desiredAccountId = accountId
-      desiredSecretKey = secretKey
-      desiredAesSecretKey = aesSecretKey
-      NSLog("AliyunHttpDns: initialize saved accountId=\(accountId)")
+
+      let normalizedAppId = rawAppId.trimmingCharacters(in: .whitespacesAndNewlines)
+      let normalizedPrimaryHost = rawPrimaryHost.trimmingCharacters(in: .whitespacesAndNewlines)
+      if normalizedAppId.isEmpty || normalizedPrimaryHost.isEmpty {
+        result(false)
+        return
+      }
+
+      appId = normalizedAppId
+      primaryServiceHost = normalizedPrimaryHost
+      backupServiceHost = (options["backupServiceHost"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+      secretKey = (options["secretKey"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+      if let p = options["servicePort"] as? Int, p > 0 {
+        servicePort = p
+      }
       result(true)
 
-
-
-    // Dart: setLogEnabled(enabled) — save desired
     case "setLogEnabled":
       let args = call.arguments as? [String: Any]
-      let enabled = (args?["enabled"] as? Bool) ?? false
-      desiredLogEnabled = enabled
-      NSLog("AliyunHttpDns: log desired=\(enabled)")
+      desiredLogEnabled = (args?["enabled"] as? Bool) ?? false
       result(nil)
 
     case "setHttpsRequestEnabled":
       let args = call.arguments as? [String: Any]
-      let enabled = (args?["enabled"] as? Bool) ?? false
-      desiredHttpsEnabled = enabled
-      NSLog("AliyunHttpDns: https request desired=\(enabled)")
+      desiredHttpsEnabled = (args?["enabled"] as? Bool) ?? false
       result(nil)
 
-    // Dart: setPersistentCacheIPEnabled(enabled, discardExpiredAfterSeconds?) — save desired
     case "setPersistentCacheIPEnabled":
-      let args = call.arguments as? [String: Any]
-      let enabled = (args?["enabled"] as? Bool) ?? false
-      let discard = args?["discardExpiredAfterSeconds"] as? Int
-      desiredPersistentCacheEnabled = enabled
-      desiredDiscardExpiredAfterSeconds = discard
-      NSLog("AliyunHttpDns: persistent cache desired=\(enabled) discard=\(discard ?? -1)")
       result(nil)
 
-    // Dart: setReuseExpiredIPEnabled(enabled) — save desired
     case "setReuseExpiredIPEnabled":
-      let args = call.arguments as? [String: Any]
-      let enabled = (args?["enabled"] as? Bool) ?? false
-      desiredReuseExpiredIPEnabled = enabled
-      NSLog("AliyunHttpDns: reuse expired ip desired=\(enabled)")
       result(nil)
 
     case "setPreResolveAfterNetworkChanged":
-      let args = call.arguments as? [String: Any]
-      let enabled = (args?["enabled"] as? Bool) ?? false
-      desiredPreResolveAfterNetworkChanged = enabled
-      NSLog("AliyunHttpDns: preResolveAfterNetworkChanged desired=\(enabled)")
       result(nil)
 
     case "setIPRankingList":
-      let args = call.arguments as? [String: Any]
-      let hostPortMap = args?["hostPortMap"] as? [String: NSNumber]
-      desiredIPRankingMap = hostPortMap
-      NSLog("AliyunHttpDns: IP ranking list desired, hosts=\(hostPortMap?.keys.joined(separator: ", ") ?? "")")
       result(nil)
 
     case "setPreResolveHosts":
-      let args = call.arguments as? [String: Any]
-      let hosts = (args?["hosts"] as? [String]) ?? []
-      let ipTypeStr = (args?["ipType"] as? String) ?? "auto"
-      switch ipTypeStr.lowercased() {
-      case "ipv4", "v4":
-        HttpDnsService.sharedInstance().setPreResolveHosts(hosts, queryIPType: AlicloudHttpDNS_IPType.init(0))
-      case "ipv6", "v6":
-        HttpDnsService.sharedInstance().setPreResolveHosts(hosts, queryIPType: AlicloudHttpDNS_IPType.init(1))
-      case "both", "64":
-        HttpDnsService.sharedInstance().setPreResolveHosts(hosts, queryIPType: AlicloudHttpDNS_IPType.init(2))
-      default:
-        HttpDnsService.sharedInstance().setPreResolveHosts(hosts)
-      }
       result(nil)
 
     case "getSessionId":
-      let sid = HttpDnsService.sharedInstance().getSessionId()
-      result(sid)
+      result(sessionId)
 
     case "cleanAllHostCache":
-      HttpDnsService.sharedInstance().cleanAllHostCache()
       result(nil)
 
-    // Dart: build() — construct service and apply desired states
     case "build":
-      guard let accountId = desiredAccountId else {
-        result(false)
-        return
+      if desiredHttpsEnabled == false {
+        NSLog("AliyunHttpDns(iOS): HTTPS is required by current protocol, force enabled")
       }
-      // Initialize singleton
-      if let secret = desiredSecretKey, !secret.isEmpty {
-        if let aes = desiredAesSecretKey, !aes.isEmpty {
-          _ = HttpDnsService(accountID: accountId, secretKey: secret, aesSecretKey: aes)
-        } else {
-          _ = HttpDnsService(accountID: accountId, secretKey: secret)
-        }
-      } else {
-        _ = HttpDnsService(accountID: accountId) // deprecated but acceptable fallback
-      }
-      let svc = HttpDnsService.sharedInstance()
-      // Apply desired runtime flags
-      if let enable = desiredPersistentCacheEnabled {
-        if let discard = desiredDiscardExpiredAfterSeconds, discard >= 0 {
-          svc.setPersistentCacheIPEnabled(enable, discardRecordsHasExpiredFor: TimeInterval(discard))
-        } else {
-          svc.setPersistentCacheIPEnabled(enable)
-        }
-      }
-      if let enable = desiredReuseExpiredIPEnabled {
-        svc.setReuseExpiredIPEnabled(enable)
-      }
-      if let enable = desiredLogEnabled {
-        svc.setLogEnabled(enable)
-      }
-      if let enable = desiredHttpsEnabled {
-        svc.setHTTPSRequestEnabled(enable)
+      if desiredLogEnabled == true {
+        NSLog("AliyunHttpDns(iOS): build success, appId=\(appId ?? "")")
       }
+      result(appId != nil && primaryServiceHost != nil)
 
-      if let en = desiredPreResolveAfterNetworkChanged {
-        svc.setPreResolveAfterNetworkChanged(en)
-      }
-      if let ipRankingMap = desiredIPRankingMap, !ipRankingMap.isEmpty {
-        svc.setIPRankingDatasource(ipRankingMap)
-      }
-      NSLog("AliyunHttpDns: build completed accountId=\(accountId)")
-      result(true)
-
-    // Dart: resolveHostSyncNonBlocking(hostname, ipType, sdnsParams?, cacheKey?)
     case "resolveHostSyncNonBlocking":
-      guard let args = call.arguments as? [String: Any], let host = args["hostname"] as? String else {
+      guard let args = call.arguments as? [String: Any],
+            let hostname = args["hostname"] as? String else {
         result(["ipv4": [], "ipv6": []])
         return
       }
-      let ipTypeStr = (args["ipType"] as? String) ?? "auto"
-      let sdnsParams = args["sdnsParams"] as? [String: String]
-      let cacheKey = args["cacheKey"] as? String
-      let type: HttpdnsQueryIPType
-      switch ipTypeStr.lowercased() {
-      case "ipv4", "v4": type = .ipv4
-      case "ipv6", "v6": type = .ipv6
-      case "both", "64": type = .both
-      default: type = .auto
+      let ipType = ((args["ipType"] as? String) ?? "auto").lowercased()
+      resolveHost(hostname: hostname, ipType: ipType) { payload in
+        result(payload)
       }
-      let svc = HttpDnsService.sharedInstance()
-      var v4: [String] = []
-      var v6: [String] = []
-      if let params = sdnsParams, let key = cacheKey, let r = svc.resolveHostSyncNonBlocking(host, by: type, withSdnsParams: params, sdnsCacheKey: key) {
-        if r.hasIpv4Address() { v4 = r.ips }
-        if r.hasIpv6Address() { v6 = r.ipv6s }
-      } else if let r = svc.resolveHostSyncNonBlocking(host, by: type) {
-        if r.hasIpv4Address() { v4 = r.ips }
-        if r.hasIpv6Address() { v6 = r.ipv6s }
+    case "resolveHostV1":
+      guard let args = call.arguments as? [String: Any],
+            let hostname = args["hostname"] as? String else {
+        result(["ipv4": [], "ipv6": [], "ttl": 0])
+        return
+      }
+      let qtype = ((args["qtype"] as? String) ?? "A").uppercased()
+      let cip = (args["cip"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+      resolveSingle(hostname: hostname, qtype: qtype, cip: cip) { records, ttl in
+        if qtype == "AAAA" {
+          result(["ipv4": [], "ipv6": records, "ttl": ttl])
+        } else {
+          result(["ipv4": records, "ipv6": [], "ttl": ttl])
+        }
       }
-      result(["ipv4": v4, "ipv6": v6])
-
-    // Legacy methods removed: preResolve / clearCache
 
     default:
       result(FlutterMethodNotImplemented)
     }
   }
+
+  private func resolveHost(hostname: String, ipType: String, completion: @escaping ([String: [String]]) -> Void) {
+    let qtypes: [String]
+    switch ipType {
+    case "ipv6", "v6":
+      qtypes = ["AAAA"]
+    case "both", "64":
+      qtypes = ["A", "AAAA"]
+    default:
+      qtypes = ["A"]
+    }
+
+    let group = DispatchGroup()
+    let lock = NSLock()
+    var ipv4: [String] = []
+    var ipv6: [String] = []
+
+    for qtype in qtypes {
+      group.enter()
+      resolveSingle(hostname: hostname, qtype: qtype, cip: nil) { records, _ in
+        lock.lock()
+        if qtype == "AAAA" {
+          ipv6.append(contentsOf: records)
+        } else {
+          ipv4.append(contentsOf: records)
+        }
+        lock.unlock()
+        group.leave()
+      }
+    }
+
+    group.notify(queue: .main) {
+      completion([
+        "ipv4": Array(Set(ipv4)),
+        "ipv6": Array(Set(ipv6))
+      ])
+    }
+  }
+
+  private func resolveSingle(hostname: String, qtype: String, cip: String?, completion: @escaping ([String], Int) -> Void) {
+    guard let appId = appId,
+          let primary = primaryServiceHost else {
+      completion([], 0)
+      return
+    }
+
+    var hosts: [String] = [primary]
+    if let backup = backupServiceHost, !backup.isEmpty, backup != primary {
+      hosts.append(backup)
+    }
+
+    func attempt(_ index: Int) {
+      if index >= hosts.count {
+        completion([], 0)
+        return
+      }
+
+      let serviceHost = hosts[index]
+      var components = URLComponents()
+      components.scheme = "https"
+      components.host = serviceHost
+      components.port = servicePort
+      components.path = "/resolve"
+
+      var queryItems: [URLQueryItem] = [
+        URLQueryItem(name: "appId", value: appId),
+        URLQueryItem(name: "dn", value: hostname),
+        URLQueryItem(name: "qtype", value: qtype),
+        URLQueryItem(name: "sdk_version", value: "flutter-ios-1.0.0"),
+        URLQueryItem(name: "os", value: "ios"),
+        URLQueryItem(name: "sid", value: sessionId)
+      ]
+
+      if let secret = secretKey, !secret.isEmpty {
+        let exp = String(Int(Date().timeIntervalSince1970) + 600)
+        let nonce = UUID().uuidString.replacingOccurrences(of: "-", with: "")
+        let signRaw = "\(appId)|\(hostname.lowercased())|\(qtype.uppercased())|\(exp)|\(nonce)"
+        let sign = hmacSHA256Hex(message: signRaw, secret: secret)
+        queryItems.append(URLQueryItem(name: "exp", value: exp))
+        queryItems.append(URLQueryItem(name: "nonce", value: nonce))
+        queryItems.append(URLQueryItem(name: "sign", value: sign))
+      }
+      if let cip = cip, !cip.isEmpty {
+        queryItems.append(URLQueryItem(name: "cip", value: cip))
+      }
+
+      components.queryItems = queryItems
+      guard let url = components.url else {
+        completion([], 0)
+        return
+      }
+
+      var req = URLRequest(url: url)
+      req.httpMethod = "GET"
+      req.timeoutInterval = desiredConnectTimeoutSeconds + desiredReadTimeoutSeconds
+      req.setValue(serviceHost, forHTTPHeaderField: "Host")
+
+      let config = URLSessionConfiguration.ephemeral
+      config.timeoutIntervalForRequest = desiredConnectTimeoutSeconds + desiredReadTimeoutSeconds
+      config.timeoutIntervalForResource = desiredConnectTimeoutSeconds + desiredReadTimeoutSeconds
+      let session = URLSession(configuration: config)
+      session.dataTask(with: req) { [weak self] data, _, error in
+        defer { session.finishTasksAndInvalidate() }
+
+        if let error = error {
+          if self?.desiredLogEnabled == true {
+            NSLog("AliyunHttpDns(iOS): resolve request failed host=\(serviceHost), err=\(error.localizedDescription)")
+          }
+          attempt(index + 1)
+          return
+        }
+        guard let data = data else {
+          attempt(index + 1)
+          return
+        }
+
+        let parsedIPs = Self.extractIPsFromResolveResponse(data: data, qtype: qtype)
+        if parsedIPs.isEmpty {
+          attempt(index + 1)
+          return
+        }
+        let ttl = Self.extractTTLFromResolveResponse(data: data)
+        completion(parsedIPs, ttl)
+      }.resume()
+    }
+
+    attempt(0)
+  }
+
+  private static func extractIPsFromResolveResponse(data: Data, qtype: String) -> [String] {
+    guard let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+          isResolveSuccessCode(obj["code"]),
+          let dataObj = obj["data"] as? [String: Any],
+          let records = dataObj["records"] as? [[String: Any]] else {
+      return []
+    }
+
+    var ips: [String] = []
+    for row in records {
+      let type = ((row["type"] as? String) ?? "").uppercased()
+      if type != qtype.uppercased() {
+        continue
+      }
+      if let ip = row["ip"] as? String, !ip.isEmpty {
+        ips.append(ip)
+      }
+    }
+    return ips
+  }
+
+  private static func extractTTLFromResolveResponse(data: Data) -> Int {
+    guard let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+          let dataObj = obj["data"] as? [String: Any],
+          let ttlValue = dataObj["ttl"] else {
+      return 0
+    }
+    if let ttl = ttlValue as? Int {
+      return ttl
+    }
+    if let ttlString = ttlValue as? String, let ttl = Int(ttlString) {
+      return ttl
+    }
+    return 0
+  }
+
+  private static func isResolveSuccessCode(_ codeValue: Any?) -> Bool {
+    if let code = codeValue as? String {
+      let normalized = code.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
+      return normalized == "SUCCESS" || normalized == "0"
+    }
+    if let code = codeValue as? Int {
+      return code == 0
+    }
+    if let code = codeValue as? NSNumber {
+      return code.intValue == 0
+    }
+    return false
+  }
+
+  private func hmacSHA256Hex(message: String, secret: String) -> String {
+    guard let keyData = secret.data(using: .utf8),
+          let messageData = message.data(using: .utf8) else {
+      return ""
+    }
+
+    var digest = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+    keyData.withUnsafeBytes { keyBytes in
+      messageData.withUnsafeBytes { msgBytes in
+        CCHmac(
+          CCHmacAlgorithm(kCCHmacAlgSHA256),
+          keyBytes.baseAddress,
+          keyData.count,
+          msgBytes.baseAddress,
+          messageData.count,
+          &digest
+        )
+      }
+    }
+    return digest.map { String(format: "%02x", $0) }.joined()
+  }
 }
-
-

EdgeHttpDNS/sdk/flutter/aliyun_httpdns/ios/aliyun_httpdns.podspec

@@ -3,7 +3,7 @@
 #
 Pod::Spec.new do |s|
   s.name             = 'aliyun_httpdns'
-  s.version          = '1.0.2'
+  s.version          = '1.0.0'
   s.summary          = 'aliyun httpdns flutter plugin'
   s.description      = <<-DESC
 aliyun httpdns flutter plugin.
@@ -16,7 +16,6 @@ DESC
   s.public_header_files = 'Classes/**/*.h'
   s.static_framework = true
   s.dependency 'Flutter'
-  s.dependency 'AlicloudHTTPDNS', '3.4.0'
   s.platform = :ios, '10.0'
 
   # Flutter.framework does not contain a i386 slice.

EdgeHttpDNS/sdk/flutter/aliyun_httpdns/lib/aliyun_httpdns.dart

@@ -1,87 +1,89 @@
-import 'dart:async';
+import 'dart:async';
+import 'dart:io';
+import 'dart:typed_data';
+
 import 'package:flutter/services.dart';
 
 class AliyunHttpdns {
   static const MethodChannel _channel = MethodChannel('aliyun_httpdns');
 
-  /// 1) 初始化：使用 accountId/secretKey/aesSecretKey
+  /// New API only:
+  /// appId + primary/backup service host + optional sign secret.
   static Future<bool> init({
-    required int accountId,
+    required String appId,
+    required String primaryServiceHost,
+    String? backupServiceHost,
+    int servicePort = 443,
     String? secretKey,
-    String? aesSecretKey,
   }) async {
-    final ok =
-        await _channel.invokeMethod<bool>('initialize', <String, dynamic>{
-      'accountId': accountId,
-      if (secretKey != null) 'secretKey': secretKey,
-      if (aesSecretKey != null) 'aesSecretKey': aesSecretKey,
-    });
+    final String normalizedAppId = appId.trim();
+    final String normalizedPrimary = primaryServiceHost.trim();
+    if (normalizedAppId.isEmpty || normalizedPrimary.isEmpty) {
+      return false;
+    }
+
+    final Map<String, dynamic> args = <String, dynamic>{
+      'appId': normalizedAppId,
+      'primaryServiceHost': normalizedPrimary,
+      if (backupServiceHost != null && backupServiceHost.trim().isNotEmpty)
+        'backupServiceHost': backupServiceHost.trim(),
+      if (servicePort > 0) 'servicePort': servicePort,
+      if (secretKey != null && secretKey.isNotEmpty) 'secretKey': secretKey,
+    };
+
+    final bool? ok = await _channel.invokeMethod<bool>('initialize', args);
     return ok ?? false;
   }
 
-  /// 构建底层 service，只有在调用了 initialize / 一系列 setXxx 后，
-  /// 调用本方法才会真正创建底层实例并应用配置
   static Future<bool> build() async {
-    final ok = await _channel.invokeMethod<bool>('build');
+    final bool? ok = await _channel.invokeMethod<bool>('build');
     return ok ?? false;
   }
 
-  /// 2) 设置日志开关
   static Future<void> setLogEnabled(bool enabled) async {
-    await _channel.invokeMethod<void>('setLogEnabled', <String, dynamic>{
-      'enabled': enabled,
-    });
+    await _channel.invokeMethod<void>('setLogEnabled', <String, dynamic>{'enabled': enabled});
   }
 
-  /// 3) 设置持久化缓存
   static Future<void> setPersistentCacheIPEnabled(bool enabled,
       {int? discardExpiredAfterSeconds}) async {
-    await _channel
-        .invokeMethod<void>('setPersistentCacheIPEnabled', <String, dynamic>{
+    await _channel.invokeMethod<void>('setPersistentCacheIPEnabled', <String, dynamic>{
       'enabled': enabled,
       if (discardExpiredAfterSeconds != null)
         'discardExpiredAfterSeconds': discardExpiredAfterSeconds,
     });
   }
 
-  /// 4) 是否允许复用过期 IP
   static Future<void> setReuseExpiredIPEnabled(bool enabled) async {
     await _channel
-        .invokeMethod<void>('setReuseExpiredIPEnabled', <String, dynamic>{
-      'enabled': enabled,
-    });
+        .invokeMethod<void>('setReuseExpiredIPEnabled', <String, dynamic>{'enabled': enabled});
   }
 
-  /// 设置是否使用 HTTPS 解析链路，避免明文流量被系统拦截
   static Future<void> setHttpsRequestEnabled(bool enabled) async {
     await _channel
-        .invokeMethod<void>('setHttpsRequestEnabled', <String, dynamic>{
-      'enabled': enabled,
-    });
+        .invokeMethod<void>('setHttpsRequestEnabled', <String, dynamic>{'enabled': enabled});
   }
 
-  /// 5) 伪异步解析：返回 IPv4/IPv6 数组
-  /// 返回格式：{"ipv4": `List<String>`, "ipv6": `List<String>`}
   static Future<Map<String, List<String>>> resolveHostSyncNonBlocking(
     String hostname, {
     String ipType = 'auto', // auto/ipv4/ipv6/both
-    Map<String, String>? sdnsParams,
-    String? cacheKey,
   }) async {
-    final Map<dynamic, dynamic>? res = await _channel
-        .invokeMethod('resolveHostSyncNonBlocking', <String, dynamic>{
+    final Map<dynamic, dynamic>? res =
+        await _channel.invokeMethod<Map<dynamic, dynamic>>('resolveHostSyncNonBlocking',
+            <String, dynamic>{
       'hostname': hostname,
       'ipType': ipType,
-      if (sdnsParams != null) 'sdnsParams': sdnsParams,
-      if (cacheKey != null) 'cacheKey': cacheKey,
     });
-    final Map<String, List<String>> out = {
+
+    final Map<String, List<String>> out = <String, List<String>>{
       'ipv4': <String>[],
       'ipv6': <String>[],
     };
-    if (res == null) return out;
-    final v4 = res['ipv4'];
-    final v6 = res['ipv6'];
+    if (res == null) {
+      return out;
+    }
+
+    final dynamic v4 = res['ipv4'];
+    final dynamic v6 = res['ipv6'];
     if (v4 is List) {
       out['ipv4'] = v4.map((e) => e.toString()).toList();
     }
@@ -91,51 +93,190 @@ class AliyunHttpdns {
     return out;
   }
 
-  // 解析域名，返回 A/AAAA 记录等（保留旧接口以兼容，未在本任务使用）
-  static Future<Map<String, dynamic>?> resolve(String hostname,
-      {Map<String, dynamic>? options}) async {
-    final res = await _channel.invokeMethod<Map<dynamic, dynamic>>('resolve', {
+  /// V1 resolve API:
+  /// qtype supports A / AAAA, optional cip for route simulation.
+  static Future<Map<String, dynamic>> resolveHost(
+    String hostname, {
+    String qtype = 'A',
+    String? cip,
+  }) async {
+    final Map<dynamic, dynamic>? res =
+        await _channel.invokeMethod<Map<dynamic, dynamic>>('resolveHostV1', <String, dynamic>{
       'hostname': hostname,
-      if (options != null) 'options': options,
+      'qtype': qtype,
+      if (cip != null && cip.trim().isNotEmpty) 'cip': cip.trim(),
     });
-    return res?.map((key, value) => MapEntry(key.toString(), value));
+
+    final Map<String, dynamic> out = <String, dynamic>{
+      'ipv4': <String>[],
+      'ipv6': <String>[],
+      'ttl': 0,
+    };
+    if (res == null) {
+      return out;
+    }
+    final dynamic v4 = res['ipv4'];
+    final dynamic v6 = res['ipv6'];
+    if (v4 is List) {
+      out['ipv4'] = v4.map((e) => e.toString()).toList();
+    }
+    if (v6 is List) {
+      out['ipv6'] = v6.map((e) => e.toString()).toList();
+    }
+    final dynamic ttl = res['ttl'];
+    if (ttl is int) {
+      out['ttl'] = ttl;
+    }
+    return out;
   }
 
-  // 1) setPreResolveHosts: 传入 host 列表，native 侧调用 SDK 预解析
-  static Future<void> setPreResolveHosts(List<String> hosts,
-      {String ipType = 'auto'}) async {
+  static Future<void> setPreResolveHosts(List<String> hosts, {String ipType = 'auto'}) async {
     await _channel.invokeMethod<void>('setPreResolveHosts', <String, dynamic>{
       'hosts': hosts,
       'ipType': ipType,
     });
   }
 
-  // 2) setLogEnabled: 已有，同步保留（在此文件顶部已有 setLogEnabled 实现）
-
-  // 3) setPreResolveAfterNetworkChanged: 是否在网络切换时自动刷新解析
   static Future<void> setPreResolveAfterNetworkChanged(bool enabled) async {
-    await _channel.invokeMethod<void>(
-        'setPreResolveAfterNetworkChanged', <String, dynamic>{
+    await _channel.invokeMethod<void>('setPreResolveAfterNetworkChanged', <String, dynamic>{
       'enabled': enabled,
     });
   }
 
-  // 4) getSessionId: 获取会话 id
-  static Future<String?> getSessionId() async {
-    final sid = await _channel.invokeMethod<String>('getSessionId');
-    return sid;
+  static Future<void> setIPRankingList(Map<String, int> hostPortMap) async {
+    await _channel
+        .invokeMethod<void>('setIPRankingList', <String, dynamic>{'hostPortMap': hostPortMap});
+  }
+
+  static Future<String?> getSessionId() async {
+    return _channel.invokeMethod<String>('getSessionId');
   }
 
-  // 5) cleanAllHostCache: 清除所有缓存
   static Future<void> cleanAllHostCache() async {
     await _channel.invokeMethod<void>('cleanAllHostCache');
   }
-  
-  /// 设置 IP 优选列表
-  /// [hostPortMap] 域名和端口的映射，例如：{'www.aliyun.com': 443}
-  static Future<void> setIPRankingList(Map<String, int> hostPortMap) async {
-    await _channel.invokeMethod<void>('setIPRankingList', <String, dynamic>{
-      'hostPortMap': hostPortMap,
-    });
+
+  static AliyunHttpdnsHttpAdapter createHttpAdapter({
+    AliyunHttpdnsAdapterOptions options = const AliyunHttpdnsAdapterOptions(),
+  }) {
+    return AliyunHttpdnsHttpAdapter._(options);
+  }
+}
+
+class AliyunHttpdnsAdapterOptions {
+  final String ipType;
+  final int connectTimeoutMs;
+  final int readTimeoutMs;
+  final bool allowInsecureCertificatesForDebugOnly;
+
+  const AliyunHttpdnsAdapterOptions({
+    this.ipType = 'auto',
+    this.connectTimeoutMs = 3000,
+    this.readTimeoutMs = 5000,
+    this.allowInsecureCertificatesForDebugOnly = false,
+  });
+}
+
+class AliyunHttpdnsRequestResult {
+  final int statusCode;
+  final Map<String, List<String>> headers;
+  final Uint8List body;
+  final String usedIp;
+
+  const AliyunHttpdnsRequestResult({
+    required this.statusCode,
+    required this.headers,
+    required this.body,
+    required this.usedIp,
+  });
+}
+
+class AliyunHttpdnsHttpAdapter {
+  final AliyunHttpdnsAdapterOptions _options;
+
+  AliyunHttpdnsHttpAdapter._(this._options);
+
+  /// Fixed behavior:
+  /// 1) resolve host by HTTPDNS
+  /// 2) connect to IP:443
+  /// 3) keep HTTP Host as original domain
+  /// 4) no fallback to domain connect
+  Future<AliyunHttpdnsRequestResult> request(
+    Uri uri, {
+    String method = 'GET',
+    Map<String, String>? headers,
+    List<int>? body,
+  }) async {
+    if (uri.host.isEmpty) {
+      throw const HttpException('HOST_ROUTE_REJECTED: host is empty');
+    }
+    if (uri.scheme.toLowerCase() != 'https') {
+      throw const HttpException('TLS_EMPTY_SNI_FAILED: only https is supported');
+    }
+
+    final Map<String, List<String>> resolved = await AliyunHttpdns.resolveHostSyncNonBlocking(
+      uri.host,
+      ipType: _options.ipType,
+    );
+    final List<String> ips = <String>[
+      ...?resolved['ipv4'],
+      ...?resolved['ipv6'],
+    ];
+    if (ips.isEmpty) {
+      throw const HttpException('NO_IP_AVAILABLE: HTTPDNS returned empty ip list');
+    }
+
+    Object? lastError;
+    for (final String ip in ips) {
+      final HttpClient client = HttpClient();
+      client.connectionTimeout = Duration(milliseconds: _options.connectTimeoutMs);
+      if (_options.allowInsecureCertificatesForDebugOnly) {
+        client.badCertificateCallback = (_, __, ___) => true;
+      }
+
+      try {
+        final Uri target = uri.replace(
+          host: ip,
+          port: uri.hasPort ? uri.port : 443,
+        );
+        final HttpClientRequest req = await client
+            .openUrl(method, target)
+            .timeout(Duration(milliseconds: _options.connectTimeoutMs));
+        req.headers.host = uri.host;
+        headers?.forEach((String key, String value) {
+          if (key.toLowerCase() == 'host') {
+            return;
+          }
+          req.headers.set(key, value);
+        });
+        if (body != null && body.isNotEmpty) {
+          req.add(body);
+        }
+
+        final HttpClientResponse resp =
+            await req.close().timeout(Duration(milliseconds: _options.readTimeoutMs));
+        final List<int> payload =
+            await resp.fold<List<int>>(<int>[], (List<int> previous, List<int> element) {
+          previous.addAll(element);
+          return previous;
+        });
+        final Map<String, List<String>> responseHeaders = <String, List<String>>{};
+        resp.headers.forEach((String name, List<String> values) {
+          responseHeaders[name] = values;
+        });
+        return AliyunHttpdnsRequestResult(
+          statusCode: resp.statusCode,
+          headers: responseHeaders,
+          body: Uint8List.fromList(payload),
+          usedIp: ip,
+        );
+      } catch (e) {
+        lastError = e;
+      } finally {
+        client.close(force: true);
+      }
+    }
+
+    throw HttpException('TLS_EMPTY_SNI_FAILED: all ip connect attempts failed, error=$lastError');
   }
 }

EdgeHttpDNS/sdk/flutter/aliyun_httpdns/pubspec.yaml

@@ -1,6 +1,6 @@
 name: aliyun_httpdns
 description: "Aliyun HTTPDNS Flutter plugin."
-version: 1.0.2
+version: 1.0.0
 homepage: https://help.aliyun.com/document_detail/2584339.html
 
 environment: