diff --git a/Android.bp b/Android.bp
index ccd7d58..ad11334 100644
--- a/Android.bp
+++ b/Android.bp
@@ -16,7 +16,7 @@
     srcs: [
         "binder/android/net/IDnsResolver.aidl",
         "binder/android/net/ResolverHostsParcel.aidl",
-        "binder/android/net/ResolverExperimentalOptionsParcel.aidl",
+        "binder/android/net/ResolverOptionsParcel.aidl",
         "binder/android/net/ResolverParamsParcel.aidl",
     ],
     imports: [
@@ -25,17 +25,22 @@
     backend: {
         java: {
             apex_available: [
+                "//apex_available:platform",
                 "com.android.bluetooth.updatable",
             ],
         },
         ndk: {
             gen_log: true,
+            apex_available: [
+                "com.android.resolv",
+            ],
         },
     },
     versions: [
         "1",
         "2",
         "3",
+        "4",
     ],
 }
 
@@ -112,7 +117,7 @@
     // Link most things statically to minimize our dependence on system ABIs.
     stl: "libc++_static",
     static_libs: [
-        "dnsresolver_aidl_interface-unstable-ndk_platform",
+        "dnsresolver_aidl_interface-ndk_platform",
         "libbase",
         "libcutils",
         "libjsoncpp",
@@ -166,6 +171,7 @@
     sanitize: {
         cfi: true,
     },
+    apex_available: ["com.android.resolv"],
 }
 
 cc_library_static {
@@ -178,6 +184,7 @@
     srcs: [
         "stats.proto",
     ],
+    apex_available: ["com.android.resolv"],
 }
 
 genrule {
@@ -209,6 +216,7 @@
         "libgtest_prod", // Used by libstatspush_compat
         "libstatspush_compat",
     ],
+    apex_available: ["com.android.resolv"],
 }
 
 filegroup {
@@ -221,11 +229,18 @@
 // TODO: Move this test to tests/
 cc_test {
     name: "resolv_unit_test",
-    test_suites: ["device-tests", "mts"],
+    test_suites: [
+        "device-tests",
+        "mts",
+    ],
     require_root: true,
     // TODO: Drop root privileges and make it be an real unit test.
     // TODO: Remove resolv_test_mts_coverage_defaults after mts coverage switched to 64-bit device.
-    defaults: ["netd_defaults", "resolv_test_defaults", "resolv_test_mts_coverage_defaults"],
+    defaults: [
+        "netd_defaults",
+        "resolv_test_defaults",
+        "resolv_test_mts_coverage_defaults",
+    ],
     srcs: [
         "resolv_cache_unit_test.cpp",
         "resolv_callback_unit_test.cpp",
diff --git a/DnsProxyListener.cpp b/DnsProxyListener.cpp
index 2046c34..8d09751 100644
--- a/DnsProxyListener.cpp
+++ b/DnsProxyListener.cpp
@@ -355,6 +355,7 @@
         const std::string& dnsQueryStats = event.dns_query_events().SerializeAsString();
         stats::BytesField dnsQueryBytesField{dnsQueryStats.c_str(), dnsQueryStats.size()};
         event.set_return_code(static_cast<ReturnCode>(returnCode));
+        event.set_network_type(resolv_get_network_types_for_net(netContext.dns_netid));
         android::net::stats::stats_write(android::net::stats::NETWORK_DNS_EVENT_REPORTED,
                                          event.event_type(), event.return_code(),
                                          event.latency_micros(), event.hints_ai_flags(),
diff --git a/ResolverController.cpp b/ResolverController.cpp
index 22878f3..13600b8 100644
--- a/ResolverController.cpp
+++ b/ResolverController.cpp
@@ -233,7 +233,7 @@
 
     return resolv_set_nameservers(resolverParams.netId, resolverParams.servers,
                                   resolverParams.domains, res_params,
-                                  resolverParams.experimentalOptions);
+                                  resolverParams.resolverOptions, resolverParams.transportTypes);
 }
 
 int ResolverController::getResolverInfo(int32_t netId, std::vector<std::string>* servers,
@@ -362,8 +362,7 @@
             dw.decIndent();
         }
         dw.println("Concurrent DNS query timeout: %d", wait_for_pending_req_timeout_count[0]);
-        resolv_stats_dump(dw, netId);
-        resolv_oem_options_dump(dw, netId);
+        resolv_netconfig_dump(dw, netId);
     }
     dw.decIndent();
 }
diff --git a/aidl_api/dnsresolver_aidl_interface/4/.hash b/aidl_api/dnsresolver_aidl_interface/4/.hash
new file mode 100644
index 0000000..c0a6b10
--- /dev/null
+++ b/aidl_api/dnsresolver_aidl_interface/4/.hash
@@ -0,0 +1 @@
+012d220dd2a6736ed40b8653351386cece8458f7
diff --git a/aidl_api/dnsresolver_aidl_interface/4/android/net/IDnsResolver.aidl b/aidl_api/dnsresolver_aidl_interface/4/android/net/IDnsResolver.aidl
new file mode 100644
index 0000000..9eb65de
--- /dev/null
+++ b/aidl_api/dnsresolver_aidl_interface/4/android/net/IDnsResolver.aidl
@@ -0,0 +1,63 @@
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL interface (or parcelable). Do not try to
+// edit this file. It looks like you are doing that because you have modified
+// an AIDL interface in a backward-incompatible way, e.g., deleting a function
+// from an interface or a field from a parcelable and it broke the build. That
+// breakage is intended.
+//
+// You must not make a backward incompatible changes to the AIDL files built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.net;
+/* @hide */
+interface IDnsResolver {
+  boolean isAlive();
+  void registerEventListener(android.net.metrics.INetdEventListener listener);
+  void setResolverConfiguration(in android.net.ResolverParamsParcel resolverParams);
+  void getResolverInfo(int netId, out @utf8InCpp String[] servers, out @utf8InCpp String[] domains, out @utf8InCpp String[] tlsServers, out int[] params, out int[] stats, out int[] wait_for_pending_req_timeout_count);
+  void startPrefix64Discovery(int netId);
+  void stopPrefix64Discovery(int netId);
+  @utf8InCpp String getPrefix64(int netId);
+  void createNetworkCache(int netId);
+  void destroyNetworkCache(int netId);
+  void setLogSeverity(int logSeverity);
+  void flushNetworkCache(int netId);
+  const int RESOLVER_PARAMS_SAMPLE_VALIDITY = 0;
+  const int RESOLVER_PARAMS_SUCCESS_THRESHOLD = 1;
+  const int RESOLVER_PARAMS_MIN_SAMPLES = 2;
+  const int RESOLVER_PARAMS_MAX_SAMPLES = 3;
+  const int RESOLVER_PARAMS_BASE_TIMEOUT_MSEC = 4;
+  const int RESOLVER_PARAMS_RETRY_COUNT = 5;
+  const int RESOLVER_PARAMS_COUNT = 6;
+  const int RESOLVER_STATS_SUCCESSES = 0;
+  const int RESOLVER_STATS_ERRORS = 1;
+  const int RESOLVER_STATS_TIMEOUTS = 2;
+  const int RESOLVER_STATS_INTERNAL_ERRORS = 3;
+  const int RESOLVER_STATS_RTT_AVG = 4;
+  const int RESOLVER_STATS_LAST_SAMPLE_TIME = 5;
+  const int RESOLVER_STATS_USABLE = 6;
+  const int RESOLVER_STATS_COUNT = 7;
+  const int DNS_RESOLVER_LOG_VERBOSE = 0;
+  const int DNS_RESOLVER_LOG_DEBUG = 1;
+  const int DNS_RESOLVER_LOG_INFO = 2;
+  const int DNS_RESOLVER_LOG_WARNING = 3;
+  const int DNS_RESOLVER_LOG_ERROR = 4;
+  const int TC_MODE_DEFAULT = 0;
+  const int TC_MODE_UDP_TCP = 1;
+  const int TRANSPORT_UNKNOWN = -1;
+  const int TRANSPORT_CELLULAR = 0;
+  const int TRANSPORT_WIFI = 1;
+  const int TRANSPORT_BLUETOOTH = 2;
+  const int TRANSPORT_ETHERNET = 3;
+  const int TRANSPORT_VPN = 4;
+  const int TRANSPORT_WIFI_AWARE = 5;
+  const int TRANSPORT_LOWPAN = 6;
+  const int TRANSPORT_TEST = 7;
+}
diff --git a/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverExperimentalOptionsParcel.aidl b/aidl_api/dnsresolver_aidl_interface/4/android/net/ResolverHostsParcel.aidl
similarity index 89%
copy from aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverExperimentalOptionsParcel.aidl
copy to aidl_api/dnsresolver_aidl_interface/4/android/net/ResolverHostsParcel.aidl
index 07a1143..3ab0533 100644
--- a/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverExperimentalOptionsParcel.aidl
+++ b/aidl_api/dnsresolver_aidl_interface/4/android/net/ResolverHostsParcel.aidl
@@ -17,7 +17,7 @@
 
 package android.net;
 /* @hide */
-parcelable ResolverExperimentalOptionsParcel {
-  android.net.ResolverHostsParcel[] hosts = {};
-  int tcMode = 0;
+parcelable ResolverHostsParcel {
+  @utf8InCpp String ipAddr;
+  @utf8InCpp String hostName = "";
 }
diff --git a/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverExperimentalOptionsParcel.aidl b/aidl_api/dnsresolver_aidl_interface/4/android/net/ResolverOptionsParcel.aidl
similarity index 95%
rename from aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverExperimentalOptionsParcel.aidl
rename to aidl_api/dnsresolver_aidl_interface/4/android/net/ResolverOptionsParcel.aidl
index 07a1143..a13216a 100644
--- a/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverExperimentalOptionsParcel.aidl
+++ b/aidl_api/dnsresolver_aidl_interface/4/android/net/ResolverOptionsParcel.aidl
@@ -17,7 +17,7 @@
 
 package android.net;
 /* @hide */
-parcelable ResolverExperimentalOptionsParcel {
+parcelable ResolverOptionsParcel {
   android.net.ResolverHostsParcel[] hosts = {};
   int tcMode = 0;
 }
diff --git a/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverExperimentalOptionsParcel.aidl b/aidl_api/dnsresolver_aidl_interface/4/android/net/ResolverParamsParcel.aidl
similarity index 68%
copy from aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverExperimentalOptionsParcel.aidl
copy to aidl_api/dnsresolver_aidl_interface/4/android/net/ResolverParamsParcel.aidl
index 07a1143..5dae1ca 100644
--- a/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverExperimentalOptionsParcel.aidl
+++ b/aidl_api/dnsresolver_aidl_interface/4/android/net/ResolverParamsParcel.aidl
@@ -17,7 +17,21 @@
 
 package android.net;
 /* @hide */
-parcelable ResolverExperimentalOptionsParcel {
-  android.net.ResolverHostsParcel[] hosts = {};
-  int tcMode = 0;
+parcelable ResolverParamsParcel {
+  int netId;
+  int sampleValiditySeconds;
+  int successThreshold;
+  int minSamples;
+  int maxSamples;
+  int baseTimeoutMsec;
+  int retryCount;
+  @utf8InCpp String[] servers;
+  @utf8InCpp String[] domains;
+  @utf8InCpp String tlsName;
+  @utf8InCpp String[] tlsServers;
+  @utf8InCpp String[] tlsFingerprints = {};
+  @utf8InCpp String caCertificate = "";
+  int tlsConnectTimeoutMs = 0;
+  android.net.ResolverOptionsParcel resolverOptions;
+  int[] transportTypes = {};
 }
diff --git a/aidl_api/dnsresolver_aidl_interface/current/android/net/IDnsResolver.aidl b/aidl_api/dnsresolver_aidl_interface/current/android/net/IDnsResolver.aidl
index 0ebc44f..9eb65de 100644
--- a/aidl_api/dnsresolver_aidl_interface/current/android/net/IDnsResolver.aidl
+++ b/aidl_api/dnsresolver_aidl_interface/current/android/net/IDnsResolver.aidl
@@ -51,5 +51,13 @@
   const int DNS_RESOLVER_LOG_ERROR = 4;
   const int TC_MODE_DEFAULT = 0;
   const int TC_MODE_UDP_TCP = 1;
-  const int TC_MODE_MAX = 2;
+  const int TRANSPORT_UNKNOWN = -1;
+  const int TRANSPORT_CELLULAR = 0;
+  const int TRANSPORT_WIFI = 1;
+  const int TRANSPORT_BLUETOOTH = 2;
+  const int TRANSPORT_ETHERNET = 3;
+  const int TRANSPORT_VPN = 4;
+  const int TRANSPORT_WIFI_AWARE = 5;
+  const int TRANSPORT_LOWPAN = 6;
+  const int TRANSPORT_TEST = 7;
 }
diff --git a/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverExperimentalOptionsParcel.aidl b/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverOptionsParcel.aidl
similarity index 95%
copy from aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverExperimentalOptionsParcel.aidl
copy to aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverOptionsParcel.aidl
index 07a1143..a13216a 100644
--- a/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverExperimentalOptionsParcel.aidl
+++ b/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverOptionsParcel.aidl
@@ -17,7 +17,7 @@
 
 package android.net;
 /* @hide */
-parcelable ResolverExperimentalOptionsParcel {
+parcelable ResolverOptionsParcel {
   android.net.ResolverHostsParcel[] hosts = {};
   int tcMode = 0;
 }
diff --git a/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverParamsParcel.aidl b/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverParamsParcel.aidl
index 8d807be..5dae1ca 100644
--- a/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverParamsParcel.aidl
+++ b/aidl_api/dnsresolver_aidl_interface/current/android/net/ResolverParamsParcel.aidl
@@ -32,5 +32,6 @@
   @utf8InCpp String[] tlsFingerprints = {};
   @utf8InCpp String caCertificate = "";
   int tlsConnectTimeoutMs = 0;
-  android.net.ResolverExperimentalOptionsParcel experimentalOptions;
+  android.net.ResolverOptionsParcel resolverOptions;
+  int[] transportTypes = {};
 }
diff --git a/binder/android/net/IDnsResolver.aidl b/binder/android/net/IDnsResolver.aidl
index c85e5cf..da13d21 100644
--- a/binder/android/net/IDnsResolver.aidl
+++ b/binder/android/net/IDnsResolver.aidl
@@ -172,14 +172,27 @@
     void flushNetworkCache(int netId);
 
     /**
-     * Values for {@code tcMode} of {@code ResolverExperimentalOptionsParcel}. It controls the way DNS
+     * Values for {@code tcMode} of {@code ResolverOptionsParcel}. It controls the way DNS
      * resolver handles truncated DNS response from UDP connection.
      *
      * TC_MODE_DEFAULT: resolver retries on TCP-only on each name server.
      * TC_MODE_UDP_TCP: resolver retries on TCP on the same server, falls back to UDP from next.
-     * TC_MODE_MAX: any value smaller than TC_MODE_DEFAULT or greater than TC_MODE_MAX is invalid.
      */
     const int TC_MODE_DEFAULT = 0;
     const int TC_MODE_UDP_TCP = 1;
-    const int TC_MODE_MAX = 2;
+
+    /**
+     * Values for {@code transportTypes} of {@code ResolverParamsParcel}. These values are
+     * always the same as the TRANSPORT_* API definations of NetworkCapabilities except for
+     * TRANSPORT_UNKNOWN. It controls the transport types for a given network.
+     */
+    const int TRANSPORT_UNKNOWN = -1;
+    const int TRANSPORT_CELLULAR = 0;
+    const int TRANSPORT_WIFI = 1;
+    const int TRANSPORT_BLUETOOTH = 2;
+    const int TRANSPORT_ETHERNET = 3;
+    const int TRANSPORT_VPN = 4;
+    const int TRANSPORT_WIFI_AWARE = 5;
+    const int TRANSPORT_LOWPAN = 6;
+    const int TRANSPORT_TEST = 7;
 }
diff --git a/binder/android/net/ResolverExperimentalOptionsParcel.aidl b/binder/android/net/ResolverOptionsParcel.aidl
similarity index 96%
rename from binder/android/net/ResolverExperimentalOptionsParcel.aidl
rename to binder/android/net/ResolverOptionsParcel.aidl
index f8fd589..8e435de 100644
--- a/binder/android/net/ResolverExperimentalOptionsParcel.aidl
+++ b/binder/android/net/ResolverOptionsParcel.aidl
@@ -23,7 +23,7 @@
  *
  * {@hide}
  */
-parcelable ResolverExperimentalOptionsParcel {
+parcelable ResolverOptionsParcel {
     /**
      * An IP/hostname mapping table for DNS local lookup customization.
      * WARNING: this is intended for local testing and other special situations.
diff --git a/binder/android/net/ResolverParamsParcel.aidl b/binder/android/net/ResolverParamsParcel.aidl
index c42367f..9a8e843 100644
--- a/binder/android/net/ResolverParamsParcel.aidl
+++ b/binder/android/net/ResolverParamsParcel.aidl
@@ -16,7 +16,7 @@
 
 package android.net;
 
-import android.net.ResolverExperimentalOptionsParcel;
+import android.net.ResolverOptionsParcel;
 
 /**
  * Configuration for a resolver parameters.
@@ -101,7 +101,15 @@
     int tlsConnectTimeoutMs = 0;
 
     /**
-    * Knobs for OEM to control alternative behavior.
-    */
-    ResolverExperimentalOptionsParcel experimentalOptions;
+     * Knobs for OEM to control alternative behavior.
+     */
+    ResolverOptionsParcel resolverOptions;
+
+    /**
+     * The transport types associated to a given network.
+     * The valid value is defined in one of the IDnsResolver.TRANSPORT_* constants.
+     * If there are multiple transport types but can't be identified to a
+     * reasonable network type by DnsResolver, it would be considered as unknown.
+     */
+    int[] transportTypes = {};
 }
diff --git a/res_cache.cpp b/res_cache.cpp
index 7c0a65a..43c268e 100644
--- a/res_cache.cpp
+++ b/res_cache.cpp
@@ -49,6 +49,7 @@
 #include <net/if.h>
 #include <netdb.h>
 
+#include <aidl/android/net/IDnsResolver.h>
 #include <android-base/logging.h>
 #include <android-base/parseint.h>
 #include <android-base/stringprintf.h>
@@ -64,6 +65,7 @@
 #include "resolv_private.h"
 #include "util.h"
 
+using aidl::android::net::IDnsResolver;
 using android::base::StringAppendF;
 using android::net::DnsQueryEvent;
 using android::net::DnsStats;
@@ -1002,6 +1004,7 @@
     // If resolverParams.hosts is empty, the existing customized table will be erased.
     HostMapping customizedTable = {};
     int tc_mode = aidl::android::net::IDnsResolver::TC_MODE_DEFAULT;
+    std::vector<int32_t> transportTypes;
 };
 
 /* gets cache associated with a network, or NULL if none exists */
@@ -1510,6 +1513,13 @@
     }
 }
 
+android::net::NetworkType resolv_get_network_types_for_net(unsigned netid) {
+    std::lock_guard guard(cache_mutex);
+    NetConfig* netconfig = find_netconfig_locked(netid);
+    if (netconfig == nullptr) return android::net::NT_UNKNOWN;
+    return convert_network_type(netconfig->transportTypes);
+}
+
 namespace {
 
 // Returns valid domains without duplicates which are limited to max size |MAXDNSRCH|.
@@ -1569,10 +1579,10 @@
     return result;
 }
 
-int resolv_set_nameservers(
-        unsigned netid, const std::vector<std::string>& servers,
-        const std::vector<std::string>& domains, const res_params& params,
-        const aidl::android::net::ResolverExperimentalOptionsParcel& experimentalOptions) {
+int resolv_set_nameservers(unsigned netid, const std::vector<std::string>& servers,
+                           const std::vector<std::string>& domains, const res_params& params,
+                           const aidl::android::net::ResolverOptionsParcel& resolverOptions,
+                           const std::vector<int32_t>& transportTypes) {
     std::vector<std::string> nameservers = filter_nameservers(servers);
     const int numservers = static_cast<int>(nameservers.size());
 
@@ -1626,17 +1636,20 @@
         return -EINVAL;
     }
     netconfig->customizedTable.clear();
-    for (const auto& host : experimentalOptions.hosts) {
+    for (const auto& host : resolverOptions.hosts) {
         if (!host.hostName.empty() && !host.ipAddr.empty())
             netconfig->customizedTable.emplace(host.hostName, host.ipAddr);
     }
 
-    if (experimentalOptions.tcMode < aidl::android::net::IDnsResolver::TC_MODE_DEFAULT ||
-        experimentalOptions.tcMode >= aidl::android::net::IDnsResolver::TC_MODE_MAX) {
-        LOG(WARNING) << __func__ << ": netid = " << netid << ", invalid TC mode";
+    if (resolverOptions.tcMode < aidl::android::net::IDnsResolver::TC_MODE_DEFAULT ||
+        resolverOptions.tcMode > aidl::android::net::IDnsResolver::TC_MODE_UDP_TCP) {
+        LOG(WARNING) << __func__ << ": netid = " << netid
+                     << ", invalid TC mode: " << resolverOptions.tcMode;
         return -EINVAL;
     }
-    netconfig->tc_mode = experimentalOptions.tcMode;
+    netconfig->tc_mode = resolverOptions.tcMode;
+
+    netconfig->transportTypes = transportTypes;
 
     return 0;
 }
@@ -1892,22 +1905,7 @@
     return false;
 }
 
-void resolv_stats_dump(DumpWriter& dw, unsigned netid) {
-    std::lock_guard guard(cache_mutex);
-    if (const auto info = find_netconfig_locked(netid); info != nullptr) {
-        info->dnsStats.dump(dw);
-    }
-}
-
-void resolv_oem_options_dump(DumpWriter& dw, unsigned netid) {
-    std::lock_guard guard(cache_mutex);
-    if (const auto info = find_netconfig_locked(netid); info != nullptr) {
-        // TODO: dump info->hosts
-        dw.println("TC mode: %s", tc_mode_to_str(info->tc_mode));
-    }
-}
-
-const char* tc_mode_to_str(const int mode) {
+static const char* tc_mode_to_str(const int mode) {
     switch (mode) {
         case aidl::android::net::IDnsResolver::TC_MODE_DEFAULT:
             return "default";
@@ -1917,3 +1915,95 @@
             return "unknown";
     }
 }
+
+static android::net::NetworkType to_stats_network_type(int32_t mainType, bool withVpn) {
+    switch (mainType) {
+        case IDnsResolver::TRANSPORT_CELLULAR:
+            return withVpn ? android::net::NT_CELLULAR_VPN : android::net::NT_CELLULAR;
+        case IDnsResolver::TRANSPORT_WIFI:
+            return withVpn ? android::net::NT_WIFI_VPN : android::net::NT_WIFI;
+        case IDnsResolver::TRANSPORT_BLUETOOTH:
+            return withVpn ? android::net::NT_BLUETOOTH_VPN : android::net::NT_BLUETOOTH;
+        case IDnsResolver::TRANSPORT_ETHERNET:
+            return withVpn ? android::net::NT_ETHERNET_VPN : android::net::NT_ETHERNET;
+        case IDnsResolver::TRANSPORT_VPN:
+            return withVpn ? android::net::NT_UNKNOWN : android::net::NT_VPN;
+        case IDnsResolver::TRANSPORT_WIFI_AWARE:
+            return withVpn ? android::net::NT_UNKNOWN : android::net::NT_WIFI_AWARE;
+        case IDnsResolver::TRANSPORT_LOWPAN:
+            return withVpn ? android::net::NT_UNKNOWN : android::net::NT_LOWPAN;
+        default:
+            return android::net::NT_UNKNOWN;
+    }
+}
+
+android::net::NetworkType convert_network_type(const std::vector<int32_t>& transportTypes) {
+    // The valid transportTypes size is 1 to 3.
+    if (transportTypes.size() > 3 || transportTypes.size() == 0) return android::net::NT_UNKNOWN;
+    // TransportTypes size == 1, map the type to stats network type directly.
+    if (transportTypes.size() == 1) return to_stats_network_type(transportTypes[0], false);
+    // TransportTypes size == 3, only cellular + wifi + vpn is valid.
+    if (transportTypes.size() == 3) {
+        std::vector<int32_t> sortedTransTypes = transportTypes;
+        std::sort(sortedTransTypes.begin(), sortedTransTypes.end());
+        if (sortedTransTypes != std::vector<int32_t>{IDnsResolver::TRANSPORT_CELLULAR,
+                                                     IDnsResolver::TRANSPORT_WIFI,
+                                                     IDnsResolver::TRANSPORT_VPN}) {
+            return android::net::NT_UNKNOWN;
+        }
+        return android::net::NT_WIFI_CELLULAR_VPN;
+    }
+    // TransportTypes size == 2, it shoud be 1 main type + vpn type.
+    // Otherwise, consider it as UNKNOWN.
+    bool hasVpn = false;
+    int32_t mainType = IDnsResolver::TRANSPORT_UNKNOWN;
+    for (const auto& transportType : transportTypes) {
+        if (transportType == IDnsResolver::TRANSPORT_VPN) {
+            hasVpn = true;
+            continue;
+        }
+        mainType = transportType;
+    }
+    return hasVpn ? to_stats_network_type(mainType, true) : android::net::NT_UNKNOWN;
+}
+
+static const char* transport_type_to_str(const std::vector<int32_t>& transportTypes) {
+    switch (convert_network_type(transportTypes)) {
+        case android::net::NT_CELLULAR:
+            return "CELLULAR";
+        case android::net::NT_WIFI:
+            return "WIFI";
+        case android::net::NT_BLUETOOTH:
+            return "BLUETOOTH";
+        case android::net::NT_ETHERNET:
+            return "ETHERNET";
+        case android::net::NT_VPN:
+            return "VPN";
+        case android::net::NT_WIFI_AWARE:
+            return "WIFI_AWARE";
+        case android::net::NT_LOWPAN:
+            return "LOWPAN";
+        case android::net::NT_CELLULAR_VPN:
+            return "CELLULAR_VPN";
+        case android::net::NT_WIFI_VPN:
+            return "WIFI_VPN";
+        case android::net::NT_BLUETOOTH_VPN:
+            return "BLUETOOTH_VPN";
+        case android::net::NT_ETHERNET_VPN:
+            return "ETHERNET_VPN";
+        case android::net::NT_WIFI_CELLULAR_VPN:
+            return "WIFI_CELLULAR_VPN";
+        default:
+            return "UNKNOWN";
+    }
+}
+
+void resolv_netconfig_dump(DumpWriter& dw, unsigned netid) {
+    std::lock_guard guard(cache_mutex);
+    if (const auto info = find_netconfig_locked(netid); info != nullptr) {
+        info->dnsStats.dump(dw);
+        // TODO: dump info->hosts
+        dw.println("TC mode: %s", tc_mode_to_str(info->tc_mode));
+        dw.println("TransportType: %s", transport_type_to_str(info->transportTypes));
+    }
+}
diff --git a/resolv_cache.h b/resolv_cache.h
index dd7ede1..49c7f56 100644
--- a/resolv_cache.h
+++ b/resolv_cache.h
@@ -32,7 +32,7 @@
 #include <vector>
 
 #include <aidl/android/net/IDnsResolver.h>
-#include <aidl/android/net/ResolverExperimentalOptionsParcel.h>
+#include <aidl/android/net/ResolverOptionsParcel.h>
 
 #include <netdutils/DumpWriter.h>
 #include <netdutils/InternetAddresses.h>
@@ -80,11 +80,12 @@
 
 // Sets name servers for a given network.
 // TODO: Pass all of ResolverParamsParcel and remove the res_params argument.
-int resolv_set_nameservers(
-        unsigned netid, const std::vector<std::string>& servers,
-        const std::vector<std::string>& domains, const res_params& params,
-        const aidl::android::net::ResolverExperimentalOptionsParcel& experimentalOptions = {
-                {} /* hosts */, aidl::android::net::IDnsResolver::TC_MODE_DEFAULT});
+int resolv_set_nameservers(unsigned netid, const std::vector<std::string>& servers,
+                           const std::vector<std::string>& domains, const res_params& params,
+                           const aidl::android::net::ResolverOptionsParcel& resolverOptions =
+                                   {{} /* hosts */,
+                                    aidl::android::net::IDnsResolver::TC_MODE_DEFAULT},
+                           const std::vector<int32_t>& transportTypes = {});
 
 // Creates the cache associated with the given network.
 int resolv_create_cache_for_net(unsigned netid);
@@ -95,6 +96,9 @@
 // Flushes the cache associated with the given network.
 int resolv_flush_cache_for_net(unsigned netid);
 
+// Get transport types to a given network.
+android::net::NetworkType resolv_get_network_types_for_net(unsigned netid);
+
 // For test only.
 // Return true if the cache is existent in the given network, false otherwise.
 bool has_named_cache(unsigned netid);
@@ -111,12 +115,6 @@
 bool resolv_stats_add(unsigned netid, const android::netdutils::IPSockAddr& server,
                       const android::net::DnsQueryEvent* record);
 
-void resolv_stats_dump(android::netdutils::DumpWriter& dw, unsigned netid);
-
-void resolv_oem_options_dump(android::netdutils::DumpWriter& dw, unsigned netid);
-
-const char* tc_mode_to_str(const int mode);
-
 /* Retrieve a local copy of the stats for the given netid. The buffer must have space for
  * MAXNS __resolver_stats. Returns the revision id of the resolvers used.
  */
@@ -130,3 +128,9 @@
 void resolv_cache_add_resolver_stats_sample(unsigned netid, int revision_id,
                                             const android::netdutils::IPSockAddr& serverSockAddr,
                                             const res_sample& sample, int max_samples);
+
+// Convert TRANSPORT_* to NT_*. It's public only for unit testing.
+android::net::NetworkType convert_network_type(const std::vector<int32_t>& transportTypes);
+
+// Dump net configuration log for a given network.
+void resolv_netconfig_dump(android::netdutils::DumpWriter& dw, unsigned netid);
diff --git a/resolv_cache_unit_test.cpp b/resolv_cache_unit_test.cpp
index 4a29258..6e7ffee 100644
--- a/resolv_cache_unit_test.cpp
+++ b/resolv_cache_unit_test.cpp
@@ -22,6 +22,7 @@
 #include <ctime>
 #include <thread>
 
+#include <aidl/android/net/IDnsResolver.h>
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <android/multinetwork.h>
@@ -38,6 +39,7 @@
 
 using namespace std::chrono_literals;
 
+using aidl::android::net::IDnsResolver;
 using android::netdutils::IPSockAddr;
 
 constexpr int TEST_NETID = 30;
@@ -59,6 +61,8 @@
     std::vector<std::string> servers;
     std::vector<std::string> domains;
     res_params params;
+    aidl::android::net::ResolverOptionsParcel resolverOptions;
+    std::vector<int32_t> transportTypes;
 };
 
 struct CacheStats {
@@ -189,7 +193,8 @@
     }
 
     int cacheSetupResolver(uint32_t netId, const SetupParams& setup) {
-        return resolv_set_nameservers(netId, setup.servers, setup.domains, setup.params);
+        return resolv_set_nameservers(netId, setup.servers, setup.domains, setup.params,
+                                      setup.resolverOptions, setup.transportTypes);
     }
 
     void cacheAddStats(uint32_t netId, int revision_id, const IPSockAddr& ipsa,
@@ -834,6 +839,64 @@
     EXPECT_STREQ(answer, domain_name);
 }
 
+TEST_F(ResolvCacheTest, GetNetworkTypesForNet) {
+    const SetupParams setup = {
+            .servers = {"127.0.0.1", "::127.0.0.2", "fe80::3"},
+            .domains = {"domain1.com", "domain2.com"},
+            .params = kParams,
+            .transportTypes = {IDnsResolver::TRANSPORT_WIFI, IDnsResolver::TRANSPORT_VPN}};
+    EXPECT_EQ(0, cacheCreate(TEST_NETID));
+    EXPECT_EQ(0, cacheSetupResolver(TEST_NETID, setup));
+    EXPECT_EQ(android::net::NT_WIFI_VPN, resolv_get_network_types_for_net(TEST_NETID));
+}
+
+TEST_F(ResolvCacheTest, ConvertTransportsToNetworkType) {
+    static const struct TestConfig {
+        int32_t networkType;
+        std::vector<int32_t> transportTypes;
+    } testConfigs[] = {
+            {android::net::NT_CELLULAR, {IDnsResolver::TRANSPORT_CELLULAR}},
+            {android::net::NT_WIFI, {IDnsResolver::TRANSPORT_WIFI}},
+            {android::net::NT_BLUETOOTH, {IDnsResolver::TRANSPORT_BLUETOOTH}},
+            {android::net::NT_ETHERNET, {IDnsResolver::TRANSPORT_ETHERNET}},
+            {android::net::NT_VPN, {IDnsResolver::TRANSPORT_VPN}},
+            {android::net::NT_WIFI_AWARE, {IDnsResolver::TRANSPORT_WIFI_AWARE}},
+            {android::net::NT_LOWPAN, {IDnsResolver::TRANSPORT_LOWPAN}},
+            {android::net::NT_CELLULAR_VPN,
+             {IDnsResolver::TRANSPORT_CELLULAR, IDnsResolver::TRANSPORT_VPN}},
+            {android::net::NT_CELLULAR_VPN,
+             {IDnsResolver::TRANSPORT_VPN, IDnsResolver::TRANSPORT_CELLULAR}},
+            {android::net::NT_WIFI_VPN,
+             {IDnsResolver::TRANSPORT_WIFI, IDnsResolver::TRANSPORT_VPN}},
+            {android::net::NT_WIFI_VPN,
+             {IDnsResolver::TRANSPORT_VPN, IDnsResolver::TRANSPORT_WIFI}},
+            {android::net::NT_BLUETOOTH_VPN,
+             {IDnsResolver::TRANSPORT_BLUETOOTH, IDnsResolver::TRANSPORT_VPN}},
+            {android::net::NT_BLUETOOTH_VPN,
+             {IDnsResolver::TRANSPORT_VPN, IDnsResolver::TRANSPORT_BLUETOOTH}},
+            {android::net::NT_ETHERNET_VPN,
+             {IDnsResolver::TRANSPORT_ETHERNET, IDnsResolver::TRANSPORT_VPN}},
+            {android::net::NT_ETHERNET_VPN,
+             {IDnsResolver::TRANSPORT_VPN, IDnsResolver::TRANSPORT_ETHERNET}},
+            {android::net::NT_UNKNOWN, {IDnsResolver::TRANSPORT_VPN, IDnsResolver::TRANSPORT_VPN}},
+            {android::net::NT_UNKNOWN,
+             {IDnsResolver::TRANSPORT_WIFI, IDnsResolver::TRANSPORT_LOWPAN}},
+            {android::net::NT_UNKNOWN, {}},
+            {android::net::NT_UNKNOWN,
+             {IDnsResolver::TRANSPORT_CELLULAR, IDnsResolver::TRANSPORT_BLUETOOTH,
+              IDnsResolver::TRANSPORT_VPN}},
+            {android::net::NT_WIFI_CELLULAR_VPN,
+             {IDnsResolver::TRANSPORT_CELLULAR, IDnsResolver::TRANSPORT_WIFI,
+              IDnsResolver::TRANSPORT_VPN}},
+            {android::net::NT_WIFI_CELLULAR_VPN,
+             {IDnsResolver::TRANSPORT_VPN, IDnsResolver::TRANSPORT_WIFI,
+              IDnsResolver::TRANSPORT_CELLULAR}},
+    };
+    for (const auto& config : testConfigs) {
+        EXPECT_EQ(config.networkType, convert_network_type(config.transportTypes));
+    }
+}
+
 namespace {
 
 constexpr int EAI_OK = 0;
diff --git a/stats.proto b/stats.proto
index abca793..403a008 100644
--- a/stats.proto
+++ b/stats.proto
@@ -63,6 +63,13 @@
     NS_R_NOTAUTH = 9;   // Not authoritative for zone
     NS_R_NOTZONE = 10;  // Zone of record different from zone section
     NS_R_MAX = 11;
+    // Define rcode=12~15(UNASSIGNED) in rcode enum type.
+    // Some DNS Servers might return undefined code to devices.
+    // Without the enum definition, that would be noise for our dashboard.
+    NS_R_UNASSIGNED12 = 12; // Unassigned
+    NS_R_UNASSIGNED13 = 13; // Unassigned
+    NS_R_UNASSIGNED14 = 14; // Unassigned
+    NS_R_UNASSIGNED15 = 15; // Unassigned
     // The following are EDNS extended rcodes
     NS_R_BADVERS = 16;
     // The following are TSIG errors
@@ -185,6 +192,8 @@
     NT_BLUETOOTH_VPN = 10;
     // Indicates this network uses an Ethernet+VPN transport.
     NT_ETHERNET_VPN = 11;
+    // Indicates this network uses a Wi-Fi+Cellular+VPN transport.
+    NT_WIFI_CELLULAR_VPN = 12;
 }
 
 enum CacheStatus{
diff --git a/tests/dns_responder/Android.bp b/tests/dns_responder/Android.bp
index b67bcee..a7ef021 100644
--- a/tests/dns_responder/Android.bp
+++ b/tests/dns_responder/Android.bp
@@ -1,14 +1,19 @@
 // TODO: Remove libnetd_test_dnsresponder after eliminating all users.
-cc_library_static {
+cc_test_library {
     name: "libnetd_test_dnsresponder",
     defaults: ["netd_defaults", "resolv_test_defaults"],
     shared_libs: [
-        "dnsresolver_aidl_interface-unstable-cpp",
         "libbinder",
         "libnetd_client",
+    ],
+    static_libs: [
+        "dnsresolver_aidl_interface-unstable-cpp",
+        "libcrypto_static",
         "libnetdutils",
         "libssl",
+        "libutils",
         "netd_aidl_interface-cpp",
+        "netd_event_listener_interface-cpp",
     ],
     srcs: [
         "dns_responder.cpp",
@@ -18,7 +23,7 @@
     export_include_dirs: ["."],
 }
 
-cc_library {
+cc_test_library {
     name: "libnetd_test_dnsresponder_ndk",
     defaults: ["netd_defaults", "resolv_test_defaults"],
     shared_libs: [
@@ -37,8 +42,8 @@
         "libcrypto_static",
         "libnetdutils",
         "libssl",
-        "netd_event_listener_interface-ndk_platform",
         "netd_aidl_interface-ndk_platform",
+        "netd_event_listener_interface-ndk_platform",
     ],
     srcs: [
         "dns_responder.cpp",
diff --git a/tests/dnsresolver_binder_test.cpp b/tests/dnsresolver_binder_test.cpp
index 1c6527f..6fb73f3 100644
--- a/tests/dnsresolver_binder_test.cpp
+++ b/tests/dnsresolver_binder_test.cpp
@@ -24,6 +24,7 @@
 #include <vector>
 
 #include <aidl/android/net/IDnsResolver.h>
+#include <android-base/file.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 #include <android/binder_manager.h>
@@ -245,6 +246,37 @@
     }
 }
 
+TEST_F(DnsResolverBinderTest, SetResolverConfiguration_TransportTypes) {
+    using ::testing::HasSubstr;
+    auto resolverParams = DnsResponderClient::GetDefaultResolverParamsParcel();
+    resolverParams.transportTypes = {IDnsResolver::TRANSPORT_WIFI, IDnsResolver::TRANSPORT_VPN};
+    ::ndk::ScopedAStatus status = mDnsResolver->setResolverConfiguration(resolverParams);
+    EXPECT_TRUE(status.isOk()) << status.getMessage();
+    // TODO: Find a way to fix a potential deadlock here if it's larger than pipe buffer
+    // size(65535).
+    android::base::unique_fd writeFd, readFd;
+    EXPECT_TRUE(Pipe(&readFd, &writeFd));
+    EXPECT_EQ(mDnsResolver->dump(writeFd.get(), nullptr, 0), 0);
+    writeFd.reset();
+    std::string str;
+    ASSERT_TRUE(ReadFdToString(readFd, &str)) << strerror(errno);
+    EXPECT_THAT(str, HasSubstr("WIFI_VPN"));
+}
+
+TEST_F(DnsResolverBinderTest, SetResolverConfiguration_TransportTypes_Default) {
+    using ::testing::HasSubstr;
+    auto resolverParams = DnsResponderClient::GetDefaultResolverParamsParcel();
+    ::ndk::ScopedAStatus status = mDnsResolver->setResolverConfiguration(resolverParams);
+    EXPECT_TRUE(status.isOk()) << status.getMessage();
+    android::base::unique_fd writeFd, readFd;
+    EXPECT_TRUE(Pipe(&readFd, &writeFd));
+    EXPECT_EQ(mDnsResolver->dump(writeFd.get(), nullptr, 0), 0);
+    writeFd.reset();
+    std::string str;
+    ASSERT_TRUE(ReadFdToString(readFd, &str)) << strerror(errno);
+    EXPECT_THAT(str, HasSubstr("UNKNOWN"));
+}
+
 TEST_F(DnsResolverBinderTest, GetResolverInfo) {
     std::vector<std::string> servers = {"127.0.0.1", "127.0.0.2"};
     std::vector<std::string> domains = {"example.com"};
diff --git a/tests/resolv_integration_test.cpp b/tests/resolv_integration_test.cpp
index 9dda0f1..270f040 100644
--- a/tests/resolv_integration_test.cpp
+++ b/tests/resolv_integration_test.cpp
@@ -1087,7 +1087,7 @@
     test::DNSResponder dns;
     StartDns(dns, {});
     auto resolverParams = DnsResponderClient::GetDefaultResolverParamsParcel();
-    resolverParams.experimentalOptions.hosts = invalidCustHosts;
+    resolverParams.resolverOptions.hosts = invalidCustHosts;
     ASSERT_TRUE(mDnsClient.resolvService()->setResolverConfiguration(resolverParams).isOk());
     for (const auto& hostname : {hostnameNoip, hostnameInvalidip}) {
         // The query won't get data from customized table because of invalid customized table
@@ -1162,7 +1162,7 @@
         StartDns(dns, config.dnsserverHosts);
 
         auto resolverParams = DnsResponderClient::GetDefaultResolverParamsParcel();
-        resolverParams.experimentalOptions.hosts = config.customizedHosts;
+        resolverParams.resolverOptions.hosts = config.customizedHosts;
         ASSERT_TRUE(mDnsClient.resolvService()->setResolverConfiguration(resolverParams).isOk());
         const addrinfo hints = {.ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM};
         ScopedAddrinfo result = safe_getaddrinfo(config.name.c_str(), nullptr, &hints);
@@ -1198,7 +1198,7 @@
     StartDns(dns, dnsSvHostV4V6);
     auto resolverParams = DnsResponderClient::GetDefaultResolverParamsParcel();
 
-    resolverParams.experimentalOptions.hosts = custHostV4V6;
+    resolverParams.resolverOptions.hosts = custHostV4V6;
     ASSERT_TRUE(mDnsClient.resolvService()->setResolverConfiguration(resolverParams).isOk());
     const addrinfo hints = {.ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM};
     ScopedAddrinfo result = safe_getaddrinfo(hostnameV4V6, nullptr, &hints);
@@ -1206,7 +1206,7 @@
     EXPECT_THAT(ToStrings(result), testing::UnorderedElementsAreArray({custAddrV4, custAddrV6}));
     EXPECT_EQ(0U, GetNumQueries(dns, hostnameV4V6));
 
-    resolverParams.experimentalOptions.hosts = {};
+    resolverParams.resolverOptions.hosts = {};
     ASSERT_TRUE(mDnsClient.resolvService()->setResolverConfiguration(resolverParams).isOk());
     result = safe_getaddrinfo(hostnameV4V6, nullptr, &hints);
     ASSERT_TRUE(result != nullptr);
@@ -4139,7 +4139,7 @@
         ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
         parcel.servers = {listen_addr, listen_addr2};
         if (config.tcMode) {
-            parcel.experimentalOptions.tcMode = config.tcMode.value();
+            parcel.resolverOptions.tcMode = config.tcMode.value();
         }
         ASSERT_EQ(mDnsClient.resolvService()->setResolverConfiguration(parcel).isOk(), config.ret);