Merge "UpstreamNetworkMonitor: remove unused mTetheringUpstreamNetwork"
diff --git a/Cronet/Android.bp b/Cronet/Android.bp
deleted file mode 100644
index 3ce88ef..0000000
--- a/Cronet/Android.bp
+++ /dev/null
@@ -1,106 +0,0 @@
-// Copyright (C) 2019 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package {
- default_applicable_licenses: ["Android-Apache-2.0"],
-}
-
-java_import {
- name: "cronet_impl_native_java",
- jars: ["prebuilt/cronet_impl_native_java.jar"],
- visibility: ["//visibility:private"],
- apex_available: ["com.android.tethering"],
- min_sdk_version: "29",
-}
-
-java_import {
- name: "cronet_impl_common_java",
- jars: ["prebuilt/cronet_impl_common_java.jar"],
- visibility: ["//visibility:private"],
- apex_available: ["com.android.tethering"],
- min_sdk_version: "29",
-}
-
-java_import {
- name: "cronet_impl_platform_java",
- jars: ["prebuilt/cronet_impl_platform_java.jar"],
- visibility: ["//visibility:private"],
- apex_available: ["com.android.tethering"],
- min_sdk_version: "29",
-}
-
-cc_prebuilt_library_shared {
- name: "libcronet.107.0.5284.2",
- shared_libs: [
- "libandroid",
- "libc",
- "libdl",
- "liblog",
- "libm",
- ],
- stl: "libc++_static",
- target: {
- android_arm64: {
- srcs: ["prebuilt/libs/arm64-v8a/libcronet.107.0.5284.2.so"],
- },
- android_arm: {
- srcs: ["prebuilt/libs/armeabi-v7a/libcronet.107.0.5284.2.so"],
- },
- android_x86_64: {
- srcs: ["prebuilt/libs/x86_64/libcronet.107.0.5284.2.so"],
- },
- android_x86: {
- srcs: ["prebuilt/libs/x86/libcronet.107.0.5284.2.so"],
- },
- },
- // These are already stripped, and restripping them just issues diagnostics.
- strip: {
- none: true,
- },
- apex_available: ["com.android.tethering"],
- min_sdk_version: "29",
-}
-
-genrule {
- name: "cronet_api-src",
- srcs: ["prebuilt/cronet_api-src.jar"],
- cmd: "cp $(in) $(out)",
- out: [
- "cronet_api-src.srcjar",
- ],
-}
-
-java_sdk_library {
- name: "framework-cronet",
- defaults: ["framework-module-defaults"],
- srcs: [
- ":cronet_api-src",
- ],
- libs: [
- "androidx.annotation_annotation",
- ],
- static_libs: [
- "androidx.core_core-nodeps",
- "cronet_impl_common_java",
- "cronet_impl_native_java",
- "cronet_impl_platform_java",
- ],
- apex_available: ["com.android.tethering"],
- jarjar_rules: "jarjar-rules.txt",
- unsafe_ignore_missing_latest_api: true,
- dist_group: "android",
- // cronet is used as a shared library.
- shared_library: true,
- exclude_kotlinc_generated_files: true,
-}
diff --git a/Cronet/AndroidManifest.xml b/Cronet/AndroidManifest.xml
deleted file mode 100644
index c6471ed..0000000
--- a/Cronet/AndroidManifest.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
--->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
- package="com.android.net.http"
- android:versionCode="11"
- android:versionName="R-initial">
-</manifest>
diff --git a/Cronet/TEST_MAPPING b/Cronet/TEST_MAPPING
deleted file mode 100644
index b1f3088..0000000
--- a/Cronet/TEST_MAPPING
+++ /dev/null
@@ -1,7 +0,0 @@
-{
- "presubmit": [
- {
- "name": "CtsCronetTestCases"
- }
- ]
-}
diff --git a/Cronet/apex/Android.bp b/Cronet/apex/Android.bp
deleted file mode 100644
index 180dafb..0000000
--- a/Cronet/apex/Android.bp
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (C) 2019 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package {
- default_applicable_licenses: ["Android-Apache-2.0"],
-}
-
-// CronetApexDefaults uses apex_defaults cronet_apex_defaults specifies. cronet_apex_defaults
-// could be "CronetApexDefaultsEnabled" or "CronetApexDefaultsDisabled" depending on the branch.
-cronet_apex_defaults = "CronetApexDefaultsEnabled"
-// This is a placeholder comment to avoid merge conflicts
-// as cronet_apex_defaults may have different values
-// depending on the branch
-
-apex_defaults {
- name: "CronetApexDefaults",
- defaults: [cronet_apex_defaults],
-}
-
-apex_defaults {
- name: "CronetApexDefaultsEnabled",
- jni_libs: ["libcronet.107.0.5284.2"],
- java_libs: ["framework-cronet"],
- arch: {
- riscv64: {
- // TODO: remove this when there is a riscv64 libcronet
- exclude_jni_libs: ["libcronet.107.0.5284.2"],
- },
- },
-}
-
-apex_defaults {
- name: "CronetApexDefaultsDisabled",
-}
-
-// TODO: Remove cronet apex after com.android.cronet is removed from PRODUCT_PACKAGES
-apex {
- name: "com.android.cronet",
- key: "com.android.cronet.key",
- updatable: false,
- manifest: "manifest.json",
-}
-
-apex_key {
- name: "com.android.cronet.key",
- public_key: "com.android.cronet.avbpubkey",
- private_key: "com.android.cronet.pem",
-}
diff --git a/Cronet/apex/AndroidManifest.xml b/Cronet/apex/AndroidManifest.xml
deleted file mode 100644
index 650badc..0000000
--- a/Cronet/apex/AndroidManifest.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
- package="com.android.cronet">
- <!-- APEX does not have classes.dex -->
- <application android:hasCode="false" />
- <uses-sdk
- android:minSdkVersion="29"
- />
-</manifest>
diff --git a/Cronet/apex/com.android.cronet.avbpubkey b/Cronet/apex/com.android.cronet.avbpubkey
deleted file mode 100644
index 38aebe0..0000000
--- a/Cronet/apex/com.android.cronet.avbpubkey
+++ /dev/null
Binary files differ
diff --git a/Cronet/apex/com.android.cronet.pem b/Cronet/apex/com.android.cronet.pem
deleted file mode 100644
index 438653f..0000000
--- a/Cronet/apex/com.android.cronet.pem
+++ /dev/null
@@ -1,51 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIJKAIBAAKCAgEAqpxkMMK57w+fzxLcwF+mEQEbKrDFWXYHL697tv8DBu/aL2tM
-LRHiKFdov0Fsnup++bd9oojI+6qyAyJh4I8nvzKc4onM0eXL++0FPZuiTv6a6r7K
-wyn+NVT2X/0yr2Hs5NL1rKXFmJPAfMoRCW9vQdi5xMlM9QN8mNaqSWddKtrQM3yC
-HDLy2zZd7MlQ1UTnmDqGCG0AVtuM34X0v1o0wAL7UwNdzOARtmnuWzcL5vBwAJg8
-eXFZH5Pt5rITxbU+eYw/V+/sUYyI0Anrj4GG+oyWQxgdxz+FwdpSAt14xtw5IDl7
-pTYqEIm+TQKnWe6NzVWfI89s2nh85hgOSgugfpS4symbfbZd4qNSOcHGQTB1ssvf
-vdYGF1WRFA20VEEOMzTMYsvcfModKNVCpibzHu/SYDIJGL0JyJWu2eIE+mrn3lLD
-nwDZ2P39YyVNpritEkbk5qugaLh9mIFqAD4L4niYLu/AtYq+CXzd7yroM2ycleRq
-JRNsCIUx3A/Z5vKx7IJaMb7Pwap3DAe3u3/2L9NCL6oo074Rf7fh5xkDF4Dua3Gg
-kPw+k183jAQECHORstdVlgVZlMxPif4lxQ8uCHJWxyDsgShPgzMtEjJyrJJQyDon
-X8pN4xqb+WX30XNYBK5sp7x6mc8w4rdAGExhUSdmTS0J/lcfar6A6/j/yg8CAwEA
-AQKCAgAiYafTJ7q+kWB8I2n3Ho9hx95IqRzsHVvvYSbGRve+MyG+App0TrFLvemu
-+SlBkTILcs3Prk8KYGjFNu2QimjRIAr7oBd1iSClYSt4Md/wmWBwxAgqclD3QGry
-Bx1quIo7xsOZikKar9PPkg0C4MED/P/ax1JJ4ez/A+uHJVxiIXxpk8LImf/U60zc
-RemTQPKG++w80HKMDmyCMwWSdkRBGZi6Luh9O/51yz0shphQbs2zYPp24r+6HF6J
-6gMQCalQZ1Hwj7oI6RA9FHKzFcA0x5YUaUy+9W8oFK4IQ8duE70zYEIplhO+B3Qh
-ItLEzc0nvwR1+/wMvtE0sU5X36X06AFhkcpjyAdmNVMiG91KGrZqruOufrOQu4VE
-njJ5VEUvWOr+6inZDWIdT3NQvwJCZkT4Vvn9WBAoKM8pkpfhY5HTGq4ttX7McHjF
-p7YBFbHRpzO+OfSwM7f/xq2WLcjOKgsFgv17CUo7KQo1rqWPD/4IKJKW5n6dzDwX
-RRF4dehUMYK2UNAbcN9S8O8nJGcJfb76FExjZtGLrhlDgawLmu71bbq5afot/IQ9
-JuB4KxG59t2JAHGNgM7WfFvcL1Zp1D+kzDEHYKYkyDJh3qB7Tw+StlAQFSQjNBX/
-c1I6DUl68rSHOc2LF4oK8ID1oe/URMg2YoaLlF8un2nGZBfwGQKCAQEA20Ie5hBC
-H8W1vTtyI4jOdn/h11RL8UuLN0xtXYunYCzD4+gAEKsAShbhKnvINThZaoxQ2sxy
-9EB+2Ob8R9muYAxR4Eu4tDBWedYmJEl74MflLMFnIrtFIKy4F54zk7J6uNG3cHRo
-yTpoIcmK101xzz1Ed9Dd0XL6rpegnWIuVlWV4slGAf1l3h6pycfx+HCYcCboz6Nq
-JMA0ioKY0fgz5q+mb7IIObN8JjGdLeBQtNh3fcXby08AT/03psKhjgBsbuyTs7s7
-E3n+jxJ3p4xHP/psU3D/HgKWewp48AJNHY8MLY+Kp0KNoQMSQKHKqsiluGTCKLTJ
-sCWg/2c8xf728wKCAQEAxzNdZ54e6WXexMMIsGoH+wVknTHiizuxN4ZqzY/nCM0M
-9heooChfMAFrq8XMC/6MXgiy5rBhl3H12HlG4S6cq3J07MsMR0N+sUFEobuZURB4
-+CbEBebmXx1kymC6FrRG4JuKZWbQ8AKpfd28QO7x915safeq6FA8cILJn4oqBGqQ
-Y8TzMKtuaCzQGoBjSgiMpx1fo9Stl7+dpGiPNsnQEG+SEsXxKoZweJPsuK8G+ZgB
-8YARajLwFfgfsCNp/8fXjA98BYM8eSxURa7USUyCmY4hU3WIGG5qc0/C69Fl35ex
-YZG7XQo1DxW/+gWsdUbAFbI4y+iJ8SRpsFxtFYifdQKCAQA5DiW4PHbYibxXN8bl
-1E3VrEV6oSb57WyWwT6cXyD49+0pu095BuaWYQnK4lcg8j7iaQ0JQraPNNFNZB42
-HEEyIUKVGV9BFGsMXVujibPAtIPAd7t84DqG3Csziillv8YLnhccHk6+PoKmeCm3
-CSIaiZjtjN6MCF2PXUmgatIgCTltwG6FSgleGaCZL3yZ58LjPFzM23tdgN6rRHy7
-9tiaqQ6odi2JxlkCH1sFex/FT6cYhYpCh5ZPOldm/7LGnvmYi9uLo6cl1FMXq/iT
-Ev/feC0EMZ1Rk97QudLqsc6baIQEvxuXlswAICp5wyBX/MqTBzU3HoR1X/VbQOQh
-qc1dAoIBACLjNhqtsNBDzS480krDZz5phWOalwi3naQR4Ka760S5VOnM3vWd3H31
-4bul2sTHAiJ994c7oPv7M4mERAuwNDQ6yYunTDE2+vtkaPbCemmeLvGXKIG4HOTP
-qxVet3i+fiNcWnLD/Rfr/29R5GSi9LHUUbyFaeNiGhPCdDmC4zT+zOcMWWNOwvlv
-z8q0ba9LrAaguF1jJDwNjTh8L4jy84PNZpHvJPvDq/MSRUVbMieInd6EBYjJ/w55
-9GLO8QOhJnkbRSdaAr9eKixCIF/uDHmEUQXi8cEFpZMohwTyGZt9X82szlnPLdfE
-gWjykW/AwmeKXTQpN++J5xDCP0CkOvkCggEBAND4wviHue/+bqY9R5EAIDIZn6kx
-VCK9roebvGjq/Az5AM7IiyUQRANv+6CmeIlXCRBMbaAtgQxhvW5UodA1livgVuzR
-ElF7Br3wfikZ34oWY0Qu8fZI0ru4syAoTiGpaUPJJgStYi76dqne15usTRk/MvwP
-tJzqpkWUYcmNv3g/w92Wr1nIJYXlPKrANSSppRg0P/CAPOHkPxLF0RwC5yIZzC5C
-hiTXSE9AwCFllMRKInnbhUdy/L+xUL6mAbGVvD/DHE7Q2xmPSsdEX5nTZkhEnW/L
-TLLgbsy2+8ouvMJCSNaMq77jq7iCIMTogEfA5GX0UO2Kjf4pnjREOzNQg4I=
------END RSA PRIVATE KEY-----
diff --git a/Cronet/apex/com.android.cronet.pk8 b/Cronet/apex/com.android.cronet.pk8
deleted file mode 100644
index a63d761..0000000
--- a/Cronet/apex/com.android.cronet.pk8
+++ /dev/null
Binary files differ
diff --git a/Cronet/apex/com.android.cronet.x509.pem b/Cronet/apex/com.android.cronet.x509.pem
deleted file mode 100644
index c9cd874..0000000
--- a/Cronet/apex/com.android.cronet.x509.pem
+++ /dev/null
@@ -1,35 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIGIzCCBAugAwIBAgIUKEbkVLro9rIJE3M71D8sgUIngUIwDQYJKoZIhvcNAQEL
-BQAwgZ8xCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApDYWxpZm9ybmlhMRYwFAYDVQQH
-DA1Nb3VudGFpbiBWaWV3MRAwDgYDVQQKDAdBbmRyb2lkMRAwDgYDVQQLDAdBbmRy
-b2lkMRswGQYDVQQDDBJjb20uYW5kcm9pZC5jcm9uZXQxIjAgBgkqhkiG9w0BCQEW
-E2FuZHJvaWRAYW5kcm9pZC5jb20wIBcNMTkxMjA1MDcwOTIxWhgPNDc1NzEwMzEw
-NzA5MjFaMIGfMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQG
-A1UEBwwNTW91bnRhaW4gVmlldzEQMA4GA1UECgwHQW5kcm9pZDEQMA4GA1UECwwH
-QW5kcm9pZDEbMBkGA1UEAwwSY29tLmFuZHJvaWQuY3JvbmV0MSIwIAYJKoZIhvcN
-AQkBFhNhbmRyb2lkQGFuZHJvaWQuY29tMIICIjANBgkqhkiG9w0BAQEFAAOCAg8A
-MIICCgKCAgEAwNXIHR2BeZl/R7tOXgC3KK71rrtK98zucfrNBNp/rUiFqiN527P4
-HLW+CAwnFJGLLzHhSbXiZLXyLS7FfPuMeiULUsv1mIVEVwVhtPvbodxwh5szxlVe
-iVf1WkIV90n2tZojTnhMsiEPt0EBWriPJstdO264snqg+oY9Dktxk4tXtTah/rUI
-KWPHeB0SWQMXZTKb30CVVHZfpG/HCXjUlVLx+14/X56EGi8fxd13q5c56qAybx73
-i6+Sm3+F/jcivDpATuPluvcPaZ4Tel9Nz5NjqjycyXBXh8f8azpN1GkJkltE116W
-ZT1iVIJoDAd540UXhW+TpjTeaEH5OeDOWorQM6nE1N9FMiyReprU7tz+HVmyD44Z
-ah43whi3gmwyjgzscW2Z0xGpgVoHgfz/RyBg5+w6p5AGPR0sewv6zr9HvQhpJsoj
-pl+HD9xcrdGb2yMiwm8RuH9dGW0Nos6p1LiXsxg6VBic3N7S+MGXo/dXdX39tkad
-tD+lNskJUJqyx70ynQtRI66YicyxsFv0BImBC+eGECT3hCgyyxnlvTAeRsVsEWtV
-Z+Xwf5M53/8uXkqGal7cC1bHEkG+0zsR8cc0U+22Nif9HQNIrsjEnybOlP6erV/M
-8yX9umVwDz5QlVKCYJFQOq+awSqR9KD9VX3xIRu8kB6aPtB4A7q3828CAwEAAaNT
-MFEwHQYDVR0OBBYEFBQBcdf/bfLa3knW1ukCOFOt++FtMB8GA1UdIwQYMBaAFBQB
-cdf/bfLa3knW1ukCOFOt++FtMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
-BQADggIBALG0r81xb6NwaGCF79SeDecbnDE1MbQ2+cRt+eU/Wl2SI2oQqbaa/WP7
-k3vsZvsBFI6r+ZBiKizpbT/N1Fx8pcoH7rsL0MoZRXaCZY6kQJLZN6AAvXEo4NR0
-p01zDvGibVk3z87R98IJHlDPU3NrljxxMCsaUxFEAjae4eS4j8G2TFm6DsTVTeqy
-zveh4NdZFsZSyUN8blChFC/7TytlizeSGNlXLMx8e/VAcxIw+wQPWLk5pNnk3TXu
-HcqwAryW/lt46+iVeTpF4ylFqYyab6Vmf9Vp6+HVatg7YkErJACeoeN4eRv6DfeY
-slMqa2i+W+veVAGP4VApg7iZE5RnNPPHn/80yATKAe0/AztoZpQWZ5g1IAnpCISg
-k65FHVhbkcKdjNQePOGwjictq21KaYFrbXfIwqpejxSqQdLMne02Dj/2kv0dU1jV
-JG9YxVWIpobauYD5mmZvN6PTYJWGQRAsIFFyWfhvnEiohGmVLNEQ3uRaue0yNMXc
-V2t8B81/jNGXwi06qxmjCMnMhucSCSFl2a2V5oiDEcVj4YbaJ+CEJPdopMhQwqab
-EgTkJBeEXoPFenToSIprL/YiuBNvvPETyTYN+hAXh3P7MSeWewkgGhpZhuyzT8F0
-vEo+nt5WhRWl0pEVLFLiOOXR+/LAB3aqrPEdd0NXvxiCb/QaZnCp
------END CERTIFICATE-----
diff --git a/Cronet/apex/manifest.json b/Cronet/apex/manifest.json
deleted file mode 100644
index 0301e9f..0000000
--- a/Cronet/apex/manifest.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
- "name": "com.android.cronet",
- "version": 1
-}
diff --git a/Cronet/api/current.txt b/Cronet/api/current.txt
deleted file mode 100644
index 21779bc..0000000
--- a/Cronet/api/current.txt
+++ /dev/null
@@ -1,175 +0,0 @@
-// Signature format: 2.0
-package org.chromium.net {
-
- public abstract class CallbackException extends org.chromium.net.CronetException {
- ctor protected CallbackException(String, Throwable);
- }
-
- public abstract class CronetEngine {
- ctor public CronetEngine();
- method public abstract java.net.URLStreamHandlerFactory createURLStreamHandlerFactory();
- method public abstract byte[] getGlobalMetricsDeltas();
- method public abstract String getVersionString();
- method public abstract org.chromium.net.UrlRequest.Builder newUrlRequestBuilder(String, org.chromium.net.UrlRequest.Callback, java.util.concurrent.Executor);
- method public abstract java.net.URLConnection openConnection(java.net.URL) throws java.io.IOException;
- method public abstract void shutdown();
- method public abstract void startNetLogToFile(String, boolean);
- method public abstract void stopNetLog();
- }
-
- public static class CronetEngine.Builder {
- ctor public CronetEngine.Builder(android.content.Context);
- method public org.chromium.net.CronetEngine.Builder addPublicKeyPins(String, java.util.Set<byte[]>, boolean, java.util.Date);
- method public org.chromium.net.CronetEngine.Builder addQuicHint(String, int, int);
- method public org.chromium.net.CronetEngine build();
- method public org.chromium.net.CronetEngine.Builder enableBrotli(boolean);
- method public org.chromium.net.CronetEngine.Builder enableHttp2(boolean);
- method public org.chromium.net.CronetEngine.Builder enableHttpCache(int, long);
- method public org.chromium.net.CronetEngine.Builder enablePublicKeyPinningBypassForLocalTrustAnchors(boolean);
- method public org.chromium.net.CronetEngine.Builder enableQuic(boolean);
- method public String getDefaultUserAgent();
- method public org.chromium.net.CronetEngine.Builder setLibraryLoader(org.chromium.net.CronetEngine.Builder.LibraryLoader);
- method public org.chromium.net.CronetEngine.Builder setStoragePath(String);
- method public org.chromium.net.CronetEngine.Builder setUserAgent(String);
- field public static final int HTTP_CACHE_DISABLED = 0; // 0x0
- field public static final int HTTP_CACHE_DISK = 3; // 0x3
- field public static final int HTTP_CACHE_DISK_NO_HTTP = 2; // 0x2
- field public static final int HTTP_CACHE_IN_MEMORY = 1; // 0x1
- }
-
- public abstract static class CronetEngine.Builder.LibraryLoader {
- ctor public CronetEngine.Builder.LibraryLoader();
- method public abstract void loadLibrary(String);
- }
-
- public abstract class CronetException extends java.io.IOException {
- ctor protected CronetException(String, Throwable);
- }
-
- public final class InlineExecutionProhibitedException extends java.util.concurrent.RejectedExecutionException {
- ctor public InlineExecutionProhibitedException();
- }
-
- public abstract class NetworkException extends org.chromium.net.CronetException {
- ctor protected NetworkException(String, Throwable);
- method public abstract int getCronetInternalErrorCode();
- method public abstract int getErrorCode();
- method public abstract boolean immediatelyRetryable();
- field public static final int ERROR_ADDRESS_UNREACHABLE = 9; // 0x9
- field public static final int ERROR_CONNECTION_CLOSED = 5; // 0x5
- field public static final int ERROR_CONNECTION_REFUSED = 7; // 0x7
- field public static final int ERROR_CONNECTION_RESET = 8; // 0x8
- field public static final int ERROR_CONNECTION_TIMED_OUT = 6; // 0x6
- field public static final int ERROR_HOSTNAME_NOT_RESOLVED = 1; // 0x1
- field public static final int ERROR_INTERNET_DISCONNECTED = 2; // 0x2
- field public static final int ERROR_NETWORK_CHANGED = 3; // 0x3
- field public static final int ERROR_OTHER = 11; // 0xb
- field public static final int ERROR_QUIC_PROTOCOL_FAILED = 10; // 0xa
- field public static final int ERROR_TIMED_OUT = 4; // 0x4
- }
-
- public abstract class QuicException extends org.chromium.net.NetworkException {
- ctor protected QuicException(String, Throwable);
- method public abstract int getQuicDetailedErrorCode();
- }
-
- public abstract class UploadDataProvider implements java.io.Closeable {
- ctor public UploadDataProvider();
- method public void close() throws java.io.IOException;
- method public abstract long getLength() throws java.io.IOException;
- method public abstract void read(org.chromium.net.UploadDataSink, java.nio.ByteBuffer) throws java.io.IOException;
- method public abstract void rewind(org.chromium.net.UploadDataSink) throws java.io.IOException;
- }
-
- public final class UploadDataProviders {
- method public static org.chromium.net.UploadDataProvider create(java.io.File);
- method public static org.chromium.net.UploadDataProvider create(android.os.ParcelFileDescriptor);
- method public static org.chromium.net.UploadDataProvider create(java.nio.ByteBuffer);
- method public static org.chromium.net.UploadDataProvider create(byte[], int, int);
- method public static org.chromium.net.UploadDataProvider create(byte[]);
- }
-
- public abstract class UploadDataSink {
- ctor public UploadDataSink();
- method public abstract void onReadError(Exception);
- method public abstract void onReadSucceeded(boolean);
- method public abstract void onRewindError(Exception);
- method public abstract void onRewindSucceeded();
- }
-
- public abstract class UrlRequest {
- ctor public UrlRequest();
- method public abstract void cancel();
- method public abstract void followRedirect();
- method public abstract void getStatus(org.chromium.net.UrlRequest.StatusListener);
- method public abstract boolean isDone();
- method public abstract void read(java.nio.ByteBuffer);
- method public abstract void start();
- }
-
- public abstract static class UrlRequest.Builder {
- ctor public UrlRequest.Builder();
- method public abstract org.chromium.net.UrlRequest.Builder addHeader(String, String);
- method public abstract org.chromium.net.UrlRequest.Builder allowDirectExecutor();
- method public abstract org.chromium.net.UrlRequest build();
- method public abstract org.chromium.net.UrlRequest.Builder disableCache();
- method public abstract org.chromium.net.UrlRequest.Builder setHttpMethod(String);
- method public abstract org.chromium.net.UrlRequest.Builder setPriority(int);
- method public abstract org.chromium.net.UrlRequest.Builder setUploadDataProvider(org.chromium.net.UploadDataProvider, java.util.concurrent.Executor);
- field public static final int REQUEST_PRIORITY_HIGHEST = 4; // 0x4
- field public static final int REQUEST_PRIORITY_IDLE = 0; // 0x0
- field public static final int REQUEST_PRIORITY_LOW = 2; // 0x2
- field public static final int REQUEST_PRIORITY_LOWEST = 1; // 0x1
- field public static final int REQUEST_PRIORITY_MEDIUM = 3; // 0x3
- }
-
- public abstract static class UrlRequest.Callback {
- ctor public UrlRequest.Callback();
- method public void onCanceled(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo);
- method public abstract void onFailed(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, org.chromium.net.CronetException);
- method public abstract void onReadCompleted(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, java.nio.ByteBuffer) throws java.lang.Exception;
- method public abstract void onRedirectReceived(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, String) throws java.lang.Exception;
- method public abstract void onResponseStarted(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo) throws java.lang.Exception;
- method public abstract void onSucceeded(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo);
- }
-
- public static class UrlRequest.Status {
- field public static final int CONNECTING = 10; // 0xa
- field public static final int DOWNLOADING_PAC_FILE = 5; // 0x5
- field public static final int ESTABLISHING_PROXY_TUNNEL = 8; // 0x8
- field public static final int IDLE = 0; // 0x0
- field public static final int INVALID = -1; // 0xffffffff
- field public static final int READING_RESPONSE = 14; // 0xe
- field public static final int RESOLVING_HOST = 9; // 0x9
- field public static final int RESOLVING_HOST_IN_PAC_FILE = 7; // 0x7
- field public static final int RESOLVING_PROXY_FOR_URL = 6; // 0x6
- field public static final int SENDING_REQUEST = 12; // 0xc
- field public static final int SSL_HANDSHAKE = 11; // 0xb
- field public static final int WAITING_FOR_AVAILABLE_SOCKET = 2; // 0x2
- field public static final int WAITING_FOR_CACHE = 4; // 0x4
- field public static final int WAITING_FOR_DELEGATE = 3; // 0x3
- field public static final int WAITING_FOR_RESPONSE = 13; // 0xd
- field public static final int WAITING_FOR_STALLED_SOCKET_POOL = 1; // 0x1
- }
-
- public abstract static class UrlRequest.StatusListener {
- ctor public UrlRequest.StatusListener();
- method public abstract void onStatus(int);
- }
-
- public abstract class UrlResponseInfo {
- ctor public UrlResponseInfo();
- method public abstract java.util.Map<java.lang.String,java.util.List<java.lang.String>> getAllHeaders();
- method public abstract java.util.List<java.util.Map.Entry<java.lang.String,java.lang.String>> getAllHeadersAsList();
- method public abstract int getHttpStatusCode();
- method public abstract String getHttpStatusText();
- method public abstract String getNegotiatedProtocol();
- method public abstract String getProxyServer();
- method public abstract long getReceivedByteCount();
- method public abstract String getUrl();
- method public abstract java.util.List<java.lang.String> getUrlChain();
- method public abstract boolean wasCached();
- }
-
-}
-
diff --git a/Cronet/api/lint-baseline.txt b/Cronet/api/lint-baseline.txt
deleted file mode 100644
index 0e2f25b..0000000
--- a/Cronet/api/lint-baseline.txt
+++ /dev/null
@@ -1,263 +0,0 @@
-// Baseline format: 1.0
-AcronymName: org.chromium.net.CronetEngine#createURLStreamHandlerFactory():
- Acronyms should not be capitalized in method names: was `createURLStreamHandlerFactory`, should this be `createUrlStreamHandlerFactory`?
-
-
-AndroidUri: org.chromium.net.CronetEngine#createURLStreamHandlerFactory():
- Use android.net.Uri instead of java.net.URL (method org.chromium.net.CronetEngine.createURLStreamHandlerFactory())
-AndroidUri: org.chromium.net.CronetEngine#openConnection(java.net.URL):
- Use android.net.Uri instead of java.net.URL (method org.chromium.net.CronetEngine.openConnection(java.net.URL))
-AndroidUri: org.chromium.net.CronetEngine#openConnection(java.net.URL) parameter #0:
- Use android.net.Uri instead of java.net.URL (parameter url in org.chromium.net.CronetEngine.openConnection(java.net.URL url))
-
-
-BuilderSetStyle: org.chromium.net.CronetEngine.Builder#enableBrotli(boolean):
- Builder methods names should use setFoo() / addFoo() / clearFoo() style: method org.chromium.net.CronetEngine.Builder.enableBrotli(boolean)
-BuilderSetStyle: org.chromium.net.CronetEngine.Builder#enableHttp2(boolean):
- Builder methods names should use setFoo() / addFoo() / clearFoo() style: method org.chromium.net.CronetEngine.Builder.enableHttp2(boolean)
-BuilderSetStyle: org.chromium.net.CronetEngine.Builder#enableHttpCache(int, long):
- Builder methods names should use setFoo() / addFoo() / clearFoo() style: method org.chromium.net.CronetEngine.Builder.enableHttpCache(int,long)
-BuilderSetStyle: org.chromium.net.CronetEngine.Builder#enablePublicKeyPinningBypassForLocalTrustAnchors(boolean):
- Builder methods names should use setFoo() / addFoo() / clearFoo() style: method org.chromium.net.CronetEngine.Builder.enablePublicKeyPinningBypassForLocalTrustAnchors(boolean)
-BuilderSetStyle: org.chromium.net.CronetEngine.Builder#enableQuic(boolean):
- Builder methods names should use setFoo() / addFoo() / clearFoo() style: method org.chromium.net.CronetEngine.Builder.enableQuic(boolean)
-BuilderSetStyle: org.chromium.net.UrlRequest.Builder#allowDirectExecutor():
- Builder methods names should use setFoo() / addFoo() / clearFoo() style: method org.chromium.net.UrlRequest.Builder.allowDirectExecutor()
-BuilderSetStyle: org.chromium.net.UrlRequest.Builder#disableCache():
- Builder methods names should use setFoo() / addFoo() / clearFoo() style: method org.chromium.net.UrlRequest.Builder.disableCache()
-
-
-ExecutorRegistration: org.chromium.net.UrlRequest#getStatus(org.chromium.net.UrlRequest.StatusListener):
- Registration methods should have overload that accepts delivery Executor: `getStatus`
-
-
-GenericException: org.chromium.net.UrlRequest.Callback#onReadCompleted(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, java.nio.ByteBuffer):
- Methods must not throw generic exceptions (`java.lang.Exception`)
-GenericException: org.chromium.net.UrlRequest.Callback#onRedirectReceived(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, String):
- Methods must not throw generic exceptions (`java.lang.Exception`)
-GenericException: org.chromium.net.UrlRequest.Callback#onResponseStarted(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo):
- Methods must not throw generic exceptions (`java.lang.Exception`)
-
-
-GetterOnBuilder: org.chromium.net.CronetEngine.Builder#getDefaultUserAgent():
- Getter should be on the built object, not the builder: method org.chromium.net.CronetEngine.Builder.getDefaultUserAgent()
-
-
-ListenerInterface: org.chromium.net.UrlRequest.StatusListener:
- Listeners should be an interface, or otherwise renamed Callback: StatusListener
-
-
-ListenerLast: org.chromium.net.CronetEngine#newUrlRequestBuilder(String, org.chromium.net.UrlRequest.Callback, java.util.concurrent.Executor) parameter #2:
- Listeners should always be at end of argument list (method `newUrlRequestBuilder`)
-
-
-MissingGetterMatchingBuilder: org.chromium.net.CronetEngine.Builder#addPublicKeyPins(String, java.util.Set<byte[]>, boolean, java.util.Date):
- org.chromium.net.CronetEngine does not declare a `getPublicKeyPinss()` method matching method org.chromium.net.CronetEngine.Builder.addPublicKeyPins(String,java.util.Set<byte[]>,boolean,java.util.Date)
-MissingGetterMatchingBuilder: org.chromium.net.CronetEngine.Builder#addQuicHint(String, int, int):
- org.chromium.net.CronetEngine does not declare a `getQuicHints()` method matching method org.chromium.net.CronetEngine.Builder.addQuicHint(String,int,int)
-MissingGetterMatchingBuilder: org.chromium.net.CronetEngine.Builder#setLibraryLoader(org.chromium.net.CronetEngine.Builder.LibraryLoader):
- org.chromium.net.CronetEngine does not declare a `getLibraryLoader()` method matching method org.chromium.net.CronetEngine.Builder.setLibraryLoader(org.chromium.net.CronetEngine.Builder.LibraryLoader)
-MissingGetterMatchingBuilder: org.chromium.net.CronetEngine.Builder#setStoragePath(String):
- org.chromium.net.CronetEngine does not declare a `getStoragePath()` method matching method org.chromium.net.CronetEngine.Builder.setStoragePath(String)
-MissingGetterMatchingBuilder: org.chromium.net.CronetEngine.Builder#setUserAgent(String):
- org.chromium.net.CronetEngine does not declare a `getUserAgent()` method matching method org.chromium.net.CronetEngine.Builder.setUserAgent(String)
-MissingGetterMatchingBuilder: org.chromium.net.UrlRequest.Builder#addHeader(String, String):
- org.chromium.net.UrlRequest does not declare a `getHeaders()` method matching method org.chromium.net.UrlRequest.Builder.addHeader(String,String)
-MissingGetterMatchingBuilder: org.chromium.net.UrlRequest.Builder#setHttpMethod(String):
- org.chromium.net.UrlRequest does not declare a `getHttpMethod()` method matching method org.chromium.net.UrlRequest.Builder.setHttpMethod(String)
-MissingGetterMatchingBuilder: org.chromium.net.UrlRequest.Builder#setPriority(int):
- org.chromium.net.UrlRequest does not declare a `getPriority()` method matching method org.chromium.net.UrlRequest.Builder.setPriority(int)
-MissingGetterMatchingBuilder: org.chromium.net.UrlRequest.Builder#setUploadDataProvider(org.chromium.net.UploadDataProvider, java.util.concurrent.Executor):
- org.chromium.net.UrlRequest does not declare a `getUploadDataProvider()` method matching method org.chromium.net.UrlRequest.Builder.setUploadDataProvider(org.chromium.net.UploadDataProvider,java.util.concurrent.Executor)
-
-
-MissingNullability: org.chromium.net.CallbackException#CallbackException(String, Throwable) parameter #0:
- Missing nullability on parameter `message` in method `CallbackException`
-MissingNullability: org.chromium.net.CallbackException#CallbackException(String, Throwable) parameter #1:
- Missing nullability on parameter `cause` in method `CallbackException`
-MissingNullability: org.chromium.net.CronetEngine#createURLStreamHandlerFactory():
- Missing nullability on method `createURLStreamHandlerFactory` return
-MissingNullability: org.chromium.net.CronetEngine#getGlobalMetricsDeltas():
- Missing nullability on method `getGlobalMetricsDeltas` return
-MissingNullability: org.chromium.net.CronetEngine#getVersionString():
- Missing nullability on method `getVersionString` return
-MissingNullability: org.chromium.net.CronetEngine#newUrlRequestBuilder(String, org.chromium.net.UrlRequest.Callback, java.util.concurrent.Executor):
- Missing nullability on method `newUrlRequestBuilder` return
-MissingNullability: org.chromium.net.CronetEngine#newUrlRequestBuilder(String, org.chromium.net.UrlRequest.Callback, java.util.concurrent.Executor) parameter #0:
- Missing nullability on parameter `url` in method `newUrlRequestBuilder`
-MissingNullability: org.chromium.net.CronetEngine#newUrlRequestBuilder(String, org.chromium.net.UrlRequest.Callback, java.util.concurrent.Executor) parameter #1:
- Missing nullability on parameter `callback` in method `newUrlRequestBuilder`
-MissingNullability: org.chromium.net.CronetEngine#newUrlRequestBuilder(String, org.chromium.net.UrlRequest.Callback, java.util.concurrent.Executor) parameter #2:
- Missing nullability on parameter `executor` in method `newUrlRequestBuilder`
-MissingNullability: org.chromium.net.CronetEngine#openConnection(java.net.URL):
- Missing nullability on method `openConnection` return
-MissingNullability: org.chromium.net.CronetEngine#openConnection(java.net.URL) parameter #0:
- Missing nullability on parameter `url` in method `openConnection`
-MissingNullability: org.chromium.net.CronetEngine#startNetLogToFile(String, boolean) parameter #0:
- Missing nullability on parameter `fileName` in method `startNetLogToFile`
-MissingNullability: org.chromium.net.CronetEngine.Builder#Builder(android.content.Context) parameter #0:
- Missing nullability on parameter `context` in method `Builder`
-MissingNullability: org.chromium.net.CronetEngine.Builder#addPublicKeyPins(String, java.util.Set<byte[]>, boolean, java.util.Date):
- Missing nullability on method `addPublicKeyPins` return
-MissingNullability: org.chromium.net.CronetEngine.Builder#addPublicKeyPins(String, java.util.Set<byte[]>, boolean, java.util.Date) parameter #0:
- Missing nullability on parameter `hostName` in method `addPublicKeyPins`
-MissingNullability: org.chromium.net.CronetEngine.Builder#addPublicKeyPins(String, java.util.Set<byte[]>, boolean, java.util.Date) parameter #1:
- Missing nullability on parameter `pinsSha256` in method `addPublicKeyPins`
-MissingNullability: org.chromium.net.CronetEngine.Builder#addPublicKeyPins(String, java.util.Set<byte[]>, boolean, java.util.Date) parameter #3:
- Missing nullability on parameter `expirationDate` in method `addPublicKeyPins`
-MissingNullability: org.chromium.net.CronetEngine.Builder#addQuicHint(String, int, int):
- Missing nullability on method `addQuicHint` return
-MissingNullability: org.chromium.net.CronetEngine.Builder#addQuicHint(String, int, int) parameter #0:
- Missing nullability on parameter `host` in method `addQuicHint`
-MissingNullability: org.chromium.net.CronetEngine.Builder#build():
- Missing nullability on method `build` return
-MissingNullability: org.chromium.net.CronetEngine.Builder#enableBrotli(boolean):
- Missing nullability on method `enableBrotli` return
-MissingNullability: org.chromium.net.CronetEngine.Builder#enableHttp2(boolean):
- Missing nullability on method `enableHttp2` return
-MissingNullability: org.chromium.net.CronetEngine.Builder#enableHttpCache(int, long):
- Missing nullability on method `enableHttpCache` return
-MissingNullability: org.chromium.net.CronetEngine.Builder#enablePublicKeyPinningBypassForLocalTrustAnchors(boolean):
- Missing nullability on method `enablePublicKeyPinningBypassForLocalTrustAnchors` return
-MissingNullability: org.chromium.net.CronetEngine.Builder#enableQuic(boolean):
- Missing nullability on method `enableQuic` return
-MissingNullability: org.chromium.net.CronetEngine.Builder#getDefaultUserAgent():
- Missing nullability on method `getDefaultUserAgent` return
-MissingNullability: org.chromium.net.CronetEngine.Builder#setLibraryLoader(org.chromium.net.CronetEngine.Builder.LibraryLoader):
- Missing nullability on method `setLibraryLoader` return
-MissingNullability: org.chromium.net.CronetEngine.Builder#setLibraryLoader(org.chromium.net.CronetEngine.Builder.LibraryLoader) parameter #0:
- Missing nullability on parameter `loader` in method `setLibraryLoader`
-MissingNullability: org.chromium.net.CronetEngine.Builder#setStoragePath(String):
- Missing nullability on method `setStoragePath` return
-MissingNullability: org.chromium.net.CronetEngine.Builder#setStoragePath(String) parameter #0:
- Missing nullability on parameter `value` in method `setStoragePath`
-MissingNullability: org.chromium.net.CronetEngine.Builder#setUserAgent(String):
- Missing nullability on method `setUserAgent` return
-MissingNullability: org.chromium.net.CronetEngine.Builder#setUserAgent(String) parameter #0:
- Missing nullability on parameter `userAgent` in method `setUserAgent`
-MissingNullability: org.chromium.net.CronetEngine.Builder.LibraryLoader#loadLibrary(String) parameter #0:
- Missing nullability on parameter `libName` in method `loadLibrary`
-MissingNullability: org.chromium.net.CronetException#CronetException(String, Throwable) parameter #0:
- Missing nullability on parameter `message` in method `CronetException`
-MissingNullability: org.chromium.net.CronetException#CronetException(String, Throwable) parameter #1:
- Missing nullability on parameter `cause` in method `CronetException`
-MissingNullability: org.chromium.net.NetworkException#NetworkException(String, Throwable) parameter #0:
- Missing nullability on parameter `message` in method `NetworkException`
-MissingNullability: org.chromium.net.NetworkException#NetworkException(String, Throwable) parameter #1:
- Missing nullability on parameter `cause` in method `NetworkException`
-MissingNullability: org.chromium.net.QuicException#QuicException(String, Throwable) parameter #0:
- Missing nullability on parameter `message` in method `QuicException`
-MissingNullability: org.chromium.net.QuicException#QuicException(String, Throwable) parameter #1:
- Missing nullability on parameter `cause` in method `QuicException`
-MissingNullability: org.chromium.net.UploadDataProvider#read(org.chromium.net.UploadDataSink, java.nio.ByteBuffer) parameter #0:
- Missing nullability on parameter `uploadDataSink` in method `read`
-MissingNullability: org.chromium.net.UploadDataProvider#read(org.chromium.net.UploadDataSink, java.nio.ByteBuffer) parameter #1:
- Missing nullability on parameter `byteBuffer` in method `read`
-MissingNullability: org.chromium.net.UploadDataProvider#rewind(org.chromium.net.UploadDataSink) parameter #0:
- Missing nullability on parameter `uploadDataSink` in method `rewind`
-MissingNullability: org.chromium.net.UploadDataProviders#create(android.os.ParcelFileDescriptor):
- Missing nullability on method `create` return
-MissingNullability: org.chromium.net.UploadDataProviders#create(android.os.ParcelFileDescriptor) parameter #0:
- Missing nullability on parameter `fd` in method `create`
-MissingNullability: org.chromium.net.UploadDataProviders#create(byte[]):
- Missing nullability on method `create` return
-MissingNullability: org.chromium.net.UploadDataProviders#create(byte[]) parameter #0:
- Missing nullability on parameter `data` in method `create`
-MissingNullability: org.chromium.net.UploadDataProviders#create(byte[], int, int):
- Missing nullability on method `create` return
-MissingNullability: org.chromium.net.UploadDataProviders#create(byte[], int, int) parameter #0:
- Missing nullability on parameter `data` in method `create`
-MissingNullability: org.chromium.net.UploadDataProviders#create(java.io.File):
- Missing nullability on method `create` return
-MissingNullability: org.chromium.net.UploadDataProviders#create(java.io.File) parameter #0:
- Missing nullability on parameter `file` in method `create`
-MissingNullability: org.chromium.net.UploadDataProviders#create(java.nio.ByteBuffer):
- Missing nullability on method `create` return
-MissingNullability: org.chromium.net.UploadDataProviders#create(java.nio.ByteBuffer) parameter #0:
- Missing nullability on parameter `buffer` in method `create`
-MissingNullability: org.chromium.net.UploadDataSink#onReadError(Exception) parameter #0:
- Missing nullability on parameter `exception` in method `onReadError`
-MissingNullability: org.chromium.net.UploadDataSink#onRewindError(Exception) parameter #0:
- Missing nullability on parameter `exception` in method `onRewindError`
-MissingNullability: org.chromium.net.UrlRequest#getStatus(org.chromium.net.UrlRequest.StatusListener) parameter #0:
- Missing nullability on parameter `listener` in method `getStatus`
-MissingNullability: org.chromium.net.UrlRequest#read(java.nio.ByteBuffer) parameter #0:
- Missing nullability on parameter `buffer` in method `read`
-MissingNullability: org.chromium.net.UrlRequest.Builder#addHeader(String, String):
- Missing nullability on method `addHeader` return
-MissingNullability: org.chromium.net.UrlRequest.Builder#addHeader(String, String) parameter #0:
- Missing nullability on parameter `header` in method `addHeader`
-MissingNullability: org.chromium.net.UrlRequest.Builder#addHeader(String, String) parameter #1:
- Missing nullability on parameter `value` in method `addHeader`
-MissingNullability: org.chromium.net.UrlRequest.Builder#allowDirectExecutor():
- Missing nullability on method `allowDirectExecutor` return
-MissingNullability: org.chromium.net.UrlRequest.Builder#build():
- Missing nullability on method `build` return
-MissingNullability: org.chromium.net.UrlRequest.Builder#disableCache():
- Missing nullability on method `disableCache` return
-MissingNullability: org.chromium.net.UrlRequest.Builder#setHttpMethod(String):
- Missing nullability on method `setHttpMethod` return
-MissingNullability: org.chromium.net.UrlRequest.Builder#setHttpMethod(String) parameter #0:
- Missing nullability on parameter `method` in method `setHttpMethod`
-MissingNullability: org.chromium.net.UrlRequest.Builder#setPriority(int):
- Missing nullability on method `setPriority` return
-MissingNullability: org.chromium.net.UrlRequest.Builder#setUploadDataProvider(org.chromium.net.UploadDataProvider, java.util.concurrent.Executor):
- Missing nullability on method `setUploadDataProvider` return
-MissingNullability: org.chromium.net.UrlRequest.Builder#setUploadDataProvider(org.chromium.net.UploadDataProvider, java.util.concurrent.Executor) parameter #0:
- Missing nullability on parameter `uploadDataProvider` in method `setUploadDataProvider`
-MissingNullability: org.chromium.net.UrlRequest.Builder#setUploadDataProvider(org.chromium.net.UploadDataProvider, java.util.concurrent.Executor) parameter #1:
- Missing nullability on parameter `executor` in method `setUploadDataProvider`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onCanceled(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo) parameter #0:
- Missing nullability on parameter `request` in method `onCanceled`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onCanceled(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo) parameter #1:
- Missing nullability on parameter `info` in method `onCanceled`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onFailed(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, org.chromium.net.CronetException) parameter #0:
- Missing nullability on parameter `request` in method `onFailed`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onFailed(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, org.chromium.net.CronetException) parameter #1:
- Missing nullability on parameter `info` in method `onFailed`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onFailed(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, org.chromium.net.CronetException) parameter #2:
- Missing nullability on parameter `error` in method `onFailed`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onReadCompleted(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, java.nio.ByteBuffer) parameter #0:
- Missing nullability on parameter `request` in method `onReadCompleted`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onReadCompleted(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, java.nio.ByteBuffer) parameter #1:
- Missing nullability on parameter `info` in method `onReadCompleted`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onReadCompleted(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, java.nio.ByteBuffer) parameter #2:
- Missing nullability on parameter `byteBuffer` in method `onReadCompleted`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onRedirectReceived(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, String) parameter #0:
- Missing nullability on parameter `request` in method `onRedirectReceived`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onRedirectReceived(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, String) parameter #1:
- Missing nullability on parameter `info` in method `onRedirectReceived`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onRedirectReceived(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo, String) parameter #2:
- Missing nullability on parameter `newLocationUrl` in method `onRedirectReceived`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onResponseStarted(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo) parameter #0:
- Missing nullability on parameter `request` in method `onResponseStarted`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onResponseStarted(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo) parameter #1:
- Missing nullability on parameter `info` in method `onResponseStarted`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onSucceeded(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo) parameter #0:
- Missing nullability on parameter `request` in method `onSucceeded`
-MissingNullability: org.chromium.net.UrlRequest.Callback#onSucceeded(org.chromium.net.UrlRequest, org.chromium.net.UrlResponseInfo) parameter #1:
- Missing nullability on parameter `info` in method `onSucceeded`
-MissingNullability: org.chromium.net.UrlResponseInfo#getAllHeaders():
- Missing nullability on method `getAllHeaders` return
-MissingNullability: org.chromium.net.UrlResponseInfo#getAllHeadersAsList():
- Missing nullability on method `getAllHeadersAsList` return
-MissingNullability: org.chromium.net.UrlResponseInfo#getHttpStatusText():
- Missing nullability on method `getHttpStatusText` return
-MissingNullability: org.chromium.net.UrlResponseInfo#getNegotiatedProtocol():
- Missing nullability on method `getNegotiatedProtocol` return
-MissingNullability: org.chromium.net.UrlResponseInfo#getProxyServer():
- Missing nullability on method `getProxyServer` return
-MissingNullability: org.chromium.net.UrlResponseInfo#getUrl():
- Missing nullability on method `getUrl` return
-MissingNullability: org.chromium.net.UrlResponseInfo#getUrlChain():
- Missing nullability on method `getUrlChain` return
-
-
-NotCloseable: org.chromium.net.CronetEngine:
- Classes that release resources (shutdown()) should implement AutoClosable and CloseGuard: class org.chromium.net.CronetEngine
-
-
-StaticFinalBuilder: org.chromium.net.CronetEngine.Builder:
- Builder must be final: org.chromium.net.CronetEngine.Builder
-StaticFinalBuilder: org.chromium.net.UrlRequest.Builder:
- Builder must be final: org.chromium.net.UrlRequest.Builder
diff --git a/Cronet/api/module-lib-current.txt b/Cronet/api/module-lib-current.txt
deleted file mode 100644
index d802177..0000000
--- a/Cronet/api/module-lib-current.txt
+++ /dev/null
@@ -1 +0,0 @@
-// Signature format: 2.0
diff --git a/Cronet/api/system-current.txt b/Cronet/api/system-current.txt
deleted file mode 100644
index d802177..0000000
--- a/Cronet/api/system-current.txt
+++ /dev/null
@@ -1 +0,0 @@
-// Signature format: 2.0
diff --git a/Cronet/api/test-current.txt b/Cronet/api/test-current.txt
deleted file mode 100644
index d802177..0000000
--- a/Cronet/api/test-current.txt
+++ /dev/null
@@ -1 +0,0 @@
-// Signature format: 2.0
diff --git a/Cronet/api/test-removed.txt b/Cronet/api/test-removed.txt
deleted file mode 100644
index d802177..0000000
--- a/Cronet/api/test-removed.txt
+++ /dev/null
@@ -1 +0,0 @@
-// Signature format: 2.0
diff --git a/Cronet/jarjar-rules.txt b/Cronet/jarjar-rules.txt
deleted file mode 100644
index 76a799e..0000000
--- a/Cronet/jarjar-rules.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-rule androidx.** com.android.net.http.@0
-rule android.support.** com.android.net.http.@0
-
diff --git a/Cronet/prebuilt/VERSION b/Cronet/prebuilt/VERSION
deleted file mode 100644
index c16ab94..0000000
--- a/Cronet/prebuilt/VERSION
+++ /dev/null
@@ -1,4 +0,0 @@
-MAJOR=80
-MINOR=0
-BUILD=3986
-PATCH=0
diff --git a/Cronet/prebuilt/api_version.txt b/Cronet/prebuilt/api_version.txt
deleted file mode 100644
index 48082f7..0000000
--- a/Cronet/prebuilt/api_version.txt
+++ /dev/null
@@ -1 +0,0 @@
-12
diff --git a/Cronet/prebuilt/cronet_api-src.jar b/Cronet/prebuilt/cronet_api-src.jar
deleted file mode 100644
index 924b877..0000000
--- a/Cronet/prebuilt/cronet_api-src.jar
+++ /dev/null
Binary files differ
diff --git a/Cronet/prebuilt/cronet_api.jar b/Cronet/prebuilt/cronet_api.jar
deleted file mode 100644
index 977b28d..0000000
--- a/Cronet/prebuilt/cronet_api.jar
+++ /dev/null
Binary files differ
diff --git a/Cronet/prebuilt/cronet_impl_common_java.jar b/Cronet/prebuilt/cronet_impl_common_java.jar
deleted file mode 100644
index fa71bf3..0000000
--- a/Cronet/prebuilt/cronet_impl_common_java.jar
+++ /dev/null
Binary files differ
diff --git a/Cronet/prebuilt/cronet_impl_native_java.jar b/Cronet/prebuilt/cronet_impl_native_java.jar
deleted file mode 100644
index 4cdd6f3..0000000
--- a/Cronet/prebuilt/cronet_impl_native_java.jar
+++ /dev/null
Binary files differ
diff --git a/Cronet/prebuilt/cronet_impl_platform_java.jar b/Cronet/prebuilt/cronet_impl_platform_java.jar
deleted file mode 100644
index 6d6042f..0000000
--- a/Cronet/prebuilt/cronet_impl_platform_java.jar
+++ /dev/null
Binary files differ
diff --git a/Cronet/prebuilt/libs/arm64-v8a/libcronet.107.0.5284.2.so b/Cronet/prebuilt/libs/arm64-v8a/libcronet.107.0.5284.2.so
deleted file mode 100644
index 7f2540a..0000000
--- a/Cronet/prebuilt/libs/arm64-v8a/libcronet.107.0.5284.2.so
+++ /dev/null
Binary files differ
diff --git a/Cronet/prebuilt/libs/armeabi-v7a/libcronet.107.0.5284.2.so b/Cronet/prebuilt/libs/armeabi-v7a/libcronet.107.0.5284.2.so
deleted file mode 100644
index 115429a..0000000
--- a/Cronet/prebuilt/libs/armeabi-v7a/libcronet.107.0.5284.2.so
+++ /dev/null
Binary files differ
diff --git a/Cronet/prebuilt/libs/x86/libcronet.107.0.5284.2.so b/Cronet/prebuilt/libs/x86/libcronet.107.0.5284.2.so
deleted file mode 100644
index 27923f7..0000000
--- a/Cronet/prebuilt/libs/x86/libcronet.107.0.5284.2.so
+++ /dev/null
Binary files differ
diff --git a/Cronet/prebuilt/libs/x86_64/libcronet.107.0.5284.2.so b/Cronet/prebuilt/libs/x86_64/libcronet.107.0.5284.2.so
deleted file mode 100644
index 803e5cd..0000000
--- a/Cronet/prebuilt/libs/x86_64/libcronet.107.0.5284.2.so
+++ /dev/null
Binary files differ
diff --git a/Cronet/tests/cts/Android.bp b/Cronet/tests/cts/Android.bp
index d10c68c..2c28b8d 100644
--- a/Cronet/tests/cts/Android.bp
+++ b/Cronet/tests/cts/Android.bp
@@ -18,10 +18,36 @@
default_applicable_licenses: ["Android-Apache-2.0"],
}
+// cronet_test_java_defaults can be used to specify a java_defaults target that
+// either enables or disables Cronet tests. This is used to disable Cronet
+// tests on tm-mainline-prod where the required APIs are not present.
+cronet_test_java_defaults = "CronetTestJavaDefaultsEnabled"
+// This is a placeholder comment to avoid merge conflicts
+// as cronet_test_java_defaults may have different values
+// depending on the branch
+
+java_defaults {
+ name: "CronetTestJavaDefaultsEnabled",
+ enabled: true,
+}
+
+java_defaults {
+ name: "CronetTestJavaDefaultsDisabled",
+ enabled: false,
+}
+
+java_defaults {
+ name: "CronetTestJavaDefaults",
+ defaults: [cronet_test_java_defaults],
+}
+
android_test {
- name: "CtsCronetTestCases",
+ name: "CtsNetHttpTestCases",
compile_multilib: "both", // Include both the 32 and 64 bit versions
- defaults: ["cts_defaults"],
+ defaults: [
+ "CronetTestJavaDefaults",
+ "cts_defaults",
+ ],
sdk_version: "test_current",
srcs: [
"src/**/*.java",
@@ -33,13 +59,14 @@
"ctstestrunner-axt",
"ctstestserver",
"junit",
+ "hamcrest-library",
],
libs: [
"android.test.runner",
"android.test.base",
"android.test.mock",
"androidx.annotation_annotation",
- "framework-cronet",
+ "framework-tethering",
"org.apache.http.legacy",
],
diff --git a/Cronet/tests/cts/AndroidManifest.xml b/Cronet/tests/cts/AndroidManifest.xml
index 5a92dea..eaa24aa 100644
--- a/Cronet/tests/cts/AndroidManifest.xml
+++ b/Cronet/tests/cts/AndroidManifest.xml
@@ -25,7 +25,6 @@
<application android:networkSecurityConfig="@xml/network_security_config">
<uses-library android:name="android.test.runner"/>
- <uses-library android:name="framework-cronet"/>
</application>
<instrumentation
diff --git a/Cronet/tests/cts/AndroidTest.xml b/Cronet/tests/cts/AndroidTest.xml
index d2422f1..e0421fd 100644
--- a/Cronet/tests/cts/AndroidTest.xml
+++ b/Cronet/tests/cts/AndroidTest.xml
@@ -23,14 +23,14 @@
<option name="config-descriptor:metadata" key="parameter" value="secondary_user" />
<target_preparer class="com.android.tradefed.targetprep.suite.SuiteApkInstaller">
<option name="cleanup-apks" value="true" />
- <option name="test-file-name" value="CtsCronetTestCases.apk" />
+ <option name="test-file-name" value="CtsNetHttpTestCases.apk" />
</target_preparer>
<test class="com.android.tradefed.testtype.AndroidJUnitTest" >
<option name="package" value="android.net.http.cts" />
<option name="runtime-hint" value="10s" />
</test>
- <!-- Only run CtsCronetTestcasess in MTS if the Tethering Mainline module is installed. -->
+ <!-- Only run CtsNetHttpTestCases in MTS if the Tethering Mainline module is installed. -->
<object type="module_controller"
class="com.android.tradefed.testtype.suite.module.MainlineTestModuleController">
<option name="mainline-module-package-name" value="com.google.android.tethering" />
diff --git a/Cronet/tests/cts/src/android/net/http/cts/CronetUrlRequestTest.java b/Cronet/tests/cts/src/android/net/http/cts/CronetUrlRequestTest.java
deleted file mode 100644
index 2898f54..0000000
--- a/Cronet/tests/cts/src/android/net/http/cts/CronetUrlRequestTest.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.net.http.cts;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import android.content.Context;
-import android.net.ConnectivityManager;
-import android.net.http.cts.util.CronetCtsTestServer;
-import android.net.http.cts.util.TestUrlRequestCallback;
-import android.net.http.cts.util.TestUrlRequestCallback.ResponseStep;
-
-import androidx.annotation.NonNull;
-import androidx.test.platform.app.InstrumentationRegistry;
-import androidx.test.runner.AndroidJUnit4;
-
-import org.chromium.net.CronetEngine;
-import org.chromium.net.UrlRequest;
-import org.chromium.net.UrlResponseInfo;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-@RunWith(AndroidJUnit4.class)
-public class CronetUrlRequestTest {
- private static final String TAG = CronetUrlRequestTest.class.getSimpleName();
-
- @NonNull private CronetEngine mCronetEngine;
- @NonNull private ConnectivityManager mCm;
- @NonNull private CronetCtsTestServer mTestServer;
-
- @Before
- public void setUp() throws Exception {
- Context context = InstrumentationRegistry.getInstrumentation().getContext();
- mCm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
- CronetEngine.Builder builder = new CronetEngine.Builder(context);
- builder.enableHttpCache(CronetEngine.Builder.HTTP_CACHE_IN_MEMORY, 100 * 1024)
- .enableHttp2(true)
- // .enableBrotli(true)
- .enableQuic(true);
- mCronetEngine = builder.build();
- mTestServer = new CronetCtsTestServer(context);
- }
-
- @After
- public void tearDown() throws Exception {
- mCronetEngine.shutdown();
- mTestServer.shutdown();
- }
-
- private static void assertGreaterThan(String msg, int first, int second) {
- assertTrue(msg + " Excepted " + first + " to be greater than " + second, first > second);
- }
-
- private void assertHasTestableNetworks() {
- assertNotNull("This test requires a working Internet connection", mCm.getActiveNetwork());
- }
-
- @Test
- public void testUrlRequestGet_CompletesSuccessfully() throws Exception {
- assertHasTestableNetworks();
- String url = mTestServer.getSuccessUrl();
- TestUrlRequestCallback callback = new TestUrlRequestCallback();
- UrlRequest.Builder builder =
- mCronetEngine.newUrlRequestBuilder(url, callback, callback.getExecutor());
- builder.build().start();
-
- callback.expectCallback(ResponseStep.ON_SUCCEEDED);
-
- UrlResponseInfo info = callback.mResponseInfo;
- assertEquals(
- "Unexpected http status code from " + url + ".", 200, info.getHttpStatusCode());
- assertGreaterThan(
- "Received byte from " + url + " is 0.", (int) info.getReceivedByteCount(), 0);
- }
-}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java b/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java
new file mode 100644
index 0000000..6a8467c
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.net.http.cts;
+
+import static android.net.http.cts.util.TestUtilsKt.assertOKStatusCode;
+import static android.net.http.cts.util.TestUtilsKt.skipIfNoInternetConnection;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsString;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import android.content.Context;
+import android.net.http.HttpEngine;
+import android.net.http.UrlRequest;
+import android.net.http.UrlResponseInfo;
+import android.net.http.cts.util.TestUrlRequestCallback;
+import android.net.http.cts.util.TestUrlRequestCallback.ResponseStep;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.runner.AndroidJUnit4;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public class HttpEngineTest {
+ private static final String HOST = "source.android.com";
+ private static final String URL = "https://" + HOST;
+
+ private HttpEngine.Builder mEngineBuilder;
+ private TestUrlRequestCallback mCallback;
+ private HttpEngine mEngine;
+
+ @Before
+ public void setUp() throws Exception {
+ Context context = InstrumentationRegistry.getInstrumentation().getContext();
+ skipIfNoInternetConnection(context);
+ mEngineBuilder = new HttpEngine.Builder(context);
+ mCallback = new TestUrlRequestCallback();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ if (mEngine != null) {
+ mEngine.shutdown();
+ }
+ }
+
+ private boolean isQuic(String negotiatedProtocol) {
+ return negotiatedProtocol.startsWith("http/2+quic") || negotiatedProtocol.startsWith("h3");
+ }
+
+ @Test
+ public void testHttpEngine_Default() throws Exception {
+ mEngine = mEngineBuilder.build();
+ UrlRequest.Builder builder =
+ mEngine.newUrlRequestBuilder(URL, mCallback, mCallback.getExecutor());
+ builder.build().start();
+
+ mCallback.expectCallback(ResponseStep.ON_SUCCEEDED);
+ UrlResponseInfo info = mCallback.mResponseInfo;
+ assertOKStatusCode(info);
+ assertEquals("h2", info.getNegotiatedProtocol());
+ }
+
+ @Test
+ public void testHttpEngine_DisableHttp2() throws Exception {
+ mEngine = mEngineBuilder.setEnableHttp2(false).build();
+ UrlRequest.Builder builder =
+ mEngine.newUrlRequestBuilder(URL, mCallback, mCallback.getExecutor());
+ builder.build().start();
+
+ mCallback.expectCallback(ResponseStep.ON_SUCCEEDED);
+ UrlResponseInfo info = mCallback.mResponseInfo;
+ assertOKStatusCode(info);
+ assertEquals("http/1.1", info.getNegotiatedProtocol());
+ }
+
+ @Test
+ public void testHttpEngine_EnableQuic() throws Exception {
+ mEngine = mEngineBuilder.setEnableQuic(true).addQuicHint(HOST, 443, 443).build();
+ // The hint doesn't guarantee that QUIC will win the race, just that it will race TCP.
+ // We send multiple requests to reduce the flakiness of the test.
+ boolean quicWasUsed = false;
+ for (int i = 0; i < 5; i++) {
+ UrlRequest.Builder builder =
+ mEngine.newUrlRequestBuilder(URL, mCallback, mCallback.getExecutor());
+ builder.build().start();
+
+ mCallback.expectCallback(ResponseStep.ON_SUCCEEDED);
+ UrlResponseInfo info = mCallback.mResponseInfo;
+ assertOKStatusCode(info);
+ quicWasUsed = isQuic(info.getNegotiatedProtocol());
+ if (quicWasUsed) {
+ break;
+ }
+ }
+ assertTrue(quicWasUsed);
+ }
+
+ @Test
+ public void testHttpEngine_GetDefaultUserAgent() throws Exception {
+ assertThat(mEngineBuilder.getDefaultUserAgent(), containsString("AndroidHttpClient"));
+ }
+}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java b/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java
new file mode 100644
index 0000000..d7d3679
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.net.http.cts;
+
+import static android.net.http.cts.util.TestUtilsKt.assertOKStatusCode;
+import static android.net.http.cts.util.TestUtilsKt.skipIfNoInternetConnection;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.greaterThan;
+
+import android.content.Context;
+import android.net.http.HttpEngine;
+import android.net.http.UrlRequest;
+import android.net.http.UrlRequest.Status;
+import android.net.http.UrlResponseInfo;
+import android.net.http.cts.util.HttpCtsTestServer;
+import android.net.http.cts.util.TestStatusListener;
+import android.net.http.cts.util.TestUrlRequestCallback;
+import android.net.http.cts.util.TestUrlRequestCallback.ResponseStep;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.runner.AndroidJUnit4;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public class UrlRequestTest {
+ private TestUrlRequestCallback mCallback;
+ private HttpCtsTestServer mTestServer;
+ private HttpEngine mHttpEngine;
+
+ @Before
+ public void setUp() throws Exception {
+ Context context = InstrumentationRegistry.getInstrumentation().getContext();
+ skipIfNoInternetConnection(context);
+ HttpEngine.Builder builder = new HttpEngine.Builder(context);
+ mHttpEngine = builder.build();
+ mCallback = new TestUrlRequestCallback();
+ mTestServer = new HttpCtsTestServer(context);
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ if (mHttpEngine != null) {
+ mHttpEngine.shutdown();
+ }
+ if (mTestServer != null) {
+ mTestServer.shutdown();
+ }
+ }
+
+ private UrlRequest buildUrlRequest(String url) {
+ return mHttpEngine.newUrlRequestBuilder(url, mCallback, mCallback.getExecutor()).build();
+ }
+
+ @Test
+ public void testUrlRequestGet_CompletesSuccessfully() throws Exception {
+ String url = mTestServer.getSuccessUrl();
+ UrlRequest request = buildUrlRequest(url);
+ request.start();
+
+ mCallback.expectCallback(ResponseStep.ON_SUCCEEDED);
+ UrlResponseInfo info = mCallback.mResponseInfo;
+ assertOKStatusCode(info);
+ assertThat("Received byte count must be > 0", info.getReceivedByteCount(), greaterThan(0L));
+ }
+
+ @Test
+ public void testUrlRequestStatus_InvalidBeforeRequestStarts() throws Exception {
+ UrlRequest request = buildUrlRequest(mTestServer.getSuccessUrl());
+ // Calling before request is started should give Status.INVALID,
+ // since the native adapter is not created.
+ TestStatusListener statusListener = new TestStatusListener();
+ request.getStatus(statusListener);
+ statusListener.expectStatus(Status.INVALID);
+ }
+}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/util/CronetCtsTestServer.kt b/Cronet/tests/cts/src/android/net/http/cts/util/HttpCtsTestServer.kt
similarity index 82%
rename from Cronet/tests/cts/src/android/net/http/cts/util/CronetCtsTestServer.kt
rename to Cronet/tests/cts/src/android/net/http/cts/util/HttpCtsTestServer.kt
index 3ccb571..87d5108 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/util/CronetCtsTestServer.kt
+++ b/Cronet/tests/cts/src/android/net/http/cts/util/HttpCtsTestServer.kt
@@ -19,8 +19,8 @@
import android.content.Context
import android.webkit.cts.CtsTestServer
-/** Extends CtsTestServer to handle POST requests and other cronet specific test requests */
-class CronetCtsTestServer(context: Context) : CtsTestServer(context) {
+/** Extends CtsTestServer to handle POST requests and other test specific requests */
+class HttpCtsTestServer(context: Context) : CtsTestServer(context) {
val successUrl: String = getAssetUrl("html/hello_world.html")
}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/util/TestStatusListener.kt b/Cronet/tests/cts/src/android/net/http/cts/util/TestStatusListener.kt
new file mode 100644
index 0000000..e526c7d
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/util/TestStatusListener.kt
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.net.http.cts.util
+
+import android.net.http.UrlRequest.StatusListener
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.TimeUnit
+import org.junit.Assert.assertSame
+
+private const val TIMEOUT_MS = 12000L
+
+/** Test status listener for requests */
+class TestStatusListener : StatusListener() {
+ private val statusFuture = CompletableFuture<Int>()
+
+ override fun onStatus(status: Int) {
+ statusFuture.complete(status)
+ }
+
+ /** Fails if the expected status is not the returned status */
+ fun expectStatus(expected: Int) {
+ assertSame(expected, statusFuture.get(TIMEOUT_MS, TimeUnit.MILLISECONDS))
+ }
+}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/util/TestUploadDataProvider.java b/Cronet/tests/cts/src/android/net/http/cts/util/TestUploadDataProvider.java
new file mode 100644
index 0000000..d047828
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/util/TestUploadDataProvider.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.net.http.cts.util;
+
+import android.net.http.UploadDataProvider;
+import android.net.http.UploadDataSink;
+import android.os.ConditionVariable;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.ClosedChannelException;
+import java.util.ArrayList;
+import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/** An UploadDataProvider implementation used in tests. */
+public class TestUploadDataProvider extends UploadDataProvider {
+ // Indicates whether all success callbacks are synchronous or asynchronous.
+ // Doesn't apply to errors.
+ public enum SuccessCallbackMode {
+ SYNC,
+ ASYNC
+ }
+
+ // Indicates whether failures should throw exceptions, invoke callbacks
+ // synchronously, or invoke callback asynchronously.
+ public enum FailMode {
+ NONE,
+ THROWN,
+ CALLBACK_SYNC,
+ CALLBACK_ASYNC
+ }
+
+ private final ArrayList<byte[]> mReads = new ArrayList<byte[]>();
+ private final SuccessCallbackMode mSuccessCallbackMode;
+ private final Executor mExecutor;
+
+ private boolean mChunked;
+
+ // Index of read to fail on.
+ private int mReadFailIndex = -1;
+ // Indicates how to fail on a read.
+ private FailMode mReadFailMode = FailMode.NONE;
+
+ private FailMode mRewindFailMode = FailMode.NONE;
+
+ private FailMode mLengthFailMode = FailMode.NONE;
+
+ private int mNumReadCalls;
+ private int mNumRewindCalls;
+
+ private int mNextRead;
+ private boolean mStarted;
+ private boolean mReadPending;
+ private boolean mRewindPending;
+ // Used to ensure there are no read/rewind requests after a failure.
+ private boolean mFailed;
+
+ private final AtomicBoolean mClosed = new AtomicBoolean(false);
+ private final ConditionVariable mAwaitingClose = new ConditionVariable(false);
+
+ public TestUploadDataProvider(
+ SuccessCallbackMode successCallbackMode, final Executor executor) {
+ mSuccessCallbackMode = successCallbackMode;
+ mExecutor = executor;
+ }
+
+ // Adds the result to be returned by a successful read request. The
+ // returned bytes must all fit within the read buffer provided by Cronet.
+ // After a rewind, if there is one, all reads will be repeated.
+ public void addRead(byte[] read) {
+ if (mStarted) {
+ throw new IllegalStateException("Adding bytes after read");
+ }
+ mReads.add(read);
+ }
+
+ public void setReadFailure(int readFailIndex, FailMode readFailMode) {
+ mReadFailIndex = readFailIndex;
+ mReadFailMode = readFailMode;
+ }
+
+ public void setLengthFailure() {
+ mLengthFailMode = FailMode.THROWN;
+ }
+
+ public void setRewindFailure(FailMode rewindFailMode) {
+ mRewindFailMode = rewindFailMode;
+ }
+
+ public void setChunked(boolean chunked) {
+ mChunked = chunked;
+ }
+
+ public int getNumReadCalls() {
+ return mNumReadCalls;
+ }
+
+ public int getNumRewindCalls() {
+ return mNumRewindCalls;
+ }
+
+ /** Returns the cumulative length of all data added by calls to addRead. */
+ @Override
+ public long getLength() throws IOException {
+ if (mClosed.get()) {
+ throw new ClosedChannelException();
+ }
+ if (mLengthFailMode == FailMode.THROWN) {
+ throw new IllegalStateException("Sync length failure");
+ }
+ return getUploadedLength();
+ }
+
+ public long getUploadedLength() {
+ if (mChunked) {
+ return -1;
+ }
+ long length = 0;
+ for (byte[] read : mReads) {
+ length += read.length;
+ }
+ return length;
+ }
+
+ @Override
+ public void read(final UploadDataSink uploadDataSink, final ByteBuffer byteBuffer)
+ throws IOException {
+ int currentReadCall = mNumReadCalls;
+ ++mNumReadCalls;
+ if (mClosed.get()) {
+ throw new ClosedChannelException();
+ }
+ assertIdle();
+
+ if (maybeFailRead(currentReadCall, uploadDataSink)) {
+ mFailed = true;
+ return;
+ }
+
+ mReadPending = true;
+ mStarted = true;
+
+ final boolean finalChunk = (mChunked && mNextRead == mReads.size() - 1);
+ if (mNextRead < mReads.size()) {
+ if ((byteBuffer.limit() - byteBuffer.position()) < mReads.get(mNextRead).length) {
+ throw new IllegalStateException("Read buffer smaller than expected.");
+ }
+ byteBuffer.put(mReads.get(mNextRead));
+ ++mNextRead;
+ } else {
+ throw new IllegalStateException("Too many reads: " + mNextRead);
+ }
+
+ Runnable completeRunnable =
+ new Runnable() {
+ @Override
+ public void run() {
+ mReadPending = false;
+ uploadDataSink.onReadSucceeded(finalChunk);
+ }
+ };
+ if (mSuccessCallbackMode == SuccessCallbackMode.SYNC) {
+ completeRunnable.run();
+ } else {
+ mExecutor.execute(completeRunnable);
+ }
+ }
+
+ @Override
+ public void rewind(final UploadDataSink uploadDataSink) throws IOException {
+ ++mNumRewindCalls;
+ if (mClosed.get()) {
+ throw new ClosedChannelException();
+ }
+ assertIdle();
+
+ if (maybeFailRewind(uploadDataSink)) {
+ mFailed = true;
+ return;
+ }
+
+ if (mNextRead == 0) {
+ // Should never try and rewind when rewinding does nothing.
+ throw new IllegalStateException("Unexpected rewind when already at beginning");
+ }
+
+ mRewindPending = true;
+ mNextRead = 0;
+
+ Runnable completeRunnable =
+ new Runnable() {
+ @Override
+ public void run() {
+ mRewindPending = false;
+ uploadDataSink.onRewindSucceeded();
+ }
+ };
+ if (mSuccessCallbackMode == SuccessCallbackMode.SYNC) {
+ completeRunnable.run();
+ } else {
+ mExecutor.execute(completeRunnable);
+ }
+ }
+
+ private void assertIdle() {
+ if (mReadPending) {
+ throw new IllegalStateException("Unexpected operation during read");
+ }
+ if (mRewindPending) {
+ throw new IllegalStateException("Unexpected operation during rewind");
+ }
+ if (mFailed) {
+ throw new IllegalStateException("Unexpected operation after failure");
+ }
+ }
+
+ private boolean maybeFailRead(int readIndex, final UploadDataSink uploadDataSink) {
+ if (readIndex != mReadFailIndex) return false;
+
+ switch (mReadFailMode) {
+ case THROWN:
+ throw new IllegalStateException("Thrown read failure");
+ case CALLBACK_SYNC:
+ uploadDataSink.onReadError(new IllegalStateException("Sync read failure"));
+ return true;
+ case CALLBACK_ASYNC:
+ Runnable errorRunnable =
+ new Runnable() {
+ @Override
+ public void run() {
+ uploadDataSink.onReadError(
+ new IllegalStateException("Async read failure"));
+ }
+ };
+ mExecutor.execute(errorRunnable);
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ private boolean maybeFailRewind(final UploadDataSink uploadDataSink) {
+ switch (mRewindFailMode) {
+ case THROWN:
+ throw new IllegalStateException("Thrown rewind failure");
+ case CALLBACK_SYNC:
+ uploadDataSink.onRewindError(new IllegalStateException("Sync rewind failure"));
+ return true;
+ case CALLBACK_ASYNC:
+ Runnable errorRunnable =
+ new Runnable() {
+ @Override
+ public void run() {
+ uploadDataSink.onRewindError(
+ new IllegalStateException("Async rewind failure"));
+ }
+ };
+ mExecutor.execute(errorRunnable);
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ @Override
+ public void close() throws IOException {
+ if (!mClosed.compareAndSet(false, true)) {
+ throw new AssertionError("Closed twice");
+ }
+ mAwaitingClose.open();
+ }
+
+ public void assertClosed() {
+ mAwaitingClose.block(5000);
+ if (!mClosed.get()) {
+ throw new AssertionError("Was not closed");
+ }
+ }
+}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/util/TestUrlRequestCallback.java b/Cronet/tests/cts/src/android/net/http/cts/util/TestUrlRequestCallback.java
index c7143f5..0b9e90f 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/util/TestUrlRequestCallback.java
+++ b/Cronet/tests/cts/src/android/net/http/cts/util/TestUrlRequestCallback.java
@@ -24,15 +24,14 @@
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import android.net.http.CallbackException;
+import android.net.http.HttpException;
+import android.net.http.InlineExecutionProhibitedException;
+import android.net.http.UrlRequest;
+import android.net.http.UrlResponseInfo;
import android.os.ConditionVariable;
import android.os.StrictMode;
-import org.chromium.net.CallbackException;
-import org.chromium.net.CronetException;
-import org.chromium.net.InlineExecutionProhibitedException;
-import org.chromium.net.UrlRequest;
-import org.chromium.net.UrlResponseInfo;
-
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
@@ -50,7 +49,7 @@
public ArrayList<UrlResponseInfo> mRedirectResponseInfoList = new ArrayList<>();
public ArrayList<String> mRedirectUrlList = new ArrayList<>();
public UrlResponseInfo mResponseInfo;
- public CronetException mError;
+ public HttpException mError;
public ResponseStep mResponseStep = ResponseStep.NOTHING;
@@ -89,7 +88,7 @@
// Signaled on each step when mAutoAdvance is false.
private final ConditionVariable mStepBlock = new ConditionVariable();
- // Executor Service for Cronet callbacks.
+ // Executor Service for Http callbacks.
private final ExecutorService mExecutorService;
private Thread mExecutorThread;
@@ -349,7 +348,7 @@
}
@Override
- public void onFailed(UrlRequest request, UrlResponseInfo info, CronetException error) {
+ public void onFailed(UrlRequest request, UrlResponseInfo info, HttpException error) {
// If the failure is because of prohibited direct execution, the test shouldn't fail
// since the request already did.
if (error.getCause() instanceof InlineExecutionProhibitedException) {
diff --git a/Cronet/tests/cts/src/android/net/http/cts/util/TestUtils.kt b/Cronet/tests/cts/src/android/net/http/cts/util/TestUtils.kt
new file mode 100644
index 0000000..d30c059
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/util/TestUtils.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.net.http.cts.util
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.http.UrlResponseInfo
+import org.junit.Assert.assertEquals
+import org.junit.Assume.assumeNotNull
+
+fun skipIfNoInternetConnection(context: Context) {
+ val connectivityManager = context.getSystemService(ConnectivityManager::class.java)
+ assumeNotNull(
+ "This test requires a working Internet connection", connectivityManager.getActiveNetwork())
+}
+
+fun assertOKStatusCode(info: UrlResponseInfo) {
+ assertEquals("Status code must be 200 OK", 200, info.getHttpStatusCode())
+}
diff --git a/OWNERS_core_networking b/OWNERS_core_networking
index 172670e..6d17476 100644
--- a/OWNERS_core_networking
+++ b/OWNERS_core_networking
@@ -1,4 +1,3 @@
-chenbruce@google.com
chiachangwang@google.com
cken@google.com
huangaaron@google.com
diff --git a/TEST_MAPPING b/TEST_MAPPING
index 700a085..a1e81c8 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -64,6 +64,9 @@
"name": "connectivity_native_test"
},
{
+ "name": "CtsNetHttpTestCases"
+ },
+ {
"name": "libclat_test"
},
{
diff --git a/Tethering/AndroidManifest.xml b/Tethering/AndroidManifest.xml
index b832e16..23467e7 100644
--- a/Tethering/AndroidManifest.xml
+++ b/Tethering/AndroidManifest.xml
@@ -43,7 +43,9 @@
<uses-permission android:name="android.permission.WRITE_SETTINGS" />
<uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+ <!-- Sending non-protected broadcast from system uid is not allowed. -->
<protected-broadcast android:name="com.android.server.connectivity.tethering.DISABLE_TETHERING" />
+ <protected-broadcast android:name="com.android.server.connectivity.KeepaliveTracker.TCP_POLLING_ALARM" />
<application
android:process="com.android.networkstack.process"
diff --git a/Tethering/apex/Android.bp b/Tethering/apex/Android.bp
index 8840394..b26911c 100644
--- a/Tethering/apex/Android.bp
+++ b/Tethering/apex/Android.bp
@@ -50,11 +50,40 @@
// as the above target may have different "enabled" values
// depending on the branch
+// cronet_in_tethering_apex_defaults can be used to specify an apex_defaults target that either
+// enables or disables inclusion of Cronet in the Tethering apex. This is used to disable Cronet
+// on tm-mainline-prod. Note: in order for Cronet APIs to work Cronet must also be enabled
+// by the cronet_java_*_defaults in common/TetheringLib/Android.bp.
+cronet_in_tethering_apex_defaults = "CronetInTetheringApexDefaultsEnabled"
+// This is a placeholder comment to avoid merge conflicts
+// as cronet_apex_defaults may have different values
+// depending on the branch
+
+apex_defaults {
+ name: "CronetInTetheringApexDefaults",
+ defaults: [cronet_in_tethering_apex_defaults],
+}
+
+apex_defaults {
+ name: "CronetInTetheringApexDefaultsEnabled",
+ jni_libs: ["cronet_aml_components_cronet_android_cronet"],
+ arch: {
+ riscv64: {
+ // TODO: remove this when there is a riscv64 libcronet
+ exclude_jni_libs: ["cronet_aml_components_cronet_android_cronet"],
+ },
+ },
+}
+
+apex_defaults {
+ name: "CronetInTetheringApexDefaultsDisabled",
+}
+
apex {
name: "com.android.tethering",
defaults: [
"ConnectivityApexDefaults",
- "CronetApexDefaults",
+ "CronetInTetheringApexDefaults",
"r-launched-apex-module",
],
compile_multilib: "both",
@@ -183,6 +212,7 @@
"android.app.usage",
"android.nearby",
"android.net",
+ "android.net.http",
"android.net.netstats",
"android.net.util",
],
@@ -197,6 +227,8 @@
"android.nearby.aidl",
"android.net.apf",
"android.net.connectivity",
+ "android.net.http.apihelpers",
+ "android.net.http.internal",
"android.net.netstats.provider",
"android.net.nsd",
"android.net.wear",
diff --git a/Tethering/common/TetheringLib/Android.bp b/Tethering/common/TetheringLib/Android.bp
index 3f4da10..4c677d0 100644
--- a/Tethering/common/TetheringLib/Android.bp
+++ b/Tethering/common/TetheringLib/Android.bp
@@ -17,8 +17,6 @@
default_applicable_licenses: ["Android-Apache-2.0"],
}
-// TODO: This is currently not used, but is being merged early, so Cronet can be disabled in
-// tm-mainline-prod.
// Both cronet_java_defaults and cronet_java_prejarjar_defaults can be used to
// specify a java_defaults target that either enables or disables Cronet. This
// is used to disable Cronet on tm-mainline-prod.
@@ -31,7 +29,10 @@
java_sdk_library {
name: "framework-tethering",
- defaults: ["framework-module-defaults"],
+ defaults: [
+ "CronetJavaDefaults",
+ "framework-tethering-defaults",
+ ],
impl_library_visibility: [
"//packages/modules/Connectivity/Tethering:__subpackages__",
"//packages/modules/Connectivity/framework",
@@ -57,24 +58,103 @@
"//packages/modules/NetworkStack/tests:__subpackages__",
"//packages/modules/Wifi/service/tests/wifitests",
],
-
- srcs: [":framework-tethering-srcs"],
- libs: ["framework-connectivity.stubs.module_lib"],
stub_only_libs: ["framework-connectivity.stubs.module_lib"],
+
+ jarjar_rules: ":framework-tethering-jarjar-rules",
+ installable: true,
+
+ hostdex: true, // for hiddenapi check
+ permitted_packages: ["android.net"],
+}
+
+java_defaults {
+ name: "CronetJavaDefaults",
+ defaults: [cronet_java_defaults],
+}
+
+java_defaults {
+ name: "CronetJavaDefaultsEnabled",
+ srcs: [":cronet_aml_api_sources"],
+ libs: [
+ "androidx.annotation_annotation",
+ ],
+ impl_only_static_libs: [
+ "cronet_aml_java",
+ ],
+ // STOPSHIP(b/265674359): fix all Cronet lint warnings and re-enable lint
+ // directly in framework-tethering
+ lint: {
+ enabled: false,
+ },
+ api_lint: {
+ enabled: false,
+ },
+ api_dir: "cronet_enabled/api",
+}
+
+java_defaults {
+ name: "CronetJavaDefaultsDisabled",
+ lint: { strict_updatability_linting: true },
+}
+
+java_defaults {
+ name: "CronetJavaPrejarjarDefaults",
+ defaults: [cronet_java_prejarjar_defaults],
+}
+
+java_defaults {
+ name: "CronetJavaPrejarjarDefaultsDisabled",
+}
+
+java_defaults {
+ name: "CronetJavaPrejarjarDefaultsEnabled",
+ static_libs: [
+ "cronet_aml_api_java",
+ "cronet_aml_java"
+ ],
+}
+
+java_library {
+ name: "framework-tethering-pre-jarjar",
+ defaults: [
+ "framework-tethering-defaults",
+ "CronetJavaPrejarjarDefaults",
+ ],
+}
+
+java_genrule {
+ name: "framework-tethering-jarjar-rules",
+ tool_files: [
+ ":framework-tethering-pre-jarjar{.jar}",
+ ":framework-tethering.stubs.module_lib{.jar}",
+ "jarjar-excludes.txt",
+ ],
+ tools: [
+ "jarjar-rules-generator",
+ ],
+ out: ["framework_tethering_jarjar_rules.txt"],
+ cmd: "$(location jarjar-rules-generator) " +
+ "$(location :framework-tethering-pre-jarjar{.jar}) " +
+ "--apistubs $(location :framework-tethering.stubs.module_lib{.jar}) " +
+ "--prefix android.net.http.internal " +
+ "--excludes $(location jarjar-excludes.txt) " +
+ "--output $(out)",
+}
+
+java_defaults {
+ name: "framework-tethering-defaults",
+ defaults: ["framework-module-defaults"],
+ srcs: [
+ ":framework-tethering-srcs"
+ ],
+ libs: ["framework-connectivity.stubs.module_lib"],
aidl: {
include_dirs: [
"packages/modules/Connectivity/framework/aidl-export",
],
},
-
- jarjar_rules: "jarjar-rules.txt",
- installable: true,
-
- hostdex: true, // for hiddenapi check
apex_available: ["com.android.tethering"],
- permitted_packages: ["android.net"],
min_sdk_version: "30",
- lint: { strict_updatability_linting: true },
}
filegroup {
diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/current.txt b/Tethering/common/TetheringLib/cronet_enabled/api/current.txt
new file mode 100644
index 0000000..c0157b7
--- /dev/null
+++ b/Tethering/common/TetheringLib/cronet_enabled/api/current.txt
@@ -0,0 +1,194 @@
+// Signature format: 2.0
+package android.net.http {
+
+ public abstract class CallbackException extends android.net.http.HttpException {
+ ctor protected CallbackException(String, Throwable);
+ }
+
+ public class ConnectionMigrationOptions {
+ method @Nullable public Boolean getEnableDefaultNetworkMigration();
+ method @Nullable public Boolean getEnablePathDegradationMigration();
+ }
+
+ public static class ConnectionMigrationOptions.Builder {
+ ctor public ConnectionMigrationOptions.Builder();
+ method public android.net.http.ConnectionMigrationOptions build();
+ method public android.net.http.ConnectionMigrationOptions.Builder setEnableDefaultNetworkMigration(boolean);
+ method public android.net.http.ConnectionMigrationOptions.Builder setEnablePathDegradationMigration(boolean);
+ }
+
+ public final class DnsOptions {
+ method @Nullable public Boolean getPersistHostCache();
+ method @Nullable public java.time.Duration getPersistHostCachePeriod();
+ }
+
+ public static final class DnsOptions.Builder {
+ ctor public DnsOptions.Builder();
+ method public android.net.http.DnsOptions build();
+ method public android.net.http.DnsOptions.Builder setPersistHostCache(boolean);
+ method public android.net.http.DnsOptions.Builder setPersistHostCachePeriod(java.time.Duration);
+ }
+
+ public abstract class HttpEngine {
+ method public abstract java.net.URLStreamHandlerFactory createURLStreamHandlerFactory();
+ method public abstract String getVersionString();
+ method public abstract android.net.http.UrlRequest.Builder newUrlRequestBuilder(String, android.net.http.UrlRequest.Callback, java.util.concurrent.Executor);
+ method public abstract java.net.URLConnection openConnection(java.net.URL) throws java.io.IOException;
+ method public abstract void shutdown();
+ }
+
+ public static class HttpEngine.Builder {
+ ctor public HttpEngine.Builder(android.content.Context);
+ method public android.net.http.HttpEngine.Builder addPublicKeyPins(String, java.util.Set<byte[]>, boolean, java.time.Instant);
+ method public android.net.http.HttpEngine.Builder addQuicHint(String, int, int);
+ method public android.net.http.HttpEngine build();
+ method public String getDefaultUserAgent();
+ method public android.net.http.HttpEngine.Builder setConnectionMigrationOptions(android.net.http.ConnectionMigrationOptions);
+ method public android.net.http.HttpEngine.Builder setDnsOptions(android.net.http.DnsOptions);
+ method public android.net.http.HttpEngine.Builder setEnableBrotli(boolean);
+ method public android.net.http.HttpEngine.Builder setEnableHttp2(boolean);
+ method public android.net.http.HttpEngine.Builder setEnableHttpCache(int, long);
+ method public android.net.http.HttpEngine.Builder setEnablePublicKeyPinningBypassForLocalTrustAnchors(boolean);
+ method public android.net.http.HttpEngine.Builder setEnableQuic(boolean);
+ method public android.net.http.HttpEngine.Builder setQuicOptions(android.net.http.QuicOptions);
+ method public android.net.http.HttpEngine.Builder setStoragePath(String);
+ method public android.net.http.HttpEngine.Builder setUserAgent(String);
+ field public static final int HTTP_CACHE_DISABLED = 0; // 0x0
+ field public static final int HTTP_CACHE_DISK = 3; // 0x3
+ field public static final int HTTP_CACHE_DISK_NO_HTTP = 2; // 0x2
+ field public static final int HTTP_CACHE_IN_MEMORY = 1; // 0x1
+ }
+
+ public class HttpException extends java.io.IOException {
+ ctor public HttpException(String, Throwable);
+ }
+
+ public final class InlineExecutionProhibitedException extends java.util.concurrent.RejectedExecutionException {
+ ctor public InlineExecutionProhibitedException();
+ }
+
+ public abstract class NetworkException extends android.net.http.HttpException {
+ ctor public NetworkException(String, Throwable);
+ method public abstract int getErrorCode();
+ method public abstract boolean isImmediatelyRetryable();
+ field public static final int ERROR_ADDRESS_UNREACHABLE = 9; // 0x9
+ field public static final int ERROR_CONNECTION_CLOSED = 5; // 0x5
+ field public static final int ERROR_CONNECTION_REFUSED = 7; // 0x7
+ field public static final int ERROR_CONNECTION_RESET = 8; // 0x8
+ field public static final int ERROR_CONNECTION_TIMED_OUT = 6; // 0x6
+ field public static final int ERROR_HOSTNAME_NOT_RESOLVED = 1; // 0x1
+ field public static final int ERROR_INTERNET_DISCONNECTED = 2; // 0x2
+ field public static final int ERROR_NETWORK_CHANGED = 3; // 0x3
+ field public static final int ERROR_OTHER = 11; // 0xb
+ field public static final int ERROR_QUIC_PROTOCOL_FAILED = 10; // 0xa
+ field public static final int ERROR_TIMED_OUT = 4; // 0x4
+ }
+
+ public abstract class QuicException extends android.net.http.NetworkException {
+ ctor protected QuicException(String, Throwable);
+ }
+
+ public class QuicOptions {
+ method @Nullable public String getHandshakeUserAgent();
+ method @Nullable public Integer getInMemoryServerConfigsCacheSize();
+ method public java.util.Set<java.lang.String> getQuicHostAllowlist();
+ }
+
+ public static class QuicOptions.Builder {
+ ctor public QuicOptions.Builder();
+ method public android.net.http.QuicOptions.Builder addAllowedQuicHost(String);
+ method public android.net.http.QuicOptions build();
+ method public android.net.http.QuicOptions.Builder setHandshakeUserAgent(String);
+ method public android.net.http.QuicOptions.Builder setInMemoryServerConfigsCacheSize(int);
+ }
+
+ public abstract class UploadDataProvider implements java.io.Closeable {
+ ctor public UploadDataProvider();
+ method public void close() throws java.io.IOException;
+ method public abstract long getLength() throws java.io.IOException;
+ method public abstract void read(android.net.http.UploadDataSink, java.nio.ByteBuffer) throws java.io.IOException;
+ method public abstract void rewind(android.net.http.UploadDataSink) throws java.io.IOException;
+ }
+
+ public abstract class UploadDataSink {
+ ctor public UploadDataSink();
+ method public abstract void onReadError(Exception);
+ method public abstract void onReadSucceeded(boolean);
+ method public abstract void onRewindError(Exception);
+ method public abstract void onRewindSucceeded();
+ }
+
+ public abstract class UrlRequest {
+ method public abstract void cancel();
+ method public abstract void followRedirect();
+ method public abstract void getStatus(android.net.http.UrlRequest.StatusListener);
+ method public abstract boolean isDone();
+ method public abstract void read(java.nio.ByteBuffer);
+ method public abstract void start();
+ }
+
+ public abstract static class UrlRequest.Builder {
+ method public abstract android.net.http.UrlRequest.Builder addHeader(String, String);
+ method public abstract android.net.http.UrlRequest.Builder allowDirectExecutor();
+ method public abstract android.net.http.UrlRequest build();
+ method public abstract android.net.http.UrlRequest.Builder disableCache();
+ method public abstract android.net.http.UrlRequest.Builder setHttpMethod(String);
+ method public abstract android.net.http.UrlRequest.Builder setPriority(int);
+ method public abstract android.net.http.UrlRequest.Builder setUploadDataProvider(android.net.http.UploadDataProvider, java.util.concurrent.Executor);
+ field public static final int REQUEST_PRIORITY_HIGHEST = 4; // 0x4
+ field public static final int REQUEST_PRIORITY_IDLE = 0; // 0x0
+ field public static final int REQUEST_PRIORITY_LOW = 2; // 0x2
+ field public static final int REQUEST_PRIORITY_LOWEST = 1; // 0x1
+ field public static final int REQUEST_PRIORITY_MEDIUM = 3; // 0x3
+ }
+
+ public abstract static class UrlRequest.Callback {
+ ctor public UrlRequest.Callback();
+ method public void onCanceled(android.net.http.UrlRequest, android.net.http.UrlResponseInfo);
+ method public abstract void onFailed(android.net.http.UrlRequest, android.net.http.UrlResponseInfo, android.net.http.HttpException);
+ method public abstract void onReadCompleted(android.net.http.UrlRequest, android.net.http.UrlResponseInfo, java.nio.ByteBuffer) throws java.lang.Exception;
+ method public abstract void onRedirectReceived(android.net.http.UrlRequest, android.net.http.UrlResponseInfo, String) throws java.lang.Exception;
+ method public abstract void onResponseStarted(android.net.http.UrlRequest, android.net.http.UrlResponseInfo) throws java.lang.Exception;
+ method public abstract void onSucceeded(android.net.http.UrlRequest, android.net.http.UrlResponseInfo);
+ }
+
+ public static class UrlRequest.Status {
+ field public static final int CONNECTING = 10; // 0xa
+ field public static final int DOWNLOADING_PAC_FILE = 5; // 0x5
+ field public static final int ESTABLISHING_PROXY_TUNNEL = 8; // 0x8
+ field public static final int IDLE = 0; // 0x0
+ field public static final int INVALID = -1; // 0xffffffff
+ field public static final int READING_RESPONSE = 14; // 0xe
+ field public static final int RESOLVING_HOST = 9; // 0x9
+ field public static final int RESOLVING_HOST_IN_PAC_FILE = 7; // 0x7
+ field public static final int RESOLVING_PROXY_FOR_URL = 6; // 0x6
+ field public static final int SENDING_REQUEST = 12; // 0xc
+ field public static final int SSL_HANDSHAKE = 11; // 0xb
+ field public static final int WAITING_FOR_AVAILABLE_SOCKET = 2; // 0x2
+ field public static final int WAITING_FOR_CACHE = 4; // 0x4
+ field public static final int WAITING_FOR_DELEGATE = 3; // 0x3
+ field public static final int WAITING_FOR_RESPONSE = 13; // 0xd
+ field public static final int WAITING_FOR_STALLED_SOCKET_POOL = 1; // 0x1
+ }
+
+ public abstract static class UrlRequest.StatusListener {
+ ctor public UrlRequest.StatusListener();
+ method public abstract void onStatus(int);
+ }
+
+ public abstract class UrlResponseInfo {
+ ctor public UrlResponseInfo();
+ method public abstract java.util.Map<java.lang.String,java.util.List<java.lang.String>> getAllHeaders();
+ method public abstract java.util.List<java.util.Map.Entry<java.lang.String,java.lang.String>> getAllHeadersAsList();
+ method public abstract int getHttpStatusCode();
+ method public abstract String getHttpStatusText();
+ method public abstract String getNegotiatedProtocol();
+ method public abstract String getProxyServer();
+ method public abstract long getReceivedByteCount();
+ method public abstract String getUrl();
+ method public abstract java.util.List<java.lang.String> getUrlChain();
+ method public abstract boolean wasCached();
+ }
+
+}
+
diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-current.txt b/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-current.txt
new file mode 100644
index 0000000..460c216
--- /dev/null
+++ b/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-current.txt
@@ -0,0 +1,50 @@
+// Signature format: 2.0
+package android.net {
+
+ public final class TetheringConstants {
+ field public static final String EXTRA_ADD_TETHER_TYPE = "extraAddTetherType";
+ field public static final String EXTRA_PROVISION_CALLBACK = "extraProvisionCallback";
+ field public static final String EXTRA_REM_TETHER_TYPE = "extraRemTetherType";
+ field public static final String EXTRA_RUN_PROVISION = "extraRunProvision";
+ field public static final String EXTRA_SET_ALARM = "extraSetAlarm";
+ }
+
+ public class TetheringManager {
+ ctor public TetheringManager(@NonNull android.content.Context, @NonNull java.util.function.Supplier<android.os.IBinder>);
+ method public int getLastTetherError(@NonNull String);
+ method @NonNull public String[] getTetherableBluetoothRegexs();
+ method @NonNull public String[] getTetherableIfaces();
+ method @NonNull public String[] getTetherableUsbRegexs();
+ method @NonNull public String[] getTetherableWifiRegexs();
+ method @NonNull public String[] getTetheredIfaces();
+ method @NonNull public String[] getTetheringErroredIfaces();
+ method public boolean isTetheringSupported();
+ method public boolean isTetheringSupported(@NonNull String);
+ method public void requestLatestTetheringEntitlementResult(int, @NonNull android.os.ResultReceiver, boolean);
+ method @Deprecated public int setUsbTethering(boolean);
+ method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.WRITE_SETTINGS}) public void startTethering(int, @NonNull java.util.concurrent.Executor, @NonNull android.net.TetheringManager.StartTetheringCallback);
+ method @Deprecated public int tether(@NonNull String);
+ method @Deprecated public int untether(@NonNull String);
+ }
+
+ public static interface TetheringManager.TetheredInterfaceCallback {
+ method public void onAvailable(@NonNull String);
+ method public void onUnavailable();
+ }
+
+ public static interface TetheringManager.TetheredInterfaceRequest {
+ method public void release();
+ }
+
+ public static interface TetheringManager.TetheringEventCallback {
+ method @Deprecated public default void onTetherableInterfaceRegexpsChanged(@NonNull android.net.TetheringManager.TetheringInterfaceRegexps);
+ }
+
+ @Deprecated public static class TetheringManager.TetheringInterfaceRegexps {
+ method @Deprecated @NonNull public java.util.List<java.lang.String> getTetherableBluetoothRegexs();
+ method @Deprecated @NonNull public java.util.List<java.lang.String> getTetherableUsbRegexs();
+ method @Deprecated @NonNull public java.util.List<java.lang.String> getTetherableWifiRegexs();
+ }
+
+}
+
diff --git a/Cronet/api/module-lib-removed.txt b/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-removed.txt
similarity index 100%
rename from Cronet/api/module-lib-removed.txt
rename to Tethering/common/TetheringLib/cronet_enabled/api/module-lib-removed.txt
diff --git a/Cronet/api/removed.txt b/Tethering/common/TetheringLib/cronet_enabled/api/removed.txt
similarity index 100%
rename from Cronet/api/removed.txt
rename to Tethering/common/TetheringLib/cronet_enabled/api/removed.txt
diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/system-current.txt b/Tethering/common/TetheringLib/cronet_enabled/api/system-current.txt
new file mode 100644
index 0000000..844ff64
--- /dev/null
+++ b/Tethering/common/TetheringLib/cronet_enabled/api/system-current.txt
@@ -0,0 +1,117 @@
+// Signature format: 2.0
+package android.net {
+
+ public final class TetheredClient implements android.os.Parcelable {
+ ctor public TetheredClient(@NonNull android.net.MacAddress, @NonNull java.util.Collection<android.net.TetheredClient.AddressInfo>, int);
+ method public int describeContents();
+ method @NonNull public java.util.List<android.net.TetheredClient.AddressInfo> getAddresses();
+ method @NonNull public android.net.MacAddress getMacAddress();
+ method public int getTetheringType();
+ method public void writeToParcel(@NonNull android.os.Parcel, int);
+ field @NonNull public static final android.os.Parcelable.Creator<android.net.TetheredClient> CREATOR;
+ }
+
+ public static final class TetheredClient.AddressInfo implements android.os.Parcelable {
+ method public int describeContents();
+ method @NonNull public android.net.LinkAddress getAddress();
+ method @Nullable public String getHostname();
+ method public void writeToParcel(@NonNull android.os.Parcel, int);
+ field @NonNull public static final android.os.Parcelable.Creator<android.net.TetheredClient.AddressInfo> CREATOR;
+ }
+
+ public final class TetheringInterface implements android.os.Parcelable {
+ ctor public TetheringInterface(int, @NonNull String);
+ method public int describeContents();
+ method @NonNull public String getInterface();
+ method public int getType();
+ method public void writeToParcel(@NonNull android.os.Parcel, int);
+ field @NonNull public static final android.os.Parcelable.Creator<android.net.TetheringInterface> CREATOR;
+ }
+
+ public class TetheringManager {
+ method @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void registerTetheringEventCallback(@NonNull java.util.concurrent.Executor, @NonNull android.net.TetheringManager.TetheringEventCallback);
+ method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.WRITE_SETTINGS}) public void requestLatestTetheringEntitlementResult(int, boolean, @NonNull java.util.concurrent.Executor, @NonNull android.net.TetheringManager.OnTetheringEntitlementResultListener);
+ method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.WRITE_SETTINGS}) public void startTethering(@NonNull android.net.TetheringManager.TetheringRequest, @NonNull java.util.concurrent.Executor, @NonNull android.net.TetheringManager.StartTetheringCallback);
+ method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.WRITE_SETTINGS}) public void stopAllTethering();
+ method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.WRITE_SETTINGS}) public void stopTethering(int);
+ method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.ACCESS_NETWORK_STATE}) public void unregisterTetheringEventCallback(@NonNull android.net.TetheringManager.TetheringEventCallback);
+ field @Deprecated public static final String ACTION_TETHER_STATE_CHANGED = "android.net.conn.TETHER_STATE_CHANGED";
+ field public static final int CONNECTIVITY_SCOPE_GLOBAL = 1; // 0x1
+ field public static final int CONNECTIVITY_SCOPE_LOCAL = 2; // 0x2
+ field public static final String EXTRA_ACTIVE_LOCAL_ONLY = "android.net.extra.ACTIVE_LOCAL_ONLY";
+ field public static final String EXTRA_ACTIVE_TETHER = "tetherArray";
+ field public static final String EXTRA_AVAILABLE_TETHER = "availableArray";
+ field public static final String EXTRA_ERRORED_TETHER = "erroredArray";
+ field public static final int TETHERING_BLUETOOTH = 2; // 0x2
+ field public static final int TETHERING_ETHERNET = 5; // 0x5
+ field public static final int TETHERING_INVALID = -1; // 0xffffffff
+ field public static final int TETHERING_NCM = 4; // 0x4
+ field public static final int TETHERING_USB = 1; // 0x1
+ field public static final int TETHERING_WIFI = 0; // 0x0
+ field public static final int TETHERING_WIFI_P2P = 3; // 0x3
+ field public static final int TETHER_ERROR_DHCPSERVER_ERROR = 12; // 0xc
+ field public static final int TETHER_ERROR_DISABLE_FORWARDING_ERROR = 9; // 0x9
+ field public static final int TETHER_ERROR_ENABLE_FORWARDING_ERROR = 8; // 0x8
+ field public static final int TETHER_ERROR_ENTITLEMENT_UNKNOWN = 13; // 0xd
+ field public static final int TETHER_ERROR_IFACE_CFG_ERROR = 10; // 0xa
+ field public static final int TETHER_ERROR_INTERNAL_ERROR = 5; // 0x5
+ field public static final int TETHER_ERROR_NO_ACCESS_TETHERING_PERMISSION = 15; // 0xf
+ field public static final int TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION = 14; // 0xe
+ field public static final int TETHER_ERROR_NO_ERROR = 0; // 0x0
+ field public static final int TETHER_ERROR_PROVISIONING_FAILED = 11; // 0xb
+ field public static final int TETHER_ERROR_SERVICE_UNAVAIL = 2; // 0x2
+ field public static final int TETHER_ERROR_TETHER_IFACE_ERROR = 6; // 0x6
+ field public static final int TETHER_ERROR_UNAVAIL_IFACE = 4; // 0x4
+ field public static final int TETHER_ERROR_UNKNOWN_IFACE = 1; // 0x1
+ field public static final int TETHER_ERROR_UNKNOWN_TYPE = 16; // 0x10
+ field public static final int TETHER_ERROR_UNSUPPORTED = 3; // 0x3
+ field public static final int TETHER_ERROR_UNTETHER_IFACE_ERROR = 7; // 0x7
+ field public static final int TETHER_HARDWARE_OFFLOAD_FAILED = 2; // 0x2
+ field public static final int TETHER_HARDWARE_OFFLOAD_STARTED = 1; // 0x1
+ field public static final int TETHER_HARDWARE_OFFLOAD_STOPPED = 0; // 0x0
+ }
+
+ public static interface TetheringManager.OnTetheringEntitlementResultListener {
+ method public void onTetheringEntitlementResult(int);
+ }
+
+ public static interface TetheringManager.StartTetheringCallback {
+ method public default void onTetheringFailed(int);
+ method public default void onTetheringStarted();
+ }
+
+ public static interface TetheringManager.TetheringEventCallback {
+ method public default void onClientsChanged(@NonNull java.util.Collection<android.net.TetheredClient>);
+ method public default void onError(@NonNull String, int);
+ method public default void onError(@NonNull android.net.TetheringInterface, int);
+ method public default void onLocalOnlyInterfacesChanged(@NonNull java.util.List<java.lang.String>);
+ method public default void onLocalOnlyInterfacesChanged(@NonNull java.util.Set<android.net.TetheringInterface>);
+ method public default void onOffloadStatusChanged(int);
+ method public default void onTetherableInterfacesChanged(@NonNull java.util.List<java.lang.String>);
+ method public default void onTetherableInterfacesChanged(@NonNull java.util.Set<android.net.TetheringInterface>);
+ method public default void onTetheredInterfacesChanged(@NonNull java.util.List<java.lang.String>);
+ method public default void onTetheredInterfacesChanged(@NonNull java.util.Set<android.net.TetheringInterface>);
+ method public default void onTetheringSupported(boolean);
+ method public default void onUpstreamChanged(@Nullable android.net.Network);
+ }
+
+ public static class TetheringManager.TetheringRequest {
+ method @Nullable public android.net.LinkAddress getClientStaticIpv4Address();
+ method public int getConnectivityScope();
+ method @Nullable public android.net.LinkAddress getLocalIpv4Address();
+ method public boolean getShouldShowEntitlementUi();
+ method public int getTetheringType();
+ method public boolean isExemptFromEntitlementCheck();
+ }
+
+ public static class TetheringManager.TetheringRequest.Builder {
+ ctor public TetheringManager.TetheringRequest.Builder(int);
+ method @NonNull public android.net.TetheringManager.TetheringRequest build();
+ method @NonNull @RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED) public android.net.TetheringManager.TetheringRequest.Builder setConnectivityScope(int);
+ method @NonNull @RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED) public android.net.TetheringManager.TetheringRequest.Builder setExemptFromEntitlementCheck(boolean);
+ method @NonNull @RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED) public android.net.TetheringManager.TetheringRequest.Builder setShouldShowEntitlementUi(boolean);
+ method @NonNull @RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED) public android.net.TetheringManager.TetheringRequest.Builder setStaticIpv4Addresses(@NonNull android.net.LinkAddress, @NonNull android.net.LinkAddress);
+ }
+
+}
+
diff --git a/Cronet/api/system-removed.txt b/Tethering/common/TetheringLib/cronet_enabled/api/system-removed.txt
similarity index 100%
rename from Cronet/api/system-removed.txt
rename to Tethering/common/TetheringLib/cronet_enabled/api/system-removed.txt
diff --git a/Tethering/common/TetheringLib/jarjar-excludes.txt b/Tethering/common/TetheringLib/jarjar-excludes.txt
new file mode 100644
index 0000000..50bc186
--- /dev/null
+++ b/Tethering/common/TetheringLib/jarjar-excludes.txt
@@ -0,0 +1,2 @@
+# Don't touch anything that's already under android.net
+android\.net\..+
\ No newline at end of file
diff --git a/Tethering/common/TetheringLib/jarjar-rules.txt b/Tethering/common/TetheringLib/jarjar-rules.txt
deleted file mode 100644
index e459fad..0000000
--- a/Tethering/common/TetheringLib/jarjar-rules.txt
+++ /dev/null
@@ -1 +0,0 @@
-# jarjar rules for the bootclasspath tethering framework library here
\ No newline at end of file
diff --git a/Tethering/src/com/android/networkstack/tethering/BpfCoordinator.java b/Tethering/src/com/android/networkstack/tethering/BpfCoordinator.java
index 44d3ffc..9f8d9b1 100644
--- a/Tethering/src/com/android/networkstack/tethering/BpfCoordinator.java
+++ b/Tethering/src/com/android/networkstack/tethering/BpfCoordinator.java
@@ -2243,5 +2243,13 @@
return mTetherClients;
}
+ // Return map of upstream interface IPv4 address to interface index.
+ // This is used for testing only.
+ @NonNull
+ @VisibleForTesting
+ final HashMap<Inet4Address, Integer> getIpv4UpstreamIndicesForTesting() {
+ return mIpv4UpstreamIndices;
+ }
+
private static native String[] getBpfCounterNames();
}
diff --git a/Tethering/tests/unit/src/com/android/networkstack/tethering/BpfCoordinatorTest.java b/Tethering/tests/unit/src/com/android/networkstack/tethering/BpfCoordinatorTest.java
index 1978e99..4f32f3c 100644
--- a/Tethering/tests/unit/src/com/android/networkstack/tethering/BpfCoordinatorTest.java
+++ b/Tethering/tests/unit/src/com/android/networkstack/tethering/BpfCoordinatorTest.java
@@ -16,6 +16,8 @@
package com.android.networkstack.tethering;
+import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
+import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
import static android.net.NetworkStats.DEFAULT_NETWORK_NO;
import static android.net.NetworkStats.METERED_NO;
import static android.net.NetworkStats.ROAMING_NO;
@@ -77,6 +79,7 @@
import android.app.usage.NetworkStatsManager;
import android.net.INetd;
import android.net.InetAddresses;
+import android.net.IpPrefix;
import android.net.LinkAddress;
import android.net.LinkProperties;
import android.net.MacAddress;
@@ -89,6 +92,7 @@
import android.os.Build;
import android.os.Handler;
import android.os.test.TestLooper;
+import android.util.SparseArray;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
@@ -156,11 +160,13 @@
private static final int INVALID_IFINDEX = 0;
private static final int UPSTREAM_IFINDEX = 1001;
+ private static final int UPSTREAM_XLAT_IFINDEX = 1002;
private static final int UPSTREAM_IFINDEX2 = 1003;
private static final int DOWNSTREAM_IFINDEX = 2001;
private static final int DOWNSTREAM_IFINDEX2 = 2002;
private static final String UPSTREAM_IFACE = "rmnet0";
+ private static final String UPSTREAM_XLAT_IFACE = "v4-rmnet0";
private static final String UPSTREAM_IFACE2 = "wlan0";
private static final MacAddress DOWNSTREAM_MAC = MacAddress.fromString("12:34:56:78:90:ab");
@@ -183,6 +189,10 @@
private static final Inet4Address PRIVATE_ADDR2 =
(Inet4Address) InetAddresses.parseNumericAddress("192.168.90.12");
+ private static final Inet4Address XLAT_LOCAL_IPV4ADDR =
+ (Inet4Address) InetAddresses.parseNumericAddress("192.0.0.46");
+ private static final IpPrefix NAT64_IP_PREFIX = new IpPrefix("64:ff9b::/96");
+
// Generally, public port and private port are the same in the NAT conntrack message.
// TODO: consider using different private port and public port for testing.
private static final short REMOTE_PORT = (short) 443;
@@ -194,6 +204,10 @@
private static final InterfaceParams UPSTREAM_IFACE_PARAMS = new InterfaceParams(
UPSTREAM_IFACE, UPSTREAM_IFINDEX, null /* macAddr, rawip */,
NetworkStackConstants.ETHER_MTU);
+ private static final InterfaceParams UPSTREAM_XLAT_IFACE_PARAMS = new InterfaceParams(
+ UPSTREAM_XLAT_IFACE, UPSTREAM_XLAT_IFINDEX, null /* macAddr, rawip */,
+ NetworkStackConstants.ETHER_MTU - 28
+ /* mtu delta from external/android-clat/clatd.c */);
private static final InterfaceParams UPSTREAM_IFACE_PARAMS2 = new InterfaceParams(
UPSTREAM_IFACE2, UPSTREAM_IFINDEX2, MacAddress.fromString("44:55:66:00:00:0c"),
NetworkStackConstants.ETHER_MTU);
@@ -2281,4 +2295,170 @@
verifyAddTetherOffloadRule4Mtu(INVALID_MTU, false /* isKernelMtu */,
NetworkStackConstants.ETHER_MTU /* expectedMtu */);
}
+
+ private static LinkProperties buildUpstreamLinkProperties(final String interfaceName,
+ boolean withIPv4, boolean withIPv6, boolean with464xlat) {
+ final LinkProperties prop = new LinkProperties();
+ prop.setInterfaceName(interfaceName);
+
+ if (withIPv4) {
+ // Assign the address no matter what the interface is. It is okay for now because
+ // only single upstream is available.
+ // TODO: consider to assign address by interface once we need to test two or more
+ // BPF supported upstreams or multi upstreams are supported.
+ prop.addLinkAddress(new LinkAddress(PUBLIC_ADDR, 24));
+ }
+
+ if (withIPv6) {
+ // TODO: make this to be constant. Currently, no test who uses this function cares what
+ // the upstream IPv6 address is.
+ prop.addLinkAddress(new LinkAddress("2001:db8::5175:15ca/64"));
+ }
+
+ if (with464xlat) {
+ final String clatInterface = "v4-" + interfaceName;
+ final LinkProperties stackedLink = new LinkProperties();
+ stackedLink.setInterfaceName(clatInterface);
+ stackedLink.addLinkAddress(new LinkAddress(XLAT_LOCAL_IPV4ADDR, 24));
+ prop.addStackedLink(stackedLink);
+ prop.setNat64Prefix(NAT64_IP_PREFIX);
+ }
+
+ return prop;
+ }
+
+ private void verifyIpv4Upstream(
+ @NonNull final HashMap<Inet4Address, Integer> ipv4UpstreamIndices,
+ @NonNull final SparseArray<String> interfaceNames) {
+ assertEquals(1, ipv4UpstreamIndices.size());
+ Integer upstreamIndex = ipv4UpstreamIndices.get(PUBLIC_ADDR);
+ assertNotNull(upstreamIndex);
+ assertEquals(UPSTREAM_IFINDEX, upstreamIndex.intValue());
+ assertEquals(1, interfaceNames.size());
+ assertTrue(interfaceNames.contains(UPSTREAM_IFINDEX));
+ }
+
+ private void verifyUpdateUpstreamNetworkState()
+ throws Exception {
+ final BpfCoordinator coordinator = makeBpfCoordinator();
+ final HashMap<Inet4Address, Integer> ipv4UpstreamIndices =
+ coordinator.getIpv4UpstreamIndicesForTesting();
+ assertTrue(ipv4UpstreamIndices.isEmpty());
+ final SparseArray<String> interfaceNames =
+ coordinator.getInterfaceNamesForTesting();
+ assertEquals(0, interfaceNames.size());
+
+ // Verify the following are added or removed after upstream changes.
+ // - BpfCoordinator#mIpv4UpstreamIndices (for building IPv4 offload rules)
+ // - BpfCoordinator#mInterfaceNames (for updating limit)
+ //
+ // +-------+-------+-----------------------+
+ // | Test | Up | Protocol |
+ // | Case# | stream+-------+-------+-------+
+ // | | | IPv4 | IPv6 | Xlat |
+ // +-------+-------+-------+-------+-------+
+ // | 1 | Cell | O | | |
+ // +-------+-------+-------+-------+-------+
+ // | 2 | Cell | | O | |
+ // +-------+-------+-------+-------+-------+
+ // | 3 | Cell | O | O | |
+ // +-------+-------+-------+-------+-------+
+ // | 4 | - | | | |
+ // +-------+-------+-------+-------+-------+
+ // | | Cell | O | | |
+ // | +-------+-------+-------+-------+
+ // | 5 | Cell | | O | O | <-- doesn't support offload (xlat)
+ // | +-------+-------+-------+-------+
+ // | | Cell | O | | |
+ // +-------+-------+-------+-------+-------+
+ // | 6 | Wifi | O | O | | <-- doesn't support offload (ether ip)
+ // +-------+-------+-------+-------+-------+
+
+ // [1] Mobile IPv4 only
+ coordinator.addUpstreamNameToLookupTable(UPSTREAM_IFINDEX, UPSTREAM_IFACE);
+ doReturn(UPSTREAM_IFACE_PARAMS).when(mDeps).getInterfaceParams(UPSTREAM_IFACE);
+ final UpstreamNetworkState mobileIPv4UpstreamState = new UpstreamNetworkState(
+ buildUpstreamLinkProperties(UPSTREAM_IFACE,
+ true /* IPv4 */, false /* IPv6 */, false /* 464xlat */),
+ new NetworkCapabilities().addTransportType(TRANSPORT_CELLULAR),
+ new Network(TEST_NET_ID));
+ coordinator.updateUpstreamNetworkState(mobileIPv4UpstreamState);
+ verifyIpv4Upstream(ipv4UpstreamIndices, interfaceNames);
+
+ // [2] Mobile IPv6 only
+ final UpstreamNetworkState mobileIPv6UpstreamState = new UpstreamNetworkState(
+ buildUpstreamLinkProperties(UPSTREAM_IFACE,
+ false /* IPv4 */, true /* IPv6 */, false /* 464xlat */),
+ new NetworkCapabilities().addTransportType(TRANSPORT_CELLULAR),
+ new Network(TEST_NET_ID));
+ coordinator.updateUpstreamNetworkState(mobileIPv6UpstreamState);
+ assertTrue(ipv4UpstreamIndices.isEmpty());
+ assertEquals(1, interfaceNames.size());
+ assertTrue(interfaceNames.contains(UPSTREAM_IFINDEX));
+
+ // [3] Mobile IPv4 and IPv6
+ final UpstreamNetworkState mobileDualStackUpstreamState = new UpstreamNetworkState(
+ buildUpstreamLinkProperties(UPSTREAM_IFACE,
+ true /* IPv4 */, true /* IPv6 */, false /* 464xlat */),
+ new NetworkCapabilities().addTransportType(TRANSPORT_CELLULAR),
+ new Network(TEST_NET_ID));
+ coordinator.updateUpstreamNetworkState(mobileDualStackUpstreamState);
+ verifyIpv4Upstream(ipv4UpstreamIndices, interfaceNames);
+
+ // [4] Lost upstream
+ coordinator.updateUpstreamNetworkState(null);
+ assertTrue(ipv4UpstreamIndices.isEmpty());
+ assertEquals(1, interfaceNames.size());
+ assertTrue(interfaceNames.contains(UPSTREAM_IFINDEX));
+
+ // [5] verify xlat interface
+ // Expect that xlat interface information isn't added to mapping.
+ doReturn(UPSTREAM_XLAT_IFACE_PARAMS).when(mDeps).getInterfaceParams(
+ UPSTREAM_XLAT_IFACE);
+ final UpstreamNetworkState mobile464xlatUpstreamState = new UpstreamNetworkState(
+ buildUpstreamLinkProperties(UPSTREAM_IFACE,
+ false /* IPv4 */, true /* IPv6 */, true /* 464xlat */),
+ new NetworkCapabilities().addTransportType(TRANSPORT_CELLULAR),
+ new Network(TEST_NET_ID));
+
+ // Need to add a valid IPv4 upstream to verify that xlat interface doesn't support.
+ // Mobile IPv4 only
+ coordinator.updateUpstreamNetworkState(mobileIPv4UpstreamState);
+ verifyIpv4Upstream(ipv4UpstreamIndices, interfaceNames);
+
+ // Mobile IPv6 and xlat
+ // IpServer doesn't add xlat interface mapping via #addUpstreamNameToLookupTable on
+ // S and T devices.
+ coordinator.updateUpstreamNetworkState(mobile464xlatUpstreamState);
+ // Upstream IPv4 address mapping is removed because xlat interface is not supported.
+ assertTrue(ipv4UpstreamIndices.isEmpty());
+ assertEquals(1, interfaceNames.size());
+ assertTrue(interfaceNames.contains(UPSTREAM_IFINDEX));
+
+ // Need to add a valid IPv4 upstream to verify that wifi interface doesn't support.
+ // Mobile IPv4 only
+ coordinator.updateUpstreamNetworkState(mobileIPv4UpstreamState);
+ verifyIpv4Upstream(ipv4UpstreamIndices, interfaceNames);
+
+ // [6] Wifi IPv4 and IPv6
+ // Expect that upstream index map is cleared because ether ip is not supported.
+ coordinator.addUpstreamNameToLookupTable(UPSTREAM_IFINDEX2, UPSTREAM_IFACE2);
+ doReturn(UPSTREAM_IFACE_PARAMS2).when(mDeps).getInterfaceParams(UPSTREAM_IFACE2);
+ final UpstreamNetworkState wifiDualStackUpstreamState = new UpstreamNetworkState(
+ buildUpstreamLinkProperties(UPSTREAM_IFACE2,
+ true /* IPv4 */, true /* IPv6 */, false /* 464xlat */),
+ new NetworkCapabilities().addTransportType(TRANSPORT_WIFI),
+ new Network(TEST_NET_ID2));
+ coordinator.updateUpstreamNetworkState(wifiDualStackUpstreamState);
+ assertTrue(ipv4UpstreamIndices.isEmpty());
+ assertEquals(2, interfaceNames.size());
+ assertTrue(interfaceNames.contains(UPSTREAM_IFINDEX));
+ assertTrue(interfaceNames.contains(UPSTREAM_IFINDEX2));
+ }
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.R)
+ public void testUpdateUpstreamNetworkState() throws Exception {
+ verifyUpdateUpstreamNetworkState();
+ }
}
diff --git a/bpf_progs/bpf_net_helpers.h b/bpf_progs/bpf_net_helpers.h
index c39269e..b7ca3af 100644
--- a/bpf_progs/bpf_net_helpers.h
+++ b/bpf_progs/bpf_net_helpers.h
@@ -21,6 +21,18 @@
#include <stdbool.h>
#include <stdint.h>
+// bionic kernel uapi linux/udp.h header is munged...
+#define __kernel_udphdr udphdr
+#include <linux/udp.h>
+
+// Offsets from beginning of L4 (TCP/UDP) header
+#define TCP_OFFSET(field) offsetof(struct tcphdr, field)
+#define UDP_OFFSET(field) offsetof(struct udphdr, field)
+
+// Offsets from beginning of L3 (IPv4/IPv6) header
+#define IP4_OFFSET(field) offsetof(struct iphdr, field)
+#define IP6_OFFSET(field) offsetof(struct ipv6hdr, field)
+
// this returns 0 iff skb->sk is NULL
static uint64_t (*bpf_get_socket_cookie)(struct __sk_buff* skb) = (void*)BPF_FUNC_get_socket_cookie;
diff --git a/bpf_progs/netd.c b/bpf_progs/netd.c
index 43920d0..84da79d 100644
--- a/bpf_progs/netd.c
+++ b/bpf_progs/netd.c
@@ -46,8 +46,9 @@
static const bool INGRESS = false;
static const bool EGRESS = true;
-#define IP_PROTO_OFF offsetof(struct iphdr, protocol)
-#define IPV6_PROTO_OFF offsetof(struct ipv6hdr, nexthdr)
+// Used for 'bool enable_tracing'
+static const bool TRACE_ON = true;
+static const bool TRACE_OFF = false;
// offsetof(struct iphdr, ihl) -- but that's a bitfield
#define IPPROTO_IHL_OFF 0
@@ -60,14 +61,18 @@
#define TCP_FLAG32_OFF 12
// For maps netd does not need to access
-#define DEFINE_BPF_MAP_NO_NETD(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries) \
- DEFINE_BPF_MAP_EXT(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries, \
- AID_ROOT, AID_NET_BW_ACCT, 0060, "fs_bpf_net_shared", "", false)
+#define DEFINE_BPF_MAP_NO_NETD(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries) \
+ DEFINE_BPF_MAP_EXT(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries, \
+ AID_ROOT, AID_NET_BW_ACCT, 0060, "fs_bpf_net_shared", "", false, \
+ BPFLOADER_MIN_VER, BPFLOADER_MAX_VER, /*ignore_on_eng*/false, \
+ /*ignore_on_user*/false, /*ignore_on_userdebug*/false)
// For maps netd only needs read only access to
-#define DEFINE_BPF_MAP_RO_NETD(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries) \
- DEFINE_BPF_MAP_EXT(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries, \
- AID_ROOT, AID_NET_BW_ACCT, 0460, "fs_bpf_netd_readonly", "", false)
+#define DEFINE_BPF_MAP_RO_NETD(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries) \
+ DEFINE_BPF_MAP_EXT(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries, \
+ AID_ROOT, AID_NET_BW_ACCT, 0460, "fs_bpf_netd_readonly", "", false, \
+ BPFLOADER_MIN_VER, BPFLOADER_MAX_VER, /*ignore_on_eng*/false, \
+ /*ignore_on_user*/false, /*ignore_on_userdebug*/false)
// For maps netd needs to be able to read and write
#define DEFINE_BPF_MAP_RW_NETD(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries) \
@@ -95,6 +100,19 @@
/* never actually used from ebpf */
DEFINE_BPF_MAP_NO_NETD(iface_index_name_map, HASH, uint32_t, IfaceValue, IFACE_INDEX_NAME_MAP_SIZE)
+// A single-element configuration array, packet tracing is enabled when 'true'.
+DEFINE_BPF_MAP_EXT(packet_trace_enabled_map, ARRAY, uint32_t, bool, 1,
+ AID_ROOT, AID_SYSTEM, 0060, "fs_bpf_net_shared", "", false,
+ BPFLOADER_IGNORED_ON_VERSION, BPFLOADER_MAX_VER, /*ignore_on_eng*/false,
+ /*ignore_on_user*/true, /*ignore_on_userdebug*/false)
+
+// A ring buffer on which packet information is pushed. This map will only be loaded
+// on eng and userdebug devices. User devices won't load this to save memory.
+DEFINE_BPF_RINGBUF_EXT(packet_trace_ringbuf, PacketTrace, PACKET_TRACE_BUF_SIZE,
+ AID_ROOT, AID_SYSTEM, 0060, "fs_bpf_net_shared", "", false,
+ BPFLOADER_IGNORED_ON_VERSION, BPFLOADER_MAX_VER, /*ignore_on_eng*/false,
+ /*ignore_on_user*/true, /*ignore_on_userdebug*/false);
+
// iptables xt_bpf programs need to be usable by both netd and netutils_wrappers
// selinux contexts, because even non-xt_bpf iptables mutations are implemented as
// a full table dump, followed by an update in userspace, and then a reload into the kernel,
@@ -222,12 +240,72 @@
: bpf_skb_load_bytes(skb, L3_off, to, len);
}
+static __always_inline inline void do_packet_tracing(
+ const struct __sk_buff* const skb, const bool egress, const uint32_t uid,
+ const uint32_t tag, const bool enable_tracing, const unsigned kver) {
+ if (!enable_tracing) return;
+ if (kver < KVER(5, 8, 0)) return;
+
+ uint32_t mapKey = 0;
+ bool* traceConfig = bpf_packet_trace_enabled_map_lookup_elem(&mapKey);
+ if (traceConfig == NULL) return;
+ if (*traceConfig == false) return;
+
+ PacketTrace* pkt = bpf_packet_trace_ringbuf_reserve();
+ if (pkt == NULL) return;
+
+ // Errors from bpf_skb_load_bytes_net are ignored to favor returning something
+ // over returning nothing. In the event of an error, the kernel will fill in
+ // zero for the destination memory. Do not change the default '= 0' below.
+
+ uint8_t proto = 0;
+ uint8_t L4_off = 0;
+ uint8_t ipVersion = 0;
+ if (skb->protocol == htons(ETH_P_IP)) {
+ (void)bpf_skb_load_bytes_net(skb, IP4_OFFSET(protocol), &proto, sizeof(proto), kver);
+ (void)bpf_skb_load_bytes_net(skb, IPPROTO_IHL_OFF, &L4_off, sizeof(L4_off), kver);
+ L4_off = (L4_off & 0x0F) * 4; // IHL calculation.
+ ipVersion = 4;
+ } else if (skb->protocol == htons(ETH_P_IPV6)) {
+ (void)bpf_skb_load_bytes_net(skb, IP6_OFFSET(nexthdr), &proto, sizeof(proto), kver);
+ L4_off = sizeof(struct ipv6hdr);
+ ipVersion = 6;
+ }
+
+ uint8_t flags = 0;
+ __be16 sport = 0, dport = 0;
+ if (proto == IPPROTO_TCP && L4_off >= 20) {
+ (void)bpf_skb_load_bytes_net(skb, L4_off + TCP_FLAG32_OFF + 1, &flags, sizeof(flags), kver);
+ (void)bpf_skb_load_bytes_net(skb, L4_off + TCP_OFFSET(source), &sport, sizeof(sport), kver);
+ (void)bpf_skb_load_bytes_net(skb, L4_off + TCP_OFFSET(dest), &dport, sizeof(dport), kver);
+ } else if (proto == IPPROTO_UDP && L4_off >= 20) {
+ (void)bpf_skb_load_bytes_net(skb, L4_off + UDP_OFFSET(source), &sport, sizeof(sport), kver);
+ (void)bpf_skb_load_bytes_net(skb, L4_off + UDP_OFFSET(dest), &dport, sizeof(dport), kver);
+ }
+
+ pkt->timestampNs = bpf_ktime_get_boot_ns();
+ pkt->ifindex = skb->ifindex;
+ pkt->length = skb->len;
+
+ pkt->uid = uid;
+ pkt->tag = tag;
+ pkt->sport = sport;
+ pkt->dport = dport;
+
+ pkt->egress = egress;
+ pkt->ipProto = proto;
+ pkt->tcpFlags = flags;
+ pkt->ipVersion = ipVersion;
+
+ bpf_packet_trace_ringbuf_submit(pkt);
+}
+
static __always_inline inline bool skip_owner_match(struct __sk_buff* skb, const unsigned kver) {
uint32_t flag = 0;
if (skb->protocol == htons(ETH_P_IP)) {
uint8_t proto;
// no need to check for success, proto will be zeroed if bpf_skb_load_bytes_net() fails
- (void)bpf_skb_load_bytes_net(skb, IP_PROTO_OFF, &proto, sizeof(proto), kver);
+ (void)bpf_skb_load_bytes_net(skb, IP4_OFFSET(protocol), &proto, sizeof(proto), kver);
if (proto == IPPROTO_ESP) return true;
if (proto != IPPROTO_TCP) return false; // handles read failure above
uint8_t ihl;
@@ -243,7 +321,7 @@
} else if (skb->protocol == htons(ETH_P_IPV6)) {
uint8_t proto;
// no need to check for success, proto will be zeroed if bpf_skb_load_bytes_net() fails
- (void)bpf_skb_load_bytes_net(skb, IPV6_PROTO_OFF, &proto, sizeof(proto), kver);
+ (void)bpf_skb_load_bytes_net(skb, IP6_OFFSET(nexthdr), &proto, sizeof(proto), kver);
if (proto == IPPROTO_ESP) return true;
if (proto != IPPROTO_TCP) return false; // handles read failure above
// if the read below fails, we'll just assume no TCP flags are set, which is fine.
@@ -315,6 +393,7 @@
}
static __always_inline inline int bpf_traffic_account(struct __sk_buff* skb, bool egress,
+ const bool enable_tracing,
const unsigned kver) {
uint32_t sock_uid = bpf_get_socket_uid(skb);
uint64_t cookie = bpf_get_socket_cookie(skb);
@@ -374,34 +453,51 @@
key.tag = 0;
}
+ do_packet_tracing(skb, egress, uid, tag, enable_tracing, kver);
update_stats_with_config(skb, egress, &key, *selectedMap);
update_app_uid_stats_map(skb, egress, &uid);
asm("%0 &= 1" : "+r"(match));
return match;
}
+DEFINE_BPF_PROG_EXT("cgroupskb/ingress/stats$trace", AID_ROOT, AID_SYSTEM,
+ bpf_cgroup_ingress_trace, KVER(5, 8, 0), KVER_INF,
+ BPFLOADER_IGNORED_ON_VERSION, BPFLOADER_MAX_VER, false,
+ "fs_bpf_netd_readonly", "", false, true, false)
+(struct __sk_buff* skb) {
+ return bpf_traffic_account(skb, INGRESS, TRACE_ON, KVER(5, 8, 0));
+}
+
DEFINE_NETD_BPF_PROG_KVER_RANGE("cgroupskb/ingress/stats$4_19", AID_ROOT, AID_SYSTEM,
bpf_cgroup_ingress_4_19, KVER(4, 19, 0), KVER_INF)
(struct __sk_buff* skb) {
- return bpf_traffic_account(skb, INGRESS, KVER(4, 19, 0));
+ return bpf_traffic_account(skb, INGRESS, TRACE_OFF, KVER(4, 19, 0));
}
DEFINE_NETD_BPF_PROG_KVER_RANGE("cgroupskb/ingress/stats$4_14", AID_ROOT, AID_SYSTEM,
bpf_cgroup_ingress_4_14, KVER_NONE, KVER(4, 19, 0))
(struct __sk_buff* skb) {
- return bpf_traffic_account(skb, INGRESS, KVER_NONE);
+ return bpf_traffic_account(skb, INGRESS, TRACE_OFF, KVER_NONE);
+}
+
+DEFINE_BPF_PROG_EXT("cgroupskb/egress/stats$trace", AID_ROOT, AID_SYSTEM,
+ bpf_cgroup_egress_trace, KVER(5, 8, 0), KVER_INF,
+ BPFLOADER_IGNORED_ON_VERSION, BPFLOADER_MAX_VER, false,
+ "fs_bpf_netd_readonly", "", false, true, false)
+(struct __sk_buff* skb) {
+ return bpf_traffic_account(skb, EGRESS, TRACE_ON, KVER(5, 8, 0));
}
DEFINE_NETD_BPF_PROG_KVER_RANGE("cgroupskb/egress/stats$4_19", AID_ROOT, AID_SYSTEM,
bpf_cgroup_egress_4_19, KVER(4, 19, 0), KVER_INF)
(struct __sk_buff* skb) {
- return bpf_traffic_account(skb, EGRESS, KVER(4, 19, 0));
+ return bpf_traffic_account(skb, EGRESS, TRACE_OFF, KVER(4, 19, 0));
}
DEFINE_NETD_BPF_PROG_KVER_RANGE("cgroupskb/egress/stats$4_14", AID_ROOT, AID_SYSTEM,
bpf_cgroup_egress_4_14, KVER_NONE, KVER(4, 19, 0))
(struct __sk_buff* skb) {
- return bpf_traffic_account(skb, EGRESS, KVER_NONE);
+ return bpf_traffic_account(skb, EGRESS, TRACE_OFF, KVER_NONE);
}
// WARNING: Android T's non-updatable netd depends on the name of this program.
diff --git a/bpf_progs/netd.h b/bpf_progs/netd.h
index cc88680..be604f9 100644
--- a/bpf_progs/netd.h
+++ b/bpf_progs/netd.h
@@ -69,6 +69,24 @@
uint64_t tcpTxPackets;
} Stats;
+typedef struct {
+ uint64_t timestampNs;
+ uint32_t ifindex;
+ uint32_t length;
+
+ uint32_t uid;
+ uint32_t tag;
+
+ __be16 sport;
+ __be16 dport;
+
+ bool egress;
+ uint8_t ipProto;
+ uint8_t tcpFlags;
+ uint8_t ipVersion; // 4=IPv4, 6=IPv6, 0=unknown
+} PacketTrace;
+STRUCT_SIZE(PacketTrace, 8+4+4 + 4+4 + 2+2 + 1+1+1+1);
+
// Since we cannot garbage collect the stats map since device boot, we need to make these maps as
// large as possible. The maximum size of number of map entries we can have is depend on the rlimit
// of MEM_LOCK granted to netd. The memory space needed by each map can be calculated by the
@@ -87,7 +105,8 @@
// dozable_uid_map: key: 4 bytes, value: 1 bytes, cost: 145216 bytes = 145Kbytes
// standby_uid_map: key: 4 bytes, value: 1 bytes, cost: 145216 bytes = 145Kbytes
// powersave_uid_map: key: 4 bytes, value: 1 bytes, cost: 145216 bytes = 145Kbytes
-// total: 4930Kbytes
+// packet_trace_ringbuf:key: 0 bytes, value: 24 bytes, cost: 32768 bytes = 32Kbytes
+// total: 4962Kbytes
// It takes maximum 4.9MB kernel memory space if all maps are full, which requires any devices
// running this module to have a memlock rlimit to be larger then 5MB. In the old qtaguid module,
// we don't have a total limit for data entries but only have limitation of tags each uid can have.
@@ -102,6 +121,7 @@
static const int IFACE_STATS_MAP_SIZE = 1000;
static const int CONFIGURATION_MAP_SIZE = 2;
static const int UID_OWNER_MAP_SIZE = 4000;
+static const int PACKET_TRACE_BUF_SIZE = 32 * 1024;
#ifdef __cplusplus
@@ -145,6 +165,8 @@
#define CONFIGURATION_MAP_PATH BPF_NETD_PATH "map_netd_configuration_map"
#define UID_OWNER_MAP_PATH BPF_NETD_PATH "map_netd_uid_owner_map"
#define UID_PERMISSION_MAP_PATH BPF_NETD_PATH "map_netd_uid_permission_map"
+#define PACKET_TRACE_RINGBUF_PATH BPF_NETD_PATH "map_netd_packet_trace_ringbuf"
+#define PACKET_TRACE_ENABLED_MAP_PATH BPF_NETD_PATH "map_netd_packet_trace_enabled_map"
#endif // __cplusplus
diff --git a/framework-t/api/current.txt b/framework-t/api/current.txt
index eb77288..5532853 100644
--- a/framework-t/api/current.txt
+++ b/framework-t/api/current.txt
@@ -192,15 +192,20 @@
method @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void discoverServices(@NonNull String, int, @NonNull android.net.NetworkRequest, @NonNull java.util.concurrent.Executor, @NonNull android.net.nsd.NsdManager.DiscoveryListener);
method public void registerService(android.net.nsd.NsdServiceInfo, int, android.net.nsd.NsdManager.RegistrationListener);
method public void registerService(@NonNull android.net.nsd.NsdServiceInfo, int, @NonNull java.util.concurrent.Executor, @NonNull android.net.nsd.NsdManager.RegistrationListener);
- method public void resolveService(android.net.nsd.NsdServiceInfo, android.net.nsd.NsdManager.ResolveListener);
- method public void resolveService(@NonNull android.net.nsd.NsdServiceInfo, @NonNull java.util.concurrent.Executor, @NonNull android.net.nsd.NsdManager.ResolveListener);
+ method public void registerServiceInfoCallback(@NonNull android.net.nsd.NsdServiceInfo, @NonNull java.util.concurrent.Executor, @NonNull android.net.nsd.NsdManager.ServiceInfoCallback);
+ method @Deprecated public void resolveService(android.net.nsd.NsdServiceInfo, android.net.nsd.NsdManager.ResolveListener);
+ method @Deprecated public void resolveService(@NonNull android.net.nsd.NsdServiceInfo, @NonNull java.util.concurrent.Executor, @NonNull android.net.nsd.NsdManager.ResolveListener);
method public void stopServiceDiscovery(android.net.nsd.NsdManager.DiscoveryListener);
+ method public void stopServiceResolution(@NonNull android.net.nsd.NsdManager.ResolveListener);
method public void unregisterService(android.net.nsd.NsdManager.RegistrationListener);
+ method public void unregisterServiceInfoCallback(@NonNull android.net.nsd.NsdManager.ServiceInfoCallback);
field public static final String ACTION_NSD_STATE_CHANGED = "android.net.nsd.STATE_CHANGED";
field public static final String EXTRA_NSD_STATE = "nsd_state";
field public static final int FAILURE_ALREADY_ACTIVE = 3; // 0x3
+ field public static final int FAILURE_BAD_PARAMETERS = 6; // 0x6
field public static final int FAILURE_INTERNAL_ERROR = 0; // 0x0
field public static final int FAILURE_MAX_LIMIT = 4; // 0x4
+ field public static final int FAILURE_OPERATION_NOT_RUNNING = 5; // 0x5
field public static final int NSD_STATE_DISABLED = 1; // 0x1
field public static final int NSD_STATE_ENABLED = 2; // 0x2
field public static final int PROTOCOL_DNS_SD = 1; // 0x1
@@ -224,21 +229,32 @@
public static interface NsdManager.ResolveListener {
method public void onResolveFailed(android.net.nsd.NsdServiceInfo, int);
+ method public default void onResolveStopped(@NonNull android.net.nsd.NsdServiceInfo);
method public void onServiceResolved(android.net.nsd.NsdServiceInfo);
+ method public default void onStopResolutionFailed(@NonNull android.net.nsd.NsdServiceInfo, int);
+ }
+
+ public static interface NsdManager.ServiceInfoCallback {
+ method public void onServiceInfoCallbackRegistrationFailed(int);
+ method public void onServiceInfoCallbackUnregistered();
+ method public void onServiceLost();
+ method public void onServiceUpdated(@NonNull android.net.nsd.NsdServiceInfo);
}
public final class NsdServiceInfo implements android.os.Parcelable {
ctor public NsdServiceInfo();
method public int describeContents();
method public java.util.Map<java.lang.String,byte[]> getAttributes();
- method public java.net.InetAddress getHost();
+ method @Deprecated public java.net.InetAddress getHost();
+ method @NonNull public java.util.List<java.net.InetAddress> getHostAddresses();
method @Nullable public android.net.Network getNetwork();
method public int getPort();
method public String getServiceName();
method public String getServiceType();
method public void removeAttribute(String);
method public void setAttribute(String, String);
- method public void setHost(java.net.InetAddress);
+ method @Deprecated public void setHost(java.net.InetAddress);
+ method public void setHostAddresses(@NonNull java.util.List<java.net.InetAddress>);
method public void setNetwork(@Nullable android.net.Network);
method public void setPort(int);
method public void setServiceName(String);
diff --git a/framework-t/src/android/net/IpSecManager.java b/framework-t/src/android/net/IpSecManager.java
index c8469b1..3afa6ef 100644
--- a/framework-t/src/android/net/IpSecManager.java
+++ b/framework-t/src/android/net/IpSecManager.java
@@ -273,7 +273,7 @@
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
- mCloseGuard.open("open");
+ mCloseGuard.open("close");
}
/** @hide */
diff --git a/framework-t/src/android/net/IpSecTransform.java b/framework-t/src/android/net/IpSecTransform.java
index 68ae5de..c236b6c 100644
--- a/framework-t/src/android/net/IpSecTransform.java
+++ b/framework-t/src/android/net/IpSecTransform.java
@@ -126,7 +126,7 @@
checkResultStatus(status);
mResourceId = result.resourceId;
Log.d(TAG, "Added Transform with Id " + mResourceId);
- mCloseGuard.open("build");
+ mCloseGuard.open("close");
} catch (ServiceSpecificException e) {
throw IpSecManager.rethrowUncheckedExceptionFromServiceSpecificException(e);
}
diff --git a/framework-t/src/android/net/NetworkTemplate.java b/framework-t/src/android/net/NetworkTemplate.java
index b2da371..f633a8f 100644
--- a/framework-t/src/android/net/NetworkTemplate.java
+++ b/framework-t/src/android/net/NetworkTemplate.java
@@ -88,18 +88,6 @@
public static final int MATCH_WIFI = 4;
/** Match rule to match ethernet networks. */
public static final int MATCH_ETHERNET = 5;
- /**
- * Match rule to match all cellular networks.
- *
- * @hide
- */
- public static final int MATCH_MOBILE_WILDCARD = 6;
- /**
- * Match rule to match all wifi networks.
- *
- * @hide
- */
- public static final int MATCH_WIFI_WILDCARD = 7;
/** Match rule to match bluetooth networks. */
public static final int MATCH_BLUETOOTH = 8;
/**
@@ -177,8 +165,6 @@
case MATCH_MOBILE:
case MATCH_WIFI:
case MATCH_ETHERNET:
- case MATCH_MOBILE_WILDCARD:
- case MATCH_WIFI_WILDCARD:
case MATCH_BLUETOOTH:
case MATCH_PROXY:
case MATCH_CARRIER:
@@ -258,7 +244,6 @@
}
private final int mMatchRule;
- private final String mSubscriberId;
/**
* Ugh, templates are designed to target a single subscriber, but we might
@@ -285,9 +270,8 @@
private static void checkValidMatchSubscriberIds(int matchRule, String[] matchSubscriberIds) {
switch (matchRule) {
- case MATCH_MOBILE:
case MATCH_CARRIER:
- // MOBILE and CARRIER templates must always specify a subscriber ID.
+ // CARRIER templates must always specify a valid subscriber ID.
if (matchSubscriberIds.length == 0) {
throw new IllegalArgumentException("checkValidMatchSubscriberIds with empty"
+ " list of ids for rule" + getMatchRuleName(matchRule));
@@ -313,21 +297,20 @@
// to metered networks. It is now possible to match mobile with any meteredness, but
// in order to preserve backward compatibility of @UnsupportedAppUsage methods, this
//constructor passes METERED_YES for these types.
- this(matchRule, subscriberId, new String[] { subscriberId },
+ this(matchRule, new String[] { subscriberId },
wifiNetworkKey != null ? new String[] { wifiNetworkKey } : new String[0],
- (matchRule == MATCH_MOBILE || matchRule == MATCH_MOBILE_WILDCARD
- || matchRule == MATCH_CARRIER) ? METERED_YES : METERED_ALL,
- ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_ALL);
+ (matchRule == MATCH_MOBILE || matchRule == MATCH_CARRIER)
+ ? METERED_YES : METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL,
+ NETWORK_TYPE_ALL, OEM_MANAGED_ALL);
}
/** @hide */
- public NetworkTemplate(int matchRule, String subscriberId, String[] matchSubscriberIds,
- String[] matchWifiNetworkKeys, int metered, int roaming,
- int defaultNetwork, int ratType, int oemManaged) {
+ public NetworkTemplate(int matchRule, String[] matchSubscriberIds,
+ String[] matchWifiNetworkKeys, int metered, int roaming, int defaultNetwork,
+ int ratType, int oemManaged) {
Objects.requireNonNull(matchWifiNetworkKeys);
Objects.requireNonNull(matchSubscriberIds);
mMatchRule = matchRule;
- mSubscriberId = subscriberId;
mMatchSubscriberIds = matchSubscriberIds;
mMatchWifiNetworkKeys = matchWifiNetworkKeys;
mMetered = metered;
@@ -344,7 +327,6 @@
private NetworkTemplate(Parcel in) {
mMatchRule = in.readInt();
- mSubscriberId = in.readString();
mMatchSubscriberIds = in.createStringArray();
mMatchWifiNetworkKeys = in.createStringArray();
mMetered = in.readInt();
@@ -357,7 +339,6 @@
@Override
public void writeToParcel(@NonNull Parcel dest, int flags) {
dest.writeInt(mMatchRule);
- dest.writeString(mSubscriberId);
dest.writeStringArray(mMatchSubscriberIds);
dest.writeStringArray(mMatchWifiNetworkKeys);
dest.writeInt(mMetered);
@@ -376,10 +357,6 @@
public String toString() {
final StringBuilder builder = new StringBuilder("NetworkTemplate: ");
builder.append("matchRule=").append(getMatchRuleName(mMatchRule));
- if (mSubscriberId != null) {
- builder.append(", subscriberId=").append(
- NetworkIdentityUtils.scrubSubscriberId(mSubscriberId));
- }
if (mMatchSubscriberIds != null) {
builder.append(", matchSubscriberIds=").append(
Arrays.toString(NetworkIdentityUtils.scrubSubscriberIds(mMatchSubscriberIds)));
@@ -406,7 +383,7 @@
@Override
public int hashCode() {
- return Objects.hash(mMatchRule, mSubscriberId, Arrays.hashCode(mMatchWifiNetworkKeys),
+ return Objects.hash(mMatchRule, Arrays.hashCode(mMatchWifiNetworkKeys),
mMetered, mRoaming, mDefaultNetwork, mRatType, mOemManaged);
}
@@ -415,7 +392,6 @@
if (obj instanceof NetworkTemplate) {
final NetworkTemplate other = (NetworkTemplate) obj;
return mMatchRule == other.mMatchRule
- && Objects.equals(mSubscriberId, other.mSubscriberId)
&& mMetered == other.mMetered
&& mRoaming == other.mRoaming
&& mDefaultNetwork == other.mDefaultNetwork
@@ -426,42 +402,25 @@
return false;
}
- /** @hide */
- public boolean isMatchRuleMobile() {
- switch (mMatchRule) {
- case MATCH_MOBILE:
- case MATCH_MOBILE_WILDCARD:
- return true;
- default:
- return false;
- }
- }
-
/**
* Get match rule of the template. See {@code MATCH_*}.
*/
- @UnsupportedAppUsage
public int getMatchRule() {
- // Wildcard rules are not exposed. For external callers, convert wildcard rules to
- // exposed rules before returning.
- switch (mMatchRule) {
- case MATCH_MOBILE_WILDCARD:
- return MATCH_MOBILE;
- case MATCH_WIFI_WILDCARD:
- return MATCH_WIFI;
- default:
- return mMatchRule;
- }
+ return mMatchRule;
}
/**
* Get subscriber Id of the template.
+ *
+ * @deprecated User should use {@link #getSubscriberIds} instead.
* @hide
*/
+ @Deprecated
@Nullable
- @UnsupportedAppUsage
+ @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.TIRAMISU,
+ publicAlternatives = "Caller should use {@code getSubscriberIds} instead.")
public String getSubscriberId() {
- return mSubscriberId;
+ return CollectionUtils.isEmpty(mMatchSubscriberIds) ? null : mMatchSubscriberIds[0];
}
/**
@@ -548,10 +507,6 @@
return matchesWifi(ident);
case MATCH_ETHERNET:
return matchesEthernet(ident);
- case MATCH_MOBILE_WILDCARD:
- return matchesMobileWildcard(ident);
- case MATCH_WIFI_WILDCARD:
- return matchesWifiWildcard(ident);
case MATCH_BLUETOOTH:
return matchesBluetooth(ident);
case MATCH_PROXY:
@@ -632,9 +587,9 @@
// TODO: consider matching against WiMAX subscriber identity
return true;
} else {
- return ident.mType == TYPE_MOBILE && !CollectionUtils.isEmpty(mMatchSubscriberIds)
- && CollectionUtils.contains(mMatchSubscriberIds, ident.mSubscriberId)
- && matchesCollapsedRatType(ident);
+ return (CollectionUtils.isEmpty(mMatchSubscriberIds)
+ || CollectionUtils.contains(mMatchSubscriberIds, ident.mSubscriberId))
+ && (ident.mType == TYPE_MOBILE && matchesCollapsedRatType(ident));
}
}
@@ -646,6 +601,8 @@
case TYPE_WIFI:
return matchesSubscriberId(ident.mSubscriberId)
&& matchesWifiNetworkKey(ident.mWifiNetworkKey);
+ case TYPE_WIFI_P2P:
+ return CollectionUtils.isEmpty(mMatchWifiNetworkKeys);
default:
return false;
}
@@ -681,24 +638,6 @@
|| CollectionUtils.contains(mMatchWifiNetworkKeys, ident.mWifiNetworkKey)));
}
- private boolean matchesMobileWildcard(NetworkIdentity ident) {
- if (ident.mType == TYPE_WIMAX) {
- return true;
- } else {
- return ident.mType == TYPE_MOBILE && matchesCollapsedRatType(ident);
- }
- }
-
- private boolean matchesWifiWildcard(NetworkIdentity ident) {
- switch (ident.mType) {
- case TYPE_WIFI:
- case TYPE_WIFI_P2P:
- return true;
- default:
- return false;
- }
- }
-
/**
* Check if matches Bluetooth network template.
*/
@@ -724,10 +663,6 @@
return "WIFI";
case MATCH_ETHERNET:
return "ETHERNET";
- case MATCH_MOBILE_WILDCARD:
- return "MOBILE_WILDCARD";
- case MATCH_WIFI_WILDCARD:
- return "WIFI_WILDCARD";
case MATCH_BLUETOOTH:
return "BLUETOOTH";
case MATCH_PROXY:
@@ -775,20 +710,20 @@
// information. For instances:
// The TYPE_WIFI with subscriberId means that it is a merged carrier wifi network.
// The TYPE_CARRIER means that the network associate to specific carrier network.
- if (template.mSubscriberId == null) return template;
- if (CollectionUtils.contains(merged, template.mSubscriberId)) {
+ if (CollectionUtils.isEmpty(template.mMatchSubscriberIds)) return template;
+
+ if (CollectionUtils.contains(merged, template.mMatchSubscriberIds[0])) {
// Requested template subscriber is part of the merge group; return
// a template that matches all merged subscribers.
final String[] matchWifiNetworkKeys = template.mMatchWifiNetworkKeys;
// TODO: Use NetworkTemplate.Builder to build a template after NetworkTemplate
// could handle incompatible subscriberIds. See b/217805241.
- return new NetworkTemplate(template.mMatchRule, merged[0], merged,
+ return new NetworkTemplate(template.mMatchRule, merged,
CollectionUtils.isEmpty(matchWifiNetworkKeys)
? new String[0] : new String[] { matchWifiNetworkKeys[0] },
- (template.mMatchRule == MATCH_MOBILE
- || template.mMatchRule == MATCH_MOBILE_WILDCARD
- || template.mMatchRule == MATCH_CARRIER) ? METERED_YES : METERED_ALL,
+ (template.mMatchRule == MATCH_MOBILE || template.mMatchRule == MATCH_CARRIER)
+ ? METERED_YES : METERED_ALL,
ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_ALL);
}
@@ -956,10 +891,7 @@
* @param matchRule the target match rule to be checked.
*/
private static void assertRequestableMatchRule(final int matchRule) {
- if (!isKnownMatchRule(matchRule)
- || matchRule == MATCH_PROXY
- || matchRule == MATCH_MOBILE_WILDCARD
- || matchRule == MATCH_WIFI_WILDCARD) {
+ if (!isKnownMatchRule(matchRule) || matchRule == MATCH_PROXY) {
throw new IllegalArgumentException("Invalid match rule: "
+ getMatchRuleName(matchRule));
}
@@ -980,20 +912,6 @@
}
/**
- * For backward compatibility, deduce match rule to a wildcard match rule
- * if the Subscriber Ids are empty.
- */
- private int getWildcardDeducedMatchRule() {
- if (mMatchRule == MATCH_MOBILE && mMatchSubscriberIds.isEmpty()) {
- return MATCH_MOBILE_WILDCARD;
- } else if (mMatchRule == MATCH_WIFI && mMatchSubscriberIds.isEmpty()
- && mMatchWifiNetworkKeys.isEmpty()) {
- return MATCH_WIFI_WILDCARD;
- }
- return mMatchRule;
- }
-
- /**
* Builds the instance of the NetworkTemplate.
*
* @return the built instance of NetworkTemplate.
@@ -1001,8 +919,7 @@
@NonNull
public NetworkTemplate build() {
assertRequestableParameters();
- return new NetworkTemplate(getWildcardDeducedMatchRule(),
- mMatchSubscriberIds.isEmpty() ? null : mMatchSubscriberIds.iterator().next(),
+ return new NetworkTemplate(mMatchRule,
mMatchSubscriberIds.toArray(new String[0]),
mMatchWifiNetworkKeys.toArray(new String[0]), mMetered, mRoaming,
mDefaultNetwork, mRatType, mOemManaged);
diff --git a/framework-t/src/android/net/nsd/INsdManagerCallback.aidl b/framework-t/src/android/net/nsd/INsdManagerCallback.aidl
index 1a262ec..d89bfa9 100644
--- a/framework-t/src/android/net/nsd/INsdManagerCallback.aidl
+++ b/framework-t/src/android/net/nsd/INsdManagerCallback.aidl
@@ -36,4 +36,10 @@
void onUnregisterServiceSucceeded(int listenerKey);
void onResolveServiceFailed(int listenerKey, int error);
void onResolveServiceSucceeded(int listenerKey, in NsdServiceInfo info);
+ void onStopResolutionFailed(int listenerKey, int error);
+ void onStopResolutionSucceeded(int listenerKey);
+ void onServiceInfoCallbackRegistrationFailed(int listenerKey, int error);
+ void onServiceUpdated(int listenerKey, in NsdServiceInfo info);
+ void onServiceUpdatedLost(int listenerKey);
+ void onServiceInfoCallbackUnregistered(int listenerKey);
}
diff --git a/framework-t/src/android/net/nsd/INsdServiceConnector.aidl b/framework-t/src/android/net/nsd/INsdServiceConnector.aidl
index b06ae55..5533154 100644
--- a/framework-t/src/android/net/nsd/INsdServiceConnector.aidl
+++ b/framework-t/src/android/net/nsd/INsdServiceConnector.aidl
@@ -32,4 +32,7 @@
void stopDiscovery(int listenerKey);
void resolveService(int listenerKey, in NsdServiceInfo serviceInfo);
void startDaemon();
+ void stopResolution(int listenerKey);
+ void registerServiceInfoCallback(int listenerKey, in NsdServiceInfo serviceInfo);
+ void unregisterServiceInfoCallback(int listenerKey);
}
\ No newline at end of file
diff --git a/framework-t/src/android/net/nsd/NsdManager.java b/framework-t/src/android/net/nsd/NsdManager.java
index fb3b1d6..122e3a0 100644
--- a/framework-t/src/android/net/nsd/NsdManager.java
+++ b/framework-t/src/android/net/nsd/NsdManager.java
@@ -16,6 +16,7 @@
package android.net.nsd;
+import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.RequiresPermission;
@@ -44,6 +45,8 @@
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
import java.util.Objects;
import java.util.concurrent.Executor;
@@ -230,7 +233,6 @@
/** @hide */
public static final int DAEMON_CLEANUP = 18;
-
/** @hide */
public static final int DAEMON_STARTUP = 19;
@@ -242,6 +244,30 @@
/** @hide */
public static final int UNREGISTER_CLIENT = 22;
+ /** @hide */
+ public static final int MDNS_DISCOVERY_MANAGER_EVENT = 23;
+
+ /** @hide */
+ public static final int STOP_RESOLUTION = 24;
+ /** @hide */
+ public static final int STOP_RESOLUTION_FAILED = 25;
+ /** @hide */
+ public static final int STOP_RESOLUTION_SUCCEEDED = 26;
+
+ /** @hide */
+ public static final int REGISTER_SERVICE_CALLBACK = 27;
+ /** @hide */
+ public static final int REGISTER_SERVICE_CALLBACK_FAILED = 28;
+ /** @hide */
+ public static final int SERVICE_UPDATED = 29;
+ /** @hide */
+ public static final int SERVICE_UPDATED_LOST = 30;
+
+ /** @hide */
+ public static final int UNREGISTER_SERVICE_CALLBACK = 31;
+ /** @hide */
+ public static final int UNREGISTER_SERVICE_CALLBACK_SUCCEEDED = 32;
+
/** Dns based service discovery protocol */
public static final int PROTOCOL_DNS_SD = 0x0001;
@@ -267,6 +293,15 @@
EVENT_NAMES.put(DAEMON_CLEANUP, "DAEMON_CLEANUP");
EVENT_NAMES.put(DAEMON_STARTUP, "DAEMON_STARTUP");
EVENT_NAMES.put(MDNS_SERVICE_EVENT, "MDNS_SERVICE_EVENT");
+ EVENT_NAMES.put(STOP_RESOLUTION, "STOP_RESOLUTION");
+ EVENT_NAMES.put(STOP_RESOLUTION_FAILED, "STOP_RESOLUTION_FAILED");
+ EVENT_NAMES.put(STOP_RESOLUTION_SUCCEEDED, "STOP_RESOLUTION_SUCCEEDED");
+ EVENT_NAMES.put(REGISTER_SERVICE_CALLBACK, "REGISTER_SERVICE_CALLBACK");
+ EVENT_NAMES.put(REGISTER_SERVICE_CALLBACK_FAILED, "REGISTER_SERVICE_CALLBACK_FAILED");
+ EVENT_NAMES.put(SERVICE_UPDATED, "SERVICE_UPDATED");
+ EVENT_NAMES.put(UNREGISTER_SERVICE_CALLBACK, "UNREGISTER_SERVICE_CALLBACK");
+ EVENT_NAMES.put(UNREGISTER_SERVICE_CALLBACK_SUCCEEDED,
+ "UNREGISTER_SERVICE_CALLBACK_SUCCEEDED");
}
/** @hide */
@@ -592,6 +627,36 @@
public void onResolveServiceSucceeded(int listenerKey, NsdServiceInfo info) {
sendInfo(RESOLVE_SERVICE_SUCCEEDED, listenerKey, info);
}
+
+ @Override
+ public void onStopResolutionFailed(int listenerKey, int error) {
+ sendError(STOP_RESOLUTION_FAILED, listenerKey, error);
+ }
+
+ @Override
+ public void onStopResolutionSucceeded(int listenerKey) {
+ sendNoArg(STOP_RESOLUTION_SUCCEEDED, listenerKey);
+ }
+
+ @Override
+ public void onServiceInfoCallbackRegistrationFailed(int listenerKey, int error) {
+ sendError(REGISTER_SERVICE_CALLBACK_FAILED, listenerKey, error);
+ }
+
+ @Override
+ public void onServiceUpdated(int listenerKey, NsdServiceInfo info) {
+ sendInfo(SERVICE_UPDATED, listenerKey, info);
+ }
+
+ @Override
+ public void onServiceUpdatedLost(int listenerKey) {
+ sendNoArg(SERVICE_UPDATED_LOST, listenerKey);
+ }
+
+ @Override
+ public void onServiceInfoCallbackUnregistered(int listenerKey) {
+ sendNoArg(UNREGISTER_SERVICE_CALLBACK_SUCCEEDED, listenerKey);
+ }
}
/**
@@ -615,6 +680,37 @@
*/
public static final int FAILURE_MAX_LIMIT = 4;
+ /**
+ * Indicates that the stop operation failed because it is not running.
+ * This failure is passed with {@link ResolveListener#onStopResolutionFailed}.
+ */
+ public static final int FAILURE_OPERATION_NOT_RUNNING = 5;
+
+ /**
+ * Indicates that the service has failed to resolve because of bad parameters.
+ *
+ * This failure is passed with
+ * {@link ServiceInfoCallback#onServiceInfoCallbackRegistrationFailed}.
+ */
+ public static final int FAILURE_BAD_PARAMETERS = 6;
+
+ /** @hide */
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef(value = {
+ FAILURE_OPERATION_NOT_RUNNING,
+ })
+ public @interface StopOperationFailureCode {
+ }
+
+ /** @hide */
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef(value = {
+ FAILURE_ALREADY_ACTIVE,
+ FAILURE_BAD_PARAMETERS,
+ })
+ public @interface ResolutionFailureCode {
+ }
+
/** Interface for callback invocation for service discovery */
public interface DiscoveryListener {
@@ -643,12 +739,97 @@
public void onServiceUnregistered(NsdServiceInfo serviceInfo);
}
- /** Interface for callback invocation for service resolution */
+ /**
+ * Callback for use with {@link NsdManager#resolveService} to resolve the service info and use
+ * with {@link NsdManager#stopServiceResolution} to stop resolution.
+ */
public interface ResolveListener {
- public void onResolveFailed(NsdServiceInfo serviceInfo, int errorCode);
+ /**
+ * Called on the internal thread or with an executor passed to
+ * {@link NsdManager#resolveService} to report the resolution was failed with an error.
+ *
+ * A resolution operation would call either onServiceResolved or onResolveFailed once based
+ * on the result.
+ */
+ void onResolveFailed(NsdServiceInfo serviceInfo, int errorCode);
- public void onServiceResolved(NsdServiceInfo serviceInfo);
+ /**
+ * Called on the internal thread or with an executor passed to
+ * {@link NsdManager#resolveService} to report the resolved service info.
+ *
+ * A resolution operation would call either onServiceResolved or onResolveFailed once based
+ * on the result.
+ */
+ void onServiceResolved(NsdServiceInfo serviceInfo);
+
+ /**
+ * Called on the internal thread or with an executor passed to
+ * {@link NsdManager#resolveService} to report the resolution was stopped.
+ *
+ * A stop resolution operation would call either onResolveStopped or onStopResolutionFailed
+ * once based on the result.
+ */
+ default void onResolveStopped(@NonNull NsdServiceInfo serviceInfo) { }
+
+ /**
+ * Called once on the internal thread or with an executor passed to
+ * {@link NsdManager#resolveService} to report that stopping resolution failed with an
+ * error.
+ *
+ * A stop resolution operation would call either onResolveStopped or onStopResolutionFailed
+ * once based on the result.
+ */
+ default void onStopResolutionFailed(@NonNull NsdServiceInfo serviceInfo,
+ @StopOperationFailureCode int errorCode) { }
+ }
+
+ /**
+ * Callback to listen to service info updates.
+ *
+ * For use with {@link NsdManager#registerServiceInfoCallback} to register, and with
+ * {@link NsdManager#unregisterServiceInfoCallback} to stop listening.
+ */
+ public interface ServiceInfoCallback {
+
+ /**
+ * Reports that registering the callback failed with an error.
+ *
+ * Called on the executor passed to {@link NsdManager#registerServiceInfoCallback}.
+ *
+ * onServiceInfoCallbackRegistrationFailed will be called exactly once when the callback
+ * could not be registered. No other callback will be sent in that case.
+ */
+ void onServiceInfoCallbackRegistrationFailed(@ResolutionFailureCode int errorCode);
+
+ /**
+ * Reports updated service info.
+ *
+ * Called on the executor passed to {@link NsdManager#registerServiceInfoCallback}. Any
+ * service updates will be notified via this callback until
+ * {@link NsdManager#unregisterServiceInfoCallback} is called. This will only be called once
+ * the service is found, so may never be called if the service is never present.
+ */
+ void onServiceUpdated(@NonNull NsdServiceInfo serviceInfo);
+
+ /**
+ * Reports when the service that this callback listens to becomes unavailable.
+ *
+ * Called on the executor passed to {@link NsdManager#registerServiceInfoCallback}. The
+ * service may become available again, in which case {@link #onServiceUpdated} will be
+ * called.
+ */
+ void onServiceLost();
+
+ /**
+ * Reports that service info updates have stopped.
+ *
+ * Called on the executor passed to {@link NsdManager#registerServiceInfoCallback}.
+ *
+ * A callback unregistration operation will call onServiceInfoCallbackUnregistered
+ * once. After this, the callback may be reused.
+ */
+ void onServiceInfoCallbackUnregistered();
}
@VisibleForTesting
@@ -741,6 +922,33 @@
executor.execute(() -> ((ResolveListener) listener).onServiceResolved(
(NsdServiceInfo) obj));
break;
+ case STOP_RESOLUTION_FAILED:
+ removeListener(key);
+ executor.execute(() -> ((ResolveListener) listener).onStopResolutionFailed(
+ ns, errorCode));
+ break;
+ case STOP_RESOLUTION_SUCCEEDED:
+ removeListener(key);
+ executor.execute(() -> ((ResolveListener) listener).onResolveStopped(
+ ns));
+ break;
+ case REGISTER_SERVICE_CALLBACK_FAILED:
+ removeListener(key);
+ executor.execute(() -> ((ServiceInfoCallback) listener)
+ .onServiceInfoCallbackRegistrationFailed(errorCode));
+ break;
+ case SERVICE_UPDATED:
+ executor.execute(() -> ((ServiceInfoCallback) listener)
+ .onServiceUpdated((NsdServiceInfo) obj));
+ break;
+ case SERVICE_UPDATED_LOST:
+ executor.execute(() -> ((ServiceInfoCallback) listener).onServiceLost());
+ break;
+ case UNREGISTER_SERVICE_CALLBACK_SUCCEEDED:
+ removeListener(key);
+ executor.execute(() -> ((ServiceInfoCallback) listener)
+ .onServiceInfoCallbackUnregistered());
+ break;
default:
Log.d(TAG, "Ignored " + message);
break;
@@ -1052,7 +1260,14 @@
* @param serviceInfo service to be resolved
* @param listener to receive callback upon success or failure. Cannot be null.
* Cannot be in use for an active service resolution.
+ *
+ * @deprecated the returned ServiceInfo may get stale at any time after resolution, including
+ * immediately after the callback is called, and may not contain some service information that
+ * could be delivered later, like additional host addresses. Prefer using
+ * {@link #registerServiceInfoCallback}, which will keep the application up-to-date with the
+ * state of the service.
*/
+ @Deprecated
public void resolveService(NsdServiceInfo serviceInfo, ResolveListener listener) {
resolveService(serviceInfo, Runnable::run, listener);
}
@@ -1064,7 +1279,14 @@
* @param serviceInfo service to be resolved
* @param executor Executor to run listener callbacks with
* @param listener to receive callback upon success or failure.
+ *
+ * @deprecated the returned ServiceInfo may get stale at any time after resolution, including
+ * immediately after the callback is called, and may not contain some service information that
+ * could be delivered later, like additional host addresses. Prefer using
+ * {@link #registerServiceInfoCallback}, which will keep the application up-to-date with the
+ * state of the service.
*/
+ @Deprecated
public void resolveService(@NonNull NsdServiceInfo serviceInfo,
@NonNull Executor executor, @NonNull ResolveListener listener) {
checkServiceInfo(serviceInfo);
@@ -1076,6 +1298,85 @@
}
}
+ /**
+ * Stop service resolution initiated with {@link #resolveService}.
+ *
+ * A successful stop is notified with a call to {@link ResolveListener#onResolveStopped}.
+ *
+ * <p> Upon failure to stop service resolution for example if resolution is done or the
+ * requester stops resolution repeatedly, the application is notified
+ * {@link ResolveListener#onStopResolutionFailed} with {@link #FAILURE_OPERATION_NOT_RUNNING}
+ *
+ * @param listener This should be a listener object that was passed to {@link #resolveService}.
+ * It identifies the resolution that should be stopped and notifies of a
+ * successful or unsuccessful stop. Throws {@code IllegalArgumentException} if
+ * the listener was not passed to resolveService before.
+ */
+ public void stopServiceResolution(@NonNull ResolveListener listener) {
+ int id = getListenerKey(listener);
+ try {
+ mService.stopResolution(id);
+ } catch (RemoteException e) {
+ e.rethrowFromSystemServer();
+ }
+ }
+
+ /**
+ * Register a callback to listen for updates to a service.
+ *
+ * An application can listen to a service to continuously monitor availability of given service.
+ * The callback methods will be called on the passed executor. And service updates are sent with
+ * continuous calls to {@link ServiceInfoCallback#onServiceUpdated}.
+ *
+ * This is different from {@link #resolveService} which provides one shot service information.
+ *
+ * <p> An application can listen to a service once a time. It needs to cancel the registration
+ * before registering other callbacks. Upon failure to register a callback for example if
+ * it's a duplicated registration, the application is notified through
+ * {@link ServiceInfoCallback#onServiceInfoCallbackRegistrationFailed} with
+ * {@link #FAILURE_BAD_PARAMETERS} or {@link #FAILURE_ALREADY_ACTIVE}.
+ *
+ * @param serviceInfo the service to receive updates for
+ * @param executor Executor to run callbacks with
+ * @param listener to receive callback upon service update
+ */
+ public void registerServiceInfoCallback(@NonNull NsdServiceInfo serviceInfo,
+ @NonNull Executor executor, @NonNull ServiceInfoCallback listener) {
+ checkServiceInfo(serviceInfo);
+ int key = putListener(listener, executor, serviceInfo);
+ try {
+ mService.registerServiceInfoCallback(key, serviceInfo);
+ } catch (RemoteException e) {
+ e.rethrowFromSystemServer();
+ }
+ }
+
+ /**
+ * Unregister a callback registered with {@link #registerServiceInfoCallback}.
+ *
+ * A successful unregistration is notified with a call to
+ * {@link ServiceInfoCallback#onServiceInfoCallbackUnregistered}. The same callback can only be
+ * reused after this is called.
+ *
+ * <p>If the callback is not already registered, this will throw with
+ * {@link IllegalArgumentException}.
+ *
+ * @param listener This should be a listener object that was passed to
+ * {@link #registerServiceInfoCallback}. It identifies the registration that
+ * should be unregistered and notifies of a successful or unsuccessful stop.
+ * Throws {@code IllegalArgumentException} if the listener was not passed to
+ * {@link #registerServiceInfoCallback} before.
+ */
+ public void unregisterServiceInfoCallback(@NonNull ServiceInfoCallback listener) {
+ // Will throw IllegalArgumentException if the listener is not known
+ int id = getListenerKey(listener);
+ try {
+ mService.unregisterServiceInfoCallback(id);
+ } catch (RemoteException e) {
+ e.rethrowFromSystemServer();
+ }
+ }
+
private static void checkListener(Object listener) {
Objects.requireNonNull(listener, "listener cannot be null");
}
diff --git a/framework-t/src/android/net/nsd/NsdServiceInfo.java b/framework-t/src/android/net/nsd/NsdServiceInfo.java
index 6438a60..caeecdd 100644
--- a/framework-t/src/android/net/nsd/NsdServiceInfo.java
+++ b/framework-t/src/android/net/nsd/NsdServiceInfo.java
@@ -26,10 +26,14 @@
import android.util.ArrayMap;
import android.util.Log;
+import com.android.net.module.util.InetAddressUtils;
+
import java.io.UnsupportedEncodingException;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
import java.util.Collections;
+import java.util.List;
import java.util.Map;
/**
@@ -46,7 +50,7 @@
private final ArrayMap<String, byte[]> mTxtRecord = new ArrayMap<>();
- private InetAddress mHost;
+ private final List<InetAddress> mHostAddresses = new ArrayList<>();
private int mPort;
@@ -84,17 +88,32 @@
mServiceType = s;
}
- /** Get the host address. The host address is valid for a resolved service. */
+ /**
+ * Get the host address. The host address is valid for a resolved service.
+ *
+ * @deprecated Use {@link #getHostAddresses()} to get the entire list of addresses for the host.
+ */
+ @Deprecated
public InetAddress getHost() {
- return mHost;
+ return mHostAddresses.size() == 0 ? null : mHostAddresses.get(0);
}
- /** Set the host address */
+ /**
+ * Set the host address
+ *
+ * @deprecated Use {@link #setHostAddresses(List)} to set multiple addresses for the host.
+ */
+ @Deprecated
public void setHost(InetAddress s) {
- mHost = s;
+ setHostAddresses(Collections.singletonList(s));
}
- /** Get port number. The port number is valid for a resolved service. */
+ /**
+ * Get port number. The port number is valid for a resolved service.
+ *
+ * The port is valid for all addresses.
+ * @see #getHostAddresses()
+ */
public int getPort() {
return mPort;
}
@@ -105,6 +124,24 @@
}
/**
+ * Get the host addresses.
+ *
+ * All host addresses are valid for the resolved service.
+ * All addresses share the same port
+ * @see #getPort()
+ */
+ @NonNull
+ public List<InetAddress> getHostAddresses() {
+ return new ArrayList<>(mHostAddresses);
+ }
+
+ /** Set the host addresses */
+ public void setHostAddresses(@NonNull List<InetAddress> addresses) {
+ mHostAddresses.clear();
+ mHostAddresses.addAll(addresses);
+ }
+
+ /**
* Unpack txt information from a base-64 encoded byte array.
*
* @param txtRecordsRawBytes The raw base64 encoded byte array.
@@ -359,7 +396,7 @@
StringBuilder sb = new StringBuilder();
sb.append("name: ").append(mServiceName)
.append(", type: ").append(mServiceType)
- .append(", host: ").append(mHost)
+ .append(", hostAddresses: ").append(TextUtils.join(", ", mHostAddresses))
.append(", port: ").append(mPort)
.append(", network: ").append(mNetwork);
@@ -377,12 +414,6 @@
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(mServiceName);
dest.writeString(mServiceType);
- if (mHost != null) {
- dest.writeInt(1);
- dest.writeByteArray(mHost.getAddress());
- } else {
- dest.writeInt(0);
- }
dest.writeInt(mPort);
// TXT record key/value pairs.
@@ -401,6 +432,10 @@
dest.writeParcelable(mNetwork, 0);
dest.writeInt(mInterfaceIndex);
+ dest.writeInt(mHostAddresses.size());
+ for (InetAddress address : mHostAddresses) {
+ InetAddressUtils.parcelInetAddress(dest, address, flags);
+ }
}
/** Implement the Parcelable interface */
@@ -410,13 +445,6 @@
NsdServiceInfo info = new NsdServiceInfo();
info.mServiceName = in.readString();
info.mServiceType = in.readString();
-
- if (in.readInt() == 1) {
- try {
- info.mHost = InetAddress.getByAddress(in.createByteArray());
- } catch (java.net.UnknownHostException e) {}
- }
-
info.mPort = in.readInt();
// TXT record key/value pairs.
@@ -432,6 +460,10 @@
}
info.mNetwork = in.readParcelable(null, Network.class);
info.mInterfaceIndex = in.readInt();
+ int size = in.readInt();
+ for (int i = 0; i < size; i++) {
+ info.mHostAddresses.add(InetAddressUtils.unparcelInetAddress(in));
+ }
return info;
}
diff --git a/framework/api/system-current.txt b/framework/api/system-current.txt
index dd3404c..0b03983 100644
--- a/framework/api/system-current.txt
+++ b/framework/api/system-current.txt
@@ -470,7 +470,9 @@
}
public abstract class SocketKeepalive implements java.lang.AutoCloseable {
+ method public final void start(@IntRange(from=0xa, to=0xe10) int, int);
field public static final int ERROR_NO_SUCH_SLOT = -33; // 0xffffffdf
+ field public static final int FLAG_AUTOMATIC_ON_OFF = 1; // 0x1
field public static final int SUCCESS = 0; // 0x0
}
diff --git a/framework/src/android/net/ConnectivityManager.java b/framework/src/android/net/ConnectivityManager.java
index 40defd4..4224da9 100644
--- a/framework/src/android/net/ConnectivityManager.java
+++ b/framework/src/android/net/ConnectivityManager.java
@@ -2287,6 +2287,13 @@
mExecutor.execute(() -> {
try {
if (mSlot != null) {
+ // TODO : this is incorrect, because in the presence of auto on/off
+ // keepalive the slot associated with this keepalive can have
+ // changed. Also, this actually causes another problem where some other
+ // app might stop your keepalive if it just knows the network and
+ // the slot and goes through the trouble of grabbing the aidl object.
+ // This code should use the callback to identify what keepalive to
+ // stop instead.
mService.stopKeepalive(mNetwork, mSlot);
}
} catch (RemoteException e) {
diff --git a/framework/src/android/net/IConnectivityManager.aidl b/framework/src/android/net/IConnectivityManager.aidl
index 7b6e769..7db231e 100644
--- a/framework/src/android/net/IConnectivityManager.aidl
+++ b/framework/src/android/net/IConnectivityManager.aidl
@@ -188,7 +188,7 @@
void startNattKeepaliveWithFd(in Network network, in ParcelFileDescriptor pfd, int resourceId,
int intervalSeconds, in ISocketKeepaliveCallback cb, String srcAddr,
- String dstAddr);
+ String dstAddr, boolean automaticOnOffKeepalives);
void startTcpKeepalive(in Network network, in ParcelFileDescriptor pfd, int intervalSeconds,
in ISocketKeepaliveCallback cb);
diff --git a/framework/src/android/net/NattSocketKeepalive.java b/framework/src/android/net/NattSocketKeepalive.java
index 56cc923..4d45e70 100644
--- a/framework/src/android/net/NattSocketKeepalive.java
+++ b/framework/src/android/net/NattSocketKeepalive.java
@@ -47,13 +47,39 @@
mResourceId = resourceId;
}
+ /**
+ * Request that keepalive be started with the given {@code intervalSec}.
+ *
+ * When a VPN is running with the network for this keepalive as its underlying network, the
+ * system can monitor the TCP connections on that VPN to determine whether this keepalive is
+ * necessary. To enable this behavior, pass {@link SocketKeepalive#FLAG_AUTOMATIC_ON_OFF} into
+ * the flags. When this is enabled, the system will disable sending keepalive packets when
+ * there are no TCP connections over the VPN(s) running over this network to save battery, and
+ * restart sending them as soon as any TCP connection is opened over one of the VPN networks.
+ * When no VPN is running on top of this network, this flag has no effect, i.e. the keepalives
+ * are always sent with the specified interval.
+ *
+ * Also {@see SocketKeepalive}.
+ *
+ * @param intervalSec The target interval in seconds between keepalive packet transmissions.
+ * The interval should be between 10 seconds and 3600 seconds. Otherwise,
+ * the supplied {@link Callback} will see a call to
+ * {@link Callback#onError(int)} with {@link #ERROR_INVALID_INTERVAL}.
+ * @param flags Flags to enable/disable available options on this keepalive.
+ * @hide
+ */
@Override
- protected void startImpl(int intervalSec) {
+ protected void startImpl(int intervalSec, int flags) {
+ if (0 != (flags & ~FLAG_AUTOMATIC_ON_OFF)) {
+ throw new IllegalArgumentException("Illegal flag value for "
+ + this.getClass().getSimpleName() + " : " + flags);
+ }
+ final boolean automaticOnOffKeepalives = 0 != (flags & FLAG_AUTOMATIC_ON_OFF);
mExecutor.execute(() -> {
try {
mService.startNattKeepaliveWithFd(mNetwork, mPfd, mResourceId,
- intervalSec, mCallback,
- mSource.getHostAddress(), mDestination.getHostAddress());
+ intervalSec, mCallback, mSource.getHostAddress(),
+ mDestination.getHostAddress(), automaticOnOffKeepalives);
} catch (RemoteException e) {
Log.e(TAG, "Error starting socket keepalive: ", e);
throw e.rethrowFromSystemServer();
diff --git a/framework/src/android/net/NetworkAgent.java b/framework/src/android/net/NetworkAgent.java
index 1486619..62e4fe1 100644
--- a/framework/src/android/net/NetworkAgent.java
+++ b/framework/src/android/net/NetworkAgent.java
@@ -281,7 +281,7 @@
*
* arg1 = the hardware slot number of the keepalive to start
* arg2 = interval in seconds
- * obj = KeepalivePacketData object describing the data to be sent
+ * obj = AutomaticKeepaliveInfo object
*
* Also used internally by ConnectivityService / KeepaliveTracker, with different semantics.
* @hide
@@ -483,6 +483,19 @@
*/
public static final int EVENT_UNREGISTER_AFTER_REPLACEMENT = BASE + 29;
+ /**
+ * Sent by AutomaticOnOffKeepaliveTracker periodically (when relevant) to trigger monitor
+ * automatic keepalive request.
+ *
+ * NATT keepalives have an automatic mode where the system only sends keepalive packets when
+ * TCP sockets are open over a VPN. The system will check periodically for presence of
+ * such open sockets, and this message is what triggers the re-evaluation.
+ *
+ * obj = AutomaticOnOffKeepaliveObject.
+ * @hide
+ */
+ public static final int CMD_MONITOR_AUTOMATIC_KEEPALIVE = BASE + 30;
+
private static NetworkInfo getLegacyNetworkInfo(final NetworkAgentConfig config) {
final NetworkInfo ni = new NetworkInfo(config.legacyType, config.legacySubType,
config.legacyTypeName, config.legacySubTypeName);
diff --git a/framework/src/android/net/NetworkCapabilities.java b/framework/src/android/net/NetworkCapabilities.java
index e07601f..e70d75d 100644
--- a/framework/src/android/net/NetworkCapabilities.java
+++ b/framework/src/android/net/NetworkCapabilities.java
@@ -18,6 +18,7 @@
import static com.android.internal.annotations.VisibleForTesting.Visibility.PRIVATE;
import static com.android.net.module.util.BitUtils.appendStringRepresentationOfBitMaskToStringBuilder;
+import static com.android.net.module.util.BitUtils.describeDifferences;
import android.annotation.IntDef;
import android.annotation.LongDef;
@@ -2069,30 +2070,14 @@
* Returns a short but human-readable string of updates from an older set of capabilities.
* @param old the old capabilities to diff from
* @return a string fit for logging differences, or null if no differences.
- * this never returns the empty string.
+ * this never returns the empty string. See BitUtils#describeDifferences.
* @hide
*/
@Nullable
public String describeCapsDifferencesFrom(@Nullable final NetworkCapabilities old) {
final long oldCaps = null == old ? 0 : old.mNetworkCapabilities;
- final long changed = oldCaps ^ mNetworkCapabilities;
- if (0 == changed) return null;
- // If the control reaches here, there are changes (additions, removals, or both) so
- // the code below is guaranteed to add something to the string and can't return "".
- final long removed = oldCaps & changed;
- final long added = mNetworkCapabilities & changed;
- final StringBuilder sb = new StringBuilder();
- if (0 != removed) {
- sb.append("-");
- appendStringRepresentationOfBitMaskToStringBuilder(sb, removed,
- NetworkCapabilities::capabilityNameOf, "-");
- }
- if (0 != added) {
- sb.append("+");
- appendStringRepresentationOfBitMaskToStringBuilder(sb, added,
- NetworkCapabilities::capabilityNameOf, "+");
- }
- return sb.toString();
+ return describeDifferences(oldCaps, mNetworkCapabilities,
+ NetworkCapabilities::capabilityNameOf);
}
/**
diff --git a/framework/src/android/net/SocketKeepalive.java b/framework/src/android/net/SocketKeepalive.java
index 57cf5e3..90e5e9b 100644
--- a/framework/src/android/net/SocketKeepalive.java
+++ b/framework/src/android/net/SocketKeepalive.java
@@ -16,6 +16,8 @@
package android.net;
+import static android.annotation.SystemApi.Client.PRIVILEGED_APPS;
+
import android.annotation.IntDef;
import android.annotation.IntRange;
import android.annotation.NonNull;
@@ -174,6 +176,27 @@
public @interface KeepaliveEvent {}
/**
+ * Whether the system automatically toggles keepalive when no TCP connection is open on the VPN.
+ *
+ * If this flag is present, the system will monitor the VPN(s) running on top of the specified
+ * network for open TCP connections. When no such connections are open, it will turn off the
+ * keepalives to conserve battery power. When there is at least one such connection it will
+ * turn on the keepalives to make sure functionality is preserved.
+ *
+ * This only works with {@link NattSocketKeepalive}.
+ * @hide
+ */
+ @SystemApi
+ public static final int FLAG_AUTOMATIC_ON_OFF = 1 << 0;
+
+ /** @hide */
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef(prefix = { "FLAG_"}, flag = true, value = {
+ FLAG_AUTOMATIC_ON_OFF
+ })
+ public @interface StartFlags {}
+
+ /**
* The minimum interval in seconds between keepalive packet transmissions.
*
* @hide
@@ -294,13 +317,15 @@
}
/**
- * Request that keepalive be started with the given {@code intervalSec}. See
- * {@link SocketKeepalive}. If the remote binder dies, or the binder call throws an exception
- * when invoking start or stop of the {@link SocketKeepalive}, a {@link RemoteException} will be
- * thrown into the {@code executor}. This is typically not important to catch because the remote
- * party is the system, so if it is not in shape to communicate through binder the system is
- * probably going down anyway. If the caller cares regardless, it can use a custom
- * {@link Executor} to catch the {@link RemoteException}.
+ * Request that keepalive be started with the given {@code intervalSec}.
+ *
+ * See {@link SocketKeepalive}. If the remote binder dies, or the binder call throws an
+ * exception when invoking start or stop of the {@link SocketKeepalive}, a
+ * {@link RuntimeException} caused by a {@link RemoteException} will be thrown into the
+ * {@link Executor}. This is typically not important to catch because the remote party is
+ * the system, so if it is not in shape to communicate through binder the system is going
+ * down anyway. If the caller still cares, it can use a custom {@link Executor} to catch the
+ * {@link RuntimeException}.
*
* @param intervalSec The target interval in seconds between keepalive packet transmissions.
* The interval should be between 10 seconds and 3600 seconds, otherwise
@@ -308,11 +333,35 @@
*/
public final void start(@IntRange(from = MIN_INTERVAL_SEC, to = MAX_INTERVAL_SEC)
int intervalSec) {
- startImpl(intervalSec);
+ startImpl(intervalSec, 0 /* flags */);
+ }
+
+ /**
+ * Request that keepalive be started with the given {@code intervalSec}.
+ *
+ * See {@link SocketKeepalive}. If the remote binder dies, or the binder call throws an
+ * exception when invoking start or stop of the {@link SocketKeepalive}, a
+ * {@link RuntimeException} caused by a {@link RemoteException} will be thrown into the
+ * {@link Executor}. This is typically not important to catch because the remote party is
+ * the system, so if it is not in shape to communicate through binder the system is going
+ * down anyway. If the caller still cares, it can use a custom {@link Executor} to catch the
+ * {@link RuntimeException}.
+ *
+ * @param intervalSec The target interval in seconds between keepalive packet transmissions.
+ * The interval should be between 10 seconds and 3600 seconds. Otherwise,
+ * the supplied {@link Callback} will see a call to
+ * {@link Callback#onError(int)} with {@link #ERROR_INVALID_INTERVAL}.
+ * @param flags Flags to enable/disable available options on this keepalive.
+ * @hide
+ */
+ @SystemApi(client = PRIVILEGED_APPS)
+ public final void start(@IntRange(from = MIN_INTERVAL_SEC, to = MAX_INTERVAL_SEC)
+ int intervalSec, @StartFlags int flags) {
+ startImpl(intervalSec, flags);
}
/** @hide */
- protected abstract void startImpl(int intervalSec);
+ protected abstract void startImpl(int intervalSec, @StartFlags int flags);
/**
* Requests that keepalive be stopped. The application must wait for {@link Callback#onStopped}
diff --git a/framework/src/android/net/TcpSocketKeepalive.java b/framework/src/android/net/TcpSocketKeepalive.java
index 7131784..51d805e 100644
--- a/framework/src/android/net/TcpSocketKeepalive.java
+++ b/framework/src/android/net/TcpSocketKeepalive.java
@@ -50,7 +50,11 @@
* acknowledgement.
*/
@Override
- protected void startImpl(int intervalSec) {
+ protected void startImpl(int intervalSec, int flags) {
+ if (0 != flags) {
+ throw new IllegalArgumentException("Illegal flag value for "
+ + this.getClass().getSimpleName() + " : " + flags);
+ }
mExecutor.execute(() -> {
try {
mService.startTcpKeepalive(mNetwork, mPfd, intervalSec, mCallback);
diff --git a/nearby/tests/integration/untrusted/src/androidx/test/uiautomator/LogcatWaitMixin.java b/nearby/tests/integration/untrusted/src/androidx/test/uiautomator/LogcatWaitMixin.java
index 86e39dc..8b5ac12 100644
--- a/nearby/tests/integration/untrusted/src/androidx/test/uiautomator/LogcatWaitMixin.java
+++ b/nearby/tests/integration/untrusted/src/androidx/test/uiautomator/LogcatWaitMixin.java
@@ -54,7 +54,7 @@
@NonNull String specificLog, @NonNull Date startTime) {
return new Condition<UiDevice, Boolean>() {
@Override
- Boolean apply(UiDevice device) {
+ public Boolean apply(UiDevice device) {
String logcatLogs;
try {
logcatLogs = device.executeShellCommand("logcat -v time -v year -d");
diff --git a/service-t/Android.bp b/service-t/Android.bp
index d876166..5bf2973 100644
--- a/service-t/Android.bp
+++ b/service-t/Android.bp
@@ -52,6 +52,7 @@
"framework-connectivity-t-pre-jarjar",
// TODO: use framework-tethering-pre-jarjar when it is separated from framework-tethering
"framework-tethering.impl",
+ "framework-wifi",
"service-connectivity-pre-jarjar",
"service-nearby-pre-jarjar",
"ServiceConnectivityResources",
diff --git a/service-t/jni/com_android_server_net_NetworkStatsService.cpp b/service-t/jni/com_android_server_net_NetworkStatsService.cpp
index 39cbaf7..af0b8d8 100644
--- a/service-t/jni/com_android_server_net_NetworkStatsService.cpp
+++ b/service-t/jni/com_android_server_net_NetworkStatsService.cpp
@@ -30,9 +30,11 @@
#include "bpf/BpfUtils.h"
#include "netdbpf/BpfNetworkStats.h"
+#include "netdbpf/NetworkTraceHandler.h"
using android::bpf::bpfGetUidStats;
using android::bpf::bpfGetIfaceStats;
+using android::bpf::NetworkTraceHandler;
namespace android {
@@ -67,7 +69,7 @@
}
}
-static jlong getTotalStat(JNIEnv* env, jclass clazz, jint type) {
+static jlong nativeGetTotalStat(JNIEnv* env, jclass clazz, jint type) {
Stats stats = {};
if (bpfGetIfaceStats(NULL, &stats) == 0) {
@@ -77,7 +79,7 @@
}
}
-static jlong getIfaceStat(JNIEnv* env, jclass clazz, jstring iface, jint type) {
+static jlong nativeGetIfaceStat(JNIEnv* env, jclass clazz, jstring iface, jint type) {
ScopedUtfChars iface8(env, iface);
if (iface8.c_str() == NULL) {
return UNKNOWN;
@@ -92,7 +94,7 @@
}
}
-static jlong getUidStat(JNIEnv* env, jclass clazz, jint uid, jint type) {
+static jlong nativeGetUidStat(JNIEnv* env, jclass clazz, jint uid, jint type) {
Stats stats = {};
if (bpfGetUidStats(uid, &stats) == 0) {
@@ -102,10 +104,15 @@
}
}
+static void nativeInitNetworkTracing(JNIEnv* env, jclass clazz) {
+ NetworkTraceHandler::InitPerfettoTracing();
+}
+
static const JNINativeMethod gMethods[] = {
- {"nativeGetTotalStat", "(I)J", (void*)getTotalStat},
- {"nativeGetIfaceStat", "(Ljava/lang/String;I)J", (void*)getIfaceStat},
- {"nativeGetUidStat", "(II)J", (void*)getUidStat},
+ {"nativeGetTotalStat", "(I)J", (void*)nativeGetTotalStat},
+ {"nativeGetIfaceStat", "(Ljava/lang/String;I)J", (void*)nativeGetIfaceStat},
+ {"nativeGetUidStat", "(II)J", (void*)nativeGetUidStat},
+ {"nativeInitNetworkTracing", "()V", (void*)nativeInitNetworkTracing},
};
int register_android_server_net_NetworkStatsService(JNIEnv* env) {
diff --git a/service-t/native/libs/libnetworkstats/Android.bp b/service-t/native/libs/libnetworkstats/Android.bp
index 5b3d314..aa1ee41 100644
--- a/service-t/native/libs/libnetworkstats/Android.bp
+++ b/service-t/native/libs/libnetworkstats/Android.bp
@@ -24,12 +24,19 @@
host_supported: false,
header_libs: ["bpf_connectivity_headers"],
srcs: [
- "BpfNetworkStats.cpp"
+ "BpfNetworkStats.cpp",
+ "NetworkTraceHandler.cpp",
],
shared_libs: [
"libbase",
"liblog",
],
+ static_libs: [
+ "libperfetto_client_experimental",
+ ],
+ export_static_lib_headers: [
+ "libperfetto_client_experimental",
+ ],
export_include_dirs: ["include"],
cflags: [
"-Wall",
@@ -54,6 +61,7 @@
header_libs: ["bpf_connectivity_headers"],
srcs: [
"BpfNetworkStatsTest.cpp",
+ "NetworkTraceHandlerTest.cpp",
],
cflags: [
"-Wall",
@@ -64,10 +72,12 @@
static_libs: [
"libgmock",
"libnetworkstats",
+ "libperfetto_client_experimental",
],
shared_libs: [
"libbase",
"liblog",
+ "libandroid_net",
],
compile_multilib: "both",
multilib: {
diff --git a/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp b/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp
new file mode 100644
index 0000000..4c37b8d
--- /dev/null
+++ b/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "NetworkTrace"
+
+#include "netdbpf/NetworkTraceHandler.h"
+
+#include <arpa/inet.h>
+#include <bpf/BpfUtils.h>
+#include <log/log.h>
+#include <perfetto/config/android/network_trace_config.pbzero.h>
+#include <perfetto/trace/android/network_trace.pbzero.h>
+#include <perfetto/trace/profiling/profile_packet.pbzero.h>
+#include <perfetto/tracing/platform.h>
+#include <perfetto/tracing/tracing.h>
+
+// Note: this is initializing state for a templated Perfetto type that resides
+// in the `perfetto` namespace. This must be defined in the global scope.
+PERFETTO_DEFINE_DATA_SOURCE_STATIC_MEMBERS(android::bpf::NetworkTraceHandler);
+
+namespace android {
+namespace bpf {
+using ::perfetto::protos::pbzero::NetworkPacketEvent;
+using ::perfetto::protos::pbzero::NetworkPacketTraceConfig;
+using ::perfetto::protos::pbzero::TracePacket;
+using ::perfetto::protos::pbzero::TrafficDirection;
+
+// static
+void NetworkTraceHandler::RegisterDataSource() {
+ ALOGD("Registering Perfetto data source");
+ perfetto::DataSourceDescriptor dsd;
+ dsd.set_name("android.network_packets");
+ NetworkTraceHandler::Register(dsd);
+}
+
+// static
+void NetworkTraceHandler::InitPerfettoTracing() {
+ perfetto::TracingInitArgs args = {};
+ args.backends |= perfetto::kSystemBackend;
+ perfetto::Tracing::Initialize(args);
+ NetworkTraceHandler::RegisterDataSource();
+}
+
+NetworkTraceHandler::NetworkTraceHandler()
+ : NetworkTraceHandler([this](const PacketTrace& pkt) {
+ NetworkTraceHandler::Trace(
+ [this, pkt](NetworkTraceHandler::TraceContext ctx) {
+ Fill(pkt, *ctx.NewTracePacket());
+ });
+ }) {}
+
+void NetworkTraceHandler::OnSetup(const SetupArgs& args) {
+ const std::string& raw = args.config->network_packet_trace_config_raw();
+ NetworkPacketTraceConfig::Decoder config(raw);
+
+ mPollMs = config.poll_ms();
+ if (mPollMs < 100) {
+ ALOGI("poll_ms is missing or below the 100ms minimum. Increasing to 100ms");
+ mPollMs = 100;
+ }
+}
+
+void NetworkTraceHandler::OnStart(const StartArgs&) {
+ if (!Start()) return;
+ mTaskRunner = perfetto::Platform::GetDefaultPlatform()->CreateTaskRunner({});
+ Loop();
+}
+
+void NetworkTraceHandler::OnStop(const StopArgs&) {
+ Stop();
+ mTaskRunner.reset();
+}
+
+void NetworkTraceHandler::Loop() {
+ mTaskRunner->PostDelayedTask([this]() { Loop(); }, mPollMs);
+ ConsumeAll();
+}
+
+void NetworkTraceHandler::Fill(const PacketTrace& src, TracePacket& dst) {
+ dst.set_timestamp(src.timestampNs);
+ auto* event = dst.set_network_packet();
+ event->set_direction(src.egress ? TrafficDirection::DIR_EGRESS
+ : TrafficDirection::DIR_INGRESS);
+ event->set_length(src.length);
+ event->set_uid(src.uid);
+ event->set_tag(src.tag);
+
+ event->set_local_port(src.egress ? ntohs(src.sport) : ntohs(src.dport));
+ event->set_remote_port(src.egress ? ntohs(src.dport) : ntohs(src.sport));
+
+ event->set_ip_proto(src.ipProto);
+ event->set_tcp_flags(src.tcpFlags);
+
+ char ifname[IF_NAMESIZE] = {};
+ if (if_indextoname(src.ifindex, ifname) == ifname) {
+ event->set_interface(std::string(ifname));
+ } else {
+ event->set_interface("error");
+ }
+}
+
+bool NetworkTraceHandler::Start() {
+ ALOGD("Starting datasource");
+
+ auto status = mConfigurationMap.init(PACKET_TRACE_ENABLED_MAP_PATH);
+ if (!status.ok()) {
+ ALOGW("Failed to bind config map: %s", status.error().message().c_str());
+ return false;
+ }
+
+ auto rb = BpfRingbuf<PacketTrace>::Create(PACKET_TRACE_RINGBUF_PATH);
+ if (!rb.ok()) {
+ ALOGW("Failed to create ringbuf: %s", rb.error().message().c_str());
+ return false;
+ }
+
+ mRingBuffer = std::move(*rb);
+
+ auto res = mConfigurationMap.writeValue(0, true, BPF_ANY);
+ if (!res.ok()) {
+ ALOGW("Failed to enable tracing: %s", res.error().message().c_str());
+ return false;
+ }
+
+ return true;
+}
+
+bool NetworkTraceHandler::Stop() {
+ ALOGD("Stopping datasource");
+
+ auto res = mConfigurationMap.writeValue(0, false, BPF_ANY);
+ if (!res.ok()) {
+ ALOGW("Failed to disable tracing: %s", res.error().message().c_str());
+ return false;
+ }
+
+ mRingBuffer.reset();
+
+ return true;
+}
+
+bool NetworkTraceHandler::ConsumeAll() {
+ if (mRingBuffer == nullptr) {
+ ALOGW("Tracing is not active");
+ return false;
+ }
+
+ base::Result<int> ret = mRingBuffer->ConsumeAll(mCallback);
+ if (!ret.ok()) {
+ ALOGW("Failed to poll ringbuf: %s", ret.error().message().c_str());
+ return false;
+ }
+
+ return true;
+}
+
+} // namespace bpf
+} // namespace android
diff --git a/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp b/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp
new file mode 100644
index 0000000..760ae91
--- /dev/null
+++ b/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp
@@ -0,0 +1,198 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <android-base/unique_fd.h>
+#include <android/multinetwork.h>
+#include <arpa/inet.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <inttypes.h>
+#include <net/if.h>
+#include <netinet/tcp.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <vector>
+
+#include "netdbpf/NetworkTraceHandler.h"
+
+using ::testing::AllOf;
+using ::testing::AnyOf;
+using ::testing::Each;
+using ::testing::Eq;
+using ::testing::Field;
+using ::testing::Test;
+
+namespace android {
+namespace bpf {
+
+__be16 bindAndListen(int s) {
+ sockaddr_in sin = {.sin_family = AF_INET};
+ socklen_t len = sizeof(sin);
+ if (bind(s, (sockaddr*)&sin, sizeof(sin))) return 0;
+ if (listen(s, 1)) return 0;
+ if (getsockname(s, (sockaddr*)&sin, &len)) return 0;
+ return sin.sin_port;
+}
+
+// This takes tcp flag constants from the standard library and makes them usable
+// with the flags we get from BPF. The standard library flags are big endian
+// whereas the BPF flags are reported in host byte order. BPF also trims the
+// flags down to the 8 single-bit flag bits (fin, syn, rst, etc).
+constexpr inline uint8_t FlagToHost(__be32 be_unix_flags) {
+ return ntohl(be_unix_flags) >> 16;
+}
+
+// Pretty prints all fields for a list of packets (useful for debugging).
+struct PacketPrinter {
+ const std::vector<PacketTrace>& data;
+ static constexpr char kTcpFlagNames[] = "FSRPAUEC";
+
+ friend std::ostream& operator<<(std::ostream& os, const PacketPrinter& d) {
+ os << "Packet count: " << d.data.size();
+ for (const PacketTrace& info : d.data) {
+ os << "\nifidx=" << info.ifindex;
+ os << ", len=" << info.length;
+ os << ", uid=" << info.uid;
+ os << ", tag=" << info.tag;
+ os << ", sport=" << info.sport;
+ os << ", dport=" << info.dport;
+ os << ", direction=" << (info.egress ? "egress" : "ingress");
+ os << ", proto=" << static_cast<int>(info.ipProto);
+ os << ", ip=" << static_cast<int>(info.ipVersion);
+ os << ", flags=";
+ for (int i = 0; i < 8; i++) {
+ os << ((info.tcpFlags & (1 << i)) ? kTcpFlagNames[i] : '.');
+ }
+ }
+ return os;
+ }
+};
+
+class NetworkTraceHandlerTest : public testing::Test {
+ protected:
+ void SetUp() {
+ if (access(PACKET_TRACE_RINGBUF_PATH, R_OK)) {
+ GTEST_SKIP() << "Network tracing is not enabled/loaded on this build";
+ }
+ }
+};
+
+TEST_F(NetworkTraceHandlerTest, PollWhileInactive) {
+ NetworkTraceHandler handler([&](const PacketTrace& pkt) {});
+
+ // One succeed after start and before stop.
+ EXPECT_FALSE(handler.ConsumeAll());
+ ASSERT_TRUE(handler.Start());
+ EXPECT_TRUE(handler.ConsumeAll());
+ ASSERT_TRUE(handler.Stop());
+ EXPECT_FALSE(handler.ConsumeAll());
+}
+
+TEST_F(NetworkTraceHandlerTest, TraceTcpSession) {
+ __be16 server_port = 0;
+ std::vector<PacketTrace> packets;
+
+ // Record all packets with the bound address and current uid. This callback is
+ // involked only within ConsumeAll, at which point the port should have
+ // already been filled in and all packets have been processed.
+ NetworkTraceHandler handler([&](const PacketTrace& pkt) {
+ if (pkt.sport != server_port && pkt.dport != server_port) return;
+ if (pkt.uid != getuid()) return;
+ packets.push_back(pkt);
+ });
+
+ ASSERT_TRUE(handler.Start());
+ const uint32_t kClientTag = 2468;
+ const uint32_t kServerTag = 1357;
+
+ // Go through a typical connection sequence between two v4 sockets using tcp.
+ // This covers connection handshake, shutdown, and one data packet.
+ {
+ android::base::unique_fd clientsocket(socket(AF_INET, SOCK_STREAM, 0));
+ ASSERT_NE(-1, clientsocket) << "Failed to open client socket";
+ ASSERT_EQ(android_tag_socket(clientsocket, kClientTag), 0);
+
+ android::base::unique_fd serversocket(socket(AF_INET, SOCK_STREAM, 0));
+ ASSERT_NE(-1, serversocket) << "Failed to open server socket";
+ ASSERT_EQ(android_tag_socket(serversocket, kServerTag), 0);
+
+ server_port = bindAndListen(serversocket);
+ ASSERT_NE(0, server_port) << "Can't bind to server port";
+
+ sockaddr_in addr = {.sin_family = AF_INET, .sin_port = server_port};
+ ASSERT_EQ(0, connect(clientsocket, (sockaddr*)&addr, sizeof(addr)))
+ << "connect to loopback failed: " << strerror(errno);
+
+ int accepted = accept(serversocket, nullptr, nullptr);
+ ASSERT_NE(-1, accepted) << "accept connection failed: " << strerror(errno);
+
+ const char data[] = "abcdefghijklmnopqrstuvwxyz";
+ EXPECT_EQ(send(clientsocket, data, sizeof(data), 0), sizeof(data))
+ << "failed to send message: " << strerror(errno);
+
+ char buff[100] = {};
+ EXPECT_EQ(recv(accepted, buff, sizeof(buff), 0), sizeof(data))
+ << "failed to receive message: " << strerror(errno);
+
+ EXPECT_EQ(std::string(data), std::string(buff));
+ }
+
+ ASSERT_TRUE(handler.ConsumeAll());
+ ASSERT_TRUE(handler.Stop());
+
+ // There are 12 packets in total (6 messages: each seen by client & server):
+ // 1. Client connects to server with syn
+ // 2. Server responds with syn ack
+ // 3. Client responds with ack
+ // 4. Client sends data with psh ack
+ // 5. Server acks the data packet
+ // 6. Client closes connection with fin ack
+ ASSERT_EQ(packets.size(), 12) << PacketPrinter{packets};
+
+ // All packets should be TCP packets.
+ EXPECT_THAT(packets, Each(Field(&PacketTrace::ipProto, Eq(IPPROTO_TCP))));
+
+ // Packet 1: client requests connection with server.
+ EXPECT_EQ(packets[0].egress, 1) << PacketPrinter{packets};
+ EXPECT_EQ(packets[0].dport, server_port) << PacketPrinter{packets};
+ EXPECT_EQ(packets[0].tag, kClientTag) << PacketPrinter{packets};
+ EXPECT_EQ(packets[0].tcpFlags, FlagToHost(TCP_FLAG_SYN))
+ << PacketPrinter{packets};
+
+ // Packet 2: server receives request from client.
+ EXPECT_EQ(packets[1].egress, 0) << PacketPrinter{packets};
+ EXPECT_EQ(packets[1].dport, server_port) << PacketPrinter{packets};
+ EXPECT_EQ(packets[1].tag, kServerTag) << PacketPrinter{packets};
+ EXPECT_EQ(packets[1].tcpFlags, FlagToHost(TCP_FLAG_SYN))
+ << PacketPrinter{packets};
+
+ // Packet 3: server replies back with syn ack.
+ EXPECT_EQ(packets[2].egress, 1) << PacketPrinter{packets};
+ EXPECT_EQ(packets[2].sport, server_port) << PacketPrinter{packets};
+ EXPECT_EQ(packets[2].tcpFlags, FlagToHost(TCP_FLAG_SYN | TCP_FLAG_ACK))
+ << PacketPrinter{packets};
+
+ // Packet 4: client receives the server's syn ack.
+ EXPECT_EQ(packets[3].egress, 0) << PacketPrinter{packets};
+ EXPECT_EQ(packets[3].sport, server_port) << PacketPrinter{packets};
+ EXPECT_EQ(packets[3].tcpFlags, FlagToHost(TCP_FLAG_SYN | TCP_FLAG_ACK))
+ << PacketPrinter{packets};
+}
+
+} // namespace bpf
+} // namespace android
diff --git a/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h b/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h
new file mode 100644
index 0000000..c257aa0
--- /dev/null
+++ b/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h
@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2023, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <perfetto/base/task_runner.h>
+#include <perfetto/tracing.h>
+
+#include <string>
+#include <unordered_map>
+
+#include "bpf/BpfMap.h"
+#include "bpf/BpfRingbuf.h"
+
+// For PacketTrace struct definition
+#include "netd.h"
+
+namespace android {
+namespace bpf {
+
+class NetworkTraceHandler : public perfetto::DataSource<NetworkTraceHandler> {
+ public:
+ // Registers this DataSource.
+ static void RegisterDataSource();
+
+ // Connects to the system Perfetto daemon and registers the trace handler.
+ static void InitPerfettoTracing();
+
+ // Initialize with the default Perfetto callback.
+ NetworkTraceHandler();
+
+ // Testonly: initialize with a callback capable of intercepting data.
+ NetworkTraceHandler(std::function<void(const PacketTrace&)> callback)
+ : mCallback(std::move(callback)) {}
+
+ // Testonly: standalone functions without perfetto dependency.
+ bool Start();
+ bool Stop();
+ bool ConsumeAll();
+
+ // perfetto::DataSource overrides:
+ void OnSetup(const SetupArgs&) override;
+ void OnStart(const StartArgs&) override;
+ void OnStop(const StopArgs&) override;
+
+ // Convert a PacketTrace into a Perfetto trace packet.
+ void Fill(const PacketTrace& src,
+ ::perfetto::protos::pbzero::TracePacket& dst);
+
+ private:
+ void Loop();
+
+ // How often to poll the ring buffer, defined by the trace config.
+ uint32_t mPollMs;
+
+ // The function to process PacketTrace, typically a Perfetto sink.
+ std::function<void(const PacketTrace&)> mCallback;
+
+ // The BPF ring buffer handle.
+ std::unique_ptr<BpfRingbuf<PacketTrace>> mRingBuffer;
+
+ // The packet tracing config map (really a 1-element array).
+ BpfMap<uint32_t, bool> mConfigurationMap;
+
+ // This must be the last member, causing it to be the first deleted. If it is
+ // not, members required for callbacks can be deleted before it's stopped.
+ std::unique_ptr<perfetto::base::TaskRunner> mTaskRunner;
+};
+
+} // namespace bpf
+} // namespace android
diff --git a/service-t/src/com/android/server/NetworkStatsServiceInitializer.java b/service-t/src/com/android/server/NetworkStatsServiceInitializer.java
index 0ea126a..82a4fbd 100644
--- a/service-t/src/com/android/server/NetworkStatsServiceInitializer.java
+++ b/service-t/src/com/android/server/NetworkStatsServiceInitializer.java
@@ -18,6 +18,7 @@
import android.content.Context;
import android.net.TrafficStats;
+import android.os.Build;
import android.util.Log;
import com.android.modules.utils.build.SdkLevel;
@@ -46,6 +47,15 @@
/* allowIsolated= */ false);
TrafficStats.init(getContext());
}
+
+ // The following code registers the Perfetto Network Trace Handler on non-user builds.
+ // The enhanced tracing is intended to be used for debugging and diagnosing issues. This
+ // is conditional on the build type rather than `isDebuggable` to match the system_server
+ // selinux rules which only allow the Perfetto connection under the same circumstances.
+ if (SdkLevel.isAtLeastU() && !Build.TYPE.equals("user")) {
+ Log.i(TAG, "Initializing network tracing hooks");
+ NetworkStatsService.nativeInitNetworkTracing();
+ }
}
@Override
diff --git a/service-t/src/com/android/server/NsdService.java b/service-t/src/com/android/server/NsdService.java
index 1226eea..49c6ef0 100644
--- a/service-t/src/com/android/server/NsdService.java
+++ b/service-t/src/com/android/server/NsdService.java
@@ -17,12 +17,17 @@
package com.android.server;
import static android.net.ConnectivityManager.NETID_UNSET;
+import static android.net.nsd.NsdManager.MDNS_DISCOVERY_MANAGER_EVENT;
import static android.net.nsd.NsdManager.MDNS_SERVICE_EVENT;
+import static android.provider.DeviceConfig.NAMESPACE_CONNECTIVITY;
+import android.annotation.NonNull;
+import android.annotation.Nullable;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.INetd;
+import android.net.InetAddresses;
import android.net.LinkProperties;
import android.net.Network;
import android.net.mdns.aidl.DiscoveryInfo;
@@ -39,18 +44,29 @@
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
+import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.os.UserHandle;
+import android.text.TextUtils;
import android.util.Log;
import android.util.Pair;
import android.util.SparseArray;
-import android.util.SparseIntArray;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.State;
import com.android.internal.util.StateMachine;
+import com.android.net.module.util.DeviceConfigUtils;
import com.android.net.module.util.PermissionUtils;
+import com.android.server.connectivity.mdns.ExecutorProvider;
+import com.android.server.connectivity.mdns.MdnsAdvertiser;
+import com.android.server.connectivity.mdns.MdnsDiscoveryManager;
+import com.android.server.connectivity.mdns.MdnsMultinetworkSocketClient;
+import com.android.server.connectivity.mdns.MdnsSearchOptions;
+import com.android.server.connectivity.mdns.MdnsServiceBrowserListener;
+import com.android.server.connectivity.mdns.MdnsServiceInfo;
+import com.android.server.connectivity.mdns.MdnsSocketClientBase;
+import com.android.server.connectivity.mdns.MdnsSocketProvider;
import java.io.FileDescriptor;
import java.io.PrintWriter;
@@ -58,7 +74,17 @@
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.StandardCharsets;
import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
/**
* Network Service Discovery Service handles remote service discovery operation requests by
@@ -69,8 +95,22 @@
public class NsdService extends INsdManager.Stub {
private static final String TAG = "NsdService";
private static final String MDNS_TAG = "mDnsConnector";
+ /**
+ * Enable discovery using the Java DiscoveryManager, instead of the legacy mdnsresponder
+ * implementation.
+ */
+ private static final String MDNS_DISCOVERY_MANAGER_VERSION = "mdns_discovery_manager_version";
+ private static final String LOCAL_DOMAIN_NAME = "local";
+ // Max label length as per RFC 1034/1035
+ private static final int MAX_LABEL_LENGTH = 63;
- private static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
+ /**
+ * Enable advertising using the Java MdnsAdvertiser, instead of the legacy mdnsresponder
+ * implementation.
+ */
+ private static final String MDNS_ADVERTISER_VERSION = "mdns_advertiser_version";
+
+ public static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
private static final long CLEANUP_DELAY_MS = 10000;
private static final int IFACE_IDX_ANY = 0;
@@ -78,10 +118,19 @@
private final NsdStateMachine mNsdStateMachine;
private final MDnsManager mMDnsManager;
private final MDnsEventCallback mMDnsEventCallback;
- // WARNING : Accessing this value in any thread is not safe, it must only be changed in the
+ @Nullable
+ private final MdnsMultinetworkSocketClient mMdnsSocketClient;
+ @Nullable
+ private final MdnsDiscoveryManager mMdnsDiscoveryManager;
+ @Nullable
+ private final MdnsSocketProvider mMdnsSocketProvider;
+ @Nullable
+ private final MdnsAdvertiser mAdvertiser;
+ // WARNING : Accessing these values in any thread is not safe, it must only be changed in the
// state machine thread. If change this outside state machine, it will need to introduce
// synchronization.
private boolean mIsDaemonStarted = false;
+ private boolean mIsMonitoringSocketsStarted = false;
/**
* Clients receiving asynchronous messages
@@ -98,6 +147,110 @@
// The count of the connected legacy clients.
private int mLegacyClientCount = 0;
+ private static class MdnsListener implements MdnsServiceBrowserListener {
+ protected final int mClientId;
+ protected final int mTransactionId;
+ @NonNull
+ protected final NsdServiceInfo mReqServiceInfo;
+ @NonNull
+ protected final String mListenedServiceType;
+
+ MdnsListener(int clientId, int transactionId, @NonNull NsdServiceInfo reqServiceInfo,
+ @NonNull String listenedServiceType) {
+ mClientId = clientId;
+ mTransactionId = transactionId;
+ mReqServiceInfo = reqServiceInfo;
+ mListenedServiceType = listenedServiceType;
+ }
+
+ @NonNull
+ public String getListenedServiceType() {
+ return mListenedServiceType;
+ }
+
+ @Override
+ public void onServiceFound(@NonNull MdnsServiceInfo serviceInfo) { }
+
+ @Override
+ public void onServiceUpdated(@NonNull MdnsServiceInfo serviceInfo) { }
+
+ @Override
+ public void onServiceRemoved(@NonNull MdnsServiceInfo serviceInfo) { }
+
+ @Override
+ public void onServiceNameDiscovered(@NonNull MdnsServiceInfo serviceInfo) { }
+
+ @Override
+ public void onServiceNameRemoved(@NonNull MdnsServiceInfo serviceInfo) { }
+
+ @Override
+ public void onSearchStoppedWithError(int error) { }
+
+ @Override
+ public void onSearchFailedToStart() { }
+
+ @Override
+ public void onDiscoveryQuerySent(@NonNull List<String> subtypes, int transactionId) { }
+
+ @Override
+ public void onFailedToParseMdnsResponse(int receivedPacketNumber, int errorCode) { }
+ }
+
+ private class DiscoveryListener extends MdnsListener {
+
+ DiscoveryListener(int clientId, int transactionId, @NonNull NsdServiceInfo reqServiceInfo,
+ @NonNull String listenServiceType) {
+ super(clientId, transactionId, reqServiceInfo, listenServiceType);
+ }
+
+ @Override
+ public void onServiceNameDiscovered(@NonNull MdnsServiceInfo serviceInfo) {
+ mNsdStateMachine.sendMessage(MDNS_DISCOVERY_MANAGER_EVENT, mTransactionId,
+ NsdManager.SERVICE_FOUND,
+ new MdnsEvent(mClientId, mReqServiceInfo.getServiceType(), serviceInfo));
+ }
+
+ @Override
+ public void onServiceNameRemoved(@NonNull MdnsServiceInfo serviceInfo) {
+ mNsdStateMachine.sendMessage(MDNS_DISCOVERY_MANAGER_EVENT, mTransactionId,
+ NsdManager.SERVICE_LOST,
+ new MdnsEvent(mClientId, mReqServiceInfo.getServiceType(), serviceInfo));
+ }
+ }
+
+ private class ResolutionListener extends MdnsListener {
+
+ ResolutionListener(int clientId, int transactionId, @NonNull NsdServiceInfo reqServiceInfo,
+ @NonNull String listenServiceType) {
+ super(clientId, transactionId, reqServiceInfo, listenServiceType);
+ }
+
+ @Override
+ public void onServiceFound(MdnsServiceInfo serviceInfo) {
+ mNsdStateMachine.sendMessage(MDNS_DISCOVERY_MANAGER_EVENT, mTransactionId,
+ NsdManager.RESOLVE_SERVICE_SUCCEEDED,
+ new MdnsEvent(mClientId, mReqServiceInfo.getServiceType(), serviceInfo));
+ }
+ }
+
+ /**
+ * Data class of mdns service callback information.
+ */
+ private static class MdnsEvent {
+ final int mClientId;
+ @NonNull
+ final String mRequestedServiceType;
+ @NonNull
+ final MdnsServiceInfo mMdnsServiceInfo;
+
+ MdnsEvent(int clientId, @NonNull String requestedServiceType,
+ @NonNull MdnsServiceInfo mdnsServiceInfo) {
+ mClientId = clientId;
+ mRequestedServiceType = requestedServiceType;
+ mMdnsServiceInfo = mdnsServiceInfo;
+ }
+ }
+
private class NsdStateMachine extends StateMachine {
private final DefaultState mDefaultState = new DefaultState();
@@ -148,6 +301,31 @@
this.removeMessages(NsdManager.DAEMON_CLEANUP);
}
+ private void maybeStartMonitoringSockets() {
+ if (mIsMonitoringSocketsStarted) {
+ if (DBG) Log.d(TAG, "Socket monitoring is already started.");
+ return;
+ }
+
+ mMdnsSocketProvider.startMonitoringSockets();
+ mIsMonitoringSocketsStarted = true;
+ }
+
+ private void maybeStopMonitoringSockets() {
+ if (!mIsMonitoringSocketsStarted) {
+ if (DBG) Log.d(TAG, "Socket monitoring has not been started.");
+ return;
+ }
+ mMdnsSocketProvider.stopMonitoringSockets();
+ mIsMonitoringSocketsStarted = false;
+ }
+
+ private void maybeStopMonitoringSocketsIfNoActiveRequest() {
+ if (!isAnyRequestActive()) {
+ maybeStopMonitoringSockets();
+ }
+ }
+
NsdStateMachine(String name, Handler handler) {
super(name, handler);
addState(mDefaultState);
@@ -180,10 +358,13 @@
cInfo = mClients.remove(connector);
if (cInfo != null) {
cInfo.expungeAllRequests();
- if (cInfo.isLegacy()) {
+ if (cInfo.isPreSClient()) {
mLegacyClientCount -= 1;
}
}
+ if (mMdnsDiscoveryManager != null || mAdvertiser != null) {
+ maybeStopMonitoringSocketsIfNoActiveRequest();
+ }
maybeScheduleStop();
break;
case NsdManager.DISCOVER_SERVICES:
@@ -221,6 +402,20 @@
clientId, NsdManager.FAILURE_INTERNAL_ERROR);
}
break;
+ case NsdManager.STOP_RESOLUTION:
+ cInfo = getClientInfoForReply(msg);
+ if (cInfo != null) {
+ cInfo.onStopResolutionFailed(
+ clientId, NsdManager.FAILURE_OPERATION_NOT_RUNNING);
+ }
+ break;
+ case NsdManager.REGISTER_SERVICE_CALLBACK:
+ cInfo = getClientInfoForReply(msg);
+ if (cInfo != null) {
+ cInfo.onServiceInfoCallbackRegistrationFailed(
+ clientId, NsdManager.FAILURE_BAD_PARAMETERS);
+ }
+ break;
case NsdManager.DAEMON_CLEANUP:
maybeStopDaemon();
break;
@@ -230,7 +425,7 @@
cInfo = getClientInfoForReply(msg);
if (cInfo != null) {
cancelStop();
- cInfo.setLegacy();
+ cInfo.setPreSClient();
mLegacyClientCount += 1;
maybeStartDaemon();
}
@@ -262,26 +457,99 @@
}
private boolean requestLimitReached(ClientInfo clientInfo) {
- if (clientInfo.mClientIds.size() >= ClientInfo.MAX_LIMIT) {
+ if (clientInfo.mClientRequests.size() >= ClientInfo.MAX_LIMIT) {
if (DBG) Log.d(TAG, "Exceeded max outstanding requests " + clientInfo);
return true;
}
return false;
}
- private void storeRequestMap(int clientId, int globalId, ClientInfo clientInfo, int what) {
- clientInfo.mClientIds.put(clientId, globalId);
- clientInfo.mClientRequests.put(clientId, what);
+ private void storeLegacyRequestMap(int clientId, int globalId, ClientInfo clientInfo,
+ int what) {
+ clientInfo.mClientRequests.put(clientId, new LegacyClientRequest(globalId, what));
mIdToClientInfoMap.put(globalId, clientInfo);
// Remove the cleanup event because here comes a new request.
cancelStop();
}
+ private void storeAdvertiserRequestMap(int clientId, int globalId,
+ ClientInfo clientInfo) {
+ clientInfo.mClientRequests.put(clientId, new AdvertiserClientRequest(globalId));
+ mIdToClientInfoMap.put(globalId, clientInfo);
+ }
+
private void removeRequestMap(int clientId, int globalId, ClientInfo clientInfo) {
- clientInfo.mClientIds.delete(clientId);
- clientInfo.mClientRequests.delete(clientId);
+ final ClientRequest existing = clientInfo.mClientRequests.get(clientId);
+ if (existing == null) return;
+ clientInfo.mClientRequests.remove(clientId);
mIdToClientInfoMap.remove(globalId);
- maybeScheduleStop();
+
+ if (existing instanceof LegacyClientRequest) {
+ maybeScheduleStop();
+ } else {
+ maybeStopMonitoringSocketsIfNoActiveRequest();
+ }
+ }
+
+ private void storeDiscoveryManagerRequestMap(int clientId, int globalId,
+ MdnsListener listener, ClientInfo clientInfo) {
+ clientInfo.mClientRequests.put(clientId,
+ new DiscoveryManagerRequest(globalId, listener));
+ mIdToClientInfoMap.put(globalId, clientInfo);
+ }
+
+ private void clearRegisteredServiceInfo(ClientInfo clientInfo) {
+ clientInfo.mRegisteredService = null;
+ clientInfo.mClientIdForServiceUpdates = 0;
+ }
+
+ /**
+ * Check the given service type is valid and construct it to a service type
+ * which can use for discovery / resolution service.
+ *
+ * <p> The valid service type should be 2 labels, or 3 labels if the query is for a
+ * subtype (see RFC6763 7.1). Each label is up to 63 characters and must start with an
+ * underscore; they are alphanumerical characters or dashes or underscore, except the
+ * last one that is just alphanumerical. The last label must be _tcp or _udp.
+ *
+ * @param serviceType the request service type for discovery / resolution service
+ * @return constructed service type or null if the given service type is invalid.
+ */
+ @Nullable
+ private String constructServiceType(String serviceType) {
+ if (TextUtils.isEmpty(serviceType)) return null;
+
+ final Pattern serviceTypePattern = Pattern.compile(
+ "^(_[a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]\\.)?"
+ + "(_[a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]\\._(?:tcp|udp))$");
+ final Matcher matcher = serviceTypePattern.matcher(serviceType);
+ if (!matcher.matches()) return null;
+ return matcher.group(1) == null
+ ? serviceType
+ : matcher.group(1) + "_sub." + matcher.group(2);
+ }
+
+ /**
+ * Truncate a service name to up to 63 UTF-8 bytes.
+ *
+ * See RFC6763 4.1.1: service instance names are UTF-8 and up to 63 bytes. Truncating
+ * names used in registerService follows historical behavior (see mdnsresponder
+ * handle_regservice_request).
+ */
+ @NonNull
+ private String truncateServiceName(@NonNull String originalName) {
+ // UTF-8 is at most 4 bytes per character; return early in the common case where
+ // the name can't possibly be over the limit given its string length.
+ if (originalName.length() <= MAX_LABEL_LENGTH / 4) return originalName;
+
+ final Charset utf8 = StandardCharsets.UTF_8;
+ final CharsetEncoder encoder = utf8.newEncoder();
+ final ByteBuffer out = ByteBuffer.allocate(MAX_LABEL_LENGTH);
+ // encode will write as many characters as possible to the out buffer, and just
+ // return an overflow code if there were too many characters (no need to check the
+ // return code here, this method truncates the name on purpose).
+ encoder.encode(CharBuffer.wrap(originalName), out, true /* endOfInput */);
+ return new String(out.array(), 0, out.position(), utf8);
}
@Override
@@ -291,7 +559,7 @@
final int clientId = msg.arg2;
final ListenerArgs args;
switch (msg.what) {
- case NsdManager.DISCOVER_SERVICES:
+ case NsdManager.DISCOVER_SERVICES: {
if (DBG) Log.d(TAG, "Discover services");
args = (ListenerArgs) msg.obj;
clientInfo = mClients.get(args.connector);
@@ -309,22 +577,46 @@
break;
}
- maybeStartDaemon();
+ final NsdServiceInfo info = args.serviceInfo;
id = getUniqueId();
- if (discoverServices(id, args.serviceInfo)) {
- if (DBG) {
- Log.d(TAG, "Discover " + msg.arg2 + " " + id
- + args.serviceInfo.getServiceType());
+ if (mMdnsDiscoveryManager != null) {
+ final String serviceType = constructServiceType(info.getServiceType());
+ if (serviceType == null) {
+ clientInfo.onDiscoverServicesFailed(clientId,
+ NsdManager.FAILURE_INTERNAL_ERROR);
+ break;
}
- storeRequestMap(clientId, id, clientInfo, msg.what);
- clientInfo.onDiscoverServicesStarted(clientId, args.serviceInfo);
+
+ final String listenServiceType = serviceType + ".local";
+ maybeStartMonitoringSockets();
+ final MdnsListener listener =
+ new DiscoveryListener(clientId, id, info, listenServiceType);
+ final MdnsSearchOptions options = MdnsSearchOptions.newBuilder()
+ .setNetwork(info.getNetwork())
+ .setIsPassiveMode(true)
+ .build();
+ mMdnsDiscoveryManager.registerListener(
+ listenServiceType, listener, options);
+ storeDiscoveryManagerRequestMap(clientId, id, listener, clientInfo);
+ clientInfo.onDiscoverServicesStarted(clientId, info);
} else {
- stopServiceDiscovery(id);
- clientInfo.onDiscoverServicesFailed(clientId,
- NsdManager.FAILURE_INTERNAL_ERROR);
+ maybeStartDaemon();
+ if (discoverServices(id, info)) {
+ if (DBG) {
+ Log.d(TAG, "Discover " + msg.arg2 + " " + id
+ + info.getServiceType());
+ }
+ storeLegacyRequestMap(clientId, id, clientInfo, msg.what);
+ clientInfo.onDiscoverServicesStarted(clientId, info);
+ } else {
+ stopServiceDiscovery(id);
+ clientInfo.onDiscoverServicesFailed(clientId,
+ NsdManager.FAILURE_INTERNAL_ERROR);
+ }
}
break;
- case NsdManager.STOP_DISCOVERY:
+ }
+ case NsdManager.STOP_DISCOVERY: {
if (DBG) Log.d(TAG, "Stop service discovery");
args = (ListenerArgs) msg.obj;
clientInfo = mClients.get(args.connector);
@@ -336,22 +628,31 @@
break;
}
- try {
- id = clientInfo.mClientIds.get(clientId);
- } catch (NullPointerException e) {
- clientInfo.onStopDiscoveryFailed(
- clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ final ClientRequest request = clientInfo.mClientRequests.get(clientId);
+ if (request == null) {
+ Log.e(TAG, "Unknown client request in STOP_DISCOVERY");
break;
}
- removeRequestMap(clientId, id, clientInfo);
- if (stopServiceDiscovery(id)) {
+ id = request.mGlobalId;
+ if (request instanceof DiscoveryManagerRequest) {
+ final MdnsListener listener =
+ ((DiscoveryManagerRequest) request).mListener;
+ mMdnsDiscoveryManager.unregisterListener(
+ listener.getListenedServiceType(), listener);
+ removeRequestMap(clientId, id, clientInfo);
clientInfo.onStopDiscoverySucceeded(clientId);
} else {
- clientInfo.onStopDiscoveryFailed(
- clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ removeRequestMap(clientId, id, clientInfo);
+ if (stopServiceDiscovery(id)) {
+ clientInfo.onStopDiscoverySucceeded(clientId);
+ } else {
+ clientInfo.onStopDiscoveryFailed(
+ clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ }
}
break;
- case NsdManager.REGISTER_SERVICE:
+ }
+ case NsdManager.REGISTER_SERVICE: {
if (DBG) Log.d(TAG, "Register service");
args = (ListenerArgs) msg.obj;
clientInfo = mClients.get(args.connector);
@@ -369,19 +670,40 @@
break;
}
- maybeStartDaemon();
id = getUniqueId();
- if (registerService(id, args.serviceInfo)) {
- if (DBG) Log.d(TAG, "Register " + clientId + " " + id);
- storeRequestMap(clientId, id, clientInfo, msg.what);
- // Return success after mDns reports success
+ if (mAdvertiser != null) {
+ final NsdServiceInfo serviceInfo = args.serviceInfo;
+ final String serviceType = serviceInfo.getServiceType();
+ final String registerServiceType = constructServiceType(serviceType);
+ if (registerServiceType == null) {
+ Log.e(TAG, "Invalid service type: " + serviceType);
+ clientInfo.onRegisterServiceFailed(clientId,
+ NsdManager.FAILURE_INTERNAL_ERROR);
+ break;
+ }
+ serviceInfo.setServiceType(registerServiceType);
+ serviceInfo.setServiceName(truncateServiceName(
+ serviceInfo.getServiceName()));
+
+ maybeStartMonitoringSockets();
+ mAdvertiser.addService(id, serviceInfo);
+ storeAdvertiserRequestMap(clientId, id, clientInfo);
} else {
- unregisterService(id);
- clientInfo.onRegisterServiceFailed(
- clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ maybeStartDaemon();
+ if (registerService(id, args.serviceInfo)) {
+ if (DBG) Log.d(TAG, "Register " + clientId + " " + id);
+ storeLegacyRequestMap(clientId, id, clientInfo, msg.what);
+ // Return success after mDns reports success
+ } else {
+ unregisterService(id);
+ clientInfo.onRegisterServiceFailed(
+ clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ }
+
}
break;
- case NsdManager.UNREGISTER_SERVICE:
+ }
+ case NsdManager.UNREGISTER_SERVICE: {
if (DBG) Log.d(TAG, "unregister service");
args = (ListenerArgs) msg.obj;
clientInfo = mClients.get(args.connector);
@@ -392,16 +714,28 @@
Log.e(TAG, "Unknown connector in unregistration");
break;
}
- id = clientInfo.mClientIds.get(clientId);
+ final ClientRequest request = clientInfo.mClientRequests.get(clientId);
+ if (request == null) {
+ Log.e(TAG, "Unknown client request in UNREGISTER_SERVICE");
+ break;
+ }
+ id = request.mGlobalId;
removeRequestMap(clientId, id, clientInfo);
- if (unregisterService(id)) {
+
+ if (mAdvertiser != null) {
+ mAdvertiser.removeService(id);
clientInfo.onUnregisterServiceSucceeded(clientId);
} else {
- clientInfo.onUnregisterServiceFailed(
- clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ if (unregisterService(id)) {
+ clientInfo.onUnregisterServiceSucceeded(clientId);
+ } else {
+ clientInfo.onUnregisterServiceFailed(
+ clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ }
}
break;
- case NsdManager.RESOLVE_SERVICE:
+ }
+ case NsdManager.RESOLVE_SERVICE: {
if (DBG) Log.d(TAG, "Resolve service");
args = (ListenerArgs) msg.obj;
clientInfo = mClients.get(args.connector);
@@ -413,8 +747,88 @@
break;
}
- if (clientInfo.mResolvedService != null) {
- clientInfo.onResolveServiceFailed(
+ final NsdServiceInfo info = args.serviceInfo;
+ id = getUniqueId();
+ if (mMdnsDiscoveryManager != null) {
+ final String serviceType = constructServiceType(info.getServiceType());
+ if (serviceType == null) {
+ clientInfo.onResolveServiceFailed(clientId,
+ NsdManager.FAILURE_INTERNAL_ERROR);
+ break;
+ }
+ final String resolveServiceType = serviceType + ".local";
+
+ maybeStartMonitoringSockets();
+ final MdnsListener listener =
+ new ResolutionListener(clientId, id, info, resolveServiceType);
+ final MdnsSearchOptions options = MdnsSearchOptions.newBuilder()
+ .setNetwork(info.getNetwork())
+ .setIsPassiveMode(true)
+ .build();
+ mMdnsDiscoveryManager.registerListener(
+ resolveServiceType, listener, options);
+ storeDiscoveryManagerRequestMap(clientId, id, listener, clientInfo);
+ } else {
+ if (clientInfo.mResolvedService != null) {
+ clientInfo.onResolveServiceFailed(
+ clientId, NsdManager.FAILURE_ALREADY_ACTIVE);
+ break;
+ }
+
+ maybeStartDaemon();
+ if (resolveService(id, args.serviceInfo)) {
+ clientInfo.mResolvedService = new NsdServiceInfo();
+ storeLegacyRequestMap(clientId, id, clientInfo, msg.what);
+ } else {
+ clientInfo.onResolveServiceFailed(
+ clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ }
+ }
+ break;
+ }
+ case NsdManager.STOP_RESOLUTION: {
+ if (DBG) Log.d(TAG, "Stop service resolution");
+ args = (ListenerArgs) msg.obj;
+ clientInfo = mClients.get(args.connector);
+ // If the binder death notification for a INsdManagerCallback was received
+ // before any calls are received by NsdService, the clientInfo would be
+ // cleared and cause NPE. Add a null check here to prevent this corner case.
+ if (clientInfo == null) {
+ Log.e(TAG, "Unknown connector in stop resolution");
+ break;
+ }
+
+ final ClientRequest request = clientInfo.mClientRequests.get(clientId);
+ if (request == null) {
+ Log.e(TAG, "Unknown client request in STOP_RESOLUTION");
+ break;
+ }
+ id = request.mGlobalId;
+ removeRequestMap(clientId, id, clientInfo);
+ if (stopResolveService(id)) {
+ clientInfo.onStopResolutionSucceeded(clientId);
+ } else {
+ clientInfo.onStopResolutionFailed(
+ clientId, NsdManager.FAILURE_OPERATION_NOT_RUNNING);
+ }
+ clientInfo.mResolvedService = null;
+ // TODO: Implement the stop resolution with MdnsDiscoveryManager.
+ break;
+ }
+ case NsdManager.REGISTER_SERVICE_CALLBACK:
+ if (DBG) Log.d(TAG, "Register a service callback");
+ args = (ListenerArgs) msg.obj;
+ clientInfo = mClients.get(args.connector);
+ // If the binder death notification for a INsdManagerCallback was received
+ // before any calls are received by NsdService, the clientInfo would be
+ // cleared and cause NPE. Add a null check here to prevent this corner case.
+ if (clientInfo == null) {
+ Log.e(TAG, "Unknown connector in callback registration");
+ break;
+ }
+
+ if (clientInfo.mRegisteredService != null) {
+ clientInfo.onServiceInfoCallbackRegistrationFailed(
clientId, NsdManager.FAILURE_ALREADY_ACTIVE);
break;
}
@@ -422,24 +836,70 @@
maybeStartDaemon();
id = getUniqueId();
if (resolveService(id, args.serviceInfo)) {
- clientInfo.mResolvedService = new NsdServiceInfo();
- storeRequestMap(clientId, id, clientInfo, msg.what);
+ clientInfo.mRegisteredService = new NsdServiceInfo();
+ clientInfo.mClientIdForServiceUpdates = clientId;
+ storeLegacyRequestMap(clientId, id, clientInfo, msg.what);
} else {
- clientInfo.onResolveServiceFailed(
- clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ clientInfo.onServiceInfoCallbackRegistrationFailed(
+ clientId, NsdManager.FAILURE_BAD_PARAMETERS);
}
break;
+ case NsdManager.UNREGISTER_SERVICE_CALLBACK: {
+ if (DBG) Log.d(TAG, "Unregister a service callback");
+ args = (ListenerArgs) msg.obj;
+ clientInfo = mClients.get(args.connector);
+ // If the binder death notification for a INsdManagerCallback was received
+ // before any calls are received by NsdService, the clientInfo would be
+ // cleared and cause NPE. Add a null check here to prevent this corner case.
+ if (clientInfo == null) {
+ Log.e(TAG, "Unknown connector in callback unregistration");
+ break;
+ }
+
+ final ClientRequest request = clientInfo.mClientRequests.get(clientId);
+ if (request == null) {
+ Log.e(TAG, "Unknown client request in STOP_RESOLUTION");
+ break;
+ }
+ id = request.mGlobalId;
+ removeRequestMap(clientId, id, clientInfo);
+ if (stopResolveService(id)) {
+ clientInfo.onServiceInfoCallbackUnregistered(clientId);
+ } else {
+ Log.e(TAG, "Failed to unregister service info callback");
+ }
+ clearRegisteredServiceInfo(clientInfo);
+ break;
+ }
case MDNS_SERVICE_EVENT:
if (!handleMDnsServiceEvent(msg.arg1, msg.arg2, msg.obj)) {
return NOT_HANDLED;
}
break;
+ case MDNS_DISCOVERY_MANAGER_EVENT:
+ if (!handleMdnsDiscoveryManagerEvent(msg.arg1, msg.arg2, msg.obj)) {
+ return NOT_HANDLED;
+ }
+ break;
default:
return NOT_HANDLED;
}
return HANDLED;
}
+ private void notifyResolveFailedResult(boolean isListenedToUpdates, int clientId,
+ ClientInfo clientInfo, int error) {
+ if (isListenedToUpdates) {
+ clientInfo.onServiceInfoCallbackRegistrationFailed(clientId, error);
+ clearRegisteredServiceInfo(clientInfo);
+ } else {
+ // The resolve API always returned FAILURE_INTERNAL_ERROR on error; keep it
+ // for backwards compatibility.
+ clientInfo.onResolveServiceFailed(clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ clientInfo.mResolvedService = null;
+ }
+ }
+
private boolean handleMDnsServiceEvent(int code, int id, Object obj) {
NsdServiceInfo servInfo;
ClientInfo clientInfo = mIdToClientInfoMap.get(id);
@@ -474,6 +934,12 @@
// interfaces that do not have an associated Network.
break;
}
+ if (foundNetId == INetd.DUMMY_NET_ID) {
+ // Ignore services on the dummy0 interface: they are only seen when
+ // discovering locally advertised services, and are not reachable
+ // through that interface.
+ break;
+ }
setServiceNetworkForCallback(servInfo, info.netId, info.interfaceIdx);
clientInfo.onServiceFound(clientId, servInfo);
break;
@@ -490,6 +956,8 @@
// found services on the same interface index and their network at the time
setServiceNetworkForCallback(servInfo, lostNetId, info.interfaceIdx);
clientInfo.onServiceLost(clientId, servInfo);
+ // TODO: also support registered service lost when not discovering
+ clientInfo.maybeNotifyRegisteredServiceLost(servInfo);
break;
}
case IMDnsEventListener.SERVICE_DISCOVERY_FAILED:
@@ -526,10 +994,15 @@
String rest = fullName.substring(index);
String type = rest.replace(".local.", "");
- clientInfo.mResolvedService.setServiceName(name);
- clientInfo.mResolvedService.setServiceType(type);
- clientInfo.mResolvedService.setPort(info.port);
- clientInfo.mResolvedService.setTxtRecords(info.txtRecord);
+ final boolean isListenedToUpdates =
+ clientId == clientInfo.mClientIdForServiceUpdates;
+ final NsdServiceInfo serviceInfo = isListenedToUpdates
+ ? clientInfo.mRegisteredService : clientInfo.mResolvedService;
+
+ serviceInfo.setServiceName(name);
+ serviceInfo.setServiceType(type);
+ serviceInfo.setPort(info.port);
+ serviceInfo.setTxtRecords(info.txtRecord);
// Network will be added after SERVICE_GET_ADDR_SUCCESS
stopResolveService(id);
@@ -537,11 +1010,11 @@
final int id2 = getUniqueId();
if (getAddrInfo(id2, info.hostname, info.interfaceIdx)) {
- storeRequestMap(clientId, id2, clientInfo, NsdManager.RESOLVE_SERVICE);
+ storeLegacyRequestMap(clientId, id2, clientInfo,
+ NsdManager.RESOLVE_SERVICE);
} else {
- clientInfo.onResolveServiceFailed(
- clientId, NsdManager.FAILURE_INTERNAL_ERROR);
- clientInfo.mResolvedService = null;
+ notifyResolveFailedResult(isListenedToUpdates, clientId, clientInfo,
+ NsdManager.FAILURE_BAD_PARAMETERS);
}
break;
}
@@ -549,17 +1022,17 @@
/* NNN resolveId errorCode */
stopResolveService(id);
removeRequestMap(clientId, id, clientInfo);
- clientInfo.mResolvedService = null;
- clientInfo.onResolveServiceFailed(
- clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ notifyResolveFailedResult(
+ clientId == clientInfo.mClientIdForServiceUpdates,
+ clientId, clientInfo, NsdManager.FAILURE_BAD_PARAMETERS);
break;
case IMDnsEventListener.SERVICE_GET_ADDR_FAILED:
/* NNN resolveId errorCode */
stopGetAddrInfo(id);
removeRequestMap(clientId, id, clientInfo);
- clientInfo.mResolvedService = null;
- clientInfo.onResolveServiceFailed(
- clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ notifyResolveFailedResult(
+ clientId == clientInfo.mClientIdForServiceUpdates,
+ clientId, clientInfo, NsdManager.FAILURE_BAD_PARAMETERS);
break;
case IMDnsEventListener.SERVICE_GET_ADDR_SUCCESS: {
/* NNN resolveId hostname ttl addr interfaceIdx netId */
@@ -576,19 +1049,126 @@
// If the resolved service is on an interface without a network, consider it
// as a failure: it would not be usable by apps as they would need
// privileged permissions.
- if (netId != NETID_UNSET && serviceHost != null) {
- clientInfo.mResolvedService.setHost(serviceHost);
- setServiceNetworkForCallback(clientInfo.mResolvedService,
- netId, info.interfaceIdx);
- clientInfo.onResolveServiceSucceeded(
- clientId, clientInfo.mResolvedService);
+ if (clientId == clientInfo.mClientIdForServiceUpdates) {
+ if (netId != NETID_UNSET && serviceHost != null) {
+ setServiceNetworkForCallback(clientInfo.mRegisteredService,
+ netId, info.interfaceIdx);
+ final List<InetAddress> addresses =
+ clientInfo.mRegisteredService.getHostAddresses();
+ addresses.add(serviceHost);
+ clientInfo.mRegisteredService.setHostAddresses(addresses);
+ clientInfo.onServiceUpdated(
+ clientId, clientInfo.mRegisteredService);
+ } else {
+ stopGetAddrInfo(id);
+ removeRequestMap(clientId, id, clientInfo);
+ clearRegisteredServiceInfo(clientInfo);
+ clientInfo.onServiceInfoCallbackRegistrationFailed(
+ clientId, NsdManager.FAILURE_BAD_PARAMETERS);
+ }
} else {
+ if (netId != NETID_UNSET && serviceHost != null) {
+ clientInfo.mResolvedService.setHost(serviceHost);
+ setServiceNetworkForCallback(clientInfo.mResolvedService,
+ netId, info.interfaceIdx);
+ clientInfo.onResolveServiceSucceeded(
+ clientId, clientInfo.mResolvedService);
+ } else {
+ clientInfo.onResolveServiceFailed(
+ clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ }
+ stopGetAddrInfo(id);
+ removeRequestMap(clientId, id, clientInfo);
+ clientInfo.mResolvedService = null;
+ }
+ break;
+ }
+ default:
+ return false;
+ }
+ return true;
+ }
+
+ private NsdServiceInfo buildNsdServiceInfoFromMdnsEvent(final MdnsEvent event) {
+ final MdnsServiceInfo serviceInfo = event.mMdnsServiceInfo;
+ final String serviceType = event.mRequestedServiceType;
+ final String serviceName = serviceInfo.getServiceInstanceName();
+ final NsdServiceInfo servInfo = new NsdServiceInfo(serviceName, serviceType);
+ final Network network = serviceInfo.getNetwork();
+ setServiceNetworkForCallback(
+ servInfo,
+ network == null ? NETID_UNSET : network.netId,
+ serviceInfo.getInterfaceIndex());
+ return servInfo;
+ }
+
+ private boolean handleMdnsDiscoveryManagerEvent(
+ int transactionId, int code, Object obj) {
+ final ClientInfo clientInfo = mIdToClientInfoMap.get(transactionId);
+ if (clientInfo == null) {
+ Log.e(TAG, String.format(
+ "id %d for %d has no client mapping", transactionId, code));
+ return false;
+ }
+
+ final MdnsEvent event = (MdnsEvent) obj;
+ final int clientId = event.mClientId;
+ final NsdServiceInfo info = buildNsdServiceInfoFromMdnsEvent(event);
+ if (DBG) {
+ Log.d(TAG, String.format("MdnsDiscoveryManager event code=%s transactionId=%d",
+ NsdManager.nameOf(code), transactionId));
+ }
+ switch (code) {
+ case NsdManager.SERVICE_FOUND:
+ clientInfo.onServiceFound(clientId, info);
+ break;
+ case NsdManager.SERVICE_LOST:
+ clientInfo.onServiceLost(clientId, info);
+ break;
+ case NsdManager.RESOLVE_SERVICE_SUCCEEDED: {
+ final ClientRequest request = clientInfo.mClientRequests.get(clientId);
+ if (request == null) {
+ Log.e(TAG, "Unknown client request in RESOLVE_SERVICE_SUCCEEDED");
+ break;
+ }
+ final MdnsServiceInfo serviceInfo = event.mMdnsServiceInfo;
+ // Add '.' in front of the service type that aligns with historical behavior
+ info.setServiceType("." + event.mRequestedServiceType);
+ info.setPort(serviceInfo.getPort());
+
+ Map<String, String> attrs = serviceInfo.getAttributes();
+ for (Map.Entry<String, String> kv : attrs.entrySet()) {
+ final String key = kv.getKey();
+ try {
+ info.setAttribute(key, serviceInfo.getAttributeAsBytes(key));
+ } catch (IllegalArgumentException e) {
+ Log.e(TAG, "Invalid attribute", e);
+ }
+ }
+ try {
+ if (serviceInfo.getIpv4Address() != null) {
+ info.setHost(InetAddresses.parseNumericAddress(
+ serviceInfo.getIpv4Address()));
+ } else {
+ info.setHost(InetAddresses.parseNumericAddress(
+ serviceInfo.getIpv6Address()));
+ }
+ clientInfo.onResolveServiceSucceeded(clientId, info);
+ } catch (IllegalArgumentException e) {
+ Log.wtf(TAG, "Invalid address in RESOLVE_SERVICE_SUCCEEDED", e);
clientInfo.onResolveServiceFailed(
clientId, NsdManager.FAILURE_INTERNAL_ERROR);
}
- stopGetAddrInfo(id);
- removeRequestMap(clientId, id, clientInfo);
- clientInfo.mResolvedService = null;
+
+ // Unregister the listener immediately like IMDnsEventListener design
+ if (!(request instanceof DiscoveryManagerRequest)) {
+ Log.wtf(TAG, "non-DiscoveryManager request in DiscoveryManager event");
+ break;
+ }
+ final MdnsListener listener = ((DiscoveryManagerRequest) request).mListener;
+ mMdnsDiscoveryManager.unregisterListener(
+ listener.getListenedServiceType(), listener);
+ removeRequestMap(clientId, transactionId, clientInfo);
break;
}
default:
@@ -650,12 +1230,95 @@
@VisibleForTesting
NsdService(Context ctx, Handler handler, long cleanupDelayMs) {
+ this(ctx, handler, cleanupDelayMs, new Dependencies());
+ }
+
+ @VisibleForTesting
+ NsdService(Context ctx, Handler handler, long cleanupDelayMs, Dependencies deps) {
mCleanupDelayMs = cleanupDelayMs;
mContext = ctx;
mNsdStateMachine = new NsdStateMachine(TAG, handler);
mNsdStateMachine.start();
mMDnsManager = ctx.getSystemService(MDnsManager.class);
mMDnsEventCallback = new MDnsEventCallback(mNsdStateMachine);
+
+ final boolean discoveryManagerEnabled = deps.isMdnsDiscoveryManagerEnabled(ctx);
+ final boolean advertiserEnabled = deps.isMdnsAdvertiserEnabled(ctx);
+ if (discoveryManagerEnabled || advertiserEnabled) {
+ mMdnsSocketProvider = deps.makeMdnsSocketProvider(ctx, handler.getLooper());
+ } else {
+ mMdnsSocketProvider = null;
+ }
+
+ if (discoveryManagerEnabled) {
+ mMdnsSocketClient =
+ new MdnsMultinetworkSocketClient(handler.getLooper(), mMdnsSocketProvider);
+ mMdnsDiscoveryManager =
+ deps.makeMdnsDiscoveryManager(new ExecutorProvider(), mMdnsSocketClient);
+ handler.post(() -> mMdnsSocketClient.setCallback(mMdnsDiscoveryManager));
+ } else {
+ mMdnsSocketClient = null;
+ mMdnsDiscoveryManager = null;
+ }
+
+ if (advertiserEnabled) {
+ mAdvertiser = deps.makeMdnsAdvertiser(handler.getLooper(), mMdnsSocketProvider,
+ new AdvertiserCallback());
+ } else {
+ mAdvertiser = null;
+ }
+ }
+
+ /**
+ * Dependencies of NsdService, for injection in tests.
+ */
+ @VisibleForTesting
+ public static class Dependencies {
+ /**
+ * Check whether the MdnsDiscoveryManager feature is enabled.
+ *
+ * @param context The global context information about an app environment.
+ * @return true if the MdnsDiscoveryManager feature is enabled.
+ */
+ public boolean isMdnsDiscoveryManagerEnabled(Context context) {
+ return DeviceConfigUtils.isFeatureEnabled(context, NAMESPACE_CONNECTIVITY,
+ MDNS_DISCOVERY_MANAGER_VERSION, false /* defaultEnabled */);
+ }
+
+ /**
+ * Check whether the MdnsAdvertiser feature is enabled.
+ *
+ * @param context The global context information about an app environment.
+ * @return true if the MdnsAdvertiser feature is enabled.
+ */
+ public boolean isMdnsAdvertiserEnabled(Context context) {
+ return DeviceConfigUtils.isFeatureEnabled(context, NAMESPACE_CONNECTIVITY,
+ MDNS_ADVERTISER_VERSION, false /* defaultEnabled */);
+ }
+
+ /**
+ * @see MdnsDiscoveryManager
+ */
+ public MdnsDiscoveryManager makeMdnsDiscoveryManager(
+ ExecutorProvider executorProvider, MdnsSocketClientBase socketClient) {
+ return new MdnsDiscoveryManager(executorProvider, socketClient);
+ }
+
+ /**
+ * @see MdnsAdvertiser
+ */
+ public MdnsAdvertiser makeMdnsAdvertiser(
+ @NonNull Looper looper, @NonNull MdnsSocketProvider socketProvider,
+ @NonNull MdnsAdvertiser.AdvertiserCallback cb) {
+ return new MdnsAdvertiser(looper, socketProvider, cb);
+ }
+
+ /**
+ * @see MdnsSocketProvider
+ */
+ public MdnsSocketProvider makeMdnsSocketProvider(Context context, Looper looper) {
+ return new MdnsSocketProvider(context, looper);
+ }
}
public static NsdService create(Context context) {
@@ -708,6 +1371,49 @@
}
}
+ private class AdvertiserCallback implements MdnsAdvertiser.AdvertiserCallback {
+ @Override
+ public void onRegisterServiceSucceeded(int serviceId, NsdServiceInfo registeredInfo) {
+ final ClientInfo clientInfo = getClientInfoOrLog(serviceId);
+ if (clientInfo == null) return;
+
+ final int clientId = getClientIdOrLog(clientInfo, serviceId);
+ if (clientId < 0) return;
+
+ // onRegisterServiceSucceeded only has the service name in its info. This aligns with
+ // historical behavior.
+ final NsdServiceInfo cbInfo = new NsdServiceInfo(registeredInfo.getServiceName(), null);
+ clientInfo.onRegisterServiceSucceeded(clientId, cbInfo);
+ }
+
+ @Override
+ public void onRegisterServiceFailed(int serviceId, int errorCode) {
+ final ClientInfo clientInfo = getClientInfoOrLog(serviceId);
+ if (clientInfo == null) return;
+
+ final int clientId = getClientIdOrLog(clientInfo, serviceId);
+ if (clientId < 0) return;
+
+ clientInfo.onRegisterServiceFailed(clientId, errorCode);
+ }
+
+ private ClientInfo getClientInfoOrLog(int serviceId) {
+ final ClientInfo clientInfo = mIdToClientInfoMap.get(serviceId);
+ if (clientInfo == null) {
+ Log.e(TAG, String.format("Callback for service %d has no client", serviceId));
+ }
+ return clientInfo;
+ }
+
+ private int getClientIdOrLog(@NonNull ClientInfo info, int serviceId) {
+ final int clientId = info.getClientId(serviceId);
+ if (clientId < 0) {
+ Log.e(TAG, String.format("Client ID not found for service %d", serviceId));
+ }
+ return clientId;
+ }
+ }
+
@Override
public INsdServiceConnector connect(INsdManagerCallback cb) {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.INTERNET, "NsdService");
@@ -763,6 +1469,26 @@
}
@Override
+ public void stopResolution(int listenerKey) {
+ mNsdStateMachine.sendMessage(mNsdStateMachine.obtainMessage(
+ NsdManager.STOP_RESOLUTION, 0, listenerKey, new ListenerArgs(this, null)));
+ }
+
+ @Override
+ public void registerServiceInfoCallback(int listenerKey, NsdServiceInfo serviceInfo) {
+ mNsdStateMachine.sendMessage(mNsdStateMachine.obtainMessage(
+ NsdManager.REGISTER_SERVICE_CALLBACK, 0, listenerKey,
+ new ListenerArgs(this, serviceInfo)));
+ }
+
+ @Override
+ public void unregisterServiceInfoCallback(int listenerKey) {
+ mNsdStateMachine.sendMessage(mNsdStateMachine.obtainMessage(
+ NsdManager.UNREGISTER_SERVICE_CALLBACK, 0, listenerKey,
+ new ListenerArgs(this, null)));
+ }
+
+ @Override
public void startDaemon() {
mNsdStateMachine.sendMessage(mNsdStateMachine.obtainMessage(
NsdManager.DAEMON_STARTUP, new ListenerArgs(this, null)));
@@ -903,6 +1629,39 @@
mNsdStateMachine.dump(fd, pw, args);
}
+ private abstract static class ClientRequest {
+ private final int mGlobalId;
+
+ private ClientRequest(int globalId) {
+ mGlobalId = globalId;
+ }
+ }
+
+ private static class LegacyClientRequest extends ClientRequest {
+ private final int mRequestCode;
+
+ private LegacyClientRequest(int globalId, int requestCode) {
+ super(globalId);
+ mRequestCode = requestCode;
+ }
+ }
+
+ private static class AdvertiserClientRequest extends ClientRequest {
+ private AdvertiserClientRequest(int globalId) {
+ super(globalId);
+ }
+ }
+
+ private static class DiscoveryManagerRequest extends ClientRequest {
+ @NonNull
+ private final MdnsListener mListener;
+
+ private DiscoveryManagerRequest(int globalId, @NonNull MdnsListener listener) {
+ super(globalId);
+ mListener = listener;
+ }
+ }
+
/* Information tracked per client */
private class ClientInfo {
@@ -911,14 +1670,16 @@
/* Remembers a resolved service until getaddrinfo completes */
private NsdServiceInfo mResolvedService;
- /* A map from client id to unique id sent to mDns */
- private final SparseIntArray mClientIds = new SparseIntArray();
-
- /* A map from client id to the type of the request we had received */
- private final SparseIntArray mClientRequests = new SparseIntArray();
+ /* A map from client-side ID (listenerKey) to the request */
+ private final SparseArray<ClientRequest> mClientRequests = new SparseArray<>();
// The target SDK of this client < Build.VERSION_CODES.S
- private boolean mIsLegacy = false;
+ private boolean mIsPreSClient = false;
+
+ /*** The service that is registered to listen to its updates */
+ private NsdServiceInfo mRegisteredService;
+ /*** The client id that listen to updates */
+ private int mClientIdForServiceUpdates;
private ClientInfo(INsdManagerCallback cb) {
mCb = cb;
@@ -929,38 +1690,59 @@
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("mResolvedService ").append(mResolvedService).append("\n");
- sb.append("mIsLegacy ").append(mIsLegacy).append("\n");
- for(int i = 0; i< mClientIds.size(); i++) {
- int clientID = mClientIds.keyAt(i);
- sb.append("clientId ").append(clientID).
- append(" mDnsId ").append(mClientIds.valueAt(i)).
- append(" type ").append(mClientRequests.get(clientID)).append("\n");
+ sb.append("mIsLegacy ").append(mIsPreSClient).append("\n");
+ for (int i = 0; i < mClientRequests.size(); i++) {
+ int clientID = mClientRequests.keyAt(i);
+ sb.append("clientId ")
+ .append(clientID)
+ .append(" mDnsId ").append(mClientRequests.valueAt(i).mGlobalId)
+ .append(" type ").append(
+ mClientRequests.valueAt(i).getClass().getSimpleName())
+ .append("\n");
}
return sb.toString();
}
- private boolean isLegacy() {
- return mIsLegacy;
+ private boolean isPreSClient() {
+ return mIsPreSClient;
}
- private void setLegacy() {
- mIsLegacy = true;
+ private void setPreSClient() {
+ mIsPreSClient = true;
}
// Remove any pending requests from the global map when we get rid of a client,
// and send cancellations to the daemon.
private void expungeAllRequests() {
- int globalId, clientId, i;
// TODO: to keep handler responsive, do not clean all requests for that client at once.
- for (i = 0; i < mClientIds.size(); i++) {
- clientId = mClientIds.keyAt(i);
- globalId = mClientIds.valueAt(i);
+ for (int i = 0; i < mClientRequests.size(); i++) {
+ final int clientId = mClientRequests.keyAt(i);
+ final ClientRequest request = mClientRequests.valueAt(i);
+ final int globalId = request.mGlobalId;
mIdToClientInfoMap.remove(globalId);
if (DBG) {
Log.d(TAG, "Terminating client-ID " + clientId
+ " global-ID " + globalId + " type " + mClientRequests.get(clientId));
}
- switch (mClientRequests.get(clientId)) {
+
+ if (request instanceof DiscoveryManagerRequest) {
+ final MdnsListener listener =
+ ((DiscoveryManagerRequest) request).mListener;
+ mMdnsDiscoveryManager.unregisterListener(
+ listener.getListenedServiceType(), listener);
+ continue;
+ }
+
+ if (request instanceof AdvertiserClientRequest) {
+ mAdvertiser.removeService(globalId);
+ continue;
+ }
+
+ if (!(request instanceof LegacyClientRequest)) {
+ throw new IllegalStateException("Unknown request type: " + request.getClass());
+ }
+
+ switch (((LegacyClientRequest) request).mRequestCode) {
case NsdManager.DISCOVER_SERVICES:
stopServiceDiscovery(globalId);
break;
@@ -974,18 +1756,31 @@
break;
}
}
- mClientIds.clear();
mClientRequests.clear();
}
- // mClientIds is a sparse array of listener id -> mDnsClient id. For a given mDnsClient id,
- // return the corresponding listener id. mDnsClient id is also called a global id.
+ // mClientRequests is a sparse array of listener id -> ClientRequest. For a given
+ // mDnsClient id, return the corresponding listener id. mDnsClient id is also called a
+ // global id.
private int getClientId(final int globalId) {
- int idx = mClientIds.indexOfValue(globalId);
- if (idx < 0) {
- return idx;
+ for (int i = 0; i < mClientRequests.size(); i++) {
+ if (mClientRequests.valueAt(i).mGlobalId == globalId) {
+ return mClientRequests.keyAt(i);
+ }
}
- return mClientIds.keyAt(idx);
+ return -1;
+ }
+
+ private void maybeNotifyRegisteredServiceLost(@NonNull NsdServiceInfo info) {
+ if (mRegisteredService == null) return;
+ if (!Objects.equals(mRegisteredService.getServiceName(), info.getServiceName())) return;
+ // Resolved services have a leading dot appended at the beginning of their type, but in
+ // discovered info it's at the end
+ if (!Objects.equals(
+ mRegisteredService.getServiceType() + ".", "." + info.getServiceType())) {
+ return;
+ }
+ onServiceUpdatedLost(mClientIdForServiceUpdates);
}
void onDiscoverServicesStarted(int listenerKey, NsdServiceInfo info) {
@@ -1083,5 +1878,53 @@
Log.e(TAG, "Error calling onResolveServiceSucceeded", e);
}
}
+
+ void onStopResolutionFailed(int listenerKey, int error) {
+ try {
+ mCb.onStopResolutionFailed(listenerKey, error);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling onStopResolutionFailed", e);
+ }
+ }
+
+ void onStopResolutionSucceeded(int listenerKey) {
+ try {
+ mCb.onStopResolutionSucceeded(listenerKey);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling onStopResolutionSucceeded", e);
+ }
+ }
+
+ void onServiceInfoCallbackRegistrationFailed(int listenerKey, int error) {
+ try {
+ mCb.onServiceInfoCallbackRegistrationFailed(listenerKey, error);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling onServiceInfoCallbackRegistrationFailed", e);
+ }
+ }
+
+ void onServiceUpdated(int listenerKey, NsdServiceInfo info) {
+ try {
+ mCb.onServiceUpdated(listenerKey, info);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling onServiceUpdated", e);
+ }
+ }
+
+ void onServiceUpdatedLost(int listenerKey) {
+ try {
+ mCb.onServiceUpdatedLost(listenerKey);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling onServiceUpdatedLost", e);
+ }
+ }
+
+ void onServiceInfoCallbackUnregistered(int listenerKey) {
+ try {
+ mCb.onServiceInfoCallbackUnregistered(listenerKey);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling onServiceInfoCallbackUnregistered", e);
+ }
+ }
}
}
diff --git a/service/mdns/com/android/server/connectivity/mdns/ConnectivityMonitor.java b/service-t/src/com/android/server/connectivity/mdns/ConnectivityMonitor.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/ConnectivityMonitor.java
rename to service-t/src/com/android/server/connectivity/mdns/ConnectivityMonitor.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/ConnectivityMonitorWithConnectivityManager.java b/service-t/src/com/android/server/connectivity/mdns/ConnectivityMonitorWithConnectivityManager.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/ConnectivityMonitorWithConnectivityManager.java
rename to service-t/src/com/android/server/connectivity/mdns/ConnectivityMonitorWithConnectivityManager.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java b/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java
rename to service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/ExecutorProvider.java b/service-t/src/com/android/server/connectivity/mdns/ExecutorProvider.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/ExecutorProvider.java
rename to service-t/src/com/android/server/connectivity/mdns/ExecutorProvider.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsAdvertiser.java b/service-t/src/com/android/server/connectivity/mdns/MdnsAdvertiser.java
similarity index 70%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsAdvertiser.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsAdvertiser.java
index 4e40efe..977478a 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsAdvertiser.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsAdvertiser.java
@@ -29,10 +29,10 @@
import com.android.internal.annotations.VisibleForTesting;
-import java.io.IOException;
import java.util.List;
import java.util.Map;
-import java.util.function.Predicate;
+import java.util.function.BiPredicate;
+import java.util.function.Consumer;
/**
* MdnsAdvertiser manages advertising services per {@link com.android.server.NsdService} requests.
@@ -85,7 +85,7 @@
public void onRegisterServiceSucceeded(
@NonNull MdnsInterfaceAdvertiser advertiser, int serviceId) {
// Wait for all current interfaces to be done probing before notifying of success.
- if (anyAdvertiser(a -> a.isProbing(serviceId))) return;
+ if (any(mAllAdvertisers, (k, a) -> a.isProbing(serviceId))) return;
// The service may still be unregistered/renamed if a conflict is found on a later added
// interface, or if a conflicting announcement/reply is detected (RFC6762 9.)
@@ -102,7 +102,37 @@
@Override
public void onServiceConflict(@NonNull MdnsInterfaceAdvertiser advertiser, int serviceId) {
- // TODO: handle conflicts found after registration (during or after probing)
+ if (DBG) {
+ Log.v(TAG, "Found conflict, restarted probing for service " + serviceId);
+ }
+
+ final Registration registration = mRegistrations.get(serviceId);
+ if (registration == null) return;
+ if (registration.mNotifiedRegistrationSuccess) {
+ // TODO: consider notifying clients that the service is no longer registered with
+ // the old name (back to probing). The legacy implementation did not send any
+ // callback though; it only sent onServiceRegistered after re-probing finishes
+ // (with the old, conflicting, actually not used name as argument... The new
+ // implementation will send callbacks with the new name).
+ registration.mNotifiedRegistrationSuccess = false;
+
+ // The service was done probing, just reset it to probing state (RFC6762 9.)
+ forAllAdvertisers(a -> a.restartProbingForConflict(serviceId));
+ return;
+ }
+
+ // Conflict was found during probing; rename once to find a name that has no conflict
+ registration.updateForConflict(
+ registration.makeNewServiceInfoForConflict(1 /* renameCount */),
+ 1 /* renameCount */);
+
+ // Keep renaming if the new name conflicts in local registrations
+ updateRegistrationUntilNoConflict((net, adv) -> adv.hasRegistration(registration),
+ registration);
+
+ // Update advertisers to use the new name
+ forAllAdvertisers(a -> a.renameServiceForConflict(
+ serviceId, registration.getServiceInfo()));
}
@Override
@@ -116,6 +146,25 @@
}
};
+ private boolean hasAnyConflict(
+ @NonNull BiPredicate<Network, InterfaceAdvertiserRequest> applicableAdvertiserFilter,
+ @NonNull NsdServiceInfo newInfo) {
+ return any(mAdvertiserRequests, (network, adv) ->
+ applicableAdvertiserFilter.test(network, adv) && adv.hasConflict(newInfo));
+ }
+
+ private void updateRegistrationUntilNoConflict(
+ @NonNull BiPredicate<Network, InterfaceAdvertiserRequest> applicableAdvertiserFilter,
+ @NonNull Registration registration) {
+ int renameCount = 0;
+ NsdServiceInfo newInfo = registration.getServiceInfo();
+ while (hasAnyConflict(applicableAdvertiserFilter, newInfo)) {
+ renameCount++;
+ newInfo = registration.makeNewServiceInfoForConflict(renameCount);
+ }
+ registration.updateForConflict(newInfo, renameCount);
+ }
+
/**
* A request for a {@link MdnsInterfaceAdvertiser}.
*
@@ -153,6 +202,21 @@
}
/**
+ * Return whether this {@link InterfaceAdvertiserRequest} has the given registration.
+ */
+ boolean hasRegistration(@NonNull Registration registration) {
+ return mPendingRegistrations.indexOfValue(registration) >= 0;
+ }
+
+ /**
+ * Return whether using the proposed new {@link NsdServiceInfo} to add a registration would
+ * cause a conflict in this {@link InterfaceAdvertiserRequest}.
+ */
+ boolean hasConflict(@NonNull NsdServiceInfo newInfo) {
+ return getConflictingService(newInfo) >= 0;
+ }
+
+ /**
* Get the ID of a conflicting service, or -1 if none.
*/
int getConflictingService(@NonNull NsdServiceInfo info) {
@@ -166,16 +230,19 @@
return -1;
}
- void addService(int id, Registration registration)
- throws NameConflictException {
- final int conflicting = getConflictingService(registration.getServiceInfo());
- if (conflicting >= 0) {
- throw new NameConflictException(conflicting);
- }
-
+ /**
+ * Add a service.
+ *
+ * Conflicts must be checked via {@link #getConflictingService} before attempting to add.
+ */
+ void addService(int id, Registration registration) {
mPendingRegistrations.put(id, registration);
for (int i = 0; i < mAdvertisers.size(); i++) {
- mAdvertisers.valueAt(i).addService(id, registration.getServiceInfo());
+ try {
+ mAdvertisers.valueAt(i).addService(id, registration.getServiceInfo());
+ } catch (NameConflictException e) {
+ Log.wtf(TAG, "Name conflict adding services that should have unique names", e);
+ }
}
}
@@ -239,32 +306,42 @@
/**
* Update the registration to use a different service name, after a conflict was found.
*
+ * @param newInfo New service info to use.
+ * @param renameCount How many renames were done before reaching the current name.
+ */
+ private void updateForConflict(@NonNull NsdServiceInfo newInfo, int renameCount) {
+ mConflictCount += renameCount;
+ mServiceInfo = newInfo;
+ }
+
+ /**
+ * Make a new service name for the registration, after a conflict was found.
+ *
* If a name conflict was found during probing or because different advertising requests
* used the same name, the registration is attempted again with a new name (here using
* a number suffix, (1), (2) etc). Registration success is notified once probing succeeds
* with a new name. This matches legacy behavior based on mdnsresponder, and appendix D of
* RFC6763.
- * @return The new service info with the updated name.
+ *
+ * @param renameCount How much to increase the number suffix for this conflict.
*/
@NonNull
- private NsdServiceInfo updateForConflict() {
- mConflictCount++;
+ public NsdServiceInfo makeNewServiceInfoForConflict(int renameCount) {
// In case of conflict choose a different service name. After the first conflict use
// "Name (2)", then "Name (3)" etc.
// TODO: use a hidden method in NsdServiceInfo once MdnsAdvertiser is moved to service-t
final NsdServiceInfo newInfo = new NsdServiceInfo();
- newInfo.setServiceName(mOriginalName + " (" + (mConflictCount + 1) + ")");
+ newInfo.setServiceName(mOriginalName + " (" + (mConflictCount + renameCount + 1) + ")");
newInfo.setServiceType(mServiceInfo.getServiceType());
for (Map.Entry<String, byte[]> attr : mServiceInfo.getAttributes().entrySet()) {
- newInfo.setAttribute(attr.getKey(), attr.getValue());
+ newInfo.setAttribute(attr.getKey(),
+ attr.getValue() == null ? null : new String(attr.getValue()));
}
newInfo.setHost(mServiceInfo.getHost());
newInfo.setPort(mServiceInfo.getPort());
newInfo.setNetwork(mServiceInfo.getNetwork());
// interfaceIndex is not set when registering
-
- mServiceInfo = newInfo;
- return mServiceInfo;
+ return newInfo;
}
@NonNull
@@ -338,55 +415,27 @@
Log.i(TAG, "Adding service " + service + " with ID " + id);
}
- try {
- final Registration registration = new Registration(service);
- while (!tryAddRegistration(id, registration)) {
- registration.updateForConflict();
- }
-
- mRegistrations.put(id, registration);
- } catch (IOException e) {
- Log.e(TAG, "Error adding service " + service, e);
- removeService(id);
- // TODO (b/264986328): add a more specific error code
- mCb.onRegisterServiceFailed(id, NsdManager.FAILURE_INTERNAL_ERROR);
- }
- }
-
- private boolean tryAddRegistration(int id, @NonNull Registration registration)
- throws IOException {
- final NsdServiceInfo serviceInfo = registration.getServiceInfo();
- final Network network = serviceInfo.getNetwork();
- try {
- InterfaceAdvertiserRequest advertiser = mAdvertiserRequests.get(network);
- if (advertiser == null) {
- advertiser = new InterfaceAdvertiserRequest(network);
- mAdvertiserRequests.put(network, advertiser);
- }
- advertiser.addService(id, registration);
- } catch (NameConflictException e) {
- if (DBG) {
- Log.i(TAG, "Service name conflicts: " + serviceInfo.getServiceName());
- }
- removeService(id);
- return false;
+ final Network network = service.getNetwork();
+ final Registration registration = new Registration(service);
+ final BiPredicate<Network, InterfaceAdvertiserRequest> checkConflictFilter;
+ if (network == null) {
+ // If registering on all networks, no advertiser must have conflicts
+ checkConflictFilter = (net, adv) -> true;
+ } else {
+ // If registering on one network, the matching network advertiser and the one for all
+ // networks must not have conflicts
+ checkConflictFilter = (net, adv) -> net == null || network.equals(net);
}
- // When adding a service to a specific network, check that it does not conflict with other
- // registrations advertising on all networks
- final InterfaceAdvertiserRequest allNetworksAdvertiser = mAdvertiserRequests.get(null);
- if (network != null && allNetworksAdvertiser != null
- && allNetworksAdvertiser.getConflictingService(serviceInfo) >= 0) {
- if (DBG) {
- Log.i(TAG, "Service conflicts with advertisement on all networks: "
- + serviceInfo.getServiceName());
- }
- removeService(id);
- return false;
- }
+ updateRegistrationUntilNoConflict(checkConflictFilter, registration);
+ InterfaceAdvertiserRequest advertiser = mAdvertiserRequests.get(network);
+ if (advertiser == null) {
+ advertiser = new InterfaceAdvertiserRequest(network);
+ mAdvertiserRequests.put(network, advertiser);
+ }
+ advertiser.addService(id, registration);
mRegistrations.put(id, registration);
- return true;
}
/**
@@ -406,12 +455,20 @@
mRegistrations.remove(id);
}
- private boolean anyAdvertiser(@NonNull Predicate<MdnsInterfaceAdvertiser> predicate) {
- for (int i = 0; i < mAllAdvertisers.size(); i++) {
- if (predicate.test(mAllAdvertisers.valueAt(i))) {
+ private static <K, V> boolean any(@NonNull ArrayMap<K, V> map,
+ @NonNull BiPredicate<K, V> predicate) {
+ for (int i = 0; i < map.size(); i++) {
+ if (predicate.test(map.keyAt(i), map.valueAt(i))) {
return true;
}
}
return false;
}
+
+ private void forAllAdvertisers(@NonNull Consumer<MdnsInterfaceAdvertiser> consumer) {
+ any(mAllAdvertisers, (socket, advertiser) -> {
+ consumer.accept(advertiser);
+ return false;
+ });
+ }
}
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsAnnouncer.java b/service-t/src/com/android/server/connectivity/mdns/MdnsAnnouncer.java
similarity index 62%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsAnnouncer.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsAnnouncer.java
index 7c84323..27fc945 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsAnnouncer.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsAnnouncer.java
@@ -30,23 +30,27 @@
*
* This allows maintaining other hosts' caches up-to-date. See RFC6762 8.3.
*/
-public class MdnsAnnouncer extends MdnsPacketRepeater<MdnsAnnouncer.AnnouncementInfo> {
+public class MdnsAnnouncer extends MdnsPacketRepeater<MdnsAnnouncer.BaseAnnouncementInfo> {
private static final long ANNOUNCEMENT_INITIAL_DELAY_MS = 1000L;
@VisibleForTesting
static final int ANNOUNCEMENT_COUNT = 8;
+ // Matches delay and GoodbyeCount used by the legacy implementation
+ private static final long EXIT_DELAY_MS = 2000L;
+ private static final int EXIT_COUNT = 3;
+
@NonNull
private final String mLogTag;
- /** Announcement request to send with {@link MdnsAnnouncer}. */
- public static class AnnouncementInfo implements MdnsPacketRepeater.Request {
+ /** Base class for announcement requests to send with {@link MdnsAnnouncer}. */
+ public abstract static class BaseAnnouncementInfo implements MdnsPacketRepeater.Request {
+ private final int mServiceId;
@NonNull
private final MdnsPacket mPacket;
- AnnouncementInfo(List<MdnsRecord> announcedRecords, List<MdnsRecord> additionalRecords) {
- // Records to announce (as answers)
- // Records to place in the "Additional records", with NSEC negative responses
- // to mark records that have been verified unique
+ protected BaseAnnouncementInfo(int serviceId, @NonNull List<MdnsRecord> announcedRecords,
+ @NonNull List<MdnsRecord> additionalRecords) {
+ mServiceId = serviceId;
final int flags = 0x8400; // Response, authoritative (rfc6762 18.4)
mPacket = new MdnsPacket(flags,
Collections.emptyList() /* questions */,
@@ -55,10 +59,22 @@
additionalRecords);
}
+ public int getServiceId() {
+ return mServiceId;
+ }
+
@Override
public MdnsPacket getPacket(int index) {
return mPacket;
}
+ }
+
+ /** Announcement request to send with {@link MdnsAnnouncer}. */
+ public static class AnnouncementInfo extends BaseAnnouncementInfo {
+ AnnouncementInfo(int serviceId, List<MdnsRecord> announcedRecords,
+ List<MdnsRecord> additionalRecords) {
+ super(serviceId, announcedRecords, additionalRecords);
+ }
@Override
public long getDelayMs(int nextIndex) {
@@ -72,9 +88,26 @@
}
}
+ /** Service exit announcement request to send with {@link MdnsAnnouncer}. */
+ public static class ExitAnnouncementInfo extends BaseAnnouncementInfo {
+ ExitAnnouncementInfo(int serviceId, List<MdnsRecord> announcedRecords) {
+ super(serviceId, announcedRecords, Collections.emptyList() /* additionalRecords */);
+ }
+
+ @Override
+ public long getDelayMs(int nextIndex) {
+ return EXIT_DELAY_MS;
+ }
+
+ @Override
+ public int getNumSends() {
+ return EXIT_COUNT;
+ }
+ }
+
public MdnsAnnouncer(@NonNull String interfaceTag, @NonNull Looper looper,
@NonNull MdnsReplySender replySender,
- @Nullable PacketRepeaterCallback<AnnouncementInfo> cb) {
+ @Nullable PacketRepeaterCallback<BaseAnnouncementInfo> cb) {
super(looper, replySender, cb);
mLogTag = MdnsAnnouncer.class.getSimpleName() + "/" + interfaceTag;
}
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsAnyRecord.java b/service-t/src/com/android/server/connectivity/mdns/MdnsAnyRecord.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsAnyRecord.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsAnyRecord.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsConfigs.java b/service-t/src/com/android/server/connectivity/mdns/MdnsConfigs.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsConfigs.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsConfigs.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsConstants.java b/service-t/src/com/android/server/connectivity/mdns/MdnsConstants.java
similarity index 97%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsConstants.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsConstants.java
index 396be5f..f0e1717 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsConstants.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsConstants.java
@@ -37,6 +37,7 @@
public static final int FLAGS_QUERY = 0x0000;
public static final int FLAGS_RESPONSE_MASK = 0xF80F;
public static final int FLAGS_RESPONSE = 0x8000;
+ public static final int FLAG_TRUNCATED = 0x0200;
public static final int QCLASS_INTERNET = 0x0001;
public static final int QCLASS_UNICAST = 0x8000;
public static final String SUBTYPE_LABEL = "_sub";
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsDiscoveryManager.java b/service-t/src/com/android/server/connectivity/mdns/MdnsDiscoveryManager.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsDiscoveryManager.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsDiscoveryManager.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsInetAddressRecord.java b/service-t/src/com/android/server/connectivity/mdns/MdnsInetAddressRecord.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsInetAddressRecord.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsInetAddressRecord.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java b/service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
similarity index 73%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
index 997dcbb..c616e01 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
@@ -25,15 +25,18 @@
import android.util.Log;
import com.android.internal.annotations.VisibleForTesting;
+import com.android.net.module.util.HexDump;
+import com.android.server.connectivity.mdns.MdnsAnnouncer.BaseAnnouncementInfo;
import com.android.server.connectivity.mdns.MdnsPacketRepeater.PacketRepeaterCallback;
import java.io.IOException;
+import java.net.InetSocketAddress;
import java.util.List;
/**
* A class that handles advertising services on a {@link MdnsInterfaceSocket} tied to an interface.
*/
-public class MdnsInterfaceAdvertiser {
+public class MdnsInterfaceAdvertiser implements MulticastPacketReader.PacketHandler {
private static final boolean DBG = MdnsAdvertiser.DBG;
@VisibleForTesting
public static final long EXIT_ANNOUNCEMENT_DELAY_MS = 100L;
@@ -113,9 +116,22 @@
/**
* Callbacks from {@link MdnsAnnouncer}.
*/
- private class AnnouncingCallback
- implements PacketRepeaterCallback<MdnsAnnouncer.AnnouncementInfo> {
- // TODO: implement
+ private class AnnouncingCallback implements PacketRepeaterCallback<BaseAnnouncementInfo> {
+ @Override
+ public void onSent(int index, @NonNull BaseAnnouncementInfo info) {
+ mRecordRepository.onAdvertisementSent(info.getServiceId());
+ }
+
+ @Override
+ public void onFinished(@NonNull BaseAnnouncementInfo info) {
+ if (info instanceof MdnsAnnouncer.ExitAnnouncementInfo) {
+ mRecordRepository.removeService(info.getServiceId());
+
+ if (mRecordRepository.getServicesCount() == 0) {
+ destroyNow();
+ }
+ }
+ }
}
/**
@@ -131,15 +147,15 @@
/** @see MdnsReplySender */
@NonNull
- public MdnsReplySender makeReplySender(@NonNull Looper looper,
+ public MdnsReplySender makeReplySender(@NonNull String interfaceTag, @NonNull Looper looper,
@NonNull MdnsInterfaceSocket socket, @NonNull byte[] packetCreationBuffer) {
- return new MdnsReplySender(looper, socket, packetCreationBuffer);
+ return new MdnsReplySender(interfaceTag, looper, socket, packetCreationBuffer);
}
/** @see MdnsAnnouncer */
public MdnsAnnouncer makeMdnsAnnouncer(@NonNull String interfaceTag, @NonNull Looper looper,
@NonNull MdnsReplySender replySender,
- @Nullable PacketRepeaterCallback<MdnsAnnouncer.AnnouncementInfo> cb) {
+ @Nullable PacketRepeaterCallback<MdnsAnnouncer.BaseAnnouncementInfo> cb) {
return new MdnsAnnouncer(interfaceTag, looper, replySender, cb);
}
@@ -168,7 +184,7 @@
mSocket = socket;
mCb = cb;
mCbHandler = new Handler(looper);
- mReplySender = deps.makeReplySender(looper, socket, packetCreationBuffer);
+ mReplySender = deps.makeReplySender(logTag, looper, socket, packetCreationBuffer);
mAnnouncer = deps.makeMdnsAnnouncer(logTag, looper, mReplySender,
mAnnouncingCallback);
mProber = deps.makeMdnsProber(logTag, looper, mReplySender, mProbingCallback);
@@ -182,7 +198,7 @@
* {@link #destroyNow()}.
*/
public void start() {
- // TODO: start receiving packets
+ mSocket.addPacketHandler(this);
}
/**
@@ -210,9 +226,10 @@
* This will trigger exit announcements for the service.
*/
public void removeService(int id) {
+ if (!mRecordRepository.hasActiveService(id)) return;
mProber.stop(id);
mAnnouncer.stop(id);
- final MdnsAnnouncer.AnnouncementInfo exitInfo = mRecordRepository.exitService(id);
+ final MdnsAnnouncer.ExitAnnouncementInfo exitInfo = mRecordRepository.exitService(id);
if (exitInfo != null) {
// This effectively schedules destroyNow(), as it is to be called when the exit
// announcement finishes if there is no service left.
@@ -252,8 +269,8 @@
mProber.stop(serviceId);
mAnnouncer.stop(serviceId);
}
-
- // TODO: stop receiving packets
+ mReplySender.cancelAll();
+ mSocket.removePacketHandler(this);
mCbHandler.post(() -> mCb.onDestroyed(mSocket));
}
@@ -261,14 +278,23 @@
* Reset a service to the probing state due to a conflict found on the network.
*/
public void restartProbingForConflict(int serviceId) {
- // TODO: implement
+ final MdnsProber.ProbingInfo probingInfo = mRecordRepository.setServiceProbing(serviceId);
+ if (probingInfo == null) return;
+
+ mProber.restartForConflict(probingInfo);
}
/**
* Rename a service following a conflict found on the network, and restart probing.
+ *
+ * If the service was not registered on this {@link MdnsInterfaceAdvertiser}, this is a no-op.
*/
public void renameServiceForConflict(int serviceId, NsdServiceInfo newInfo) {
- // TODO: implement
+ final MdnsProber.ProbingInfo probingInfo = mRecordRepository.renameServiceForConflict(
+ serviceId, newInfo);
+ if (probingInfo == null) return;
+
+ mProber.restartForConflict(probingInfo);
}
/**
@@ -279,4 +305,40 @@
public boolean isProbing(int serviceId) {
return mRecordRepository.isProbing(serviceId);
}
+
+ @Override
+ public void handlePacket(byte[] recvbuf, int length, InetSocketAddress src) {
+ final MdnsPacket packet;
+ try {
+ packet = MdnsPacket.parse(new MdnsPacketReader(recvbuf, length));
+ } catch (MdnsPacket.ParseException e) {
+ Log.e(mTag, "Error parsing mDNS packet", e);
+ if (DBG) {
+ Log.v(
+ mTag, "Packet: " + HexDump.toHexString(recvbuf, 0, length));
+ }
+ return;
+ }
+
+ if (DBG) {
+ Log.v(mTag,
+ "Parsed packet with " + packet.questions.size() + " questions, "
+ + packet.answers.size() + " answers, "
+ + packet.authorityRecords.size() + " authority, "
+ + packet.additionalRecords.size() + " additional from " + src);
+ }
+
+ for (int conflictServiceId : mRecordRepository.getConflictingServices(packet)) {
+ mCbHandler.post(() -> mCb.onServiceConflict(this, conflictServiceId));
+ }
+
+ // Even in case of conflict, add replies for other services. But in general conflicts would
+ // happen when the incoming packet has answer records (not a question), so there will be no
+ // answer. One exception is simultaneous probe tiebreaking (rfc6762 8.2), in which case the
+ // conflicting service is still probing and won't reply either.
+ final MdnsRecordRepository.ReplyInfo answers = mRecordRepository.getReply(packet, src);
+
+ if (answers == null) return;
+ mReplySender.queueReply(answers);
+ }
}
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceSocket.java b/service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceSocket.java
similarity index 95%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceSocket.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceSocket.java
index d1290b6..119c7a8 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceSocket.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceSocket.java
@@ -162,6 +162,14 @@
}
/**
+ * Remove a handler added via {@link #addPacketHandler}. If the handler is not present, this is
+ * a no-op.
+ */
+ public void removePacketHandler(@NonNull MulticastPacketReader.PacketHandler handler) {
+ mPacketReader.removePacketHandler(handler);
+ }
+
+ /**
* Returns the network interface that this socket is bound to.
*
* <p>This method could be used on any thread.
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClient.java b/service-t/src/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClient.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClient.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClient.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsNsecRecord.java b/service-t/src/com/android/server/connectivity/mdns/MdnsNsecRecord.java
similarity index 87%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsNsecRecord.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsNsecRecord.java
index 06fdd5e..6ec2f99 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsNsecRecord.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsNsecRecord.java
@@ -17,12 +17,14 @@
package com.android.server.connectivity.mdns;
import android.net.DnsResolver;
+import android.text.TextUtils;
import com.android.net.module.util.CollectionUtils;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Objects;
/**
* A mDNS "NSEC" record, used in particular for negative responses (RFC6762 6.1).
@@ -140,4 +142,30 @@
writer.writeUInt8(bytesInBlock);
writer.writeBytes(bytes);
}
+
+ @Override
+ public String toString() {
+ return "NSEC: NextDomain: " + TextUtils.join(".", mNextDomain)
+ + " Types " + Arrays.toString(mTypes);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(super.hashCode(),
+ Arrays.hashCode(mNextDomain), Arrays.hashCode(mTypes));
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (this == other) {
+ return true;
+ }
+ if (!(other instanceof MdnsNsecRecord)) {
+ return false;
+ }
+
+ return super.equals(other)
+ && Arrays.equals(mNextDomain, ((MdnsNsecRecord) other).mNextDomain)
+ && Arrays.equals(mTypes, ((MdnsNsecRecord) other).mTypes);
+ }
}
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsPacket.java b/service-t/src/com/android/server/connectivity/mdns/MdnsPacket.java
new file mode 100644
index 0000000..27002b9
--- /dev/null
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsPacket.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.connectivity.mdns;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.util.Log;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A class holding data that can be included in a mDNS packet.
+ */
+public class MdnsPacket {
+ private static final String TAG = MdnsPacket.class.getSimpleName();
+
+ public final int flags;
+ @NonNull
+ public final List<MdnsRecord> questions;
+ @NonNull
+ public final List<MdnsRecord> answers;
+ @NonNull
+ public final List<MdnsRecord> authorityRecords;
+ @NonNull
+ public final List<MdnsRecord> additionalRecords;
+
+ MdnsPacket(int flags,
+ @NonNull List<MdnsRecord> questions,
+ @NonNull List<MdnsRecord> answers,
+ @NonNull List<MdnsRecord> authorityRecords,
+ @NonNull List<MdnsRecord> additionalRecords) {
+ this.flags = flags;
+ this.questions = Collections.unmodifiableList(questions);
+ this.answers = Collections.unmodifiableList(answers);
+ this.authorityRecords = Collections.unmodifiableList(authorityRecords);
+ this.additionalRecords = Collections.unmodifiableList(additionalRecords);
+ }
+
+ /**
+ * Exception thrown on parse errors.
+ */
+ public static class ParseException extends IOException {
+ public final int code;
+
+ public ParseException(int code, @NonNull String message, @Nullable Throwable cause) {
+ super(message, cause);
+ this.code = code;
+ }
+ }
+
+ /**
+ * Parse the packet in the provided {@link MdnsPacketReader}.
+ */
+ @NonNull
+ public static MdnsPacket parse(@NonNull MdnsPacketReader reader) throws ParseException {
+ final int flags;
+ try {
+ reader.readUInt16(); // transaction ID (not used)
+ flags = reader.readUInt16();
+ } catch (EOFException e) {
+ throw new ParseException(MdnsResponseErrorCode.ERROR_END_OF_FILE,
+ "Reached the end of the mDNS response unexpectedly.", e);
+ }
+ return parseRecordsSection(reader, flags);
+ }
+
+ /**
+ * Parse the records section of a mDNS packet in the provided {@link MdnsPacketReader}.
+ *
+ * The records section starts with the questions count, just after the packet flags.
+ */
+ public static MdnsPacket parseRecordsSection(@NonNull MdnsPacketReader reader, int flags)
+ throws ParseException {
+ try {
+ final int numQuestions = reader.readUInt16();
+ final int numAnswers = reader.readUInt16();
+ final int numAuthority = reader.readUInt16();
+ final int numAdditional = reader.readUInt16();
+
+ final ArrayList<MdnsRecord> questions = parseRecords(reader, numQuestions, true);
+ final ArrayList<MdnsRecord> answers = parseRecords(reader, numAnswers, false);
+ final ArrayList<MdnsRecord> authority = parseRecords(reader, numAuthority, false);
+ final ArrayList<MdnsRecord> additional = parseRecords(reader, numAdditional, false);
+
+ return new MdnsPacket(flags, questions, answers, authority, additional);
+ } catch (EOFException e) {
+ throw new ParseException(MdnsResponseErrorCode.ERROR_END_OF_FILE,
+ "Reached the end of the mDNS response unexpectedly.", e);
+ }
+ }
+
+ private static ArrayList<MdnsRecord> parseRecords(@NonNull MdnsPacketReader reader, int count,
+ boolean isQuestion)
+ throws ParseException {
+ final ArrayList<MdnsRecord> records = new ArrayList<>(count);
+ for (int i = 0; i < count; ++i) {
+ final MdnsRecord record = parseRecord(reader, isQuestion);
+ if (record != null) {
+ records.add(record);
+ }
+ }
+ return records;
+ }
+
+ @Nullable
+ private static MdnsRecord parseRecord(@NonNull MdnsPacketReader reader, boolean isQuestion)
+ throws ParseException {
+ String[] name;
+ try {
+ name = reader.readLabels();
+ } catch (IOException e) {
+ throw new ParseException(MdnsResponseErrorCode.ERROR_READING_RECORD_NAME,
+ "Failed to read labels from mDNS response.", e);
+ }
+
+ final int type;
+ try {
+ type = reader.readUInt16();
+ } catch (EOFException e) {
+ throw new ParseException(MdnsResponseErrorCode.ERROR_END_OF_FILE,
+ "Reached the end of the mDNS response unexpectedly.", e);
+ }
+
+ switch (type) {
+ case MdnsRecord.TYPE_A: {
+ try {
+ return new MdnsInetAddressRecord(name, MdnsRecord.TYPE_A, reader, isQuestion);
+ } catch (IOException e) {
+ throw new ParseException(MdnsResponseErrorCode.ERROR_READING_A_RDATA,
+ "Failed to read A record from mDNS response.", e);
+ }
+ }
+
+ case MdnsRecord.TYPE_AAAA: {
+ try {
+ return new MdnsInetAddressRecord(name,
+ MdnsRecord.TYPE_AAAA, reader, isQuestion);
+ } catch (IOException e) {
+ throw new ParseException(MdnsResponseErrorCode.ERROR_READING_AAAA_RDATA,
+ "Failed to read AAAA record from mDNS response.", e);
+ }
+ }
+
+ case MdnsRecord.TYPE_PTR: {
+ try {
+ return new MdnsPointerRecord(name, reader, isQuestion);
+ } catch (IOException e) {
+ throw new ParseException(MdnsResponseErrorCode.ERROR_READING_PTR_RDATA,
+ "Failed to read PTR record from mDNS response.", e);
+ }
+ }
+
+ case MdnsRecord.TYPE_SRV: {
+ try {
+ return new MdnsServiceRecord(name, reader, isQuestion);
+ } catch (IOException e) {
+ throw new ParseException(MdnsResponseErrorCode.ERROR_READING_SRV_RDATA,
+ "Failed to read SRV record from mDNS response.", e);
+ }
+ }
+
+ case MdnsRecord.TYPE_TXT: {
+ try {
+ return new MdnsTextRecord(name, reader, isQuestion);
+ } catch (IOException e) {
+ throw new ParseException(MdnsResponseErrorCode.ERROR_READING_TXT_RDATA,
+ "Failed to read TXT record from mDNS response.", e);
+ }
+ }
+
+ case MdnsRecord.TYPE_NSEC: {
+ try {
+ return new MdnsNsecRecord(name, reader, isQuestion);
+ } catch (IOException e) {
+ throw new ParseException(MdnsResponseErrorCode.ERROR_READING_NSEC_RDATA,
+ "Failed to read NSEC record from mDNS response.", e);
+ }
+ }
+
+ case MdnsRecord.TYPE_ANY: {
+ try {
+ return new MdnsAnyRecord(name, reader);
+ } catch (IOException e) {
+ throw new ParseException(MdnsResponseErrorCode.ERROR_READING_ANY_RDATA,
+ "Failed to read TYPE_ANY record from mDNS response.", e);
+ }
+ }
+
+ default: {
+ try {
+ if (MdnsAdvertiser.DBG) {
+ Log.i(TAG, "Skipping parsing of record of unhandled type " + type);
+ }
+ skipMdnsRecord(reader, isQuestion);
+ return null;
+ } catch (IOException e) {
+ throw new ParseException(MdnsResponseErrorCode.ERROR_SKIPPING_UNKNOWN_RECORD,
+ "Failed to skip mDNS record.", e);
+ }
+ }
+ }
+ }
+
+ private static void skipMdnsRecord(@NonNull MdnsPacketReader reader, boolean isQuestion)
+ throws IOException {
+ reader.skip(2); // Skip the class
+ if (isQuestion) return;
+ // Skip TTL and data
+ reader.skip(4);
+ int dataLength = reader.readUInt16();
+ reader.skip(dataLength);
+ }
+}
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsPacketReader.java b/service-t/src/com/android/server/connectivity/mdns/MdnsPacketReader.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsPacketReader.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsPacketReader.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsPacketRepeater.java b/service-t/src/com/android/server/connectivity/mdns/MdnsPacketRepeater.java
similarity index 94%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsPacketRepeater.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsPacketRepeater.java
index ae54e70..4c385da 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsPacketRepeater.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsPacketRepeater.java
@@ -16,6 +16,9 @@
package com.android.server.connectivity.mdns;
+import static com.android.server.connectivity.mdns.MdnsRecordRepository.IPV4_ADDR;
+import static com.android.server.connectivity.mdns.MdnsRecordRepository.IPV6_ADDR;
+
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.os.Handler;
@@ -32,10 +35,6 @@
*/
public abstract class MdnsPacketRepeater<T extends MdnsPacketRepeater.Request> {
private static final boolean DBG = MdnsAdvertiser.DBG;
- private static final InetSocketAddress IPV4_ADDR = new InetSocketAddress(
- MdnsConstants.getMdnsIPv4Address(), MdnsConstants.MDNS_PORT);
- private static final InetSocketAddress IPV6_ADDR = new InetSocketAddress(
- MdnsConstants.getMdnsIPv6Address(), MdnsConstants.MDNS_PORT);
private static final InetSocketAddress[] ALL_ADDRS = new InetSocketAddress[] {
IPV4_ADDR, IPV6_ADDR
};
@@ -114,7 +113,7 @@
final MdnsPacket packet = request.getPacket(index);
if (DBG) {
Log.v(getTag(), "Sending packets for iteration " + index + " out of "
- + request.getNumSends());
+ + request.getNumSends() + " for ID " + msg.what);
}
// Send to both v4 and v6 addresses; the reply sender will take care of ignoring the
// send when the socket has not joined the relevant group.
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsPacketWriter.java b/service-t/src/com/android/server/connectivity/mdns/MdnsPacketWriter.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsPacketWriter.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsPacketWriter.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsPointerRecord.java b/service-t/src/com/android/server/connectivity/mdns/MdnsPointerRecord.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsPointerRecord.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsPointerRecord.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsProber.java b/service-t/src/com/android/server/connectivity/mdns/MdnsProber.java
similarity index 86%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsProber.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsProber.java
index 2cd9148..669b323 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsProber.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsProber.java
@@ -33,13 +33,13 @@
* TODO: implement receiving replies and handling conflicts.
*/
public class MdnsProber extends MdnsPacketRepeater<MdnsProber.ProbingInfo> {
+ private static final long CONFLICT_RETRY_DELAY_MS = 5_000L;
@NonNull
private final String mLogTag;
public MdnsProber(@NonNull String interfaceTag, @NonNull Looper looper,
@NonNull MdnsReplySender replySender,
@NonNull PacketRepeaterCallback<ProbingInfo> cb) {
- // 3 packets as per https://datatracker.ietf.org/doc/html/rfc6762#section-8.1
super(looper, replySender, cb);
mLogTag = MdnsProber.class.getSimpleName() + "/" + interfaceTag;
}
@@ -140,4 +140,18 @@
private void startProbing(@NonNull ProbingInfo info, long delay) {
startSending(info.getServiceId(), info, delay);
}
+
+ /**
+ * Restart probing with new service info as a conflict was found.
+ */
+ public void restartForConflict(@NonNull ProbingInfo newInfo) {
+ stop(newInfo.getServiceId());
+
+ /* RFC 6762 8.1: "If fifteen conflicts occur within any ten-second period, then the host
+ MUST wait at least five seconds before each successive additional probe attempt. [...]
+ For very simple devices, a valid way to comply with this requirement is to always wait
+ five seconds after any failed probe attempt before trying again. */
+ // TODO: count 15 conflicts in 10s instead of waiting for 5s every time
+ startProbing(newInfo, CONFLICT_RETRY_DELAY_MS);
+ }
}
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsRecord.java b/service-t/src/com/android/server/connectivity/mdns/MdnsRecord.java
similarity index 99%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsRecord.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsRecord.java
index 00871ea..bcee9d1 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsRecord.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsRecord.java
@@ -45,6 +45,7 @@
private static final int FLAG_CACHE_FLUSH = 0x8000;
public static final long RECEIPT_TIME_NOT_SENT = 0L;
+ public static final int CLASS_ANY = 0x00ff;
/** Status indicating that the record is current. */
public static final int STATUS_OK = 0;
@@ -317,4 +318,4 @@
return (recordType * 31) + Arrays.hashCode(recordName);
}
}
-}
\ No newline at end of file
+}
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsRecordRepository.java b/service-t/src/com/android/server/connectivity/mdns/MdnsRecordRepository.java
new file mode 100644
index 0000000..e975ab4
--- /dev/null
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsRecordRepository.java
@@ -0,0 +1,885 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.connectivity.mdns;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.annotation.TargetApi;
+import android.net.LinkAddress;
+import android.net.nsd.NsdServiceInfo;
+import android.os.Build;
+import android.os.Looper;
+import android.os.SystemClock;
+import android.util.ArraySet;
+import android.util.SparseArray;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.net.module.util.CollectionUtils;
+import com.android.net.module.util.HexDump;
+
+import java.io.IOException;
+import java.net.Inet4Address;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.NetworkInterface;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Random;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A repository of records advertised through {@link MdnsInterfaceAdvertiser}.
+ *
+ * Must be used on a consistent looper thread.
+ */
+@TargetApi(Build.VERSION_CODES.TIRAMISU) // Allow calling T+ APIs; this is only loaded on T+
+public class MdnsRecordRepository {
+ // RFC6762 p.15
+ private static final long MIN_MULTICAST_REPLY_INTERVAL_MS = 1_000L;
+
+ // TTLs as per RFC6762 10.
+ // TTL for records with a host name as the resource record's name (e.g., A, AAAA, HINFO) or a
+ // host name contained within the resource record's rdata (e.g., SRV, reverse mapping PTR
+ // record)
+ private static final long NAME_RECORDS_TTL_MILLIS = TimeUnit.SECONDS.toMillis(120);
+ // TTL for other records
+ private static final long NON_NAME_RECORDS_TTL_MILLIS = TimeUnit.MINUTES.toMillis(75);
+
+ // Top-level domain for link-local queries, as per RFC6762 3.
+ private static final String LOCAL_TLD = "local";
+
+ // Service type for service enumeration (RFC6763 9.)
+ private static final String[] DNS_SD_SERVICE_TYPE =
+ new String[] { "_services", "_dns-sd", "_udp", LOCAL_TLD };
+
+ public static final InetSocketAddress IPV6_ADDR = new InetSocketAddress(
+ MdnsConstants.getMdnsIPv6Address(), MdnsConstants.MDNS_PORT);
+ public static final InetSocketAddress IPV4_ADDR = new InetSocketAddress(
+ MdnsConstants.getMdnsIPv4Address(), MdnsConstants.MDNS_PORT);
+
+ @NonNull
+ private final Random mDelayGenerator = new Random();
+ // Map of service unique ID -> records for service
+ @NonNull
+ private final SparseArray<ServiceRegistration> mServices = new SparseArray<>();
+ @NonNull
+ private final List<RecordInfo<?>> mGeneralRecords = new ArrayList<>();
+ @NonNull
+ private final Looper mLooper;
+ @NonNull
+ private String[] mDeviceHostname;
+
+ public MdnsRecordRepository(@NonNull Looper looper) {
+ this(looper, new Dependencies());
+ }
+
+ @VisibleForTesting
+ public MdnsRecordRepository(@NonNull Looper looper, @NonNull Dependencies deps) {
+ mDeviceHostname = deps.getHostname();
+ mLooper = looper;
+ }
+
+ /**
+ * Dependencies to use with {@link MdnsRecordRepository}, useful for testing.
+ */
+ @VisibleForTesting
+ public static class Dependencies {
+ /**
+ * Get a unique hostname to be used by the device.
+ */
+ @NonNull
+ public String[] getHostname() {
+ // Generate a very-probably-unique hostname. This allows minimizing possible conflicts
+ // to the point that probing for it is no longer necessary (as per RFC6762 8.1 last
+ // paragraph), and does not leak more information than what could already be obtained by
+ // looking at the mDNS packets source address.
+ // This differs from historical behavior that just used "Android.local" for many
+ // devices, creating a lot of conflicts.
+ // Having a different hostname per interface is an acceptable option as per RFC6762 14.
+ // This hostname will change every time the interface is reconnected, so this does not
+ // allow tracking the device.
+ // TODO: consider deriving a hostname from other sources, such as the IPv6 addresses
+ // (reusing the same privacy-protecting mechanics).
+ return new String[] {
+ "Android_" + UUID.randomUUID().toString().replace("-", ""), LOCAL_TLD };
+ }
+
+ /**
+ * @see NetworkInterface#getInetAddresses().
+ */
+ @NonNull
+ public Enumeration<InetAddress> getInterfaceInetAddresses(@NonNull NetworkInterface iface) {
+ return iface.getInetAddresses();
+ }
+ }
+
+ private static class RecordInfo<T extends MdnsRecord> {
+ public final T record;
+ public final NsdServiceInfo serviceInfo;
+
+ /**
+ * Whether the name of this record is expected to be fully owned by the service or may be
+ * advertised by other hosts as well (shared).
+ */
+ public final boolean isSharedName;
+
+ /**
+ * Whether probing is still in progress for the record.
+ */
+ public boolean isProbing;
+
+ /**
+ * Last time (as per SystemClock.elapsedRealtime) when advertised via multicast, 0 if never
+ */
+ public long lastAdvertisedTimeMs;
+
+ /**
+ * Last time (as per SystemClock.elapsedRealtime) when sent via unicast or multicast,
+ * 0 if never
+ */
+ public long lastSentTimeMs;
+
+ RecordInfo(NsdServiceInfo serviceInfo, T record, boolean sharedName,
+ boolean probing) {
+ this.serviceInfo = serviceInfo;
+ this.record = record;
+ this.isSharedName = sharedName;
+ this.isProbing = probing;
+ }
+ }
+
+ private static class ServiceRegistration {
+ @NonNull
+ public final List<RecordInfo<?>> allRecords;
+ @NonNull
+ public final RecordInfo<MdnsPointerRecord> ptrRecord;
+ @NonNull
+ public final RecordInfo<MdnsServiceRecord> srvRecord;
+ @NonNull
+ public final RecordInfo<MdnsTextRecord> txtRecord;
+ @NonNull
+ public final NsdServiceInfo serviceInfo;
+
+ /**
+ * Whether the service is sending exit announcements and will be destroyed soon.
+ */
+ public boolean exiting = false;
+
+ /**
+ * Create a ServiceRegistration for dns-sd service registration (RFC6763).
+ *
+ * @param deviceHostname Hostname of the device (for the interface used)
+ * @param serviceInfo Service to advertise
+ */
+ ServiceRegistration(@NonNull String[] deviceHostname, @NonNull NsdServiceInfo serviceInfo) {
+ this.serviceInfo = serviceInfo;
+
+ final String[] serviceType = splitServiceType(serviceInfo);
+ final String[] serviceName = splitFullyQualifiedName(serviceInfo, serviceType);
+
+ // Service PTR record
+ ptrRecord = new RecordInfo<>(
+ serviceInfo,
+ new MdnsPointerRecord(
+ serviceType,
+ 0L /* receiptTimeMillis */,
+ false /* cacheFlush */,
+ NON_NAME_RECORDS_TTL_MILLIS,
+ serviceName),
+ true /* sharedName */, true /* probing */);
+
+ srvRecord = new RecordInfo<>(
+ serviceInfo,
+ new MdnsServiceRecord(serviceName,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ NAME_RECORDS_TTL_MILLIS, 0 /* servicePriority */, 0 /* serviceWeight */,
+ serviceInfo.getPort(),
+ deviceHostname),
+ false /* sharedName */, true /* probing */);
+
+ txtRecord = new RecordInfo<>(
+ serviceInfo,
+ new MdnsTextRecord(serviceName,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */, // Service name is verified unique after probing
+ NON_NAME_RECORDS_TTL_MILLIS,
+ attrsToTextEntries(serviceInfo.getAttributes())),
+ false /* sharedName */, true /* probing */);
+
+ final ArrayList<RecordInfo<?>> allRecords = new ArrayList<>(4);
+ allRecords.add(ptrRecord);
+ allRecords.add(srvRecord);
+ allRecords.add(txtRecord);
+ // Service type enumeration record (RFC6763 9.)
+ allRecords.add(new RecordInfo<>(
+ serviceInfo,
+ new MdnsPointerRecord(
+ DNS_SD_SERVICE_TYPE,
+ 0L /* receiptTimeMillis */,
+ false /* cacheFlush */,
+ NON_NAME_RECORDS_TTL_MILLIS,
+ serviceType),
+ true /* sharedName */, true /* probing */));
+
+ this.allRecords = Collections.unmodifiableList(allRecords);
+ }
+
+ void setProbing(boolean probing) {
+ for (RecordInfo<?> info : allRecords) {
+ info.isProbing = probing;
+ }
+ }
+ }
+
+ /**
+ * Inform the repository of the latest interface addresses.
+ */
+ public void updateAddresses(@NonNull List<LinkAddress> newAddresses) {
+ mGeneralRecords.clear();
+ for (LinkAddress addr : newAddresses) {
+ final String[] revDnsAddr = getReverseDnsAddress(addr.getAddress());
+ mGeneralRecords.add(new RecordInfo<>(
+ null /* serviceInfo */,
+ new MdnsPointerRecord(
+ revDnsAddr,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ NAME_RECORDS_TTL_MILLIS,
+ mDeviceHostname),
+ false /* sharedName */, false /* probing */));
+
+ mGeneralRecords.add(new RecordInfo<>(
+ null /* serviceInfo */,
+ new MdnsInetAddressRecord(
+ mDeviceHostname,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ NAME_RECORDS_TTL_MILLIS,
+ addr.getAddress()),
+ false /* sharedName */, false /* probing */));
+ }
+ }
+
+ /**
+ * Add a service to the repository.
+ *
+ * This may remove/replace any existing service that used the name added but is exiting.
+ * @param serviceId A unique service ID.
+ * @param serviceInfo Service info to add.
+ * @return If the added service replaced another with a matching name (which was exiting), the
+ * ID of the replaced service.
+ * @throws NameConflictException There is already a (non-exiting) service using the name.
+ */
+ public int addService(int serviceId, NsdServiceInfo serviceInfo) throws NameConflictException {
+ if (mServices.contains(serviceId)) {
+ throw new IllegalArgumentException(
+ "Service ID must not be reused across registrations: " + serviceId);
+ }
+
+ final int existing = getServiceByName(serviceInfo.getServiceName());
+ // It's OK to re-add a service that is exiting
+ if (existing >= 0 && !mServices.get(existing).exiting) {
+ throw new NameConflictException(existing);
+ }
+
+ final ServiceRegistration registration = new ServiceRegistration(
+ mDeviceHostname, serviceInfo);
+ mServices.put(serviceId, registration);
+
+ // Remove existing exiting service
+ mServices.remove(existing);
+ return existing;
+ }
+
+ /**
+ * @return The ID of the service identified by its name, or -1 if none.
+ */
+ private int getServiceByName(@NonNull String serviceName) {
+ for (int i = 0; i < mServices.size(); i++) {
+ final ServiceRegistration registration = mServices.valueAt(i);
+ if (serviceName.equals(registration.serviceInfo.getServiceName())) {
+ return mServices.keyAt(i);
+ }
+ }
+ return -1;
+ }
+
+ private MdnsProber.ProbingInfo makeProbingInfo(int serviceId,
+ @NonNull MdnsServiceRecord srvRecord) {
+ final List<MdnsRecord> probingRecords = new ArrayList<>();
+ // Probe with cacheFlush cleared; it is set when announcing, as it was verified unique:
+ // RFC6762 10.2
+ probingRecords.add(new MdnsServiceRecord(srvRecord.getName(),
+ 0L /* receiptTimeMillis */,
+ false /* cacheFlush */,
+ srvRecord.getTtl(),
+ srvRecord.getServicePriority(), srvRecord.getServiceWeight(),
+ srvRecord.getServicePort(),
+ srvRecord.getServiceHost()));
+
+ return new MdnsProber.ProbingInfo(serviceId, probingRecords);
+ }
+
+ private static List<MdnsServiceInfo.TextEntry> attrsToTextEntries(Map<String, byte[]> attrs) {
+ final List<MdnsServiceInfo.TextEntry> out = new ArrayList<>(attrs.size());
+ for (Map.Entry<String, byte[]> attr : attrs.entrySet()) {
+ out.add(new MdnsServiceInfo.TextEntry(attr.getKey(), attr.getValue()));
+ }
+ return out;
+ }
+
+ /**
+ * Mark a service in the repository as exiting.
+ * @param id ID of the service, used at registration time.
+ * @return The exit announcement to indicate the service was removed, or null if not necessary.
+ */
+ @Nullable
+ public MdnsAnnouncer.ExitAnnouncementInfo exitService(int id) {
+ final ServiceRegistration registration = mServices.get(id);
+ if (registration == null) return null;
+ if (registration.exiting) return null;
+
+ // Send exit (TTL 0) for the PTR record, if the record was sent (in particular don't send
+ // if still probing)
+ if (registration.ptrRecord.lastSentTimeMs == 0L) {
+ return null;
+ }
+
+ registration.exiting = true;
+ final MdnsPointerRecord expiredRecord = new MdnsPointerRecord(
+ registration.ptrRecord.record.getName(),
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 0L /* ttlMillis */,
+ registration.ptrRecord.record.getPointer());
+
+ // Exit should be skipped if the record is still advertised by another service, but that
+ // would be a conflict (2 service registrations with the same service name), so it would
+ // not have been allowed by the repository.
+ return new MdnsAnnouncer.ExitAnnouncementInfo(id, Collections.singletonList(expiredRecord));
+ }
+
+ public void removeService(int id) {
+ mServices.remove(id);
+ }
+
+ /**
+ * @return The number of services currently held in the repository, including exiting services.
+ */
+ public int getServicesCount() {
+ return mServices.size();
+ }
+
+ /**
+ * Remove all services from the repository
+ * @return IDs of the removed services
+ */
+ @NonNull
+ public int[] clearServices() {
+ final int[] ret = new int[mServices.size()];
+ for (int i = 0; i < mServices.size(); i++) {
+ ret[i] = mServices.keyAt(i);
+ }
+ mServices.clear();
+ return ret;
+ }
+
+ /**
+ * Info about a reply to be sent.
+ */
+ public static class ReplyInfo {
+ @NonNull
+ public final List<MdnsRecord> answers;
+ @NonNull
+ public final List<MdnsRecord> additionalAnswers;
+ public final long sendDelayMs;
+ @NonNull
+ public final InetSocketAddress destination;
+
+ public ReplyInfo(
+ @NonNull List<MdnsRecord> answers,
+ @NonNull List<MdnsRecord> additionalAnswers,
+ long sendDelayMs,
+ @NonNull InetSocketAddress destination) {
+ this.answers = answers;
+ this.additionalAnswers = additionalAnswers;
+ this.sendDelayMs = sendDelayMs;
+ this.destination = destination;
+ }
+
+ @Override
+ public String toString() {
+ return "{ReplyInfo to " + destination + ", answers: " + answers.size()
+ + ", additionalAnswers: " + additionalAnswers.size()
+ + ", sendDelayMs " + sendDelayMs + "}";
+ }
+ }
+
+ /**
+ * Get the reply to send to an incoming packet.
+ *
+ * @param packet The incoming packet.
+ * @param src The source address of the incoming packet.
+ */
+ @Nullable
+ public ReplyInfo getReply(MdnsPacket packet, InetSocketAddress src) {
+ final long now = SystemClock.elapsedRealtime();
+ final boolean replyUnicast = (packet.flags & MdnsConstants.QCLASS_UNICAST) != 0;
+ final ArrayList<MdnsRecord> additionalAnswerRecords = new ArrayList<>();
+ final ArrayList<RecordInfo<?>> answerInfo = new ArrayList<>();
+ for (MdnsRecord question : packet.questions) {
+ // Add answers from general records
+ addReplyFromService(question, mGeneralRecords, null /* servicePtrRecord */,
+ null /* serviceSrvRecord */, null /* serviceTxtRecord */, replyUnicast, now,
+ answerInfo, additionalAnswerRecords);
+
+ // Add answers from each service
+ for (int i = 0; i < mServices.size(); i++) {
+ final ServiceRegistration registration = mServices.valueAt(i);
+ if (registration.exiting) continue;
+ addReplyFromService(question, registration.allRecords, registration.ptrRecord,
+ registration.srvRecord, registration.txtRecord, replyUnicast, now,
+ answerInfo, additionalAnswerRecords);
+ }
+ }
+
+ if (answerInfo.size() == 0 && additionalAnswerRecords.size() == 0) {
+ return null;
+ }
+
+ // Determine the send delay
+ final long delayMs;
+ if ((packet.flags & MdnsConstants.FLAG_TRUNCATED) != 0) {
+ // RFC 6762 6.: 400-500ms delay if TC bit is set
+ delayMs = 400L + mDelayGenerator.nextInt(100);
+ } else if (packet.questions.size() > 1
+ || CollectionUtils.any(answerInfo, a -> a.isSharedName)) {
+ // 20-120ms if there may be responses from other hosts (not a fully owned
+ // name) (RFC 6762 6.), or if there are multiple questions (6.3).
+ // TODO: this should be 0 if this is a probe query ("can be distinguished from a
+ // normal query by the fact that a probe query contains a proposed record in the
+ // Authority Section that answers the question" in 6.), and the reply is for a fully
+ // owned record.
+ delayMs = 20L + mDelayGenerator.nextInt(100);
+ } else {
+ delayMs = 0L;
+ }
+
+ // Determine the send destination
+ final InetSocketAddress dest;
+ if (replyUnicast) {
+ dest = src;
+ } else if (src.getAddress() instanceof Inet4Address) {
+ dest = IPV4_ADDR;
+ } else {
+ dest = IPV6_ADDR;
+ }
+
+ // Build the list of answer records from their RecordInfo
+ final ArrayList<MdnsRecord> answerRecords = new ArrayList<>(answerInfo.size());
+ for (RecordInfo<?> info : answerInfo) {
+ // TODO: consider actual packet send delay after response aggregation
+ info.lastSentTimeMs = now + delayMs;
+ if (!replyUnicast) {
+ info.lastAdvertisedTimeMs = info.lastSentTimeMs;
+ }
+ answerRecords.add(info.record);
+ }
+
+ return new ReplyInfo(answerRecords, additionalAnswerRecords, delayMs, dest);
+ }
+
+ /**
+ * Add answers and additional answers for a question, from a ServiceRegistration.
+ */
+ private void addReplyFromService(@NonNull MdnsRecord question,
+ @NonNull List<RecordInfo<?>> serviceRecords,
+ @Nullable RecordInfo<MdnsPointerRecord> servicePtrRecord,
+ @Nullable RecordInfo<MdnsServiceRecord> serviceSrvRecord,
+ @Nullable RecordInfo<MdnsTextRecord> serviceTxtRecord,
+ boolean replyUnicast, long now, @NonNull List<RecordInfo<?>> answerInfo,
+ @NonNull List<MdnsRecord> additionalAnswerRecords) {
+ boolean hasDnsSdPtrRecordAnswer = false;
+ boolean hasDnsSdSrvRecordAnswer = false;
+ boolean hasFullyOwnedNameMatch = false;
+ boolean hasKnownAnswer = false;
+
+ final int answersStartIndex = answerInfo.size();
+ for (RecordInfo<?> info : serviceRecords) {
+ if (info.isProbing) continue;
+
+ /* RFC6762 6.: the record name must match the question name, the record rrtype
+ must match the question qtype unless the qtype is "ANY" (255) or the rrtype is
+ "CNAME" (5), and the record rrclass must match the question qclass unless the
+ qclass is "ANY" (255) */
+ if (!Arrays.equals(info.record.getName(), question.getName())) continue;
+ hasFullyOwnedNameMatch |= !info.isSharedName;
+
+ // The repository does not store CNAME records
+ if (question.getType() != MdnsRecord.TYPE_ANY
+ && question.getType() != info.record.getType()) {
+ continue;
+ }
+ if (question.getRecordClass() != MdnsRecord.CLASS_ANY
+ && question.getRecordClass() != info.record.getRecordClass()) {
+ continue;
+ }
+
+ hasKnownAnswer = true;
+ hasDnsSdPtrRecordAnswer |= (info == servicePtrRecord);
+ hasDnsSdSrvRecordAnswer |= (info == serviceSrvRecord);
+
+ // TODO: responses to probe queries should bypass this check and only ensure the
+ // reply is sent 250ms after the last sent time (RFC 6762 p.15)
+ if (!replyUnicast && info.lastAdvertisedTimeMs > 0L
+ && now - info.lastAdvertisedTimeMs < MIN_MULTICAST_REPLY_INTERVAL_MS) {
+ continue;
+ }
+
+ // TODO: Don't reply if in known answers of the querier (7.1) if TTL is > half
+
+ answerInfo.add(info);
+ }
+
+ // RFC6762 6.1:
+ // "Any time a responder receives a query for a name for which it has verified exclusive
+ // ownership, for a type for which that name has no records, the responder MUST [...]
+ // respond asserting the nonexistence of that record"
+ if (hasFullyOwnedNameMatch && !hasKnownAnswer) {
+ additionalAnswerRecords.add(new MdnsNsecRecord(
+ question.getName(),
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ // TODO: RFC6762 6.1: "In general, the TTL given for an NSEC record SHOULD
+ // be the same as the TTL that the record would have had, had it existed."
+ NAME_RECORDS_TTL_MILLIS,
+ question.getName(),
+ new int[] { question.getType() }));
+ }
+
+ // No more records to add if no answer
+ if (answerInfo.size() == answersStartIndex) return;
+
+ final List<RecordInfo<?>> additionalAnswerInfo = new ArrayList<>();
+ // RFC6763 12.1: if including PTR record, include the SRV and TXT records it names
+ if (hasDnsSdPtrRecordAnswer) {
+ if (serviceTxtRecord != null) {
+ additionalAnswerInfo.add(serviceTxtRecord);
+ }
+ if (serviceSrvRecord != null) {
+ additionalAnswerInfo.add(serviceSrvRecord);
+ }
+ }
+
+ // RFC6763 12.1&.2: if including PTR or SRV record, include the address records it names
+ if (hasDnsSdPtrRecordAnswer || hasDnsSdSrvRecordAnswer) {
+ for (RecordInfo<?> record : mGeneralRecords) {
+ if (record.record instanceof MdnsInetAddressRecord) {
+ additionalAnswerInfo.add(record);
+ }
+ }
+ }
+
+ for (RecordInfo<?> info : additionalAnswerInfo) {
+ additionalAnswerRecords.add(info.record);
+ }
+
+ // RFC6762 6.1: negative responses
+ addNsecRecordsForUniqueNames(additionalAnswerRecords,
+ answerInfo.listIterator(answersStartIndex),
+ additionalAnswerInfo.listIterator());
+ }
+
+ /**
+ * Add NSEC records indicating that the response records are unique.
+ *
+ * Following RFC6762 6.1:
+ * "On receipt of a question for a particular name, rrtype, and rrclass, for which a responder
+ * does have one or more unique answers, the responder MAY also include an NSEC record in the
+ * Additional Record Section indicating the nonexistence of other rrtypes for that name and
+ * rrclass."
+ * @param destinationList List to add the NSEC records to.
+ * @param answerRecords Lists of answered records based on which to add NSEC records (typically
+ * answer and additionalAnswer sections)
+ */
+ @SafeVarargs
+ private static void addNsecRecordsForUniqueNames(
+ List<MdnsRecord> destinationList,
+ Iterator<RecordInfo<?>>... answerRecords) {
+ // Group unique records by name. Use a TreeMap with comparator as arrays don't implement
+ // equals / hashCode.
+ final Map<String[], List<MdnsRecord>> nsecByName = new TreeMap<>(Arrays::compare);
+ // But keep the list of names in added order, otherwise records would be sorted in
+ // alphabetical order instead of the order of the original records, which would look like
+ // inconsistent behavior depending on service name.
+ final List<String[]> namesInAddedOrder = new ArrayList<>();
+ for (Iterator<RecordInfo<?>> answers : answerRecords) {
+ addNonSharedRecordsToMap(answers, nsecByName, namesInAddedOrder);
+ }
+
+ for (String[] nsecName : namesInAddedOrder) {
+ final List<MdnsRecord> entryRecords = nsecByName.get(nsecName);
+ long minTtl = Long.MAX_VALUE;
+ final Set<Integer> types = new ArraySet<>(entryRecords.size());
+ for (MdnsRecord record : entryRecords) {
+ if (minTtl > record.getTtl()) minTtl = record.getTtl();
+ types.add(record.getType());
+ }
+
+ destinationList.add(new MdnsNsecRecord(
+ nsecName,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ minTtl,
+ nsecName,
+ CollectionUtils.toIntArray(types)));
+ }
+ }
+
+ /**
+ * Add non-shared records to a map listing them by record name, and to a list of names that
+ * remembers the adding order.
+ *
+ * In the destination map records are grouped by name; so the map has one key per record name,
+ * and the values are the lists of different records that share the same name.
+ * @param records Records to scan.
+ * @param dest Map to add the records to.
+ * @param namesInAddedOrder List of names to add the names in order, keeping the first
+ * occurrence of each name.
+ */
+ private static void addNonSharedRecordsToMap(
+ Iterator<RecordInfo<?>> records,
+ Map<String[], List<MdnsRecord>> dest,
+ List<String[]> namesInAddedOrder) {
+ while (records.hasNext()) {
+ final RecordInfo<?> record = records.next();
+ if (record.isSharedName) continue;
+ final List<MdnsRecord> recordsForName = dest.computeIfAbsent(record.record.name,
+ key -> {
+ namesInAddedOrder.add(key);
+ return new ArrayList<>();
+ });
+ recordsForName.add(record.record);
+ }
+ }
+
+ /**
+ * Called to indicate that probing succeeded for a service.
+ * @param probeSuccessInfo The successful probing info.
+ * @return The {@link MdnsAnnouncer.AnnouncementInfo} to send, now that probing has succeeded.
+ */
+ public MdnsAnnouncer.AnnouncementInfo onProbingSucceeded(
+ MdnsProber.ProbingInfo probeSuccessInfo)
+ throws IOException {
+
+ final ServiceRegistration registration = mServices.get(probeSuccessInfo.getServiceId());
+ if (registration == null) throw new IOException(
+ "Service is not registered: " + probeSuccessInfo.getServiceId());
+ registration.setProbing(false);
+
+ final ArrayList<MdnsRecord> answers = new ArrayList<>();
+ final ArrayList<MdnsRecord> additionalAnswers = new ArrayList<>();
+
+ // Interface address records in general records
+ for (RecordInfo<?> record : mGeneralRecords) {
+ answers.add(record.record);
+ }
+
+ // All service records
+ for (RecordInfo<?> info : registration.allRecords) {
+ answers.add(info.record);
+ }
+
+ addNsecRecordsForUniqueNames(additionalAnswers,
+ mGeneralRecords.iterator(), registration.allRecords.iterator());
+
+ return new MdnsAnnouncer.AnnouncementInfo(probeSuccessInfo.getServiceId(),
+ answers, additionalAnswers);
+ }
+
+ /**
+ * Get the service IDs of services conflicting with a received packet.
+ */
+ public Set<Integer> getConflictingServices(MdnsPacket packet) {
+ // Avoid allocating a new set for each incoming packet: use an empty set by default.
+ Set<Integer> conflicting = Collections.emptySet();
+ for (MdnsRecord record : packet.answers) {
+ for (int i = 0; i < mServices.size(); i++) {
+ final ServiceRegistration registration = mServices.valueAt(i);
+ if (registration.exiting) continue;
+
+ // Only look for conflicts in service name, as a different service name can be used
+ // if there is a conflict, but there is nothing actionable if any other conflict
+ // happens. In fact probing is only done for the service name in the SRV record.
+ // This means only SRV and TXT records need to be checked.
+ final RecordInfo<MdnsServiceRecord> srvRecord = registration.srvRecord;
+ if (!Arrays.equals(record.getName(), srvRecord.record.getName())) continue;
+
+ // As per RFC6762 9., it's fine if the "conflict" is an identical record with same
+ // data.
+ if (record instanceof MdnsServiceRecord) {
+ final MdnsServiceRecord local = srvRecord.record;
+ final MdnsServiceRecord other = (MdnsServiceRecord) record;
+ // Note "equals" does not consider TTL or receipt time, as intended here
+ if (Objects.equals(local, other)) {
+ continue;
+ }
+ }
+
+ if (record instanceof MdnsTextRecord) {
+ final MdnsTextRecord local = registration.txtRecord.record;
+ final MdnsTextRecord other = (MdnsTextRecord) record;
+ if (Objects.equals(local, other)) {
+ continue;
+ }
+ }
+
+ if (conflicting.size() == 0) {
+ // Conflict was found: use a mutable set
+ conflicting = new ArraySet<>();
+ }
+ final int serviceId = mServices.keyAt(i);
+ conflicting.add(serviceId);
+ }
+ }
+
+ return conflicting;
+ }
+
+ /**
+ * (Re)set a service to the probing state.
+ * @return The {@link MdnsProber.ProbingInfo} to send for probing.
+ */
+ @Nullable
+ public MdnsProber.ProbingInfo setServiceProbing(int serviceId) {
+ final ServiceRegistration registration = mServices.get(serviceId);
+ if (registration == null) return null;
+
+ registration.setProbing(true);
+ return makeProbingInfo(serviceId, registration.srvRecord.record);
+ }
+
+ /**
+ * Indicates whether a given service is in probing state.
+ */
+ public boolean isProbing(int serviceId) {
+ final ServiceRegistration registration = mServices.get(serviceId);
+ if (registration == null) return false;
+
+ return registration.srvRecord.isProbing;
+ }
+
+ /**
+ * Return whether the repository has an active (non-exiting) service for the given ID.
+ */
+ public boolean hasActiveService(int serviceId) {
+ final ServiceRegistration registration = mServices.get(serviceId);
+ if (registration == null) return false;
+
+ return !registration.exiting;
+ }
+
+ /**
+ * Rename a service to the newly provided info, following a conflict.
+ *
+ * If the specified service does not exist, this returns null.
+ */
+ @Nullable
+ public MdnsProber.ProbingInfo renameServiceForConflict(int serviceId, NsdServiceInfo newInfo) {
+ if (!mServices.contains(serviceId)) return null;
+
+ final ServiceRegistration newService = new ServiceRegistration(
+ mDeviceHostname, newInfo);
+ mServices.put(serviceId, newService);
+ return makeProbingInfo(serviceId, newService.srvRecord.record);
+ }
+
+ /**
+ * Called when {@link MdnsAdvertiser} sent an advertisement for the given service.
+ */
+ public void onAdvertisementSent(int serviceId) {
+ final ServiceRegistration registration = mServices.get(serviceId);
+ if (registration == null) return;
+
+ final long now = SystemClock.elapsedRealtime();
+ for (RecordInfo<?> record : registration.allRecords) {
+ record.lastSentTimeMs = now;
+ record.lastAdvertisedTimeMs = now;
+ }
+ }
+
+ /**
+ * Compute:
+ * 2001:db8::1 --> 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.B.D.0.1.0.0.2.ip6.arpa
+ *
+ * Or:
+ * 192.0.2.123 --> 123.2.0.192.in-addr.arpa
+ */
+ @VisibleForTesting
+ public static String[] getReverseDnsAddress(@NonNull InetAddress addr) {
+ // xxx.xxx.xxx.xxx.in-addr.arpa (up to 28 characters)
+ // or 32 hex characters separated by dots + .ip6.arpa
+ final byte[] addrBytes = addr.getAddress();
+ final List<String> out = new ArrayList<>();
+ if (addr instanceof Inet4Address) {
+ for (int i = addrBytes.length - 1; i >= 0; i--) {
+ out.add(String.valueOf(Byte.toUnsignedInt(addrBytes[i])));
+ }
+ out.add("in-addr");
+ } else {
+ final String hexAddr = HexDump.toHexString(addrBytes);
+
+ for (int i = hexAddr.length() - 1; i >= 0; i--) {
+ out.add(String.valueOf(hexAddr.charAt(i)));
+ }
+ out.add("ip6");
+ }
+ out.add("arpa");
+
+ return out.toArray(new String[0]);
+ }
+
+ private static String[] splitFullyQualifiedName(
+ @NonNull NsdServiceInfo info, @NonNull String[] serviceType) {
+ final String[] split = new String[serviceType.length + 1];
+ split[0] = info.getServiceName();
+ System.arraycopy(serviceType, 0, split, 1, serviceType.length);
+
+ return split;
+ }
+
+ private static String[] splitServiceType(@NonNull NsdServiceInfo info) {
+ // String.split(pattern, 0) removes trailing empty strings, which would appear when
+ // splitting "domain.name." (with a dot a the end), so this is what is needed here.
+ final String[] split = info.getServiceType().split("\\.", 0);
+ final String[] type = new String[split.length + 1];
+ System.arraycopy(split, 0, type, 0, split.length);
+ type[split.length] = LOCAL_TLD;
+
+ return type;
+ }
+}
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsReplySender.java b/service-t/src/com/android/server/connectivity/mdns/MdnsReplySender.java
similarity index 61%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsReplySender.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsReplySender.java
index c6b8f47..f1389ca 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsReplySender.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsReplySender.java
@@ -16,8 +16,15 @@
package com.android.server.connectivity.mdns;
+import static com.android.server.connectivity.mdns.MdnsSocketProvider.ensureRunningOnHandlerThread;
+
import android.annotation.NonNull;
+import android.os.Handler;
import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+
+import com.android.server.connectivity.mdns.MdnsRecordRepository.ReplyInfo;
import java.io.IOException;
import java.net.DatagramPacket;
@@ -25,6 +32,7 @@
import java.net.Inet6Address;
import java.net.InetSocketAddress;
import java.net.MulticastSocket;
+import java.util.Collections;
/**
* A class that handles sending mDNS replies to a {@link MulticastSocket}, possibly queueing them
@@ -33,30 +41,46 @@
* TODO: implement sending after a delay, combining queued replies and duplicate answer suppression
*/
public class MdnsReplySender {
+ private static final boolean DBG = MdnsAdvertiser.DBG;
+ private static final int MSG_SEND = 1;
+
+ private final String mLogTag;
@NonNull
private final MdnsInterfaceSocket mSocket;
@NonNull
- private final Looper mLooper;
+ private final Handler mHandler;
@NonNull
private final byte[] mPacketCreationBuffer;
- public MdnsReplySender(@NonNull Looper looper,
+ public MdnsReplySender(@NonNull String interfaceTag, @NonNull Looper looper,
@NonNull MdnsInterfaceSocket socket, @NonNull byte[] packetCreationBuffer) {
- mLooper = looper;
+ mHandler = new SendHandler(looper);
+ mLogTag = MdnsReplySender.class.getSimpleName() + "/" + interfaceTag;
mSocket = socket;
mPacketCreationBuffer = packetCreationBuffer;
}
/**
+ * Queue a reply to be sent when its send delay expires.
+ */
+ public void queueReply(@NonNull ReplyInfo reply) {
+ ensureRunningOnHandlerThread(mHandler);
+ // TODO: implement response aggregation (RFC 6762 6.4)
+ mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_SEND, reply), reply.sendDelayMs);
+
+ if (DBG) {
+ Log.v(mLogTag, "Scheduling " + reply);
+ }
+ }
+
+ /**
* Send a packet immediately.
*
* Must be called on the looper thread used by the {@link MdnsReplySender}.
*/
public void sendNow(@NonNull MdnsPacket packet, @NonNull InetSocketAddress destination)
throws IOException {
- if (Thread.currentThread() != mLooper.getThread()) {
- throw new IllegalStateException("sendNow must be called in the handler thread");
- }
+ ensureRunningOnHandlerThread(mHandler);
if (!((destination.getAddress() instanceof Inet6Address && mSocket.hasJoinedIpv6())
|| (destination.getAddress() instanceof Inet4Address && mSocket.hasJoinedIpv4()))) {
// Skip sending if the socket has not joined the v4/v6 group (there was no address)
@@ -93,4 +117,37 @@
mSocket.send(new DatagramPacket(outBuffer, 0, len, destination));
}
+
+ /**
+ * Cancel all pending sends.
+ */
+ public void cancelAll() {
+ ensureRunningOnHandlerThread(mHandler);
+ mHandler.removeMessages(MSG_SEND);
+ }
+
+ private class SendHandler extends Handler {
+ SendHandler(@NonNull Looper looper) {
+ super(looper);
+ }
+
+ @Override
+ public void handleMessage(@NonNull Message msg) {
+ final ReplyInfo replyInfo = (ReplyInfo) msg.obj;
+ if (DBG) Log.v(mLogTag, "Sending " + replyInfo);
+
+ final int flags = 0x8400; // Response, authoritative (rfc6762 18.4)
+ final MdnsPacket packet = new MdnsPacket(flags,
+ Collections.emptyList() /* questions */,
+ replyInfo.answers,
+ Collections.emptyList() /* authorityRecords */,
+ replyInfo.additionalAnswers);
+
+ try {
+ sendNow(packet, replyInfo.destination);
+ } catch (IOException e) {
+ Log.e(mLogTag, "Error sending MDNS response", e);
+ }
+ }
+ }
}
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsResponse.java b/service-t/src/com/android/server/connectivity/mdns/MdnsResponse.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsResponse.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsResponse.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsResponseDecoder.java b/service-t/src/com/android/server/connectivity/mdns/MdnsResponseDecoder.java
similarity index 69%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsResponseDecoder.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsResponseDecoder.java
index 50f2069..82da2e4 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsResponseDecoder.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsResponseDecoder.java
@@ -24,11 +24,9 @@
import com.android.server.connectivity.mdns.util.MdnsLogger;
import java.io.EOFException;
-import java.io.IOException;
import java.net.DatagramPacket;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.LinkedList;
import java.util.List;
/** A class that decodes mDNS responses from UDP packets. */
@@ -48,12 +46,6 @@
this.serviceType = serviceType;
}
- private static void skipMdnsRecord(MdnsPacketReader reader) throws IOException {
- reader.skip(2 + 4); // skip the class and TTL
- int dataLength = reader.readUInt16();
- reader.skip(dataLength);
- }
-
private static MdnsResponse findResponseWithPointer(
List<MdnsResponse> responses, String[] pointer) {
if (responses != null) {
@@ -120,7 +112,7 @@
int interfaceIndex, @Nullable Network network) {
MdnsPacketReader reader = new MdnsPacketReader(recvbuf, length);
- List<MdnsRecord> records;
+ final MdnsPacket mdnsPacket;
try {
reader.readUInt16(); // transaction ID (not used)
int flags = reader.readUInt16();
@@ -128,111 +120,25 @@
return MdnsResponseErrorCode.ERROR_NOT_RESPONSE_MESSAGE;
}
- int numQuestions = reader.readUInt16();
- int numAnswers = reader.readUInt16();
- int numAuthority = reader.readUInt16();
- int numRecords = reader.readUInt16();
-
- LOGGER.log(String.format(
- "num questions: %d, num answers: %d, num authority: %d, num records: %d",
- numQuestions, numAnswers, numAuthority, numRecords));
-
- if (numAnswers < 1) {
+ mdnsPacket = MdnsPacket.parseRecordsSection(reader, flags);
+ if (mdnsPacket.answers.size() < 1) {
return MdnsResponseErrorCode.ERROR_NO_ANSWERS;
}
-
- records = new LinkedList<>();
-
- for (int i = 0; i < (numAnswers + numAuthority + numRecords); ++i) {
- String[] name;
- try {
- name = reader.readLabels();
- } catch (IOException e) {
- LOGGER.e("Failed to read labels from mDNS response.", e);
- return MdnsResponseErrorCode.ERROR_READING_RECORD_NAME;
- }
- int type = reader.readUInt16();
-
- switch (type) {
- case MdnsRecord.TYPE_A: {
- try {
- records.add(new MdnsInetAddressRecord(name, MdnsRecord.TYPE_A, reader));
- } catch (IOException e) {
- LOGGER.e("Failed to read A record from mDNS response.", e);
- return MdnsResponseErrorCode.ERROR_READING_A_RDATA;
- }
- break;
- }
-
- case MdnsRecord.TYPE_AAAA: {
- try {
- // AAAA should only contain the IPv6 address.
- MdnsInetAddressRecord record =
- new MdnsInetAddressRecord(name, MdnsRecord.TYPE_AAAA, reader);
- if (record.getInet6Address() != null) {
- records.add(record);
- }
- } catch (IOException e) {
- LOGGER.e("Failed to read AAAA record from mDNS response.", e);
- return MdnsResponseErrorCode.ERROR_READING_AAAA_RDATA;
- }
- break;
- }
-
- case MdnsRecord.TYPE_PTR: {
- try {
- records.add(new MdnsPointerRecord(name, reader));
- } catch (IOException e) {
- LOGGER.e("Failed to read PTR record from mDNS response.", e);
- return MdnsResponseErrorCode.ERROR_READING_PTR_RDATA;
- }
- break;
- }
-
- case MdnsRecord.TYPE_SRV: {
- if (name.length == 4) {
- try {
- records.add(new MdnsServiceRecord(name, reader));
- } catch (IOException e) {
- LOGGER.e("Failed to read SRV record from mDNS response.", e);
- return MdnsResponseErrorCode.ERROR_READING_SRV_RDATA;
- }
- } else {
- try {
- skipMdnsRecord(reader);
- } catch (IOException e) {
- LOGGER.e("Failed to skip SVR record from mDNS response.", e);
- return MdnsResponseErrorCode.ERROR_SKIPPING_SRV_RDATA;
- }
- }
- break;
- }
-
- case MdnsRecord.TYPE_TXT: {
- try {
- records.add(new MdnsTextRecord(name, reader));
- } catch (IOException e) {
- LOGGER.e("Failed to read TXT record from mDNS response.", e);
- return MdnsResponseErrorCode.ERROR_READING_TXT_RDATA;
- }
- break;
- }
-
- default: {
- try {
- skipMdnsRecord(reader);
- } catch (IOException e) {
- LOGGER.e("Failed to skip mDNS record.", e);
- return MdnsResponseErrorCode.ERROR_SKIPPING_UNKNOWN_RECORD;
- }
- }
- }
- }
} catch (EOFException e) {
LOGGER.e("Reached the end of the mDNS response unexpectedly.", e);
return MdnsResponseErrorCode.ERROR_END_OF_FILE;
+ } catch (MdnsPacket.ParseException e) {
+ LOGGER.e(e.getMessage(), e);
+ return e.code;
}
+ final ArrayList<MdnsRecord> records = new ArrayList<>(
+ mdnsPacket.questions.size() + mdnsPacket.answers.size()
+ + mdnsPacket.authorityRecords.size() + mdnsPacket.additionalRecords.size());
+ records.addAll(mdnsPacket.answers);
+ records.addAll(mdnsPacket.authorityRecords);
+ records.addAll(mdnsPacket.additionalRecords);
+
// The response records are structured in a hierarchy, where some records reference
// others, as follows:
//
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsResponseErrorCode.java b/service-t/src/com/android/server/connectivity/mdns/MdnsResponseErrorCode.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsResponseErrorCode.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsResponseErrorCode.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsSearchOptions.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSearchOptions.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsSearchOptions.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsSearchOptions.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsServiceBrowserListener.java b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceBrowserListener.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsServiceBrowserListener.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsServiceBrowserListener.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsServiceInfo.java b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceInfo.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsServiceInfo.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsServiceInfo.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsServiceRecord.java b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceRecord.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsServiceRecord.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsServiceRecord.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsSocket.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSocket.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsSocket.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsSocket.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsSocketClient.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClient.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsSocketClient.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsSocketClient.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsSocketClientBase.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClientBase.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsSocketClientBase.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsSocketClientBase.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsSocketProvider.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketProvider.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsSocketProvider.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsSocketProvider.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsTextRecord.java b/service-t/src/com/android/server/connectivity/mdns/MdnsTextRecord.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MdnsTextRecord.java
rename to service-t/src/com/android/server/connectivity/mdns/MdnsTextRecord.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MulticastNetworkInterfaceProvider.java b/service-t/src/com/android/server/connectivity/mdns/MulticastNetworkInterfaceProvider.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/MulticastNetworkInterfaceProvider.java
rename to service-t/src/com/android/server/connectivity/mdns/MulticastNetworkInterfaceProvider.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/MulticastPacketReader.java b/service-t/src/com/android/server/connectivity/mdns/MulticastPacketReader.java
similarity index 92%
rename from service/mdns/com/android/server/connectivity/mdns/MulticastPacketReader.java
rename to service-t/src/com/android/server/connectivity/mdns/MulticastPacketReader.java
index 20cc47f..b597f0a 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MulticastPacketReader.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MulticastPacketReader.java
@@ -107,5 +107,14 @@
ensureRunningOnHandlerThread(mHandler);
mPacketHandlers.add(handler);
}
+
+ /**
+ * Remove a packet handler added via {@link #addPacketHandler}. If the handler was not set,
+ * this is a no-op.
+ */
+ public void removePacketHandler(@NonNull PacketHandler handler) {
+ ensureRunningOnHandlerThread(mHandler);
+ mPacketHandlers.remove(handler);
+ }
}
diff --git a/service/mdns/com/android/server/connectivity/mdns/NameConflictException.java b/service-t/src/com/android/server/connectivity/mdns/NameConflictException.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/NameConflictException.java
rename to service-t/src/com/android/server/connectivity/mdns/NameConflictException.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/NetworkInterfaceWrapper.java b/service-t/src/com/android/server/connectivity/mdns/NetworkInterfaceWrapper.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/NetworkInterfaceWrapper.java
rename to service-t/src/com/android/server/connectivity/mdns/NetworkInterfaceWrapper.java
diff --git a/service/mdns/com/android/server/connectivity/mdns/util/MdnsLogger.java b/service-t/src/com/android/server/connectivity/mdns/util/MdnsLogger.java
similarity index 100%
rename from service/mdns/com/android/server/connectivity/mdns/util/MdnsLogger.java
rename to service-t/src/com/android/server/connectivity/mdns/util/MdnsLogger.java
diff --git a/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java b/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java
index 51683de..60485f1 100644
--- a/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java
+++ b/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java
@@ -657,7 +657,17 @@
}
void restart() {
- if (DBG) Log.d(TAG, "reconnecting Ethernet");
+ if (DBG) Log.d(TAG, "restart IpClient");
+
+ if (mIpClient == null) {
+ // If restart() is called from a provisioning failure, it is
+ // possible that link disappeared in the meantime. In that
+ // case, stop() has already been called and IpClient should not
+ // get restarted to prevent a provisioning failure loop.
+ Log.i(TAG, String.format("restart() was called on stopped interface %s", name));
+ return;
+ }
+
stop();
start();
}
diff --git a/service-t/src/com/android/server/net/NetworkStatsFactory.java b/service-t/src/com/android/server/net/NetworkStatsFactory.java
index 8161f50..e0abdf1 100644
--- a/service-t/src/com/android/server/net/NetworkStatsFactory.java
+++ b/service-t/src/com/android/server/net/NetworkStatsFactory.java
@@ -200,16 +200,6 @@
}
/**
- * Parse and return interface-level summary {@link NetworkStats} measured
- * using {@code /proc/net/dev} style hooks, which may include non IP layer
- * traffic. Values monotonically increase since device boot, and may include
- * details about inactive interfaces.
- */
- public NetworkStats readNetworkStatsSummaryDev() throws IOException {
- return mDeps.getNetworkStatsDev();
- }
-
- /**
* Parse and return interface-level summary {@link NetworkStats}. Designed
* to return only IP layer traffic. Values monotonically increase since
* device boot, and may include details about inactive interfaces.
diff --git a/service-t/src/com/android/server/net/NetworkStatsService.java b/service-t/src/com/android/server/net/NetworkStatsService.java
index 6206d83..1606fd0 100644
--- a/service-t/src/com/android/server/net/NetworkStatsService.java
+++ b/service-t/src/com/android/server/net/NetworkStatsService.java
@@ -339,13 +339,11 @@
}
}
- Config getDevConfig();
Config getXtConfig();
Config getUidConfig();
Config getUidTagConfig();
long getGlobalAlertBytes(long def);
- long getDevPersistBytes(long def);
long getXtPersistBytes(long def);
long getUidPersistBytes(long def);
long getUidTagPersistBytes(long def);
@@ -395,8 +393,6 @@
private final Semaphore mStatsProviderSem = new Semaphore(0, true);
@GuardedBy("mStatsLock")
- private NetworkStatsRecorder mDevRecorder;
- @GuardedBy("mStatsLock")
private NetworkStatsRecorder mXtRecorder;
@GuardedBy("mStatsLock")
private NetworkStatsRecorder mUidRecorder;
@@ -541,6 +537,7 @@
BroadcastOptions.makeBasic())
.setDeliveryGroupPolicy(
ConstantsShim.DELIVERY_GROUP_POLICY_MOST_RECENT)
+ .setDeferUntilActive(true)
.toBundle();
} catch (UnsupportedApiLevelException e) {
Log.wtf(TAG, "Using unsupported API" + e);
@@ -864,8 +861,6 @@
mSystemReady = true;
// create data recorders along with historical rotators
- mDevRecorder = buildRecorder(PREFIX_DEV, mSettings.getDevConfig(), false, mStatsDir,
- true /* wipeOnError */);
mXtRecorder = buildRecorder(PREFIX_XT, mSettings.getXtConfig(), false, mStatsDir,
true /* wipeOnError */);
mUidRecorder = buildRecorder(PREFIX_UID, mSettings.getUidConfig(), false, mStatsDir,
@@ -963,7 +958,6 @@
final long currentTime = mClock.millis();
// persist any pending stats
- mDevRecorder.forcePersistLocked(currentTime);
mXtRecorder.forcePersistLocked(currentTime);
mUidRecorder.forcePersistLocked(currentTime);
mUidTagRecorder.forcePersistLocked(currentTime);
@@ -1030,8 +1024,17 @@
Log.i(TAG, "Starting import : attempts " + attempts + "/" + targetAttempts);
}
+ // Still create a legacy dev recorder locally but the service doesn't really use it.
+ // This is for backward compatibility where the OEMs might call readPlatformCollection to
+ // perform proprietary operations and relying on the side-effects to complete the follow-up
+ // import process.
+ final NetworkStatsSettings.Config devConfig =
+ new NetworkStatsSettings.Config(HOUR_IN_MILLIS,
+ 15 * DAY_IN_MILLIS, 90 * DAY_IN_MILLIS);
+ final NetworkStatsRecorder devRecorder = buildRecorder(PREFIX_DEV, devConfig,
+ false, mStatsDir, true /* wipeOnError */);
final MigrationInfo[] migrations = new MigrationInfo[]{
- new MigrationInfo(mDevRecorder), new MigrationInfo(mXtRecorder),
+ new MigrationInfo(devRecorder), new MigrationInfo(mXtRecorder),
new MigrationInfo(mUidRecorder), new MigrationInfo(mUidTagRecorder)
};
@@ -1041,9 +1044,10 @@
final File legacyBaseDir = mDeps.getLegacyStatsDir();
// Set wipeOnError flag false so the recorder won't damage persistent data if reads
// failed and calling deleteAll.
+ // Set DEV legacy recorder as null since the DEV recorder has been removed.
+ // Thus it doesn't need to build DEV legacy recorder for comparing with imported data.
legacyRecorders = new NetworkStatsRecorder[]{
- buildRecorder(PREFIX_DEV, mSettings.getDevConfig(), false, legacyBaseDir,
- false /* wipeOnError */),
+ null /* dev Recorder */,
buildRecorder(PREFIX_XT, mSettings.getXtConfig(), false, legacyBaseDir,
false /* wipeOnError */),
buildRecorder(PREFIX_UID, mSettings.getUidConfig(), false, legacyBaseDir,
@@ -1060,7 +1064,6 @@
// commit any data to disk until all are read.
for (int i = 0; i < migrations.length; i++) {
final MigrationInfo migration = migrations[i];
-
// Read the collection from platform code, and set fallbacks counter if throws
// for better debugging.
try {
@@ -1094,6 +1097,7 @@
// Find the latest end time.
for (final MigrationInfo migration : migrations) {
+ if (PREFIX_DEV.equals(migration.recorder.getCookie())) continue;
final long migrationEnd = migration.collection.getEndMillis();
if (migrationEnd > migrationEndTime) migrationEndTime = migrationEnd;
}
@@ -1110,7 +1114,8 @@
for (final MigrationInfo migration : migrations) {
migration.imported = true;
migration.recorder.removeDataBefore(migrationEndTime);
- if (migration.collection.isEmpty()) continue;
+ if (migration.collection.isEmpty()
+ || PREFIX_DEV.equals(migration.recorder.getCookie())) continue;
migration.recorder.importCollectionLocked(migration.collection);
}
@@ -1133,6 +1138,7 @@
if (migrationEndTime > Long.MIN_VALUE) {
try {
for (final MigrationInfo migration : migrations) {
+ if (PREFIX_DEV.equals(migration.recorder.getCookie())) continue;
if (migration.imported) {
migration.recorder.removeDataBefore(migrationEndTime);
}
@@ -1143,6 +1149,7 @@
// framework will reboot, and if there are remaining tries, the migration
// process will retry, which is fine because it's idempotent.
for (final MigrationInfo migration : migrations) {
+ if (PREFIX_DEV.equals(migration.recorder.getCookie())) continue;
migration.recorder.recoverAndDeleteData();
}
}
@@ -1196,11 +1203,14 @@
/**
* Compare imported data with the data returned by legacy recorders.
*
- * @return true if the data matches, false if the data does not match or throw with exceptions.
+ * @return true if the data matches or if {@code legacyRecorder} is null, false if the data
+ * does not match or throw with exceptions.
*/
private boolean compareImportedToLegacyStats(@NonNull MigrationInfo migration,
- @NonNull NetworkStatsRecorder legacyRecorder) {
+ @Nullable NetworkStatsRecorder legacyRecorder) {
final NetworkStatsCollection legacyStats;
+ // Skip the recorder that doesn't need to be compared.
+ if (legacyRecorder == null) return true;
try {
legacyStats = legacyRecorder.getOrLoadCompleteLocked();
} catch (Throwable e) {
@@ -1854,7 +1864,6 @@
updatePersistThresholdsLocked();
- mDevRecorder.maybePersistLocked(currentTime);
mXtRecorder.maybePersistLocked(currentTime);
mUidRecorder.maybePersistLocked(currentTime);
mUidTagRecorder.maybePersistLocked(currentTime);
@@ -1970,7 +1979,6 @@
*/
@GuardedBy("mStatsLock")
private void updatePersistThresholdsLocked() {
- mDevRecorder.setPersistThreshold(mSettings.getDevPersistBytes(mPersistThreshold));
mXtRecorder.setPersistThreshold(mSettings.getXtPersistBytes(mPersistThreshold));
mUidRecorder.setPersistThreshold(mSettings.getUidPersistBytes(mPersistThreshold));
mUidTagRecorder.setPersistThreshold(mSettings.getUidTagPersistBytes(mPersistThreshold));
@@ -2250,30 +2258,23 @@
@GuardedBy("mStatsLock")
private void recordSnapshotLocked(long currentTime) throws RemoteException {
// snapshot and record current counters; read UID stats first to
- // avoid over counting dev stats.
+ // avoid over counting xt stats.
Trace.traceBegin(TRACE_TAG_NETWORK, "snapshotUid");
final NetworkStats uidSnapshot = getNetworkStatsUidDetail(INTERFACES_ALL);
Trace.traceEnd(TRACE_TAG_NETWORK);
Trace.traceBegin(TRACE_TAG_NETWORK, "snapshotXt");
final NetworkStats xtSnapshot = readNetworkStatsSummaryXt();
Trace.traceEnd(TRACE_TAG_NETWORK);
- Trace.traceBegin(TRACE_TAG_NETWORK, "snapshotDev");
- final NetworkStats devSnapshot = readNetworkStatsSummaryDev();
- Trace.traceEnd(TRACE_TAG_NETWORK);
- // Snapshot for dev/xt stats from all custom stats providers. Counts per-interface data
- // from stats providers that isn't already counted by dev and XT stats.
+ // Snapshot for xt stats from all custom stats providers. Counts per-interface data
+ // from stats providers that isn't already counted by XT stats.
Trace.traceBegin(TRACE_TAG_NETWORK, "snapshotStatsProvider");
final NetworkStats providersnapshot = getNetworkStatsFromProviders(STATS_PER_IFACE);
Trace.traceEnd(TRACE_TAG_NETWORK);
xtSnapshot.combineAllValues(providersnapshot);
- devSnapshot.combineAllValues(providersnapshot);
- // For xt/dev, we pass a null VPN array because usage is aggregated by UID, so VPN traffic
+ // For xt, we pass a null VPN array because usage is aggregated by UID, so VPN traffic
// can't be reattributed to responsible apps.
- Trace.traceBegin(TRACE_TAG_NETWORK, "recordDev");
- mDevRecorder.recordSnapshotLocked(devSnapshot, mActiveIfaces, currentTime);
- Trace.traceEnd(TRACE_TAG_NETWORK);
Trace.traceBegin(TRACE_TAG_NETWORK, "recordXt");
mXtRecorder.recordSnapshotLocked(xtSnapshot, mActiveIfaces, currentTime);
Trace.traceEnd(TRACE_TAG_NETWORK);
@@ -2353,13 +2354,11 @@
// persist any pending data depending on requested flags
Trace.traceBegin(TRACE_TAG_NETWORK, "[persisting]");
if (persistForce) {
- mDevRecorder.forcePersistLocked(currentTime);
mXtRecorder.forcePersistLocked(currentTime);
mUidRecorder.forcePersistLocked(currentTime);
mUidTagRecorder.forcePersistLocked(currentTime);
} else {
if (persistNetwork) {
- mDevRecorder.maybePersistLocked(currentTime);
mXtRecorder.maybePersistLocked(currentTime);
}
if (persistUid) {
@@ -2416,30 +2415,25 @@
final long currentTime = mClock.millis();
NetworkTemplate template;
- NetworkStats.Entry devTotal;
NetworkStats.Entry xtTotal;
NetworkStats.Entry uidTotal;
// collect mobile sample
template = new NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES).build();
- devTotal = mDevRecorder.getTotalSinceBootLocked(template);
xtTotal = mXtRecorder.getTotalSinceBootLocked(template);
uidTotal = mUidRecorder.getTotalSinceBootLocked(template);
EventLog.writeEvent(LOG_TAG_NETSTATS_MOBILE_SAMPLE,
- devTotal.rxBytes, devTotal.rxPackets, devTotal.txBytes, devTotal.txPackets,
xtTotal.rxBytes, xtTotal.rxPackets, xtTotal.txBytes, xtTotal.txPackets,
uidTotal.rxBytes, uidTotal.rxPackets, uidTotal.txBytes, uidTotal.txPackets,
currentTime);
// collect wifi sample
template = new NetworkTemplate.Builder(MATCH_WIFI).build();
- devTotal = mDevRecorder.getTotalSinceBootLocked(template);
xtTotal = mXtRecorder.getTotalSinceBootLocked(template);
uidTotal = mUidRecorder.getTotalSinceBootLocked(template);
EventLog.writeEvent(LOG_TAG_NETSTATS_WIFI_SAMPLE,
- devTotal.rxBytes, devTotal.rxPackets, devTotal.txBytes, devTotal.txPackets,
xtTotal.rxBytes, xtTotal.rxPackets, xtTotal.txBytes, xtTotal.txPackets,
uidTotal.rxBytes, uidTotal.rxPackets, uidTotal.txBytes, uidTotal.txPackets,
currentTime);
@@ -2741,7 +2735,12 @@
pw.println("Dev stats:");
pw.increaseIndent();
- mDevRecorder.dumpLocked(pw, fullHistory);
+ pw.println("Pending bytes: ");
+ if (fullHistory) {
+ pw.println("Complete history:");
+ } else {
+ pw.println("History since boot:");
+ }
pw.decreaseIndent();
pw.println("Xt stats:");
@@ -2801,7 +2800,6 @@
mActiveIfaces);
dumpInterfaces(proto, NetworkStatsServiceDumpProto.ACTIVE_UID_INTERFACES,
mActiveUidIfaces);
- mDevRecorder.dumpDebugLocked(proto, NetworkStatsServiceDumpProto.DEV_STATS);
mXtRecorder.dumpDebugLocked(proto, NetworkStatsServiceDumpProto.XT_STATS);
mUidRecorder.dumpDebugLocked(proto, NetworkStatsServiceDumpProto.UID_STATS);
mUidTagRecorder.dumpDebugLocked(proto,
@@ -2936,14 +2934,6 @@
});
}
- private NetworkStats readNetworkStatsSummaryDev() {
- try {
- return mStatsFactory.readNetworkStatsSummaryDev();
- } catch (IOException e) {
- throw new IllegalStateException(e);
- }
- }
-
private NetworkStats readNetworkStatsSummaryXt() {
try {
return mStatsFactory.readNetworkStatsSummaryXt();
@@ -3252,12 +3242,8 @@
return false;
}
@Override
- public Config getDevConfig() {
- return new Config(HOUR_IN_MILLIS, 15 * DAY_IN_MILLIS, 90 * DAY_IN_MILLIS);
- }
- @Override
public Config getXtConfig() {
- return getDevConfig();
+ return new Config(HOUR_IN_MILLIS, 15 * DAY_IN_MILLIS, 90 * DAY_IN_MILLIS);
}
@Override
public Config getUidConfig() {
@@ -3268,10 +3254,6 @@
return new Config(2 * HOUR_IN_MILLIS, 5 * DAY_IN_MILLIS, 15 * DAY_IN_MILLIS);
}
@Override
- public long getDevPersistBytes(long def) {
- return def;
- }
- @Override
public long getXtPersistBytes(long def) {
return def;
}
@@ -3288,4 +3270,7 @@
private static native long nativeGetTotalStat(int type);
private static native long nativeGetIfaceStat(String iface, int type);
private static native long nativeGetUidStat(int uid, int type);
+
+ /** Initializes and registers the Perfetto Network Trace data source */
+ public static native void nativeInitNetworkTracing();
}
diff --git a/service/Android.bp b/service/Android.bp
index 8fa6436..c8d2fdd 100644
--- a/service/Android.bp
+++ b/service/Android.bp
@@ -195,27 +195,6 @@
],
}
-// TODO: Remove this temporary library and put code into module when test coverage is enough.
-java_library {
- name: "service-mdns",
- sdk_version: "system_server_current",
- min_sdk_version: "30",
- srcs: [
- "mdns/**/*.java",
- ],
- libs: [
- "framework-annotations-lib",
- "framework-connectivity-pre-jarjar",
- "framework-connectivity-t-pre-jarjar",
- "framework-tethering",
- "framework-wifi",
- "service-connectivity-pre-jarjar",
- ],
- visibility: [
- "//packages/modules/Connectivity/tests:__subpackages__",
- ],
-}
-
java_library {
name: "service-connectivity-protos",
sdk_version: "system_current",
diff --git a/service/jni/com_android_server_connectivity_ClatCoordinator.cpp b/service/jni/com_android_server_connectivity_ClatCoordinator.cpp
index 18d2311..7060958 100644
--- a/service/jni/com_android_server_connectivity_ClatCoordinator.cpp
+++ b/service/jni/com_android_server_connectivity_ClatCoordinator.cpp
@@ -19,6 +19,7 @@
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
+#include <linux/if_packet.h>
#include <linux/if_tun.h>
#include <linux/ioctl.h>
#include <log/log.h>
@@ -36,9 +37,6 @@
#include "libclat/clatutils.h"
#include "nativehelper/scoped_utf_chars.h"
-// Sync from system/netd/include/netid_client.h
-#define MARK_UNSET 0u
-
// Sync from system/netd/server/NetdConstants.h
#define __INT_STRLEN(i) sizeof(#i)
#define _INT_STRLEN(i) __INT_STRLEN(i)
@@ -184,6 +182,12 @@
throwIOException(env, "packet socket failed", errno);
return -1;
}
+ int on = 1;
+ if (setsockopt(sock, SOL_PACKET, PACKET_AUXDATA, &on, sizeof(on))) {
+ throwIOException(env, "packet socket auxdata enablement failed", errno);
+ close(sock);
+ return -1;
+ }
return sock;
}
@@ -197,7 +201,7 @@
}
// TODO: check the mark validation
- if (mark != MARK_UNSET && setsockopt(sock, SOL_SOCKET, SO_MARK, &mark, sizeof(mark)) < 0) {
+ if (setsockopt(sock, SOL_SOCKET, SO_MARK, &mark, sizeof(mark)) < 0) {
throwIOException(env, "could not set mark on raw socket", errno);
close(sock);
return -1;
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsPacket.java b/service/mdns/com/android/server/connectivity/mdns/MdnsPacket.java
deleted file mode 100644
index eae084a..0000000
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsPacket.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.server.connectivity.mdns;
-
-import java.util.Collections;
-import java.util.List;
-
-/**
- * A class holding data that can be included in a mDNS packet.
- */
-public class MdnsPacket {
- public final int flags;
- public final List<MdnsRecord> questions;
- public final List<MdnsRecord> answers;
- public final List<MdnsRecord> authorityRecords;
- public final List<MdnsRecord> additionalRecords;
-
- MdnsPacket(int flags,
- List<MdnsRecord> questions,
- List<MdnsRecord> answers,
- List<MdnsRecord> authorityRecords,
- List<MdnsRecord> additionalRecords) {
- this.flags = flags;
- this.questions = Collections.unmodifiableList(questions);
- this.answers = Collections.unmodifiableList(answers);
- this.authorityRecords = Collections.unmodifiableList(authorityRecords);
- this.additionalRecords = Collections.unmodifiableList(additionalRecords);
- }
-}
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsRecordRepository.java b/service/mdns/com/android/server/connectivity/mdns/MdnsRecordRepository.java
deleted file mode 100644
index bb9c751..0000000
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsRecordRepository.java
+++ /dev/null
@@ -1,393 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.server.connectivity.mdns;
-
-import android.annotation.NonNull;
-import android.annotation.Nullable;
-import android.net.LinkAddress;
-import android.net.nsd.NsdServiceInfo;
-import android.os.Looper;
-import android.util.SparseArray;
-
-import com.android.internal.annotations.VisibleForTesting;
-
-import java.io.IOException;
-import java.net.InetAddress;
-import java.net.NetworkInterface;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Enumeration;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.TimeUnit;
-
-/**
- * A repository of records advertised through {@link MdnsInterfaceAdvertiser}.
- *
- * Must be used on a consistent looper thread.
- */
-public class MdnsRecordRepository {
- // TTLs as per RFC6762 10.
- // TTL for records with a host name as the resource record's name (e.g., A, AAAA, HINFO) or a
- // host name contained within the resource record's rdata (e.g., SRV, reverse mapping PTR
- // record)
- private static final long NAME_RECORDS_TTL_MILLIS = TimeUnit.SECONDS.toMillis(120);
- // TTL for other records
- private static final long NON_NAME_RECORDS_TTL_MILLIS = TimeUnit.MINUTES.toMillis(75);
-
- // Top-level domain for link-local queries, as per RFC6762 3.
- private static final String LOCAL_TLD = "local";
-
- // Service type for service enumeration (RFC6763 9.)
- private static final String[] DNS_SD_SERVICE_TYPE =
- new String[] { "_services", "_dns-sd", "_udp", LOCAL_TLD };
-
- // Map of service unique ID -> records for service
- @NonNull
- private final SparseArray<ServiceRegistration> mServices = new SparseArray<>();
- @NonNull
- private final Looper mLooper;
- @NonNull
- private String[] mDeviceHostname;
-
- public MdnsRecordRepository(@NonNull Looper looper) {
- this(looper, new Dependencies());
- }
-
- @VisibleForTesting
- public MdnsRecordRepository(@NonNull Looper looper, @NonNull Dependencies deps) {
- mDeviceHostname = deps.getHostname();
- mLooper = looper;
- }
-
- /**
- * Dependencies to use with {@link MdnsRecordRepository}, useful for testing.
- */
- @VisibleForTesting
- public static class Dependencies {
- /**
- * Get a unique hostname to be used by the device.
- */
- @NonNull
- public String[] getHostname() {
- // Generate a very-probably-unique hostname. This allows minimizing possible conflicts
- // to the point that probing for it is no longer necessary (as per RFC6762 8.1 last
- // paragraph), and does not leak more information than what could already be obtained by
- // looking at the mDNS packets source address.
- // This differs from historical behavior that just used "Android.local" for many
- // devices, creating a lot of conflicts.
- // Having a different hostname per interface is an acceptable option as per RFC6762 14.
- // This hostname will change every time the interface is reconnected, so this does not
- // allow tracking the device.
- // TODO: consider deriving a hostname from other sources, such as the IPv6 addresses
- // (reusing the same privacy-protecting mechanics).
- return new String[] {
- "Android_" + UUID.randomUUID().toString().replace("-", ""), LOCAL_TLD };
- }
-
- /**
- * @see NetworkInterface#getInetAddresses().
- */
- @NonNull
- public Enumeration<InetAddress> getInterfaceInetAddresses(@NonNull NetworkInterface iface) {
- return iface.getInetAddresses();
- }
- }
-
- private static class RecordInfo<T extends MdnsRecord> {
- public final T record;
- public final NsdServiceInfo serviceInfo;
-
- /**
- * Whether the name of this record is expected to be fully owned by the service or may be
- * advertised by other hosts as well (shared).
- */
- public final boolean isSharedName;
-
- /**
- * Whether probing is still in progress for the record.
- */
- public boolean isProbing;
-
- RecordInfo(NsdServiceInfo serviceInfo, T record, boolean sharedName,
- boolean probing) {
- this.serviceInfo = serviceInfo;
- this.record = record;
- this.isSharedName = sharedName;
- this.isProbing = probing;
- }
- }
-
- private static class ServiceRegistration {
- @NonNull
- public final List<RecordInfo<?>> allRecords;
- @NonNull
- public final RecordInfo<MdnsPointerRecord> ptrRecord;
- @NonNull
- public final RecordInfo<MdnsServiceRecord> srvRecord;
- @NonNull
- public final RecordInfo<MdnsTextRecord> txtRecord;
- @NonNull
- public final NsdServiceInfo serviceInfo;
-
- /**
- * Whether the service is sending exit announcements and will be destroyed soon.
- */
- public boolean exiting = false;
-
- /**
- * Create a ServiceRegistration for dns-sd service registration (RFC6763).
- *
- * @param deviceHostname Hostname of the device (for the interface used)
- * @param serviceInfo Service to advertise
- */
- ServiceRegistration(@NonNull String[] deviceHostname, @NonNull NsdServiceInfo serviceInfo) {
- this.serviceInfo = serviceInfo;
-
- final String[] serviceType = splitServiceType(serviceInfo);
- final String[] serviceName = splitFullyQualifiedName(serviceInfo, serviceType);
-
- // Service PTR record
- ptrRecord = new RecordInfo<>(
- serviceInfo,
- new MdnsPointerRecord(
- serviceType,
- 0L /* receiptTimeMillis */,
- false /* cacheFlush */,
- NON_NAME_RECORDS_TTL_MILLIS,
- serviceName),
- true /* sharedName */, true /* probing */);
-
- srvRecord = new RecordInfo<>(
- serviceInfo,
- new MdnsServiceRecord(serviceName,
- 0L /* receiptTimeMillis */,
- true /* cacheFlush */,
- NAME_RECORDS_TTL_MILLIS, 0 /* servicePriority */, 0 /* serviceWeight */,
- serviceInfo.getPort(),
- deviceHostname),
- false /* sharedName */, true /* probing */);
-
- txtRecord = new RecordInfo<>(
- serviceInfo,
- new MdnsTextRecord(serviceName,
- 0L /* receiptTimeMillis */,
- true /* cacheFlush */, // Service name is verified unique after probing
- NON_NAME_RECORDS_TTL_MILLIS,
- attrsToTextEntries(serviceInfo.getAttributes())),
- false /* sharedName */, true /* probing */);
-
- final ArrayList<RecordInfo<?>> allRecords = new ArrayList<>(4);
- allRecords.add(ptrRecord);
- allRecords.add(srvRecord);
- allRecords.add(txtRecord);
- // Service type enumeration record (RFC6763 9.)
- allRecords.add(new RecordInfo<>(
- serviceInfo,
- new MdnsPointerRecord(
- DNS_SD_SERVICE_TYPE,
- 0L /* receiptTimeMillis */,
- false /* cacheFlush */,
- NON_NAME_RECORDS_TTL_MILLIS,
- serviceType),
- true /* sharedName */, true /* probing */));
-
- this.allRecords = Collections.unmodifiableList(allRecords);
- }
-
- void setProbing(boolean probing) {
- for (RecordInfo<?> info : allRecords) {
- info.isProbing = probing;
- }
- }
- }
-
- /**
- * Inform the repository of the latest interface addresses.
- */
- public void updateAddresses(@NonNull List<LinkAddress> newAddresses) {
- // TODO: implement to update addresses in records
- }
-
- /**
- * Add a service to the repository.
- *
- * This may remove/replace any existing service that used the name added but is exiting.
- * @param serviceId A unique service ID.
- * @param serviceInfo Service info to add.
- * @return If the added service replaced another with a matching name (which was exiting), the
- * ID of the replaced service.
- * @throws NameConflictException There is already a (non-exiting) service using the name.
- */
- public int addService(int serviceId, NsdServiceInfo serviceInfo) throws NameConflictException {
- if (mServices.contains(serviceId)) {
- throw new IllegalArgumentException(
- "Service ID must not be reused across registrations: " + serviceId);
- }
-
- final int existing = getServiceByName(serviceInfo.getServiceName());
- // It's OK to re-add a service that is exiting
- if (existing >= 0 && !mServices.get(existing).exiting) {
- throw new NameConflictException(existing);
- }
-
- final ServiceRegistration registration = new ServiceRegistration(
- mDeviceHostname, serviceInfo);
- mServices.put(serviceId, registration);
-
- // Remove existing exiting service
- mServices.remove(existing);
- return existing;
- }
-
- /**
- * @return The ID of the service identified by its name, or -1 if none.
- */
- private int getServiceByName(@NonNull String serviceName) {
- for (int i = 0; i < mServices.size(); i++) {
- final ServiceRegistration registration = mServices.valueAt(i);
- if (serviceName.equals(registration.serviceInfo.getServiceName())) {
- return mServices.keyAt(i);
- }
- }
- return -1;
- }
-
- private MdnsProber.ProbingInfo makeProbingInfo(int serviceId,
- @NonNull MdnsServiceRecord srvRecord) {
- final List<MdnsRecord> probingRecords = new ArrayList<>();
- // Probe with cacheFlush cleared; it is set when announcing, as it was verified unique:
- // RFC6762 10.2
- probingRecords.add(new MdnsServiceRecord(srvRecord.getName(),
- 0L /* receiptTimeMillis */,
- false /* cacheFlush */,
- srvRecord.getTtl(),
- srvRecord.getServicePriority(), srvRecord.getServiceWeight(),
- srvRecord.getServicePort(),
- srvRecord.getServiceHost()));
-
- return new MdnsProber.ProbingInfo(serviceId, probingRecords);
- }
-
- private static List<MdnsServiceInfo.TextEntry> attrsToTextEntries(Map<String, byte[]> attrs) {
- final List<MdnsServiceInfo.TextEntry> out = new ArrayList<>(attrs.size());
- for (Map.Entry<String, byte[]> attr : attrs.entrySet()) {
- out.add(new MdnsServiceInfo.TextEntry(attr.getKey(), attr.getValue()));
- }
- return out;
- }
-
- /**
- * Mark a service in the repository as exiting.
- * @param id ID of the service, used at registration time.
- * @return The exit announcement to indicate the service was removed, or null if not necessary.
- */
- @Nullable
- public MdnsAnnouncer.AnnouncementInfo exitService(int id) {
- final ServiceRegistration registration = mServices.get(id);
- if (registration == null) return null;
- if (registration.exiting) return null;
-
- registration.exiting = true;
-
- // TODO: implement
- return null;
- }
-
- /**
- * Remove a service from the repository
- */
- public void removeService(int id) {
- mServices.remove(id);
- }
-
- /**
- * @return The number of services currently held in the repository, including exiting services.
- */
- public int getServicesCount() {
- return mServices.size();
- }
-
- /**
- * Remove all services from the repository
- * @return IDs of the removed services
- */
- @NonNull
- public int[] clearServices() {
- final int[] ret = new int[mServices.size()];
- for (int i = 0; i < mServices.size(); i++) {
- ret[i] = mServices.keyAt(i);
- }
- mServices.clear();
- return ret;
- }
-
- /**
- * Called to indicate that probing succeeded for a service.
- * @param probeSuccessInfo The successful probing info.
- * @return The {@link MdnsAnnouncer.AnnouncementInfo} to send, now that probing has succeeded.
- */
- public MdnsAnnouncer.AnnouncementInfo onProbingSucceeded(
- MdnsProber.ProbingInfo probeSuccessInfo) throws IOException {
- // TODO: implement: set service as not probing anymore and generate announcements
- throw new IOException("Announcements not implemented");
- }
-
- /**
- * (Re)set a service to the probing state.
- * @return The {@link MdnsProber.ProbingInfo} to send for probing.
- */
- @Nullable
- public MdnsProber.ProbingInfo setServiceProbing(int serviceId) {
- final ServiceRegistration registration = mServices.get(serviceId);
- if (registration == null) return null;
-
- registration.setProbing(true);
- return makeProbingInfo(serviceId, registration.srvRecord.record);
- }
-
- /**
- * Indicates whether a given service is in probing state.
- */
- public boolean isProbing(int serviceId) {
- final ServiceRegistration registration = mServices.get(serviceId);
- if (registration == null) return false;
-
- return registration.srvRecord.isProbing;
- }
-
- private static String[] splitFullyQualifiedName(
- @NonNull NsdServiceInfo info, @NonNull String[] serviceType) {
- final String[] split = new String[serviceType.length + 1];
- split[0] = info.getServiceName();
- System.arraycopy(serviceType, 0, split, 1, serviceType.length);
-
- return split;
- }
-
- private static String[] splitServiceType(@NonNull NsdServiceInfo info) {
- // String.split(pattern, 0) removes trailing empty strings, which would appear when
- // splitting "domain.name." (with a dot a the end), so this is what is needed here.
- final String[] split = info.getServiceType().split("\\.", 0);
- final String[] type = new String[split.length + 1];
- System.arraycopy(split, 0, type, 0, split.length);
- type[split.length] = LOCAL_TLD;
-
- return type;
- }
-}
diff --git a/service/native/libs/libclat/clatutils.cpp b/service/native/libs/libclat/clatutils.cpp
index be86612..c6a9781 100644
--- a/service/native/libs/libclat/clatutils.cpp
+++ b/service/native/libs/libclat/clatutils.cpp
@@ -29,13 +29,6 @@
#include "checksum.h"
}
-// Sync from external/android-clat/clatd.h
-#define MAXMTU 65536
-#define PACKETLEN (MAXMTU + sizeof(struct tun_pi))
-
-// Sync from system/netd/include/netid_client.h.
-#define MARK_UNSET 0u
-
namespace android {
namespace net {
namespace clat {
@@ -132,7 +125,7 @@
// Socket's mark affects routing decisions (network selection)
// An fwmark is necessary for clat to bypass the VPN during initialization.
- if ((mark != MARK_UNSET) && setsockopt(s, SOL_SOCKET, SO_MARK, &mark, sizeof(mark))) {
+ if (setsockopt(s, SOL_SOCKET, SO_MARK, &mark, sizeof(mark))) {
int ret = errno;
ALOGE("setsockopt(SOL_SOCKET, SO_MARK) failed: %s", strerror(errno));
close(s);
@@ -180,7 +173,7 @@
}
// Socket's mark affects routing decisions (network selection)
- if ((mark != MARK_UNSET) && setsockopt(s, SOL_SOCKET, SO_MARK, &mark, sizeof(mark))) {
+ if (setsockopt(s, SOL_SOCKET, SO_MARK, &mark, sizeof(mark))) {
int ret = errno;
ALOGE("setsockopt(SOL_SOCKET, SO_MARK) failed: %s", strerror(errno));
close(s);
@@ -235,7 +228,7 @@
// Compare it against the first four bytes of our IPv6 address, in host byte order (BPF loads
// are always in host byte order). If it matches, continue with next instruction (JMP 0). If it
// doesn't match, jump ahead to statement that returns 0 (ignore packet). Repeat for the other
- // three words of the IPv6 address, and if they all match, return PACKETLEN (accept packet).
+ // three words of the IPv6 address, and if they all match, return full packet (accept packet).
BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 24),
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htonl(ipv6[0]), 0, 7),
BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 28),
@@ -244,7 +237,7 @@
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htonl(ipv6[2]), 0, 3),
BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 36),
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htonl(ipv6[3]), 0, 1),
- BPF_STMT(BPF_RET | BPF_K, PACKETLEN),
+ BPF_STMT(BPF_RET | BPF_K, 0xFFFFFFFF),
BPF_STMT(BPF_RET | BPF_K, 0),
};
// clang-format on
diff --git a/service/src/com/android/server/ConnectivityService.java b/service/src/com/android/server/ConnectivityService.java
index a7e6a2e..330a1da 100755
--- a/service/src/com/android/server/ConnectivityService.java
+++ b/service/src/com/android/server/ConnectivityService.java
@@ -269,6 +269,8 @@
import com.android.networkstack.apishim.common.BroadcastOptionsShim;
import com.android.networkstack.apishim.common.UnsupportedApiLevelException;
import com.android.server.connectivity.AutodestructReference;
+import com.android.server.connectivity.AutomaticOnOffKeepaliveTracker;
+import com.android.server.connectivity.AutomaticOnOffKeepaliveTracker.AutomaticOnOffKeepalive;
import com.android.server.connectivity.CarrierPrivilegeAuthenticator;
import com.android.server.connectivity.ClatCoordinator;
import com.android.server.connectivity.ConnectivityFlags;
@@ -407,8 +409,7 @@
private final MockableSystemProperties mSystemProperties;
- @VisibleForTesting
- protected final PermissionMonitor mPermissionMonitor;
+ private final PermissionMonitor mPermissionMonitor;
@VisibleForTesting
final RequestInfoPerUidCounter mNetworkRequestCounter;
@@ -843,7 +844,7 @@
private final LocationPermissionChecker mLocationPermissionChecker;
- private final KeepaliveTracker mKeepaliveTracker;
+ private final AutomaticOnOffKeepaliveTracker mKeepaliveTracker;
private final QosCallbackTracker mQosCallbackTracker;
private final NetworkNotificationManager mNotifier;
private final LingerMonitor mLingerMonitor;
@@ -1565,7 +1566,7 @@
mSettingsObserver = new SettingsObserver(mContext, mHandler);
registerSettingsCallbacks();
- mKeepaliveTracker = new KeepaliveTracker(mContext, mHandler);
+ mKeepaliveTracker = new AutomaticOnOffKeepaliveTracker(mContext, mHandler);
mNotifier = new NetworkNotificationManager(mContext, mTelephonyManager);
mQosCallbackTracker = new QosCallbackTracker(mHandler, mNetworkRequestCounter);
@@ -3081,6 +3082,7 @@
optsShim.setDeliveryGroupPolicy(ConstantsShim.DELIVERY_GROUP_POLICY_MOST_RECENT);
optsShim.setDeliveryGroupMatchingKey(ConnectivityManager.CONNECTIVITY_ACTION,
createDeliveryGroupKeyForConnectivityAction(info));
+ optsShim.setDeferUntilActive(true);
} catch (UnsupportedApiLevelException e) {
Log.wtf(TAG, "Using unsupported API" + e);
}
@@ -5544,9 +5546,40 @@
mKeepaliveTracker.handleStartKeepalive(msg);
break;
}
+ case NetworkAgent.CMD_MONITOR_AUTOMATIC_KEEPALIVE: {
+ final AutomaticOnOffKeepalive ki = (AutomaticOnOffKeepalive) msg.obj;
+
+ final Network network = ki.getNetwork();
+ boolean networkFound = false;
+ final ArrayList<NetworkAgentInfo> vpnsRunningOnThisNetwork = new ArrayList<>();
+ for (NetworkAgentInfo n : mNetworkAgentInfos) {
+ if (n.network.equals(network)) networkFound = true;
+ if (n.isVPN() && n.everConnected() && hasUnderlyingNetwork(n, network)) {
+ vpnsRunningOnThisNetwork.add(n);
+ }
+ }
+
+ // If the network no longer exists, then the keepalive should have been
+ // cleaned up already. There is no point trying to resume keepalives.
+ if (!networkFound) return;
+
+ if (!vpnsRunningOnThisNetwork.isEmpty()) {
+ mKeepaliveTracker.handleMonitorAutomaticKeepalive(ki,
+ // TODO: check all the VPNs running on top of this network
+ vpnsRunningOnThisNetwork.get(0).network.netId);
+ } else {
+ // If no VPN, then make sure the keepalive is running.
+ mKeepaliveTracker.handleMaybeResumeKeepalive(ki);
+ }
+ break;
+ }
// Sent by KeepaliveTracker to process an app request on the state machine thread.
case NetworkAgent.CMD_STOP_SOCKET_KEEPALIVE: {
NetworkAgentInfo nai = getNetworkAgentInfoForNetwork((Network) msg.obj);
+ if (nai == null) {
+ Log.e(TAG, "Attempt to stop keepalive on nonexistent network");
+ return;
+ }
int slot = msg.arg1;
int reason = msg.arg2;
mKeepaliveTracker.handleStopKeepalive(nai, slot, reason);
@@ -6217,9 +6250,7 @@
if (mOemNetworkPreferences.getNetworkPreferences().size() > 0) {
handleSetOemNetworkPreference(mOemNetworkPreferences, null);
}
- if (!mProfileNetworkPreferences.isEmpty()) {
- updateProfileAllowedNetworks();
- }
+ updateProfileAllowedNetworks();
}
private void onUserRemoved(@NonNull final UserHandle user) {
@@ -9788,20 +9819,23 @@
enforceKeepalivePermission();
mKeepaliveTracker.startNattKeepalive(
getNetworkAgentInfoForNetwork(network), null /* fd */,
- intervalSeconds, cb,
- srcAddr, srcPort, dstAddr, NattSocketKeepalive.NATT_PORT);
+ intervalSeconds, cb, srcAddr, srcPort, dstAddr, NattSocketKeepalive.NATT_PORT,
+ // Keep behavior of the deprecated method as it is. Set automaticOnOffKeepalives to
+ // false because there is no way and no plan to configure automaticOnOffKeepalives
+ // in this deprecated method.
+ false /* automaticOnOffKeepalives */);
}
@Override
public void startNattKeepaliveWithFd(Network network, ParcelFileDescriptor pfd, int resourceId,
int intervalSeconds, ISocketKeepaliveCallback cb, String srcAddr,
- String dstAddr) {
+ String dstAddr, boolean automaticOnOffKeepalives) {
try {
final FileDescriptor fd = pfd.getFileDescriptor();
mKeepaliveTracker.startNattKeepalive(
getNetworkAgentInfoForNetwork(network), fd, resourceId,
intervalSeconds, cb,
- srcAddr, dstAddr, NattSocketKeepalive.NATT_PORT);
+ srcAddr, dstAddr, NattSocketKeepalive.NATT_PORT, automaticOnOffKeepalives);
} finally {
// FileDescriptors coming from AIDL calls must be manually closed to prevent leaks.
// startNattKeepalive calls Os.dup(fd) before returning, so we can close immediately.
diff --git a/service/src/com/android/server/connectivity/AutomaticOnOffKeepaliveTracker.java b/service/src/com/android/server/connectivity/AutomaticOnOffKeepaliveTracker.java
new file mode 100644
index 0000000..46fff6c
--- /dev/null
+++ b/service/src/com/android/server/connectivity/AutomaticOnOffKeepaliveTracker.java
@@ -0,0 +1,720 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.connectivity;
+
+import static android.net.NetworkAgent.CMD_START_SOCKET_KEEPALIVE;
+import static android.net.SocketKeepalive.ERROR_INVALID_SOCKET;
+import static android.net.SocketKeepalive.SUCCESS;
+import static android.provider.DeviceConfig.NAMESPACE_CONNECTIVITY;
+import static android.system.OsConstants.AF_INET;
+import static android.system.OsConstants.AF_INET6;
+import static android.system.OsConstants.SOL_SOCKET;
+import static android.system.OsConstants.SO_SNDTIMEO;
+
+import static com.android.net.module.util.netlink.NetlinkConstants.NLMSG_DONE;
+import static com.android.net.module.util.netlink.NetlinkConstants.SOCKDIAG_MSG_HEADER_SIZE;
+import static com.android.net.module.util.netlink.NetlinkConstants.SOCK_DIAG_BY_FAMILY;
+import static com.android.net.module.util.netlink.NetlinkUtils.IO_TIMEOUT_MS;
+
+import android.annotation.IntDef;
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.INetd;
+import android.net.ISocketKeepaliveCallback;
+import android.net.MarkMaskParcel;
+import android.net.Network;
+import android.net.NetworkAgent;
+import android.net.SocketKeepalive.InvalidSocketException;
+import android.os.FileUtils;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.os.RemoteException;
+import android.os.SystemClock;
+import android.system.ErrnoException;
+import android.system.Os;
+import android.system.StructTimeval;
+import android.util.Log;
+import android.util.SparseArray;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.util.IndentingPrintWriter;
+import com.android.modules.utils.build.SdkLevel;
+import com.android.net.module.util.CollectionUtils;
+import com.android.net.module.util.DeviceConfigUtils;
+import com.android.net.module.util.HexDump;
+import com.android.net.module.util.SocketUtils;
+import com.android.net.module.util.netlink.InetDiagMessage;
+import com.android.net.module.util.netlink.NetlinkUtils;
+import com.android.net.module.util.netlink.StructNlAttr;
+
+import java.io.FileDescriptor;
+import java.io.InterruptedIOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.net.SocketException;
+import java.nio.BufferUnderflowException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Manages automatic on/off socket keepalive requests.
+ *
+ * Provides methods to stop and start automatic keepalive requests, and keeps track of keepalives
+ * across all networks. This class is tightly coupled to ConnectivityService. It is not
+ * thread-safe and its handle* methods must be called only from the ConnectivityService handler
+ * thread.
+ */
+public class AutomaticOnOffKeepaliveTracker {
+ private static final String TAG = "AutomaticOnOffKeepaliveTracker";
+ private static final int[] ADDRESS_FAMILIES = new int[] {AF_INET6, AF_INET};
+ private static final String ACTION_TCP_POLLING_ALARM =
+ "com.android.server.connectivity.KeepaliveTracker.TCP_POLLING_ALARM";
+ private static final String EXTRA_NETWORK = "network_id";
+ private static final String EXTRA_SLOT = "slot";
+ private static final long DEFAULT_TCP_POLLING_INTERVAL_MS = 120_000L;
+ private static final String AUTOMATIC_ON_OFF_KEEPALIVE_VERSION =
+ "automatic_on_off_keepalive_version";
+ /**
+ * States for {@code #AutomaticOnOffKeepalive}.
+ *
+ * If automatic mode is off for this keepalive, the state is STATE_ALWAYS_ON and it stays
+ * so for the entire lifetime of this object.
+ *
+ * If enabled, a new AutomaticOnOffKeepalive starts with STATE_ENABLED. The system will monitor
+ * the TCP sockets on VPN networks running on top of the specified network, and turn off
+ * keepalive if there is no TCP socket any of the VPN networks. Conversely, it will turn
+ * keepalive back on if any TCP socket is open on any of the VPN networks.
+ *
+ * When there is no TCP socket on any of the VPN networks, the state becomes STATE_SUSPENDED.
+ * The {@link KeepaliveTracker.KeepaliveInfo} object is kept to remember the parameters so it
+ * is possible to resume keepalive later with the same parameters.
+ *
+ * When the system detects some TCP socket is open on one of the VPNs while in STATE_SUSPENDED,
+ * this AutomaticOnOffKeepalive goes to STATE_ENABLED again.
+ *
+ * When finishing keepalive, this object is deleted.
+ */
+ private static final int STATE_ENABLED = 0;
+ private static final int STATE_SUSPENDED = 1;
+ private static final int STATE_ALWAYS_ON = 2;
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef(prefix = { "STATE_" }, value = {
+ STATE_ENABLED,
+ STATE_SUSPENDED,
+ STATE_ALWAYS_ON
+ })
+ private @interface AutomaticOnOffState {}
+
+ @NonNull
+ private final Handler mConnectivityServiceHandler;
+ @NonNull
+ private final KeepaliveTracker mKeepaliveTracker;
+ @NonNull
+ private final Context mContext;
+ @NonNull
+ private final AlarmManager mAlarmManager;
+
+ /**
+ * The {@code inetDiagReqV2} messages for different IP family.
+ *
+ * Key: Ip family type.
+ * Value: Bytes array represent the {@code inetDiagReqV2}.
+ *
+ * This should only be accessed in the connectivity service handler thread.
+ */
+ private final SparseArray<byte[]> mSockDiagMsg = new SparseArray<>();
+ private final Dependencies mDependencies;
+ private final INetd mNetd;
+ /**
+ * Keeps track of automatic on/off keepalive requests.
+ * This should be only updated in ConnectivityService handler thread.
+ */
+ private final ArrayList<AutomaticOnOffKeepalive> mAutomaticOnOffKeepalives = new ArrayList<>();
+
+ private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ if (ACTION_TCP_POLLING_ALARM.equals(intent.getAction())) {
+ Log.d(TAG, "Received TCP polling intent");
+ final Network network = intent.getParcelableExtra(EXTRA_NETWORK);
+ final int slot = intent.getIntExtra(EXTRA_SLOT, -1);
+ mConnectivityServiceHandler.obtainMessage(
+ NetworkAgent.CMD_MONITOR_AUTOMATIC_KEEPALIVE,
+ slot, 0 , network).sendToTarget();
+ }
+ }
+ };
+
+ /**
+ * Information about a managed keepalive.
+ *
+ * The keepalive in mKi is managed by this object. This object can be in one of three states
+ * (in mAutomatiOnOffState) :
+ * • STATE_ALWAYS_ON : this keepalive is always on
+ * • STATE_ENABLED : this keepalive is currently on, and monitored for possibly being turned
+ * off if no TCP socket is open on the VPN.
+ * • STATE_SUSPENDED : this keepalive is currently off, and monitored for possibly being
+ * resumed if a TCP socket is open on the VPN.
+ * See the documentation for the states for more detail.
+ */
+ public class AutomaticOnOffKeepalive {
+ @NonNull
+ private final KeepaliveTracker.KeepaliveInfo mKi;
+ @Nullable
+ private final FileDescriptor mFd;
+ @Nullable
+ private final PendingIntent mTcpPollingAlarm;
+ @AutomaticOnOffState
+ private int mAutomaticOnOffState;
+
+ AutomaticOnOffKeepalive(@NonNull final KeepaliveTracker.KeepaliveInfo ki,
+ final boolean autoOnOff, @NonNull Context context) throws InvalidSocketException {
+ this.mKi = Objects.requireNonNull(ki);
+ if (autoOnOff && mDependencies.isFeatureEnabled(AUTOMATIC_ON_OFF_KEEPALIVE_VERSION)) {
+ mAutomaticOnOffState = STATE_ENABLED;
+ if (null == ki.mFd) {
+ throw new IllegalArgumentException("fd can't be null with automatic "
+ + "on/off keepalives");
+ }
+ try {
+ mFd = Os.dup(ki.mFd);
+ } catch (ErrnoException e) {
+ Log.e(TAG, "Cannot dup fd: ", e);
+ throw new InvalidSocketException(ERROR_INVALID_SOCKET, e);
+ }
+ mTcpPollingAlarm = createTcpPollingAlarmIntent(
+ context, ki.getNai().network(), ki.getSlot());
+ } else {
+ mAutomaticOnOffState = STATE_ALWAYS_ON;
+ // A null fd is acceptable in KeepaliveInfo for backward compatibility of
+ // PacketKeepalive API, but it must never happen with automatic keepalives.
+ // TODO : remove mFd from KeepaliveInfo or from this class.
+ mFd = ki.mFd;
+ mTcpPollingAlarm = null;
+ }
+ }
+
+ public Network getNetwork() {
+ return mKi.getNai().network;
+ }
+
+ public boolean match(Network network, int slot) {
+ return mKi.getNai().network().equals(network) && mKi.getSlot() == slot;
+ }
+
+ private PendingIntent createTcpPollingAlarmIntent(@NonNull Context context,
+ @NonNull Network network, int slot) {
+ final Intent intent = new Intent(ACTION_TCP_POLLING_ALARM);
+ intent.putExtra(EXTRA_NETWORK, network);
+ intent.putExtra(EXTRA_SLOT, slot);
+ return PendingIntent.getBroadcast(
+ context, 0 /* requestCode */, intent, PendingIntent.FLAG_IMMUTABLE);
+ }
+ }
+
+ public AutomaticOnOffKeepaliveTracker(@NonNull Context context, @NonNull Handler handler) {
+ this(context, handler, new Dependencies(context));
+ }
+
+ @VisibleForTesting
+ public AutomaticOnOffKeepaliveTracker(@NonNull Context context, @NonNull Handler handler,
+ @NonNull Dependencies dependencies) {
+ mContext = Objects.requireNonNull(context);
+ mDependencies = Objects.requireNonNull(dependencies);
+ mConnectivityServiceHandler = Objects.requireNonNull(handler);
+ mNetd = mDependencies.getNetd();
+ mKeepaliveTracker = mDependencies.newKeepaliveTracker(
+ mContext, mConnectivityServiceHandler);
+
+ if (SdkLevel.isAtLeastU()) {
+ mContext.registerReceiver(mReceiver, new IntentFilter(ACTION_TCP_POLLING_ALARM),
+ null, handler);
+ }
+ mAlarmManager = mContext.getSystemService(AlarmManager.class);
+ }
+
+ private void startTcpPollingAlarm(@NonNull PendingIntent alarm) {
+ final long triggerAtMillis =
+ SystemClock.elapsedRealtime() + DEFAULT_TCP_POLLING_INTERVAL_MS;
+ // Setup a non-wake up alarm.
+ mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME, triggerAtMillis, alarm);
+ }
+
+ /**
+ * Determine if any state transition is needed for the specific automatic keepalive.
+ */
+ public void handleMonitorAutomaticKeepalive(@NonNull final AutomaticOnOffKeepalive ki,
+ final int vpnNetId) {
+ // Might happen if the automatic keepalive was removed by the app just as the alarm fires.
+ if (!mAutomaticOnOffKeepalives.contains(ki)) return;
+ if (STATE_ALWAYS_ON == ki.mAutomaticOnOffState) {
+ throw new IllegalStateException("Should not monitor non-auto keepalive");
+ }
+
+ handleMonitorTcpConnections(ki, vpnNetId);
+ }
+
+ /**
+ * Determine if disable or re-enable keepalive is needed or not based on TCP sockets status.
+ */
+ private void handleMonitorTcpConnections(@NonNull AutomaticOnOffKeepalive ki, int vpnNetId) {
+ // Might happen if the automatic keepalive was removed by the app just as the alarm fires.
+ if (!mAutomaticOnOffKeepalives.contains(ki)) return;
+ if (STATE_ALWAYS_ON == ki.mAutomaticOnOffState) {
+ throw new IllegalStateException("Should not monitor non-auto keepalive");
+ }
+ if (!isAnyTcpSocketConnected(vpnNetId)) {
+ // No TCP socket exists. Stop keepalive if ENABLED, and remain SUSPENDED if currently
+ // SUSPENDED.
+ if (ki.mAutomaticOnOffState == STATE_ENABLED) {
+ ki.mAutomaticOnOffState = STATE_SUSPENDED;
+ handleSuspendKeepalive(ki.mKi);
+ }
+ } else {
+ handleMaybeResumeKeepalive(ki);
+ }
+ // TODO: listen to socket status instead of periodically check.
+ startTcpPollingAlarm(ki.mTcpPollingAlarm);
+ }
+
+ /**
+ * Resume an auto on/off keepalive, unless it's already resumed
+ * @param autoKi the keepalive to resume
+ */
+ public void handleMaybeResumeKeepalive(@NonNull AutomaticOnOffKeepalive autoKi) {
+ // Might happen if the automatic keepalive was removed by the app just as the alarm fires.
+ if (!mAutomaticOnOffKeepalives.contains(autoKi)) return;
+ if (STATE_ALWAYS_ON == autoKi.mAutomaticOnOffState) {
+ throw new IllegalStateException("Should not resume non-auto keepalive");
+ }
+ if (autoKi.mAutomaticOnOffState == STATE_ENABLED) return;
+ KeepaliveTracker.KeepaliveInfo newKi;
+ try {
+ // Get fd from AutomaticOnOffKeepalive since the fd in the original
+ // KeepaliveInfo should be closed.
+ newKi = autoKi.mKi.withFd(autoKi.mFd);
+ } catch (InvalidSocketException | IllegalArgumentException | SecurityException e) {
+ Log.e(TAG, "Fail to construct keepalive", e);
+ mKeepaliveTracker.notifyErrorCallback(autoKi.mKi.mCallback, ERROR_INVALID_SOCKET);
+ return;
+ }
+ autoKi.mAutomaticOnOffState = STATE_ENABLED;
+ handleResumeKeepalive(newKi);
+ }
+
+ private int findAutomaticOnOffKeepaliveIndex(@NonNull Network network, int slot) {
+ ensureRunningOnHandlerThread();
+
+ int index = 0;
+ for (AutomaticOnOffKeepalive ki : mAutomaticOnOffKeepalives) {
+ if (ki.match(network, slot)) {
+ return index;
+ }
+ index++;
+ }
+ return -1;
+ }
+
+ @Nullable
+ private AutomaticOnOffKeepalive findAutomaticOnOffKeepalive(@NonNull Network network,
+ int slot) {
+ ensureRunningOnHandlerThread();
+
+ final int index = findAutomaticOnOffKeepaliveIndex(network, slot);
+ return (index >= 0) ? mAutomaticOnOffKeepalives.get(index) : null;
+ }
+
+ /**
+ * Handle keepalive events from lower layer.
+ *
+ * Forward to KeepaliveTracker.
+ */
+ public void handleEventSocketKeepalive(@NonNull NetworkAgentInfo nai, int slot, int reason) {
+ mKeepaliveTracker.handleEventSocketKeepalive(nai, slot, reason);
+ }
+
+ /**
+ * Handle stop all keepalives on the specific network.
+ */
+ public void handleStopAllKeepalives(NetworkAgentInfo nai, int reason) {
+ mKeepaliveTracker.handleStopAllKeepalives(nai, reason);
+ final List<AutomaticOnOffKeepalive> matches =
+ CollectionUtils.filter(mAutomaticOnOffKeepalives, it -> it.mKi.getNai() == nai);
+ for (final AutomaticOnOffKeepalive ki : matches) {
+ cleanupAutoOnOffKeepalive(ki);
+ }
+ }
+
+ /**
+ * Handle start keepalive contained within a message.
+ *
+ * The message is expected to contain a KeepaliveTracker.KeepaliveInfo.
+ */
+ public void handleStartKeepalive(Message message) {
+ final AutomaticOnOffKeepalive autoKi = (AutomaticOnOffKeepalive) message.obj;
+ mKeepaliveTracker.handleStartKeepalive(autoKi.mKi);
+
+ // Add automatic on/off request into list to track its life cycle.
+ mAutomaticOnOffKeepalives.add(autoKi);
+ if (STATE_ALWAYS_ON != autoKi.mAutomaticOnOffState) {
+ startTcpPollingAlarm(autoKi.mTcpPollingAlarm);
+ }
+ }
+
+ private void handleResumeKeepalive(@NonNull final KeepaliveTracker.KeepaliveInfo ki) {
+ mKeepaliveTracker.handleStartKeepalive(ki);
+ }
+
+ private void handleSuspendKeepalive(@NonNull final KeepaliveTracker.KeepaliveInfo ki) {
+ // TODO : mKT.handleStopKeepalive should take a KeepaliveInfo instead
+ // TODO : create a separate success code for suspend
+ mKeepaliveTracker.handleStopKeepalive(ki.getNai(), ki.getSlot(), SUCCESS);
+ }
+
+ /**
+ * Handle stop keepalives on the specific network with given slot.
+ */
+ public void handleStopKeepalive(@NonNull NetworkAgentInfo nai, int slot, int reason) {
+ final AutomaticOnOffKeepalive autoKi = findAutomaticOnOffKeepalive(nai.network, slot);
+ if (null == autoKi) {
+ Log.e(TAG, "Attempt to stop nonexistent keepalive " + slot + " on " + nai);
+ return;
+ }
+
+ // Stop the keepalive unless it was suspended. This includes the case where it's managed
+ // but enabled, and the case where it's always on.
+ if (autoKi.mAutomaticOnOffState != STATE_SUSPENDED) {
+ mKeepaliveTracker.handleStopKeepalive(nai, slot, reason);
+ }
+
+ cleanupAutoOnOffKeepalive(autoKi);
+ }
+
+ private void cleanupAutoOnOffKeepalive(@NonNull final AutomaticOnOffKeepalive autoKi) {
+ ensureRunningOnHandlerThread();
+ if (null != autoKi.mTcpPollingAlarm) mAlarmManager.cancel(autoKi.mTcpPollingAlarm);
+ // Close the duplicated fd that maintains the lifecycle of socket.
+ FileUtils.closeQuietly(autoKi.mFd);
+ mAutomaticOnOffKeepalives.remove(autoKi);
+ }
+
+ /**
+ * Called when requesting that keepalives be started on a IPsec NAT-T socket. See
+ * {@link android.net.SocketKeepalive}.
+ *
+ * Forward to KeepaliveTracker.
+ **/
+ public void startNattKeepalive(@Nullable NetworkAgentInfo nai,
+ @Nullable FileDescriptor fd,
+ int intervalSeconds,
+ @NonNull ISocketKeepaliveCallback cb,
+ @NonNull String srcAddrString,
+ int srcPort,
+ @NonNull String dstAddrString,
+ int dstPort, boolean automaticOnOffKeepalives) {
+ final KeepaliveTracker.KeepaliveInfo ki = mKeepaliveTracker.makeNattKeepaliveInfo(nai, fd,
+ intervalSeconds, cb, srcAddrString, srcPort, dstAddrString, dstPort);
+ if (null == ki) return;
+ try {
+ final AutomaticOnOffKeepalive autoKi = new AutomaticOnOffKeepalive(ki,
+ automaticOnOffKeepalives, mContext);
+ mConnectivityServiceHandler.obtainMessage(NetworkAgent.CMD_START_SOCKET_KEEPALIVE,
+ // TODO : move ConnectivityService#encodeBool to a static lib.
+ automaticOnOffKeepalives ? 1 : 0, 0, autoKi).sendToTarget();
+ } catch (InvalidSocketException e) {
+ mKeepaliveTracker.notifyErrorCallback(cb, e.error);
+ }
+ }
+
+ /**
+ * Called when requesting that keepalives be started on a IPsec NAT-T socket. See
+ * {@link android.net.SocketKeepalive}.
+ *
+ * Forward to KeepaliveTracker.
+ **/
+ public void startNattKeepalive(@Nullable NetworkAgentInfo nai,
+ @Nullable FileDescriptor fd,
+ int resourceId,
+ int intervalSeconds,
+ @NonNull ISocketKeepaliveCallback cb,
+ @NonNull String srcAddrString,
+ @NonNull String dstAddrString,
+ int dstPort,
+ boolean automaticOnOffKeepalives) {
+ final KeepaliveTracker.KeepaliveInfo ki = mKeepaliveTracker.makeNattKeepaliveInfo(nai, fd,
+ resourceId, intervalSeconds, cb, srcAddrString, dstAddrString, dstPort);
+ if (null == ki) return;
+ try {
+ final AutomaticOnOffKeepalive autoKi = new AutomaticOnOffKeepalive(ki,
+ automaticOnOffKeepalives, mContext);
+ mConnectivityServiceHandler.obtainMessage(NetworkAgent.CMD_START_SOCKET_KEEPALIVE,
+ // TODO : move ConnectivityService#encodeBool to a static lib.
+ automaticOnOffKeepalives ? 1 : 0, 0, autoKi).sendToTarget();
+ } catch (InvalidSocketException e) {
+ mKeepaliveTracker.notifyErrorCallback(cb, e.error);
+ }
+ }
+
+ /**
+ * Called by ConnectivityService to start TCP keepalive on a file descriptor.
+ *
+ * In order to offload keepalive for application correctly, sequence number, ack number and
+ * other fields are needed to form the keepalive packet. Thus, this function synchronously
+ * puts the socket into repair mode to get the necessary information. After the socket has been
+ * put into repair mode, the application cannot access the socket until reverted to normal.
+ * See {@link android.net.SocketKeepalive}.
+ *
+ * Forward to KeepaliveTracker.
+ **/
+ public void startTcpKeepalive(@Nullable NetworkAgentInfo nai,
+ @NonNull FileDescriptor fd,
+ int intervalSeconds,
+ @NonNull ISocketKeepaliveCallback cb) {
+ final KeepaliveTracker.KeepaliveInfo ki = mKeepaliveTracker.makeTcpKeepaliveInfo(nai, fd,
+ intervalSeconds, cb);
+ if (null == ki) return;
+ try {
+ final AutomaticOnOffKeepalive autoKi = new AutomaticOnOffKeepalive(ki,
+ false /* autoOnOff, tcp keepalives are never auto on/off */, mContext);
+ mConnectivityServiceHandler.obtainMessage(CMD_START_SOCKET_KEEPALIVE, autoKi)
+ .sendToTarget();
+ } catch (InvalidSocketException e) {
+ mKeepaliveTracker.notifyErrorCallback(cb, e.error);
+ }
+ }
+
+ /**
+ * Dump AutomaticOnOffKeepaliveTracker state.
+ */
+ public void dump(IndentingPrintWriter pw) {
+ // TODO: Dump the necessary information for automatic on/off keepalive.
+ mKeepaliveTracker.dump(pw);
+ }
+
+ /**
+ * Check all keepalives on the network are still valid.
+ *
+ * Forward to KeepaliveTracker.
+ */
+ public void handleCheckKeepalivesStillValid(NetworkAgentInfo nai) {
+ mKeepaliveTracker.handleCheckKeepalivesStillValid(nai);
+ }
+
+ @VisibleForTesting
+ boolean isAnyTcpSocketConnected(int netId) {
+ FileDescriptor fd = null;
+
+ try {
+ fd = mDependencies.createConnectedNetlinkSocket();
+
+ // Get network mask
+ final MarkMaskParcel parcel = mNetd.getFwmarkForNetwork(netId);
+ final int networkMark = (parcel != null) ? parcel.mark : NetlinkUtils.UNKNOWN_MARK;
+ final int networkMask = (parcel != null) ? parcel.mask : NetlinkUtils.NULL_MASK;
+
+ // Send request for each IP family
+ for (final int family : ADDRESS_FAMILIES) {
+ if (isAnyTcpSocketConnectedForFamily(fd, family, networkMark, networkMask)) {
+ return true;
+ }
+ }
+ } catch (ErrnoException | SocketException | InterruptedIOException | RemoteException e) {
+ Log.e(TAG, "Fail to get socket info via netlink.", e);
+ } finally {
+ SocketUtils.closeSocketQuietly(fd);
+ }
+
+ return false;
+ }
+
+ private boolean isAnyTcpSocketConnectedForFamily(FileDescriptor fd, int family, int networkMark,
+ int networkMask) throws ErrnoException, InterruptedIOException {
+ ensureRunningOnHandlerThread();
+ // Build SocketDiag messages and cache it.
+ if (mSockDiagMsg.get(family) == null) {
+ mSockDiagMsg.put(family, InetDiagMessage.buildInetDiagReqForAliveTcpSockets(family));
+ }
+ mDependencies.sendRequest(fd, mSockDiagMsg.get(family));
+
+ // Iteration limitation as a protection to avoid possible infinite loops.
+ // DEFAULT_RECV_BUFSIZE could read more than 20 sockets per time. Max iteration
+ // should be enough to go through reasonable TCP sockets in the device.
+ final int maxIteration = 100;
+ int parsingIteration = 0;
+ while (parsingIteration < maxIteration) {
+ final ByteBuffer bytes = mDependencies.recvSockDiagResponse(fd);
+
+ try {
+ while (NetlinkUtils.enoughBytesRemainForValidNlMsg(bytes)) {
+ final int startPos = bytes.position();
+
+ final int nlmsgLen = bytes.getInt();
+ final int nlmsgType = bytes.getShort();
+ if (isEndOfMessageOrError(nlmsgType)) return false;
+ // TODO: Parse InetDiagMessage to get uid and dst address information to filter
+ // socket via NetlinkMessage.parse.
+
+ // Skip the header to move to data part.
+ bytes.position(startPos + SOCKDIAG_MSG_HEADER_SIZE);
+
+ if (isTargetTcpSocket(bytes, nlmsgLen, networkMark, networkMask)) {
+ return true;
+ }
+ }
+ } catch (BufferUnderflowException e) {
+ // The exception happens in random place in either header position or any data
+ // position. Partial bytes from the middle of the byte buffer may not be enough to
+ // clarify, so print out the content before the error to possibly prevent printing
+ // the whole 8K buffer.
+ final int exceptionPos = bytes.position();
+ final String hex = HexDump.dumpHexString(bytes.array(), 0, exceptionPos);
+ Log.e(TAG, "Unexpected socket info parsing: " + hex, e);
+ }
+
+ parsingIteration++;
+ }
+ return false;
+ }
+
+ private boolean isEndOfMessageOrError(int nlmsgType) {
+ return nlmsgType == NLMSG_DONE || nlmsgType != SOCK_DIAG_BY_FAMILY;
+ }
+
+ private boolean isTargetTcpSocket(@NonNull ByteBuffer bytes, int nlmsgLen, int networkMark,
+ int networkMask) {
+ final int mark = readSocketDataAndReturnMark(bytes, nlmsgLen);
+ return (mark & networkMask) == networkMark;
+ }
+
+ private int readSocketDataAndReturnMark(@NonNull ByteBuffer bytes, int nlmsgLen) {
+ final int nextMsgOffset = bytes.position() + nlmsgLen - SOCKDIAG_MSG_HEADER_SIZE;
+ int mark = NetlinkUtils.INIT_MARK_VALUE;
+ // Get socket mark
+ // TODO: Add a parsing method in NetlinkMessage.parse to support this to skip the remaining
+ // data.
+ while (bytes.position() < nextMsgOffset) {
+ final StructNlAttr nlattr = StructNlAttr.parse(bytes);
+ if (nlattr != null && nlattr.nla_type == NetlinkUtils.INET_DIAG_MARK) {
+ mark = nlattr.getValueAsInteger();
+ }
+ }
+ return mark;
+ }
+
+ private void ensureRunningOnHandlerThread() {
+ if (mConnectivityServiceHandler.getLooper().getThread() != Thread.currentThread()) {
+ throw new IllegalStateException(
+ "Not running on handler thread: " + Thread.currentThread().getName());
+ }
+ }
+
+ /**
+ * Dependencies class for testing.
+ */
+ @VisibleForTesting
+ public static class Dependencies {
+ private final Context mContext;
+
+ public Dependencies(final Context context) {
+ mContext = context;
+ }
+
+ /**
+ * Create a netlink socket connected to the kernel.
+ *
+ * @return fd the fileDescriptor of the socket.
+ */
+ public FileDescriptor createConnectedNetlinkSocket()
+ throws ErrnoException, SocketException {
+ final FileDescriptor fd = NetlinkUtils.createNetLinkInetDiagSocket();
+ NetlinkUtils.connectSocketToNetlink(fd);
+ Os.setsockoptTimeval(fd, SOL_SOCKET, SO_SNDTIMEO,
+ StructTimeval.fromMillis(IO_TIMEOUT_MS));
+ return fd;
+ }
+
+ /**
+ * Send composed message request to kernel.
+ *
+ * The given FileDescriptor is expected to be created by
+ * {@link #createConnectedNetlinkSocket} or equivalent way.
+ *
+ * @param fd a netlink socket {@code FileDescriptor} connected to the kernel.
+ * @param msg the byte array representing the request message to write to kernel.
+ */
+ public void sendRequest(@NonNull final FileDescriptor fd,
+ @NonNull final byte[] msg)
+ throws ErrnoException, InterruptedIOException {
+ Os.write(fd, msg, 0 /* byteOffset */, msg.length);
+ }
+
+ /**
+ * Get an INetd connector.
+ */
+ public INetd getNetd() {
+ return INetd.Stub.asInterface(
+ (IBinder) mContext.getSystemService(Context.NETD_SERVICE));
+ }
+
+ /**
+ * Receive the response message from kernel via given {@code FileDescriptor}.
+ * The usage should follow the {@code #sendRequest} call with the same
+ * FileDescriptor.
+ *
+ * The overall response may be large but the individual messages should not be
+ * excessively large(8-16kB) because trying to get the kernel to return
+ * everything in one big buffer is inefficient as it forces the kernel to allocate
+ * large chunks of linearly physically contiguous memory. The usage should iterate the
+ * call of this method until the end of the overall message.
+ *
+ * The default receiving buffer size should be small enough that it is always
+ * processed within the {@link NetlinkUtils#IO_TIMEOUT_MS} timeout.
+ */
+ public ByteBuffer recvSockDiagResponse(@NonNull final FileDescriptor fd)
+ throws ErrnoException, InterruptedIOException {
+ return NetlinkUtils.recvMessage(
+ fd, NetlinkUtils.DEFAULT_RECV_BUFSIZE, NetlinkUtils.IO_TIMEOUT_MS);
+ }
+
+ /**
+ * Construct a new KeepaliveTracker.
+ */
+ public KeepaliveTracker newKeepaliveTracker(@NonNull Context context,
+ @NonNull Handler connectivityserviceHander) {
+ return new KeepaliveTracker(mContext, connectivityserviceHander);
+ }
+
+ /**
+ * Find out if a feature is enabled from DeviceConfig.
+ *
+ * @param name The name of the property to look up.
+ * @return whether the feature is enabled
+ */
+ public boolean isFeatureEnabled(@NonNull final String name) {
+ return DeviceConfigUtils.isFeatureEnabled(mContext, NAMESPACE_CONNECTIVITY, name);
+ }
+ }
+}
diff --git a/service/src/com/android/server/connectivity/CarrierPrivilegeAuthenticator.java b/service/src/com/android/server/connectivity/CarrierPrivilegeAuthenticator.java
index b06c8aa..4325763 100644
--- a/service/src/com/android/server/connectivity/CarrierPrivilegeAuthenticator.java
+++ b/service/src/com/android/server/connectivity/CarrierPrivilegeAuthenticator.java
@@ -38,6 +38,7 @@
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
+import com.android.modules.utils.HandlerExecutor;
import com.android.networkstack.apishim.TelephonyManagerShimImpl;
import com.android.networkstack.apishim.common.TelephonyManagerShim;
import com.android.networkstack.apishim.common.TelephonyManagerShim.CarrierPrivilegesListenerShim;
@@ -46,7 +47,6 @@
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executor;
-import java.util.concurrent.RejectedExecutionException;
/**
* Tracks the uid of the carrier privileged app that provides the carrier config.
@@ -105,27 +105,6 @@
}
/**
- * An adapter {@link Executor} that posts all executed tasks onto the given
- * {@link Handler}.
- *
- * TODO : migrate to the version in frameworks/libs/net when it's ready
- *
- * @hide
- */
- public class HandlerExecutor implements Executor {
- private final Handler mHandler;
- public HandlerExecutor(@NonNull Handler handler) {
- mHandler = handler;
- }
- @Override
- public void execute(Runnable command) {
- if (!mHandler.post(command)) {
- throw new RejectedExecutionException(mHandler + " is shutting down");
- }
- }
- }
-
- /**
* Broadcast receiver for ACTION_MULTI_SIM_CONFIG_CHANGED
*
* <p>The broadcast receiver is registered with mHandler
diff --git a/service/src/com/android/server/connectivity/FullScore.java b/service/src/com/android/server/connectivity/FullScore.java
index 2303894..87ae0c9 100644
--- a/service/src/com/android/server/connectivity/FullScore.java
+++ b/service/src/com/android/server/connectivity/FullScore.java
@@ -23,7 +23,7 @@
import static android.net.NetworkScore.KEEP_CONNECTED_NONE;
import static android.net.NetworkScore.POLICY_YIELD_TO_BAD_WIFI;
-import static com.android.net.module.util.BitUtils.appendStringRepresentationOfBitMaskToStringBuilder;
+import static com.android.net.module.util.BitUtils.describeDifferences;
import android.annotation.NonNull;
import android.annotation.Nullable;
@@ -338,31 +338,14 @@
/**
* Returns a short but human-readable string of updates from an older score.
- * @param old the old capabilities to diff from
+ * @param old the old score to diff from
* @return a string fit for logging differences, or null if no differences.
- * this method cannot return the empty string.
+ * this method cannot return the empty string. See BitUtils#describeDifferences.
*/
@Nullable
public String describeDifferencesFrom(@Nullable final FullScore old) {
final long oldPolicies = null == old ? 0 : old.mPolicies;
- final long changed = oldPolicies ^ mPolicies;
- if (0 == changed) return null;
- // If the control reaches here, there are changes (additions, removals, or both) so
- // the code below is guaranteed to add something to the string and can't return "".
- final long removed = oldPolicies & changed;
- final long added = mPolicies & changed;
- final StringBuilder sb = new StringBuilder();
- if (0 != removed) {
- sb.append("-");
- appendStringRepresentationOfBitMaskToStringBuilder(sb, removed,
- FullScore::policyNameOf, "-");
- }
- if (0 != added) {
- sb.append("+");
- appendStringRepresentationOfBitMaskToStringBuilder(sb, added,
- FullScore::policyNameOf, "+");
- }
- return sb.toString();
+ return describeDifferences(oldPolicies, mPolicies, FullScore::policyNameOf);
}
// Example output :
diff --git a/service/src/com/android/server/connectivity/KeepaliveTracker.java b/service/src/com/android/server/connectivity/KeepaliveTracker.java
index 3b58823..63b76c7 100644
--- a/service/src/com/android/server/connectivity/KeepaliveTracker.java
+++ b/service/src/com/android/server/connectivity/KeepaliveTracker.java
@@ -18,7 +18,6 @@
import static android.content.pm.PackageManager.PERMISSION_GRANTED;
import static android.net.NattSocketKeepalive.NATT_PORT;
-import static android.net.NetworkAgent.CMD_START_SOCKET_KEEPALIVE;
import static android.net.SocketKeepalive.BINDER_DIED;
import static android.net.SocketKeepalive.DATA_RECEIVED;
import static android.net.SocketKeepalive.ERROR_INSUFFICIENT_RESOURCES;
@@ -50,7 +49,6 @@
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
-import android.os.Message;
import android.os.Process;
import android.os.RemoteException;
import android.system.ErrnoException;
@@ -88,7 +86,6 @@
/** Keeps track of keepalive requests. */
private final HashMap <NetworkAgentInfo, HashMap<Integer, KeepaliveInfo>> mKeepalives =
new HashMap<> ();
- private final Handler mConnectivityServiceHandler;
@NonNull
private final TcpKeepaliveController mTcpController;
@NonNull
@@ -109,9 +106,9 @@
private final int mAllowedUnprivilegedSlotsForUid;
public KeepaliveTracker(Context context, Handler handler) {
- mConnectivityServiceHandler = handler;
mTcpController = new TcpKeepaliveController(handler);
mContext = context;
+
mSupportedKeepalives = KeepaliveUtils.getSupportedKeepalives(mContext);
final ConnectivityResources res = new ConnectivityResources(mContext);
@@ -129,13 +126,13 @@
*/
class KeepaliveInfo implements IBinder.DeathRecipient {
// Bookkeeping data.
- private final ISocketKeepaliveCallback mCallback;
+ public final ISocketKeepaliveCallback mCallback;
private final int mUid;
private final int mPid;
private final boolean mPrivileged;
- private final NetworkAgentInfo mNai;
+ public final NetworkAgentInfo mNai;
private final int mType;
- private final FileDescriptor mFd;
+ public final FileDescriptor mFd;
public static final int TYPE_NATT = 1;
public static final int TYPE_TCP = 2;
@@ -243,6 +240,10 @@
}
}
+ public int getSlot() {
+ return mSlot;
+ }
+
private int checkNetworkConnected() {
if (!mNai.networkInfo.isConnectedOrConnecting()) {
return ERROR_INVALID_NETWORK;
@@ -415,6 +416,13 @@
void onFileDescriptorInitiatedStop(final int socketKeepaliveReason) {
handleStopKeepalive(mNai, mSlot, socketKeepaliveReason);
}
+
+ /**
+ * Construct a new KeepaliveInfo from existing KeepaliveInfo with a new fd.
+ */
+ public KeepaliveInfo withFd(@NonNull FileDescriptor fd) throws InvalidSocketException {
+ return new KeepaliveInfo(mCallback, mNai, mPacket, mInterval, mType, fd);
+ }
}
void notifyErrorCallback(ISocketKeepaliveCallback cb, int error) {
@@ -444,8 +452,10 @@
return slot;
}
- public void handleStartKeepalive(Message message) {
- KeepaliveInfo ki = (KeepaliveInfo) message.obj;
+ /**
+ * Handle start keepalives with the message.
+ */
+ public void handleStartKeepalive(KeepaliveInfo ki) {
NetworkAgentInfo nai = ki.getNai();
int slot = findFirstFreeSlot(nai);
mKeepalives.get(nai).put(slot, ki);
@@ -604,7 +614,8 @@
* Called when requesting that keepalives be started on a IPsec NAT-T socket. See
* {@link android.net.SocketKeepalive}.
**/
- public void startNattKeepalive(@Nullable NetworkAgentInfo nai,
+ @Nullable
+ public KeepaliveInfo makeNattKeepaliveInfo(@Nullable NetworkAgentInfo nai,
@Nullable FileDescriptor fd,
int intervalSeconds,
@NonNull ISocketKeepaliveCallback cb,
@@ -614,7 +625,7 @@
int dstPort) {
if (nai == null) {
notifyErrorCallback(cb, ERROR_INVALID_NETWORK);
- return;
+ return null;
}
InetAddress srcAddress, dstAddress;
@@ -623,7 +634,7 @@
dstAddress = InetAddresses.parseNumericAddress(dstAddrString);
} catch (IllegalArgumentException e) {
notifyErrorCallback(cb, ERROR_INVALID_IP_ADDRESS);
- return;
+ return null;
}
KeepalivePacketData packet;
@@ -632,7 +643,7 @@
srcAddress, srcPort, dstAddress, NATT_PORT);
} catch (InvalidPacketException e) {
notifyErrorCallback(cb, e.getError());
- return;
+ return null;
}
KeepaliveInfo ki = null;
try {
@@ -641,15 +652,14 @@
} catch (InvalidSocketException | IllegalArgumentException | SecurityException e) {
Log.e(TAG, "Fail to construct keepalive", e);
notifyErrorCallback(cb, ERROR_INVALID_SOCKET);
- return;
+ return null;
}
- Log.d(TAG, "Created keepalive: " + ki.toString());
- mConnectivityServiceHandler.obtainMessage(
- NetworkAgent.CMD_START_SOCKET_KEEPALIVE, ki).sendToTarget();
+ Log.d(TAG, "Created keepalive: " + ki);
+ return ki;
}
/**
- * Called by ConnectivityService to start TCP keepalive on a file descriptor.
+ * Make a KeepaliveInfo for a TCP socket.
*
* In order to offload keepalive for application correctly, sequence number, ack number and
* other fields are needed to form the keepalive packet. Thus, this function synchronously
@@ -658,13 +668,14 @@
*
* See {@link android.net.SocketKeepalive}.
**/
- public void startTcpKeepalive(@Nullable NetworkAgentInfo nai,
+ @Nullable
+ public KeepaliveInfo makeTcpKeepaliveInfo(@Nullable NetworkAgentInfo nai,
@NonNull FileDescriptor fd,
int intervalSeconds,
@NonNull ISocketKeepaliveCallback cb) {
if (nai == null) {
notifyErrorCallback(cb, ERROR_INVALID_NETWORK);
- return;
+ return null;
}
final TcpKeepalivePacketData packet;
@@ -672,10 +683,10 @@
packet = TcpKeepaliveController.getTcpKeepalivePacket(fd);
} catch (InvalidSocketException e) {
notifyErrorCallback(cb, e.error);
- return;
+ return null;
} catch (InvalidPacketException e) {
notifyErrorCallback(cb, e.getError());
- return;
+ return null;
}
KeepaliveInfo ki = null;
try {
@@ -684,20 +695,22 @@
} catch (InvalidSocketException | IllegalArgumentException | SecurityException e) {
Log.e(TAG, "Fail to construct keepalive e=" + e);
notifyErrorCallback(cb, ERROR_INVALID_SOCKET);
- return;
+ return null;
}
Log.d(TAG, "Created keepalive: " + ki.toString());
- mConnectivityServiceHandler.obtainMessage(CMD_START_SOCKET_KEEPALIVE, ki).sendToTarget();
+ return ki;
}
- /**
- * Called when requesting that keepalives be started on a IPsec NAT-T socket. This function is
- * identical to {@link #startNattKeepalive}, but also takes a {@code resourceId}, which is the
- * resource index bound to the {@link UdpEncapsulationSocket} when creating by
- * {@link com.android.server.IpSecService} to verify whether the given
- * {@link UdpEncapsulationSocket} is legitimate.
- **/
- public void startNattKeepalive(@Nullable NetworkAgentInfo nai,
+ /**
+ * Make a KeepaliveInfo for an IPSec NAT-T socket.
+ *
+ * This function is identical to {@link #makeNattKeepaliveInfo}, but also takes a
+ * {@code resourceId}, which is the resource index bound to the {@link UdpEncapsulationSocket}
+ * when creating by {@link com.android.server.IpSecService} to verify whether the given
+ * {@link UdpEncapsulationSocket} is legitimate.
+ **/
+ @Nullable
+ public KeepaliveInfo makeNattKeepaliveInfo(@Nullable NetworkAgentInfo nai,
@Nullable FileDescriptor fd,
int resourceId,
int intervalSeconds,
@@ -708,6 +721,7 @@
// Ensure that the socket is created by IpSecService.
if (!isNattKeepaliveSocketValid(fd, resourceId)) {
notifyErrorCallback(cb, ERROR_INVALID_SOCKET);
+ return null;
}
// Get src port to adopt old API.
@@ -717,10 +731,11 @@
srcPort = ((InetSocketAddress) srcSockAddr).getPort();
} catch (ErrnoException e) {
notifyErrorCallback(cb, ERROR_INVALID_SOCKET);
+ return null;
}
// Forward request to old API.
- startNattKeepalive(nai, fd, intervalSeconds, cb, srcAddrString, srcPort,
+ return makeNattKeepaliveInfo(nai, fd, intervalSeconds, cb, srcAddrString, srcPort,
dstAddrString, dstPort);
}
@@ -739,6 +754,9 @@
return true;
}
+ /**
+ * Dump KeepaliveTracker state.
+ */
public void dump(IndentingPrintWriter pw) {
pw.println("Supported Socket keepalives: " + Arrays.toString(mSupportedKeepalives));
pw.println("Reserved Privileged keepalives: " + mReservedPrivilegedSlots);
diff --git a/service/src/com/android/server/connectivity/PermissionMonitor.java b/service/src/com/android/server/connectivity/PermissionMonitor.java
index ff979d8..c15f042 100755
--- a/service/src/com/android/server/connectivity/PermissionMonitor.java
+++ b/service/src/com/android/server/connectivity/PermissionMonitor.java
@@ -1211,18 +1211,6 @@
}
}
- /** Should only be used by unit tests */
- @VisibleForTesting
- public synchronized Set<UidRange> getVpnInterfaceUidRanges(String iface) {
- return mVpnInterfaceUidRanges.get(iface);
- }
-
- /** Should only be used by unit tests */
- @VisibleForTesting
- synchronized Set<UidRange> getVpnLockdownUidRanges() {
- return mVpnLockdownUidRanges.getSet();
- }
-
private synchronized void onSettingChanged() {
// Step1. Update uids allowed to use restricted networks and compute the set of uids to
// update.
diff --git a/tests/common/java/android/net/netstats/NetworkTemplateTest.kt b/tests/common/java/android/net/netstats/NetworkTemplateTest.kt
index 3c2340c..99f1e0b 100644
--- a/tests/common/java/android/net/netstats/NetworkTemplateTest.kt
+++ b/tests/common/java/android/net/netstats/NetworkTemplateTest.kt
@@ -26,10 +26,8 @@
import android.net.NetworkTemplate.MATCH_CARRIER
import android.net.NetworkTemplate.MATCH_ETHERNET
import android.net.NetworkTemplate.MATCH_MOBILE
-import android.net.NetworkTemplate.MATCH_MOBILE_WILDCARD
import android.net.NetworkTemplate.MATCH_PROXY
import android.net.NetworkTemplate.MATCH_WIFI
-import android.net.NetworkTemplate.MATCH_WIFI_WILDCARD
import android.net.NetworkTemplate.NETWORK_TYPE_ALL
import android.net.NetworkTemplate.OEM_MANAGED_ALL
import android.telephony.TelephonyManager
@@ -64,10 +62,8 @@
}
// Verify hidden match rules cannot construct templates.
- listOf(MATCH_WIFI_WILDCARD, MATCH_MOBILE_WILDCARD, MATCH_PROXY).forEach {
- assertFailsWith<IllegalArgumentException> {
- NetworkTemplate.Builder(it).build()
- }
+ assertFailsWith<IllegalArgumentException> {
+ NetworkTemplate.Builder(MATCH_PROXY).build()
}
// Verify template which matches metered cellular and carrier networks with
@@ -75,10 +71,9 @@
listOf(MATCH_MOBILE, MATCH_CARRIER).forEach { matchRule ->
NetworkTemplate.Builder(matchRule).setSubscriberIds(setOf(TEST_IMSI1))
.setMeteredness(METERED_YES).build().let {
- val expectedTemplate = NetworkTemplate(matchRule, TEST_IMSI1,
- arrayOf(TEST_IMSI1), emptyArray<String>(), METERED_YES,
- ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL,
- OEM_MANAGED_ALL)
+ val expectedTemplate = NetworkTemplate(matchRule, arrayOf(TEST_IMSI1),
+ emptyArray<String>(), METERED_YES, ROAMING_ALL, DEFAULT_NETWORK_ALL,
+ NETWORK_TYPE_ALL, OEM_MANAGED_ALL)
assertEquals(expectedTemplate, it)
}
}
@@ -88,10 +83,9 @@
listOf(MATCH_MOBILE, MATCH_CARRIER).forEach { matchRule ->
NetworkTemplate.Builder(matchRule).setSubscriberIds(setOf(TEST_IMSI1))
.setRoaming(ROAMING_YES).setMeteredness(METERED_YES).build().let {
- val expectedTemplate = NetworkTemplate(matchRule, TEST_IMSI1,
- arrayOf(TEST_IMSI1), emptyArray<String>(), METERED_YES,
- ROAMING_YES, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL,
- OEM_MANAGED_ALL)
+ val expectedTemplate = NetworkTemplate(matchRule, arrayOf(TEST_IMSI1),
+ emptyArray<String>(), METERED_YES, ROAMING_YES, DEFAULT_NETWORK_ALL,
+ NETWORK_TYPE_ALL, OEM_MANAGED_ALL)
assertEquals(expectedTemplate, it)
}
}
@@ -104,42 +98,39 @@
// Verify template which matches metered cellular networks,
// regardless of IMSI. See buildTemplateMobileWildcard.
NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES).build().let {
- val expectedTemplate = NetworkTemplate(MATCH_MOBILE_WILDCARD, null /*subscriberId*/,
- emptyArray<String>() /*subscriberIds*/, emptyArray<String>(),
+ val expectedTemplate = NetworkTemplate(MATCH_MOBILE,
+ emptyArray<String>() /*subscriberIds*/, emptyArray<String>() /*wifiNetworkKey*/,
METERED_YES, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL,
OEM_MANAGED_ALL)
assertEquals(expectedTemplate, it)
}
// Verify template which matches metered cellular networks and ratType.
- // See NetworkTemplate#buildTemplateMobileWithRatType.
NetworkTemplate.Builder(MATCH_MOBILE).setSubscriberIds(setOf(TEST_IMSI1))
.setMeteredness(METERED_YES).setRatType(TelephonyManager.NETWORK_TYPE_UMTS)
.build().let {
- val expectedTemplate = NetworkTemplate(MATCH_MOBILE, TEST_IMSI1,
- arrayOf(TEST_IMSI1), emptyArray<String>(), METERED_YES,
- ROAMING_ALL, DEFAULT_NETWORK_ALL, TelephonyManager.NETWORK_TYPE_UMTS,
- OEM_MANAGED_ALL)
+ val expectedTemplate = NetworkTemplate(MATCH_MOBILE, arrayOf(TEST_IMSI1),
+ emptyArray<String>(), METERED_YES, ROAMING_ALL, DEFAULT_NETWORK_ALL,
+ TelephonyManager.NETWORK_TYPE_UMTS, OEM_MANAGED_ALL)
assertEquals(expectedTemplate, it)
}
// Verify template which matches all wifi networks,
// regardless of Wifi Network Key. See buildTemplateWifiWildcard and buildTemplateWifi.
NetworkTemplate.Builder(MATCH_WIFI).build().let {
- val expectedTemplate = NetworkTemplate(MATCH_WIFI_WILDCARD, null /*subscriberId*/,
- emptyArray<String>() /*subscriberIds*/, emptyArray<String>(),
- METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL,
- OEM_MANAGED_ALL)
+ val expectedTemplate = NetworkTemplate(MATCH_WIFI,
+ emptyArray<String>() /*subscriberIds*/, emptyArray<String>(), METERED_ALL,
+ ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_ALL)
assertEquals(expectedTemplate, it)
}
// Verify template which matches wifi networks with the given Wifi Network Key.
// See buildTemplateWifi(wifiNetworkKey).
NetworkTemplate.Builder(MATCH_WIFI).setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build().let {
- val expectedTemplate = NetworkTemplate(MATCH_WIFI, null /*subscriberId*/,
- emptyArray<String>() /*subscriberIds*/, arrayOf(TEST_WIFI_KEY1),
- METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL,
- OEM_MANAGED_ALL)
+ val expectedTemplate =
+ NetworkTemplate(MATCH_WIFI, emptyArray<String>() /*subscriberIds*/,
+ arrayOf(TEST_WIFI_KEY1), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL,
+ NETWORK_TYPE_ALL, OEM_MANAGED_ALL)
assertEquals(expectedTemplate, it)
}
@@ -147,10 +138,9 @@
// given Wifi Network Key, and IMSI. See buildTemplateWifi(wifiNetworkKey, subscriberId).
NetworkTemplate.Builder(MATCH_WIFI).setSubscriberIds(setOf(TEST_IMSI1))
.setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build().let {
- val expectedTemplate = NetworkTemplate(MATCH_WIFI, TEST_IMSI1,
- arrayOf(TEST_IMSI1), arrayOf(TEST_WIFI_KEY1),
- METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL,
- OEM_MANAGED_ALL)
+ val expectedTemplate = NetworkTemplate(MATCH_WIFI, arrayOf(TEST_IMSI1),
+ arrayOf(TEST_WIFI_KEY1), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL,
+ NETWORK_TYPE_ALL, OEM_MANAGED_ALL)
assertEquals(expectedTemplate, it)
}
@@ -158,7 +148,7 @@
// See buildTemplateEthernet and buildTemplateBluetooth.
listOf(MATCH_ETHERNET, MATCH_BLUETOOTH).forEach { matchRule ->
NetworkTemplate.Builder(matchRule).build().let {
- val expectedTemplate = NetworkTemplate(matchRule, null /*subscriberId*/,
+ val expectedTemplate = NetworkTemplate(matchRule,
emptyArray<String>() /*subscriberIds*/, emptyArray<String>(),
METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL,
OEM_MANAGED_ALL)
@@ -193,7 +183,7 @@
// Verify template which matches wifi wildcard with the given empty key set.
NetworkTemplate.Builder(MATCH_WIFI).setWifiNetworkKeys(setOf<String>()).build().let {
- val expectedTemplate = NetworkTemplate(MATCH_WIFI_WILDCARD, null /*subscriberId*/,
+ val expectedTemplate = NetworkTemplate(MATCH_WIFI,
emptyArray<String>() /*subscriberIds*/, emptyArray<String>(),
METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL,
OEM_MANAGED_ALL)
diff --git a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
index 61b597a..d4b23a3 100644
--- a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
+++ b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
@@ -96,6 +96,7 @@
import static com.android.net.module.util.NetworkStackConstants.TEST_CAPTIVE_PORTAL_HTTP_URL;
import static com.android.networkstack.apishim.ConstantsShim.BLOCKED_REASON_LOCKDOWN_VPN;
import static com.android.networkstack.apishim.ConstantsShim.BLOCKED_REASON_NONE;
+import static com.android.networkstack.apishim.ConstantsShim.RECEIVER_EXPORTED;
import static com.android.testutils.Cleanup.testAndCleanup;
import static com.android.testutils.DevSdkIgnoreRuleKt.SC_V2;
import static com.android.testutils.MiscAsserts.assertThrows;
@@ -1131,7 +1132,8 @@
final ConnectivityActionReceiver receiver = new ConnectivityActionReceiver(
mCm, ConnectivityManager.TYPE_WIFI, NetworkInfo.State.CONNECTED);
- mContext.registerReceiver(receiver, filter);
+ final int flags = SdkLevel.isAtLeastT() ? RECEIVER_EXPORTED : 0;
+ mContext.registerReceiver(receiver, filter, flags);
// Create a broadcast PendingIntent for NETWORK_CALLBACK_ACTION.
final Intent intent = new Intent(NETWORK_CALLBACK_ACTION)
@@ -1188,7 +1190,8 @@
final String extraBoolKey = "extra_bool";
firstIntent = PendingIntent.getBroadcast(mContext,
0 /* requestCode */,
- new Intent(broadcastAction).putExtra(extraBoolKey, false),
+ new Intent(broadcastAction).putExtra(extraBoolKey, false)
+ .setPackage(mContext.getPackageName()),
PendingIntent.FLAG_UPDATE_CURRENT | pendingIntentFlagMutable);
if (useListen) {
@@ -1201,7 +1204,8 @@
// intent will be updated with the new extras
secondIntent = PendingIntent.getBroadcast(mContext,
0 /* requestCode */,
- new Intent(broadcastAction).putExtra(extraBoolKey, true),
+ new Intent(broadcastAction).putExtra(extraBoolKey, true)
+ .setPackage(mContext.getPackageName()),
PendingIntent.FLAG_UPDATE_CURRENT | pendingIntentFlagMutable);
// Because secondIntent.intentFilterEquals the first, the request should be replaced
@@ -1225,7 +1229,8 @@
networkFuture.complete(intent.getParcelableExtra(EXTRA_NETWORK));
}
};
- mContext.registerReceiver(receiver, filter);
+ final int flags = SdkLevel.isAtLeastT() ? RECEIVER_EXPORTED : 0;
+ mContext.registerReceiver(receiver, filter, flags);
final Network wifiNetwork = mCtsNetUtils.ensureWifiConnected();
try {
diff --git a/tests/cts/net/src/android/net/cts/IpSecManagerTunnelTest.java b/tests/cts/net/src/android/net/cts/IpSecManagerTunnelTest.java
index a9a3380..5fc3068 100644
--- a/tests/cts/net/src/android/net/cts/IpSecManagerTunnelTest.java
+++ b/tests/cts/net/src/android/net/cts/IpSecManagerTunnelTest.java
@@ -32,10 +32,13 @@
import static android.system.OsConstants.AF_INET;
import static android.system.OsConstants.AF_INET6;
+import static com.android.compatibility.common.util.PropertyUtil.getVsrApiLevel;
+
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeTrue;
@@ -80,6 +83,11 @@
private static final String TAG = IpSecManagerTunnelTest.class.getSimpleName();
+ // Redefine this flag here so that IPsec code shipped in a mainline module can build on old
+ // platforms before FEATURE_IPSEC_TUNNEL_MIGRATION API is released.
+ private static final String FEATURE_IPSEC_TUNNEL_MIGRATION =
+ "android.software.ipsec_tunnel_migration";
+
private static final InetAddress LOCAL_OUTER_4 = InetAddress.parseNumericAddress("192.0.2.1");
private static final InetAddress REMOTE_OUTER_4 = InetAddress.parseNumericAddress("192.0.2.2");
private static final InetAddress LOCAL_OUTER_6 =
@@ -994,6 +1002,41 @@
checkTunnelInput(innerFamily, outerFamily, useEncap, transportInTunnelMode);
}
+ /** Checks if FEATURE_IPSEC_TUNNEL_MIGRATION is enabled on the device */
+ private static boolean hasIpsecTunnelMigrateFeature() {
+ return sContext.getPackageManager().hasSystemFeature(FEATURE_IPSEC_TUNNEL_MIGRATION);
+ }
+
+ @IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ @Test
+ public void testHasIpSecTunnelMigrateFeature() throws Exception {
+ // FEATURE_IPSEC_TUNNEL_MIGRATION is required when VSR API is U/U+
+ if (getVsrApiLevel() > Build.VERSION_CODES.TIRAMISU) {
+ assertTrue(hasIpsecTunnelMigrateFeature());
+ }
+ }
+
+ @IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ @Test
+ public void testMigrateTunnelModeTransform() throws Exception {
+ assumeTrue(mCtsNetUtils.hasIpsecTunnelsFeature());
+ assumeTrue(hasIpsecTunnelMigrateFeature());
+
+ IpSecTransform.Builder transformBuilder = new IpSecTransform.Builder(sContext);
+ transformBuilder.setEncryption(new IpSecAlgorithm(IpSecAlgorithm.CRYPT_AES_CBC, CRYPT_KEY));
+ transformBuilder.setAuthentication(
+ new IpSecAlgorithm(IpSecAlgorithm.AUTH_HMAC_SHA256, AUTH_KEY, AUTH_KEY.length * 4));
+ int spi = getRandomSpi(LOCAL_OUTER_4, REMOTE_OUTER_4);
+
+ try (IpSecManager.SecurityParameterIndex outSpi =
+ mISM.allocateSecurityParameterIndex(REMOTE_OUTER_4, spi);
+ IpSecTransform outTunnelTransform =
+ transformBuilder.buildTunnelModeTransform(LOCAL_INNER_4, outSpi)) {
+ mISM.startTunnelModeTransformMigration(
+ outTunnelTransform, LOCAL_OUTER_4_NEW, REMOTE_OUTER_4_NEW);
+ }
+ }
+
// Transport-in-Tunnel mode tests
@Test
public void testTransportInTunnelModeV4InV4() throws Exception {
diff --git a/tests/cts/net/src/android/net/cts/NsdManagerTest.kt b/tests/cts/net/src/android/net/cts/NsdManagerTest.kt
index 2b5c305..66e7713 100644
--- a/tests/cts/net/src/android/net/cts/NsdManagerTest.kt
+++ b/tests/cts/net/src/android/net/cts/NsdManagerTest.kt
@@ -41,7 +41,14 @@
import android.net.cts.NsdManagerTest.NsdRegistrationRecord.RegistrationEvent.ServiceUnregistered
import android.net.cts.NsdManagerTest.NsdRegistrationRecord.RegistrationEvent.UnregistrationFailed
import android.net.cts.NsdManagerTest.NsdResolveRecord.ResolveEvent.ResolveFailed
+import android.net.cts.NsdManagerTest.NsdResolveRecord.ResolveEvent.ResolveStopped
import android.net.cts.NsdManagerTest.NsdResolveRecord.ResolveEvent.ServiceResolved
+import android.net.cts.NsdManagerTest.NsdResolveRecord.ResolveEvent.StopResolutionFailed
+import android.net.cts.NsdManagerTest.NsdServiceInfoCallbackRecord.ServiceInfoCallbackEvent.RegisterCallbackFailed
+import android.net.cts.NsdManagerTest.NsdServiceInfoCallbackRecord.ServiceInfoCallbackEvent.ServiceUpdated
+import android.net.cts.NsdManagerTest.NsdServiceInfoCallbackRecord.ServiceInfoCallbackEvent.ServiceUpdatedLost
+import android.net.cts.NsdManagerTest.NsdServiceInfoCallbackRecord.ServiceInfoCallbackEvent.UnregisterCallbackSucceeded
+import android.net.cts.util.CtsNetUtils
import android.net.nsd.NsdManager
import android.net.nsd.NsdManager.DiscoveryListener
import android.net.nsd.NsdManager.RegistrationListener
@@ -58,6 +65,7 @@
import com.android.net.module.util.ArrayTrackRecord
import com.android.net.module.util.TrackRecord
import com.android.networkstack.apishim.NsdShimImpl
+import com.android.networkstack.apishim.common.NsdShim
import com.android.testutils.ConnectivityModuleTest
import com.android.testutils.DevSdkIgnoreRule
import com.android.testutils.TestableNetworkAgent
@@ -66,15 +74,6 @@
import com.android.testutils.runAsShell
import com.android.testutils.tryTest
import com.android.testutils.waitForIdle
-import org.junit.After
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
-import org.junit.Assume.assumeTrue
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
import java.io.File
import java.net.ServerSocket
import java.nio.charset.StandardCharsets
@@ -86,6 +85,15 @@
import kotlin.test.assertNull
import kotlin.test.assertTrue
import kotlin.test.fail
+import org.junit.After
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
private const val TAG = "NsdManagerTest"
private const val TIMEOUT_MS = 2000L
@@ -113,6 +121,7 @@
private val serviceName = "NsdTest%09d".format(Random().nextInt(1_000_000_000))
private val serviceType = "_nmt%09d._tcp".format(Random().nextInt(1_000_000_000))
private val handlerThread = HandlerThread(NsdManagerTest::class.java.simpleName)
+ private val ctsNetUtils by lazy{ CtsNetUtils(context) }
private lateinit var testNetwork1: TestTapNetwork
private lateinit var testNetwork2: TestTapNetwork
@@ -155,7 +164,8 @@
inline fun <reified V : NsdEvent> expectCallback(timeoutMs: Long = TIMEOUT_MS): V {
val nextEvent = nextEvents.poll(timeoutMs)
- assertNotNull(nextEvent, "No callback received after $timeoutMs ms")
+ assertNotNull(nextEvent, "No callback received after $timeoutMs ms, expected " +
+ "${V::class.java.simpleName}")
assertTrue(nextEvent is V, "Expected ${V::class.java.simpleName} but got " +
nextEvent.javaClass.simpleName)
return nextEvent
@@ -182,10 +192,10 @@
val errorCode: Int
) : RegistrationEvent()
- data class ServiceRegistered(override val serviceInfo: NsdServiceInfo)
- : RegistrationEvent()
- data class ServiceUnregistered(override val serviceInfo: NsdServiceInfo)
- : RegistrationEvent()
+ data class ServiceRegistered(override val serviceInfo: NsdServiceInfo) :
+ RegistrationEvent()
+ data class ServiceUnregistered(override val serviceInfo: NsdServiceInfo) :
+ RegistrationEvent()
}
override fun onRegistrationFailed(si: NsdServiceInfo, err: Int) {
@@ -208,11 +218,11 @@
private class NsdDiscoveryRecord(expectedThreadId: Int? = null) :
DiscoveryListener, NsdRecord<NsdDiscoveryRecord.DiscoveryEvent>(expectedThreadId) {
sealed class DiscoveryEvent : NsdEvent {
- data class StartDiscoveryFailed(val serviceType: String, val errorCode: Int)
- : DiscoveryEvent()
+ data class StartDiscoveryFailed(val serviceType: String, val errorCode: Int) :
+ DiscoveryEvent()
- data class StopDiscoveryFailed(val serviceType: String, val errorCode: Int)
- : DiscoveryEvent()
+ data class StopDiscoveryFailed(val serviceType: String, val errorCode: Int) :
+ DiscoveryEvent()
data class DiscoveryStarted(val serviceType: String) : DiscoveryEvent()
data class DiscoveryStopped(val serviceType: String) : DiscoveryEvent()
@@ -259,10 +269,13 @@
private class NsdResolveRecord : ResolveListener,
NsdRecord<NsdResolveRecord.ResolveEvent>() {
sealed class ResolveEvent : NsdEvent {
- data class ResolveFailed(val serviceInfo: NsdServiceInfo, val errorCode: Int)
- : ResolveEvent()
+ data class ResolveFailed(val serviceInfo: NsdServiceInfo, val errorCode: Int) :
+ ResolveEvent()
data class ServiceResolved(val serviceInfo: NsdServiceInfo) : ResolveEvent()
+ data class ResolveStopped(val serviceInfo: NsdServiceInfo) : ResolveEvent()
+ data class StopResolutionFailed(val serviceInfo: NsdServiceInfo, val errorCode: Int) :
+ ResolveEvent()
}
override fun onResolveFailed(si: NsdServiceInfo, err: Int) {
@@ -272,6 +285,40 @@
override fun onServiceResolved(si: NsdServiceInfo) {
add(ServiceResolved(si))
}
+
+ override fun onResolveStopped(si: NsdServiceInfo) {
+ add(ResolveStopped(si))
+ }
+
+ override fun onStopResolutionFailed(si: NsdServiceInfo, err: Int) {
+ add(StopResolutionFailed(si, err))
+ }
+ }
+
+ private class NsdServiceInfoCallbackRecord : NsdShim.ServiceInfoCallbackShim,
+ NsdRecord<NsdServiceInfoCallbackRecord.ServiceInfoCallbackEvent>() {
+ sealed class ServiceInfoCallbackEvent : NsdEvent {
+ data class RegisterCallbackFailed(val errorCode: Int) : ServiceInfoCallbackEvent()
+ data class ServiceUpdated(val serviceInfo: NsdServiceInfo) : ServiceInfoCallbackEvent()
+ object ServiceUpdatedLost : ServiceInfoCallbackEvent()
+ object UnregisterCallbackSucceeded : ServiceInfoCallbackEvent()
+ }
+
+ override fun onServiceInfoCallbackRegistrationFailed(err: Int) {
+ add(RegisterCallbackFailed(err))
+ }
+
+ override fun onServiceUpdated(si: NsdServiceInfo) {
+ add(ServiceUpdated(si))
+ }
+
+ override fun onServiceLost() {
+ add(ServiceUpdatedLost)
+ }
+
+ override fun onServiceInfoCallbackUnregistered() {
+ add(UnregisterCallbackSucceeded)
+ }
}
@Before
@@ -739,6 +786,84 @@
NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER))
}
+ @Test
+ fun testStopServiceResolution() {
+ // This test requires shims supporting U+ APIs (NsdManager.stopServiceResolution)
+ assumeTrue(TestUtils.shouldTestUApis())
+
+ val si = NsdServiceInfo()
+ si.serviceType = this@NsdManagerTest.serviceType
+ si.serviceName = this@NsdManagerTest.serviceName
+ si.port = 12345 // Test won't try to connect so port does not matter
+
+ val resolveRecord = NsdResolveRecord()
+ // Try to resolve an unknown service then stop it immediately.
+ // Expected ResolveStopped callback.
+ nsdShim.resolveService(nsdManager, si, { it.run() }, resolveRecord)
+ nsdShim.stopServiceResolution(nsdManager, resolveRecord)
+ val stoppedCb = resolveRecord.expectCallback<ResolveStopped>()
+ assertEquals(si.serviceName, stoppedCb.serviceInfo.serviceName)
+ assertEquals(si.serviceType, stoppedCb.serviceInfo.serviceType)
+ }
+
+ @Test
+ fun testRegisterServiceInfoCallback() {
+ // This test requires shims supporting U+ APIs (NsdManager.subscribeService)
+ assumeTrue(TestUtils.shouldTestUApis())
+
+ // Ensure Wi-Fi network connected and get addresses
+ val wifiNetwork = ctsNetUtils.ensureWifiConnected()
+ val lp = cm.getLinkProperties(wifiNetwork)
+ assertNotNull(lp)
+ val addresses = lp.addresses
+ assertFalse(addresses.isEmpty())
+
+ val si = NsdServiceInfo().apply {
+ serviceType = this@NsdManagerTest.serviceType
+ serviceName = this@NsdManagerTest.serviceName
+ network = wifiNetwork
+ port = 12345 // Test won't try to connect so port does not matter
+ }
+
+ // Register service on Wi-Fi network
+ val registrationRecord = NsdRegistrationRecord()
+ registerService(registrationRecord, si)
+
+ val discoveryRecord = NsdDiscoveryRecord()
+ val cbRecord = NsdServiceInfoCallbackRecord()
+ tryTest {
+ // Discover service on Wi-Fi network.
+ nsdShim.discoverServices(nsdManager, serviceType, NsdManager.PROTOCOL_DNS_SD,
+ wifiNetwork, Executor { it.run() }, discoveryRecord)
+ val foundInfo = discoveryRecord.waitForServiceDiscovered(
+ serviceName, wifiNetwork)
+
+ // Subscribe to service and check the addresses are the same as Wi-Fi addresses
+ nsdShim.registerServiceInfoCallback(nsdManager, foundInfo, { it.run() }, cbRecord)
+ for (i in addresses.indices) {
+ val subscribeCb = cbRecord.expectCallback<ServiceUpdated>()
+ assertEquals(foundInfo.serviceName, subscribeCb.serviceInfo.serviceName)
+ val hostAddresses = subscribeCb.serviceInfo.hostAddresses
+ assertEquals(i + 1, hostAddresses.size)
+ for (hostAddress in hostAddresses) {
+ assertTrue(addresses.contains(hostAddress))
+ }
+ }
+ } cleanupStep {
+ nsdManager.unregisterService(registrationRecord)
+ registrationRecord.expectCallback<ServiceUnregistered>()
+ discoveryRecord.expectCallback<ServiceLost>()
+ cbRecord.expectCallback<ServiceUpdatedLost>()
+ } cleanupStep {
+ // Cancel subscription and check stop callback received.
+ nsdShim.unregisterServiceInfoCallback(nsdManager, cbRecord)
+ cbRecord.expectCallback<UnregisterCallbackSucceeded>()
+ } cleanup {
+ nsdManager.stopServiceDiscovery(discoveryRecord)
+ discoveryRecord.expectCallback<DiscoveryStopped>()
+ }
+ }
+
/**
* Register a service and return its registration record.
*/
diff --git a/tests/unit/Android.bp b/tests/unit/Android.bp
index 209430a..e0de246 100644
--- a/tests/unit/Android.bp
+++ b/tests/unit/Android.bp
@@ -73,8 +73,6 @@
"java/com/android/server/connectivity/NetdEventListenerServiceTest.java",
"java/com/android/server/connectivity/VpnTest.java",
"java/com/android/server/net/ipmemorystore/*.java",
- "java/com/android/server/connectivity/mdns/**/*.java",
- "java/com/android/server/connectivity/mdns/**/*.kt",
]
}
@@ -149,7 +147,6 @@
static_libs: [
"services.core",
"services.net",
- "service-mdns",
],
jni_libs: [
"libandroid_net_connectivity_com_android_net_module_util_jni",
diff --git a/tests/unit/java/android/net/NetworkTemplateTest.kt b/tests/unit/java/android/net/NetworkTemplateTest.kt
index c3440c5..78854fb 100644
--- a/tests/unit/java/android/net/NetworkTemplateTest.kt
+++ b/tests/unit/java/android/net/NetworkTemplateTest.kt
@@ -34,10 +34,8 @@
import android.net.NetworkStats.ROAMING_ALL
import android.net.NetworkTemplate.MATCH_CARRIER
import android.net.NetworkTemplate.MATCH_MOBILE
-import android.net.NetworkTemplate.MATCH_MOBILE_WILDCARD
import android.net.NetworkTemplate.MATCH_TEST
import android.net.NetworkTemplate.MATCH_WIFI
-import android.net.NetworkTemplate.MATCH_WIFI_WILDCARD
import android.net.NetworkTemplate.NETWORK_TYPE_ALL
import android.net.NetworkTemplate.OEM_MANAGED_ALL
import android.net.NetworkTemplate.OEM_MANAGED_NO
@@ -231,7 +229,6 @@
val templateMobileWildcard = buildTemplateMobileWildcard()
val templateMobileNullImsiWithRatType = NetworkTemplate.Builder(MATCH_MOBILE)
.setRatType(TelephonyManager.NETWORK_TYPE_UMTS).build()
-
val mobileImsi1 = buildMobileNetworkState(TEST_IMSI1)
val identMobile1 = buildNetworkIdentity(mockContext, mobileImsi1,
false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS)
@@ -447,18 +444,18 @@
@Test
fun testParcelUnparcel() {
- val templateMobile = NetworkTemplate(MATCH_MOBILE, TEST_IMSI1, arrayOf(TEST_IMSI1),
+ val templateMobile = NetworkTemplate(MATCH_MOBILE, arrayOf(TEST_IMSI1),
emptyArray<String>(), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL,
TelephonyManager.NETWORK_TYPE_LTE, OEM_MANAGED_ALL)
- val templateWifi = NetworkTemplate(MATCH_WIFI, null, emptyArray<String>(),
+ val templateWifi = NetworkTemplate(MATCH_WIFI, emptyArray<String>(),
arrayOf(TEST_WIFI_KEY1), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, 0,
OEM_MANAGED_ALL)
- val templateOem = NetworkTemplate(MATCH_MOBILE_WILDCARD, null, emptyArray<String>(),
+ val templateOem = NetworkTemplate(MATCH_MOBILE, emptyArray<String>(),
emptyArray<String>(), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, 0,
OEM_MANAGED_YES)
- assertParcelSane(templateMobile, 9)
- assertParcelSane(templateWifi, 9)
- assertParcelSane(templateOem, 9)
+ assertParcelSane(templateMobile, 8)
+ assertParcelSane(templateWifi, 8)
+ assertParcelSane(templateOem, 8)
}
// Verify NETWORK_TYPE_* constants in NetworkTemplate do not conflict with
@@ -491,13 +488,14 @@
* @param matchType A match rule from {@code NetworkTemplate.MATCH_*} corresponding to the
* networkType.
* @param subscriberId To be populated with {@code TEST_IMSI*} only if networkType is
- * {@code TYPE_MOBILE}. May be left as null when matchType is
- * {@link NetworkTemplate.MATCH_MOBILE_WILDCARD}.
- * @param templateWifiKey Top be populated with {@code TEST_WIFI_KEY*} only if networkType is
- * {@code TYPE_WIFI}. May be left as null when matchType is
- * {@link NetworkTemplate.MATCH_WIFI_WILDCARD}.
- * @param identWifiKey If networkType is {@code TYPE_WIFI}, this value must *NOT* be null. Provide
- * one of {@code TEST_WIFI_KEY*}.
+ * {@code TYPE_MOBILE}. Note that {@code MATCH_MOBILE} with an empty subscriberId list
+ * will match any subscriber ID.
+ * @param templateWifiKey To be populated with {@code TEST_WIFI_KEY*} only if networkType is
+ * {@code TYPE_WIFI}. Note that {@code MATCH_WIFI} with both an empty subscriberId list
+ * and an empty wifiNetworkKey list will match any subscriber ID and/or any wifi network
+ * key.
+ * @param identWifiKey If networkType is {@code TYPE_WIFI}, this value must *NOT* be null.
+ * Provide one of {@code TEST_WIFI_KEY*}.
*/
private fun matchOemManagedIdent(
networkType: Int,
@@ -507,13 +505,15 @@
identWifiKey: String? = null
) {
val oemManagedStates = arrayOf(OEM_NONE, OEM_PAID, OEM_PRIVATE, OEM_PAID or OEM_PRIVATE)
- val matchSubscriberIds = arrayOf(subscriberId)
- val matchWifiNetworkKeys = arrayOf(templateWifiKey)
+ val matchSubscriberIds =
+ if (subscriberId == null) emptyArray<String>() else arrayOf(subscriberId)
+ val matchWifiNetworkKeys =
+ if (templateWifiKey == null) emptyArray<String>() else arrayOf(templateWifiKey)
- val templateOemYes = NetworkTemplate(matchType, subscriberId, matchSubscriberIds,
+ val templateOemYes = NetworkTemplate(matchType, matchSubscriberIds,
matchWifiNetworkKeys, METERED_ALL, ROAMING_ALL,
DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_YES)
- val templateOemAll = NetworkTemplate(matchType, subscriberId, matchSubscriberIds,
+ val templateOemAll = NetworkTemplate(matchType, matchSubscriberIds,
matchWifiNetworkKeys, METERED_ALL, ROAMING_ALL,
DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_ALL)
@@ -524,7 +524,7 @@
// Create a template with each OEM managed type and match it against the NetworkIdentity
for (templateOemManagedState in oemManagedStates) {
- val template = NetworkTemplate(matchType, subscriberId, matchSubscriberIds,
+ val template = NetworkTemplate(matchType, matchSubscriberIds,
matchWifiNetworkKeys, METERED_ALL, ROAMING_ALL,
DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, templateOemManagedState)
if (identityOemManagedState == templateOemManagedState) {
@@ -547,11 +547,10 @@
@Test
fun testOemManagedMatchesIdent() {
matchOemManagedIdent(TYPE_MOBILE, MATCH_MOBILE, subscriberId = TEST_IMSI1)
- matchOemManagedIdent(TYPE_MOBILE, MATCH_MOBILE_WILDCARD)
+ matchOemManagedIdent(TYPE_MOBILE, MATCH_MOBILE)
matchOemManagedIdent(TYPE_WIFI, MATCH_WIFI, templateWifiKey = TEST_WIFI_KEY1,
identWifiKey = TEST_WIFI_KEY1)
- matchOemManagedIdent(TYPE_WIFI, MATCH_WIFI_WILDCARD,
- identWifiKey = TEST_WIFI_KEY1)
+ matchOemManagedIdent(TYPE_WIFI, MATCH_WIFI, identWifiKey = TEST_WIFI_KEY1)
}
@Test
diff --git a/tests/unit/java/android/net/nsd/NsdServiceInfoTest.java b/tests/unit/java/android/net/nsd/NsdServiceInfoTest.java
index 64355ed..9ce0693 100644
--- a/tests/unit/java/android/net/nsd/NsdServiceInfoTest.java
+++ b/tests/unit/java/android/net/nsd/NsdServiceInfoTest.java
@@ -21,6 +21,7 @@
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import android.net.InetAddresses;
import android.net.Network;
import android.os.Build;
import android.os.Bundle;
@@ -38,6 +39,7 @@
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
+import java.util.List;
import java.util.Map;
@RunWith(DevSdkIgnoreRunner.class)
@@ -45,6 +47,8 @@
@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.S_V2)
public class NsdServiceInfoTest {
+ private static final InetAddress IPV4_ADDRESS = InetAddresses.parseNumericAddress("192.0.2.1");
+ private static final InetAddress IPV6_ADDRESS = InetAddresses.parseNumericAddress("2001:db8::");
public final static InetAddress LOCALHOST;
static {
// Because test.
@@ -124,6 +128,7 @@
fullInfo.setServiceType("_kitten._tcp");
fullInfo.setPort(4242);
fullInfo.setHost(LOCALHOST);
+ fullInfo.setHostAddresses(List.of(IPV4_ADDRESS));
fullInfo.setNetwork(new Network(123));
fullInfo.setInterfaceIndex(456);
checkParcelable(fullInfo);
@@ -139,6 +144,7 @@
attributedInfo.setServiceType("_kitten._tcp");
attributedInfo.setPort(4242);
attributedInfo.setHost(LOCALHOST);
+ fullInfo.setHostAddresses(List.of(IPV6_ADDRESS, IPV4_ADDRESS));
attributedInfo.setAttribute("color", "pink");
attributedInfo.setAttribute("sound", (new String("にゃあ")).getBytes("UTF-8"));
attributedInfo.setAttribute("adorable", (String) null);
diff --git a/tests/unit/java/com/android/server/ConnectivityServiceTest.java b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
index 51f54a4..a2d284b 100755
--- a/tests/unit/java/com/android/server/ConnectivityServiceTest.java
+++ b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
@@ -169,6 +169,15 @@
import static com.android.testutils.MiscAsserts.assertRunsInAtMost;
import static com.android.testutils.MiscAsserts.assertSameElements;
import static com.android.testutils.MiscAsserts.assertThrows;
+import static com.android.testutils.RecorderCallback.CallbackEntry.AVAILABLE;
+import static com.android.testutils.RecorderCallback.CallbackEntry.BLOCKED_STATUS;
+import static com.android.testutils.RecorderCallback.CallbackEntry.LINK_PROPERTIES_CHANGED;
+import static com.android.testutils.RecorderCallback.CallbackEntry.LOSING;
+import static com.android.testutils.RecorderCallback.CallbackEntry.LOST;
+import static com.android.testutils.RecorderCallback.CallbackEntry.NETWORK_CAPS_UPDATED;
+import static com.android.testutils.RecorderCallback.CallbackEntry.RESUMED;
+import static com.android.testutils.RecorderCallback.CallbackEntry.SUSPENDED;
+import static com.android.testutils.RecorderCallback.CallbackEntry.UNAVAILABLE;
import static com.android.testutils.TestPermissionUtil.runAsShell;
import static org.junit.Assert.assertEquals;
@@ -530,9 +539,9 @@
private ConnectivityServiceDependencies mDeps;
private ConnectivityService mService;
private WrappedConnectivityManager mCm;
- private TestNetworkAgentWrapper mWiFiNetworkAgent;
- private TestNetworkAgentWrapper mCellNetworkAgent;
- private TestNetworkAgentWrapper mEthernetNetworkAgent;
+ private TestNetworkAgentWrapper mWiFiAgent;
+ private TestNetworkAgentWrapper mCellAgent;
+ private TestNetworkAgentWrapper mEthernetAgent;
private MockVpn mMockVpn;
private Context mContext;
private NetworkPolicyCallback mPolicyCallback;
@@ -839,6 +848,7 @@
verify(mBroadcastOptionsShim).setDeliveryGroupMatchingKey(
eq(CONNECTIVITY_ACTION),
eq(createDeliveryGroupKeyForConnectivityAction(ni)));
+ verify(mBroadcastOptionsShim).setDeferUntilActive(eq(true));
} catch (UnsupportedApiLevelException e) {
throw new RuntimeException(e);
}
@@ -875,9 +885,9 @@
private void waitForIdle() {
HandlerUtils.waitForIdle(mCsHandlerThread, TIMEOUT_MS);
- waitForIdle(mCellNetworkAgent, TIMEOUT_MS);
- waitForIdle(mWiFiNetworkAgent, TIMEOUT_MS);
- waitForIdle(mEthernetNetworkAgent, TIMEOUT_MS);
+ waitForIdle(mCellAgent, TIMEOUT_MS);
+ waitForIdle(mWiFiAgent, TIMEOUT_MS);
+ waitForIdle(mEthernetAgent, TIMEOUT_MS);
HandlerUtils.waitForIdle(mCsHandlerThread, TIMEOUT_MS);
HandlerUtils.waitForIdle(ConnectivityThread.get(), TIMEOUT_MS);
}
@@ -900,15 +910,15 @@
// Bring up a network that we can use to send messages to ConnectivityService.
ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTED);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
b.expectBroadcast();
- Network n = mWiFiNetworkAgent.getNetwork();
+ Network n = mWiFiAgent.getNetwork();
assertNotNull(n);
// Tests that calling waitForIdle waits for messages to be processed.
for (int i = 0; i < attempts; i++) {
- mWiFiNetworkAgent.setSignalStrength(i);
+ mWiFiAgent.setSignalStrength(i);
waitForIdle();
assertEquals(i, mCm.getNetworkCapabilities(n).getSignalStrength());
}
@@ -920,16 +930,16 @@
public void verifyThatNotWaitingForIdleCausesRaceConditions() throws Exception {
// Bring up a network that we can use to send messages to ConnectivityService.
ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTED);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
b.expectBroadcast();
- Network n = mWiFiNetworkAgent.getNetwork();
+ Network n = mWiFiAgent.getNetwork();
assertNotNull(n);
// Ensure that not calling waitForIdle causes a race condition.
final int attempts = 50; // Causes the test to take about 200ms on bullhead-eng.
for (int i = 0; i < attempts; i++) {
- mWiFiNetworkAgent.setSignalStrength(i);
+ mWiFiAgent.setSignalStrength(i);
if (i != mCm.getNetworkCapabilities(n).getSignalStrength()) {
// We hit a race condition, as expected. Pass the test.
return;
@@ -2116,17 +2126,17 @@
unregisterDefaultNetworkCallbacks();
maybeTearDownEnterpriseNetwork();
setAlwaysOnNetworks(false);
- if (mCellNetworkAgent != null) {
- mCellNetworkAgent.disconnect();
- mCellNetworkAgent = null;
+ if (mCellAgent != null) {
+ mCellAgent.disconnect();
+ mCellAgent = null;
}
- if (mWiFiNetworkAgent != null) {
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent = null;
+ if (mWiFiAgent != null) {
+ mWiFiAgent.disconnect();
+ mWiFiAgent = null;
}
- if (mEthernetNetworkAgent != null) {
- mEthernetNetworkAgent.disconnect();
- mEthernetNetworkAgent = null;
+ if (mEthernetAgent != null) {
+ mEthernetAgent.disconnect();
+ mEthernetAgent = null;
}
if (mQosCallbackMockHelper != null) {
@@ -2189,13 +2199,13 @@
}
switch (transport) {
case TRANSPORT_WIFI:
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
break;
case TRANSPORT_CELLULAR:
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
break;
case TRANSPORT_ETHERNET:
- assertEquals(mEthernetNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mEthernetAgent.getNetwork(), mCm.getActiveNetwork());
break;
default:
break;
@@ -2369,10 +2379,10 @@
@Test
public void testNetworkFeature() throws Exception {
// Connect the cell agent and wait for the connected broadcast.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_SUPL);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.addCapability(NET_CAPABILITY_SUPL);
ExpectedBroadcast b = expectConnectivityAction(TYPE_MOBILE, DetailedState.CONNECTED);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
// Build legacy request for SUPL.
@@ -2386,45 +2396,45 @@
b = registerConnectivityBroadcast(1);
final TestNetworkCallback callback = new TestNetworkCallback();
mCm.requestNetwork(legacyRequest, callback);
- callback.expect(CallbackEntry.AVAILABLE, mCellNetworkAgent);
+ callback.expect(AVAILABLE, mCellAgent);
mCm.unregisterNetworkCallback(callback);
b.expectNoBroadcast(800); // 800ms long enough to at least flake if this is sent
// Disconnect the network and expect mobile disconnected broadcast.
b = expectConnectivityAction(TYPE_MOBILE, DetailedState.DISCONNECTED);
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
b.expectBroadcast();
}
@Test
public void testLingering() throws Exception {
verifyNoNetwork();
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
assertNull(mCm.getActiveNetworkInfo());
assertNull(mCm.getActiveNetwork());
// Test bringing up validated cellular.
ExpectedBroadcast b = expectConnectivityAction(TYPE_MOBILE, DetailedState.CONNECTED);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
assertLength(2, mCm.getAllNetworks());
- assertTrue(mCm.getAllNetworks()[0].equals(mCm.getActiveNetwork()) ||
- mCm.getAllNetworks()[1].equals(mCm.getActiveNetwork()));
- assertTrue(mCm.getAllNetworks()[0].equals(mWiFiNetworkAgent.getNetwork()) ||
- mCm.getAllNetworks()[1].equals(mWiFiNetworkAgent.getNetwork()));
+ assertTrue(mCm.getAllNetworks()[0].equals(mCm.getActiveNetwork())
+ || mCm.getAllNetworks()[1].equals(mCm.getActiveNetwork()));
+ assertTrue(mCm.getAllNetworks()[0].equals(mWiFiAgent.getNetwork())
+ || mCm.getAllNetworks()[1].equals(mWiFiAgent.getNetwork()));
// Test bringing up validated WiFi.
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
assertLength(2, mCm.getAllNetworks());
- assertTrue(mCm.getAllNetworks()[0].equals(mCm.getActiveNetwork()) ||
- mCm.getAllNetworks()[1].equals(mCm.getActiveNetwork()));
- assertTrue(mCm.getAllNetworks()[0].equals(mCellNetworkAgent.getNetwork()) ||
- mCm.getAllNetworks()[1].equals(mCellNetworkAgent.getNetwork()));
+ assertTrue(mCm.getAllNetworks()[0].equals(mCm.getActiveNetwork())
+ || mCm.getAllNetworks()[1].equals(mCm.getActiveNetwork()));
+ assertTrue(mCm.getAllNetworks()[0].equals(mCellAgent.getNetwork())
+ || mCm.getAllNetworks()[1].equals(mCellAgent.getNetwork()));
// Test cellular linger timeout.
- mCellNetworkAgent.expectDisconnected();
+ mCellAgent.expectDisconnected();
waitForIdle();
assertLength(1, mCm.getAllNetworks());
verifyActiveNetwork(TRANSPORT_WIFI);
@@ -2432,7 +2442,7 @@
assertEquals(mCm.getAllNetworks()[0], mCm.getActiveNetwork());
// Test WiFi disconnect.
b = registerConnectivityBroadcast(1);
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
b.expectBroadcast();
verifyNoNetwork();
}
@@ -2449,43 +2459,43 @@
// 1. Create a network that is not requested by anyone, and does not satisfy any of the
// default requests. Verify that the network will be inactive instead of torn down.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithoutInternet();
- listenCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithoutInternet();
+ listenCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
listenCallback.assertNoCallback();
// Verify that the network will be torn down after nascent expiry. A small period of time
// is added in case of flakiness.
final int nascentTimeoutMs =
mService.mNascentDelayMs + mService.mNascentDelayMs / 4;
- listenCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent, nascentTimeoutMs);
+ listenCallback.expect(LOST, mWiFiAgent, nascentTimeoutMs);
// 2. Create a network that is satisfied by a request comes later.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithoutInternet();
- listenCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithoutInternet();
+ listenCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
final NetworkRequest wifiRequest = new NetworkRequest.Builder()
.addTransportType(TRANSPORT_WIFI).build();
final TestNetworkCallback wifiCallback = new TestNetworkCallback();
mCm.requestNetwork(wifiRequest, wifiCallback);
- wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Verify that the network will be kept since the request is still satisfied. And is able
// to get disconnected as usual if the request is released after the nascent timer expires.
listenCallback.assertNoCallback(nascentTimeoutMs);
mCm.unregisterNetworkCallback(wifiCallback);
- listenCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ listenCallback.expect(LOST, mWiFiAgent);
// 3. Create a network that is satisfied by a request comes later.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithoutInternet();
- listenCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithoutInternet();
+ listenCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
mCm.requestNetwork(wifiRequest, wifiCallback);
- wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Verify that the network will still be torn down after the request gets removed.
mCm.unregisterNetworkCallback(wifiCallback);
- listenCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ listenCallback.expect(LOST, mWiFiAgent);
// There is no need to ensure that LOSING is never sent in the common case that the
// network immediately satisfies a request that was already present, because it is already
@@ -2518,20 +2528,20 @@
.addCapability(NET_CAPABILITY_FOREGROUND).build(), fgMobileListenCallback);
// Connect wifi, which satisfies default request.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- wifiListenCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ wifiListenCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
// Connect a cellular network, verify that satisfies only the background callback.
setAlwaysOnNetworks(true);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- bgMobileListenCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ bgMobileListenCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
fgMobileListenCallback.assertNoCallback();
- assertFalse(isForegroundNetwork(mCellNetworkAgent));
+ assertFalse(isForegroundNetwork(mCellAgent));
- mCellNetworkAgent.disconnect();
- bgMobileListenCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ bgMobileListenCallback.expect(LOST, mCellAgent);
fgMobileListenCallback.assertNoCallback();
mCm.unregisterNetworkCallback(wifiListenCallback);
@@ -2596,34 +2606,34 @@
final boolean cellRadioTimesharingCapable) throws Exception {
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up unvalidated WiFi
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent.connect(false);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test bringing up unvalidated cellular
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false);
waitForIdle();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test cellular disconnect.
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
waitForIdle();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test bringing up validated cellular
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
b = registerConnectivityBroadcast(2);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Test cellular disconnect.
b = registerConnectivityBroadcast(2);
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test WiFi disconnect.
b = registerConnectivityBroadcast(1);
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
b.expectBroadcast();
verifyNoNetwork();
}
@@ -2644,25 +2654,25 @@
final boolean cellRadioTimesharingCapable) throws Exception {
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up unvalidated cellular.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mCellNetworkAgent.connect(false);
+ mCellAgent.connect(false);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Test bringing up unvalidated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent.connect(false);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test WiFi disconnect.
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Test cellular disconnect.
b = registerConnectivityBroadcast(1);
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
b.expectBroadcast();
verifyNoNetwork();
}
@@ -2683,28 +2693,28 @@
final boolean cellRadioTimesharingCapable) throws Exception {
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up unvalidated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent.connect(false);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
- assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
// Test bringing up validated cellular.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
b = registerConnectivityBroadcast(2);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
- assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
// Test cellular disconnect.
b = registerConnectivityBroadcast(2);
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Unlingering a network should not cause it to be marked as validated.
- assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
}
@@ -2776,7 +2786,7 @@
net1.expectDisconnected(TEST_CALLBACK_TIMEOUT_MS);
}
net1.disconnect();
- generalCb.expect(CallbackEntry.LOST, net1);
+ generalCb.expect(LOST, net1);
// Remove primary from net 2
net2.setScore(new NetworkScore.Builder().build());
@@ -2813,7 +2823,7 @@
net2.expectDisconnected(TEST_CALLBACK_TIMEOUT_MS);
}
net2.disconnect();
- generalCb.expect(CallbackEntry.LOST, net2);
+ generalCb.expect(LOST, net2);
defaultCb.assertNoCallback();
net3.disconnect();
@@ -2838,25 +2848,25 @@
final boolean cellRadioTimesharingCapable) throws Exception {
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up validated cellular.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Test bringing up validated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test WiFi getting really weak.
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.adjustScore(-11);
+ mWiFiAgent.adjustScore(-11);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Test WiFi restoring signal strength.
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.adjustScore(11);
+ mWiFiAgent.adjustScore(11);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
}
@@ -2878,29 +2888,29 @@
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up WiFi without NET_CAPABILITY_INTERNET.
// Expect it to be torn down immediately because it satisfies no requests.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithoutInternet();
- mWiFiNetworkAgent.expectDisconnected();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithoutInternet();
+ mWiFiAgent.expectDisconnected();
// Test bringing up cellular without NET_CAPABILITY_INTERNET.
// Expect it to be torn down immediately because it satisfies no requests.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mCellNetworkAgent.connectWithoutInternet();
- mCellNetworkAgent.expectDisconnected();
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mCellAgent.connectWithoutInternet();
+ mCellAgent.expectDisconnected();
// Test bringing up validated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
final ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test bringing up unvalidated cellular.
// Expect it to be torn down because it could never be the highest scoring network
// satisfying the default request even if it validated.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false);
- mCellNetworkAgent.expectDisconnected();
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false);
+ mCellAgent.expectDisconnected();
verifyActiveNetwork(TRANSPORT_WIFI);
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
}
// TODO : migrate to @Parameterized
@@ -2919,37 +2929,37 @@
final boolean cellRadioTimesharingCapable) throws Exception {
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up validated cellular.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Test bringing up validated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Reevaluate WiFi (it'll instantly fail DNS).
b = registerConnectivityBroadcast(2);
- assertTrue(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertTrue(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
- mCm.reportBadNetwork(mWiFiNetworkAgent.getNetwork());
+ mCm.reportBadNetwork(mWiFiAgent.getNetwork());
// Should quickly fall back to Cellular.
b.expectBroadcast();
- assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Reevaluate cellular (it'll instantly fail DNS).
b = registerConnectivityBroadcast(2);
- assertTrue(mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork()).hasCapability(
+ assertTrue(mCm.getNetworkCapabilities(mCellAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
- mCm.reportBadNetwork(mCellNetworkAgent.getNetwork());
+ mCm.reportBadNetwork(mCellAgent.getNetwork());
// Should quickly fall back to WiFi.
b.expectBroadcast();
- assertFalse(mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mCellAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
- assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
verifyActiveNetwork(TRANSPORT_WIFI);
}
@@ -2970,25 +2980,25 @@
final boolean cellRadioTimesharingCapable) throws Exception {
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up unvalidated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent.connect(false);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test bringing up validated cellular.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
b = registerConnectivityBroadcast(2);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Reevaluate cellular (it'll instantly fail DNS).
b = registerConnectivityBroadcast(2);
- assertTrue(mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork()).hasCapability(
+ assertTrue(mCm.getNetworkCapabilities(mCellAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
- mCm.reportBadNetwork(mCellNetworkAgent.getNetwork());
+ mCm.reportBadNetwork(mCellAgent.getNetwork());
// Should quickly fall back to WiFi.
b.expectBroadcast();
- assertFalse(mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mCellAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
verifyActiveNetwork(TRANSPORT_WIFI);
}
@@ -3016,7 +3026,7 @@
}
public CallbackEntry.Losing expectLosing(final HasNetwork n, final long timeoutMs) {
- final CallbackEntry.Losing losing = expect(CallbackEntry.LOSING, n, timeoutMs);
+ final CallbackEntry.Losing losing = expect(LOSING, n, timeoutMs);
final int maxMsToLive = losing.getMaxMsToLive();
if (maxMsToLive < 0 || maxMsToLive > mService.mLingerDelayMs) {
// maxMsToLive is the value that was received in the onLosing callback. That must
@@ -3052,19 +3062,19 @@
static void expectOnLost(TestNetworkAgentWrapper network, TestNetworkCallback ... callbacks) {
for (TestNetworkCallback c : callbacks) {
- c.expect(CallbackEntry.LOST, network);
+ c.expect(LOST, network);
}
}
static void expectAvailableCallbacksUnvalidatedWithSpecifier(TestNetworkAgentWrapper network,
NetworkSpecifier specifier, TestNetworkCallback ... callbacks) {
for (TestNetworkCallback c : callbacks) {
- c.expect(CallbackEntry.AVAILABLE, network);
+ c.expect(AVAILABLE, network);
c.expectCapabilitiesThat(network, (nc) ->
!nc.hasCapability(NET_CAPABILITY_VALIDATED)
&& Objects.equals(specifier, nc.getNetworkSpecifier()));
- c.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, network);
- c.expect(CallbackEntry.BLOCKED_STATUS, network);
+ c.expect(LINK_PROPERTIES_CHANGED, network);
+ c.expect(BLOCKED_STATUS, network);
}
}
@@ -3074,12 +3084,12 @@
final NetworkRequest wifiRequest = new NetworkRequest.Builder()
.addTransportType(TRANSPORT_WIFI).build();
mCm.requestNetwork(wifiRequest, cb);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
// Updating the score triggers a rematch.
- mWiFiNetworkAgent.setScore(new NetworkScore.Builder().build());
+ mWiFiAgent.setScore(new NetworkScore.Builder().build());
cb.assertNoCallback();
- mWiFiNetworkAgent.connect(false);
- cb.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent.connect(false);
+ cb.expectAvailableCallbacksUnvalidated(mWiFiAgent);
cb.assertNoCallback();
mCm.unregisterNetworkCallback(cb);
}
@@ -3090,13 +3100,13 @@
final NetworkRequest wifiRequest = new NetworkRequest.Builder()
.addTransportType(TRANSPORT_WIFI).build();
mCm.registerNetworkCallback(wifiRequest, cb);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- final NetworkCapabilities nc = mWiFiNetworkAgent.getNetworkCapabilities();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ final NetworkCapabilities nc = mWiFiAgent.getNetworkCapabilities();
nc.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
- mWiFiNetworkAgent.setNetworkCapabilities(nc, true /* sendToConnectivityService */);
+ mWiFiAgent.setNetworkCapabilities(nc, true /* sendToConnectivityService */);
cb.assertNoCallback();
- mWiFiNetworkAgent.connect(false);
- cb.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent.connect(false);
+ cb.expectAvailableCallbacksUnvalidated(mWiFiAgent);
final CallbackEntry found = CollectionUtils.findLast(cb.getHistory(),
it -> it instanceof CallbackEntry.CapabilitiesChanged);
assertTrue(((CallbackEntry.CapabilitiesChanged) found).getCaps()
@@ -3122,79 +3132,79 @@
// Test unvalidated networks
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false);
- genericNetworkCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- cellNetworkCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false);
+ genericNetworkCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ cellNetworkCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
b.expectBroadcast();
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
// This should not trigger spurious onAvailable() callbacks, b/21762680.
- mCellNetworkAgent.adjustScore(-1);
+ mCellAgent.adjustScore(-1);
waitForIdle();
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
b.expectBroadcast();
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.disconnect();
- genericNetworkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- wifiNetworkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ genericNetworkCallback.expect(LOST, mWiFiAgent);
+ wifiNetworkCallback.expect(LOST, mWiFiAgent);
cellNetworkCallback.assertNoCallback();
b.expectBroadcast();
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
b = registerConnectivityBroadcast(1);
- mCellNetworkAgent.disconnect();
- genericNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- cellNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ genericNetworkCallback.expect(LOST, mCellAgent);
+ cellNetworkCallback.expect(LOST, mCellAgent);
b.expectBroadcast();
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
// Test validated networks
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- genericNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ genericNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
// This should not trigger spurious onAvailable() callbacks, b/21762680.
- mCellNetworkAgent.adjustScore(-1);
+ mCellAgent.adjustScore(-1);
waitForIdle();
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- genericNetworkCallback.expectLosing(mCellNetworkAgent);
- genericNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- wifiNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- cellNetworkCallback.expectLosing(mCellNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ genericNetworkCallback.expectLosing(mCellAgent);
+ genericNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ wifiNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ cellNetworkCallback.expectLosing(mCellAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
// Cell will disconnect after the lingering period. Before that elapses check that
// there have been no callbacks.
assertNoCallbacks(0 /* timeoutMs */,
genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
- mWiFiNetworkAgent.disconnect();
- genericNetworkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- wifiNetworkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ genericNetworkCallback.expect(LOST, mWiFiAgent);
+ wifiNetworkCallback.expect(LOST, mWiFiAgent);
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
- mCellNetworkAgent.disconnect();
- genericNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- cellNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ genericNetworkCallback.expect(LOST, mCellAgent);
+ cellNetworkCallback.expect(LOST, mCellAgent);
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
}
@@ -3206,10 +3216,10 @@
mCm.registerNetworkCallback(wifiRequest, callback);
mCm.registerDefaultNetworkCallback(defaultCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
final LinkProperties newLp = new LinkProperties();
final Uri capportUrl = Uri.parse("https://capport.example.com/api");
@@ -3218,20 +3228,20 @@
final Uri expectedCapportUrl = sanitized ? null : capportUrl;
newLp.setCaptivePortalApiUrl(capportUrl);
- mWiFiNetworkAgent.sendLinkProperties(newLp);
- callback.expectLinkPropertiesThat(mWiFiNetworkAgent, lp ->
+ mWiFiAgent.sendLinkProperties(newLp);
+ callback.expectLinkPropertiesThat(mWiFiAgent, lp ->
Objects.equals(expectedCapportUrl, lp.getCaptivePortalApiUrl()));
- defaultCallback.expectLinkPropertiesThat(mWiFiNetworkAgent, lp ->
+ defaultCallback.expectLinkPropertiesThat(mWiFiAgent, lp ->
Objects.equals(expectedCapportUrl, lp.getCaptivePortalApiUrl()));
final CaptivePortalData expectedCapportData = sanitized ? null : capportData;
- mWiFiNetworkAgent.notifyCapportApiDataChanged(capportData);
- callback.expectLinkPropertiesThat(mWiFiNetworkAgent, lp ->
+ mWiFiAgent.notifyCapportApiDataChanged(capportData);
+ callback.expectLinkPropertiesThat(mWiFiAgent, lp ->
Objects.equals(expectedCapportData, lp.getCaptivePortalData()));
- defaultCallback.expectLinkPropertiesThat(mWiFiNetworkAgent, lp ->
+ defaultCallback.expectLinkPropertiesThat(mWiFiAgent, lp ->
Objects.equals(expectedCapportData, lp.getCaptivePortalData()));
- final LinkProperties lp = mCm.getLinkProperties(mWiFiNetworkAgent.getNetwork());
+ final LinkProperties lp = mCm.getLinkProperties(mWiFiAgent.getNetwork());
assertEquals(expectedCapportUrl, lp.getCaptivePortalApiUrl());
assertEquals(expectedCapportData, lp.getCaptivePortalData());
}
@@ -3266,19 +3276,18 @@
final int originalOwnerUid = Process.myUid();
ncTemplate.setOwnerUid(originalOwnerUid);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(),
- ncTemplate);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(), ncTemplate);
+ mWiFiAgent.connect(false);
waitForIdle();
- // Send ConnectivityService an update to the mWiFiNetworkAgent's capabilities that changes
+ // Send ConnectivityService an update to the mWiFiAgent's capabilities that changes
// the owner UID and an unrelated capability.
- NetworkCapabilities agentCapabilities = mWiFiNetworkAgent.getNetworkCapabilities();
+ NetworkCapabilities agentCapabilities = mWiFiAgent.getNetworkCapabilities();
assertEquals(originalOwnerUid, agentCapabilities.getOwnerUid());
agentCapabilities.setOwnerUid(42);
assertFalse(agentCapabilities.hasCapability(NET_CAPABILITY_NOT_CONGESTED));
agentCapabilities.addCapability(NET_CAPABILITY_NOT_CONGESTED);
- mWiFiNetworkAgent.setNetworkCapabilities(agentCapabilities, true);
+ mWiFiAgent.setNetworkCapabilities(agentCapabilities, true);
waitForIdle();
// Owner UIDs are not visible without location permission.
@@ -3286,7 +3295,7 @@
Manifest.permission.ACCESS_FINE_LOCATION);
// Check that the capability change has been applied but the owner UID is not modified.
- NetworkCapabilities nc = mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork());
+ NetworkCapabilities nc = mCm.getNetworkCapabilities(mWiFiAgent.getNetwork());
assertEquals(originalOwnerUid, nc.getOwnerUid());
assertTrue(nc.hasCapability(NET_CAPABILITY_NOT_CONGESTED));
}
@@ -3308,56 +3317,56 @@
TestNetworkCallback defaultCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(defaultCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mEthernetNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mEthernetAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- defaultCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
// We get AVAILABLE on wifi when wifi connects and satisfies our unmetered request.
// We then get LOSING when wifi validates and cell is outscored.
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// TODO: Investigate sending validated before losing.
- callback.expectLosing(mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ callback.expectLosing(mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mEthernetNetworkAgent.connect(true);
- callback.expectAvailableCallbacksUnvalidated(mEthernetNetworkAgent);
+ mEthernetAgent.connect(true);
+ callback.expectAvailableCallbacksUnvalidated(mEthernetAgent);
// TODO: Investigate sending validated before losing.
- callback.expectLosing(mWiFiNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetNetworkAgent);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetNetworkAgent);
- assertEquals(mEthernetNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ callback.expectLosing(mWiFiAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetAgent);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetAgent);
+ assertEquals(mEthernetAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mEthernetNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mEthernetNetworkAgent);
- defaultCallback.expect(CallbackEntry.LOST, mEthernetNetworkAgent);
- defaultCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
+ mEthernetAgent.disconnect();
+ callback.expect(LOST, mEthernetAgent);
+ defaultCallback.expect(LOST, mEthernetAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
for (int i = 0; i < 4; i++) {
TestNetworkAgentWrapper oldNetwork, newNetwork;
if (i % 2 == 0) {
- mWiFiNetworkAgent.adjustScore(-15);
- oldNetwork = mWiFiNetworkAgent;
- newNetwork = mCellNetworkAgent;
+ mWiFiAgent.adjustScore(-15);
+ oldNetwork = mWiFiAgent;
+ newNetwork = mCellAgent;
} else {
- mWiFiNetworkAgent.adjustScore(15);
- oldNetwork = mCellNetworkAgent;
- newNetwork = mWiFiNetworkAgent;
+ mWiFiAgent.adjustScore(15);
+ oldNetwork = mCellAgent;
+ newNetwork = mWiFiAgent;
}
callback.expectLosing(oldNetwork);
@@ -3366,28 +3375,28 @@
defaultCallback.expectAvailableCallbacksValidated(newNetwork);
assertEquals(newNetwork.getNetwork(), mCm.getActiveNetwork());
}
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
// Verify that if a network no longer satisfies a request, we send LOST and not LOSING, even
// if the network is still up.
- mWiFiNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
// We expect a notification about the capabilities change, and nothing else.
- defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED, mWiFiNetworkAgent);
+ defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED, mWiFiAgent);
defaultCallback.assertNoCallback();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ callback.expect(LOST, mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Wifi no longer satisfies our listen, which is for an unmetered network.
// But because its score is 55, it's still up (and the default network).
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
// Disconnect our test networks.
- mWiFiNetworkAgent.disconnect();
- defaultCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mWiFiAgent.disconnect();
+ defaultCallback.expect(LOST, mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mCellAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mCellNetworkAgent.disconnect();
- defaultCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ defaultCallback.expect(LOST, mCellAgent);
waitForIdle();
assertEquals(null, mCm.getActiveNetwork());
@@ -3401,64 +3410,64 @@
mCm.registerNetworkCallback(request, callback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false); // Score: 10
- callback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false); // Score: 10
+ callback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Bring up wifi with a score of 20.
// Cell stays up because it would satisfy the default request if it validated.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false); // Score: 20
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false); // Score: 20
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- defaultCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ defaultCallback.expect(LOST, mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Bring up wifi, then validate it. Previous versions would immediately tear down cell, but
// it's arguably correct to linger it, since it was the default network before it validated.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// TODO: Investigate sending validated before losing.
- callback.expectLosing(mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ callback.expectLosing(mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- defaultCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- mCellNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- defaultCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ defaultCallback.expect(LOST, mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ mCellAgent.disconnect();
+ callback.expect(LOST, mCellAgent);
+ defaultCallback.expect(LOST, mCellAgent);
waitForIdle();
assertEquals(null, mCm.getActiveNetwork());
// If a network is lingering, and we add and remove a request from it, resume lingering.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- defaultCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// TODO: Investigate sending validated before losing.
- callback.expectLosing(mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ callback.expectLosing(mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
NetworkRequest cellRequest = new NetworkRequest.Builder()
@@ -3468,14 +3477,14 @@
// TODO: should this cause an AVAILABLE callback, to indicate that the network is no longer
// lingering?
mCm.unregisterNetworkCallback(noopCallback);
- callback.expectLosing(mCellNetworkAgent);
+ callback.expectLosing(mCellAgent);
// Similar to the above: lingering can start even after the lingered request is removed.
// Disconnect wifi and switch to cell.
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- defaultCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ defaultCallback.expect(LOST, mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mCellAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Cell is now the default network. Pin it with a cell-specific request.
@@ -3483,44 +3492,44 @@
mCm.requestNetwork(cellRequest, noopCallback);
// Now connect wifi, and expect it to become the default network.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// The default request is lingering on cell, but nothing happens to cell, and we send no
// callbacks for it, because it's kept up by cellRequest.
callback.assertNoCallback();
// Now unregister cellRequest and expect cell to start lingering.
mCm.unregisterNetworkCallback(noopCallback);
- callback.expectLosing(mCellNetworkAgent);
+ callback.expectLosing(mCellAgent);
// Let linger run its course.
callback.assertNoCallback(0 /* timeoutMs */);
final int lingerTimeoutMs = mService.mLingerDelayMs + mService.mLingerDelayMs / 4;
- callback.expect(CallbackEntry.LOST, mCellNetworkAgent, lingerTimeoutMs);
+ callback.expect(LOST, mCellAgent, lingerTimeoutMs);
// Register a TRACK_DEFAULT request and check that it does not affect lingering.
TestNetworkCallback trackDefaultCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(trackDefaultCallback);
- trackDefaultCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mEthernetNetworkAgent.connect(true);
- callback.expectAvailableCallbacksUnvalidated(mEthernetNetworkAgent);
- callback.expectLosing(mWiFiNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetNetworkAgent);
- trackDefaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetNetworkAgent);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetNetworkAgent);
+ trackDefaultCallback.expectAvailableCallbacksValidated(mWiFiAgent);
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mEthernetAgent.connect(true);
+ callback.expectAvailableCallbacksUnvalidated(mEthernetAgent);
+ callback.expectLosing(mWiFiAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetAgent);
+ trackDefaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetAgent);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Let linger run its course.
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent, lingerTimeoutMs);
+ callback.expect(LOST, mWiFiAgent, lingerTimeoutMs);
// Clean up.
- mEthernetNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mEthernetNetworkAgent);
- defaultCallback.expect(CallbackEntry.LOST, mEthernetNetworkAgent);
- trackDefaultCallback.expect(CallbackEntry.LOST, mEthernetNetworkAgent);
+ mEthernetAgent.disconnect();
+ callback.expect(LOST, mEthernetAgent);
+ defaultCallback.expect(LOST, mEthernetAgent);
+ trackDefaultCallback.expect(LOST, mEthernetAgent);
mCm.unregisterNetworkCallback(callback);
mCm.unregisterNetworkCallback(defaultCallback);
@@ -3556,19 +3565,19 @@
TestNetworkCallback defaultCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(defaultCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- defaultCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
// Wifi comes up and cell lingers.
- mWiFiNetworkAgent.connect(true);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expectLosing(mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mWiFiAgent.connect(true);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expectLosing(mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
// File a request for cellular, then release it.
NetworkRequest cellRequest = new NetworkRequest.Builder()
@@ -3576,13 +3585,12 @@
NetworkCallback noopCallback = new NetworkCallback();
mCm.requestNetwork(cellRequest, noopCallback);
mCm.unregisterNetworkCallback(noopCallback);
- callback.expectLosing(mCellNetworkAgent);
+ callback.expectLosing(mCellAgent);
// Let linger run its course.
callback.assertNoCallback();
final int lingerTimeoutMs = TEST_LINGER_DELAY_MS + TEST_LINGER_DELAY_MS / 4;
- callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellNetworkAgent,
- lingerTimeoutMs);
+ callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellAgent, lingerTimeoutMs);
// Clean up.
mCm.unregisterNetworkCallback(defaultCallback);
@@ -3637,7 +3645,7 @@
private void expectDisconnectAndClearNotifications(TestNetworkCallback callback,
TestNetworkAgentWrapper agent, NotificationType type) {
- callback.expect(CallbackEntry.LOST, agent);
+ callback.expect(LOST, agent);
expectClearNotification(agent, type);
}
@@ -3708,7 +3716,7 @@
final NetworkAgentWrapper.Callbacks callbacks = new NetworkAgentWrapper.Callbacks(
onNetworkCreated, onNetworkUnwanted, onNetworkDisconnected);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, callbacks);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, callbacks);
// Connect a network, and file a request for it after it has come up, to ensure the nascent
// timer is cleared and the test does not have to wait for it. Filing the request after the
@@ -3716,13 +3724,13 @@
// nascent timer if the first request satisfied by the network was filed before the network
// connected.
// TODO: fix this bug, file the request before connecting, and remove the waitForIdle.
- mWiFiNetworkAgent.connectWithoutInternet();
+ mWiFiAgent.connectWithoutInternet();
waitForIdle();
mCm.requestNetwork(request, callback);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Set teardown delay and make sure CS has processed it.
- mWiFiNetworkAgent.getNetworkAgent().setTeardownDelayMillis(300);
+ mWiFiAgent.getNetworkAgent().setTeardownDelayMillis(300);
waitForIdle();
// Post the duringTeardown lambda to the handler so it fires while teardown is in progress.
@@ -3730,7 +3738,7 @@
// down the network and started the teardown timer, and short enough that the lambda is
// scheduled to run before the teardown timer.
final Handler h = new Handler(mCsHandlerThread.getLooper());
- h.postDelayed(() -> duringTeardown.accept(mWiFiNetworkAgent.getNetwork()), 150);
+ h.postDelayed(() -> duringTeardown.accept(mWiFiAgent.getNetwork()), 150);
// Disconnect the network and check that events happened in the right order.
mCm.unregisterNetworkCallback(callback);
@@ -3751,106 +3759,104 @@
mCm.registerNetworkCallback(request, callback);
// Bring up validated cell.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
// Bring up unvalidated wifi with explicitlySelected=true.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(true, false);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(true, false);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Cell remains the default.
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
// Expect a high-priority NO_INTERNET notification.
- expectUnvalidationCheckWillNotify(mWiFiNetworkAgent, NotificationType.NO_INTERNET);
+ expectUnvalidationCheckWillNotify(mWiFiAgent, NotificationType.NO_INTERNET);
// Lower WiFi's score to lower than cell, and check that it doesn't disconnect because
// it's explicitly selected.
- mWiFiNetworkAgent.adjustScore(-40);
- mWiFiNetworkAgent.adjustScore(40);
+ mWiFiAgent.adjustScore(-40);
+ mWiFiAgent.adjustScore(40);
callback.assertNoCallback();
// If the user chooses yes on the "No Internet access, stay connected?" dialog, we switch to
// wifi even though it's unvalidated.
- mCm.setAcceptUnvalidated(mWiFiNetworkAgent.getNetwork(), true, false);
- callback.expectLosing(mCellNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCm.setAcceptUnvalidated(mWiFiAgent.getNetwork(), true, false);
+ callback.expectLosing(mCellAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
// Disconnect wifi, and then reconnect, again with explicitlySelected=true.
- mWiFiNetworkAgent.disconnect();
- expectDisconnectAndClearNotifications(callback, mWiFiNetworkAgent,
- NotificationType.NO_INTERNET);
+ mWiFiAgent.disconnect();
+ expectDisconnectAndClearNotifications(callback, mWiFiAgent, NotificationType.NO_INTERNET);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(true, false);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(true, false);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Expect a high-priority NO_INTERNET notification.
- expectUnvalidationCheckWillNotify(mWiFiNetworkAgent, NotificationType.NO_INTERNET);
+ expectUnvalidationCheckWillNotify(mWiFiAgent, NotificationType.NO_INTERNET);
// If the user chooses no on the "No Internet access, stay connected?" dialog, we ask the
// network to disconnect.
- mCm.setAcceptUnvalidated(mWiFiNetworkAgent.getNetwork(), false, false);
- expectDisconnectAndClearNotifications(callback, mWiFiNetworkAgent,
- NotificationType.NO_INTERNET);
+ mCm.setAcceptUnvalidated(mWiFiAgent.getNetwork(), false, false);
+ expectDisconnectAndClearNotifications(callback, mWiFiAgent, NotificationType.NO_INTERNET);
reset(mNotificationManager);
// Reconnect, again with explicitlySelected=true, but this time validate.
// Expect no notifications.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(true, false);
- mWiFiNetworkAgent.connect(true);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expectLosing(mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(true, false);
+ mWiFiAgent.connect(true);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expectLosing(mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mEthernetNetworkAgent.connect(true);
- callback.expectAvailableCallbacksUnvalidated(mEthernetNetworkAgent);
- callback.expectLosing(mWiFiNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetNetworkAgent);
- assertEquals(mEthernetNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mEthernetAgent.connect(true);
+ callback.expectAvailableCallbacksUnvalidated(mEthernetAgent);
+ callback.expectLosing(mWiFiAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetAgent);
+ assertEquals(mEthernetAgent.getNetwork(), mCm.getActiveNetwork());
callback.assertNoCallback();
// Disconnect wifi, and then reconnect as if the user had selected "yes, don't ask again"
// (i.e., with explicitlySelected=true and acceptUnvalidated=true). Expect to switch to
// wifi immediately.
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(true, true);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expectLosing(mEthernetNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- mEthernetNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mEthernetNetworkAgent);
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(true, true);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expectLosing(mEthernetAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
+ mEthernetAgent.disconnect();
+ callback.expect(LOST, mEthernetAgent);
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
// Disconnect and reconnect with explicitlySelected=false and acceptUnvalidated=true.
// Check that the network is not scored specially and that the device prefers cell data.
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(false, true);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(false, true);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
// Clean up.
- mWiFiNetworkAgent.disconnect();
- mCellNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
+ mCellAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- callback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ callback.expect(LOST, mWiFiAgent);
+ callback.expect(LOST, mCellAgent);
}
private void doTestFirstEvaluation(
@@ -3864,36 +3870,36 @@
TestNetworkCallback callback = new TestNetworkCallback();
mCm.registerNetworkCallback(request, callback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- doConnect.accept(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ doConnect.accept(mWiFiAgent);
// Expect the available callbacks, but don't require specific values for their arguments
// since this method doesn't know how the network was connected.
- callback.expect(CallbackEntry.AVAILABLE, mWiFiNetworkAgent);
- callback.expect(CallbackEntry.NETWORK_CAPS_UPDATED, mWiFiNetworkAgent);
- callback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mWiFiNetworkAgent);
- callback.expect(CallbackEntry.BLOCKED_STATUS, mWiFiNetworkAgent);
+ callback.expect(AVAILABLE, mWiFiAgent);
+ callback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
+ callback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent);
+ callback.expect(BLOCKED_STATUS, mWiFiAgent);
if (waitForSecondCaps) {
// This is necessary because of b/245893397, the same bug that happens where we use
// expectAvailableDoubleValidatedCallbacks.
- callback.expect(CallbackEntry.NETWORK_CAPS_UPDATED, mWiFiNetworkAgent);
+ callback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
}
final NetworkAgentInfo nai =
- mService.getNetworkAgentInfoForNetwork(mWiFiNetworkAgent.getNetwork());
+ mService.getNetworkAgentInfoForNetwork(mWiFiAgent.getNetwork());
final long firstEvaluation = nai.getFirstEvaluationConcludedTime();
if (evaluatedByValidation) {
assertNotEquals(0L, firstEvaluation);
} else {
assertEquals(0L, firstEvaluation);
}
- mService.scheduleEvaluationTimeout(mWiFiNetworkAgent.getNetwork(), 0L /* timeout */);
+ mService.scheduleEvaluationTimeout(mWiFiAgent.getNetwork(), 0L /* timeout */);
waitForIdle();
if (evaluatedByValidation) {
assertEquals(firstEvaluation, nai.getFirstEvaluationConcludedTime());
} else {
assertNotEquals(0L, nai.getFirstEvaluationConcludedTime());
}
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
mCm.unregisterNetworkCallback(callback);
}
@@ -4062,9 +4068,9 @@
@Test
public void testRegisterIgnoringScore() throws Exception {
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.setScore(new NetworkScore.Builder().setLegacyInt(90).build());
- mWiFiNetworkAgent.connect(true /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.setScore(new NetworkScore.Builder().setLegacyInt(90).build());
+ mWiFiAgent.connect(true /* validated */);
// Make sure the factory sees the default network
final NetworkCapabilities filter = new NetworkCapabilities();
@@ -4087,13 +4093,13 @@
testFactoryAll.expectRequestAdd();
// The legacy int will be ignored anyway, set the only other knob to true
- mWiFiNetworkAgent.setScore(new NetworkScore.Builder().setLegacyInt(110)
+ mWiFiAgent.setScore(new NetworkScore.Builder().setLegacyInt(110)
.setTransportPrimary(true).build());
expectNoRequestChanged(testFactory); // still not seeing the request
expectNoRequestChanged(testFactoryAll); // still seeing the request
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
}
@Test
@@ -4181,18 +4187,18 @@
@Test
public void testMMSonWiFi() throws Exception {
// Test bringing up cellular without MMS NetworkRequest gets reaped
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_MMS);
- mCellNetworkAgent.connectWithoutInternet();
- mCellNetworkAgent.expectDisconnected();
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.addCapability(NET_CAPABILITY_MMS);
+ mCellAgent.connectWithoutInternet();
+ mCellAgent.expectDisconnected();
waitForIdle();
assertEmpty(mCm.getAllNetworks());
verifyNoNetwork();
// Test bringing up validated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
final ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
@@ -4203,24 +4209,24 @@
mCm.requestNetwork(builder.build(), networkCallback);
// Test bringing up unvalidated cellular with MMS
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_MMS);
- mCellNetworkAgent.connectWithoutInternet();
- networkCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.addCapability(NET_CAPABILITY_MMS);
+ mCellAgent.connectWithoutInternet();
+ networkCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
verifyActiveNetwork(TRANSPORT_WIFI);
// Test releasing NetworkRequest disconnects cellular with MMS
mCm.unregisterNetworkCallback(networkCallback);
- mCellNetworkAgent.expectDisconnected();
+ mCellAgent.expectDisconnected();
verifyActiveNetwork(TRANSPORT_WIFI);
}
@Test
public void testMMSonCell() throws Exception {
// Test bringing up cellular without MMS
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
ExpectedBroadcast b = expectConnectivityAction(TYPE_MOBILE, DetailedState.CONNECTED);
- mCellNetworkAgent.connect(false);
+ mCellAgent.connect(false);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
@@ -4254,143 +4260,139 @@
mCm.registerNetworkCallback(request, callback);
// Bring up validated mobile data.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
// Bring up wifi with partial connectivity.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithPartialConnectivity();
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithPartialConnectivity();
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiAgent);
// Mobile data should be the default network.
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
callback.assertNoCallback();
// Expect a PARTIAL_CONNECTIVITY notification. The notification appears as soon as partial
// connectivity is detected, and is low priority because the network was not explicitly
// selected by the user. This happens if we reconnect to a network where the user previously
// accepted partial connectivity without checking "always".
- expectNotification(mWiFiNetworkAgent, NotificationType.PARTIAL_CONNECTIVITY);
+ expectNotification(mWiFiAgent, NotificationType.PARTIAL_CONNECTIVITY);
// With HTTPS probe disabled, NetworkMonitor should pass the network validation with http
// probe.
- mWiFiNetworkAgent.setNetworkPartialValid(false /* privateDnsProbeSent */);
+ mWiFiAgent.setNetworkPartialValid(false /* privateDnsProbeSent */);
// If the user chooses yes to use this partial connectivity wifi, switch the default
// network to wifi and check if wifi becomes valid or not.
- mCm.setAcceptPartialConnectivity(mWiFiNetworkAgent.getNetwork(), true /* accept */,
+ mCm.setAcceptPartialConnectivity(mWiFiAgent.getNetwork(), true /* accept */,
false /* always */);
// If user accepts partial connectivity network,
// NetworkMonitor#setAcceptPartialConnectivity() should be called too.
waitForIdle();
- verify(mWiFiNetworkAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
+ verify(mWiFiAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
// Need a trigger point to let NetworkMonitor tell ConnectivityService that the network is
// validated.
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- callback.expectLosing(mCellNetworkAgent);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ callback.expectLosing(mCellAgent);
NetworkCapabilities nc = callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED,
- mWiFiNetworkAgent);
+ mWiFiAgent);
assertTrue(nc.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
// Once the network validates, the notification disappears.
- expectClearNotification(mWiFiNetworkAgent, NotificationType.PARTIAL_CONNECTIVITY);
+ expectClearNotification(mWiFiAgent, NotificationType.PARTIAL_CONNECTIVITY);
// Disconnect and reconnect wifi with partial connectivity again.
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithPartialConnectivity();
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithPartialConnectivity();
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiAgent);
// Mobile data should be the default network.
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
waitForIdle();
// Expect a low-priority PARTIAL_CONNECTIVITY notification as soon as partial connectivity
// is detected.
- expectNotification(mWiFiNetworkAgent, NotificationType.PARTIAL_CONNECTIVITY);
+ expectNotification(mWiFiAgent, NotificationType.PARTIAL_CONNECTIVITY);
// If the user chooses no, disconnect wifi immediately.
- mCm.setAcceptPartialConnectivity(mWiFiNetworkAgent.getNetwork(), false /* accept */,
+ mCm.setAcceptPartialConnectivity(mWiFiAgent.getNetwork(), false /* accept */,
false /* always */);
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- expectClearNotification(mWiFiNetworkAgent, NotificationType.PARTIAL_CONNECTIVITY);
+ callback.expect(LOST, mWiFiAgent);
+ expectClearNotification(mWiFiAgent, NotificationType.PARTIAL_CONNECTIVITY);
reset(mNotificationManager);
// If the user accepted partial connectivity before, and the device connects to that network
// again, but now the network has full connectivity, then the network shouldn't contain
// NET_CAPABILITY_PARTIAL_CONNECTIVITY.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
// acceptUnvalidated is also used as setting for accepting partial networks.
- mWiFiNetworkAgent.explicitlySelected(true /* explicitlySelected */,
- true /* acceptUnvalidated */);
- mWiFiNetworkAgent.connect(true);
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
+ mWiFiAgent.explicitlySelected(true /* explicitlySelected */, true /* acceptUnvalidated */);
+ mWiFiAgent.connect(true);
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
// If user accepted partial connectivity network before,
// NetworkMonitor#setAcceptPartialConnectivity() will be called in
// ConnectivityService#updateNetworkInfo().
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- verify(mWiFiNetworkAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
- callback.expectLosing(mCellNetworkAgent);
- nc = callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ verify(mWiFiAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
+ callback.expectLosing(mCellAgent);
+ nc = callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
assertFalse(nc.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY));
// Wifi should be the default network.
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
// The user accepted partial connectivity and selected "don't ask again". Now the user
// reconnects to the partial connectivity network. Switch to wifi as soon as partial
// connectivity is detected.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(true /* explicitlySelected */,
- true /* acceptUnvalidated */);
- mWiFiNetworkAgent.connectWithPartialConnectivity();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(true /* explicitlySelected */, true /* acceptUnvalidated */);
+ mWiFiAgent.connectWithPartialConnectivity();
// If user accepted partial connectivity network before,
// NetworkMonitor#setAcceptPartialConnectivity() will be called in
// ConnectivityService#updateNetworkInfo().
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- verify(mWiFiNetworkAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
- callback.expectLosing(mCellNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiNetworkAgent);
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ verify(mWiFiAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
+ callback.expectLosing(mCellAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
+ callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiAgent);
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
- mWiFiNetworkAgent.setNetworkValid(false /* privateDnsProbeSent */);
+ mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
// Need a trigger point to let NetworkMonitor tell ConnectivityService that the network is
// validated.
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
// If the user accepted partial connectivity, and the device auto-reconnects to the partial
// connectivity network, it should contain both PARTIAL_CONNECTIVITY and VALIDATED.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(false /* explicitlySelected */,
- true /* acceptUnvalidated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(false /* explicitlySelected */, true /* acceptUnvalidated */);
// NetworkMonitor will immediately (once the HTTPS probe fails...) report the network as
// valid, because ConnectivityService calls setAcceptPartialConnectivity before it calls
// notifyNetworkConnected.
- mWiFiNetworkAgent.connectWithPartialValidConnectivity(
- false /* privateDnsProbeSent */);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- verify(mWiFiNetworkAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
- callback.expectLosing(mCellNetworkAgent);
+ mWiFiAgent.connectWithPartialValidConnectivity(false /* privateDnsProbeSent */);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ verify(mWiFiAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
+ callback.expectLosing(mCellAgent);
callback.expectCapabilitiesWith(
- NET_CAPABILITY_PARTIAL_CONNECTIVITY | NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ NET_CAPABILITY_PARTIAL_CONNECTIVITY | NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
verifyNoMoreInteractions(mNotificationManager);
}
@@ -4409,43 +4411,39 @@
// Bring up a network with a captive portal.
// Expect onAvailable callback of listen for NET_CAPABILITY_CAPTIVE_PORTAL.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
String redirectUrl = "http://android.com/path";
- mWiFiNetworkAgent.connectWithCaptivePortal(redirectUrl,
- false /* privateDnsProbeSent */);
- wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.waitForRedirectUrl(), redirectUrl);
+ mWiFiAgent.connectWithCaptivePortal(redirectUrl, false /* privateDnsProbeSent */);
+ wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.waitForRedirectUrl(), redirectUrl);
// This is necessary because of b/245893397, the same bug that happens where we use
// expectAvailableDoubleValidatedCallbacks.
// TODO : fix b/245893397 and remove this.
- wifiCallback.expectCapabilitiesWith(NET_CAPABILITY_CAPTIVE_PORTAL, mWiFiNetworkAgent);
+ wifiCallback.expectCapabilitiesWith(NET_CAPABILITY_CAPTIVE_PORTAL, mWiFiAgent);
// Check that startCaptivePortalApp sends the expected command to NetworkMonitor.
- mCm.startCaptivePortalApp(mWiFiNetworkAgent.getNetwork());
- verify(mWiFiNetworkAgent.mNetworkMonitor, timeout(TIMEOUT_MS).times(1))
- .launchCaptivePortalApp();
+ mCm.startCaptivePortalApp(mWiFiAgent.getNetwork());
+ verify(mWiFiAgent.mNetworkMonitor, timeout(TIMEOUT_MS).times(1)).launchCaptivePortalApp();
// Report that the captive portal is dismissed with partial connectivity, and check that
// callbacks are fired with PARTIAL and without CAPTIVE_PORTAL.
- mWiFiNetworkAgent.setNetworkPartial();
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
+ mWiFiAgent.setNetworkPartial();
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
waitForIdle();
- wifiCallback.expectCapabilitiesThat(
- mWiFiNetworkAgent, nc ->
+ wifiCallback.expectCapabilitiesThat(mWiFiAgent, nc ->
nc.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY)
- && !nc.hasCapability(NET_CAPABILITY_CAPTIVE_PORTAL));
+ && !nc.hasCapability(NET_CAPABILITY_CAPTIVE_PORTAL));
// Report partial connectivity is accepted.
- mWiFiNetworkAgent.setNetworkPartialValid(false /* privateDnsProbeSent */);
- mCm.setAcceptPartialConnectivity(mWiFiNetworkAgent.getNetwork(), true /* accept */,
+ mWiFiAgent.setNetworkPartialValid(false /* privateDnsProbeSent */);
+ mCm.setAcceptPartialConnectivity(mWiFiAgent.getNetwork(), true /* accept */,
false /* always */);
waitForIdle();
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- wifiCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- validatedCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- validatedCallback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY,
- mWiFiNetworkAgent);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ wifiCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ validatedCallback.expectAvailableCallbacksValidated(mWiFiAgent);
+ validatedCallback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiAgent);
mCm.unregisterNetworkCallback(wifiCallback);
mCm.unregisterNetworkCallback(validatedCallback);
@@ -4465,41 +4463,39 @@
// Bring up a network with a captive portal.
// Expect onAvailable callback of listen for NET_CAPABILITY_CAPTIVE_PORTAL.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
String firstRedirectUrl = "http://example.com/firstPath";
- mWiFiNetworkAgent.connectWithCaptivePortal(firstRedirectUrl,
- false /* privateDnsProbeSent */);
- captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.waitForRedirectUrl(), firstRedirectUrl);
+ mWiFiAgent.connectWithCaptivePortal(firstRedirectUrl, false /* privateDnsProbeSent */);
+ captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.waitForRedirectUrl(), firstRedirectUrl);
// Take down network.
// Expect onLost callback.
- mWiFiNetworkAgent.disconnect();
- captivePortalCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ captivePortalCallback.expect(LOST, mWiFiAgent);
// Bring up a network with a captive portal.
// Expect onAvailable callback of listen for NET_CAPABILITY_CAPTIVE_PORTAL.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
String secondRedirectUrl = "http://example.com/secondPath";
- mWiFiNetworkAgent.connectWithCaptivePortal(secondRedirectUrl,
- false /* privateDnsProbeSent */);
- captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.waitForRedirectUrl(), secondRedirectUrl);
+ mWiFiAgent.connectWithCaptivePortal(secondRedirectUrl, false /* privateDnsProbeSent */);
+ captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.waitForRedirectUrl(), secondRedirectUrl);
// Make captive portal disappear then revalidate.
// Expect onLost callback because network no longer provides NET_CAPABILITY_CAPTIVE_PORTAL.
- mWiFiNetworkAgent.setNetworkValid(false /* privateDnsProbeSent */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- captivePortalCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ captivePortalCallback.expect(LOST, mWiFiAgent);
// Expect NET_CAPABILITY_VALIDATED onAvailable callback.
- validatedCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ validatedCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
// Break network connectivity.
// Expect NET_CAPABILITY_VALIDATED onLost callback.
- mWiFiNetworkAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
- validatedCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
+ validatedCallback.expect(LOST, mWiFiAgent);
}
private Intent startCaptivePortalApp(TestNetworkAgentWrapper networkAgent) throws Exception {
@@ -4536,37 +4532,35 @@
mCm.registerNetworkCallback(validatedRequest, validatedCallback);
// Bring up wifi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- validatedCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- Network wifiNetwork = mWiFiNetworkAgent.getNetwork();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ validatedCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ Network wifiNetwork = mWiFiAgent.getNetwork();
// Check that calling startCaptivePortalApp does nothing.
final int fastTimeoutMs = 100;
mCm.startCaptivePortalApp(wifiNetwork);
waitForIdle();
- verify(mWiFiNetworkAgent.mNetworkMonitor, never()).launchCaptivePortalApp();
+ verify(mWiFiAgent.mNetworkMonitor, never()).launchCaptivePortalApp();
mServiceContext.expectNoStartActivityIntent(fastTimeoutMs);
// Turn into a captive portal.
- mWiFiNetworkAgent.setNetworkPortal("http://example.com",
- false /* privateDnsProbeSent */);
+ mWiFiAgent.setNetworkPortal("http://example.com", false /* privateDnsProbeSent */);
mCm.reportNetworkConnectivity(wifiNetwork, false);
- captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- validatedCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ validatedCallback.expect(LOST, mWiFiAgent);
// This is necessary because of b/245893397, the same bug that happens where we use
// expectAvailableDoubleValidatedCallbacks.
// TODO : fix b/245893397 and remove this.
- captivePortalCallback.expect(CallbackEntry.NETWORK_CAPS_UPDATED,
- mWiFiNetworkAgent);
+ captivePortalCallback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
- startCaptivePortalApp(mWiFiNetworkAgent);
+ startCaptivePortalApp(mWiFiAgent);
// Report that the captive portal is dismissed, and check that callbacks are fired
- mWiFiNetworkAgent.setNetworkValid(false /* privateDnsProbeSent */);
- mWiFiNetworkAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
- validatedCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- captivePortalCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
+ mWiFiAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
+ validatedCallback.expectAvailableCallbacksValidated(mWiFiAgent);
+ captivePortalCallback.expect(LOST, mWiFiAgent);
mCm.unregisterNetworkCallback(validatedCallback);
mCm.unregisterNetworkCallback(captivePortalCallback);
@@ -4579,11 +4573,11 @@
.addCapability(NET_CAPABILITY_CAPTIVE_PORTAL).build();
mCm.registerNetworkCallback(captivePortalRequest, captivePortalCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithCaptivePortal(TEST_REDIRECT_URL, false);
- captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithCaptivePortal(TEST_REDIRECT_URL, false);
+ captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
- final Intent signInIntent = startCaptivePortalApp(mWiFiNetworkAgent);
+ final Intent signInIntent = startCaptivePortalApp(mWiFiAgent);
final CaptivePortal captivePortal = signInIntent
.getParcelableExtra(ConnectivityManager.EXTRA_CAPTIVE_PORTAL);
@@ -4591,14 +4585,14 @@
waitForIdle();
// Since network will disconnect, ensure no notification of response to NetworkMonitor
- verify(mWiFiNetworkAgent.mNetworkMonitor, never())
+ verify(mWiFiAgent.mNetworkMonitor, never())
.notifyCaptivePortalAppFinished(CaptivePortal.APP_RETURN_UNWANTED);
// Report that the network is disconnected
- mWiFiNetworkAgent.expectDisconnected();
- mWiFiNetworkAgent.expectPreventReconnectReceived();
- verify(mWiFiNetworkAgent.mNetworkMonitor).notifyNetworkDisconnected();
- captivePortalCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.expectDisconnected();
+ mWiFiAgent.expectPreventReconnectReceived();
+ verify(mWiFiAgent.mNetworkMonitor).notifyNetworkDisconnected();
+ captivePortalCallback.expect(LOST, mWiFiAgent);
mCm.unregisterNetworkCallback(captivePortalCallback);
}
@@ -4618,13 +4612,12 @@
setCaptivePortalMode(ConnectivitySettingsManager.CAPTIVE_PORTAL_MODE_AVOID);
// Bring up a network with a captive portal.
// Expect it to fail to connect and not result in any callbacks.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- String firstRedirectUrl = "http://example.com/firstPath";
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ final String firstRedirectUrl = "http://example.com/firstPath";
- mWiFiNetworkAgent.connectWithCaptivePortal(firstRedirectUrl,
- false /* privateDnsProbeSent */);
- mWiFiNetworkAgent.expectDisconnected();
- mWiFiNetworkAgent.expectPreventReconnectReceived();
+ mWiFiAgent.connectWithCaptivePortal(firstRedirectUrl, false /* privateDnsProbeSent */);
+ mWiFiAgent.expectDisconnected();
+ mWiFiAgent.expectPreventReconnectReceived();
assertNoCallbacks(captivePortalCallback, validatedCallback);
}
@@ -4638,28 +4631,28 @@
.addCapability(NET_CAPABILITY_CAPTIVE_PORTAL).build();
mCm.registerNetworkCallback(captivePortalRequest, captivePortalCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
final String redirectUrl = "http://example.com/firstPath";
- mWiFiNetworkAgent.connectWithCaptivePortal(redirectUrl,
+ mWiFiAgent.connectWithCaptivePortal(redirectUrl,
false /* privateDnsProbeSent */);
- captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
final CaptivePortalData testData = new CaptivePortalData.Builder()
.setUserPortalUrl(Uri.parse(redirectUrl))
.setBytesRemaining(12345L)
.build();
- mWiFiNetworkAgent.notifyCapportApiDataChanged(testData);
+ mWiFiAgent.notifyCapportApiDataChanged(testData);
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> testData.equals(lp.getCaptivePortalData()));
final LinkProperties newLps = new LinkProperties();
newLps.setMtu(1234);
- mWiFiNetworkAgent.sendLinkProperties(newLps);
+ mWiFiAgent.sendLinkProperties(newLps);
// CaptivePortalData is not lost and unchanged when LPs are received from the NetworkAgent
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> testData.equals(lp.getCaptivePortalData()) && lp.getMtu() == 1234);
}
@@ -4673,11 +4666,11 @@
.addCapability(NET_CAPABILITY_CAPTIVE_PORTAL).build();
mCm.registerNetworkCallback(captivePortalRequest, captivePortalCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithCaptivePortal(TEST_REDIRECT_URL,
+ mWiFiAgent.connectWithCaptivePortal(TEST_REDIRECT_URL,
false /* privateDnsProbeSent */);
- captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
return captivePortalCallback;
}
@@ -4752,52 +4745,52 @@
final CaptivePortalTestData captivePortalTestData = setupCaptivePortalData();
// Baseline capport data
- mWiFiNetworkAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
+ mWiFiAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mCapportData.equals(lp.getCaptivePortalData()));
// Venue URL, T&C URL and friendly name from Network agent with Passpoint source, confirm
// that API data gets precedence on the bytes remaining.
final LinkProperties linkProperties = new LinkProperties();
linkProperties.setCaptivePortalData(captivePortalTestData.mNaPasspointData);
- mWiFiNetworkAgent.sendLinkProperties(linkProperties);
+ mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the capport data is merged
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mExpectedMergedPasspointData
.equals(lp.getCaptivePortalData()));
// Now send this information from non-Passpoint source, confirm that Capport data takes
// precedence
linkProperties.setCaptivePortalData(captivePortalTestData.mNaOtherData);
- mWiFiNetworkAgent.sendLinkProperties(linkProperties);
+ mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the capport data is merged
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mExpectedMergedOtherData
.equals(lp.getCaptivePortalData()));
// Create a new LP with no Network agent capport data
final LinkProperties newLps = new LinkProperties();
newLps.setMtu(1234);
- mWiFiNetworkAgent.sendLinkProperties(newLps);
+ mWiFiAgent.sendLinkProperties(newLps);
// CaptivePortalData is not lost and has the original values when LPs are received from the
// NetworkAgent
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mCapportData.equals(lp.getCaptivePortalData())
&& lp.getMtu() == 1234);
// Now send capport data only from the Network agent
- mWiFiNetworkAgent.notifyCapportApiDataChanged(null);
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ mWiFiAgent.notifyCapportApiDataChanged(null);
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> lp.getCaptivePortalData() == null);
newLps.setCaptivePortalData(captivePortalTestData.mNaPasspointData);
- mWiFiNetworkAgent.sendLinkProperties(newLps);
+ mWiFiAgent.sendLinkProperties(newLps);
// Make sure that only the network agent capport data is available
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mNaPasspointData.equals(lp.getCaptivePortalData()));
}
@@ -4810,27 +4803,27 @@
// on the bytes remaining.
final LinkProperties linkProperties = new LinkProperties();
linkProperties.setCaptivePortalData(captivePortalTestData.mNaPasspointData);
- mWiFiNetworkAgent.sendLinkProperties(linkProperties);
+ mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the data is saved correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mNaPasspointData.equals(lp.getCaptivePortalData()));
// Expected merged data: Network agent data is preferred, and values that are not used by
// it are merged from capport data
- mWiFiNetworkAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
+ mWiFiAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
// Make sure that the Capport data is merged correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mExpectedMergedPasspointData.equals(
lp.getCaptivePortalData()));
// Now set the naData to null
linkProperties.setCaptivePortalData(null);
- mWiFiNetworkAgent.sendLinkProperties(linkProperties);
+ mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the Capport data is retained correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mCapportData.equals(lp.getCaptivePortalData()));
}
@@ -4844,18 +4837,18 @@
// on the bytes remaining.
final LinkProperties linkProperties = new LinkProperties();
linkProperties.setCaptivePortalData(captivePortalTestData.mNaOtherData);
- mWiFiNetworkAgent.sendLinkProperties(linkProperties);
+ mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the data is saved correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mNaOtherData.equals(lp.getCaptivePortalData()));
// Expected merged data: Network agent data is preferred, and values that are not used by
// it are merged from capport data
- mWiFiNetworkAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
+ mWiFiAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
// Make sure that the Capport data is merged correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mExpectedMergedOtherData.equals(
lp.getCaptivePortalData()));
}
@@ -4977,51 +4970,50 @@
LocalStringNetworkSpecifier nsFoo = new LocalStringNetworkSpecifier("foo");
LocalStringNetworkSpecifier nsBar = new LocalStringNetworkSpecifier("bar");
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiNetworkAgent, null /* specifier */,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiAgent, null /* specifier */,
cEmpty1, cEmpty2, cEmpty3, cEmpty4);
assertNoCallbacks(cFoo, cBar);
- mWiFiNetworkAgent.disconnect();
- expectOnLost(mWiFiNetworkAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4);
+ mWiFiAgent.disconnect();
+ expectOnLost(mWiFiAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.setNetworkSpecifier(nsFoo);
- mWiFiNetworkAgent.connect(false);
- expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiNetworkAgent, nsFoo,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.setNetworkSpecifier(nsFoo);
+ mWiFiAgent.connect(false);
+ expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiAgent, nsFoo,
cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo);
cBar.assertNoCallback();
assertEquals(nsFoo,
- mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).getNetworkSpecifier());
+ mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).getNetworkSpecifier());
assertNoCallbacks(cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo);
- mWiFiNetworkAgent.disconnect();
- expectOnLost(mWiFiNetworkAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo);
+ mWiFiAgent.disconnect();
+ expectOnLost(mWiFiAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.setNetworkSpecifier(nsBar);
- mWiFiNetworkAgent.connect(false);
- expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiNetworkAgent, nsBar,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.setNetworkSpecifier(nsBar);
+ mWiFiAgent.connect(false);
+ expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiAgent, nsBar,
cEmpty1, cEmpty2, cEmpty3, cEmpty4, cBar);
cFoo.assertNoCallback();
assertEquals(nsBar,
- mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).getNetworkSpecifier());
+ mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).getNetworkSpecifier());
- mWiFiNetworkAgent.disconnect();
- expectOnLost(mWiFiNetworkAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4, cBar);
+ mWiFiAgent.disconnect();
+ expectOnLost(mWiFiAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4, cBar);
cFoo.assertNoCallback();
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.setNetworkSpecifier(new ConfidentialMatchAllNetworkSpecifier());
- mWiFiNetworkAgent.connect(false);
- expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiNetworkAgent, null /* specifier */,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.setNetworkSpecifier(new ConfidentialMatchAllNetworkSpecifier());
+ mWiFiAgent.connect(false);
+ expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiAgent, null /* specifier */,
cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo, cBar);
- assertNull(
- mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).getNetworkSpecifier());
+ assertNull(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).getNetworkSpecifier());
- mWiFiNetworkAgent.disconnect();
- expectOnLost(mWiFiNetworkAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo, cBar);
+ mWiFiAgent.disconnect();
+ expectOnLost(mWiFiAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo, cBar);
}
/**
@@ -5100,8 +5092,8 @@
@Test
public void testNetworkRequestUidSpoofSecurityException() throws Exception {
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
NetworkRequest networkRequest = newWifiRequestBuilder().build();
TestNetworkCallback networkCallback = new TestNetworkCallback();
doThrow(new SecurityException()).when(mAppOpsManager).checkPackage(anyInt(), anyString());
@@ -5156,35 +5148,35 @@
cellNetworkCallback.assertNoCallback();
// Bring up cell and expect CALLBACK_AVAILABLE.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- systemDefaultCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ systemDefaultCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
assertEquals(systemDefaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Bring up wifi and expect CALLBACK_AVAILABLE.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
cellNetworkCallback.assertNoCallback();
- defaultNetworkCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- systemDefaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ defaultNetworkCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ systemDefaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
assertEquals(systemDefaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Bring down cell. Expect no default network callback, since it wasn't the default.
- mCellNetworkAgent.disconnect();
- cellNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ cellNetworkCallback.expect(LOST, mCellAgent);
defaultNetworkCallback.assertNoCallback();
systemDefaultCallback.assertNoCallback();
assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
assertEquals(systemDefaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Bring up cell. Expect no default network callback, since it won't be the default.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
defaultNetworkCallback.assertNoCallback();
systemDefaultCallback.assertNoCallback();
assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
@@ -5192,16 +5184,16 @@
// Bring down wifi. Expect the default network callback to notified of LOST wifi
// followed by AVAILABLE cell.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
cellNetworkCallback.assertNoCallback();
- defaultNetworkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- defaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- systemDefaultCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- systemDefaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- mCellNetworkAgent.disconnect();
- cellNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- defaultNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- systemDefaultCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ defaultNetworkCallback.expect(LOST, mWiFiAgent);
+ defaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
+ systemDefaultCallback.expect(LOST, mWiFiAgent);
+ systemDefaultCallback.expectAvailableCallbacksValidated(mCellAgent);
+ mCellAgent.disconnect();
+ cellNetworkCallback.expect(LOST, mCellAgent);
+ defaultNetworkCallback.expect(LOST, mCellAgent);
+ systemDefaultCallback.expect(LOST, mCellAgent);
waitForIdle();
assertEquals(null, mCm.getActiveNetwork());
@@ -5213,7 +5205,7 @@
assertEquals(null, systemDefaultCallback.getLastAvailableNetwork());
mMockVpn.disconnect();
- defaultNetworkCallback.expect(CallbackEntry.LOST, mMockVpn);
+ defaultNetworkCallback.expect(LOST, mMockVpn);
systemDefaultCallback.assertNoCallback();
waitForIdle();
assertEquals(null, mCm.getActiveNetwork());
@@ -5228,29 +5220,27 @@
mCm.requestNetwork(cellRequest, cellNetworkCallback);
// Bring up the mobile network.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
// We should get onAvailable(), onCapabilitiesChanged(), and
// onLinkPropertiesChanged() in rapid succession. Additionally, we
// should get onCapabilitiesChanged() when the mobile network validates.
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
cellNetworkCallback.assertNoCallback();
// Update LinkProperties.
final LinkProperties lp = new LinkProperties();
lp.setInterfaceName("foonet_data0");
- mCellNetworkAgent.sendLinkProperties(lp);
+ mCellAgent.sendLinkProperties(lp);
// We should get onLinkPropertiesChanged().
- cellNetworkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED,
- mCellNetworkAgent);
+ cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
cellNetworkCallback.assertNoCallback();
// Suspend the network.
- mCellNetworkAgent.suspend();
- cellNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_SUSPENDED,
- mCellNetworkAgent);
- cellNetworkCallback.expect(CallbackEntry.SUSPENDED, mCellNetworkAgent);
+ mCellAgent.suspend();
+ cellNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_SUSPENDED, mCellAgent);
+ cellNetworkCallback.expect(SUSPENDED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertEquals(NetworkInfo.State.SUSPENDED, mCm.getActiveNetworkInfo().getState());
@@ -5259,21 +5249,20 @@
mCm.registerDefaultNetworkCallback(dfltNetworkCallback);
// We should get onAvailable(), onCapabilitiesChanged(), onLinkPropertiesChanged(),
// as well as onNetworkSuspended() in rapid succession.
- dfltNetworkCallback.expectAvailableAndSuspendedCallbacks(mCellNetworkAgent, true);
+ dfltNetworkCallback.expectAvailableAndSuspendedCallbacks(mCellAgent, true);
dfltNetworkCallback.assertNoCallback();
mCm.unregisterNetworkCallback(dfltNetworkCallback);
- mCellNetworkAgent.resume();
- cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_SUSPENDED,
- mCellNetworkAgent);
- cellNetworkCallback.expect(CallbackEntry.RESUMED, mCellNetworkAgent);
+ mCellAgent.resume();
+ cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_SUSPENDED, mCellAgent);
+ cellNetworkCallback.expect(RESUMED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertEquals(NetworkInfo.State.CONNECTED, mCm.getActiveNetworkInfo().getState());
dfltNetworkCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(dfltNetworkCallback);
// This time onNetworkSuspended should not be called.
- dfltNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ dfltNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
dfltNetworkCallback.assertNoCallback();
mCm.unregisterNetworkCallback(dfltNetworkCallback);
@@ -5282,8 +5271,8 @@
@Test
public void testRegisterPrivilegedDefaultCallbacksRequirePermissions() throws Exception {
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false /* validated */);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false /* validated */);
mServiceContext.setPermission(CONNECTIVITY_USE_RESTRICTED_NETWORKS, PERMISSION_DENIED);
final Handler handler = new Handler(ConnectivityThread.getInstanceLooper());
@@ -5298,16 +5287,16 @@
mServiceContext.setPermission(CONNECTIVITY_USE_RESTRICTED_NETWORKS, PERMISSION_GRANTED);
mCm.registerSystemDefaultNetworkCallback(callback, handler);
mServiceContext.setPermission(CONNECTIVITY_USE_RESTRICTED_NETWORKS, PERMISSION_DENIED);
- callback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mCellAgent);
mCm.unregisterNetworkCallback(callback);
mServiceContext.setPermission(NETWORK_SETTINGS, PERMISSION_GRANTED);
mCm.registerSystemDefaultNetworkCallback(callback, handler);
- callback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mCellAgent);
mCm.unregisterNetworkCallback(callback);
mCm.registerDefaultNetworkCallbackForUid(APP1_UID, callback, handler);
- callback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mCellAgent);
mCm.unregisterNetworkCallback(callback);
}
@@ -5338,15 +5327,15 @@
mCm.registerNetworkCallback(includeOtherUidsRequest, includeOtherUidsCallback);
// Both callbacks see a network with no specifier that applies to their UID.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false /* validated */);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- otherUidCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- includeOtherUidsCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- otherUidCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- includeOtherUidsCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false /* validated */);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ otherUidCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ includeOtherUidsCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ otherUidCallback.expect(LOST, mWiFiAgent);
+ includeOtherUidsCallback.expect(LOST, mWiFiAgent);
// Only the includeOtherUidsCallback sees a VPN that does not apply to its UID.
final UidRange range = UidRange.createForUser(UserHandle.of(RESTRICTED_USER));
@@ -5357,7 +5346,7 @@
otherUidCallback.assertNoCallback();
mMockVpn.disconnect();
- includeOtherUidsCallback.expect(CallbackEntry.LOST, mMockVpn);
+ includeOtherUidsCallback.expect(LOST, mMockVpn);
callback.assertNoCallback();
otherUidCallback.assertNoCallback();
}
@@ -5422,10 +5411,10 @@
final NetworkCapabilities ncTemplate = new NetworkCapabilities()
.addTransportType(TRANSPORT_WIFI)
.setNetworkSpecifier(specifier);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, emptyLp, ncTemplate);
- mWiFiNetworkAgent.connect(false /* validated */);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- otherUidCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, emptyLp, ncTemplate);
+ mWiFiAgent.connect(false /* validated */);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ otherUidCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
includeOtherUidsCallback.assertNoCallback();
}
@@ -5480,63 +5469,63 @@
mCm.registerNetworkCallback(request, callback);
mCm.registerNetworkCallback(fgRequest, fgCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- fgCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertTrue(isForegroundNetwork(mCellNetworkAgent));
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ fgCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertTrue(isForegroundNetwork(mCellAgent));
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
// When wifi connects, cell lingers.
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expectLosing(mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- fgCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- fgCallback.expectLosing(mCellNetworkAgent);
- fgCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- assertTrue(isForegroundNetwork(mCellNetworkAgent));
- assertTrue(isForegroundNetwork(mWiFiNetworkAgent));
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expectLosing(mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ fgCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ fgCallback.expectLosing(mCellAgent);
+ fgCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ assertTrue(isForegroundNetwork(mCellAgent));
+ assertTrue(isForegroundNetwork(mWiFiAgent));
// When lingering is complete, cell is still there but is now in the background.
waitForIdle();
int timeoutMs = TEST_LINGER_DELAY_MS + TEST_LINGER_DELAY_MS / 4;
- fgCallback.expect(CallbackEntry.LOST, mCellNetworkAgent, timeoutMs);
+ fgCallback.expect(LOST, mCellAgent, timeoutMs);
// Expect a network capabilities update sans FOREGROUND.
- callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellNetworkAgent);
- assertFalse(isForegroundNetwork(mCellNetworkAgent));
- assertTrue(isForegroundNetwork(mWiFiNetworkAgent));
+ callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellAgent);
+ assertFalse(isForegroundNetwork(mCellAgent));
+ assertTrue(isForegroundNetwork(mWiFiAgent));
// File a cell request and check that cell comes into the foreground.
final NetworkRequest cellRequest = new NetworkRequest.Builder()
.addTransportType(TRANSPORT_CELLULAR).build();
final TestNetworkCallback cellCallback = new TestNetworkCallback();
mCm.requestNetwork(cellRequest, cellCallback);
- cellCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- fgCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ cellCallback.expectAvailableCallbacksValidated(mCellAgent);
+ fgCallback.expectAvailableCallbacksValidated(mCellAgent);
// Expect a network capabilities update with FOREGROUND, because the most recent
// request causes its state to change.
- cellCallback.expectCapabilitiesWith(NET_CAPABILITY_FOREGROUND, mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_FOREGROUND, mCellNetworkAgent);
- assertTrue(isForegroundNetwork(mCellNetworkAgent));
- assertTrue(isForegroundNetwork(mWiFiNetworkAgent));
+ cellCallback.expectCapabilitiesWith(NET_CAPABILITY_FOREGROUND, mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_FOREGROUND, mCellAgent);
+ assertTrue(isForegroundNetwork(mCellAgent));
+ assertTrue(isForegroundNetwork(mWiFiAgent));
// Release the request. The network immediately goes into the background, since it was not
// lingering.
mCm.unregisterNetworkCallback(cellCallback);
- fgCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ fgCallback.expect(LOST, mCellAgent);
// Expect a network capabilities update sans FOREGROUND.
- callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellNetworkAgent);
- assertFalse(isForegroundNetwork(mCellNetworkAgent));
- assertTrue(isForegroundNetwork(mWiFiNetworkAgent));
+ callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellAgent);
+ assertFalse(isForegroundNetwork(mCellAgent));
+ assertTrue(isForegroundNetwork(mWiFiAgent));
// Disconnect wifi and check that cell is foreground again.
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- fgCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- fgCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- assertTrue(isForegroundNetwork(mCellNetworkAgent));
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ fgCallback.expect(LOST, mWiFiAgent);
+ fgCallback.expectAvailableCallbacksValidated(mCellAgent);
+ assertTrue(isForegroundNetwork(mCellAgent));
mCm.unregisterNetworkCallback(callback);
mCm.unregisterNetworkCallback(fgCallback);
@@ -5577,11 +5566,11 @@
}
});
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
// Don't request that the network validate, because otherwise connect() will block until
// the network gets NET_CAPABILITY_VALIDATED, after all the callbacks below have fired,
// and we won't actually measure anything.
- mCellNetworkAgent.connect(false);
+ mCellAgent.connect(false);
long onAvailableDispatchingDuration = durationOf(() -> {
await(availableLatch, 10 * CONNECT_TIME_LIMIT_MS);
@@ -5594,9 +5583,9 @@
onAvailableDispatchingDuration <= CONNECT_TIME_LIMIT_MS);
// Give wifi a high enough score that we'll linger cell when wifi comes up.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.adjustScore(40);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.adjustScore(40);
+ mWiFiAgent.connect(false);
long onLostDispatchingDuration = durationOf(() -> {
await(losingLatch, 10 * SWITCH_TIME_LIMIT_MS);
@@ -5642,9 +5631,9 @@
assertTrue(testFactory.getMyStartRequested());
// Bring up wifi. The factory stops looking for a network.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
// Score 60 - 40 penalty for not validated yet, then 60 when it validates
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
// The network connects with a low score, so the offer can still beat it and
// nothing happens. Then the network validates, and the offer with its filter score
// of 40 can no longer beat it and the request is removed.
@@ -5663,9 +5652,9 @@
// Bring up cell data and check that the factory stops looking.
assertLength(1, mCm.getAllNetworks());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false);
- cellNetworkCallback.expectAvailableCallbacks(mCellNetworkAgent, false, false, false,
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false);
+ cellNetworkCallback.expectAvailableCallbacks(mCellAgent, false, false, false,
TEST_CALLBACK_TIMEOUT_MS);
// When cell connects, it will satisfy the "mobile always on request" right away
// by virtue of being the only network that can satisfy the request. However, its
@@ -5675,11 +5664,11 @@
// Next, cell validates. This gives it a score of 50 and the test factory can't
// hope to beat that according to its filters. It will see the message that its
// offer is now unnecessary.
- mCellNetworkAgent.setNetworkValid(true);
+ mCellAgent.setNetworkValid(true);
// Need a trigger point to let NetworkMonitor tell ConnectivityService that network is
// validated – see testPartialConnectivity.
- mCm.reportNetworkConnectivity(mCellNetworkAgent.getNetwork(), true);
- cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mCellNetworkAgent);
+ mCm.reportNetworkConnectivity(mCellAgent.getNetwork(), true);
+ cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mCellAgent);
testFactory.expectRequestRemove();
testFactory.assertRequestCountEquals(0);
// Accordingly, the factory shouldn't be started.
@@ -5692,8 +5681,8 @@
// Cell disconnects. There is still the "mobile data always on" request outstanding,
// and the test factory should see it now that it isn't hopelessly outscored.
- mCellNetworkAgent.disconnect();
- cellNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ cellNetworkCallback.expect(LOST, mCellAgent);
// Wait for the network to be removed from internal structures before
// calling synchronous getter
waitForIdle();
@@ -5704,9 +5693,9 @@
// Reconnect cell validated, see the request disappear again. Then withdraw the
// mobile always on request. This will tear down cell, and there shouldn't be a
// blip where the test factory briefly sees the request or anything.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
waitForIdle();
assertLength(2, mCm.getAllNetworks());
testFactory.expectRequestRemove();
@@ -5716,7 +5705,7 @@
testFactory.assertRequestCountEquals(0);
assertFalse(testFactory.getMyStartRequested());
// ... and cell data to be torn down immediately since it is no longer nascent.
- cellNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ cellNetworkCallback.expect(LOST, mCellAgent);
waitForIdle();
assertLength(1, mCm.getAllNetworks());
testFactory.terminate();
@@ -5861,39 +5850,39 @@
mCm.registerNetworkCallback(wifiRequest, wifiNetworkCallback);
// Cell connects and validates.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR,
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR,
new LinkProperties(), null /* ncTemplate */, cellProvider);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
cellCallback.assertNoCallback();
wifiCallback.assertNoCallback();
// Bring up wifi. At first it's invalidated, so cell is still needed.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI,
new LinkProperties(), null /* ncTemplate */, wifiProvider);
- mWiFiNetworkAgent.connect(false);
- wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent.connect(false);
+ wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
cellCallback.assertNoCallback();
wifiCallback.assertNoCallback();
// Wifi validates. Cell is no longer needed, because it's outscored.
- mWiFiNetworkAgent.setNetworkValid(true /* privateDnsProbeSent */);
+ mWiFiAgent.setNetworkValid(true /* privateDnsProbeSent */);
// Have CS reconsider the network (see testPartialConnectivity)
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
cellCallback.expectOnNetworkUnneeded(defaultCaps);
wifiCallback.assertNoCallback();
// Wifi is no longer validated. Cell is needed again.
- mWiFiNetworkAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
- wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
+ wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
cellCallback.expectOnNetworkNeeded(defaultCaps);
wifiCallback.assertNoCallback();
// Disconnect wifi and pretend the carrier restricts moving away from bad wifi.
- mWiFiNetworkAgent.disconnect();
- wifiNetworkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ wifiNetworkCallback.expect(LOST, mWiFiAgent);
// This has getAvoidBadWifi return false. This test doesn't change the value of the
// associated setting.
doReturn(0).when(mResources).getInteger(R.integer.config_networkAvoidBadWifi);
@@ -5901,23 +5890,23 @@
waitForIdle();
// Connect wifi again, cell is needed until wifi validates.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI,
new LinkProperties(), null /* ncTemplate */, wifiProvider);
- mWiFiNetworkAgent.connect(false);
- wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent.connect(false);
+ wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
cellCallback.assertNoCallback();
wifiCallback.assertNoCallback();
- mWiFiNetworkAgent.setNetworkValid(true /* privateDnsProbeSent */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkValid(true /* privateDnsProbeSent */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
cellCallback.expectOnNetworkUnneeded(defaultCaps);
wifiCallback.assertNoCallback();
// Wifi loses validation. Because the device doesn't avoid bad wifis, cell is
// not needed.
- mWiFiNetworkAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
- wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
+ wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
cellCallback.assertNoCallback();
wifiCallback.assertNoCallback();
}
@@ -5939,19 +5928,19 @@
mCm.registerNetworkCallback(wifiRequest, wifiCallback);
// Bring up validated cell and unvalidated wifi.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
if (preferBadWifi) {
- expectUnvalidationCheckWillNotify(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
- mDefaultNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ expectUnvalidationCheckWillNotify(mWiFiAgent, NotificationType.LOST_INTERNET);
+ mDefaultNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
} else {
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
mDefaultNetworkCallback.assertNoCallback();
}
}
@@ -5996,25 +5985,25 @@
mPolicyTracker.reevaluate();
// Bring up validated cell.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- defaultCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- Network cellNetwork = mCellNetworkAgent.getNetwork();
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ Network cellNetwork = mCellAgent.getNetwork();
// Bring up validated wifi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- validatedWifiCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- Network wifiNetwork = mWiFiNetworkAgent.getNetwork();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ validatedWifiCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ Network wifiNetwork = mWiFiAgent.getNetwork();
// Fail validation on wifi.
- mWiFiNetworkAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
+ mWiFiAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
mCm.reportNetworkConnectivity(wifiNetwork, false);
- defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- validatedWifiCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- expectNotification(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
+ defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ validatedWifiCallback.expect(LOST, mWiFiAgent);
+ expectNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
// Because avoid bad wifi is off, we don't switch to cellular.
defaultCallback.assertNoCallback();
@@ -6028,24 +6017,24 @@
// that we switch back to cell.
doReturn(1).when(mResources).getInteger(R.integer.config_networkAvoidBadWifi);
mPolicyTracker.reevaluate();
- defaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mCellAgent);
assertEquals(mCm.getActiveNetwork(), cellNetwork);
- expectClearNotification(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
+ expectClearNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
// Switch back to a restrictive carrier.
doReturn(0).when(mResources).getInteger(R.integer.config_networkAvoidBadWifi);
mPolicyTracker.reevaluate();
- defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
assertEquals(mCm.getActiveNetwork(), wifiNetwork);
// A notification was already shown for this very network.
- expectNoNotification(mWiFiNetworkAgent);
+ expectNoNotification(mWiFiAgent);
// Simulate the user selecting "switch" on the dialog, and check that we switch to cell.
// In principle this is a little bit unrealistic because the switch to a less restrictive
// carrier above should have remove the notification but this doesn't matter for the
// purposes of this test.
mCm.setAvoidUnvalidated(wifiNetwork);
- defaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mCellAgent);
assertFalse(mCm.getNetworkCapabilities(wifiNetwork).hasCapability(
NET_CAPABILITY_VALIDATED));
assertTrue(mCm.getNetworkCapabilities(cellNetwork).hasCapability(
@@ -6053,54 +6042,54 @@
assertEquals(mCm.getActiveNetwork(), cellNetwork);
// Disconnect and reconnect wifi to clear the one-time switch above.
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- validatedWifiCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- wifiNetwork = mWiFiNetworkAgent.getNetwork();
+ mWiFiAgent.disconnect();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ validatedWifiCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ wifiNetwork = mWiFiAgent.getNetwork();
// Fail validation on wifi and expect the dialog to appear.
- mWiFiNetworkAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
+ mWiFiAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
mCm.reportNetworkConnectivity(wifiNetwork, false);
- defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- validatedWifiCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- expectNotification(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
+ defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ validatedWifiCallback.expect(LOST, mWiFiAgent);
+ expectNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
// Simulate the user selecting "switch" and checking the don't ask again checkbox.
Settings.Global.putInt(cr, ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI, 1);
mPolicyTracker.reevaluate();
// We now switch to cell.
- defaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mCellAgent);
assertFalse(mCm.getNetworkCapabilities(wifiNetwork).hasCapability(
NET_CAPABILITY_VALIDATED));
assertTrue(mCm.getNetworkCapabilities(cellNetwork).hasCapability(
NET_CAPABILITY_VALIDATED));
assertEquals(mCm.getActiveNetwork(), cellNetwork);
- expectClearNotification(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
+ expectClearNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
// Simulate the user turning the cellular fallback setting off and then on.
// We switch to wifi and then to cell.
Settings.Global.putString(cr, ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI, null);
mPolicyTracker.reevaluate();
- defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
assertEquals(mCm.getActiveNetwork(), wifiNetwork);
// Notification is cleared again because CS doesn't particularly remember that it has
// cleared it before, and if it hasn't cleared it before then it should do so now.
- expectClearNotification(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
+ expectClearNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
Settings.Global.putInt(cr, ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI, 1);
mPolicyTracker.reevaluate();
- defaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mCellAgent);
assertEquals(mCm.getActiveNetwork(), cellNetwork);
// If cell goes down, we switch to wifi.
- mCellNetworkAgent.disconnect();
- defaultCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mCellAgent.disconnect();
+ defaultCallback.expect(LOST, mCellAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
validatedWifiCallback.assertNoCallback();
// Notification is cleared yet again because the device switched to wifi.
- expectClearNotification(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
+ expectClearNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
mCm.unregisterNetworkCallback(cellNetworkCallback);
mCm.unregisterNetworkCallback(validatedWifiCallback);
@@ -6137,9 +6126,9 @@
final TestNetworkCallback networkCallback = new TestNetworkCallback();
mCm.requestNetwork(nr, networkCallback, TEST_REQUEST_TIMEOUT_MS);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- networkCallback.expectAvailableCallbacks(mWiFiNetworkAgent, false, false, false,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ networkCallback.expectAvailableCallbacks(mWiFiAgent, false, false, false,
TEST_CALLBACK_TIMEOUT_MS);
// pass timeout and validate that UNAVAILABLE is not called
@@ -6157,12 +6146,12 @@
final TestNetworkCallback networkCallback = new TestNetworkCallback();
mCm.requestNetwork(nr, networkCallback, TEST_REQUEST_TIMEOUT_MS);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- networkCallback.expectAvailableCallbacks(mWiFiNetworkAgent, false, false, false,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ networkCallback.expectAvailableCallbacks(mWiFiAgent, false, false, false,
TEST_CALLBACK_TIMEOUT_MS);
- mWiFiNetworkAgent.disconnect();
- networkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ networkCallback.expect(LOST, mWiFiAgent);
// Validate that UNAVAILABLE is not called
networkCallback.assertNoCallback();
@@ -6182,11 +6171,11 @@
mCm.requestNetwork(nr, networkCallback, timeoutMs);
// pass timeout and validate that UNAVAILABLE is called
- networkCallback.expect(CallbackEntry.UNAVAILABLE);
+ networkCallback.expect(UNAVAILABLE);
// create a network satisfying request - validate that request not triggered
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
networkCallback.assertNoCallback();
}
@@ -6208,8 +6197,8 @@
networkCallback.assertNoCallback();
// create a network satisfying request - validate that request not triggered
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
networkCallback.assertNoCallback();
}
@@ -6266,7 +6255,7 @@
// onUnavailable!
testFactory.triggerUnfulfillable(newRequest);
- networkCallback.expect(CallbackEntry.UNAVAILABLE);
+ networkCallback.expect(UNAVAILABLE);
// Declaring a request unfulfillable releases it automatically.
testFactory.expectRequestRemove();
@@ -6447,18 +6436,18 @@
private Network connectKeepaliveNetwork(LinkProperties lp) throws Exception {
// Ensure the network is disconnected before anything else occurs
- if (mWiFiNetworkAgent != null) {
- assertNull(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()));
+ if (mWiFiAgent != null) {
+ assertNull(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()));
}
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
waitForIdle();
- return mWiFiNetworkAgent.getNetwork();
+ return mWiFiAgent.getNetwork();
}
@Test
@@ -6515,10 +6504,10 @@
callback.expectError(PacketKeepalive.ERROR_HARDWARE_UNSUPPORTED);
// Check that a started keepalive can be stopped.
- mWiFiNetworkAgent.setStartKeepaliveEvent(PacketKeepalive.SUCCESS);
+ mWiFiAgent.setStartKeepaliveEvent(PacketKeepalive.SUCCESS);
ka = mCm.startNattKeepalive(myNet, validKaInterval, callback, myIPv4, 12345, dstIPv4);
callback.expectStarted();
- mWiFiNetworkAgent.setStopKeepaliveEvent(PacketKeepalive.SUCCESS);
+ mWiFiAgent.setStopKeepaliveEvent(PacketKeepalive.SUCCESS);
ka.stop();
callback.expectStopped();
@@ -6528,15 +6517,15 @@
callback.expectStarted();
bogusLp.removeLinkAddress(new LinkAddress(myIPv4, 25));
bogusLp.addLinkAddress(new LinkAddress(notMyIPv4, 25));
- mWiFiNetworkAgent.sendLinkProperties(bogusLp);
+ mWiFiAgent.sendLinkProperties(bogusLp);
callback.expectError(PacketKeepalive.ERROR_INVALID_IP_ADDRESS);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
// Check that a started keepalive is stopped correctly when the network disconnects.
ka = mCm.startNattKeepalive(myNet, validKaInterval, callback, myIPv4, 12345, dstIPv4);
callback.expectStarted();
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
callback.expectError(PacketKeepalive.ERROR_INVALID_NETWORK);
// ... and that stopping it after that has no adverse effects.
@@ -6547,15 +6536,15 @@
// Reconnect.
myNet = connectKeepaliveNetwork(lp);
- mWiFiNetworkAgent.setStartKeepaliveEvent(PacketKeepalive.SUCCESS);
+ mWiFiAgent.setStartKeepaliveEvent(PacketKeepalive.SUCCESS);
// Check that keepalive slots start from 1 and increment. The first one gets slot 1.
- mWiFiNetworkAgent.setExpectedKeepaliveSlot(1);
+ mWiFiAgent.setExpectedKeepaliveSlot(1);
ka = mCm.startNattKeepalive(myNet, validKaInterval, callback, myIPv4, 12345, dstIPv4);
callback.expectStarted();
// The second one gets slot 2.
- mWiFiNetworkAgent.setExpectedKeepaliveSlot(2);
+ mWiFiAgent.setExpectedKeepaliveSlot(2);
TestKeepaliveCallback callback2 = new TestKeepaliveCallback();
PacketKeepalive ka2 = mCm.startNattKeepalive(
myNet, validKaInterval, callback2, myIPv4, 6789, dstIPv4);
@@ -6565,7 +6554,7 @@
ka.stop();
callback.expectStopped();
- mWiFiNetworkAgent.setExpectedKeepaliveSlot(1);
+ mWiFiAgent.setExpectedKeepaliveSlot(1);
TestKeepaliveCallback callback3 = new TestKeepaliveCallback();
PacketKeepalive ka3 = mCm.startNattKeepalive(
myNet, validKaInterval, callback3, myIPv4, 9876, dstIPv4);
@@ -6667,12 +6656,12 @@
}
// Check that a started keepalive can be stopped.
- mWiFiNetworkAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
+ mWiFiAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
try (SocketKeepalive ka = mCm.createSocketKeepalive(
myNet, testSocket, myIPv4, dstIPv4, executor, callback)) {
ka.start(validKaInterval);
callback.expectStarted();
- mWiFiNetworkAgent.setStopKeepaliveEvent(SocketKeepalive.SUCCESS);
+ mWiFiAgent.setStopKeepaliveEvent(SocketKeepalive.SUCCESS);
ka.stop();
callback.expectStopped();
@@ -6701,9 +6690,9 @@
callback.expectStarted();
bogusLp.removeLinkAddress(new LinkAddress(myIPv4, 25));
bogusLp.addLinkAddress(new LinkAddress(notMyIPv4, 25));
- mWiFiNetworkAgent.sendLinkProperties(bogusLp);
+ mWiFiAgent.sendLinkProperties(bogusLp);
callback.expectError(SocketKeepalive.ERROR_INVALID_IP_ADDRESS);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
}
// Check that a started keepalive is stopped correctly when the network disconnects.
@@ -6711,21 +6700,20 @@
myNet, testSocket, myIPv4, dstIPv4, executor, callback)) {
ka.start(validKaInterval);
callback.expectStarted();
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
callback.expectError(SocketKeepalive.ERROR_INVALID_NETWORK);
// ... and that stopping it after that has no adverse effects.
waitForIdle();
- final Network myNetAlias = myNet;
- assertNull(mCm.getNetworkCapabilities(myNetAlias));
+ assertNull(mCm.getNetworkCapabilities(myNet));
ka.stop();
callback.assertNoCallback();
}
// Reconnect.
myNet = connectKeepaliveNetwork(lp);
- mWiFiNetworkAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
+ mWiFiAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
// Check that a stop followed by network disconnects does not result in crash.
try (SocketKeepalive ka = mCm.createSocketKeepalive(
@@ -6734,7 +6722,7 @@
callback.expectStarted();
// Delay the response of keepalive events in networkAgent long enough to make sure
// the follow-up network disconnection will be processed first.
- mWiFiNetworkAgent.setKeepaliveResponseDelay(3 * TIMEOUT_MS);
+ mWiFiAgent.setKeepaliveResponseDelay(3 * TIMEOUT_MS);
ka.stop();
// Call stop() twice shouldn't result in crash, b/182586681.
ka.stop();
@@ -6744,8 +6732,8 @@
waitForIdleSerialExecutor(executor, TIMEOUT_MS);
waitForIdle();
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
callback.expectStopped();
callback.assertNoCallback();
}
@@ -6753,20 +6741,18 @@
// Reconnect.
waitForIdle();
myNet = connectKeepaliveNetwork(lp);
- mWiFiNetworkAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
+ mWiFiAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
// Check that keepalive slots start from 1 and increment. The first one gets slot 1.
- mWiFiNetworkAgent.setExpectedKeepaliveSlot(1);
- int srcPort2 = 0;
+ mWiFiAgent.setExpectedKeepaliveSlot(1);
try (SocketKeepalive ka = mCm.createSocketKeepalive(
myNet, testSocket, myIPv4, dstIPv4, executor, callback)) {
ka.start(validKaInterval);
callback.expectStarted();
// The second one gets slot 2.
- mWiFiNetworkAgent.setExpectedKeepaliveSlot(2);
+ mWiFiAgent.setExpectedKeepaliveSlot(2);
final UdpEncapsulationSocket testSocket2 = mIpSec.openUdpEncapsulationSocket();
- srcPort2 = testSocket2.getPort();
TestSocketKeepaliveCallback callback2 = new TestSocketKeepaliveCallback(executor);
try (SocketKeepalive ka2 = mCm.createSocketKeepalive(
myNet, testSocket2, myIPv4, dstIPv4, executor, callback2)) {
@@ -6789,9 +6775,9 @@
// assertFalse(isUdpPortInUse(srcPort));
// assertFalse(isUdpPortInUse(srcPort2));
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
- mWiFiNetworkAgent = null;
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
+ mWiFiAgent = null;
}
@Test
@@ -6865,9 +6851,9 @@
testSocketV4.close();
testSocketV6.close();
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
- mWiFiNetworkAgent = null;
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
+ mWiFiAgent = null;
}
private void doTestNattSocketKeepalivesFdWithExecutor(Executor executor) throws Exception {
@@ -6882,8 +6868,8 @@
lp.addLinkAddress(new LinkAddress(myIPv4, 25));
lp.addRoute(new RouteInfo(InetAddress.getByName("192.0.2.254")));
Network myNet = connectKeepaliveNetwork(lp);
- mWiFiNetworkAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
- mWiFiNetworkAgent.setStopKeepaliveEvent(SocketKeepalive.SUCCESS);
+ mWiFiAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
+ mWiFiAgent.setStopKeepaliveEvent(SocketKeepalive.SUCCESS);
TestSocketKeepaliveCallback callback = new TestSocketKeepaliveCallback(executor);
@@ -6918,9 +6904,9 @@
// TODO: enable this check after ensuring a valid free port. See b/129512753#comment7.
// assertFalse(isUdpPortInUse(srcPort));
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
- mWiFiNetworkAgent = null;
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
+ mWiFiAgent = null;
}
private static boolean isUdpPortInUse(int port) {
@@ -6958,18 +6944,18 @@
}
private void assertPinnedToWifiWithCellDefault() {
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getBoundNetworkForProcess());
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getBoundNetworkForProcess());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
}
private void assertPinnedToWifiWithWifiDefault() {
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getBoundNetworkForProcess());
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getBoundNetworkForProcess());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
}
private void assertNotPinnedToWifi() {
assertNull(mCm.getBoundNetworkForProcess());
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
}
@Test
@@ -6982,23 +6968,23 @@
TestNetworkPinner.pin(mServiceContext, wifiRequest);
assertNull(mCm.getBoundNetworkForProcess());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
// When wi-fi connects, expect to be pinned.
assertTrue(TestNetworkPinner.awaitPin(100));
assertPinnedToWifiWithCellDefault();
// Disconnect and expect the pin to drop.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
assertTrue(TestNetworkPinner.awaitUnpin(100));
assertNotPinnedToWifi();
// Reconnecting does not cause the pin to come back.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
assertFalse(TestNetworkPinner.awaitPin(100));
assertNotPinnedToWifi();
@@ -7013,21 +6999,21 @@
// Disconnect cell and wifi.
ExpectedBroadcast b = registerConnectivityBroadcast(3); // cell down, wifi up, wifi down.
- mCellNetworkAgent.disconnect();
- mWiFiNetworkAgent.disconnect();
+ mCellAgent.disconnect();
+ mWiFiAgent.disconnect();
b.expectBroadcast();
// Pinning takes effect even if the pinned network is the default when the pin is set...
TestNetworkPinner.pin(mServiceContext, wifiRequest);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
assertTrue(TestNetworkPinner.awaitPin(100));
assertPinnedToWifiWithWifiDefault();
// ... and is maintained even when that network is no longer the default.
b = registerConnectivityBroadcast(1);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mCellAgent.connect(true);
b.expectBroadcast();
assertPinnedToWifiWithCellDefault();
}
@@ -7231,7 +7217,7 @@
// Disconnect wifi aware network.
wifiAware.disconnect();
- callback.expect(CallbackEntry.LOST, TIMEOUT_MS);
+ callback.expect(LOST, TIMEOUT_MS);
mCm.unregisterNetworkCallback(callback);
verifyNoNetwork();
@@ -7278,12 +7264,11 @@
// ConnectivityService.
TestNetworkAgentWrapper networkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
networkAgent.connect(true);
- networkCallback.expect(CallbackEntry.AVAILABLE, networkAgent);
- networkCallback.expect(CallbackEntry.NETWORK_CAPS_UPDATED, networkAgent);
+ networkCallback.expect(AVAILABLE, networkAgent);
+ networkCallback.expect(NETWORK_CAPS_UPDATED, networkAgent);
CallbackEntry.LinkPropertiesChanged cbi =
- networkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED,
- networkAgent);
- networkCallback.expect(CallbackEntry.BLOCKED_STATUS, networkAgent);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, networkAgent);
+ networkCallback.expect(BLOCKED_STATUS, networkAgent);
networkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, networkAgent);
networkCallback.assertNoCallback();
checkDirectlyConnectedRoutes(cbi.getLp(), asList(myIpv4Address),
@@ -7298,7 +7283,7 @@
newLp.addLinkAddress(myIpv6Address1);
newLp.addLinkAddress(myIpv6Address2);
networkAgent.sendLinkProperties(newLp);
- cbi = networkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, networkAgent);
+ cbi = networkCallback.expect(LINK_PROPERTIES_CHANGED, networkAgent);
networkCallback.assertNoCallback();
checkDirectlyConnectedRoutes(cbi.getLp(),
asList(myIpv4Address, myIpv6Address1, myIpv6Address2),
@@ -7359,15 +7344,15 @@
}
private List<Network> onlyCell() {
- return List.of(mCellNetworkAgent.getNetwork());
+ return List.of(mCellAgent.getNetwork());
}
private List<Network> onlyWifi() {
- return List.of(mWiFiNetworkAgent.getNetwork());
+ return List.of(mWiFiAgent.getNetwork());
}
private List<Network> cellAndWifi() {
- return List.of(mCellNetworkAgent.getNetwork(), mWiFiNetworkAgent.getNetwork());
+ return List.of(mCellAgent.getNetwork(), mWiFiAgent.getNetwork());
}
@Test
@@ -7377,11 +7362,11 @@
LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
// Simple connection with initial LP should have updated ifaces.
- mCellNetworkAgent.connect(false);
+ mCellAgent.connect(false);
waitForIdle();
expectNotifyNetworkStatus(onlyCell(), onlyCell(), MOBILE_IFNAME);
reset(mStatsManager);
@@ -7391,13 +7376,13 @@
cellLp.addRoute(new RouteInfo((IpPrefix) null, InetAddress.getByName("192.0.2.4"),
MOBILE_IFNAME));
cellLp.setDnsServers(List.of(InetAddress.getAllByName("8.8.8.8")));
- mCellNetworkAgent.sendLinkProperties(cellLp);
+ mCellAgent.sendLinkProperties(cellLp);
verifyNoMoreInteractions(mStatsManager);
reset(mStatsManager);
// Default network switch should update ifaces.
- mWiFiNetworkAgent.connect(false);
- mWiFiNetworkAgent.sendLinkProperties(wifiLp);
+ mWiFiAgent.connect(false);
+ mWiFiAgent.sendLinkProperties(wifiLp);
waitForIdle();
assertEquals(wifiLp, mService.getActiveLinkProperties());
expectNotifyNetworkStatus(cellAndWifi(), onlyWifi(), WIFI_IFNAME);
@@ -7409,52 +7394,52 @@
// notifyNetworkStatus is called again, traffic on that interface will be accounted to the
// disconnected network. This is likely a bug in ConnectivityService; it should probably
// call notifyNetworkStatus again without the disconnected network.
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
waitForIdle();
expectNotifyNetworkStatus(cellAndWifi(), onlyWifi(), WIFI_IFNAME);
verifyNoMoreInteractions(mStatsManager);
reset(mStatsManager);
// Connecting a network updates ifaces even if the network doesn't become default.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(false);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(false);
waitForIdle();
expectNotifyNetworkStatus(cellAndWifi(), onlyWifi(), WIFI_IFNAME);
reset(mStatsManager);
// Disconnect should update ifaces.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
waitForIdle();
expectNotifyNetworkStatus(onlyCell(), onlyCell(), MOBILE_IFNAME);
reset(mStatsManager);
// Metered change should update ifaces
- mCellNetworkAgent.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
+ mCellAgent.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
waitForIdle();
expectNotifyNetworkStatus(onlyCell(), onlyCell(), MOBILE_IFNAME);
reset(mStatsManager);
- mCellNetworkAgent.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
+ mCellAgent.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
waitForIdle();
expectNotifyNetworkStatus(onlyCell(), onlyCell(), MOBILE_IFNAME);
reset(mStatsManager);
// Temp metered change shouldn't update ifaces
- mCellNetworkAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
+ mCellAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
waitForIdle();
verify(mStatsManager, never()).notifyNetworkStatus(eq(onlyCell()),
any(List.class), eq(MOBILE_IFNAME), any(List.class));
reset(mStatsManager);
// Congested change shouldn't update ifaces
- mCellNetworkAgent.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED);
+ mCellAgent.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED);
waitForIdle();
verify(mStatsManager, never()).notifyNetworkStatus(eq(onlyCell()),
any(List.class), eq(MOBILE_IFNAME), any(List.class));
reset(mStatsManager);
// Roaming change should update ifaces
- mCellNetworkAgent.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING);
+ mCellAgent.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING);
waitForIdle();
expectNotifyNetworkStatus(onlyCell(), onlyCell(), MOBILE_IFNAME);
reset(mStatsManager);
@@ -7466,25 +7451,22 @@
mMockVpn.establishForMyUid(lp);
assertUidRangesUpdatedForMyUid(true);
- final List<Network> cellAndVpn =
- List.of(mCellNetworkAgent.getNetwork(), mMockVpn.getNetwork());
+ final List<Network> cellAndVpn = List.of(mCellAgent.getNetwork(), mMockVpn.getNetwork());
// A VPN with default (null) underlying networks sets the underlying network's interfaces...
expectNotifyNetworkStatus(cellAndVpn, cellAndVpn, MOBILE_IFNAME, Process.myUid(),
VPN_IFNAME, List.of(MOBILE_IFNAME));
// ...and updates them as the default network switches.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- mWiFiNetworkAgent.sendLinkProperties(wifiLp);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ mWiFiAgent.sendLinkProperties(wifiLp);
final Network[] onlyNull = new Network[]{null};
- final List<Network> wifiAndVpn =
- List.of(mWiFiNetworkAgent.getNetwork(), mMockVpn.getNetwork());
- final List<Network> cellWifiAndVpn =
- List.of(mCellNetworkAgent.getNetwork(), mWiFiNetworkAgent.getNetwork(),
- mMockVpn.getNetwork());
+ final List<Network> wifiAndVpn = List.of(mWiFiAgent.getNetwork(), mMockVpn.getNetwork());
+ final List<Network> cellWifiAndVpn = List.of(mCellAgent.getNetwork(),
+ mWiFiAgent.getNetwork(), mMockVpn.getNetwork());
final Network[] cellNullAndWifi =
- new Network[]{mCellNetworkAgent.getNetwork(), null, mWiFiNetworkAgent.getNetwork()};
+ new Network[] { mCellAgent.getNetwork(), null, mWiFiAgent.getNetwork() };
waitForIdle();
assertEquals(wifiLp, mService.getActiveLinkProperties());
@@ -7524,9 +7506,9 @@
// could result in incorrect data usage measurements if the interface used by the
// disconnected network is reused by a system component that does not register an agent for
// it (e.g., tethering).
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
waitForIdle();
- assertNull(mService.getLinkProperties(mCellNetworkAgent.getNetwork()));
+ assertNull(mService.getLinkProperties(mCellAgent.getNetwork()));
expectNotifyNetworkStatus(cellWifiAndVpn, wifiAndVpn, MOBILE_IFNAME, Process.myUid(),
VPN_IFNAME, List.of(MOBILE_IFNAME, WIFI_IFNAME));
@@ -7542,16 +7524,16 @@
// ... but if something else happens that causes notifyIfacesChangedForNetworkStats to be
// called again, it does. For example, connect Ethernet, but with a low score, such that it
// does not become the default network.
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mEthernetNetworkAgent.setScore(
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mEthernetAgent.setScore(
new NetworkScore.Builder().setLegacyInt(30).setExiting(true).build());
- mEthernetNetworkAgent.connect(false);
+ mEthernetAgent.connect(false);
waitForIdle();
verify(mStatsManager).notifyNetworkStatus(any(List.class),
any(List.class), any() /* anyString() doesn't match null */,
argThat(vpnInfos -> vpnInfos.get(0).getUnderlyingInterfaces().size() == 1
&& WIFI_IFNAME.equals(vpnInfos.get(0).getUnderlyingInterfaces().get(0))));
- mEthernetNetworkAgent.disconnect();
+ mEthernetAgent.disconnect();
waitForIdle();
reset(mStatsManager);
@@ -7591,18 +7573,18 @@
final int[] adminUids = new int[] {Process.myUid() + 1};
final NetworkCapabilities ncTemplate = new NetworkCapabilities();
ncTemplate.setAdministratorUids(adminUids);
- mCellNetworkAgent =
+ mCellAgent =
new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, new LinkProperties(), ncTemplate);
- mCellNetworkAgent.connect(false /* validated */);
+ mCellAgent.connect(false /* validated */);
// Verify case where caller has permission
mServiceContext.setPermission(
NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, PERMISSION_GRANTED);
TestNetworkCallback callback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(callback);
- callback.expect(CallbackEntry.AVAILABLE, mCellNetworkAgent);
+ callback.expect(AVAILABLE, mCellAgent);
callback.expectCapabilitiesThat(
- mCellNetworkAgent, nc -> Arrays.equals(adminUids, nc.getAdministratorUids()));
+ mCellAgent, nc -> Arrays.equals(adminUids, nc.getAdministratorUids()));
mCm.unregisterNetworkCallback(callback);
// Verify case where caller does NOT have permission
@@ -7611,9 +7593,8 @@
mServiceContext.setPermission(NETWORK_STACK, PERMISSION_DENIED);
callback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(callback);
- callback.expect(CallbackEntry.AVAILABLE, mCellNetworkAgent);
- callback.expectCapabilitiesThat(
- mCellNetworkAgent, nc -> nc.getAdministratorUids().length == 0);
+ callback.expect(AVAILABLE, mCellAgent);
+ callback.expectCapabilitiesThat(mCellAgent, nc -> nc.getAdministratorUids().length == 0);
}
@Test
@@ -7630,10 +7611,10 @@
// Connect a VCN-managed wifi network.
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.removeCapability(NET_CAPABILITY_NOT_VCN_MANAGED);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.removeCapability(NET_CAPABILITY_NOT_VCN_MANAGED);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true /* validated */);
final List<Network> none = List.of();
expectNotifyNetworkStatus(onlyWifi(), none, null); // Wifi is not the default network
@@ -7648,7 +7629,7 @@
final LinkProperties lp = new LinkProperties();
lp.setInterfaceName(vcnIface);
final TestNetworkAgentWrapper vcn = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, lp, nc);
- vcn.setUnderlyingNetworks(List.of(mWiFiNetworkAgent.getNetwork()));
+ vcn.setUnderlyingNetworks(List.of(mWiFiAgent.getNetwork()));
vcn.connect(false /* validated */);
final TestNetworkCallback callback = new TestNetworkCallback();
@@ -7661,12 +7642,12 @@
assertFalse(nc.hasTransport(TRANSPORT_WIFI));
assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_METERED));
final List<Network> onlyVcn = List.of(vcn.getNetwork());
- final List<Network> vcnAndWifi = List.of(vcn.getNetwork(), mWiFiNetworkAgent.getNetwork());
+ final List<Network> vcnAndWifi = List.of(vcn.getNetwork(), mWiFiAgent.getNetwork());
expectNotifyNetworkStatus(vcnAndWifi, onlyVcn, vcnIface, ownerUid, vcnIface,
List.of(WIFI_IFNAME));
// Add NOT_METERED to the underlying network, check that it is not propagated.
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
callback.assertNoCallback();
nc = mCm.getNetworkCapabilities(vcn.getNetwork());
assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_METERED));
@@ -7674,11 +7655,11 @@
// Switch underlying networks.
final LinkProperties cellLp = new LinkProperties();
cellLp.setInterfaceName(MOBILE_IFNAME);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_VCN_MANAGED);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_ROAMING);
- mCellNetworkAgent.connect(false /* validated */);
- vcn.setUnderlyingNetworks(List.of(mCellNetworkAgent.getNetwork()));
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_VCN_MANAGED);
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_ROAMING);
+ mCellAgent.connect(false /* validated */);
+ vcn.setUnderlyingNetworks(List.of(mCellAgent.getNetwork()));
// The underlying capability changes do not propagate to the virtual network, but
// NetworkStatsService is informed of the new underlying interface.
@@ -7687,7 +7668,7 @@
assertFalse(nc.hasTransport(TRANSPORT_WIFI));
assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_ROAMING));
final List<Network> vcnWifiAndCell = List.of(vcn.getNetwork(),
- mWiFiNetworkAgent.getNetwork(), mCellNetworkAgent.getNetwork());
+ mWiFiAgent.getNetwork(), mCellAgent.getNetwork());
expectNotifyNetworkStatus(vcnWifiAndCell, onlyVcn, vcnIface, ownerUid, vcnIface,
List.of(MOBILE_IFNAME));
}
@@ -7696,7 +7677,7 @@
public void testBasicDnsConfigurationPushed() throws Exception {
setPrivateDnsSettings(PRIVATE_DNS_MODE_OPPORTUNISTIC, "ignored.example.com");
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
waitForIdle();
verify(mMockDnsResolver, never()).setResolverConfiguration(any());
verifyNoMoreInteractions(mMockDnsResolver);
@@ -7712,18 +7693,17 @@
cellLp.addLinkAddress(new LinkAddress("2001:db8:1::1/64"));
cellLp.addRoute(new RouteInfo((IpPrefix) null, InetAddress.getByName("2001:db8:1::1"),
MOBILE_IFNAME));
- mCellNetworkAgent.sendLinkProperties(cellLp);
- mCellNetworkAgent.connect(false);
+ mCellAgent.sendLinkProperties(cellLp);
+ mCellAgent.connect(false);
waitForIdle();
- verify(mMockDnsResolver, times(1)).createNetworkCache(
- eq(mCellNetworkAgent.getNetwork().netId));
+ verify(mMockDnsResolver, times(1)).createNetworkCache(eq(mCellAgent.getNetwork().netId));
// CS tells dnsresolver about the empty DNS config for this network.
verify(mMockDnsResolver, atLeastOnce()).setResolverConfiguration(any());
reset(mMockDnsResolver);
cellLp.addDnsServer(InetAddress.getByName("2001:db8::1"));
- mCellNetworkAgent.sendLinkProperties(cellLp);
+ mCellAgent.sendLinkProperties(cellLp);
waitForIdle();
verify(mMockDnsResolver, atLeastOnce()).setResolverConfiguration(
mResolverParamsParcelCaptor.capture());
@@ -7735,7 +7715,7 @@
reset(mMockDnsResolver);
cellLp.addDnsServer(InetAddress.getByName("192.0.2.1"));
- mCellNetworkAgent.sendLinkProperties(cellLp);
+ mCellAgent.sendLinkProperties(cellLp);
waitForIdle();
verify(mMockDnsResolver, atLeastOnce()).setResolverConfiguration(
mResolverParamsParcelCaptor.capture());
@@ -7753,7 +7733,7 @@
final String TLS_SERVER6 = "2001:db8:53::53";
final InetAddress[] TLS_IPS = new InetAddress[]{ InetAddress.getByName(TLS_SERVER6) };
final String[] TLS_SERVERS = new String[]{ TLS_SERVER6 };
- mCellNetworkAgent.mNmCallbacks.notifyPrivateDnsConfigResolved(
+ mCellAgent.mNmCallbacks.notifyPrivateDnsConfigResolved(
new PrivateDnsConfig(TLS_SPECIFIER, TLS_IPS).toParcel());
waitForIdle();
@@ -7774,11 +7754,10 @@
final TestNetworkCallback callback = new TestNetworkCallback();
mCm.registerNetworkCallback(request, callback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- verify(mMockDnsResolver, times(1)).createNetworkCache(
- eq(mWiFiNetworkAgent.getNetwork().netId));
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ verify(mMockDnsResolver, times(1)).createNetworkCache(eq(mWiFiAgent.getNetwork().netId));
verify(mMockDnsResolver, times(2)).setResolverConfiguration(
mResolverParamsParcelCaptor.capture());
final ResolverParamsParcel resolverParams = mResolverParamsParcelCaptor.getValue();
@@ -7794,31 +7773,31 @@
TestNetworkCallback callback = new TestNetworkCallback();
mCm.registerNetworkCallback(request, callback);
// Bring up wifi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Private DNS resolution failed, checking if the notification will be shown or not.
- mWiFiNetworkAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
- mWiFiNetworkAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
+ mWiFiAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
+ mWiFiAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
waitForIdle();
// If network validation failed, NetworkMonitor will re-evaluate the network.
// ConnectivityService should filter the redundant notification. This part is trying to
// simulate that situation and check if ConnectivityService could filter that case.
- mWiFiNetworkAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
+ mWiFiAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
waitForIdle();
verify(mNotificationManager, timeout(TIMEOUT_MS).times(1)).notify(anyString(),
eq(NotificationType.PRIVATE_DNS_BROKEN.eventId), any());
// If private DNS resolution successful, the PRIVATE_DNS_BROKEN notification shouldn't be
// shown.
- mWiFiNetworkAgent.setNetworkValid(true /* privateDnsProbeSent */);
- mWiFiNetworkAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
+ mWiFiAgent.setNetworkValid(true /* privateDnsProbeSent */);
+ mWiFiAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
waitForIdle();
verify(mNotificationManager, timeout(TIMEOUT_MS).times(1)).cancel(anyString(),
eq(NotificationType.PRIVATE_DNS_BROKEN.eventId));
// If private DNS resolution failed again, the PRIVATE_DNS_BROKEN notification should be
// shown again.
- mWiFiNetworkAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
- mWiFiNetworkAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
+ mWiFiAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
+ mWiFiAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
waitForIdle();
verify(mNotificationManager, timeout(TIMEOUT_MS).times(2)).notify(anyString(),
eq(NotificationType.PRIVATE_DNS_BROKEN.eventId), any());
@@ -7834,7 +7813,7 @@
.addTransportType(TRANSPORT_CELLULAR).build();
mCm.requestNetwork(cellRequest, cellNetworkCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
waitForIdle();
// CS tells netd about the empty DNS config for this network.
verify(mMockDnsResolver, never()).setResolverConfiguration(any());
@@ -7854,11 +7833,10 @@
cellLp.addDnsServer(InetAddress.getByName("2001:db8::1"));
cellLp.addDnsServer(InetAddress.getByName("192.0.2.1"));
- mCellNetworkAgent.sendLinkProperties(cellLp);
- mCellNetworkAgent.connect(false);
+ mCellAgent.sendLinkProperties(cellLp);
+ mCellAgent.connect(false);
waitForIdle();
- verify(mMockDnsResolver, times(1)).createNetworkCache(
- eq(mCellNetworkAgent.getNetwork().netId));
+ verify(mMockDnsResolver, times(1)).createNetworkCache(eq(mCellAgent.getNetwork().netId));
verify(mMockDnsResolver, atLeastOnce()).setResolverConfiguration(
mResolverParamsParcelCaptor.capture());
ResolverParamsParcel resolvrParams = mResolverParamsParcelCaptor.getValue();
@@ -7870,12 +7848,11 @@
assertTrue(new ArraySet<>(resolvrParams.tlsServers).containsAll(
asList("2001:db8::1", "192.0.2.1")));
reset(mMockDnsResolver);
- cellNetworkCallback.expect(CallbackEntry.AVAILABLE, mCellNetworkAgent);
- cellNetworkCallback.expect(CallbackEntry.NETWORK_CAPS_UPDATED,
- mCellNetworkAgent);
+ cellNetworkCallback.expect(AVAILABLE, mCellAgent);
+ cellNetworkCallback.expect(NETWORK_CAPS_UPDATED, mCellAgent);
CallbackEntry.LinkPropertiesChanged cbi = cellNetworkCallback.expect(
- CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
- cellNetworkCallback.expect(CallbackEntry.BLOCKED_STATUS, mCellNetworkAgent);
+ LINK_PROPERTIES_CHANGED, mCellAgent);
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertFalse(cbi.getLp().isPrivateDnsActive());
assertNull(cbi.getLp().getPrivateDnsServerName());
@@ -7906,8 +7883,7 @@
setPrivateDnsSettings(PRIVATE_DNS_MODE_PROVIDER_HOSTNAME, "strict.example.com");
// Can't test dns configuration for strict mode without properly mocking
// out the DNS lookups, but can test that LinkProperties is updated.
- cbi = cellNetworkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED,
- mCellNetworkAgent);
+ cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertTrue(cbi.getLp().isPrivateDnsActive());
assertEquals("strict.example.com", cbi.getLp().getPrivateDnsServerName());
@@ -7933,18 +7909,17 @@
.addTransportType(TRANSPORT_CELLULAR).build();
mCm.requestNetwork(cellRequest, cellNetworkCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
waitForIdle();
LinkProperties lp = new LinkProperties();
- mCellNetworkAgent.sendLinkProperties(lp);
- mCellNetworkAgent.connect(false);
+ mCellAgent.sendLinkProperties(lp);
+ mCellAgent.connect(false);
waitForIdle();
- cellNetworkCallback.expect(CallbackEntry.AVAILABLE, mCellNetworkAgent);
- cellNetworkCallback.expect(CallbackEntry.NETWORK_CAPS_UPDATED,
- mCellNetworkAgent);
+ cellNetworkCallback.expect(AVAILABLE, mCellAgent);
+ cellNetworkCallback.expect(NETWORK_CAPS_UPDATED, mCellAgent);
CallbackEntry.LinkPropertiesChanged cbi = cellNetworkCallback.expect(
- CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
- cellNetworkCallback.expect(CallbackEntry.BLOCKED_STATUS, mCellNetworkAgent);
+ LINK_PROPERTIES_CHANGED, mCellAgent);
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertFalse(cbi.getLp().isPrivateDnsActive());
assertNull(cbi.getLp().getPrivateDnsServerName());
@@ -7954,16 +7929,15 @@
// Send a validation event for a server that is not part of the current
// resolver config. The validation event should be ignored.
mService.mResolverUnsolEventCallback.onPrivateDnsValidationEvent(
- makePrivateDnsValidationEvent(mCellNetworkAgent.getNetwork().netId, "",
+ makePrivateDnsValidationEvent(mCellAgent.getNetwork().netId, "",
"145.100.185.18", VALIDATION_RESULT_SUCCESS));
cellNetworkCallback.assertNoCallback();
// Add a dns server to the LinkProperties.
LinkProperties lp2 = new LinkProperties(lp);
lp2.addDnsServer(InetAddress.getByName("145.100.185.16"));
- mCellNetworkAgent.sendLinkProperties(lp2);
- cbi = cellNetworkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED,
- mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(lp2);
+ cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertFalse(cbi.getLp().isPrivateDnsActive());
assertNull(cbi.getLp().getPrivateDnsServerName());
@@ -7973,13 +7947,13 @@
// Send a validation event containing a hostname that is not part of
// the current resolver config. The validation event should be ignored.
mService.mResolverUnsolEventCallback.onPrivateDnsValidationEvent(
- makePrivateDnsValidationEvent(mCellNetworkAgent.getNetwork().netId,
+ makePrivateDnsValidationEvent(mCellAgent.getNetwork().netId,
"145.100.185.16", "hostname", VALIDATION_RESULT_SUCCESS));
cellNetworkCallback.assertNoCallback();
// Send a validation event where validation failed.
mService.mResolverUnsolEventCallback.onPrivateDnsValidationEvent(
- makePrivateDnsValidationEvent(mCellNetworkAgent.getNetwork().netId,
+ makePrivateDnsValidationEvent(mCellAgent.getNetwork().netId,
"145.100.185.16", "", VALIDATION_RESULT_FAILURE));
cellNetworkCallback.assertNoCallback();
@@ -7987,10 +7961,9 @@
// the current resolver config. A LinkProperties callback with updated
// private dns fields should be sent.
mService.mResolverUnsolEventCallback.onPrivateDnsValidationEvent(
- makePrivateDnsValidationEvent(mCellNetworkAgent.getNetwork().netId,
+ makePrivateDnsValidationEvent(mCellAgent.getNetwork().netId,
"145.100.185.16", "", VALIDATION_RESULT_SUCCESS));
- cbi = cellNetworkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED,
- mCellNetworkAgent);
+ cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertTrue(cbi.getLp().isPrivateDnsActive());
assertNull(cbi.getLp().getPrivateDnsServerName());
@@ -8000,9 +7973,8 @@
// the network agent sends unrelated changes.
LinkProperties lp3 = new LinkProperties(lp2);
lp3.setMtu(1300);
- mCellNetworkAgent.sendLinkProperties(lp3);
- cbi = cellNetworkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED,
- mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(lp3);
+ cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertTrue(cbi.getLp().isPrivateDnsActive());
assertNull(cbi.getLp().getPrivateDnsServerName());
@@ -8013,9 +7985,8 @@
// fields in LinkProperties.
LinkProperties lp4 = new LinkProperties(lp3);
lp4.removeDnsServer(InetAddress.getByName("145.100.185.16"));
- mCellNetworkAgent.sendLinkProperties(lp4);
- cbi = cellNetworkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED,
- mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(lp4);
+ cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertFalse(cbi.getLp().isPrivateDnsActive());
assertNull(cbi.getLp().getPrivateDnsServerName());
@@ -8050,10 +8021,10 @@
@Test
public void testApplyUnderlyingCapabilities() throws Exception {
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mCellNetworkAgent.connect(false /* validated */);
- mWiFiNetworkAgent.connect(false /* validated */);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mCellAgent.connect(false /* validated */);
+ mWiFiAgent.connect(false /* validated */);
final NetworkCapabilities cellNc = new NetworkCapabilities()
.addTransportType(TRANSPORT_CELLULAR)
@@ -8070,12 +8041,12 @@
.addCapability(NET_CAPABILITY_NOT_SUSPENDED)
.addCapability(NET_CAPABILITY_NOT_VCN_MANAGED)
.setLinkUpstreamBandwidthKbps(20);
- mCellNetworkAgent.setNetworkCapabilities(cellNc, true /* sendToConnectivityService */);
- mWiFiNetworkAgent.setNetworkCapabilities(wifiNc, true /* sendToConnectivityService */);
+ mCellAgent.setNetworkCapabilities(cellNc, true /* sendToConnectivityService */);
+ mWiFiAgent.setNetworkCapabilities(wifiNc, true /* sendToConnectivityService */);
waitForIdle();
- final Network mobile = mCellNetworkAgent.getNetwork();
- final Network wifi = mWiFiNetworkAgent.getNetwork();
+ final Network mobile = mCellAgent.getNetwork();
+ final Network wifi = mWiFiAgent.getNetwork();
final NetworkCapabilities initialCaps = new NetworkCapabilities();
initialCaps.addTransportType(TRANSPORT_VPN);
@@ -8206,8 +8177,7 @@
mMockVpn.setUnderlyingNetworks(new Network[]{wifiNetwork});
// onCapabilitiesChanged() should be called because
// NetworkCapabilities#mUnderlyingNetworks is updated.
- CallbackEntry ce = callback.expect(CallbackEntry.NETWORK_CAPS_UPDATED,
- mMockVpn);
+ CallbackEntry ce = callback.expect(NETWORK_CAPS_UPDATED, mMockVpn);
final NetworkCapabilities vpnNc1 = ((CallbackEntry.CapabilitiesChanged) ce).getCaps();
// Since the wifi network hasn't brought up,
// ConnectivityService#applyUnderlyingCapabilities cannot find it. Update
@@ -8230,9 +8200,9 @@
// Make that underlying network connect, and expect to see its capabilities immediately
// reflected in the VPN's capabilities.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- assertEquals(wifiNetwork, mWiFiNetworkAgent.getNetwork());
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ assertEquals(wifiNetwork, mWiFiAgent.getNetwork());
+ mWiFiAgent.connect(false);
// TODO: the callback for the VPN happens before any callbacks are called for the wifi
// network that has just connected. There appear to be two issues here:
// 1. The VPN code will accept an underlying network as soon as getNetworkCapabilities()
@@ -8243,21 +8213,21 @@
// 2. When a network connects, updateNetworkInfo propagates underlying network
// capabilities before rematching networks.
// Given that this scenario can't really happen, this is probably fine for now.
- ce = callback.expect(CallbackEntry.NETWORK_CAPS_UPDATED, mMockVpn);
+ ce = callback.expect(NETWORK_CAPS_UPDATED, mMockVpn);
final NetworkCapabilities vpnNc2 = ((CallbackEntry.CapabilitiesChanged) ce).getCaps();
// The wifi network is brought up, NetworkCapabilities#mUnderlyingNetworks is updated to
// it.
underlyingNetwork.add(wifiNetwork);
assertEquals(underlyingNetwork, vpnNc2.getUnderlyingNetworks());
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
assertTrue(mCm.getNetworkCapabilities(mMockVpn.getNetwork())
.hasTransport(TRANSPORT_VPN));
assertTrue(mCm.getNetworkCapabilities(mMockVpn.getNetwork())
.hasTransport(TRANSPORT_WIFI));
// Disconnect the network, and expect to see the VPN capabilities change accordingly.
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
callback.expectCapabilitiesThat(mMockVpn, (nc) ->
nc.getTransportTypes().length == 1 && nc.hasTransport(TRANSPORT_VPN));
@@ -8283,8 +8253,8 @@
callback.expectAvailableCallbacksUnvalidated(mMockVpn);
// Connect cellular data.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false /* validated */);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false /* validated */);
callback.expectCapabilitiesThat(mMockVpn,
nc -> nc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED)
&& nc.hasTransport(TRANSPORT_CELLULAR));
@@ -8299,11 +8269,11 @@
assertGetNetworkInfoOfGetActiveNetworkIsConnected(true);
// Suspend the cellular network and expect the VPN to be suspended.
- mCellNetworkAgent.suspend();
+ mCellAgent.suspend();
callback.expectCapabilitiesThat(mMockVpn,
nc -> !nc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED)
&& nc.hasTransport(TRANSPORT_CELLULAR));
- callback.expect(CallbackEntry.SUSPENDED, mMockVpn);
+ callback.expect(SUSPENDED, mMockVpn);
callback.assertNoCallback();
assertFalse(mCm.getNetworkCapabilities(mMockVpn.getNetwork())
@@ -8316,12 +8286,12 @@
assertGetNetworkInfoOfGetActiveNetworkIsConnected(false);
// Switch to another network. The VPN should no longer be suspended.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false /* validated */);
callback.expectCapabilitiesThat(mMockVpn,
nc -> nc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED)
&& nc.hasTransport(TRANSPORT_WIFI));
- callback.expect(CallbackEntry.RESUMED, mMockVpn);
+ callback.expect(RESUMED, mMockVpn);
callback.assertNoCallback();
assertTrue(mCm.getNetworkCapabilities(mMockVpn.getNetwork())
@@ -8333,9 +8303,9 @@
assertGetNetworkInfoOfGetActiveNetworkIsConnected(true);
// Unsuspend cellular and then switch back to it. The VPN remains not suspended.
- mCellNetworkAgent.resume();
+ mCellAgent.resume();
callback.assertNoCallback();
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
callback.expectCapabilitiesThat(mMockVpn,
nc -> nc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED)
&& nc.hasTransport(TRANSPORT_CELLULAR));
@@ -8354,11 +8324,11 @@
assertGetNetworkInfoOfGetActiveNetworkIsConnected(true);
// Suspend cellular and expect no connectivity.
- mCellNetworkAgent.suspend();
+ mCellAgent.suspend();
callback.expectCapabilitiesThat(mMockVpn,
nc -> !nc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED)
&& nc.hasTransport(TRANSPORT_CELLULAR));
- callback.expect(CallbackEntry.SUSPENDED, mMockVpn);
+ callback.expect(SUSPENDED, mMockVpn);
callback.assertNoCallback();
assertFalse(mCm.getNetworkCapabilities(mMockVpn.getNetwork())
@@ -8370,11 +8340,11 @@
assertGetNetworkInfoOfGetActiveNetworkIsConnected(false);
// Resume cellular and expect that connectivity comes back.
- mCellNetworkAgent.resume();
+ mCellAgent.resume();
callback.expectCapabilitiesThat(mMockVpn,
nc -> nc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED)
&& nc.hasTransport(TRANSPORT_CELLULAR));
- callback.expect(CallbackEntry.RESUMED, mMockVpn);
+ callback.expect(RESUMED, mMockVpn);
callback.assertNoCallback();
assertTrue(mCm.getNetworkCapabilities(mMockVpn.getNetwork())
@@ -8413,14 +8383,14 @@
new Handler(ConnectivityThread.getInstanceLooper()));
defaultCallback.assertNoCallback();
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
- genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- genericNotVpnNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- systemDefaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ genericNotVpnNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ systemDefaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
vpnNetworkCallback.assertNoCallback();
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
@@ -8446,16 +8416,15 @@
defaultCallback.expectAvailableThenValidatedCallbacks(mMockVpn);
systemDefaultCallback.assertNoCallback();
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- assertEquals(mWiFiNetworkAgent.getNetwork(),
- systemDefaultCallback.getLastAvailableNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), systemDefaultCallback.getLastAvailableNetwork());
ranges.clear();
mMockVpn.setUids(ranges);
- genericNetworkCallback.expect(CallbackEntry.LOST, mMockVpn);
+ genericNetworkCallback.expect(LOST, mMockVpn);
genericNotVpnNetworkCallback.assertNoCallback();
wifiNetworkCallback.assertNoCallback();
- vpnNetworkCallback.expect(CallbackEntry.LOST, mMockVpn);
+ vpnNetworkCallback.expect(LOST, mMockVpn);
// TODO : The default network callback should actually get a LOST call here (also see the
// comment below for AVAILABLE). This is because ConnectivityService does not look at UID
@@ -8463,7 +8432,7 @@
// can't currently update their UIDs without disconnecting, so this does not matter too
// much, but that is the reason the test here has to check for an update to the
// capabilities instead of the expected LOST then AVAILABLE.
- defaultCallback.expect(CallbackEntry.NETWORK_CAPS_UPDATED, mMockVpn);
+ defaultCallback.expect(NETWORK_CAPS_UPDATED, mMockVpn);
systemDefaultCallback.assertNoCallback();
ranges.add(new UidRange(uid, uid));
@@ -8475,25 +8444,25 @@
vpnNetworkCallback.expectAvailableCallbacksValidated(mMockVpn);
// TODO : Here like above, AVAILABLE would be correct, but because this can't actually
// happen outside of the test, ConnectivityService does not rematch callbacks.
- defaultCallback.expect(CallbackEntry.NETWORK_CAPS_UPDATED, mMockVpn);
+ defaultCallback.expect(NETWORK_CAPS_UPDATED, mMockVpn);
systemDefaultCallback.assertNoCallback();
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
- genericNetworkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- genericNotVpnNetworkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- wifiNetworkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ genericNetworkCallback.expect(LOST, mWiFiAgent);
+ genericNotVpnNetworkCallback.expect(LOST, mWiFiAgent);
+ wifiNetworkCallback.expect(LOST, mWiFiAgent);
vpnNetworkCallback.assertNoCallback();
defaultCallback.assertNoCallback();
- systemDefaultCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ systemDefaultCallback.expect(LOST, mWiFiAgent);
mMockVpn.disconnect();
- genericNetworkCallback.expect(CallbackEntry.LOST, mMockVpn);
+ genericNetworkCallback.expect(LOST, mMockVpn);
genericNotVpnNetworkCallback.assertNoCallback();
wifiNetworkCallback.assertNoCallback();
- vpnNetworkCallback.expect(CallbackEntry.LOST, mMockVpn);
- defaultCallback.expect(CallbackEntry.LOST, mMockVpn);
+ vpnNetworkCallback.expect(LOST, mMockVpn);
+ defaultCallback.expect(LOST, mMockVpn);
systemDefaultCallback.assertNoCallback();
assertEquals(null, mCm.getActiveNetwork());
@@ -8511,10 +8480,10 @@
final TestNetworkCallback defaultCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(defaultCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
- defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
mMockVpn.establishForMyUid(true /* validated */, false /* hasInternet */,
@@ -8537,10 +8506,10 @@
final TestNetworkCallback defaultCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(defaultCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
- defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
mMockVpn.establishForMyUid(true /* validated */, true /* hasInternet */,
@@ -8551,8 +8520,8 @@
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
mMockVpn.disconnect();
- defaultCallback.expect(CallbackEntry.LOST, mMockVpn);
- defaultCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
+ defaultCallback.expect(LOST, mMockVpn);
+ defaultCallback.expectAvailableCallbacksValidated(mWiFiAgent);
mCm.unregisterNetworkCallback(defaultCallback);
}
@@ -8563,9 +8532,9 @@
mCm.registerDefaultNetworkCallback(callback);
// Bring up Ethernet.
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mEthernetNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mEthernetNetworkAgent);
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mEthernetAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mEthernetAgent);
callback.assertNoCallback();
// Bring up a VPN that has the INTERNET capability, initially unvalidated.
@@ -8600,8 +8569,8 @@
callback.assertNoCallback();
mMockVpn.disconnect();
- callback.expect(CallbackEntry.LOST, mMockVpn);
- callback.expectAvailableCallbacksValidated(mEthernetNetworkAgent);
+ callback.expect(LOST, mMockVpn);
+ callback.expectAvailableCallbacksValidated(mEthernetAgent);
}
@Test
@@ -8618,9 +8587,9 @@
// Connect cell. It will become the default network, and in the absence of setting
// underlying networks explicitly it will become the sole underlying network for the vpn.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
+ mCellAgent.connect(true);
mMockVpn.establishForMyUid(true /* validated */, false /* hasInternet */,
false /* privateDnsProbeSent */);
@@ -8685,38 +8654,36 @@
assertDefaultNetworkCapabilities(userId /* no networks */);
// Connect cell and use it as an underlying network.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
+ mCellAgent.connect(true);
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mCellAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR) && !caps.hasTransport(TRANSPORT_WIFI)
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mCellAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
+ mWiFiAgent.connect(true);
mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork(), mWiFiNetworkAgent.getNetwork() });
+ new Network[] { mCellAgent.getNetwork(), mWiFiAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR) && caps.hasTransport(TRANSPORT_WIFI)
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent, mWiFiNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mCellAgent, mWiFiAgent);
// Don't disconnect, but note the VPN is not using wifi any more.
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mCellAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
@@ -8725,86 +8692,84 @@
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
// The return value of getDefaultNetworkCapabilitiesForUser always includes the default
// network (wifi) as well as the underlying networks (cell).
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent, mWiFiNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mCellAgent, mWiFiAgent);
// Remove NOT_SUSPENDED from the only network and observe VPN is now suspended.
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_SUSPENDED);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_SUSPENDED);
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR) && !caps.hasTransport(TRANSPORT_WIFI)
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& !caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
- vpnNetworkCallback.expect(CallbackEntry.SUSPENDED, mMockVpn);
+ vpnNetworkCallback.expect(SUSPENDED, mMockVpn);
// Add NOT_SUSPENDED again and observe VPN is no longer suspended.
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR) && !caps.hasTransport(TRANSPORT_WIFI)
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
- vpnNetworkCallback.expect(CallbackEntry.RESUMED, mMockVpn);
+ vpnNetworkCallback.expect(RESUMED, mMockVpn);
// Use Wifi but not cell. Note the VPN is now unmetered and not suspended.
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mWiFiNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mWiFiAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& !caps.hasTransport(TRANSPORT_CELLULAR) && caps.hasTransport(TRANSPORT_WIFI)
&& caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
- assertDefaultNetworkCapabilities(userId, mWiFiNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mWiFiAgent);
// Use both again.
mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork(), mWiFiNetworkAgent.getNetwork() });
+ new Network[] { mCellAgent.getNetwork(), mWiFiAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR) && caps.hasTransport(TRANSPORT_WIFI)
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent, mWiFiNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mCellAgent, mWiFiAgent);
// Cell is suspended again. As WiFi is not, this should not cause a callback.
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_SUSPENDED);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_SUSPENDED);
vpnNetworkCallback.assertNoCallback();
// Stop using WiFi. The VPN is suspended again.
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mCellAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR)
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& !caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
- vpnNetworkCallback.expect(CallbackEntry.SUSPENDED, mMockVpn);
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent, mWiFiNetworkAgent);
+ vpnNetworkCallback.expect(SUSPENDED, mMockVpn);
+ assertDefaultNetworkCapabilities(userId, mCellAgent, mWiFiAgent);
// Use both again.
mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork(), mWiFiNetworkAgent.getNetwork() });
+ new Network[] { mCellAgent.getNetwork(), mWiFiAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR) && caps.hasTransport(TRANSPORT_WIFI)
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
- vpnNetworkCallback.expect(CallbackEntry.RESUMED, mMockVpn);
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent, mWiFiNetworkAgent);
+ vpnNetworkCallback.expect(RESUMED, mMockVpn);
+ assertDefaultNetworkCapabilities(userId, mCellAgent, mWiFiAgent);
// Disconnect cell. Receive update without even removing the dead network from the
// underlying networks – it's dead anyway. Not metered any more.
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& !caps.hasTransport(TRANSPORT_CELLULAR) && caps.hasTransport(TRANSPORT_WIFI)
&& caps.hasCapability(NET_CAPABILITY_NOT_METERED));
- assertDefaultNetworkCapabilities(userId, mWiFiNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mWiFiAgent);
// Disconnect wifi too. No underlying networks means this is now metered.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& !caps.hasTransport(TRANSPORT_CELLULAR) && !caps.hasTransport(TRANSPORT_WIFI)
@@ -8846,8 +8811,8 @@
assertVpnTransportInfo(nc, VpnManager.TYPE_VPN_SERVICE);
// Connect to Cell; Cell is the default network.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
@@ -8855,9 +8820,9 @@
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED));
// Connect to WiFi; WiFi is the new default.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
@@ -8866,10 +8831,10 @@
// Disconnect Cell. The default network did not change, so there shouldn't be any changes in
// the capabilities.
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
// Disconnect wifi too. Now we have no default network.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
@@ -8903,13 +8868,13 @@
assertVpnTransportInfo(nc, VpnManager.TYPE_VPN_SERVICE);
// Set an underlying network and expect to see the VPN transports change.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
callback.expectCapabilitiesThat(mMockVpn, (caps)
-> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_WIFI));
- callback.expectCapabilitiesThat(mWiFiNetworkAgent, (caps)
+ callback.expectCapabilitiesThat(mWiFiAgent, (caps)
-> caps.hasCapability(NET_CAPABILITY_VALIDATED));
doReturn(UserHandle.getUid(RESTRICTED_USER, VPN_UID)).when(mPackageManager)
@@ -8931,8 +8896,8 @@
&& caps.hasTransport(TRANSPORT_WIFI));
// Change the VPN's capabilities somehow (specifically, disconnect wifi).
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
callback.expectCapabilitiesThat(mMockVpn, (caps)
-> caps.getUids().size() == 2
&& caps.getUids().contains(singleUidRange)
@@ -8972,8 +8937,8 @@
final int uid = Process.myUid();
// Connect wifi and check that UIDs in the main and restricted profiles have network access.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true /* validated */);
final int restrictedUid = UserHandle.getUid(RESTRICTED_USER, 42 /* appId */);
assertNotNull(mCm.getActiveNetworkForUid(uid));
assertNotNull(mCm.getActiveNetworkForUid(restrictedUid));
@@ -9022,9 +8987,9 @@
public void testIsActiveNetworkMeteredOverWifi() throws Exception {
// Returns true by default when no network is available.
assertTrue(mCm.isActiveNetworkMetered());
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
waitForIdle();
assertFalse(mCm.isActiveNetworkMetered());
@@ -9034,9 +8999,9 @@
public void testIsActiveNetworkMeteredOverCell() throws Exception {
// Returns true by default when no network is available.
assertTrue(mCm.isActiveNetworkMetered());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
+ mCellAgent.connect(true);
waitForIdle();
assertTrue(mCm.isActiveNetworkMetered());
@@ -9046,9 +9011,9 @@
public void testIsActiveNetworkMeteredOverVpnTrackingPlatformDefault() throws Exception {
// Returns true by default when no network is available.
assertTrue(mCm.isActiveNetworkMetered());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
+ mCellAgent.connect(true);
waitForIdle();
assertTrue(mCm.isActiveNetworkMetered());
@@ -9063,9 +9028,9 @@
assertTrue(mCm.isActiveNetworkMetered());
// Connect WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
waitForIdle();
// VPN should still be the active network.
assertEquals(mMockVpn.getNetwork(), mCm.getActiveNetwork());
@@ -9074,13 +9039,13 @@
assertFalse(mCm.isActiveNetworkMetered());
// Disconnecting Cell should not affect VPN's meteredness.
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
waitForIdle();
assertFalse(mCm.isActiveNetworkMetered());
// Disconnect WiFi; Now there is no platform default network.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
waitForIdle();
// VPN without any underlying networks is treated as metered.
@@ -9093,15 +9058,15 @@
public void testIsActiveNetworkMeteredOverVpnSpecifyingUnderlyingNetworks() throws Exception {
// Returns true by default when no network is available.
assertTrue(mCm.isActiveNetworkMetered());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
+ mCellAgent.connect(true);
waitForIdle();
assertTrue(mCm.isActiveNetworkMetered());
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
waitForIdle();
assertFalse(mCm.isActiveNetworkMetered());
@@ -9112,16 +9077,14 @@
// Ensure VPN is now the active network.
assertEquals(mMockVpn.getNetwork(), mCm.getActiveNetwork());
// VPN is using Cell
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mCellAgent.getNetwork() });
waitForIdle();
// Expect VPN to be metered.
assertTrue(mCm.isActiveNetworkMetered());
// VPN is now using WiFi
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mWiFiNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mWiFiAgent.getNetwork() });
waitForIdle();
// Expect VPN to be unmetered
@@ -9129,7 +9092,7 @@
// VPN is using Cell | WiFi.
mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork(), mWiFiNetworkAgent.getNetwork() });
+ new Network[] { mCellAgent.getNetwork(), mWiFiAgent.getNetwork() });
waitForIdle();
// Expect VPN to be metered.
@@ -9137,7 +9100,7 @@
// VPN is using WiFi | Cell.
mMockVpn.setUnderlyingNetworks(
- new Network[] { mWiFiNetworkAgent.getNetwork(), mCellNetworkAgent.getNetwork() });
+ new Network[] { mWiFiAgent.getNetwork(), mCellAgent.getNetwork() });
waitForIdle();
// Order should not matter and VPN should still be metered.
@@ -9157,9 +9120,9 @@
public void testIsActiveNetworkMeteredOverAlwaysMeteredVpn() throws Exception {
// Returns true by default when no network is available.
assertTrue(mCm.isActiveNetworkMetered());
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
waitForIdle();
assertFalse(mCm.isActiveNetworkMetered());
@@ -9179,8 +9142,7 @@
// VPN explicitly declares WiFi as its underlying network.
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mWiFiNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mWiFiAgent.getNetwork() });
waitForIdle();
// Doesn't really matter whether VPN declares its underlying networks explicitly.
@@ -9188,7 +9150,7 @@
// With WiFi lost, VPN is basically without any underlying networks. And in that case it is
// anyways suppose to be metered.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
waitForIdle();
assertTrue(mCm.isActiveNetworkMetered());
@@ -9222,80 +9184,74 @@
mockUidNetworkingBlocked();
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- detailedCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent,
- BLOCKED_REASON_NONE);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ detailedCallback.expectAvailableThenValidatedCallbacks(mCellAgent, BLOCKED_REASON_NONE);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
setBlockedReasonChanged(BLOCKED_REASON_BATTERY_SAVER);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent,
- BLOCKED_REASON_BATTERY_SAVER);
+ cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_BATTERY_SAVER);
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
- assertExtraInfoFromCmBlocked(mCellNetworkAgent);
+ assertExtraInfoFromCmBlocked(mCellAgent);
// If blocked state does not change but blocked reason does, the boolean callback is called.
// TODO: investigate de-duplicating.
setBlockedReasonChanged(BLOCKED_METERED_REASON_USER_RESTRICTED);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent,
+ cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent,
BLOCKED_METERED_REASON_USER_RESTRICTED);
setBlockedReasonChanged(BLOCKED_REASON_NONE);
- cellNetworkCallback.expectBlockedStatusCallback(false, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent, BLOCKED_REASON_NONE);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ cellNetworkCallback.expectBlockedStatusCallback(false, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_NONE);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent,
- BLOCKED_METERED_REASON_DATA_SAVER);
+ cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_METERED_REASON_DATA_SAVER);
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
- assertExtraInfoFromCmBlocked(mCellNetworkAgent);
+ assertExtraInfoFromCmBlocked(mCellAgent);
// Restrict the network based on UID rule and NOT_METERED capability change.
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellNetworkAgent);
- cellNetworkCallback.expectBlockedStatusCallback(false, mCellNetworkAgent);
- detailedCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent, BLOCKED_REASON_NONE);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellAgent);
+ cellNetworkCallback.expectBlockedStatusCallback(false, mCellAgent);
+ detailedCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_NONE);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
- cellNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED,
- mCellNetworkAgent);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellNetworkAgent);
- detailedCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED,
- mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent,
- BLOCKED_METERED_REASON_DATA_SAVER);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
+ cellNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED, mCellAgent);
+ cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
+ detailedCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_METERED_REASON_DATA_SAVER);
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
- assertExtraInfoFromCmBlocked(mCellNetworkAgent);
+ assertExtraInfoFromCmBlocked(mCellAgent);
setBlockedReasonChanged(BLOCKED_REASON_NONE);
- cellNetworkCallback.expectBlockedStatusCallback(false, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent, BLOCKED_REASON_NONE);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ cellNetworkCallback.expectBlockedStatusCallback(false, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_NONE);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
setBlockedReasonChanged(BLOCKED_REASON_NONE);
cellNetworkCallback.assertNoCallback();
@@ -9303,30 +9259,29 @@
// Restrict background data. Networking is not blocked because the network is unmetered.
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent,
- BLOCKED_METERED_REASON_DATA_SAVER);
+ cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_METERED_REASON_DATA_SAVER);
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
- assertExtraInfoFromCmBlocked(mCellNetworkAgent);
+ assertExtraInfoFromCmBlocked(mCellAgent);
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
cellNetworkCallback.assertNoCallback();
setBlockedReasonChanged(BLOCKED_REASON_NONE);
- cellNetworkCallback.expectBlockedStatusCallback(false, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent, BLOCKED_REASON_NONE);
+ cellNetworkCallback.expectBlockedStatusCallback(false, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_NONE);
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
setBlockedReasonChanged(BLOCKED_REASON_NONE);
cellNetworkCallback.assertNoCallback();
detailedCallback.assertNoCallback();
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
mCm.unregisterNetworkCallback(cellNetworkCallback);
}
@@ -9343,34 +9298,34 @@
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
defaultCallback.assertNoCallback();
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
- defaultCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
+ defaultCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mCellAgent);
// Allow to use the network after switching to NOT_METERED network.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
// Switch to METERED network. Restrict the use of the network.
- mWiFiNetworkAgent.disconnect();
- defaultCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksValidatedAndBlocked(mCellNetworkAgent);
+ mWiFiAgent.disconnect();
+ defaultCallback.expect(LOST, mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksValidatedAndBlocked(mCellAgent);
// Network becomes NOT_METERED.
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- defaultCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellNetworkAgent);
- defaultCallback.expectBlockedStatusCallback(false, mCellNetworkAgent);
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ defaultCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellAgent);
+ defaultCallback.expectBlockedStatusCallback(false, mCellAgent);
// Verify there's no Networkcallbacks invoked after data saver on/off.
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
setBlockedReasonChanged(BLOCKED_REASON_NONE);
defaultCallback.assertNoCallback();
- mCellNetworkAgent.disconnect();
- defaultCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ defaultCallback.expect(LOST, mCellAgent);
defaultCallback.assertNoCallback();
mCm.unregisterNetworkCallback(defaultCallback);
@@ -9434,7 +9389,7 @@
// Expect exactly one blocked callback for each agent.
for (int i = 0; i < agents.length; i++) {
- final CallbackEntry e = callback.expect(CallbackEntry.BLOCKED_STATUS, TIMEOUT_MS,
+ final CallbackEntry e = callback.expect(BLOCKED_STATUS, TIMEOUT_MS,
c -> c.getBlocked() == blocked);
final Network network = e.getNetwork();
assertTrue("Received unexpected blocked callback for network " + network,
@@ -9487,14 +9442,14 @@
expectNetworkRejectNonSecureVpn(inOrder, true, uidRangeParcels);
// Connect a network when lockdown is active, expect to see it blocked.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false /* validated */);
- callback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiNetworkAgent);
- vpnUidCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- vpnUidDefaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- vpnDefaultCallbackAsUid.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false /* validated */);
+ callback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiAgent);
+ vpnUidCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ vpnUidDefaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ vpnDefaultCallbackAsUid.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.BLOCKED);
// Mobile is BLOCKED even though it's not actually connected.
@@ -9503,14 +9458,14 @@
// Disable lockdown, expect to see the network unblocked.
mMockVpn.setAlwaysOnPackage(null, false /* lockdown */, allowList);
- callback.expectBlockedStatusCallback(false, mWiFiNetworkAgent);
- defaultCallback.expectBlockedStatusCallback(false, mWiFiNetworkAgent);
+ callback.expectBlockedStatusCallback(false, mWiFiAgent);
+ defaultCallback.expectBlockedStatusCallback(false, mWiFiAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
expectNetworkRejectNonSecureVpn(inOrder, false, uidRangeParcels);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
@@ -9532,22 +9487,22 @@
final UidRangeParcel[] uidRangeParcelsAlsoExcludingUs = uidRangeParcelsExcludingUids(
excludedUids.toArray(new Integer[0]));
expectNetworkRejectNonSecureVpn(inOrder, true, uidRangeParcelsAlsoExcludingUs);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
// Connect a new network, expect it to be unblocked.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false /* validated */);
- callback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false /* validated */);
+ callback.expectAvailableCallbacksUnvalidated(mCellAgent);
defaultCallback.assertNoCallback();
- vpnUidCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ vpnUidCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
// Cellular is DISCONNECTED because it's not the default and there are no requests for it.
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
@@ -9562,12 +9517,12 @@
mMockVpn.setAlwaysOnPackage(ALWAYS_ON_PACKAGE, true /* lockdown */, allowList);
waitForIdle();
expectNetworkRejectNonSecureVpn(inOrder, true, uidRangeParcels);
- defaultCallback.expectBlockedStatusCallback(true, mWiFiNetworkAgent);
- assertBlockedCallbackInAnyOrder(callback, true, mWiFiNetworkAgent, mCellNetworkAgent);
+ defaultCallback.expectBlockedStatusCallback(true, mWiFiAgent);
+ assertBlockedCallbackInAnyOrder(callback, true, mWiFiAgent, mCellAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
@@ -9575,13 +9530,13 @@
// Disable lockdown. Everything is unblocked.
mMockVpn.setAlwaysOnPackage(null, false /* lockdown */, allowList);
- defaultCallback.expectBlockedStatusCallback(false, mWiFiNetworkAgent);
- assertBlockedCallbackInAnyOrder(callback, false, mWiFiNetworkAgent, mCellNetworkAgent);
+ defaultCallback.expectBlockedStatusCallback(false, mWiFiAgent);
+ assertBlockedCallbackInAnyOrder(callback, false, mWiFiAgent, mCellAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
@@ -9595,8 +9550,8 @@
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
@@ -9608,20 +9563,20 @@
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
// Enable lockdown and connect a VPN. The VPN is not blocked.
mMockVpn.setAlwaysOnPackage(ALWAYS_ON_PACKAGE, true /* lockdown */, allowList);
- defaultCallback.expectBlockedStatusCallback(true, mWiFiNetworkAgent);
- assertBlockedCallbackInAnyOrder(callback, true, mWiFiNetworkAgent, mCellNetworkAgent);
+ defaultCallback.expectBlockedStatusCallback(true, mWiFiAgent);
+ assertBlockedCallbackInAnyOrder(callback, true, mWiFiAgent, mCellAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
@@ -9634,15 +9589,15 @@
vpnUidDefaultCallback.assertNoCallback(); // VPN does not apply to VPN_UID
vpnDefaultCallbackAsUid.assertNoCallback();
assertEquals(mMockVpn.getNetwork(), mCm.getActiveNetwork());
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_VPN, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
mMockVpn.disconnect();
- defaultCallback.expect(CallbackEntry.LOST, mMockVpn);
- defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiNetworkAgent);
+ defaultCallback.expect(LOST, mMockVpn);
+ defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
@@ -9661,8 +9616,8 @@
mServiceContext.setPermission(NETWORK_SETTINGS, PERMISSION_GRANTED);
// Connect Wi-Fi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true /* validated */);
// Connect a VPN that excludes its UID from its UID ranges.
final LinkProperties lp = new LinkProperties();
@@ -9671,7 +9626,7 @@
final Set<UidRange> ranges = new ArraySet<>();
ranges.add(new UidRange(0, myUid - 1));
ranges.add(new UidRange(myUid + 1, UserHandle.PER_USER_RANGE - 1));
- mMockVpn.setUnderlyingNetworks(new Network[]{mWiFiNetworkAgent.getNetwork()});
+ mMockVpn.setUnderlyingNetworks(new Network[] { mWiFiAgent.getNetwork() });
mMockVpn.establish(lp, myUid, ranges);
// Wait for validation before registering callbacks.
@@ -9693,8 +9648,8 @@
perUidCb.expectAvailableCallbacksValidated(mMockVpn);
// getActiveNetwork is not affected by this bug.
assertEquals(mMockVpn.getNetwork(), mCm.getActiveNetworkForUid(myUid + 1));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(myUid));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(myUid));
doAsUid(otherUid, () -> mCm.unregisterNetworkCallback(otherUidCb));
mCm.unregisterNetworkCallback(defaultCb);
@@ -9777,11 +9732,11 @@
cellLp.setInterfaceName("rmnet0");
cellLp.addLinkAddress(new LinkAddress("2001:db8::1/64"));
cellLp.addRoute(new RouteInfo(new IpPrefix("::/0"), null, "rmnet0"));
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(false /* validated */);
- callback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
- systemDefaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(false /* validated */);
+ callback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
+ systemDefaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
waitForIdle();
assertNull(mMockVpn.getAgent());
@@ -9790,37 +9745,36 @@
// TODO: consider fixing this.
cellLp.addLinkAddress(new LinkAddress("192.0.2.2/25"));
cellLp.addRoute(new RouteInfo(new IpPrefix("0.0.0.0/0"), null, "rmnet0"));
- mCellNetworkAgent.sendLinkProperties(cellLp);
- callback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
- defaultCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
- systemDefaultCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED,
- mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ callback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
+ defaultCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
+ systemDefaultCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
waitForIdle();
assertNull(mMockVpn.getAgent());
// Disconnect, then try again with a network that supports IPv4 at connection time.
// Expect lockdown VPN to come up.
ExpectedBroadcast b1 = expectConnectivityAction(TYPE_MOBILE, DetailedState.DISCONNECTED);
- mCellNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- defaultCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- systemDefaultCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ callback.expect(LOST, mCellAgent);
+ defaultCallback.expect(LOST, mCellAgent);
+ systemDefaultCallback.expect(LOST, mCellAgent);
b1.expectBroadcast();
// When lockdown VPN is active, the NetworkInfo state in CONNECTIVITY_ACTION is overwritten
// with the state of the VPN network. So expect a CONNECTING broadcast.
b1 = expectConnectivityAction(TYPE_MOBILE, DetailedState.CONNECTING);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(false /* validated */);
- callback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
- systemDefaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(false /* validated */);
+ callback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
+ systemDefaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
b1.expectBroadcast();
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_WIFI, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_VPN, DetailedState.BLOCKED);
- assertExtraInfoFromCmBlocked(mCellNetworkAgent);
+ assertExtraInfoFromCmBlocked(mCellAgent);
// TODO: it would be nice if we could simply rely on the production code here, and have
// LockdownVpnTracker start the VPN, have the VPN code register its NetworkAgent with
@@ -9838,7 +9792,7 @@
mMockVpn.expectStartLegacyVpnRunner();
b1 = expectConnectivityAction(TYPE_VPN, DetailedState.CONNECTED);
ExpectedBroadcast b2 = expectConnectivityAction(TYPE_MOBILE, DetailedState.CONNECTED);
- establishLegacyLockdownVpn(mCellNetworkAgent.getNetwork());
+ establishLegacyLockdownVpn(mCellAgent.getNetwork());
callback.expectAvailableThenValidatedCallbacks(mMockVpn);
defaultCallback.expectAvailableThenValidatedCallbacks(mMockVpn);
systemDefaultCallback.assertNoCallback();
@@ -9849,7 +9803,7 @@
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_VPN, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
assertTrue(vpnNc.hasTransport(TRANSPORT_VPN));
assertTrue(vpnNc.hasTransport(TRANSPORT_CELLULAR));
assertFalse(vpnNc.hasTransport(TRANSPORT_WIFI));
@@ -9864,13 +9818,13 @@
final NetworkCapabilities wifiNc = new NetworkCapabilities();
wifiNc.addTransportType(TRANSPORT_WIFI);
wifiNc.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp, wifiNc);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp, wifiNc);
b1 = expectConnectivityAction(TYPE_MOBILE, DetailedState.DISCONNECTED);
// Wifi is CONNECTING because the VPN isn't up yet.
b2 = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTING);
ExpectedBroadcast b3 = expectConnectivityAction(TYPE_VPN, DetailedState.DISCONNECTED);
- mWiFiNetworkAgent.connect(false /* validated */);
+ mWiFiAgent.connect(false /* validated */);
b1.expectBroadcast();
b2.expectBroadcast();
b3.expectBroadcast();
@@ -9881,23 +9835,23 @@
// connected, so the network is not considered blocked by the lockdown UID ranges? But the
// fact that a VPN is connected should only result in the VPN itself being unblocked, not
// any other network. Bug in isUidBlockedByVpn?
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expect(CallbackEntry.LOST, mMockVpn);
- defaultCallback.expect(CallbackEntry.LOST, mMockVpn);
- defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiNetworkAgent);
- systemDefaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expect(LOST, mMockVpn);
+ defaultCallback.expect(LOST, mMockVpn);
+ defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiAgent);
+ systemDefaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// While the VPN is reconnecting on the new network, everything is blocked.
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_WIFI, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_VPN, DetailedState.BLOCKED);
- assertExtraInfoFromCmBlocked(mWiFiNetworkAgent);
+ assertExtraInfoFromCmBlocked(mWiFiAgent);
// The VPN comes up again on wifi.
b1 = expectConnectivityAction(TYPE_VPN, DetailedState.CONNECTED);
b2 = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTED);
- establishLegacyLockdownVpn(mWiFiNetworkAgent.getNetwork());
+ establishLegacyLockdownVpn(mWiFiAgent.getNetwork());
callback.expectAvailableThenValidatedCallbacks(mMockVpn);
defaultCallback.expectAvailableThenValidatedCallbacks(mMockVpn);
systemDefaultCallback.assertNoCallback();
@@ -9907,7 +9861,7 @@
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_VPN, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mWiFiNetworkAgent);
+ assertExtraInfoFromCmPresent(mWiFiAgent);
vpnNc = mCm.getNetworkCapabilities(mMockVpn.getNetwork());
assertTrue(vpnNc.hasTransport(TRANSPORT_VPN));
assertTrue(vpnNc.hasTransport(TRANSPORT_WIFI));
@@ -9915,8 +9869,8 @@
assertTrue(vpnNc.hasCapability(NET_CAPABILITY_NOT_METERED));
// Disconnect cell. Nothing much happens since it's not the default network.
- mCellNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ callback.expect(LOST, mCellAgent);
defaultCallback.assertNoCallback();
systemDefaultCallback.assertNoCallback();
@@ -9924,17 +9878,17 @@
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_VPN, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mWiFiNetworkAgent);
+ assertExtraInfoFromCmPresent(mWiFiAgent);
b1 = expectConnectivityAction(TYPE_WIFI, DetailedState.DISCONNECTED);
b2 = expectConnectivityAction(TYPE_VPN, DetailedState.DISCONNECTED);
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- systemDefaultCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ systemDefaultCallback.expect(LOST, mWiFiAgent);
b1.expectBroadcast();
callback.expectCapabilitiesThat(mMockVpn, nc -> !nc.hasTransport(TRANSPORT_WIFI));
mMockVpn.expectStopVpnRunnerPrivileged();
- callback.expect(CallbackEntry.LOST, mMockVpn);
+ callback.expect(LOST, mMockVpn);
b2.expectBroadcast();
VMSHandlerThread.quitSafely();
@@ -10081,32 +10035,32 @@
callbackWithoutCap);
// Setup networks with testing capability and verify the default network changes.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.addCapability(testCap);
- mCellNetworkAgent.connect(true);
- callbackWithCap.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- callbackWithoutCap.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- verify(mMockNetd).networkSetDefault(eq(mCellNetworkAgent.getNetwork().netId));
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.addCapability(testCap);
+ mCellAgent.connect(true);
+ callbackWithCap.expectAvailableThenValidatedCallbacks(mCellAgent);
+ callbackWithoutCap.expectAvailableThenValidatedCallbacks(mCellAgent);
+ verify(mMockNetd).networkSetDefault(eq(mCellAgent.getNetwork().netId));
reset(mMockNetd);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(testCap);
- mWiFiNetworkAgent.connect(true);
- callbackWithCap.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- callbackWithoutCap.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- verify(mMockNetd).networkSetDefault(eq(mWiFiNetworkAgent.getNetwork().netId));
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(testCap);
+ mWiFiAgent.connect(true);
+ callbackWithCap.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ callbackWithoutCap.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ verify(mMockNetd).networkSetDefault(eq(mWiFiAgent.getNetwork().netId));
reset(mMockNetd);
// Remove the testing capability on wifi, verify the callback and default network
// changes back to cellular.
- mWiFiNetworkAgent.removeCapability(testCap);
- callbackWithCap.expectAvailableCallbacksValidated(mCellNetworkAgent);
- callbackWithoutCap.expectCapabilitiesWithout(testCap, mWiFiNetworkAgent);
- verify(mMockNetd).networkSetDefault(eq(mCellNetworkAgent.getNetwork().netId));
+ mWiFiAgent.removeCapability(testCap);
+ callbackWithCap.expectAvailableCallbacksValidated(mCellAgent);
+ callbackWithoutCap.expectCapabilitiesWithout(testCap, mWiFiAgent);
+ verify(mMockNetd).networkSetDefault(eq(mCellAgent.getNetwork().netId));
reset(mMockNetd);
- mCellNetworkAgent.removeCapability(testCap);
- callbackWithCap.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.removeCapability(testCap);
+ callbackWithCap.expect(LOST, mCellAgent);
callbackWithoutCap.assertNoCallback();
verify(mMockNetd).networkClearDefault();
@@ -10119,8 +10073,8 @@
public final void testBatteryStatsNetworkType() throws Exception {
final LinkProperties cellLp = new LinkProperties();
cellLp.setInterfaceName("cell0");
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(true);
waitForIdle();
final ArrayTrackRecord<ReportedInterfaces>.ReadHead readHead =
mDeps.mReportedInterfaceHistory.newReadHead();
@@ -10130,24 +10084,24 @@
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName("wifi0");
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
waitForIdle();
assertNotNull(readHead.poll(TIMEOUT_MS, ri -> ri.contentEquals(mServiceContext,
wifiLp.getInterfaceName(),
new int[] { TRANSPORT_WIFI })));
- mCellNetworkAgent.disconnect();
- mWiFiNetworkAgent.disconnect();
+ mCellAgent.disconnect();
+ mWiFiAgent.disconnect();
cellLp.setInterfaceName("wifi0");
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(true);
waitForIdle();
assertNotNull(readHead.poll(TIMEOUT_MS, ri -> ri.contentEquals(mServiceContext,
cellLp.getInterfaceName(),
new int[] { TRANSPORT_CELLULAR })));
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
}
/**
@@ -10268,12 +10222,12 @@
cellLp.addLinkAddress(myIpv6);
cellLp.addRoute(ipv6Default);
cellLp.addRoute(ipv6Subnet);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
reset(mClatCoordinator);
// Connect with ipv6 link properties. Expect prefix discovery to be started.
- mCellNetworkAgent.connect(true);
- int cellNetId = mCellNetworkAgent.getNetwork().netId;
+ mCellAgent.connect(true);
+ int cellNetId = mCellAgent.getNetwork().netId;
waitForIdle();
verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(cellNetId,
@@ -10287,7 +10241,7 @@
cellLp.getInterfaceName(),
new int[] { TRANSPORT_CELLULAR })));
- networkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ networkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
verify(mMockDnsResolver, times(1)).startPrefix64Discovery(cellNetId);
// Switching default network updates TCP buffer sizes.
@@ -10295,8 +10249,8 @@
// Add an IPv4 address. Expect prefix discovery to be stopped. Netd doesn't tell us that
// the NAT64 prefix was removed because one was never discovered.
cellLp.addLinkAddress(myIpv4);
- mCellNetworkAgent.sendLinkProperties(cellLp);
- networkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
assertRoutesAdded(cellNetId, ipv4Subnet);
verify(mMockDnsResolver, times(1)).stopPrefix64Discovery(cellNetId);
verify(mMockDnsResolver, atLeastOnce()).setResolverConfiguration(any());
@@ -10318,37 +10272,37 @@
// Remove IPv4 address. Expect prefix discovery to be started again.
cellLp.removeLinkAddress(myIpv4);
- mCellNetworkAgent.sendLinkProperties(cellLp);
- networkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
verify(mMockDnsResolver, times(1)).startPrefix64Discovery(cellNetId);
assertRoutesRemoved(cellNetId, ipv4Subnet);
// When NAT64 prefix discovery succeeds, LinkProperties are updated and clatd is started.
- Nat464Xlat clat = getNat464Xlat(mCellNetworkAgent);
- assertNull(mCm.getLinkProperties(mCellNetworkAgent.getNetwork()).getNat64Prefix());
+ Nat464Xlat clat = getNat464Xlat(mCellAgent);
+ assertNull(mCm.getLinkProperties(mCellAgent.getNetwork()).getNat64Prefix());
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(
makeNat64PrefixEvent(cellNetId, PREFIX_OPERATION_ADDED, kNat64PrefixString, 96));
LinkProperties lpBeforeClat = networkCallback.expect(
- CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent).getLp();
+ LINK_PROPERTIES_CHANGED, mCellAgent).getLp();
assertEquals(0, lpBeforeClat.getStackedLinks().size());
assertEquals(kNat64Prefix, lpBeforeClat.getNat64Prefix());
verifyClatdStart(null /* inOrder */, MOBILE_IFNAME, cellNetId, kNat64Prefix.toString());
// Clat iface comes up. Expect stacked link to be added.
clat.interfaceLinkStateChanged(CLAT_MOBILE_IFNAME, true);
- networkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
- List<LinkProperties> stackedLps = mCm.getLinkProperties(mCellNetworkAgent.getNetwork())
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
+ List<LinkProperties> stackedLps = mCm.getLinkProperties(mCellAgent.getNetwork())
.getStackedLinks();
assertEquals(makeClatLinkProperties(myIpv4), stackedLps.get(0));
assertRoutesAdded(cellNetId, stackedDefault);
verify(mMockNetd, times(1)).networkAddInterface(cellNetId, CLAT_MOBILE_IFNAME);
// Change trivial linkproperties and see if stacked link is preserved.
cellLp.addDnsServer(InetAddress.getByName("8.8.8.8"));
- mCellNetworkAgent.sendLinkProperties(cellLp);
- networkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
List<LinkProperties> stackedLpsAfterChange =
- mCm.getLinkProperties(mCellNetworkAgent.getNetwork()).getStackedLinks();
+ mCm.getLinkProperties(mCellAgent.getNetwork()).getStackedLinks();
assertNotEquals(stackedLpsAfterChange, Collections.EMPTY_LIST);
assertEquals(makeClatLinkProperties(myIpv4), stackedLpsAfterChange.get(0));
@@ -10371,7 +10325,7 @@
// Expect clatd to be stopped and started with the new prefix.
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
cellNetId, PREFIX_OPERATION_ADDED, kOtherNat64PrefixString, 96));
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
(lp) -> lp.getStackedLinks().size() == 0);
verifyClatdStop(null /* inOrder */, MOBILE_IFNAME);
assertRoutesRemoved(cellNetId, stackedDefault);
@@ -10379,10 +10333,10 @@
verifyClatdStart(null /* inOrder */, MOBILE_IFNAME, cellNetId,
kOtherNat64Prefix.toString());
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
(lp) -> lp.getNat64Prefix().equals(kOtherNat64Prefix));
clat.interfaceLinkStateChanged(CLAT_MOBILE_IFNAME, true);
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
(lp) -> lp.getStackedLinks().size() == 1);
assertRoutesAdded(cellNetId, stackedDefault);
verify(mMockNetd, times(1)).networkAddInterface(cellNetId, CLAT_MOBILE_IFNAME);
@@ -10393,15 +10347,15 @@
// linkproperties are cleaned up.
cellLp.addLinkAddress(myIpv4);
cellLp.addRoute(ipv4Subnet);
- mCellNetworkAgent.sendLinkProperties(cellLp);
- networkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
assertRoutesAdded(cellNetId, ipv4Subnet);
verifyClatdStop(null /* inOrder */, MOBILE_IFNAME);
verify(mMockDnsResolver, times(1)).stopPrefix64Discovery(cellNetId);
// As soon as stop is called, the linkproperties lose the stacked interface.
- networkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
- LinkProperties actualLpAfterIpv4 = mCm.getLinkProperties(mCellNetworkAgent.getNetwork());
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
+ LinkProperties actualLpAfterIpv4 = mCm.getLinkProperties(mCellAgent.getNetwork());
LinkProperties expected = new LinkProperties(cellLp);
expected.setNat64Prefix(kOtherNat64Prefix);
assertEquals(expected, actualLpAfterIpv4);
@@ -10424,45 +10378,44 @@
// Stopping prefix discovery causes netd to tell us that the NAT64 prefix is gone.
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
cellNetId, PREFIX_OPERATION_REMOVED, kOtherNat64PrefixString, 96));
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
- (lp) -> lp.getNat64Prefix() == null);
+ networkCallback.expectLinkPropertiesThat(mCellAgent, lp -> lp.getNat64Prefix() == null);
// Remove IPv4 address and expect prefix discovery and clatd to be started again.
cellLp.removeLinkAddress(myIpv4);
cellLp.removeRoute(new RouteInfo(myIpv4, null, MOBILE_IFNAME));
cellLp.removeDnsServer(InetAddress.getByName("8.8.8.8"));
- mCellNetworkAgent.sendLinkProperties(cellLp);
- networkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
assertRoutesRemoved(cellNetId, ipv4Subnet); // Directly-connected routes auto-added.
verify(mMockDnsResolver, times(1)).startPrefix64Discovery(cellNetId);
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
cellNetId, PREFIX_OPERATION_ADDED, kNat64PrefixString, 96));
- networkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
verifyClatdStart(null /* inOrder */, MOBILE_IFNAME, cellNetId, kNat64Prefix.toString());
// Clat iface comes up. Expect stacked link to be added.
clat.interfaceLinkStateChanged(CLAT_MOBILE_IFNAME, true);
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
- (lp) -> lp.getStackedLinks().size() == 1 && lp.getNat64Prefix() != null);
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
+ lp -> lp.getStackedLinks().size() == 1 && lp.getNat64Prefix() != null);
assertRoutesAdded(cellNetId, stackedDefault);
verify(mMockNetd, times(1)).networkAddInterface(cellNetId, CLAT_MOBILE_IFNAME);
// NAT64 prefix is removed. Expect that clat is stopped.
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
cellNetId, PREFIX_OPERATION_REMOVED, kNat64PrefixString, 96));
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
- (lp) -> lp.getStackedLinks().size() == 0 && lp.getNat64Prefix() == null);
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
+ lp -> lp.getStackedLinks().size() == 0 && lp.getNat64Prefix() == null);
assertRoutesRemoved(cellNetId, ipv4Subnet, stackedDefault);
// Stop has no effect because clat is already stopped.
verifyClatdStop(null /* inOrder */, MOBILE_IFNAME);
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
- (lp) -> lp.getStackedLinks().size() == 0);
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
+ lp -> lp.getStackedLinks().size() == 0);
verify(mMockNetd, times(1)).networkRemoveInterface(cellNetId, CLAT_MOBILE_IFNAME);
verify(mMockNetd, times(1)).interfaceGetCfg(CLAT_MOBILE_IFNAME);
// Clean up.
- mCellNetworkAgent.disconnect();
- networkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ networkCallback.expect(LOST, mCellAgent);
networkCallback.assertNoCallback();
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_CELLULAR)));
@@ -10479,20 +10432,20 @@
doReturn(getClatInterfaceConfigParcel(myIpv4)).when(mMockNetd)
.interfaceGetCfg(CLAT_MOBILE_IFNAME);
cellLp.setNat64Prefix(kNat64Prefix);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(false /* validated */);
- networkCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- cellNetId = mCellNetworkAgent.getNetwork().netId;
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(false /* validated */);
+ networkCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ cellNetId = mCellAgent.getNetwork().netId;
verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(cellNetId,
INetd.PERMISSION_NONE));
assertRoutesAdded(cellNetId, ipv6Subnet, ipv6Default);
// Clatd is started and clat iface comes up. Expect stacked link to be added.
verifyClatdStart(null /* inOrder */, MOBILE_IFNAME, cellNetId, kNat64Prefix.toString());
- clat = getNat464Xlat(mCellNetworkAgent);
+ clat = getNat464Xlat(mCellAgent);
clat.interfaceLinkStateChanged(CLAT_MOBILE_IFNAME, true /* up */);
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
- (lp) -> lp.getStackedLinks().size() == 1
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
+ lp -> lp.getStackedLinks().size() == 1
&& lp.getNat64Prefix().equals(kNat64Prefix));
verify(mMockNetd).networkAddInterface(cellNetId, CLAT_MOBILE_IFNAME);
// assertRoutesAdded sees all calls since last mMockNetd reset, so expect IPv6 routes again.
@@ -10501,8 +10454,8 @@
reset(mClatCoordinator);
// Disconnect the network. clat is stopped and the network is destroyed.
- mCellNetworkAgent.disconnect();
- networkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ networkCallback.expect(LOST, mCellAgent);
networkCallback.assertNoCallback();
verifyClatdStop(null /* inOrder */, MOBILE_IFNAME);
verify(mMockNetd).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
@@ -10547,11 +10500,11 @@
// prefix discovery is never started.
LinkProperties lp = new LinkProperties(baseLp);
lp.setNat64Prefix(pref64FromRa);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
- mWiFiNetworkAgent.connect(false);
- final Network network = mWiFiNetworkAgent.getNetwork();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
+ mWiFiAgent.connect(false);
+ final Network network = mWiFiAgent.getNetwork();
int netId = network.getNetId();
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
verifyClatdStart(inOrder, iface, netId, pref64FromRa.toString());
inOrder.verify(mMockDnsResolver).setPrefix64(netId, pref64FromRa.toString());
inOrder.verify(mMockDnsResolver, never()).startPrefix64Discovery(netId);
@@ -10560,8 +10513,8 @@
// If the RA prefix is withdrawn, clatd is stopped and prefix discovery is started.
lp.setNat64Prefix(null);
- mWiFiNetworkAgent.sendLinkProperties(lp);
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, null);
+ mWiFiAgent.sendLinkProperties(lp);
+ expectNat64PrefixChange(callback, mWiFiAgent, null);
verifyClatdStop(inOrder, iface);
inOrder.verify(mMockDnsResolver).setPrefix64(netId, "");
inOrder.verify(mMockDnsResolver).startPrefix64Discovery(netId);
@@ -10569,8 +10522,8 @@
// If the RA prefix appears while DNS discovery is in progress, discovery is stopped and
// clatd is started with the prefix from the RA.
lp.setNat64Prefix(pref64FromRa);
- mWiFiNetworkAgent.sendLinkProperties(lp);
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, pref64FromRa);
+ mWiFiAgent.sendLinkProperties(lp);
+ expectNat64PrefixChange(callback, mWiFiAgent, pref64FromRa);
verifyClatdStart(inOrder, iface, netId, pref64FromRa.toString());
inOrder.verify(mMockDnsResolver).stopPrefix64Discovery(netId);
inOrder.verify(mMockDnsResolver).setPrefix64(netId, pref64FromRa.toString());
@@ -10578,21 +10531,21 @@
// Withdraw the RA prefix so we can test the case where an RA prefix appears after DNS
// discovery has succeeded.
lp.setNat64Prefix(null);
- mWiFiNetworkAgent.sendLinkProperties(lp);
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, null);
+ mWiFiAgent.sendLinkProperties(lp);
+ expectNat64PrefixChange(callback, mWiFiAgent, null);
verifyClatdStop(inOrder, iface);
inOrder.verify(mMockDnsResolver).setPrefix64(netId, "");
inOrder.verify(mMockDnsResolver).startPrefix64Discovery(netId);
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(
makeNat64PrefixEvent(netId, PREFIX_OPERATION_ADDED, pref64FromDnsStr, 96));
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, pref64FromDns);
+ expectNat64PrefixChange(callback, mWiFiAgent, pref64FromDns);
verifyClatdStart(inOrder, iface, netId, pref64FromDns.toString());
// If an RA advertises the same prefix that was discovered by DNS, nothing happens: prefix
// discovery is not stopped, and there are no callbacks.
lp.setNat64Prefix(pref64FromDns);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
callback.assertNoCallback();
verifyNeverClatdStop(inOrder, iface);
verifyNeverClatdStart(inOrder, iface);
@@ -10602,7 +10555,7 @@
// If the RA is later withdrawn, nothing happens again.
lp.setNat64Prefix(null);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
callback.assertNoCallback();
verifyNeverClatdStop(inOrder, iface);
verifyNeverClatdStart(inOrder, iface);
@@ -10612,8 +10565,8 @@
// If the RA prefix changes, clatd is restarted and prefix discovery is stopped.
lp.setNat64Prefix(pref64FromRa);
- mWiFiNetworkAgent.sendLinkProperties(lp);
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, pref64FromRa);
+ mWiFiAgent.sendLinkProperties(lp);
+ expectNat64PrefixChange(callback, mWiFiAgent, pref64FromRa);
verifyClatdStop(inOrder, iface);
inOrder.verify(mMockDnsResolver).stopPrefix64Discovery(netId);
@@ -10627,8 +10580,8 @@
// If the RA prefix changes, clatd is restarted and prefix discovery is not started.
lp.setNat64Prefix(newPref64FromRa);
- mWiFiNetworkAgent.sendLinkProperties(lp);
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, newPref64FromRa);
+ mWiFiAgent.sendLinkProperties(lp);
+ expectNat64PrefixChange(callback, mWiFiAgent, newPref64FromRa);
verifyClatdStop(inOrder, iface);
inOrder.verify(mMockDnsResolver).setPrefix64(netId, "");
verifyClatdStart(inOrder, iface, netId, newPref64FromRa.toString());
@@ -10638,7 +10591,7 @@
// If the RA prefix changes to the same value, nothing happens.
lp.setNat64Prefix(newPref64FromRa);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
callback.assertNoCallback();
assertEquals(newPref64FromRa, mCm.getLinkProperties(network).getNat64Prefix());
verifyNeverClatdStop(inOrder, iface);
@@ -10652,19 +10605,19 @@
// If the same prefix is learned first by DNS and then by RA, and clat is later stopped,
// (e.g., because the network disconnects) setPrefix64(netid, "") is never called.
lp.setNat64Prefix(null);
- mWiFiNetworkAgent.sendLinkProperties(lp);
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, null);
+ mWiFiAgent.sendLinkProperties(lp);
+ expectNat64PrefixChange(callback, mWiFiAgent, null);
verifyClatdStop(inOrder, iface);
inOrder.verify(mMockDnsResolver).setPrefix64(netId, "");
inOrder.verify(mMockDnsResolver).startPrefix64Discovery(netId);
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(
makeNat64PrefixEvent(netId, PREFIX_OPERATION_ADDED, pref64FromDnsStr, 96));
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, pref64FromDns);
+ expectNat64PrefixChange(callback, mWiFiAgent, pref64FromDns);
verifyClatdStart(inOrder, iface, netId, pref64FromDns.toString());
inOrder.verify(mMockDnsResolver, never()).setPrefix64(eq(netId), any());
lp.setNat64Prefix(pref64FromDns);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
callback.assertNoCallback();
verifyNeverClatdStop(inOrder, iface);
verifyNeverClatdStart(inOrder, iface);
@@ -10676,8 +10629,8 @@
// before CONNECTIVITY_ACTION is sent. Wait for CONNECTIVITY_ACTION before verifying that
// clat has been stopped, or the test will be flaky.
ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.DISCONNECTED);
- mWiFiNetworkAgent.disconnect();
- callback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
b.expectBroadcast();
verifyClatdStop(inOrder, iface);
@@ -10704,17 +10657,17 @@
cellLp.setInterfaceName(MOBILE_IFNAME);
cellLp.addLinkAddress(new LinkAddress("2001:db8:1::1/64"));
cellLp.addRoute(new RouteInfo(new IpPrefix("::/0"), null, MOBILE_IFNAME));
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.sendLinkProperties(cellLp);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- defaultCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- final int cellNetId = mCellNetworkAgent.getNetwork().netId;
+ mCellAgent.sendLinkProperties(cellLp);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ final int cellNetId = mCellAgent.getNetwork().netId;
waitForIdle();
verify(mMockDnsResolver, never()).startPrefix64Discovery(cellNetId);
- Nat464Xlat clat = getNat464Xlat(mCellNetworkAgent);
+ Nat464Xlat clat = getNat464Xlat(mCellAgent);
assertTrue("Nat464Xlat was not IDLE", !clat.isStarted());
// This cannot happen because prefix discovery cannot succeed if it is never started.
@@ -10734,25 +10687,25 @@
.build();
mCm.registerNetworkCallback(networkRequest, networkCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
final LinkProperties cellLp = new LinkProperties();
cellLp.setInterfaceName(MOBILE_IFNAME);
- mCellNetworkAgent.sendLinkProperties(cellLp);
- mCellNetworkAgent.connect(true);
- networkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ mCellAgent.connect(true);
+ networkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
verify(mMockNetd, times(1)).idletimerAddInterface(eq(MOBILE_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_CELLULAR)));
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent.sendLinkProperties(wifiLp);
+ mWiFiAgent.sendLinkProperties(wifiLp);
// Network switch
- mWiFiNetworkAgent.connect(true);
- networkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- networkCallback.expectLosing(mCellNetworkAgent);
- networkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mWiFiAgent.connect(true);
+ networkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ networkCallback.expectLosing(mCellAgent);
+ networkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
verify(mMockNetd, times(1)).idletimerAddInterface(eq(WIFI_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_WIFI)));
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
@@ -10760,8 +10713,8 @@
// Disconnect wifi and switch back to cell
reset(mMockNetd);
- mWiFiNetworkAgent.disconnect();
- networkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ networkCallback.expect(LOST, mWiFiAgent);
assertNoCallbacks(networkCallback);
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(WIFI_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_WIFI)));
@@ -10770,13 +10723,13 @@
// reconnect wifi
reset(mMockNetd);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent.sendLinkProperties(wifiLp);
- mWiFiNetworkAgent.connect(true);
- networkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- networkCallback.expectLosing(mCellNetworkAgent);
- networkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mWiFiAgent.sendLinkProperties(wifiLp);
+ mWiFiAgent.connect(true);
+ networkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ networkCallback.expectLosing(mCellAgent);
+ networkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
verify(mMockNetd, times(1)).idletimerAddInterface(eq(WIFI_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_WIFI)));
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
@@ -10784,21 +10737,20 @@
// Disconnect cell
reset(mMockNetd);
- mCellNetworkAgent.disconnect();
- networkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ networkCallback.expect(LOST, mCellAgent);
// LOST callback is triggered earlier than removing idle timer. Broadcast should also be
// sent as network being switched. Ensure rule removal for cell will not be triggered
// unexpectedly before network being removed.
waitForIdle();
verify(mMockNetd, times(0)).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_CELLULAR)));
- verify(mMockNetd, times(1)).networkDestroy(eq(mCellNetworkAgent.getNetwork().netId));
- verify(mMockDnsResolver, times(1))
- .destroyNetworkCache(eq(mCellNetworkAgent.getNetwork().netId));
+ verify(mMockNetd, times(1)).networkDestroy(eq(mCellAgent.getNetwork().netId));
+ verify(mMockDnsResolver, times(1)).destroyNetworkCache(eq(mCellAgent.getNetwork().netId));
// Disconnect wifi
ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.DISCONNECTED);
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
b.expectBroadcast();
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(WIFI_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_WIFI)));
@@ -10825,21 +10777,21 @@
final TestNetworkCallback networkCallback = new TestNetworkCallback();
mCm.registerNetworkCallback(networkRequest, networkCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
reset(mMockNetd);
// Switching default network updates TCP buffer sizes.
- mCellNetworkAgent.connect(false);
- networkCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ mCellAgent.connect(false);
+ networkCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
verifyTcpBufferSizeChange(ConnectivityService.DEFAULT_TCP_BUFFER_SIZES);
// Change link Properties should have updated tcp buffer size.
LinkProperties lp = new LinkProperties();
lp.setTcpBufferSizes(testTcpBufferSizes);
- mCellNetworkAgent.sendLinkProperties(lp);
- networkCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(lp);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
verifyTcpBufferSizeChange(testTcpBufferSizes);
// Clean up.
- mCellNetworkAgent.disconnect();
- networkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ networkCallback.expect(LOST, mCellAgent);
networkCallback.assertNoCallback();
mCm.unregisterNetworkCallback(networkCallback);
}
@@ -10847,8 +10799,8 @@
@Test
public void testGetGlobalProxyForNetwork() throws Exception {
final ProxyInfo testProxyInfo = ProxyInfo.buildDirectProxy("test", 8888);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- final Network wifiNetwork = mWiFiNetworkAgent.getNetwork();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ final Network wifiNetwork = mWiFiAgent.getNetwork();
mProxyTracker.setGlobalProxy(testProxyInfo);
assertEquals(testProxyInfo, mService.getProxyForNetwork(wifiNetwork));
}
@@ -10856,15 +10808,15 @@
@Test
public void testGetProxyForActiveNetwork() throws Exception {
final ProxyInfo testProxyInfo = ProxyInfo.buildDirectProxy("test", 8888);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
waitForIdle();
assertNull(mService.getProxyForNetwork(null));
final LinkProperties testLinkProperties = new LinkProperties();
testLinkProperties.setHttpProxy(testProxyInfo);
- mWiFiNetworkAgent.sendLinkProperties(testLinkProperties);
+ mWiFiAgent.sendLinkProperties(testLinkProperties);
waitForIdle();
assertEquals(testProxyInfo, mService.getProxyForNetwork(null));
@@ -10875,8 +10827,8 @@
final ProxyInfo testProxyInfo = ProxyInfo.buildDirectProxy("test", 8888);
// Set up a WiFi network with no proxy
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
waitForIdle();
assertNull(mService.getProxyForNetwork(null));
@@ -10889,7 +10841,7 @@
// Test that the VPN network returns a proxy, and the WiFi does not.
assertEquals(testProxyInfo, mService.getProxyForNetwork(mMockVpn.getNetwork()));
assertEquals(testProxyInfo, mService.getProxyForNetwork(null));
- assertNull(mService.getProxyForNetwork(mWiFiNetworkAgent.getNetwork()));
+ assertNull(mService.getProxyForNetwork(mWiFiAgent.getNetwork()));
// Test that the VPN network returns no proxy when it is set to null.
testLinkProperties.setHttpProxy(null);
@@ -10900,7 +10852,7 @@
// Set WiFi proxy and check that the vpn proxy is still null.
testLinkProperties.setHttpProxy(testProxyInfo);
- mWiFiNetworkAgent.sendLinkProperties(testLinkProperties);
+ mWiFiAgent.sendLinkProperties(testLinkProperties);
waitForIdle();
assertNull(mService.getProxyForNetwork(null));
@@ -10908,8 +10860,8 @@
// correct proxy setting.
mMockVpn.disconnect();
waitForIdle();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- assertEquals(testProxyInfo, mService.getProxyForNetwork(mWiFiNetworkAgent.getNetwork()));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(testProxyInfo, mService.getProxyForNetwork(mWiFiAgent.getNetwork()));
assertEquals(testProxyInfo, mService.getProxyForNetwork(null));
}
@@ -10930,7 +10882,6 @@
verify(mBpfNetMaps, times(2)).addUidInterfaceRules(eq("tun0"), uidCaptor.capture());
assertContainsExactly(uidCaptor.getAllValues().get(0), APP1_UID, APP2_UID);
assertContainsExactly(uidCaptor.getAllValues().get(1), APP1_UID, APP2_UID);
- assertTrue(mService.mPermissionMonitor.getVpnInterfaceUidRanges("tun0").equals(vpnRange));
mMockVpn.disconnect();
waitForIdle();
@@ -10938,7 +10889,6 @@
// Disconnected VPN should have interface rules removed
verify(mBpfNetMaps).removeUidInterfaceRules(uidCaptor.capture());
assertContainsExactly(uidCaptor.getValue(), APP1_UID, APP2_UID);
- assertNull(mService.mPermissionMonitor.getVpnInterfaceUidRanges("tun0"));
}
private void checkInterfaceFilteringRuleWithNullInterface(final LinkProperties lp,
@@ -10963,8 +10913,6 @@
assertContainsExactly(uidCaptor.getAllValues().get(0), APP1_UID, APP2_UID, VPN_UID);
assertContainsExactly(uidCaptor.getAllValues().get(1), APP1_UID, APP2_UID, VPN_UID);
}
- assertEquals(mService.mPermissionMonitor.getVpnInterfaceUidRanges(null /* iface */),
- vpnRange);
mMockVpn.disconnect();
waitForIdle();
@@ -10976,7 +10924,6 @@
} else {
assertContainsExactly(uidCaptor.getValue(), APP1_UID, APP2_UID, VPN_UID);
}
- assertNull(mService.mPermissionMonitor.getVpnInterfaceUidRanges(null /* iface */));
} else {
// Before T, rules are not configured for null interface.
verify(mBpfNetMaps, never()).addUidInterfaceRules(any(), any());
@@ -11088,15 +11035,15 @@
@Test
public void testLinkPropertiesWithWakeOnLanForActiveNetwork() throws Exception {
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_WOL_IFNAME);
wifiLp.setWakeOnLanSupported(false);
// Default network switch should update ifaces.
- mWiFiNetworkAgent.connect(false);
- mWiFiNetworkAgent.sendLinkProperties(wifiLp);
+ mWiFiAgent.connect(false);
+ mWiFiAgent.sendLinkProperties(wifiLp);
waitForIdle();
// ConnectivityService should have changed the WakeOnLanSupported to true
@@ -11488,18 +11435,17 @@
.addTransportType(TRANSPORT_WIFI).build();
mCm.registerNetworkCallback(wifiRequest, wifiNetworkCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(),
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(),
ncTemplate);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent.connect(false);
- wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Send network capabilities update with TransportInfo to trigger capabilities changed
// callback.
- mWiFiNetworkAgent.setNetworkCapabilities(
- ncTemplate.setTransportInfo(actualTransportInfo), true);
+ mWiFiAgent.setNetworkCapabilities(ncTemplate.setTransportInfo(actualTransportInfo), true);
- wifiNetworkCallback.expectCapabilitiesThat(mWiFiNetworkAgent,
+ wifiNetworkCallback.expectCapabilitiesThat(mWiFiAgent,
nc -> Objects.equals(expectedOwnerUid, nc.getOwnerUid())
&& Objects.equals(expectedTransportInfo, nc.getTransportInfo()));
}
@@ -11528,32 +11474,31 @@
.addTransportType(TRANSPORT_WIFI)
.setTransportInfo(new TestTransportInfo());
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(),
- ncTemplate);
- mWiFiNetworkAgent.connect(true /* validated; waits for callback */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(), ncTemplate);
+ mWiFiAgent.connect(true /* validated; waits for callback */);
// NETWORK_SETTINGS redaction is controlled by the NETWORK_SETTINGS permission
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).settingsRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).settingsRedacted);
withPermission(NETWORK_SETTINGS, () -> {
- assertFalse(getTestTransportInfo(mWiFiNetworkAgent).settingsRedacted);
+ assertFalse(getTestTransportInfo(mWiFiAgent).settingsRedacted);
});
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).settingsRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).settingsRedacted);
// LOCAL_MAC_ADDRESS redaction is controlled by the LOCAL_MAC_ADDRESS permission
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).localMacAddressRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).localMacAddressRedacted);
withPermission(LOCAL_MAC_ADDRESS, () -> {
- assertFalse(getTestTransportInfo(mWiFiNetworkAgent).localMacAddressRedacted);
+ assertFalse(getTestTransportInfo(mWiFiAgent).localMacAddressRedacted);
});
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).localMacAddressRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).localMacAddressRedacted);
// Synchronous getNetworkCapabilities calls never return unredacted location-sensitive
// information.
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).locationRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).locationRedacted);
setupLocationPermissions(Build.VERSION_CODES.S, true, AppOpsManager.OPSTR_FINE_LOCATION,
Manifest.permission.ACCESS_FINE_LOCATION);
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).locationRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).locationRedacted);
denyAllLocationPrivilegedPermissions();
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).locationRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).locationRedacted);
}
private void setupConnectionOwnerUid(int vpnOwnerUid, @VpnManager.VpnType int vpnType)
@@ -11978,9 +11923,9 @@
mCm.registerDefaultNetworkCallback(callback);
final LinkProperties linkProperties = new LinkProperties();
linkProperties.setInterfaceName(INTERFACE_NAME);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, linkProperties);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, linkProperties);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
callback.assertNoCallback();
final NetworkRequest request = new NetworkRequest.Builder().build();
@@ -12017,10 +11962,10 @@
final NetworkCapabilities ncTemplate = new NetworkCapabilities()
.addTransportType(TRANSPORT_CELLULAR)
.setTransportInfo(new TestTransportInfo());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, new LinkProperties(),
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, new LinkProperties(),
ncTemplate);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
callback.assertNoCallback();
// Make sure a report is sent and that the caps are suitably redacted.
@@ -12046,7 +11991,7 @@
// Trigger notifyDataStallSuspected() on the INetworkMonitorCallbacks instance in the
// cellular network agent
- mCellNetworkAgent.notifyDataStallSuspected();
+ mCellAgent.notifyDataStallSuspected();
// Verify onDataStallSuspected fired
verify(mConnectivityDiagnosticsCallback, timeout(TIMEOUT_MS)).onDataStallSuspected(
@@ -12057,7 +12002,7 @@
public void testConnectivityDiagnosticsCallbackOnConnectivityReported() throws Exception {
setUpConnectivityDiagnosticsCallback();
- final Network n = mCellNetworkAgent.getNetwork();
+ final Network n = mCellAgent.getNetwork();
final boolean hasConnectivity = true;
mService.reportNetworkConnectivity(n, hasConnectivity);
@@ -12090,7 +12035,7 @@
// report known Connectivity from a different uid. Verify that network is not re-validated
// and this callback is not notified.
- final Network n = mCellNetworkAgent.getNetwork();
+ final Network n = mCellAgent.getNetwork();
final boolean hasConnectivity = true;
doAsUid(Process.myUid() + 1, () -> mService.reportNetworkConnectivity(n, hasConnectivity));
@@ -12142,11 +12087,11 @@
final NetworkRequest request = new NetworkRequest.Builder().build();
final TestNetworkCallback networkCallback = new TestNetworkCallback();
mCm.registerNetworkCallback(request, networkCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
reset(mMockNetd);
- mCellNetworkAgent.connect(false);
- networkCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- final int netId = mCellNetworkAgent.getNetwork().netId;
+ mCellAgent.connect(false);
+ networkCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ final int netId = mCellAgent.getNetwork().netId;
final String iface = "rmnet_data0";
final InetAddress gateway = InetAddress.getByName("fe80::5678");
@@ -12163,8 +12108,8 @@
lp.addRoute(direct);
lp.addRoute(rio1);
lp.addRoute(defaultRoute);
- mCellNetworkAgent.sendLinkProperties(lp);
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent, x -> x.getRoutes().size() == 3);
+ mCellAgent.sendLinkProperties(lp);
+ networkCallback.expectLinkPropertiesThat(mCellAgent, x -> x.getRoutes().size() == 3);
assertRoutesAdded(netId, direct, rio1, defaultRoute);
reset(mMockNetd);
@@ -12178,9 +12123,8 @@
assertFalse(lp.getRoutes().contains(defaultRoute));
assertTrue(lp.getRoutes().contains(defaultWithMtu));
- mCellNetworkAgent.sendLinkProperties(lp);
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
- x -> x.getRoutes().contains(rio2));
+ mCellAgent.sendLinkProperties(lp);
+ networkCallback.expectLinkPropertiesThat(mCellAgent, x -> x.getRoutes().contains(rio2));
assertRoutesRemoved(netId, rio1);
assertRoutesAdded(netId, rio2);
@@ -12292,8 +12236,8 @@
@Test
public void testVpnUidRangesUpdate() throws Exception {
// Set up a WiFi network without proxy.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
assertNull(mService.getProxyForNetwork(null));
assertNull(mCm.getDefaultProxy());
@@ -12345,11 +12289,11 @@
b5.expectBroadcast();
// Proxy is added in WiFi(default network), setDefaultProxy will be called.
- final LinkProperties wifiLp = mCm.getLinkProperties(mWiFiNetworkAgent.getNetwork());
+ final LinkProperties wifiLp = mCm.getLinkProperties(mWiFiAgent.getNetwork());
assertNotNull(wifiLp);
final ExpectedBroadcast b6 = expectProxyChangeAction(testProxyInfo);
wifiLp.setHttpProxy(testProxyInfo);
- mWiFiNetworkAgent.sendLinkProperties(wifiLp);
+ mWiFiAgent.sendLinkProperties(wifiLp);
waitForIdle();
b6.expectBroadcast();
}
@@ -12357,8 +12301,8 @@
@Test
public void testProxyBroadcastWillBeSentWhenVpnHasProxyAndConnects() throws Exception {
// Set up a WiFi network without proxy.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
assertNull(mService.getProxyForNetwork(null));
assertNull(mCm.getDefaultProxy());
@@ -12392,22 +12336,22 @@
public void testProxyBroadcastWillBeSentWhenTheProxyOfNonDefaultNetworkHasChanged()
throws Exception {
// Set up a CELLULAR network without proxy.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
assertNull(mService.getProxyForNetwork(null));
assertNull(mCm.getDefaultProxy());
// CELLULAR network should be the default network.
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
// Set up a WiFi network without proxy.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
assertNull(mService.getProxyForNetwork(null));
assertNull(mCm.getDefaultProxy());
// WiFi network should be the default network.
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
// CELLULAR network is not the default network.
- assertNotEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertNotEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
// CELLULAR network is not the system default network, but it might be a per-app default
// network. The proxy broadcast should be sent once its proxy has changed.
@@ -12416,7 +12360,7 @@
final ProxyInfo testProxyInfo = ProxyInfo.buildDirectProxy("test", 8888);
final ExpectedBroadcast b = registerPacProxyBroadcast();
cellularLp.setHttpProxy(testProxyInfo);
- mCellNetworkAgent.sendLinkProperties(cellularLp);
+ mCellAgent.sendLinkProperties(cellularLp);
b.expectBroadcast();
}
@@ -12445,66 +12389,64 @@
.build();
mCm.registerNetworkCallback(allNetworksRequest, allNetworksCb);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true /* validated */);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true /* validated */);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- allNetworksCb.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ allNetworksCb.expectAvailableThenValidatedCallbacks(mCellAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true /* validated */);
- mDefaultNetworkCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ mDefaultNetworkCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
// While the default callback doesn't see the network before it's validated, the listen
// sees the network come up and validate later
- allNetworksCb.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- allNetworksCb.expectLosing(mCellNetworkAgent);
- allNetworksCb.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- allNetworksCb.expect(CallbackEntry.LOST, mCellNetworkAgent,
- TEST_LINGER_DELAY_MS * 2);
+ allNetworksCb.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ allNetworksCb.expectLosing(mCellAgent);
+ allNetworksCb.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ allNetworksCb.expect(LOST, mCellAgent, TEST_LINGER_DELAY_MS * 2);
// The cell network has disconnected (see LOST above) because it was outscored and
// had no requests (see setAlwaysOnNetworks(false) above)
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
final NetworkScore score = new NetworkScore.Builder().setLegacyInt(30).build();
- mCellNetworkAgent.setScore(score);
- mCellNetworkAgent.connect(false /* validated */);
+ mCellAgent.setScore(score);
+ mCellAgent.connect(false /* validated */);
// The cell network gets torn down right away.
- allNetworksCb.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- allNetworksCb.expect(CallbackEntry.LOST, mCellNetworkAgent,
- TEST_NASCENT_DELAY_MS * 2);
+ allNetworksCb.expectAvailableCallbacksUnvalidated(mCellAgent);
+ allNetworksCb.expect(LOST, mCellAgent, TEST_NASCENT_DELAY_MS * 2);
allNetworksCb.assertNoCallback();
// Now create a cell network with KEEP_CONNECTED_FOR_HANDOVER and make sure it's
// not disconnected immediately when outscored.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
final NetworkScore scoreKeepup = new NetworkScore.Builder().setLegacyInt(30)
.setKeepConnectedReason(KEEP_CONNECTED_FOR_HANDOVER).build();
- mCellNetworkAgent.setScore(scoreKeepup);
- mCellNetworkAgent.connect(true /* validated */);
+ mCellAgent.setScore(scoreKeepup);
+ mCellAgent.connect(true /* validated */);
- allNetworksCb.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ allNetworksCb.expectAvailableThenValidatedCallbacks(mCellAgent);
mDefaultNetworkCallback.assertNoCallback();
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
- allNetworksCb.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- mDefaultNetworkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ allNetworksCb.expect(LOST, mWiFiAgent);
+ mDefaultNetworkCallback.expect(LOST, mWiFiAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
// Reconnect a WiFi network and make sure the cell network is still not torn down.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true /* validated */);
- allNetworksCb.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- mDefaultNetworkCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ allNetworksCb.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ mDefaultNetworkCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
// Now remove the reason to keep connected and make sure the network lingers and is
// torn down.
- mCellNetworkAgent.setScore(new NetworkScore.Builder().setLegacyInt(30).build());
- allNetworksCb.expectLosing(mCellNetworkAgent, TEST_NASCENT_DELAY_MS * 2);
- allNetworksCb.expect(CallbackEntry.LOST, mCellNetworkAgent, TEST_LINGER_DELAY_MS * 2);
+ mCellAgent.setScore(new NetworkScore.Builder().setLegacyInt(30).build());
+ allNetworksCb.expectLosing(mCellAgent, TEST_NASCENT_DELAY_MS * 2);
+ allNetworksCb.expect(LOST, mCellAgent, TEST_LINGER_DELAY_MS * 2);
mDefaultNetworkCallback.assertNoCallback();
mCm.unregisterNetworkCallback(allNetworksCb);
@@ -12522,21 +12464,21 @@
mFilter = mock(QosFilter.class);
// Ensure the network is disconnected before anything else occurs
- assertNull(mCellNetworkAgent);
+ assertNull(mCellAgent);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
verifyActiveNetwork(TRANSPORT_CELLULAR);
waitForIdle();
- final Network network = mCellNetworkAgent.getNetwork();
+ final Network network = mCellAgent.getNetwork();
final Pair<IQosCallback, IBinder> pair = createQosCallback();
mCallback = pair.first;
doReturn(network).when(mFilter).getNetwork();
doReturn(QosCallbackException.EX_TYPE_FILTER_NONE).when(mFilter).validate();
- mAgentWrapper = mCellNetworkAgent;
+ mAgentWrapper = mCellAgent;
}
void registerQosCallback(@NonNull final QosFilter filter,
@@ -13126,12 +13068,12 @@
// Corresponds to a metered cellular network. Will be used for the default network.
case TRANSPORT_CELLULAR:
if (!connectAgent) {
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
break;
}
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
+ mCellAgent.connect(true);
break;
// Corresponds to a restricted ethernet network with OEM_PAID/OEM_PRIVATE.
case TRANSPORT_ETHERNET:
@@ -13144,12 +13086,12 @@
// Corresponds to unmetered Wi-Fi.
case TRANSPORT_WIFI:
if (!connectAgent) {
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
break;
}
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
break;
default:
throw new AssertionError("Unsupported transport type passed in.");
@@ -13159,15 +13101,15 @@
}
private void startOemManagedNetwork(final boolean isOemPaid) throws Exception {
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mEthernetNetworkAgent.addCapability(
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mEthernetAgent.addCapability(
isOemPaid ? NET_CAPABILITY_OEM_PAID : NET_CAPABILITY_OEM_PRIVATE);
- mEthernetNetworkAgent.removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
- mEthernetNetworkAgent.connect(true);
+ mEthernetAgent.removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
+ mEthernetAgent.connect(true);
}
private void stopOemManagedNetwork() {
- mEthernetNetworkAgent.disconnect();
+ mEthernetAgent.disconnect();
waitForIdle();
}
@@ -13400,7 +13342,7 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
// Verify that the active network is correct
verifyActiveNetwork(TRANSPORT_ETHERNET);
@@ -13421,16 +13363,16 @@
assertTrue(mCm.isActiveNetworkMetered());
// Connect to an unmetered restricted network that will only be available to the OEM pref.
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mEthernetNetworkAgent.addCapability(NET_CAPABILITY_OEM_PAID);
- mEthernetNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mEthernetNetworkAgent.removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
- mEthernetNetworkAgent.connect(true);
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mEthernetAgent.addCapability(NET_CAPABILITY_OEM_PAID);
+ mEthernetAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mEthernetAgent.removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
+ mEthernetAgent.connect(true);
waitForIdle();
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
assertFalse(mCm.isActiveNetworkMetered());
// default NCs will be unregistered in tearDown
@@ -13461,19 +13403,18 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
// At this point with a restricted network used, the available callback should trigger.
- defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mEthernetNetworkAgent);
- assertEquals(defaultNetworkCallback.getLastAvailableNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mEthernetAgent);
+ assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mEthernetAgent.getNetwork());
otherUidDefaultCallback.assertNoCallback();
// Now bring down the default network which should trigger a LOST callback.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, false);
// At this point, with no network is available, the lost callback should trigger
- defaultNetworkCallback.expect(CallbackEntry.LOST, mEthernetNetworkAgent);
+ defaultNetworkCallback.expect(LOST, mEthernetAgent);
otherUidDefaultCallback.assertNoCallback();
// Confirm we can unregister without issues.
@@ -13506,12 +13447,11 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
// At this point with a restricted network used, the available callback should trigger
- defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mEthernetNetworkAgent);
- assertEquals(defaultNetworkCallback.getLastAvailableNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mEthernetAgent);
+ assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mEthernetAgent.getNetwork());
otherUidDefaultCallback.assertNoCallback();
// Now bring down the default network which should trigger a LOST callback.
@@ -13519,7 +13459,7 @@
otherUidDefaultCallback.assertNoCallback();
// At this point, with no network is available, the lost callback should trigger
- defaultNetworkCallback.expect(CallbackEntry.LOST, mEthernetNetworkAgent);
+ defaultNetworkCallback.expect(LOST, mEthernetAgent);
otherUidDefaultCallback.assertNoCallback();
// Confirm we can unregister without issues.
@@ -13552,27 +13492,26 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
// As this callback does not have access to the OEM_PAID network, it will not fire.
defaultNetworkCallback.assertNoCallback();
assertDefaultNetworkCapabilities(userId /* no networks */);
// The other UID does have access, and gets a callback.
- otherUidDefaultCallback.expectAvailableThenValidatedCallbacks(mEthernetNetworkAgent);
+ otherUidDefaultCallback.expectAvailableThenValidatedCallbacks(mEthernetAgent);
// Bring up unrestricted cellular. This should now satisfy the default network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// At this point with an unrestricted network used, the available callback should trigger
// The other UID is unaffected and remains on the paid network.
- defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertEquals(defaultNetworkCallback.getLastAvailableNetwork(),
- mCellNetworkAgent.getNetwork());
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent);
+ defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mCellAgent.getNetwork());
+ assertDefaultNetworkCapabilities(userId, mCellAgent);
otherUidDefaultCallback.assertNoCallback();
// Now bring down the per-app network.
@@ -13581,13 +13520,13 @@
// Since the callback didn't use the per-app network, only the other UID gets a callback.
// Because the preference specifies no fallback, it does not switch to cellular.
defaultNetworkCallback.assertNoCallback();
- otherUidDefaultCallback.expect(CallbackEntry.LOST, mEthernetNetworkAgent);
+ otherUidDefaultCallback.expect(LOST, mEthernetAgent);
// Now bring down the default network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, false);
// As this callback was tracking the default, this should now trigger.
- defaultNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ defaultNetworkCallback.expect(LOST, mCellAgent);
otherUidDefaultCallback.assertNoCallback();
// Confirm we can unregister without issues.
@@ -13740,22 +13679,22 @@
// Bring up metered cellular. This will satisfy the fallback network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
OEM_PREF_ANY_NET_ID, 0 /* times */,
false /* shouldDestroyNetwork */);
// Bring up ethernet with OEM_PAID. This will satisfy NET_CAPABILITY_OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
// Bring up unmetered Wi-Fi. This will satisfy NET_CAPABILITY_NOT_METERED.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mWiFiNetworkAgent.getNetwork().netId, 1 /* times */,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
+ mWiFiAgent.getNetwork().netId, 1 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
// Disconnecting OEM_PAID should have no effect as it is lower in priority then unmetered.
@@ -13769,15 +13708,15 @@
// Disconnecting unmetered should put PANS on lowest priority fallback request.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
- mWiFiNetworkAgent.getNetwork().netId, 0 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
+ mWiFiAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
// Disconnecting the fallback network should result in no connectivity.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
OEM_PREF_ANY_NET_ID, 0 /* times */,
- mCellNetworkAgent.getNetwork().netId, 0 /* times */,
+ mCellAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
}
@@ -13815,22 +13754,22 @@
// Bring up ethernet with OEM_PAID. This will satisfy NET_CAPABILITY_OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
mService.mNoServiceNetwork.network.getNetId(), 1 /* times */,
false /* shouldDestroyNetwork */);
// Bring up unmetered Wi-Fi. This will satisfy NET_CAPABILITY_NOT_METERED.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mWiFiNetworkAgent.getNetwork().netId, 1 /* times */,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
+ mWiFiAgent.getNetwork().netId, 1 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
// Disconnecting unmetered should put PANS on OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
- mWiFiNetworkAgent.getNetwork().netId, 0 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
+ mWiFiAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
// Disconnecting OEM_PAID should result in no connectivity.
@@ -13838,7 +13777,7 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
mService.mNoServiceNetwork.network.getNetId(), 1 /* times */,
- mEthernetNetworkAgent.getNetwork().netId, 0 /* times */,
+ mEthernetAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
}
@@ -13882,7 +13821,7 @@
// Bring up ethernet with OEM_PAID. This will satisfy NET_CAPABILITY_OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
mService.mNoServiceNetwork.network.getNetId(), 1 /* times */,
false /* shouldDestroyNetwork */);
@@ -13890,7 +13829,7 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
mService.mNoServiceNetwork.network.getNetId(), 1 /* times */,
- mEthernetNetworkAgent.getNetwork().netId, 0 /* times */,
+ mEthernetAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
}
@@ -13934,7 +13873,7 @@
// Bring up ethernet with OEM_PRIVATE. This will satisfy NET_CAPABILITY_OEM_PRIVATE.
startOemManagedNetwork(false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
mService.mNoServiceNetwork.network.getNetId(), 1 /* times */,
false /* shouldDestroyNetwork */);
@@ -13942,7 +13881,7 @@
stopOemManagedNetwork();
verifySetOemNetworkPreferenceForPreference(uidRanges,
mService.mNoServiceNetwork.network.getNetId(), 1 /* times */,
- mEthernetNetworkAgent.getNetwork().netId, 0 /* times */,
+ mEthernetAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
}
@@ -13975,7 +13914,7 @@
// Test that we correctly add the expected values for multiple users.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
OEM_PREF_ANY_NET_ID, 0 /* times */,
false /* shouldDestroyNetwork */);
@@ -13983,7 +13922,7 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
OEM_PREF_ANY_NET_ID, 0 /* times */,
- mCellNetworkAgent.getNetwork().netId, 0 /* times */,
+ mCellAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
}
@@ -14018,7 +13957,7 @@
// Test that we correctly add the expected values for multiple users.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifySetOemNetworkPreferenceForPreference(uidRangesSingleUser,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
OEM_PREF_ANY_NET_ID, 0 /* times */,
false /* shouldDestroyNetwork */);
@@ -14031,8 +13970,8 @@
// Test that we correctly add values for all users and remove for the single user.
verifySetOemNetworkPreferenceForPreference(uidRangesBothUsers, uidRangesSingleUser,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
// Send a broadcast indicating a user was removed.
@@ -14043,8 +13982,8 @@
// Test that we correctly add values for the single user and remove for the all users.
verifySetOemNetworkPreferenceForPreference(uidRangesSingleUser, uidRangesBothUsers,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
}
@@ -14074,7 +14013,7 @@
// Test that we correctly add the expected values for installed packages.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifySetOemNetworkPreferenceForPreference(uidRangesSinglePackage,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
OEM_PREF_ANY_NET_ID, 0 /* times */,
false /* shouldDestroyNetwork */);
@@ -14090,8 +14029,8 @@
// Test the single package is removed and the combined packages are added.
verifySetOemNetworkPreferenceForPreference(uidRangesAllPackages, uidRangesSinglePackage,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
// Set the system to no longer recognize the package to be installed
@@ -14104,8 +14043,8 @@
// Test the combined packages are removed and the single package is added.
verifySetOemNetworkPreferenceForPreference(uidRangesSinglePackage, uidRangesAllPackages,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
// Set the system to change the installed package's uid
@@ -14121,8 +14060,8 @@
// Test the original uid is removed and is replaced with the new uid.
verifySetOemNetworkPreferenceForPreference(uidRangesReplacedPackage, uidRangesSinglePackage,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
}
@@ -14147,32 +14086,32 @@
// Bring up metered cellular. This will satisfy the fallback network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mCellNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mCellAgent.getNetwork());
// Bring up ethernet with OEM_PAID. This will satisfy NET_CAPABILITY_OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Bring up unmetered Wi-Fi. This will satisfy NET_CAPABILITY_NOT_METERED.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mWiFiNetworkAgent.getNetwork(),
- mWiFiNetworkAgent.getNetwork());
+ mWiFiAgent.getNetwork(),
+ mWiFiAgent.getNetwork());
// Disconnecting unmetered Wi-Fi will put the pref on OEM_PAID and fallback on cellular.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Disconnecting cellular should keep OEM network on OEM_PAID and fallback will be null.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
// Disconnecting OEM_PAID will put both on null as it is the last network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, false);
@@ -14220,8 +14159,8 @@
oemPaidFactory.register();
oemPaidFactory.expectRequestAdd(); // Because nobody satisfies the request
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
// A network connected that satisfies the default internet request. For the OEM_PAID
// preference, this is not as good as an OEM_PAID network, so even if the score of
@@ -14256,7 +14195,7 @@
expectNoRequestChanged(internetFactory);
internetFactory.assertRequestCountEquals(0);
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
// The network satisfying the default internet request has disconnected, so the
// internetFactory sees the default request again. However there is a network with OEM_PAID
// connected, so the 2nd OEM_PAID req is already satisfied, so the oemPaidFactory doesn't
@@ -14267,8 +14206,8 @@
internetFactory.assertRequestCountEquals(1);
// Cell connects again, still with score 50. Back to the previous state.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
expectNoRequestChanged(oemPaidFactory);
oemPaidFactory.assertRequestCountEquals(1);
internetFactory.expectRequestRemove();
@@ -14280,18 +14219,18 @@
wifiCallback);
// Now WiFi connects and it's unmetered, but it's weaker than cell.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.setScore(new NetworkScore.Builder().setLegacyInt(30).setExiting(true)
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.setScore(new NetworkScore.Builder().setLegacyInt(30).setExiting(true)
.build()); // Not the best Internet network, but unmetered
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
// The OEM_PAID preference prefers an unmetered network to an OEM_PAID network, so
// the oemPaidFactory can't beat wifi no matter how high its score.
oemPaidFactory.expectRequestRemove();
expectNoRequestChanged(internetFactory);
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
// Now that the best internet network (cell, with its 50 score compared to 30 for WiFi
// at this point), the default internet request is satisfied by a network worse than
// the internetFactory announced, so it gets the request. However, there is still an
@@ -14322,32 +14261,32 @@
// Bring up metered cellular. This will satisfy the fallback network but not the pref.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
+ mCellAgent.getNetwork(),
mService.mNoServiceNetwork.network());
// Bring up ethernet with OEM_PAID. This will satisfy NET_CAPABILITY_OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Bring up unmetered Wi-Fi. This will satisfy NET_CAPABILITY_NOT_METERED.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mWiFiNetworkAgent.getNetwork(),
- mWiFiNetworkAgent.getNetwork());
+ mWiFiAgent.getNetwork(),
+ mWiFiAgent.getNetwork());
// Disconnecting unmetered Wi-Fi will put the OEM pref on OEM_PAID and fallback on cellular.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Disconnecting cellular should keep OEM network on OEM_PAID and fallback will be null.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
// Disconnecting OEM_PAID puts the fallback on null and the pref on the disconnected net.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, false);
@@ -14380,32 +14319,32 @@
// Bring up metered cellular. This will satisfy the fallback network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
+ mCellAgent.getNetwork(),
mService.mNoServiceNetwork.network());
// Bring up ethernet with OEM_PAID. This will satisfy NET_CAPABILITY_OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Bring up unmetered Wi-Fi. The OEM network shouldn't change, the fallback will take Wi-Fi.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mWiFiNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mWiFiAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Disconnecting unmetered Wi-Fi shouldn't change the OEM network with fallback on cellular.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Disconnecting OEM_PAID will keep the fallback on cellular and nothing for OEM_PAID.
// OEM_PAID_ONLY not supporting a fallback now uses the disconnected network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
+ mCellAgent.getNetwork(),
mService.mNoServiceNetwork.network());
// Disconnecting cellular will put the fallback on null and the pref on disconnected.
@@ -14439,32 +14378,32 @@
// Bring up metered cellular. This will satisfy the fallback network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
+ mCellAgent.getNetwork(),
mService.mNoServiceNetwork.network());
// Bring up ethernet with OEM_PRIVATE. This will satisfy NET_CAPABILITY_OEM_PRIVATE.
startOemManagedNetwork(false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Bring up unmetered Wi-Fi. The OEM network shouldn't change, the fallback will take Wi-Fi.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mWiFiNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mWiFiAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Disconnecting unmetered Wi-Fi shouldn't change the OEM network with fallback on cellular.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Disconnecting OEM_PRIVATE will keep the fallback on cellular.
// OEM_PRIVATE_ONLY not supporting a fallback now uses to the disconnected network.
stopOemManagedNetwork();
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
+ mCellAgent.getNetwork(),
mService.mNoServiceNetwork.network());
// Disconnecting cellular will put the fallback on null and pref on disconnected.
@@ -14485,13 +14424,13 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
- mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
- mSystemDefaultNetworkCallback.expectCapabilitiesThat(mCellNetworkAgent, nc ->
+ mCellAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
+ mSystemDefaultNetworkCallback.expectCapabilitiesThat(mCellAgent, nc ->
nc.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED));
- mDefaultNetworkCallback.expectCapabilitiesThat(mCellNetworkAgent, nc ->
+ mDefaultNetworkCallback.expectCapabilitiesThat(mCellAgent, nc ->
nc.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED));
// default callbacks will be unregistered in tearDown
@@ -14546,29 +14485,29 @@
final TestNetworkCallback cellCb = new TestNetworkCallback();
mCm.requestNetwork(new NetworkRequest.Builder().addCapability(NET_CAPABILITY_MMS).build(),
cellCb);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp, cellNcTemplate);
- mCellNetworkAgent.connect(true);
- cellCb.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp, cellNcTemplate);
+ mCellAgent.connect(true);
+ cellCb.expectAvailableCallbacksUnvalidated(mCellAgent);
List<NetworkStateSnapshot> snapshots = mCm.getAllNetworkStateSnapshots();
assertLength(1, snapshots);
// Compose the expected cellular snapshot for verification.
final NetworkCapabilities cellNc =
- mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork());
+ mCm.getNetworkCapabilities(mCellAgent.getNetwork());
final NetworkStateSnapshot cellSnapshot = new NetworkStateSnapshot(
- mCellNetworkAgent.getNetwork(), cellNc, cellLp,
+ mCellAgent.getNetwork(), cellNc, cellLp,
null, ConnectivityManager.TYPE_MOBILE);
assertEquals(cellSnapshot, snapshots.get(0));
// Connect wifi and verify the snapshots.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
waitForIdle();
// Compose the expected wifi snapshot for verification.
final NetworkCapabilities wifiNc =
- mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork());
+ mCm.getNetworkCapabilities(mWiFiAgent.getNetwork());
final NetworkStateSnapshot wifiSnapshot = new NetworkStateSnapshot(
- mWiFiNetworkAgent.getNetwork(), wifiNc, new LinkProperties(), null,
+ mWiFiAgent.getNetwork(), wifiNc, new LinkProperties(), null,
ConnectivityManager.TYPE_WIFI);
snapshots = mCm.getAllNetworkStateSnapshots();
@@ -14576,33 +14515,33 @@
assertContainsAll(snapshots, cellSnapshot, wifiSnapshot);
// Set cellular as suspended, verify the snapshots will contain suspended networks.
- mCellNetworkAgent.suspend();
+ mCellAgent.suspend();
waitForIdle();
final NetworkCapabilities cellSuspendedNc =
- mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork());
+ mCm.getNetworkCapabilities(mCellAgent.getNetwork());
assertFalse(cellSuspendedNc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
final NetworkStateSnapshot cellSuspendedSnapshot = new NetworkStateSnapshot(
- mCellNetworkAgent.getNetwork(), cellSuspendedNc, cellLp,
+ mCellAgent.getNetwork(), cellSuspendedNc, cellLp,
null, ConnectivityManager.TYPE_MOBILE);
snapshots = mCm.getAllNetworkStateSnapshots();
assertLength(2, snapshots);
assertContainsAll(snapshots, cellSuspendedSnapshot, wifiSnapshot);
// Disconnect wifi, verify the snapshots contain only cellular.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
waitForIdle();
snapshots = mCm.getAllNetworkStateSnapshots();
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertLength(1, snapshots);
assertEquals(cellSuspendedSnapshot, snapshots.get(0));
- mCellNetworkAgent.resume();
+ mCellAgent.resume();
waitForIdle();
snapshots = mCm.getAllNetworkStateSnapshots();
assertLength(1, snapshots);
assertEquals(cellSnapshot, snapshots.get(0));
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
waitForIdle();
verifyNoNetwork();
mCm.unregisterNetworkCallback(cellCb);
@@ -14673,35 +14612,35 @@
new NetworkRequest.Builder().addCapability(NET_CAPABILITY_TRUSTED).build(),
bestMatchingCb, mCsHandlerThread.getThreadHandler());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- bestMatchingCb.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ bestMatchingCb.expectAvailableThenValidatedCallbacks(mCellAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- bestMatchingCb.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ bestMatchingCb.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
// Change something on cellular to trigger capabilities changed, since the callback
// only cares about the best network, verify it received nothing from cellular.
- mCellNetworkAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
+ mCellAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
bestMatchingCb.assertNoCallback();
// Make cellular the best network again, verify the callback now tracks cellular.
- mWiFiNetworkAgent.adjustScore(-50);
- bestMatchingCb.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mWiFiAgent.adjustScore(-50);
+ bestMatchingCb.expectAvailableCallbacksValidated(mCellAgent);
// Make cellular temporary non-trusted, which will not satisfying the request.
// Verify the callback switch from/to the other network accordingly.
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_TRUSTED);
- bestMatchingCb.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_TRUSTED);
- bestMatchingCb.expectAvailableDoubleValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent.removeCapability(NET_CAPABILITY_TRUSTED);
+ bestMatchingCb.expectAvailableCallbacksValidated(mWiFiAgent);
+ mCellAgent.addCapability(NET_CAPABILITY_TRUSTED);
+ bestMatchingCb.expectAvailableDoubleValidatedCallbacks(mCellAgent);
// Verify the callback doesn't care about wifi disconnect.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
bestMatchingCb.assertNoCallback();
- mCellNetworkAgent.disconnect();
- bestMatchingCb.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ bestMatchingCb.expect(LOST, mCellAgent);
}
private UidRangeParcel[] uidRangeFor(final UserHandle handle) {
@@ -14798,18 +14737,17 @@
TestNetworkCallback disAllowProfileDefaultNetworkCallback) throws Exception {
final InOrder inOrder = inOrder(mMockNetd);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
- mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- profileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ profileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
if (disAllowProfileDefaultNetworkCallback != null) {
- disAllowProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(
- mCellNetworkAgent);
+ disAllowProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
}
inOrder.verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
final TestNetworkAgentWrapper workAgent =
makeEnterpriseNetworkAgent(profileNetworkPreference.getPreferenceEnterpriseId());
@@ -14836,7 +14774,7 @@
// system default is not handled specially, the rules are always active as long as
// a preference is set.
inOrder.verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreference),
PREFERENCE_ORDER_PROFILE));
}
@@ -14846,7 +14784,7 @@
if (allowFallback && !connectWorkProfileAgentAhead) {
assertNoCallbacks(profileDefaultNetworkCallback);
} else if (!connectWorkProfileAgentAhead) {
- profileDefaultNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ profileDefaultNetworkCallback.expect(LOST, mCellAgent);
if (disAllowProfileDefaultNetworkCallback != null) {
assertNoCallbacks(disAllowProfileDefaultNetworkCallback);
}
@@ -14871,7 +14809,7 @@
if (allowFallback && !connectWorkProfileAgentAhead) {
inOrder.verify(mMockNetd).networkRemoveUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreference),
PREFERENCE_ORDER_PROFILE));
}
@@ -14901,13 +14839,13 @@
// Conversely, change a capability on the system-wide default network and make sure
// that only the apps outside of the work profile receive the callbacks.
- mCellNetworkAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
- mSystemDefaultNetworkCallback.expectCapabilitiesThat(mCellNetworkAgent, nc ->
+ mCellAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
+ mSystemDefaultNetworkCallback.expectCapabilitiesThat(mCellAgent, nc ->
nc.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED));
- mDefaultNetworkCallback.expectCapabilitiesThat(mCellNetworkAgent, nc ->
+ mDefaultNetworkCallback.expectCapabilitiesThat(mCellAgent, nc ->
nc.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED));
if (disAllowProfileDefaultNetworkCallback != null) {
- disAllowProfileDefaultNetworkCallback.expectCapabilitiesThat(mCellNetworkAgent, nc ->
+ disAllowProfileDefaultNetworkCallback.expectCapabilitiesThat(mCellAgent, nc ->
nc.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED));
}
profileDefaultNetworkCallback.assertNoCallback();
@@ -14915,35 +14853,33 @@
// Disconnect and reconnect the system-wide default network and make sure that the
// apps on this network see the appropriate callbacks, and the app on the work profile
// doesn't because it continues to use the enterprise network.
- mCellNetworkAgent.disconnect();
- mSystemDefaultNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- mDefaultNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ mSystemDefaultNetworkCallback.expect(LOST, mCellAgent);
+ mDefaultNetworkCallback.expect(LOST, mCellAgent);
if (disAllowProfileDefaultNetworkCallback != null) {
- disAllowProfileDefaultNetworkCallback.expect(
- CallbackEntry.LOST, mCellNetworkAgent);
+ disAllowProfileDefaultNetworkCallback.expect(LOST, mCellAgent);
}
profileDefaultNetworkCallback.assertNoCallback();
- inOrder.verify(mMockNetd).networkDestroy(mCellNetworkAgent.getNetwork().netId);
+ inOrder.verify(mMockNetd).networkDestroy(mCellAgent.getNetwork().netId);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
if (disAllowProfileDefaultNetworkCallback != null) {
- disAllowProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(
- mCellNetworkAgent);
+ disAllowProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
}
profileDefaultNetworkCallback.assertNoCallback();
inOrder.verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
// When the agent disconnects, test that the app on the work profile falls back to the
// default network.
workAgent.disconnect();
- profileDefaultNetworkCallback.expect(CallbackEntry.LOST, workAgent);
+ profileDefaultNetworkCallback.expect(LOST, workAgent);
if (allowFallback) {
- profileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ profileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
if (disAllowProfileDefaultNetworkCallback != null) {
assertNoCallbacks(disAllowProfileDefaultNetworkCallback);
}
@@ -14951,27 +14887,26 @@
assertNoCallbacks(mSystemDefaultNetworkCallback, mDefaultNetworkCallback);
if (allowFallback) {
inOrder.verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreference),
PREFERENCE_ORDER_PROFILE));
}
inOrder.verify(mMockNetd).networkDestroy(workAgent.getNetwork().netId);
- mCellNetworkAgent.disconnect();
- mSystemDefaultNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- mDefaultNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ mSystemDefaultNetworkCallback.expect(LOST, mCellAgent);
+ mDefaultNetworkCallback.expect(LOST, mCellAgent);
if (disAllowProfileDefaultNetworkCallback != null) {
- disAllowProfileDefaultNetworkCallback.expect(
- CallbackEntry.LOST, mCellNetworkAgent);
+ disAllowProfileDefaultNetworkCallback.expect(LOST, mCellAgent);
}
if (allowFallback) {
- profileDefaultNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ profileDefaultNetworkCallback.expect(LOST, mCellAgent);
}
// Waiting for the handler to be idle before checking for networkDestroy is necessary
// here because ConnectivityService calls onLost before the network is fully torn down.
waitForIdle();
- inOrder.verify(mMockNetd).networkDestroy(mCellNetworkAgent.getNetwork().netId);
+ inOrder.verify(mMockNetd).networkDestroy(mCellAgent.getNetwork().netId);
// If the control comes here, callbacks seem to behave correctly in the presence of
// a default network when the enterprise network goes up and down. Now, make sure they
@@ -15008,7 +14943,7 @@
// When the agent disconnects, test that the app on the work profile fall back to the
// default network.
workAgent2.disconnect();
- profileDefaultNetworkCallback.expect(CallbackEntry.LOST, workAgent2);
+ profileDefaultNetworkCallback.expect(LOST, workAgent2);
if (disAllowProfileDefaultNetworkCallback != null) {
assertNoCallbacks(disAllowProfileDefaultNetworkCallback);
}
@@ -15354,23 +15289,23 @@
registerDefaultNetworkCallbackAsUid(appCb3, testWorkProfileAppUid3);
// Connect both a regular cell agent and an enterprise network first.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
final TestNetworkAgentWrapper workAgent1 = makeEnterpriseNetworkAgent(NET_ENTERPRISE_ID_1);
final TestNetworkAgentWrapper workAgent2 = makeEnterpriseNetworkAgent(NET_ENTERPRISE_ID_2);
workAgent1.connect(true);
workAgent2.connect(true);
- mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
- appCb1.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb2.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb3.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ appCb1.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb2.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb3.expectAvailableThenValidatedCallbacks(mCellAgent);
verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
workAgent1.getNetwork().netId, INetd.PERMISSION_SYSTEM));
verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
@@ -15437,8 +15372,8 @@
assertNoCallbacks(mSystemDefaultNetworkCallback, mDefaultNetworkCallback);
appCb3.expectAvailableCallbacksValidated(workAgent1);
- appCb2.expectAvailableCallbacksValidated(mCellNetworkAgent);
- appCb1.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ appCb2.expectAvailableCallbacksValidated(mCellAgent);
+ appCb1.expectAvailableCallbacksValidated(mCellAgent);
// Set the preferences for testHandle to default.
ProfileNetworkPreference.Builder profileNetworkPreferenceBuilder =
@@ -15455,9 +15390,9 @@
PREFERENCE_ORDER_PROFILE));
assertNoCallbacks(mSystemDefaultNetworkCallback, mDefaultNetworkCallback, appCb1, appCb2);
- appCb3.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ appCb3.expectAvailableCallbacksValidated(mCellAgent);
workAgent2.disconnect();
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
mCm.unregisterNetworkCallback(appCb1);
mCm.unregisterNetworkCallback(appCb2);
@@ -15502,8 +15437,8 @@
registerDefaultNetworkCallbackAsUid(appCb5, testWorkProfileAppUid5);
// Connect both a regular cell agent and an enterprise network first.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
final TestNetworkAgentWrapper workAgent1 = makeEnterpriseNetworkAgent(NET_ENTERPRISE_ID_1);
final TestNetworkAgentWrapper workAgent2 = makeEnterpriseNetworkAgent(NET_ENTERPRISE_ID_2);
@@ -15517,16 +15452,16 @@
workAgent4.connect(true);
workAgent5.connect(true);
- mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb1.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb2.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb3.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb4.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb5.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb1.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb2.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb3.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb4.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb5.expectAvailableThenValidatedCallbacks(mCellAgent);
verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
workAgent1.getNetwork().netId, INetd.PERMISSION_SYSTEM));
verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
@@ -15618,36 +15553,36 @@
workAgent4.disconnect();
workAgent5.disconnect();
- appCb1.expect(CallbackEntry.LOST, workAgent1);
- appCb2.expect(CallbackEntry.LOST, workAgent2);
- appCb3.expect(CallbackEntry.LOST, workAgent3);
- appCb4.expect(CallbackEntry.LOST, workAgent4);
- appCb5.expect(CallbackEntry.LOST, workAgent5);
+ appCb1.expect(LOST, workAgent1);
+ appCb2.expect(LOST, workAgent2);
+ appCb3.expect(LOST, workAgent3);
+ appCb4.expect(LOST, workAgent4);
+ appCb5.expect(LOST, workAgent5);
- appCb1.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ appCb1.expectAvailableCallbacksValidated(mCellAgent);
appCb2.assertNoCallback();
- appCb3.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ appCb3.expectAvailableCallbacksValidated(mCellAgent);
appCb4.assertNoCallback();
- appCb5.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ appCb5.expectAvailableCallbacksValidated(mCellAgent);
verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreferenceBuilder1.build()),
PREFERENCE_ORDER_PROFILE));
verify(mMockNetd, never()).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreferenceBuilder2.build()),
PREFERENCE_ORDER_PROFILE));
verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreferenceBuilder3.build()),
PREFERENCE_ORDER_PROFILE));
verify(mMockNetd, never()).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreferenceBuilder4.build()),
PREFERENCE_ORDER_PROFILE));
verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreferenceBuilder5.build()),
PREFERENCE_ORDER_PROFILE));
@@ -15665,9 +15600,9 @@
listener.expectOnComplete();
assertNoCallbacks(mSystemDefaultNetworkCallback, mDefaultNetworkCallback, appCb1, appCb3,
appCb5);
- appCb2.expectAvailableCallbacksValidated(mCellNetworkAgent);
- appCb4.expectAvailableCallbacksValidated(mCellNetworkAgent);
- mCellNetworkAgent.disconnect();
+ appCb2.expectAvailableCallbacksValidated(mCellAgent);
+ appCb4.expectAvailableCallbacksValidated(mCellAgent);
+ mCellAgent.disconnect();
mCm.unregisterNetworkCallback(appCb1);
mCm.unregisterNetworkCallback(appCb2);
@@ -15687,8 +15622,8 @@
final UserHandle testHandle = setupEnterpriseNetwork();
// Connect both a regular cell agent and an enterprise network first.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
final TestNetworkAgentWrapper workAgent = makeEnterpriseNetworkAgent();
workAgent.connect(true);
@@ -15698,27 +15633,27 @@
r -> r.run(), listener);
listener.expectOnComplete();
inOrder.verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
inOrder.verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
workAgent.getNetwork().netId, uidRangeFor(testHandle), PREFERENCE_ORDER_PROFILE));
registerDefaultNetworkCallbacks();
- mSystemDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mSystemDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(workAgent);
mCm.setProfileNetworkPreference(testHandle, PROFILE_NETWORK_PREFERENCE_DEFAULT,
r -> r.run(), listener);
listener.expectOnComplete();
- mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
assertNoCallbacks(mSystemDefaultNetworkCallback, mDefaultNetworkCallback);
inOrder.verify(mMockNetd).networkRemoveUidRangesParcel(new NativeUidRangeConfig(
workAgent.getNetwork().netId, uidRangeFor(testHandle), PREFERENCE_ORDER_PROFILE));
workAgent.disconnect();
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
// Callbacks will be unregistered by tearDown()
}
@@ -15740,18 +15675,18 @@
registerDefaultNetworkCallbackAsUid(app4Cb, testWorkProfileAppUid4);
// Connect both a regular cell agent and an enterprise network first.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
final TestNetworkAgentWrapper workAgent = makeEnterpriseNetworkAgent();
workAgent.connect(true);
- mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- app4Cb.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ app4Cb.expectAvailableThenValidatedCallbacks(mCellAgent);
inOrder.verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
inOrder.verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
workAgent.getNetwork().netId, INetd.PERMISSION_SYSTEM));
@@ -15782,12 +15717,12 @@
inOrder.verify(mMockNetd).networkRemoveUidRangesParcel(new NativeUidRangeConfig(
workAgent.getNetwork().netId, uidRangeFor(testHandle2), PREFERENCE_ORDER_PROFILE));
- mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
assertNoCallbacks(mSystemDefaultNetworkCallback, mDefaultNetworkCallback,
app4Cb);
workAgent.disconnect();
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
mCm.unregisterNetworkCallback(app4Cb);
// Other callbacks will be unregistered by tearDown()
@@ -15798,17 +15733,17 @@
final InOrder inOrder = inOrder(mMockNetd);
final UserHandle testHandle = setupEnterpriseNetwork();
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
final TestOnCompleteListener listener = new TestOnCompleteListener();
mCm.setProfileNetworkPreference(testHandle, PROFILE_NETWORK_PREFERENCE_ENTERPRISE,
r -> r.run(), listener);
listener.expectOnComplete();
inOrder.verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
inOrder.verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId, uidRangeFor(testHandle),
+ mCellAgent.getNetwork().netId, uidRangeFor(testHandle),
PREFERENCE_ORDER_PROFILE));
final Intent removedIntent = new Intent(ACTION_USER_REMOVED);
@@ -15816,11 +15751,44 @@
processBroadcast(removedIntent);
inOrder.verify(mMockNetd).networkRemoveUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId, uidRangeFor(testHandle),
+ mCellAgent.getNetwork().netId, uidRangeFor(testHandle),
PREFERENCE_ORDER_PROFILE));
}
@Test
+ public void testProfileNetworkPreferenceBlocking_addUser() throws Exception {
+ final InOrder inOrder = inOrder(mMockNetd);
+ doReturn(asList(PRIMARY_USER_HANDLE)).when(mUserManager).getUserHandles(anyBoolean());
+
+ // Only one network
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+
+ // Verify uid ranges 0~99999 are allowed
+ final ArraySet<UidRange> allowedRanges = new ArraySet<>();
+ allowedRanges.add(PRIMARY_UIDRANGE);
+ final NativeUidRangeConfig config1User = new NativeUidRangeConfig(
+ mCellAgent.getNetwork().netId,
+ toUidRangeStableParcels(allowedRanges),
+ 0 /* subPriority */);
+ inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[] { config1User });
+
+ doReturn(asList(PRIMARY_USER_HANDLE, SECONDARY_USER_HANDLE))
+ .when(mUserManager).getUserHandles(anyBoolean());
+ final Intent addedIntent = new Intent(ACTION_USER_ADDED);
+ addedIntent.putExtra(Intent.EXTRA_USER, UserHandle.of(SECONDARY_USER));
+ processBroadcast(addedIntent);
+
+ // Make sure the allow list has been updated.
+ allowedRanges.add(UidRange.createForUser(SECONDARY_USER_HANDLE));
+ final NativeUidRangeConfig config2Users = new NativeUidRangeConfig(
+ mCellAgent.getNetwork().netId,
+ toUidRangeStableParcels(allowedRanges),
+ 0 /* subPriority */);
+ inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[] { config2Users });
+ }
+
+ @Test
public void testProfileNetworkPreferenceBlocking_changePreference() throws Exception {
final InOrder inOrder = inOrder(mMockNetd);
final UserHandle testHandle = setupEnterpriseNetwork();
@@ -15829,8 +15797,8 @@
// Start with 1 default network and 1 enterprise network, both networks should
// not be restricted since the blocking preference is not set yet.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
// Verify uid ranges 0~99999, 200000~299999 are all allowed for cellular.
final UidRange profileUidRange =
@@ -15841,7 +15809,7 @@
final UidRangeParcel[] allowAllUidRangesParcel = toUidRangeStableParcels(
allowedAllUidRanges);
final NativeUidRangeConfig cellAllAllowedConfig = new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
allowAllUidRangesParcel,
0 /* subPriority */);
inOrder.verify(mMockNetd).setNetworkAllowlist(
@@ -15886,7 +15854,7 @@
));
final UidRangeParcel[] excludeAppRangesParcel = toUidRangeStableParcels(excludeAppRanges);
final NativeUidRangeConfig cellExcludeAppConfig = new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
excludeAppRangesParcel,
0 /* subPriority */);
inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
@@ -15930,8 +15898,8 @@
// Start with 1 default network, which should be restricted since the blocking
// preference is already set.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
// Verify cellular network applies to the allow list.
// Cell: 0~99999, 200000~TEST_APP_UID-1, TEST_APP_UID+1~299999
@@ -15947,7 +15915,7 @@
));
final UidRangeParcel[] excludeAppRangesParcel = toUidRangeStableParcels(excludeAppRanges);
final NativeUidRangeConfig cellExcludeAppConfig = new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
excludeAppRangesParcel,
0 /* subPriority */);
inOrder.verify(mMockNetd).setNetworkAllowlist(
@@ -15980,7 +15948,7 @@
inOrder.verify(mMockNetd).setNetworkAllowlist(
new NativeUidRangeConfig[]{cellExcludeAppConfig});
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
waitForIdle();
inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[]{});
}
@@ -16230,7 +16198,7 @@
.addCapability(NET_CAPABILITY_NOT_VCN_MANAGED)
.removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET,
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET,
new LinkProperties(), ncb.build());
final ArraySet<Integer> serviceUidSet = new ArraySet<>();
@@ -16242,22 +16210,22 @@
.addTransportType(TRANSPORT_ETHERNET)
.removeCapability(NET_CAPABILITY_NOT_RESTRICTED)
.build(), cb);
- mEthernetNetworkAgent.connect(true);
- cb.expectAvailableThenValidatedCallbacks(mEthernetNetworkAgent);
+ mEthernetAgent.connect(true);
+ cb.expectAvailableThenValidatedCallbacks(mEthernetAgent);
// Cell gets to set the service UID as access UID
ncb.setAllowedUids(serviceUidSet);
- mEthernetNetworkAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
+ mEthernetAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
if (SdkLevel.isAtLeastT() && hasAutomotiveFeature) {
- cb.expectCapabilitiesThat(mEthernetNetworkAgent,
+ cb.expectCapabilitiesThat(mEthernetAgent,
caps -> caps.getAllowedUids().equals(serviceUidSet));
} else {
// S and no automotive feature must ignore access UIDs.
cb.assertNoCallback(TEST_CALLBACK_TIMEOUT_MS);
}
- mEthernetNetworkAgent.disconnect();
- cb.expect(CallbackEntry.LOST, mEthernetNetworkAgent);
+ mEthernetAgent.disconnect();
+ cb.expect(LOST, mEthernetAgent);
mCm.unregisterNetworkCallback(cb);
}
@@ -16280,7 +16248,7 @@
.removeCapability(NET_CAPABILITY_NOT_RESTRICTED)
.setNetworkSpecifier(new TelephonyNetworkSpecifier(1 /* subid */));
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR,
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR,
new LinkProperties(), ncb.build());
final ArraySet<Integer> serviceUidSet = new ArraySet<>();
@@ -16298,13 +16266,12 @@
.addTransportType(TRANSPORT_CELLULAR)
.removeCapability(NET_CAPABILITY_NOT_RESTRICTED)
.build(), cb);
- mCellNetworkAgent.connect(true);
- cb.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent.connect(true);
+ cb.expectAvailableThenValidatedCallbacks(mCellAgent);
ncb.setAllowedUids(serviceUidSet);
- mCellNetworkAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
+ mCellAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
if (SdkLevel.isAtLeastT()) {
- cb.expectCapabilitiesThat(mCellNetworkAgent,
- caps -> caps.getAllowedUids().equals(serviceUidSet));
+ cb.expectCapabilitiesThat(mCellAgent, cp -> cp.getAllowedUids().equals(serviceUidSet));
} else {
// S must ignore access UIDs.
cb.assertNoCallback(TEST_CALLBACK_TIMEOUT_MS);
@@ -16312,10 +16279,9 @@
// ...but not to some other UID. Rejection sets UIDs to the empty set
ncb.setAllowedUids(nonServiceUidSet);
- mCellNetworkAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
+ mCellAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
if (SdkLevel.isAtLeastT()) {
- cb.expectCapabilitiesThat(mCellNetworkAgent,
- caps -> caps.getAllowedUids().isEmpty());
+ cb.expectCapabilitiesThat(mCellAgent, cp -> cp.getAllowedUids().isEmpty());
} else {
// S must ignore access UIDs.
cb.assertNoCallback(TEST_CALLBACK_TIMEOUT_MS);
@@ -16323,11 +16289,11 @@
// ...and also not to multiple UIDs even including the service UID
ncb.setAllowedUids(serviceUidSetPlus);
- mCellNetworkAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
+ mCellAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
cb.assertNoCallback(TEST_CALLBACK_TIMEOUT_MS);
- mCellNetworkAgent.disconnect();
- cb.expect(CallbackEntry.LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ cb.expect(LOST, mCellAgent);
mCm.unregisterNetworkCallback(cb);
// Must be unset before touching the transports, because remove and add transport types
@@ -16341,12 +16307,11 @@
.addTransportType(TRANSPORT_WIFI)
.removeCapability(NET_CAPABILITY_NOT_RESTRICTED)
.build(), cb);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI,
- new LinkProperties(), ncb.build());
- mWiFiNetworkAgent.connect(true);
- cb.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(), ncb.build());
+ mWiFiAgent.connect(true);
+ cb.expectAvailableThenValidatedCallbacks(mWiFiAgent);
ncb.setAllowedUids(serviceUidSet);
- mWiFiNetworkAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
+ mWiFiAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
cb.assertNoCallback(TEST_CALLBACK_TIMEOUT_MS);
mCm.unregisterNetworkCallback(cb);
}
@@ -16533,12 +16498,12 @@
public void testMobileDataPreferredUidsChanged() throws Exception {
final InOrder inorder = inOrder(mMockNetd);
registerDefaultNetworkCallbacks();
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
- final int cellNetId = mCellNetworkAgent.getNetwork().netId;
+ final int cellNetId = mCellAgent.getNetwork().netId;
inorder.verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(
cellNetId, INetd.PERMISSION_NONE));
@@ -16591,13 +16556,13 @@
cellNetworkCallback.assertNoCallback();
registerDefaultNetworkCallbacks();
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
- final int wifiNetId = mWiFiNetworkAgent.getNetwork().netId;
+ final int wifiNetId = mWiFiAgent.getNetwork().netId;
inorder.verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(
wifiNetId, INetd.PERMISSION_NONE));
@@ -16618,14 +16583,14 @@
// Cellular network connected. mTestPackageDefaultNetworkCallback should receive
// callback with cellular network and net id and uid ranges should be updated to netd.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
mDefaultNetworkCallback.assertNoCallback();
- mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
- final int cellNetId = mCellNetworkAgent.getNetwork().netId;
+ final int cellNetId = mCellAgent.getNetwork().netId;
final NativeUidRangeConfig cellConfig = new NativeUidRangeConfig(cellNetId, uidRanges,
PREFERENCE_ORDER_MOBILE_DATA_PREFERERRED);
inorder.verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(
@@ -16635,26 +16600,26 @@
// Cellular network disconnected. mTestPackageDefaultNetworkCallback should receive
// callback with wifi network from fallback request.
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
mDefaultNetworkCallback.assertNoCallback();
- cellNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- mTestPackageDefaultNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- mTestPackageDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ cellNetworkCallback.expect(LOST, mCellAgent);
+ mTestPackageDefaultNetworkCallback.expect(LOST, mCellAgent);
+ mTestPackageDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
inorder.verify(mMockNetd, times(1)).networkAddUidRangesParcel(wifiConfig);
inorder.verify(mMockNetd, never()).networkRemoveUidRangesParcel(any());
inorder.verify(mMockNetd).networkDestroy(cellNetId);
// Cellular network comes back. mTestPackageDefaultNetworkCallback should receive
// callback with cellular network.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
mDefaultNetworkCallback.assertNoCallback();
- mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
- final int cellNetId2 = mCellNetworkAgent.getNetwork().netId;
+ final int cellNetId2 = mCellAgent.getNetwork().netId;
final NativeUidRangeConfig cellConfig2 = new NativeUidRangeConfig(cellNetId2, uidRanges,
PREFERENCE_ORDER_MOBILE_DATA_PREFERERRED);
inorder.verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(
@@ -16664,11 +16629,11 @@
// Wifi network disconnected. mTestPackageDefaultNetworkCallback should not receive
// any callback.
- mWiFiNetworkAgent.disconnect();
- mDefaultNetworkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mWiFiAgent.disconnect();
+ mDefaultNetworkCallback.expect(LOST, mWiFiAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
mTestPackageDefaultNetworkCallback.assertNoCallback();
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
waitForIdle();
inorder.verify(mMockNetd, never()).networkAddUidRangesParcel(any());
inorder.verify(mMockNetd, never()).networkRemoveUidRangesParcel(any());
@@ -16700,15 +16665,15 @@
cellFactory.expectRequestAdds(2);
cellFactory.assertRequestCountEquals(2);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
// The cellFactory however is outscored, and should lose default internet request.
// But it should still see mobile data preferred request.
cellFactory.expectRequestRemove();
cellFactory.assertRequestCountEquals(1);
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
// The network satisfying the default internet request has disconnected, so the
// cellFactory sees the default internet requests again.
cellFactory.expectRequestAdd();
@@ -16750,7 +16715,7 @@
final UserHandle testHandle = setupEnterpriseNetwork();
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
- final int cellNetId = mCellNetworkAgent.getNetwork().netId;
+ final int cellNetId = mCellAgent.getNetwork().netId;
inorder.verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(
cellNetId, INetd.PERMISSION_NONE));
@@ -16823,28 +16788,28 @@
// Register callbacks and have wifi network as default network.
registerDefaultNetworkCallbacks();
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- mProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(),
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ mProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(),
mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
// Set MOBILE_DATA_PREFERRED_UIDS setting with TEST_WORK_PROFILE_APP_UID and
// TEST_PACKAGE_UID. Both mProfileDefaultNetworkCallback and
// mTestPackageDefaultNetworkCallback should receive callback with cell network.
setAndUpdateMobileDataPreferredUids(Set.of(TEST_WORK_PROFILE_APP_UID, TEST_PACKAGE_UID));
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
mDefaultNetworkCallback.assertNoCallback();
- mProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(),
+ mProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(),
mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
// Set user profile network preference with test profile. mProfileDefaultNetworkCallback
// should receive callback with higher priority network preference (enterprise network).
@@ -16859,7 +16824,7 @@
assertNoCallbacks(mDefaultNetworkCallback, mTestPackageDefaultNetworkCallback);
mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(workAgent);
assertEquals(workAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
// Set oem network preference with TEST_PACKAGE_UID. mTestPackageDefaultNetworkCallback
// should receive callback with higher priority network preference (current default network)
@@ -16870,8 +16835,8 @@
final UidRangeParcel[] uidRanges1 = toUidRangeStableParcels(uidRangesForUids(uids1));
setupSetOemNetworkPreferenceForPreferenceTest(networkPref, uidRanges1, TEST_PACKAGE_NAME);
assertNoCallbacks(mDefaultNetworkCallback, mProfileDefaultNetworkCallback);
- mTestPackageDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ mTestPackageDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
assertEquals(workAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
// Set oem network preference with TEST_WORK_PROFILE_APP_UID. Both
@@ -16883,11 +16848,11 @@
setupSetOemNetworkPreferenceForPreferenceTest(
networkPref, uidRanges2, "com.android.test", testHandle);
mDefaultNetworkCallback.assertNoCallback();
- mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- mTestPackageDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(),
+ mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
+ mTestPackageDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
+ assertEquals(mWiFiAgent.getNetwork(),
mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
// Remove oem network preference, mProfileDefaultNetworkCallback should receive callback
// with current highest priority network preference (enterprise network) and the others
@@ -16899,23 +16864,23 @@
assertNoCallbacks(mDefaultNetworkCallback, mTestPackageDefaultNetworkCallback);
mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(workAgent);
assertEquals(workAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
// Remove user profile network preference.
mCm.setProfileNetworkPreference(testHandle, PROFILE_NETWORK_PREFERENCE_DEFAULT,
r -> r.run(), listener);
listener.expectOnComplete();
assertNoCallbacks(mDefaultNetworkCallback, mTestPackageDefaultNetworkCallback);
- mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(),
+ mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(),
mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
// Disconnect wifi
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
assertNoCallbacks(mProfileDefaultNetworkCallback, mTestPackageDefaultNetworkCallback);
- mDefaultNetworkCallback.expect(CallbackEntry.LOST, mWiFiNetworkAgent);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mDefaultNetworkCallback.expect(LOST, mWiFiAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
}
@Test
@@ -16929,13 +16894,13 @@
public void testUpdateRateLimit_EnableDisable() throws Exception {
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
final LinkProperties cellLp = new LinkProperties();
cellLp.setInterfaceName(MOBILE_IFNAME);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(false);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(false);
waitForIdle();
@@ -16968,8 +16933,8 @@
public void testUpdateRateLimit_WhenNewNetworkIsAdded() throws Exception {
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
waitForIdle();
@@ -16984,8 +16949,8 @@
final LinkProperties cellLp = new LinkProperties();
cellLp.setInterfaceName(MOBILE_IFNAME);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(false);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(false);
assertNotNull(readHead.poll(TIMEOUT_MS, it -> it.first == cellLp.getInterfaceName()
&& it.second == rateLimitInBytesPerSec));
}
@@ -16995,8 +16960,8 @@
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connectWithoutInternet();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connectWithoutInternet();
waitForIdle();
@@ -17020,8 +16985,8 @@
// - ensure network interface is not rate limited
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
waitForIdle();
final ArrayTrackRecord<Pair<String, Long>>.ReadHead readHeadWifi =
@@ -17033,14 +16998,14 @@
it -> it.first == wifiLp.getInterfaceName()
&& it.second == rateLimitInBytesPerSec));
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
assertNotNull(readHeadWifi.poll(TIMEOUT_MS,
it -> it.first == wifiLp.getInterfaceName() && it.second == -1));
setIngressRateLimit(-1);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
assertNull(readHeadWifi.poll(TIMEOUT_MS, it -> it.first == wifiLp.getInterfaceName()));
}
@@ -17048,8 +17013,8 @@
public void testUpdateRateLimit_UpdateExistingRateLimit() throws Exception {
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
waitForIdle();
final ArrayTrackRecord<Pair<String, Long>>.ReadHead readHeadWifi =
@@ -17078,8 +17043,8 @@
public void testUpdateRateLimit_DoesNothingBeforeT() throws Exception {
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
waitForIdle();
final ArrayTrackRecord<Pair<String, Long>>.ReadHead readHead =
@@ -17118,8 +17083,8 @@
final String bssid1 = "AA:AA:AA:AA:AA:AA";
final String bssid2 = "BB:BB:BB:BB:BB:BB";
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
NetworkCapabilities wifiNc1 = new NetworkCapabilities()
.addCapability(NET_CAPABILITY_INTERNET)
.addCapability(NET_CAPABILITY_NOT_VPN)
@@ -17132,106 +17097,98 @@
.setTransportInfo(new WifiInfo.Builder().setBssid(bssid2).build());
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp, wifiNc1);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp, wifiNc1);
+ mWiFiAgent.connect(true);
// The default network will be switching to Wi-Fi Network.
final TestNetworkCallback wifiNetworkCallback = new TestNetworkCallback();
final NetworkRequest wifiRequest = new NetworkRequest.Builder()
.addTransportType(TRANSPORT_WIFI).build();
mCm.requestNetwork(wifiRequest, wifiNetworkCallback);
- wifiNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
+ wifiNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
registerDefaultNetworkCallbacks();
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
// There is a bug in the current code where ignoring validation after roam will not
// correctly change the default network if the result if the validation is partial or
// captive portal. TODO : fix the bug and reinstate this code.
if (false) {
// Wi-Fi roaming from wifiNc1 to wifiNc2 but the network is now behind a captive portal.
- mWiFiNetworkAgent.setNetworkCapabilities(wifiNc2, true /* sendToConnectivityService */);
+ mWiFiAgent.setNetworkCapabilities(wifiNc2, true /* sendToConnectivityService */);
// The only thing changed in this CAPS is the BSSID, which can't be tested for in this
// test because it's redacted.
- wifiNetworkCallback.expect(CallbackEntry.NETWORK_CAPS_UPDATED,
- mWiFiNetworkAgent);
- mDefaultNetworkCallback.expect(CallbackEntry.NETWORK_CAPS_UPDATED,
- mWiFiNetworkAgent);
- mWiFiNetworkAgent.setNetworkPortal(TEST_REDIRECT_URL,
- false /* privateDnsProbeSent */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
+ wifiNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
+ mDefaultNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
+ mWiFiAgent.setNetworkPortal(TEST_REDIRECT_URL, false /* privateDnsProbeSent */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
// Wi-Fi is now detected to have a portal : cell should become the default network.
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED,
- mWiFiNetworkAgent);
- wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_CAPTIVE_PORTAL,
- mWiFiNetworkAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
+ wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_CAPTIVE_PORTAL, mWiFiAgent);
// Wi-Fi becomes valid again. The default network goes back to Wi-Fi.
- mWiFiNetworkAgent.setNetworkValid(false /* privateDnsProbeSent */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_CAPTIVE_PORTAL,
- mWiFiNetworkAgent);
+ mWiFiAgent);
// Wi-Fi roaming from wifiNc2 to wifiNc1, and the network now has partial connectivity.
- mWiFiNetworkAgent.setNetworkCapabilities(wifiNc1, true);
- wifiNetworkCallback.expect(CallbackEntry.NETWORK_CAPS_UPDATED,
- mWiFiNetworkAgent);
- mDefaultNetworkCallback.expect(CallbackEntry.NETWORK_CAPS_UPDATED,
- mWiFiNetworkAgent);
- mWiFiNetworkAgent.setNetworkPartial();
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
+ mWiFiAgent.setNetworkCapabilities(wifiNc1, true);
+ wifiNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
+ mDefaultNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
+ mWiFiAgent.setNetworkPartial();
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
// Wi-Fi now only offers partial connectivity, so in the absence of accepting partial
// connectivity explicitly for this network, it loses default status to cell.
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY,
- mWiFiNetworkAgent);
+ mWiFiAgent);
// Wi-Fi becomes valid again. The default network goes back to Wi-Fi.
- mWiFiNetworkAgent.setNetworkValid(false /* privateDnsProbeSent */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_PARTIAL_CONNECTIVITY,
- mWiFiNetworkAgent);
+ mWiFiAgent);
}
mCm.unregisterNetworkCallback(wifiNetworkCallback);
// Wi-Fi roams from wifiNc1 to wifiNc2, and now becomes really invalid. If validation
// failures after roam are not ignored, this will cause cell to become the default network.
// If they are ignored, this will not cause a switch until later.
- mWiFiNetworkAgent.setNetworkCapabilities(wifiNc2, true);
- mDefaultNetworkCallback.expect(CallbackEntry.NETWORK_CAPS_UPDATED,
- mWiFiNetworkAgent);
- mWiFiNetworkAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
+ mWiFiAgent.setNetworkCapabilities(wifiNc2, true);
+ mDefaultNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
+ mWiFiAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
if (enabled) {
// Network validation failed, but the result will be ignored.
- assertTrue(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertTrue(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
- mWiFiNetworkAgent.setNetworkValid(false);
+ mWiFiAgent.setNetworkValid(false);
// Behavior of after config_validationFailureAfterRoamIgnoreTimeMillis
ConditionVariable waitForValidationBlock = new ConditionVariable();
doReturn(50).when(mResources)
.getInteger(R.integer.config_validationFailureAfterRoamIgnoreTimeMillis);
// Wi-Fi roaming from wifiNc2 to wifiNc1.
- mWiFiNetworkAgent.setNetworkCapabilities(wifiNc1, true);
- mWiFiNetworkAgent.setNetworkInvalid(false);
+ mWiFiAgent.setNetworkCapabilities(wifiNc1, true);
+ mWiFiAgent.setNetworkInvalid(false);
waitForValidationBlock.block(150);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
} else {
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
}
// Wi-Fi is still connected and would become the default network if cell were to
// disconnect. This assertion ensures that the switch to cellular was not caused by
// Wi-Fi disconnecting (e.g., because the capability change to wifiNc2 caused it
// to stop satisfying the default request).
- mCellNetworkAgent.disconnect();
- mDefaultNetworkCallback.expect(CallbackEntry.LOST, mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mCellAgent.disconnect();
+ mDefaultNetworkCallback.expect(LOST, mCellAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
}
@@ -17314,8 +17271,8 @@
lp.setInterfaceName(WIFI_IFNAME);
lp.setMtu(mtu);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.sendLinkProperties(lp);
waitForIdle();
verify(mMockNetd).interfaceSetMtu(eq(WIFI_IFNAME), eq(mtu));
@@ -17328,12 +17285,12 @@
lp.setInterfaceName(WIFI_IFNAME);
lp.setMtu(mtu);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
LinkProperties lp2 = new LinkProperties(lp);
lp2.setMtu(mtu2);
- mWiFiNetworkAgent.sendLinkProperties(lp2);
+ mWiFiAgent.sendLinkProperties(lp2);
waitForIdle();
verify(mMockNetd).interfaceSetMtu(eq(WIFI_IFNAME), eq(mtu2));
@@ -17346,8 +17303,8 @@
lp.setInterfaceName(WIFI_IFNAME);
lp.setMtu(mtu);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
- mWiFiNetworkAgent.sendLinkProperties(new LinkProperties(lp));
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
+ mWiFiAgent.sendLinkProperties(new LinkProperties(lp));
waitForIdle();
verify(mMockNetd, never()).interfaceSetMtu(eq(WIFI_IFNAME), anyInt());
@@ -17360,13 +17317,13 @@
lp.setInterfaceName(WIFI_IFNAME);
lp.setMtu(mtu);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
LinkProperties lp2 = new LinkProperties();
assertNull(lp2.getInterfaceName());
lp2.setMtu(mtu);
- mWiFiNetworkAgent.sendLinkProperties(new LinkProperties(lp2));
+ mWiFiAgent.sendLinkProperties(new LinkProperties(lp2));
waitForIdle();
verify(mMockNetd, never()).interfaceSetMtu(any(), anyInt());
@@ -17379,14 +17336,14 @@
lp.setInterfaceName(WIFI_IFNAME);
lp.setMtu(mtu);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
final String ifaceName2 = WIFI_IFNAME + "_2";
LinkProperties lp2 = new LinkProperties();
lp2.setInterfaceName(ifaceName2);
lp2.setMtu(mtu);
- mWiFiNetworkAgent.sendLinkProperties(new LinkProperties(lp2));
+ mWiFiAgent.sendLinkProperties(new LinkProperties(lp2));
waitForIdle();
verify(mMockNetd).interfaceSetMtu(eq(ifaceName2), eq(mtu));
diff --git a/tests/unit/java/com/android/server/NsdServiceTest.java b/tests/unit/java/com/android/server/NsdServiceTest.java
index 5808beb..98a8ed2 100644
--- a/tests/unit/java/com/android/server/NsdServiceTest.java
+++ b/tests/unit/java/com/android/server/NsdServiceTest.java
@@ -16,16 +16,25 @@
package com.android.server;
+import static android.net.InetAddresses.parseNumericAddress;
+import static android.net.nsd.NsdManager.FAILURE_BAD_PARAMETERS;
import static android.net.nsd.NsdManager.FAILURE_INTERNAL_ERROR;
+import static android.net.nsd.NsdManager.FAILURE_OPERATION_NOT_RUNNING;
+
+import static com.android.testutils.ContextUtils.mockService;
import static libcore.junit.util.compat.CoreCompatChangeRule.DisableCompatChanges;
import static libcore.junit.util.compat.CoreCompatChangeRule.EnableCompatChanges;
+import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doReturn;
@@ -42,7 +51,7 @@
import android.content.ContentResolver;
import android.content.Context;
import android.net.INetd;
-import android.net.InetAddresses;
+import android.net.Network;
import android.net.mdns.aidl.DiscoveryInfo;
import android.net.mdns.aidl.GetAddressInfo;
import android.net.mdns.aidl.IMDnsEventListener;
@@ -63,10 +72,17 @@
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
+import android.os.RemoteException;
import androidx.annotation.NonNull;
import androidx.test.filters.SmallTest;
+import com.android.server.NsdService.Dependencies;
+import com.android.server.connectivity.mdns.MdnsAdvertiser;
+import com.android.server.connectivity.mdns.MdnsDiscoveryManager;
+import com.android.server.connectivity.mdns.MdnsServiceBrowserListener;
+import com.android.server.connectivity.mdns.MdnsServiceInfo;
+import com.android.server.connectivity.mdns.MdnsSocketProvider;
import com.android.testutils.DevSdkIgnoreRule;
import com.android.testutils.DevSdkIgnoreRunner;
import com.android.testutils.HandlerUtils;
@@ -82,7 +98,10 @@
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import java.net.UnknownHostException;
import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
import java.util.Queue;
// TODOs:
@@ -96,11 +115,13 @@
private static final long CLEANUP_DELAY_MS = 500;
private static final long TIMEOUT_MS = 500;
private static final String SERVICE_NAME = "a_name";
- private static final String SERVICE_TYPE = "a_type";
+ private static final String SERVICE_TYPE = "_test._tcp";
private static final String SERVICE_FULL_NAME = SERVICE_NAME + "." + SERVICE_TYPE;
private static final String DOMAIN_NAME = "mytestdevice.local";
private static final int PORT = 2201;
private static final int IFACE_IDX_ANY = 0;
+ private static final String IPV4_ADDRESS = "192.0.2.0";
+ private static final String IPV6_ADDRESS = "2001:db8::";
// Records INsdManagerCallback created when NsdService#connect is called.
// Only accessed on the test thread, since NsdService#connect is called by the NsdManager
@@ -112,6 +133,10 @@
@Mock Context mContext;
@Mock ContentResolver mResolver;
@Mock MDnsManager mMockMDnsM;
+ @Mock Dependencies mDeps;
+ @Mock MdnsDiscoveryManager mDiscoveryManager;
+ @Mock MdnsAdvertiser mAdvertiser;
+ @Mock MdnsSocketProvider mSocketProvider;
HandlerThread mThread;
TestHandler mHandler;
NsdService mService;
@@ -133,9 +158,7 @@
mThread.start();
mHandler = new TestHandler(mThread.getLooper());
when(mContext.getContentResolver()).thenReturn(mResolver);
- doReturn(MDnsManager.MDNS_SERVICE).when(mContext)
- .getSystemServiceName(MDnsManager.class);
- doReturn(mMockMDnsM).when(mContext).getSystemService(MDnsManager.MDNS_SERVICE);
+ mockService(mContext, MDnsManager.class, MDnsManager.MDNS_SERVICE, mMockMDnsM);
if (mContext.getSystemService(MDnsManager.class) == null) {
// Test is using mockito-extended
doCallRealMethod().when(mContext).getSystemService(MDnsManager.class);
@@ -146,6 +169,7 @@
doReturn(true).when(mMockMDnsM).discover(anyInt(), anyString(), anyInt());
doReturn(true).when(mMockMDnsM).resolve(
anyInt(), anyString(), anyString(), anyString(), anyInt());
+ doReturn(false).when(mDeps).isMdnsDiscoveryManagerEnabled(any(Context.class));
mService = makeService();
}
@@ -382,13 +406,42 @@
final NsdServiceInfo resolvedService = resInfoCaptor.getValue();
assertEquals(SERVICE_NAME, resolvedService.getServiceName());
assertEquals("." + SERVICE_TYPE, resolvedService.getServiceType());
- assertEquals(InetAddresses.parseNumericAddress(serviceAddress), resolvedService.getHost());
+ assertEquals(parseNumericAddress(serviceAddress), resolvedService.getHost());
assertEquals(servicePort, resolvedService.getPort());
assertNull(resolvedService.getNetwork());
assertEquals(interfaceIdx, resolvedService.getInterfaceIndex());
}
@Test
+ public void testDiscoverOnBlackholeNetwork() throws Exception {
+ final NsdManager client = connectClient(mService);
+ final DiscoveryListener discListener = mock(DiscoveryListener.class);
+ client.discoverServices(SERVICE_TYPE, PROTOCOL, discListener);
+ waitForIdle();
+
+ final IMDnsEventListener eventListener = getEventListener();
+ final ArgumentCaptor<Integer> discIdCaptor = ArgumentCaptor.forClass(Integer.class);
+ verify(mMockMDnsM).discover(discIdCaptor.capture(), eq(SERVICE_TYPE),
+ eq(0) /* interfaceIdx */);
+ // NsdManager uses a separate HandlerThread to dispatch callbacks (on ServiceHandler), so
+ // this needs to use a timeout
+ verify(discListener, timeout(TIMEOUT_MS)).onDiscoveryStarted(SERVICE_TYPE);
+
+ final DiscoveryInfo discoveryInfo = new DiscoveryInfo(
+ discIdCaptor.getValue(),
+ IMDnsEventListener.SERVICE_FOUND,
+ SERVICE_NAME,
+ SERVICE_TYPE,
+ DOMAIN_NAME,
+ 123 /* interfaceIdx */,
+ INetd.DUMMY_NET_ID); // netId of the blackhole network
+ eventListener.onServiceDiscoveryStatus(discoveryInfo);
+ waitForIdle();
+
+ verify(discListener, never()).onServiceFound(any());
+ }
+
+ @Test
public void testServiceRegistrationSuccessfulAndFailed() throws Exception {
final NsdManager client = connectClient(mService);
final NsdServiceInfo request = new NsdServiceInfo(SERVICE_NAME, SERVICE_TYPE);
@@ -555,12 +608,504 @@
anyInt()/* interfaceIdx */);
}
+ @Test
+ public void testStopServiceResolution() {
+ final NsdManager client = connectClient(mService);
+ final NsdServiceInfo request = new NsdServiceInfo(SERVICE_NAME, SERVICE_TYPE);
+ final ResolveListener resolveListener = mock(ResolveListener.class);
+ client.resolveService(request, resolveListener);
+ waitForIdle();
+
+ final ArgumentCaptor<Integer> resolvIdCaptor = ArgumentCaptor.forClass(Integer.class);
+ verify(mMockMDnsM).resolve(resolvIdCaptor.capture(), eq(SERVICE_NAME), eq(SERVICE_TYPE),
+ eq("local.") /* domain */, eq(IFACE_IDX_ANY));
+
+ final int resolveId = resolvIdCaptor.getValue();
+ client.stopServiceResolution(resolveListener);
+ waitForIdle();
+
+ verify(mMockMDnsM).stopOperation(resolveId);
+ verify(resolveListener, timeout(TIMEOUT_MS)).onResolveStopped(argThat(ns ->
+ request.getServiceName().equals(ns.getServiceName())
+ && request.getServiceType().equals(ns.getServiceType())));
+ }
+
+ @Test
+ public void testStopResolutionFailed() {
+ final NsdManager client = connectClient(mService);
+ final NsdServiceInfo request = new NsdServiceInfo(SERVICE_NAME, SERVICE_TYPE);
+ final ResolveListener resolveListener = mock(ResolveListener.class);
+ client.resolveService(request, resolveListener);
+ waitForIdle();
+
+ final ArgumentCaptor<Integer> resolvIdCaptor = ArgumentCaptor.forClass(Integer.class);
+ verify(mMockMDnsM).resolve(resolvIdCaptor.capture(), eq(SERVICE_NAME), eq(SERVICE_TYPE),
+ eq("local.") /* domain */, eq(IFACE_IDX_ANY));
+
+ final int resolveId = resolvIdCaptor.getValue();
+ doReturn(false).when(mMockMDnsM).stopOperation(anyInt());
+ client.stopServiceResolution(resolveListener);
+ waitForIdle();
+
+ verify(mMockMDnsM).stopOperation(resolveId);
+ verify(resolveListener, timeout(TIMEOUT_MS)).onStopResolutionFailed(argThat(ns ->
+ request.getServiceName().equals(ns.getServiceName())
+ && request.getServiceType().equals(ns.getServiceType())),
+ eq(FAILURE_OPERATION_NOT_RUNNING));
+ }
+
+ @Test @DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ public void testStopResolutionDuringGettingAddress() throws RemoteException {
+ final NsdManager client = connectClient(mService);
+ final NsdServiceInfo request = new NsdServiceInfo(SERVICE_NAME, SERVICE_TYPE);
+ final ResolveListener resolveListener = mock(ResolveListener.class);
+ client.resolveService(request, resolveListener);
+ waitForIdle();
+
+ final IMDnsEventListener eventListener = getEventListener();
+ final ArgumentCaptor<Integer> resolvIdCaptor = ArgumentCaptor.forClass(Integer.class);
+ verify(mMockMDnsM).resolve(resolvIdCaptor.capture(), eq(SERVICE_NAME), eq(SERVICE_TYPE),
+ eq("local.") /* domain */, eq(IFACE_IDX_ANY));
+
+ // Resolve service successfully.
+ final ResolutionInfo resolutionInfo = new ResolutionInfo(
+ resolvIdCaptor.getValue(),
+ IMDnsEventListener.SERVICE_RESOLVED,
+ null /* serviceName */,
+ null /* serviceType */,
+ null /* domain */,
+ SERVICE_FULL_NAME,
+ DOMAIN_NAME,
+ PORT,
+ new byte[0] /* txtRecord */,
+ IFACE_IDX_ANY);
+ doReturn(true).when(mMockMDnsM).getServiceAddress(anyInt(), any(), anyInt());
+ eventListener.onServiceResolutionStatus(resolutionInfo);
+ waitForIdle();
+
+ final ArgumentCaptor<Integer> getAddrIdCaptor = ArgumentCaptor.forClass(Integer.class);
+ verify(mMockMDnsM).getServiceAddress(getAddrIdCaptor.capture(), eq(DOMAIN_NAME),
+ eq(IFACE_IDX_ANY));
+
+ final int getAddrId = getAddrIdCaptor.getValue();
+ client.stopServiceResolution(resolveListener);
+ waitForIdle();
+
+ verify(mMockMDnsM).stopOperation(getAddrId);
+ verify(resolveListener, timeout(TIMEOUT_MS)).onResolveStopped(argThat(ns ->
+ request.getServiceName().equals(ns.getServiceName())
+ && request.getServiceType().equals(ns.getServiceType())));
+ }
+
+ private void verifyUpdatedServiceInfo(NsdServiceInfo info, String serviceName,
+ String serviceType, String address, int port, int interfaceIndex, Network network) {
+ assertEquals(serviceName, info.getServiceName());
+ assertEquals(serviceType, info.getServiceType());
+ assertTrue(info.getHostAddresses().contains(parseNumericAddress(address)));
+ assertEquals(port, info.getPort());
+ assertEquals(network, info.getNetwork());
+ assertEquals(interfaceIndex, info.getInterfaceIndex());
+ }
+
+ @Test
+ public void testRegisterAndUnregisterServiceInfoCallback() throws RemoteException {
+ final NsdManager client = connectClient(mService);
+ final NsdServiceInfo request = new NsdServiceInfo(SERVICE_NAME, SERVICE_TYPE);
+ final NsdManager.ServiceInfoCallback serviceInfoCallback = mock(
+ NsdManager.ServiceInfoCallback.class);
+ client.registerServiceInfoCallback(request, Runnable::run, serviceInfoCallback);
+ waitForIdle();
+
+ final IMDnsEventListener eventListener = getEventListener();
+ final ArgumentCaptor<Integer> resolvIdCaptor = ArgumentCaptor.forClass(Integer.class);
+ verify(mMockMDnsM).resolve(resolvIdCaptor.capture(), eq(SERVICE_NAME), eq(SERVICE_TYPE),
+ eq("local.") /* domain */, eq(IFACE_IDX_ANY));
+
+ // Resolve service successfully.
+ final ResolutionInfo resolutionInfo = new ResolutionInfo(
+ resolvIdCaptor.getValue(),
+ IMDnsEventListener.SERVICE_RESOLVED,
+ null /* serviceName */,
+ null /* serviceType */,
+ null /* domain */,
+ SERVICE_FULL_NAME,
+ DOMAIN_NAME,
+ PORT,
+ new byte[0] /* txtRecord */,
+ IFACE_IDX_ANY);
+ doReturn(true).when(mMockMDnsM).getServiceAddress(anyInt(), any(), anyInt());
+ eventListener.onServiceResolutionStatus(resolutionInfo);
+ waitForIdle();
+
+ final ArgumentCaptor<Integer> getAddrIdCaptor = ArgumentCaptor.forClass(Integer.class);
+ verify(mMockMDnsM).getServiceAddress(getAddrIdCaptor.capture(), eq(DOMAIN_NAME),
+ eq(IFACE_IDX_ANY));
+
+ // First address info
+ final String v4Address = "192.0.2.1";
+ final String v6Address = "2001:db8::";
+ final GetAddressInfo addressInfo1 = new GetAddressInfo(
+ getAddrIdCaptor.getValue(),
+ IMDnsEventListener.SERVICE_GET_ADDR_SUCCESS,
+ SERVICE_FULL_NAME,
+ v4Address,
+ IFACE_IDX_ANY,
+ 999 /* netId */);
+ eventListener.onGettingServiceAddressStatus(addressInfo1);
+ waitForIdle();
+
+ final ArgumentCaptor<NsdServiceInfo> updateInfoCaptor =
+ ArgumentCaptor.forClass(NsdServiceInfo.class);
+ verify(serviceInfoCallback, timeout(TIMEOUT_MS).times(1))
+ .onServiceUpdated(updateInfoCaptor.capture());
+ verifyUpdatedServiceInfo(updateInfoCaptor.getAllValues().get(0) /* info */, SERVICE_NAME,
+ "." + SERVICE_TYPE, v4Address, PORT, IFACE_IDX_ANY, new Network(999));
+
+ // Second address info
+ final GetAddressInfo addressInfo2 = new GetAddressInfo(
+ getAddrIdCaptor.getValue(),
+ IMDnsEventListener.SERVICE_GET_ADDR_SUCCESS,
+ SERVICE_FULL_NAME,
+ v6Address,
+ IFACE_IDX_ANY,
+ 999 /* netId */);
+ eventListener.onGettingServiceAddressStatus(addressInfo2);
+ waitForIdle();
+
+ verify(serviceInfoCallback, timeout(TIMEOUT_MS).times(2))
+ .onServiceUpdated(updateInfoCaptor.capture());
+ verifyUpdatedServiceInfo(updateInfoCaptor.getAllValues().get(1) /* info */, SERVICE_NAME,
+ "." + SERVICE_TYPE, v6Address, PORT, IFACE_IDX_ANY, new Network(999));
+
+ client.unregisterServiceInfoCallback(serviceInfoCallback);
+ waitForIdle();
+
+ verify(serviceInfoCallback, timeout(TIMEOUT_MS)).onServiceInfoCallbackUnregistered();
+ }
+
+ @Test
+ public void testRegisterServiceCallbackFailed() throws Exception {
+ final NsdManager client = connectClient(mService);
+ final NsdServiceInfo request = new NsdServiceInfo(SERVICE_NAME, SERVICE_TYPE);
+ final NsdManager.ServiceInfoCallback subscribeListener = mock(
+ NsdManager.ServiceInfoCallback.class);
+ client.registerServiceInfoCallback(request, Runnable::run, subscribeListener);
+ waitForIdle();
+
+ final IMDnsEventListener eventListener = getEventListener();
+ final ArgumentCaptor<Integer> resolvIdCaptor = ArgumentCaptor.forClass(Integer.class);
+ verify(mMockMDnsM).resolve(resolvIdCaptor.capture(), eq(SERVICE_NAME), eq(SERVICE_TYPE),
+ eq("local.") /* domain */, eq(IFACE_IDX_ANY));
+
+ // Fail to resolve service.
+ final ResolutionInfo resolutionFailedInfo = new ResolutionInfo(
+ resolvIdCaptor.getValue(),
+ IMDnsEventListener.SERVICE_RESOLUTION_FAILED,
+ null /* serviceName */,
+ null /* serviceType */,
+ null /* domain */,
+ null /* serviceFullName */,
+ null /* domainName */,
+ 0 /* port */,
+ new byte[0] /* txtRecord */,
+ IFACE_IDX_ANY);
+ eventListener.onServiceResolutionStatus(resolutionFailedInfo);
+ verify(subscribeListener, timeout(TIMEOUT_MS))
+ .onServiceInfoCallbackRegistrationFailed(eq(FAILURE_BAD_PARAMETERS));
+ }
+
+ @Test
+ public void testUnregisterNotRegisteredCallback() {
+ final NsdManager client = connectClient(mService);
+ final NsdManager.ServiceInfoCallback serviceInfoCallback = mock(
+ NsdManager.ServiceInfoCallback.class);
+
+ assertThrows(IllegalArgumentException.class, () ->
+ client.unregisterServiceInfoCallback(serviceInfoCallback));
+ }
+
+ private void makeServiceWithMdnsDiscoveryManagerEnabled() {
+ doReturn(true).when(mDeps).isMdnsDiscoveryManagerEnabled(any(Context.class));
+ doReturn(mDiscoveryManager).when(mDeps).makeMdnsDiscoveryManager(any(), any());
+ doReturn(mSocketProvider).when(mDeps).makeMdnsSocketProvider(any(), any());
+
+ mService = makeService();
+ verify(mDeps).makeMdnsDiscoveryManager(any(), any());
+ verify(mDeps).makeMdnsSocketProvider(any(), any());
+ }
+
+ private void makeServiceWithMdnsAdvertiserEnabled() {
+ doReturn(true).when(mDeps).isMdnsAdvertiserEnabled(any(Context.class));
+ doReturn(mAdvertiser).when(mDeps).makeMdnsAdvertiser(any(), any(), any());
+ doReturn(mSocketProvider).when(mDeps).makeMdnsSocketProvider(any(), any());
+
+ mService = makeService();
+ verify(mDeps).makeMdnsAdvertiser(any(), any(), any());
+ verify(mDeps).makeMdnsSocketProvider(any(), any());
+ }
+
+ @Test
+ public void testMdnsDiscoveryManagerFeature() {
+ // Create NsdService w/o feature enabled.
+ connectClient(mService);
+ verify(mDeps, never()).makeMdnsDiscoveryManager(any(), any());
+ verify(mDeps, never()).makeMdnsSocketProvider(any(), any());
+
+ // Create NsdService again w/ feature enabled.
+ makeServiceWithMdnsDiscoveryManagerEnabled();
+ }
+
+ @Test
+ public void testDiscoveryWithMdnsDiscoveryManager() {
+ makeServiceWithMdnsDiscoveryManagerEnabled();
+
+ final NsdManager client = connectClient(mService);
+ final DiscoveryListener discListener = mock(DiscoveryListener.class);
+ final Network network = new Network(999);
+ final String serviceTypeWithLocalDomain = SERVICE_TYPE + ".local";
+ // Verify the discovery start / stop.
+ final ArgumentCaptor<MdnsServiceBrowserListener> listenerCaptor =
+ ArgumentCaptor.forClass(MdnsServiceBrowserListener.class);
+ client.discoverServices(SERVICE_TYPE, PROTOCOL, network, r -> r.run(), discListener);
+ waitForIdle();
+ verify(mSocketProvider).startMonitoringSockets();
+ verify(mDiscoveryManager).registerListener(eq(serviceTypeWithLocalDomain),
+ listenerCaptor.capture(), argThat(options -> network.equals(options.getNetwork())));
+ verify(discListener, timeout(TIMEOUT_MS)).onDiscoveryStarted(SERVICE_TYPE);
+
+ final MdnsServiceBrowserListener listener = listenerCaptor.getValue();
+ final MdnsServiceInfo foundInfo = new MdnsServiceInfo(
+ SERVICE_NAME, /* serviceInstanceName */
+ serviceTypeWithLocalDomain.split("\\."), /* serviceType */
+ List.of(), /* subtypes */
+ new String[] {"android", "local"}, /* hostName */
+ 12345, /* port */
+ IPV4_ADDRESS,
+ IPV6_ADDRESS,
+ List.of(), /* textStrings */
+ List.of(), /* textEntries */
+ 1234, /* interfaceIndex */
+ network);
+
+ // Verify onServiceNameDiscovered callback
+ listener.onServiceNameDiscovered(foundInfo);
+ verify(discListener, timeout(TIMEOUT_MS)).onServiceFound(argThat(info ->
+ info.getServiceName().equals(SERVICE_NAME)
+ && info.getServiceType().equals(SERVICE_TYPE)
+ && info.getNetwork().equals(network)));
+
+ final MdnsServiceInfo removedInfo = new MdnsServiceInfo(
+ SERVICE_NAME, /* serviceInstanceName */
+ serviceTypeWithLocalDomain.split("\\."), /* serviceType */
+ null, /* subtypes */
+ null, /* hostName */
+ 0, /* port */
+ null, /* ipv4Address */
+ null, /* ipv6Address */
+ null, /* textStrings */
+ null, /* textEntries */
+ 1234, /* interfaceIndex */
+ network);
+ // Verify onServiceNameRemoved callback
+ listener.onServiceNameRemoved(removedInfo);
+ verify(discListener, timeout(TIMEOUT_MS)).onServiceLost(argThat(info ->
+ info.getServiceName().equals(SERVICE_NAME)
+ && info.getServiceType().equals(SERVICE_TYPE)
+ && info.getNetwork().equals(network)));
+
+ client.stopServiceDiscovery(discListener);
+ waitForIdle();
+ verify(mDiscoveryManager).unregisterListener(eq(serviceTypeWithLocalDomain), any());
+ verify(discListener, timeout(TIMEOUT_MS)).onDiscoveryStopped(SERVICE_TYPE);
+ verify(mSocketProvider, timeout(CLEANUP_DELAY_MS + TIMEOUT_MS)).stopMonitoringSockets();
+ }
+
+ @Test
+ public void testDiscoveryWithMdnsDiscoveryManager_FailedWithInvalidServiceType() {
+ makeServiceWithMdnsDiscoveryManagerEnabled();
+
+ final NsdManager client = connectClient(mService);
+ final DiscoveryListener discListener = mock(DiscoveryListener.class);
+ final Network network = new Network(999);
+ final String invalidServiceType = "a_service";
+ client.discoverServices(
+ invalidServiceType, PROTOCOL, network, r -> r.run(), discListener);
+ waitForIdle();
+ verify(discListener, timeout(TIMEOUT_MS))
+ .onStartDiscoveryFailed(invalidServiceType, FAILURE_INTERNAL_ERROR);
+
+ final String serviceTypeWithLocalDomain = SERVICE_TYPE + ".local";
+ client.discoverServices(
+ serviceTypeWithLocalDomain, PROTOCOL, network, r -> r.run(), discListener);
+ waitForIdle();
+ verify(discListener, timeout(TIMEOUT_MS))
+ .onStartDiscoveryFailed(serviceTypeWithLocalDomain, FAILURE_INTERNAL_ERROR);
+
+ final String serviceTypeWithoutTcpOrUdpEnding = "_test._com";
+ client.discoverServices(
+ serviceTypeWithoutTcpOrUdpEnding, PROTOCOL, network, r -> r.run(), discListener);
+ waitForIdle();
+ verify(discListener, timeout(TIMEOUT_MS))
+ .onStartDiscoveryFailed(serviceTypeWithoutTcpOrUdpEnding, FAILURE_INTERNAL_ERROR);
+ }
+
+ @Test
+ public void testResolutionWithMdnsDiscoveryManager() throws UnknownHostException {
+ makeServiceWithMdnsDiscoveryManagerEnabled();
+
+ final NsdManager client = connectClient(mService);
+ final ResolveListener resolveListener = mock(ResolveListener.class);
+ final Network network = new Network(999);
+ final String serviceType = "_nsd._service._tcp";
+ final String constructedServiceType = "_nsd._sub._service._tcp.local";
+ final ArgumentCaptor<MdnsServiceBrowserListener> listenerCaptor =
+ ArgumentCaptor.forClass(MdnsServiceBrowserListener.class);
+ final NsdServiceInfo request = new NsdServiceInfo(SERVICE_NAME, serviceType);
+ request.setNetwork(network);
+ client.resolveService(request, resolveListener);
+ waitForIdle();
+ verify(mSocketProvider).startMonitoringSockets();
+ verify(mDiscoveryManager).registerListener(eq(constructedServiceType),
+ listenerCaptor.capture(), argThat(options -> network.equals(options.getNetwork())));
+
+ final MdnsServiceBrowserListener listener = listenerCaptor.getValue();
+ final MdnsServiceInfo mdnsServiceInfo = new MdnsServiceInfo(
+ SERVICE_NAME,
+ constructedServiceType.split("\\."),
+ List.of(), /* subtypes */
+ new String[]{"android", "local"}, /* hostName */
+ PORT,
+ IPV4_ADDRESS,
+ IPV6_ADDRESS,
+ List.of() /* textStrings */,
+ List.of(MdnsServiceInfo.TextEntry.fromBytes(new byte[]{
+ 'k', 'e', 'y', '=', (byte) 0xFF, (byte) 0xFE})) /* textEntries */,
+ 1234,
+ network);
+
+ // Verify onServiceFound callback
+ listener.onServiceFound(mdnsServiceInfo);
+ final ArgumentCaptor<NsdServiceInfo> infoCaptor =
+ ArgumentCaptor.forClass(NsdServiceInfo.class);
+ verify(resolveListener, timeout(TIMEOUT_MS)).onServiceResolved(infoCaptor.capture());
+ final NsdServiceInfo info = infoCaptor.getValue();
+ assertEquals(SERVICE_NAME, info.getServiceName());
+ assertEquals("." + serviceType, info.getServiceType());
+ assertEquals(PORT, info.getPort());
+ assertTrue(info.getAttributes().containsKey("key"));
+ assertEquals(1, info.getAttributes().size());
+ assertArrayEquals(new byte[]{(byte) 0xFF, (byte) 0xFE}, info.getAttributes().get("key"));
+ assertEquals(parseNumericAddress(IPV4_ADDRESS), info.getHost());
+ assertEquals(network, info.getNetwork());
+
+ // Verify the listener has been unregistered.
+ verify(mDiscoveryManager, timeout(TIMEOUT_MS))
+ .unregisterListener(eq(constructedServiceType), any());
+ verify(mSocketProvider, timeout(CLEANUP_DELAY_MS + TIMEOUT_MS)).stopMonitoringSockets();
+ }
+
+ @Test
+ public void testAdvertiseWithMdnsAdvertiser() {
+ makeServiceWithMdnsAdvertiserEnabled();
+
+ final NsdManager client = connectClient(mService);
+ final RegistrationListener regListener = mock(RegistrationListener.class);
+ // final String serviceTypeWithLocalDomain = SERVICE_TYPE + ".local";
+ final ArgumentCaptor<MdnsAdvertiser.AdvertiserCallback> cbCaptor =
+ ArgumentCaptor.forClass(MdnsAdvertiser.AdvertiserCallback.class);
+ verify(mDeps).makeMdnsAdvertiser(any(), any(), cbCaptor.capture());
+
+ final NsdServiceInfo regInfo = new NsdServiceInfo(SERVICE_NAME, SERVICE_TYPE);
+ regInfo.setHost(parseNumericAddress("192.0.2.123"));
+ regInfo.setPort(12345);
+ regInfo.setAttribute("testattr", "testvalue");
+ regInfo.setNetwork(new Network(999));
+
+ client.registerService(regInfo, NsdManager.PROTOCOL_DNS_SD, Runnable::run, regListener);
+ waitForIdle();
+ verify(mSocketProvider).startMonitoringSockets();
+ final ArgumentCaptor<Integer> idCaptor = ArgumentCaptor.forClass(Integer.class);
+ verify(mAdvertiser).addService(idCaptor.capture(), argThat(info ->
+ matches(info, regInfo)));
+
+ // Verify onServiceRegistered callback
+ final MdnsAdvertiser.AdvertiserCallback cb = cbCaptor.getValue();
+ cb.onRegisterServiceSucceeded(idCaptor.getValue(), regInfo);
+
+ verify(regListener, timeout(TIMEOUT_MS)).onServiceRegistered(argThat(info -> matches(info,
+ new NsdServiceInfo(regInfo.getServiceName(), null))));
+
+ client.unregisterService(regListener);
+ waitForIdle();
+ verify(mAdvertiser).removeService(idCaptor.getValue());
+ verify(regListener, timeout(TIMEOUT_MS)).onServiceUnregistered(
+ argThat(info -> matches(info, regInfo)));
+ verify(mSocketProvider, timeout(TIMEOUT_MS)).stopMonitoringSockets();
+ }
+
+ @Test
+ public void testAdvertiseWithMdnsAdvertiser_FailedWithInvalidServiceType() {
+ makeServiceWithMdnsAdvertiserEnabled();
+
+ final NsdManager client = connectClient(mService);
+ final RegistrationListener regListener = mock(RegistrationListener.class);
+ // final String serviceTypeWithLocalDomain = SERVICE_TYPE + ".local";
+ final ArgumentCaptor<MdnsAdvertiser.AdvertiserCallback> cbCaptor =
+ ArgumentCaptor.forClass(MdnsAdvertiser.AdvertiserCallback.class);
+ verify(mDeps).makeMdnsAdvertiser(any(), any(), cbCaptor.capture());
+
+ final NsdServiceInfo regInfo = new NsdServiceInfo(SERVICE_NAME, "invalid_type");
+ regInfo.setHost(parseNumericAddress("192.0.2.123"));
+ regInfo.setPort(12345);
+ regInfo.setAttribute("testattr", "testvalue");
+ regInfo.setNetwork(new Network(999));
+
+ client.registerService(regInfo, NsdManager.PROTOCOL_DNS_SD, Runnable::run, regListener);
+ waitForIdle();
+ verify(mAdvertiser, never()).addService(anyInt(), any());
+
+ verify(regListener, timeout(TIMEOUT_MS)).onRegistrationFailed(
+ argThat(info -> matches(info, regInfo)), eq(FAILURE_INTERNAL_ERROR));
+ }
+
+ @Test
+ public void testAdvertiseWithMdnsAdvertiser_LongServiceName() {
+ makeServiceWithMdnsAdvertiserEnabled();
+
+ final NsdManager client = connectClient(mService);
+ final RegistrationListener regListener = mock(RegistrationListener.class);
+ // final String serviceTypeWithLocalDomain = SERVICE_TYPE + ".local";
+ final ArgumentCaptor<MdnsAdvertiser.AdvertiserCallback> cbCaptor =
+ ArgumentCaptor.forClass(MdnsAdvertiser.AdvertiserCallback.class);
+ verify(mDeps).makeMdnsAdvertiser(any(), any(), cbCaptor.capture());
+
+ final NsdServiceInfo regInfo = new NsdServiceInfo("a".repeat(70), SERVICE_TYPE);
+ regInfo.setHost(parseNumericAddress("192.0.2.123"));
+ regInfo.setPort(12345);
+ regInfo.setAttribute("testattr", "testvalue");
+ regInfo.setNetwork(new Network(999));
+
+ client.registerService(regInfo, NsdManager.PROTOCOL_DNS_SD, Runnable::run, regListener);
+ waitForIdle();
+ final ArgumentCaptor<Integer> idCaptor = ArgumentCaptor.forClass(Integer.class);
+ // Service name is truncated to 63 characters
+ verify(mAdvertiser).addService(idCaptor.capture(),
+ argThat(info -> info.getServiceName().equals("a".repeat(63))));
+
+ // Verify onServiceRegistered callback
+ final MdnsAdvertiser.AdvertiserCallback cb = cbCaptor.getValue();
+ cb.onRegisterServiceSucceeded(idCaptor.getValue(), regInfo);
+
+ verify(regListener, timeout(TIMEOUT_MS)).onServiceRegistered(
+ argThat(info -> matches(info, new NsdServiceInfo(regInfo.getServiceName(), null))));
+ }
+
private void waitForIdle() {
HandlerUtils.waitForIdle(mHandler, TIMEOUT_MS);
}
NsdService makeService() {
- final NsdService service = new NsdService(mContext, mHandler, CLEANUP_DELAY_MS) {
+ final NsdService service = new NsdService(mContext, mHandler, CLEANUP_DELAY_MS, mDeps) {
@Override
public INsdServiceConnector connect(INsdManagerCallback baseCb) {
// Wrap the callback in a transparent mock, to mock asBinder returning a
@@ -599,6 +1144,19 @@
verify(mMockMDnsM, timeout(cleanupDelayMs + TIMEOUT_MS)).stopDaemon();
}
+ /**
+ * Return true if two service info are the same.
+ *
+ * Useful for argument matchers as {@link NsdServiceInfo} does not implement equals.
+ */
+ private boolean matches(NsdServiceInfo a, NsdServiceInfo b) {
+ return Objects.equals(a.getServiceName(), b.getServiceName())
+ && Objects.equals(a.getServiceType(), b.getServiceType())
+ && Objects.equals(a.getHost(), b.getHost())
+ && Objects.equals(a.getNetwork(), b.getNetwork())
+ && Objects.equals(a.getAttributes(), b.getAttributes());
+ }
+
public static class TestHandler extends Handler {
public Message lastMessage;
diff --git a/tests/unit/java/com/android/server/VpnManagerServiceTest.java b/tests/unit/java/com/android/server/VpnManagerServiceTest.java
index c8a93a6..deb56ef 100644
--- a/tests/unit/java/com/android/server/VpnManagerServiceTest.java
+++ b/tests/unit/java/com/android/server/VpnManagerServiceTest.java
@@ -131,6 +131,11 @@
Vpn vpn, VpnProfile profile) {
return mLockdownVpnTracker;
}
+
+ @Override
+ public @UserIdInt int getMainUserId() {
+ return UserHandle.USER_SYSTEM;
+ }
}
@Before
diff --git a/tests/unit/java/com/android/server/connectivity/AutomaticOnOffKeepaliveTrackerTest.java b/tests/unit/java/com/android/server/connectivity/AutomaticOnOffKeepaliveTrackerTest.java
new file mode 100644
index 0000000..6c29d6e
--- /dev/null
+++ b/tests/unit/java/com/android/server/connectivity/AutomaticOnOffKeepaliveTrackerTest.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.connectivity;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+
+import android.content.Context;
+import android.net.INetd;
+import android.net.MarkMaskParcel;
+import android.os.Build;
+import android.os.HandlerThread;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import com.android.testutils.DevSdkIgnoreRule;
+import com.android.testutils.DevSdkIgnoreRunner;
+
+import libcore.util.HexEncoding;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@RunWith(DevSdkIgnoreRunner.class)
+@SmallTest
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+public class AutomaticOnOffKeepaliveTrackerTest {
+ private static final int TEST_NETID = 0xA85;
+ private static final int TEST_NETID_FWMARK = 0x0A85;
+ private static final int OTHER_NETID = 0x1A85;
+ private static final int NETID_MASK = 0xffff;
+ private AutomaticOnOffKeepaliveTracker mAOOKeepaliveTracker;
+ private HandlerThread mHandlerThread;
+
+ @Mock INetd mNetd;
+ @Mock AutomaticOnOffKeepaliveTracker.Dependencies mDependencies;
+ @Mock Context mCtx;
+ @Mock KeepaliveTracker mKeepaliveTracker;
+
+ // Hexadecimal representation of a SOCK_DIAG response with tcp info.
+ private static final String SOCK_DIAG_TCP_INET_HEX =
+ // struct nlmsghdr.
+ "14010000" + // length = 276
+ "1400" + // type = SOCK_DIAG_BY_FAMILY
+ "0301" + // flags = NLM_F_REQUEST | NLM_F_DUMP
+ "00000000" + // seqno
+ "00000000" + // pid (0 == kernel)
+ // struct inet_diag_req_v2
+ "02" + // family = AF_INET
+ "06" + // state
+ "00" + // timer
+ "00" + // retrans
+ // inet_diag_sockid
+ "DEA5" + // idiag_sport = 42462
+ "71B9" + // idiag_dport = 47473
+ "0a006402000000000000000000000000" + // idiag_src = 10.0.100.2
+ "08080808000000000000000000000000" + // idiag_dst = 8.8.8.8
+ "00000000" + // idiag_if
+ "34ED000076270000" + // idiag_cookie = 43387759684916
+ "00000000" + // idiag_expires
+ "00000000" + // idiag_rqueue
+ "00000000" + // idiag_wqueue
+ "00000000" + // idiag_uid
+ "00000000" + // idiag_inode
+ // rtattr
+ "0500" + // len = 5
+ "0800" + // type = 8
+ "00000000" + // data
+ "0800" + // len = 8
+ "0F00" + // type = 15(INET_DIAG_MARK)
+ "850A0C00" + // data, socket mark=789125
+ "AC00" + // len = 172
+ "0200" + // type = 2(INET_DIAG_INFO)
+ // tcp_info
+ "01" + // state = TCP_ESTABLISHED
+ "00" + // ca_state = TCP_CA_OPEN
+ "05" + // retransmits = 5
+ "00" + // probes = 0
+ "00" + // backoff = 0
+ "07" + // option = TCPI_OPT_WSCALE|TCPI_OPT_SACK|TCPI_OPT_TIMESTAMPS
+ "88" + // wscale = 8
+ "00" + // delivery_rate_app_limited = 0
+ "4A911B00" + // rto = 1806666
+ "00000000" + // ato = 0
+ "2E050000" + // sndMss = 1326
+ "18020000" + // rcvMss = 536
+ "00000000" + // unsacked = 0
+ "00000000" + // acked = 0
+ "00000000" + // lost = 0
+ "00000000" + // retrans = 0
+ "00000000" + // fackets = 0
+ "BB000000" + // lastDataSent = 187
+ "00000000" + // lastAckSent = 0
+ "BB000000" + // lastDataRecv = 187
+ "BB000000" + // lastDataAckRecv = 187
+ "DC050000" + // pmtu = 1500
+ "30560100" + // rcvSsthresh = 87600
+ "3E2C0900" + // rttt = 601150
+ "1F960400" + // rttvar = 300575
+ "78050000" + // sndSsthresh = 1400
+ "0A000000" + // sndCwnd = 10
+ "A8050000" + // advmss = 1448
+ "03000000" + // reordering = 3
+ "00000000" + // rcvrtt = 0
+ "30560100" + // rcvspace = 87600
+ "00000000" + // totalRetrans = 0
+ "53AC000000000000" + // pacingRate = 44115
+ "FFFFFFFFFFFFFFFF" + // maxPacingRate = 18446744073709551615
+ "0100000000000000" + // bytesAcked = 1
+ "0000000000000000" + // bytesReceived = 0
+ "0A000000" + // SegsOut = 10
+ "00000000" + // SegsIn = 0
+ "00000000" + // NotSentBytes = 0
+ "3E2C0900" + // minRtt = 601150
+ "00000000" + // DataSegsIn = 0
+ "00000000" + // DataSegsOut = 0
+ "0000000000000000"; // deliverRate = 0
+ private static final String SOCK_DIAG_NO_TCP_INET_HEX =
+ // struct nlmsghdr
+ "14000000" // length = 20
+ + "0300" // type = NLMSG_DONE
+ + "0301" // flags = NLM_F_REQUEST | NLM_F_DUMP
+ + "00000000" // seqno
+ + "00000000" // pid (0 == kernel)
+ // struct inet_diag_req_v2
+ + "02" // family = AF_INET
+ + "06" // state
+ + "00" // timer
+ + "00"; // retrans
+ private static final byte[] SOCK_DIAG_NO_TCP_INET_BYTES =
+ HexEncoding.decode(SOCK_DIAG_NO_TCP_INET_HEX.toCharArray(), false);
+ private static final String TEST_RESPONSE_HEX =
+ SOCK_DIAG_TCP_INET_HEX + SOCK_DIAG_NO_TCP_INET_HEX;
+ private static final byte[] TEST_RESPONSE_BYTES =
+ HexEncoding.decode(TEST_RESPONSE_HEX.toCharArray(), false);
+
+ @Before
+ public void setup() throws Exception {
+ MockitoAnnotations.initMocks(this);
+
+ doReturn(mNetd).when(mDependencies).getNetd();
+ doReturn(makeMarkMaskParcel(NETID_MASK, TEST_NETID_FWMARK)).when(mNetd)
+ .getFwmarkForNetwork(TEST_NETID);
+
+ doNothing().when(mDependencies).sendRequest(any(), any());
+
+ mHandlerThread = new HandlerThread("KeepaliveTrackerTest");
+ mHandlerThread.start();
+ doReturn(mKeepaliveTracker).when(mDependencies).newKeepaliveTracker(
+ mCtx, mHandlerThread.getThreadHandler());
+ doReturn(true).when(mDependencies).isFeatureEnabled(any());
+ mAOOKeepaliveTracker = new AutomaticOnOffKeepaliveTracker(
+ mCtx, mHandlerThread.getThreadHandler(), mDependencies);
+ }
+
+ @Test
+ public void testIsAnyTcpSocketConnected_runOnNonHandlerThread() throws Exception {
+ setupResponseWithSocketExisting();
+ assertThrows(IllegalStateException.class,
+ () -> mAOOKeepaliveTracker.isAnyTcpSocketConnected(TEST_NETID));
+ }
+
+ @Test
+ public void testIsAnyTcpSocketConnected_withTargetNetId() throws Exception {
+ setupResponseWithSocketExisting();
+ mHandlerThread.getThreadHandler().post(
+ () -> assertTrue(mAOOKeepaliveTracker.isAnyTcpSocketConnected(TEST_NETID)));
+ }
+
+ @Test
+ public void testIsAnyTcpSocketConnected_withIncorrectNetId() throws Exception {
+ setupResponseWithSocketExisting();
+ mHandlerThread.getThreadHandler().post(
+ () -> assertFalse(mAOOKeepaliveTracker.isAnyTcpSocketConnected(OTHER_NETID)));
+ }
+
+ @Test
+ public void testIsAnyTcpSocketConnected_noSocketExists() throws Exception {
+ setupResponseWithoutSocketExisting();
+ mHandlerThread.getThreadHandler().post(
+ () -> assertFalse(mAOOKeepaliveTracker.isAnyTcpSocketConnected(TEST_NETID)));
+ }
+
+ private void setupResponseWithSocketExisting() throws Exception {
+ final ByteBuffer tcpBufferV6 = getByteBuffer(TEST_RESPONSE_BYTES);
+ final ByteBuffer tcpBufferV4 = getByteBuffer(TEST_RESPONSE_BYTES);
+ doReturn(tcpBufferV6, tcpBufferV4).when(mDependencies).recvSockDiagResponse(any());
+ }
+
+ private void setupResponseWithoutSocketExisting() throws Exception {
+ final ByteBuffer tcpBufferV6 = getByteBuffer(SOCK_DIAG_NO_TCP_INET_BYTES);
+ final ByteBuffer tcpBufferV4 = getByteBuffer(SOCK_DIAG_NO_TCP_INET_BYTES);
+ doReturn(tcpBufferV6, tcpBufferV4).when(mDependencies).recvSockDiagResponse(any());
+ }
+
+ private MarkMaskParcel makeMarkMaskParcel(final int mask, final int mark) {
+ final MarkMaskParcel parcel = new MarkMaskParcel();
+ parcel.mask = mask;
+ parcel.mark = mark;
+ return parcel;
+ }
+
+ private ByteBuffer getByteBuffer(final byte[] bytes) {
+ final ByteBuffer buffer = ByteBuffer.wrap(bytes);
+ buffer.order(ByteOrder.nativeOrder());
+ return buffer;
+ }
+}
diff --git a/tests/unit/java/com/android/server/connectivity/PermissionMonitorTest.java b/tests/unit/java/com/android/server/connectivity/PermissionMonitorTest.java
index 8076edb..cf02e3a 100644
--- a/tests/unit/java/com/android/server/connectivity/PermissionMonitorTest.java
+++ b/tests/unit/java/com/android/server/connectivity/PermissionMonitorTest.java
@@ -46,7 +46,6 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.AdditionalMatchers.aryEq;
import static org.mockito.ArgumentMatchers.any;
@@ -844,7 +843,6 @@
// When VPN is disconnected, expect rules to be torn down
mPermissionMonitor.onVpnUidRangesRemoved(ifName, vpnRange2, VPN_UID);
verify(mBpfNetMaps).removeUidInterfaceRules(aryEq(new int[] {MOCK_UID12}));
- assertNull(mPermissionMonitor.getVpnInterfaceUidRanges(ifName));
}
@Test
@@ -915,7 +913,6 @@
verify(mBpfNetMaps, times(2)).updateUidLockdownRule(anyInt(), eq(true) /* add */);
verify(mBpfNetMaps).updateUidLockdownRule(MOCK_UID11, true /* add */);
verify(mBpfNetMaps).updateUidLockdownRule(VPN_UID, true /* add */);
- assertEquals(mPermissionMonitor.getVpnLockdownUidRanges(), Set.of(lockdownRange));
reset(mBpfNetMaps);
@@ -924,7 +921,6 @@
verify(mBpfNetMaps, times(2)).updateUidLockdownRule(anyInt(), eq(false) /* add */);
verify(mBpfNetMaps).updateUidLockdownRule(MOCK_UID11, false /* add */);
verify(mBpfNetMaps).updateUidLockdownRule(VPN_UID, false /* add */);
- assertTrue(mPermissionMonitor.getVpnLockdownUidRanges().isEmpty());
}
@Test
@@ -944,7 +940,6 @@
mPermissionMonitor.updateVpnLockdownUidRanges(true /* add */, lockdownRange);
verify(mBpfNetMaps).updateUidLockdownRule(anyInt(), eq(true) /* add */);
verify(mBpfNetMaps).updateUidLockdownRule(MOCK_UID11, true /* add */);
- assertEquals(mPermissionMonitor.getVpnLockdownUidRanges(), Set.of(lockdownRange));
reset(mBpfNetMaps);
@@ -952,7 +947,6 @@
// already has the rule
mPermissionMonitor.updateVpnLockdownUidRanges(true /* add */, lockdownRange);
verify(mBpfNetMaps, never()).updateUidLockdownRule(anyInt(), anyBoolean());
- assertEquals(mPermissionMonitor.getVpnLockdownUidRanges(), Set.of(lockdownRange));
reset(mBpfNetMaps);
@@ -960,7 +954,6 @@
// the range 2 times.
mPermissionMonitor.updateVpnLockdownUidRanges(false /* add */, lockdownRange);
verify(mBpfNetMaps, never()).updateUidLockdownRule(anyInt(), anyBoolean());
- assertEquals(mPermissionMonitor.getVpnLockdownUidRanges(), Set.of(lockdownRange));
reset(mBpfNetMaps);
@@ -969,7 +962,6 @@
mPermissionMonitor.updateVpnLockdownUidRanges(false /* add */, lockdownRange);
verify(mBpfNetMaps).updateUidLockdownRule(anyInt(), eq(false) /* add */);
verify(mBpfNetMaps).updateUidLockdownRule(MOCK_UID11, false /* add */);
- assertTrue(mPermissionMonitor.getVpnLockdownUidRanges().isEmpty());
}
@Test
@@ -990,7 +982,6 @@
mPermissionMonitor.updateVpnLockdownUidRanges(true /* add */, lockdownRangeDuplicates);
verify(mBpfNetMaps).updateUidLockdownRule(anyInt(), eq(true) /* add */);
verify(mBpfNetMaps).updateUidLockdownRule(MOCK_UID11, true /* add */);
- assertEquals(mPermissionMonitor.getVpnLockdownUidRanges(), Set.of(lockdownRange));
reset(mBpfNetMaps);
@@ -998,7 +989,6 @@
// ranges we added contains duplicated uid ranges.
mPermissionMonitor.updateVpnLockdownUidRanges(false /* add */, lockdownRange);
verify(mBpfNetMaps, never()).updateUidLockdownRule(anyInt(), anyBoolean());
- assertEquals(mPermissionMonitor.getVpnLockdownUidRanges(), Set.of(lockdownRange));
reset(mBpfNetMaps);
@@ -1006,7 +996,6 @@
mPermissionMonitor.updateVpnLockdownUidRanges(false /* add */, lockdownRange);
verify(mBpfNetMaps).updateUidLockdownRule(anyInt(), eq(false) /* add */);
verify(mBpfNetMaps).updateUidLockdownRule(MOCK_UID11, false /* add */);
- assertTrue(mPermissionMonitor.getVpnLockdownUidRanges().isEmpty());
}
@Test
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt
index e2babb1..1febe6d 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt
@@ -38,6 +38,7 @@
import org.mockito.Mockito.any
import org.mockito.Mockito.anyInt
import org.mockito.Mockito.argThat
+import org.mockito.Mockito.atLeastOnce
import org.mockito.Mockito.doReturn
import org.mockito.Mockito.mock
import org.mockito.Mockito.never
@@ -161,6 +162,60 @@
verify(socketProvider).unrequestSocket(socketCb)
}
+ @Test
+ fun testAddService_Conflicts() {
+ val advertiser = MdnsAdvertiser(thread.looper, socketProvider, cb, mockDeps)
+ postSync { advertiser.addService(SERVICE_ID_1, SERVICE_1) }
+
+ val oneNetSocketCbCaptor = ArgumentCaptor.forClass(SocketCallback::class.java)
+ verify(socketProvider).requestSocket(eq(TEST_NETWORK_1), oneNetSocketCbCaptor.capture())
+ val oneNetSocketCb = oneNetSocketCbCaptor.value
+
+ // Register a service with the same name on all networks (name conflict)
+ postSync { advertiser.addService(SERVICE_ID_2, ALL_NETWORKS_SERVICE) }
+ val allNetSocketCbCaptor = ArgumentCaptor.forClass(SocketCallback::class.java)
+ verify(socketProvider).requestSocket(eq(null), allNetSocketCbCaptor.capture())
+ val allNetSocketCb = allNetSocketCbCaptor.value
+
+ // Callbacks for matching network and all networks both get the socket
+ postSync {
+ oneNetSocketCb.onSocketCreated(TEST_NETWORK_1, mockSocket1, listOf(TEST_LINKADDR))
+ allNetSocketCb.onSocketCreated(TEST_NETWORK_1, mockSocket1, listOf(TEST_LINKADDR))
+ }
+
+ val expectedRenamed = NsdServiceInfo(
+ "${ALL_NETWORKS_SERVICE.serviceName} (2)", ALL_NETWORKS_SERVICE.serviceType).apply {
+ port = ALL_NETWORKS_SERVICE.port
+ host = ALL_NETWORKS_SERVICE.host
+ network = ALL_NETWORKS_SERVICE.network
+ }
+
+ val intAdvCbCaptor = ArgumentCaptor.forClass(MdnsInterfaceAdvertiser.Callback::class.java)
+ verify(mockDeps).makeAdvertiser(eq(mockSocket1), eq(listOf(TEST_LINKADDR)),
+ eq(thread.looper), any(), intAdvCbCaptor.capture())
+ verify(mockInterfaceAdvertiser1).addService(eq(SERVICE_ID_1),
+ argThat { it.matches(SERVICE_1) })
+ verify(mockInterfaceAdvertiser1).addService(eq(SERVICE_ID_2),
+ argThat { it.matches(expectedRenamed) })
+
+ doReturn(false).`when`(mockInterfaceAdvertiser1).isProbing(SERVICE_ID_1)
+ postSync { intAdvCbCaptor.value.onRegisterServiceSucceeded(
+ mockInterfaceAdvertiser1, SERVICE_ID_1) }
+ verify(cb).onRegisterServiceSucceeded(eq(SERVICE_ID_1), argThat { it.matches(SERVICE_1) })
+
+ doReturn(false).`when`(mockInterfaceAdvertiser1).isProbing(SERVICE_ID_2)
+ postSync { intAdvCbCaptor.value.onRegisterServiceSucceeded(
+ mockInterfaceAdvertiser1, SERVICE_ID_2) }
+ verify(cb).onRegisterServiceSucceeded(eq(SERVICE_ID_2),
+ argThat { it.matches(expectedRenamed) })
+
+ postSync { oneNetSocketCb.onInterfaceDestroyed(TEST_NETWORK_1, mockSocket1) }
+ postSync { allNetSocketCb.onInterfaceDestroyed(TEST_NETWORK_1, mockSocket1) }
+
+ // destroyNow can be called multiple times
+ verify(mockInterfaceAdvertiser1, atLeastOnce()).destroyNow()
+ }
+
private fun postSync(r: () -> Unit) {
handler.post(r)
handler.waitForIdle(TIMEOUT_MS)
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsAnnouncerTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsAnnouncerTest.kt
index 961f0f0..6c3f729 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsAnnouncerTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsAnnouncerTest.kt
@@ -22,11 +22,11 @@
import android.os.SystemClock
import com.android.internal.util.HexDump
import com.android.server.connectivity.mdns.MdnsAnnouncer.AnnouncementInfo
+import com.android.server.connectivity.mdns.MdnsAnnouncer.BaseAnnouncementInfo
+import com.android.server.connectivity.mdns.MdnsRecordRepository.getReverseDnsAddress
import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo
import com.android.testutils.DevSdkIgnoreRunner
import java.net.DatagramPacket
-import java.net.Inet6Address
-import java.net.InetAddress
import kotlin.test.assertEquals
import kotlin.test.assertTrue
import org.junit.After
@@ -68,7 +68,7 @@
private class TestAnnouncementInfo(
announcedRecords: List<MdnsRecord>,
additionalRecords: List<MdnsRecord>
- ) : AnnouncementInfo(announcedRecords, additionalRecords) {
+ ) : AnnouncementInfo(1 /* serviceId */, announcedRecords, additionalRecords) {
override fun getDelayMs(nextIndex: Int) =
if (nextIndex < FIRST_ANNOUNCES_COUNT) {
FIRST_ANNOUNCES_DELAY
@@ -79,10 +79,10 @@
@Test
fun testAnnounce() {
- val replySender = MdnsReplySender(thread.looper, socket, buffer)
+ val replySender = MdnsReplySender("testiface", thread.looper, socket, buffer)
@Suppress("UNCHECKED_CAST")
val cb = mock(MdnsPacketRepeater.PacketRepeaterCallback::class.java)
- as MdnsPacketRepeater.PacketRepeaterCallback<AnnouncementInfo>
+ as MdnsPacketRepeater.PacketRepeaterCallback<BaseAnnouncementInfo>
val announcer = MdnsAnnouncer("testiface", thread.looper, replySender, cb)
/*
The expected packet replicates records announced when registering a service, as observed in
@@ -91,7 +91,7 @@
scapy.raw(scapy.dns_compress(scapy.DNS(rd=0, qr=1, aa=1,
qd = None,
an =
- scapy.DNSRR(type='PTR', rrname='123.0.2.192.in-addr.arpa.', rdata='Android.local',
+ scapy.DNSRR(type='PTR', rrname='123.2.0.192.in-addr.arpa.', rdata='Android.local',
rclass=0x8001, ttl=120) /
scapy.DNSRR(type='PTR',
rrname='3.2.1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.B.D.0.1.0.0.2.ip6.arpa',
@@ -111,8 +111,8 @@
scapy.DNSRR(type='AAAA', rrname='Android.local', rclass=0x8001, rdata='2001:db8::456',
ttl=120),
ar =
- scapy.DNSRRNSEC(rrname='123.0.2.192.in-addr.arpa.', rclass=0x8001, ttl=120,
- nextname='123.0.2.192.in-addr.arpa.', typebitmaps=[12]) /
+ scapy.DNSRRNSEC(rrname='123.2.0.192.in-addr.arpa.', rclass=0x8001, ttl=120,
+ nextname='123.2.0.192.in-addr.arpa.', typebitmaps=[12]) /
scapy.DNSRRNSEC(
rrname='3.2.1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.B.D.0.1.0.0.2.ip6.arpa',
rclass=0x8001, ttl=120,
@@ -131,7 +131,7 @@
typebitmaps=[1, 28]))
)).hex().upper()
*/
- val expected = "00008400000000090000000503313233013001320331393207696E2D61646472046172706" +
+ val expected = "00008400000000090000000503313233013201300331393207696E2D61646472046172706" +
"100000C800100000078000F07416E64726F6964056C6F63616C00013301320131013001300130013" +
"00130013001300130013001300130013001300130013001300130013001300130013001380142014" +
"40130013101300130013203697036C020000C8001000000780002C030013601350134C045000C800" +
@@ -149,9 +149,9 @@
val v4Addr = parseNumericAddress("192.0.2.123")
val v6Addr1 = parseNumericAddress("2001:DB8::123")
val v6Addr2 = parseNumericAddress("2001:DB8::456")
- val v4AddrRev = arrayOf("123", "0", "2", "192", "in-addr", "arpa")
- val v6Addr1Rev = getReverseV6AddressName(v6Addr1)
- val v6Addr2Rev = getReverseV6AddressName(v6Addr2)
+ val v4AddrRev = getReverseDnsAddress(v4Addr)
+ val v6Addr1Rev = getReverseDnsAddress(v6Addr1)
+ val v6Addr2Rev = getReverseDnsAddress(v6Addr2)
val announcedRecords = listOf(
// Reverse address records
@@ -254,7 +254,10 @@
verify(socket, atLeast(i + 1)).send(any())
val now = SystemClock.elapsedRealtime()
assertTrue(now > timeStart + startDelay + i * FIRST_ANNOUNCES_DELAY)
- assertTrue(now < timeStart + startDelay + (i + 1) * FIRST_ANNOUNCES_DELAY)
+ // Loops can be much slower than the expected timing (>100ms delay), use
+ // TEST_TIMEOUT_MS as tolerance.
+ assertTrue(now < timeStart + startDelay + (i + 1) * FIRST_ANNOUNCES_DELAY +
+ TEST_TIMEOUT_MS)
}
// Subsequent announces should happen quickly (NEXT_ANNOUNCES_DELAY)
@@ -267,13 +270,3 @@
}
}
}
-
-/**
- * Compute 2001:db8::1 --> 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.B.D.1.0.0.2.ip6.arpa
- */
-private fun getReverseV6AddressName(addr: InetAddress): Array<String> {
- assertTrue(addr is Inet6Address)
- return addr.address.flatMapTo(mutableListOf("arpa", "ip6")) {
- HexDump.toHexString(it).toCharArray().map(Char::toString)
- }.reversed().toTypedArray()
-}
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiserTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiserTest.kt
index ad22305..4a806b1 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiserTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiserTest.kt
@@ -21,13 +21,20 @@
import android.net.nsd.NsdServiceInfo
import android.os.Build
import android.os.HandlerThread
+import com.android.net.module.util.HexDump
import com.android.server.connectivity.mdns.MdnsAnnouncer.AnnouncementInfo
+import com.android.server.connectivity.mdns.MdnsAnnouncer.BaseAnnouncementInfo
+import com.android.server.connectivity.mdns.MdnsAnnouncer.ExitAnnouncementInfo
import com.android.server.connectivity.mdns.MdnsInterfaceAdvertiser.EXIT_ANNOUNCEMENT_DELAY_MS
import com.android.server.connectivity.mdns.MdnsPacketRepeater.PacketRepeaterCallback
import com.android.server.connectivity.mdns.MdnsProber.ProbingInfo
import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo
import com.android.testutils.DevSdkIgnoreRunner
import com.android.testutils.waitForIdle
+import java.net.InetSocketAddress
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
import org.junit.After
import org.junit.Before
import org.junit.Test
@@ -35,8 +42,12 @@
import org.mockito.ArgumentCaptor
import org.mockito.Mockito.any
import org.mockito.Mockito.anyInt
+import org.mockito.Mockito.anyString
+import org.mockito.Mockito.doAnswer
import org.mockito.Mockito.doReturn
+import org.mockito.Mockito.eq
import org.mockito.Mockito.mock
+import org.mockito.Mockito.times
import org.mockito.Mockito.verify
private const val LOG_TAG = "testlogtag"
@@ -63,13 +74,18 @@
private val replySender = mock(MdnsReplySender::class.java)
private val announcer = mock(MdnsAnnouncer::class.java)
private val prober = mock(MdnsProber::class.java)
+ @Suppress("UNCHECKED_CAST")
private val probeCbCaptor = ArgumentCaptor.forClass(PacketRepeaterCallback::class.java)
as ArgumentCaptor<PacketRepeaterCallback<ProbingInfo>>
+ @Suppress("UNCHECKED_CAST")
private val announceCbCaptor = ArgumentCaptor.forClass(PacketRepeaterCallback::class.java)
- as ArgumentCaptor<PacketRepeaterCallback<AnnouncementInfo>>
+ as ArgumentCaptor<PacketRepeaterCallback<BaseAnnouncementInfo>>
+ private val packetHandlerCaptor = ArgumentCaptor.forClass(
+ MulticastPacketReader.PacketHandler::class.java)
private val probeCb get() = probeCbCaptor.value
private val announceCb get() = announceCbCaptor.value
+ private val packetHandler get() = packetHandlerCaptor.value
private val advertiser by lazy {
MdnsInterfaceAdvertiser(LOG_TAG, socket, TEST_ADDRS, thread.looper, TEST_BUFFER, cb, deps)
@@ -78,14 +94,29 @@
@Before
fun setUp() {
doReturn(repository).`when`(deps).makeRecordRepository(any())
- doReturn(replySender).`when`(deps).makeReplySender(any(), any(), any())
- doReturn(announcer).`when`(deps).makeMdnsAnnouncer(any(), any(), any(), any())
- doReturn(prober).`when`(deps).makeMdnsProber(any(), any(), any(), any())
+ doReturn(replySender).`when`(deps).makeReplySender(anyString(), any(), any(), any())
+ doReturn(announcer).`when`(deps).makeMdnsAnnouncer(anyString(), any(), any(), any())
+ doReturn(prober).`when`(deps).makeMdnsProber(anyString(), any(), any(), any())
- doReturn(-1).`when`(repository).addService(anyInt(), any())
+ val knownServices = mutableSetOf<Int>()
+ doAnswer { inv ->
+ knownServices.add(inv.getArgument(0))
+ -1
+ }.`when`(repository).addService(anyInt(), any())
+ doAnswer { inv ->
+ knownServices.remove(inv.getArgument(0))
+ null
+ }.`when`(repository).removeService(anyInt())
+ doAnswer {
+ knownServices.toIntArray().also { knownServices.clear() }
+ }.`when`(repository).clearServices()
+ doAnswer { inv ->
+ knownServices.contains(inv.getArgument(0))
+ }.`when`(repository).hasActiveService(anyInt())
thread.start()
advertiser.start()
+ verify(socket).addPacketHandler(packetHandlerCaptor.capture())
verify(deps).makeMdnsProber(any(), any(), any(), probeCbCaptor.capture())
verify(deps).makeMdnsAnnouncer(any(), any(), any(), announceCbCaptor.capture())
}
@@ -97,18 +128,7 @@
@Test
fun testAddRemoveService() {
- val testProbingInfo = mock(ProbingInfo::class.java)
- doReturn(TEST_SERVICE_ID_1).`when`(testProbingInfo).serviceId
- doReturn(testProbingInfo).`when`(repository).setServiceProbing(TEST_SERVICE_ID_1)
-
- advertiser.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
- verify(repository).addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
- verify(prober).startProbing(testProbingInfo)
-
- // Simulate probing success: continues to announcing
- val testAnnouncementInfo = mock(AnnouncementInfo::class.java)
- doReturn(testAnnouncementInfo).`when`(repository).onProbingSucceeded(testProbingInfo)
- probeCb.onFinished(testProbingInfo)
+ val testAnnouncementInfo = addServiceAndFinishProbing(TEST_SERVICE_ID_1, TEST_SERVICE_1)
verify(announcer).startSending(TEST_SERVICE_ID_1, testAnnouncementInfo,
0L /* initialDelayMs */)
@@ -117,13 +137,139 @@
verify(cb).onRegisterServiceSucceeded(advertiser, TEST_SERVICE_ID_1)
// Remove the service: expect exit announcements
- val testExitInfo = mock(AnnouncementInfo::class.java)
+ val testExitInfo = mock(ExitAnnouncementInfo::class.java)
doReturn(testExitInfo).`when`(repository).exitService(TEST_SERVICE_ID_1)
advertiser.removeService(TEST_SERVICE_ID_1)
+ verify(prober).stop(TEST_SERVICE_ID_1)
+ verify(announcer).stop(TEST_SERVICE_ID_1)
verify(announcer).startSending(TEST_SERVICE_ID_1, testExitInfo, EXIT_ANNOUNCEMENT_DELAY_MS)
- // TODO: after exit announcements are implemented, verify that announceCb.onFinished causes
- // cb.onDestroyed to be called.
+ // Exit announcements finish: the advertiser has no left service and destroys itself
+ announceCb.onFinished(testExitInfo)
+ thread.waitForIdle(TIMEOUT_MS)
+ verify(cb).onDestroyed(socket)
+ }
+
+ @Test
+ fun testDoubleRemove() {
+ addServiceAndFinishProbing(TEST_SERVICE_ID_1, TEST_SERVICE_1)
+
+ val testExitInfo = mock(ExitAnnouncementInfo::class.java)
+ doReturn(testExitInfo).`when`(repository).exitService(TEST_SERVICE_ID_1)
+ advertiser.removeService(TEST_SERVICE_ID_1)
+
+ verify(prober).stop(TEST_SERVICE_ID_1)
+ verify(announcer).stop(TEST_SERVICE_ID_1)
+ verify(announcer).startSending(TEST_SERVICE_ID_1, testExitInfo, EXIT_ANNOUNCEMENT_DELAY_MS)
+
+ doReturn(false).`when`(repository).hasActiveService(TEST_SERVICE_ID_1)
+ advertiser.removeService(TEST_SERVICE_ID_1)
+ // Prober, announcer were still stopped only one time
+ verify(prober, times(1)).stop(TEST_SERVICE_ID_1)
+ verify(announcer, times(1)).stop(TEST_SERVICE_ID_1)
+ }
+
+ @Test
+ fun testReplyToQuery() {
+ addServiceAndFinishProbing(TEST_SERVICE_ID_1, TEST_SERVICE_1)
+
+ val mockReply = mock(MdnsRecordRepository.ReplyInfo::class.java)
+ doReturn(mockReply).`when`(repository).getReply(any(), any())
+
+ // Query obtained with:
+ // scapy.raw(scapy.DNS(
+ // qd = scapy.DNSQR(qtype='PTR', qname='_testservice._tcp.local'))
+ // ).hex().upper()
+ val query = HexDump.hexStringToByteArray(
+ "0000010000010000000000000C5F7465737473657276696365045F746370056C6F63616C00000C0001"
+ )
+ val src = InetSocketAddress(parseNumericAddress("2001:db8::456"), MdnsConstants.MDNS_PORT)
+ packetHandler.handlePacket(query, query.size, src)
+
+ val packetCaptor = ArgumentCaptor.forClass(MdnsPacket::class.java)
+ verify(repository).getReply(packetCaptor.capture(), eq(src))
+
+ packetCaptor.value.let {
+ assertEquals(1, it.questions.size)
+ assertEquals(0, it.answers.size)
+ assertEquals(0, it.authorityRecords.size)
+ assertEquals(0, it.additionalRecords.size)
+
+ assertTrue(it.questions[0] is MdnsPointerRecord)
+ assertContentEquals(arrayOf("_testservice", "_tcp", "local"), it.questions[0].name)
+ }
+
+ verify(replySender).queueReply(mockReply)
+ }
+
+ @Test
+ fun testConflict() {
+ addServiceAndFinishProbing(TEST_SERVICE_ID_1, TEST_SERVICE_1)
+ doReturn(setOf(TEST_SERVICE_ID_1)).`when`(repository).getConflictingServices(any())
+
+ // Reply obtained with:
+ // scapy.raw(scapy.DNS(
+ // qd = None,
+ // an = scapy.DNSRR(type='TXT', rrname='_testservice._tcp.local'))
+ // ).hex().upper()
+ val query = HexDump.hexStringToByteArray("0000010000000001000000000C5F7465737473657276696" +
+ "365045F746370056C6F63616C0000100001000000000000")
+ val src = InetSocketAddress(parseNumericAddress("2001:db8::456"), MdnsConstants.MDNS_PORT)
+ packetHandler.handlePacket(query, query.size, src)
+
+ val packetCaptor = ArgumentCaptor.forClass(MdnsPacket::class.java)
+ verify(repository).getConflictingServices(packetCaptor.capture())
+
+ packetCaptor.value.let {
+ assertEquals(0, it.questions.size)
+ assertEquals(1, it.answers.size)
+ assertEquals(0, it.authorityRecords.size)
+ assertEquals(0, it.additionalRecords.size)
+
+ assertTrue(it.answers[0] is MdnsTextRecord)
+ assertContentEquals(arrayOf("_testservice", "_tcp", "local"), it.answers[0].name)
+ }
+
+ thread.waitForIdle(TIMEOUT_MS)
+ verify(cb).onServiceConflict(advertiser, TEST_SERVICE_ID_1)
+ }
+
+ @Test
+ fun testRestartProbingForConflict() {
+ val mockProbingInfo = mock(ProbingInfo::class.java)
+ doReturn(mockProbingInfo).`when`(repository).setServiceProbing(TEST_SERVICE_ID_1)
+
+ advertiser.restartProbingForConflict(TEST_SERVICE_ID_1)
+
+ verify(prober).restartForConflict(mockProbingInfo)
+ }
+
+ @Test
+ fun testRenameServiceForConflict() {
+ val mockProbingInfo = mock(ProbingInfo::class.java)
+ doReturn(mockProbingInfo).`when`(repository).renameServiceForConflict(
+ TEST_SERVICE_ID_1, TEST_SERVICE_1)
+
+ advertiser.renameServiceForConflict(TEST_SERVICE_ID_1, TEST_SERVICE_1)
+
+ verify(prober).restartForConflict(mockProbingInfo)
+ }
+
+ private fun addServiceAndFinishProbing(serviceId: Int, serviceInfo: NsdServiceInfo):
+ AnnouncementInfo {
+ val testProbingInfo = mock(ProbingInfo::class.java)
+ doReturn(serviceId).`when`(testProbingInfo).serviceId
+ doReturn(testProbingInfo).`when`(repository).setServiceProbing(serviceId)
+
+ advertiser.addService(serviceId, serviceInfo)
+ verify(repository).addService(serviceId, serviceInfo)
+ verify(prober).startProbing(testProbingInfo)
+
+ // Simulate probing success: continues to announcing
+ val testAnnouncementInfo = mock(AnnouncementInfo::class.java)
+ doReturn(testAnnouncementInfo).`when`(repository).onProbingSucceeded(testProbingInfo)
+ probeCb.onFinished(testProbingInfo)
+ return testAnnouncementInfo
}
}
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsPacketTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsPacketTest.kt
new file mode 100644
index 0000000..f88da1f
--- /dev/null
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsPacketTest.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.connectivity.mdns
+
+import android.net.InetAddresses
+import com.android.net.module.util.HexDump
+import com.android.testutils.DevSdkIgnoreRunner
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(DevSdkIgnoreRunner::class)
+class MdnsPacketTest {
+ @Test
+ fun testParseQuery() {
+ // Probe packet with 1 question for Android.local, and 4 additionalRecords with 4 addresses
+ // for Android.local (similar to legacy mdnsresponder probes, although it used to put 4
+ // identical questions(!!) for Android.local when there were 4 addresses).
+ val packetHex = "00000000000100000004000007416e64726f6964056c6f63616c0000ff0001c00c000100" +
+ "01000000780004c000027bc00c001c000100000078001020010db8000000000000000000000123c0" +
+ "0c001c000100000078001020010db8000000000000000000000456c00c001c000100000078001020" +
+ "010db8000000000000000000000789"
+
+ val bytes = HexDump.hexStringToByteArray(packetHex)
+ val reader = MdnsPacketReader(bytes, bytes.size)
+ val packet = MdnsPacket.parse(reader)
+
+ assertEquals(1, packet.questions.size)
+ assertEquals(0, packet.answers.size)
+ assertEquals(4, packet.authorityRecords.size)
+ assertEquals(0, packet.additionalRecords.size)
+
+ val hostname = arrayOf("Android", "local")
+ packet.questions[0].let {
+ assertTrue(it is MdnsAnyRecord)
+ assertContentEquals(hostname, it.name)
+ }
+
+ packet.authorityRecords.forEach {
+ assertTrue(it is MdnsInetAddressRecord)
+ assertContentEquals(hostname, it.name)
+ assertEquals(120000, it.ttl)
+ }
+
+ assertEquals(InetAddresses.parseNumericAddress("192.0.2.123"),
+ (packet.authorityRecords[0] as MdnsInetAddressRecord).inet4Address)
+ assertEquals(InetAddresses.parseNumericAddress("2001:db8::123"),
+ (packet.authorityRecords[1] as MdnsInetAddressRecord).inet6Address)
+ assertEquals(InetAddresses.parseNumericAddress("2001:db8::456"),
+ (packet.authorityRecords[2] as MdnsInetAddressRecord).inet6Address)
+ assertEquals(InetAddresses.parseNumericAddress("2001:db8::789"),
+ (packet.authorityRecords[3] as MdnsInetAddressRecord).inet6Address)
+ }
+}
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsProberTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsProberTest.kt
index 3caa97d..a2dbbc6 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsProberTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsProberTest.kt
@@ -114,7 +114,7 @@
@Test
fun testProbe() {
- val replySender = MdnsReplySender(thread.looper, socket, buffer)
+ val replySender = MdnsReplySender("testiface", thread.looper, socket, buffer)
val prober = TestProber(thread.looper, replySender, cb)
val probeInfo = TestProbeInfo(
listOf(makeServiceRecord(TEST_SERVICE_NAME_1, 37890)))
@@ -129,7 +129,7 @@
@Test
fun testProbeMultipleRecords() {
- val replySender = MdnsReplySender(thread.looper, socket, buffer)
+ val replySender = MdnsReplySender("testiface", thread.looper, socket, buffer)
val prober = TestProber(thread.looper, replySender, cb)
val probeInfo = TestProbeInfo(listOf(
makeServiceRecord(TEST_SERVICE_NAME_1, 37890),
@@ -167,7 +167,7 @@
@Test
fun testStopProbing() {
- val replySender = MdnsReplySender(thread.looper, socket, buffer)
+ val replySender = MdnsReplySender("testiface", thread.looper, socket, buffer)
val prober = TestProber(thread.looper, replySender, cb)
val probeInfo = TestProbeInfo(
listOf(makeServiceRecord(TEST_SERVICE_NAME_1, 37890)),
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsRecordRepositoryTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsRecordRepositoryTest.kt
index 502a36a..ecc11ec 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsRecordRepositoryTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsRecordRepositoryTest.kt
@@ -17,17 +17,23 @@
package com.android.server.connectivity.mdns
import android.net.InetAddresses.parseNumericAddress
+import android.net.LinkAddress
import android.net.nsd.NsdServiceInfo
import android.os.Build
import android.os.HandlerThread
+import com.android.server.connectivity.mdns.MdnsAnnouncer.AnnouncementInfo
import com.android.server.connectivity.mdns.MdnsRecordRepository.Dependencies
+import com.android.server.connectivity.mdns.MdnsRecordRepository.getReverseDnsAddress
+import com.android.server.connectivity.mdns.MdnsServiceInfo.TextEntry
import com.android.testutils.DevSdkIgnoreRule
import com.android.testutils.DevSdkIgnoreRunner
+import java.net.InetSocketAddress
import java.net.NetworkInterface
import java.util.Collections
import kotlin.test.assertContentEquals
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
+import kotlin.test.assertFalse
import kotlin.test.assertNotNull
import kotlin.test.assertTrue
import org.junit.After
@@ -39,10 +45,10 @@
private const val TEST_SERVICE_ID_2 = 43
private const val TEST_PORT = 12345
private val TEST_HOSTNAME = arrayOf("Android_000102030405060708090A0B0C0D0E0F", "local")
-private val TEST_ADDRESSES = arrayOf(
- parseNumericAddress("192.0.2.111"),
- parseNumericAddress("2001:db8::111"),
- parseNumericAddress("2001:db8::222"))
+private val TEST_ADDRESSES = listOf(
+ LinkAddress(parseNumericAddress("192.0.2.111"), 24),
+ LinkAddress(parseNumericAddress("2001:db8::111"), 64),
+ LinkAddress(parseNumericAddress("2001:db8::222"), 64))
private val TEST_SERVICE_1 = NsdServiceInfo().apply {
serviceType = "_testservice._tcp"
@@ -50,6 +56,12 @@
port = TEST_PORT
}
+private val TEST_SERVICE_2 = NsdServiceInfo().apply {
+ serviceType = "_testservice._tcp"
+ serviceName = "MyOtherTestService"
+ port = TEST_PORT
+}
+
@RunWith(DevSdkIgnoreRunner::class)
@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.S_V2)
class MdnsRecordRepositoryTest {
@@ -57,7 +69,7 @@
private val deps = object : Dependencies() {
override fun getHostname() = TEST_HOSTNAME
override fun getInterfaceInetAddresses(iface: NetworkInterface) =
- Collections.enumeration(TEST_ADDRESSES.toList())
+ Collections.enumeration(TEST_ADDRESSES.map { it.address })
}
@Before
@@ -113,9 +125,65 @@
}
@Test
- fun testExitingServiceReAdded() {
+ fun testInvalidReuseOfServiceId() {
val repository = MdnsRecordRepository(thread.looper, deps)
repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
+ assertFailsWith(IllegalArgumentException::class) {
+ repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_2)
+ }
+ }
+
+ @Test
+ fun testHasActiveService() {
+ val repository = MdnsRecordRepository(thread.looper, deps)
+ assertFalse(repository.hasActiveService(TEST_SERVICE_ID_1))
+
+ repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
+ assertTrue(repository.hasActiveService(TEST_SERVICE_ID_1))
+
+ val probingInfo = repository.setServiceProbing(TEST_SERVICE_ID_1)
+ repository.onProbingSucceeded(probingInfo)
+ repository.onAdvertisementSent(TEST_SERVICE_ID_1)
+ assertTrue(repository.hasActiveService(TEST_SERVICE_ID_1))
+
+ repository.exitService(TEST_SERVICE_ID_1)
+ assertFalse(repository.hasActiveService(TEST_SERVICE_ID_1))
+ }
+
+ @Test
+ fun testExitAnnouncements() {
+ val repository = MdnsRecordRepository(thread.looper, deps)
+ repository.initWithService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
+ repository.onAdvertisementSent(TEST_SERVICE_ID_1)
+
+ val exitAnnouncement = repository.exitService(TEST_SERVICE_ID_1)
+ assertNotNull(exitAnnouncement)
+ assertEquals(1, repository.servicesCount)
+ val packet = exitAnnouncement.getPacket(0)
+
+ assertEquals(0x8400 /* response, authoritative */, packet.flags)
+ assertEquals(0, packet.questions.size)
+ assertEquals(0, packet.authorityRecords.size)
+ assertEquals(0, packet.additionalRecords.size)
+
+ assertContentEquals(listOf(
+ MdnsPointerRecord(
+ arrayOf("_testservice", "_tcp", "local"),
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 0L /* ttlMillis */,
+ arrayOf("MyTestService", "_testservice", "_tcp", "local"))
+ ), packet.answers)
+
+ repository.removeService(TEST_SERVICE_ID_1)
+ assertEquals(0, repository.servicesCount)
+ }
+
+ @Test
+ fun testExitingServiceReAdded() {
+ val repository = MdnsRecordRepository(thread.looper, deps)
+ repository.initWithService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
+ repository.onAdvertisementSent(TEST_SERVICE_ID_1)
repository.exitService(TEST_SERVICE_ID_1)
assertEquals(TEST_SERVICE_ID_1, repository.addService(TEST_SERVICE_ID_2, TEST_SERVICE_1))
@@ -124,4 +192,279 @@
repository.removeService(TEST_SERVICE_ID_2)
assertEquals(0, repository.servicesCount)
}
+
+ @Test
+ fun testOnProbingSucceeded() {
+ val repository = MdnsRecordRepository(thread.looper, deps)
+ val announcementInfo = repository.initWithService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
+ repository.onAdvertisementSent(TEST_SERVICE_ID_1)
+ val packet = announcementInfo.getPacket(0)
+
+ assertEquals(0x8400 /* response, authoritative */, packet.flags)
+ assertEquals(0, packet.questions.size)
+ assertEquals(0, packet.authorityRecords.size)
+
+ val serviceType = arrayOf("_testservice", "_tcp", "local")
+ val serviceName = arrayOf("MyTestService", "_testservice", "_tcp", "local")
+ val v4AddrRev = getReverseDnsAddress(TEST_ADDRESSES[0].address)
+ val v6Addr1Rev = getReverseDnsAddress(TEST_ADDRESSES[1].address)
+ val v6Addr2Rev = getReverseDnsAddress(TEST_ADDRESSES[2].address)
+
+ assertContentEquals(listOf(
+ // Reverse address and address records for the hostname
+ MdnsPointerRecord(v4AddrRev,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 120000L /* ttlMillis */,
+ TEST_HOSTNAME),
+ MdnsInetAddressRecord(TEST_HOSTNAME,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 120000L /* ttlMillis */,
+ TEST_ADDRESSES[0].address),
+ MdnsPointerRecord(v6Addr1Rev,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 120000L /* ttlMillis */,
+ TEST_HOSTNAME),
+ MdnsInetAddressRecord(TEST_HOSTNAME,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 120000L /* ttlMillis */,
+ TEST_ADDRESSES[1].address),
+ MdnsPointerRecord(v6Addr2Rev,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 120000L /* ttlMillis */,
+ TEST_HOSTNAME),
+ MdnsInetAddressRecord(TEST_HOSTNAME,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 120000L /* ttlMillis */,
+ TEST_ADDRESSES[2].address),
+ // Service registration records (RFC6763)
+ MdnsPointerRecord(
+ serviceType,
+ 0L /* receiptTimeMillis */,
+ // Not a unique name owned by the announcer, so cacheFlush=false
+ false /* cacheFlush */,
+ 4500000L /* ttlMillis */,
+ serviceName),
+ MdnsServiceRecord(
+ serviceName,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 120000L /* ttlMillis */,
+ 0 /* servicePriority */,
+ 0 /* serviceWeight */,
+ TEST_PORT /* servicePort */,
+ TEST_HOSTNAME),
+ MdnsTextRecord(
+ serviceName,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 4500000L /* ttlMillis */,
+ emptyList() /* entries */),
+ // Service type enumeration record (RFC6763 9.)
+ MdnsPointerRecord(
+ arrayOf("_services", "_dns-sd", "_udp", "local"),
+ 0L /* receiptTimeMillis */,
+ false /* cacheFlush */,
+ 4500000L /* ttlMillis */,
+ serviceType)
+ ), packet.answers)
+
+ assertContentEquals(listOf(
+ MdnsNsecRecord(v4AddrRev,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 120000L /* ttlMillis */,
+ v4AddrRev,
+ intArrayOf(MdnsRecord.TYPE_PTR)),
+ MdnsNsecRecord(TEST_HOSTNAME,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 120000L /* ttlMillis */,
+ TEST_HOSTNAME,
+ intArrayOf(MdnsRecord.TYPE_A, MdnsRecord.TYPE_AAAA)),
+ MdnsNsecRecord(v6Addr1Rev,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 120000L /* ttlMillis */,
+ v6Addr1Rev,
+ intArrayOf(MdnsRecord.TYPE_PTR)),
+ MdnsNsecRecord(v6Addr2Rev,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 120000L /* ttlMillis */,
+ v6Addr2Rev,
+ intArrayOf(MdnsRecord.TYPE_PTR)),
+ MdnsNsecRecord(serviceName,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ 4500000L /* ttlMillis */,
+ serviceName,
+ intArrayOf(MdnsRecord.TYPE_TXT, MdnsRecord.TYPE_SRV))
+ ), packet.additionalRecords)
+ }
+
+ @Test
+ fun testGetReverseDnsAddress() {
+ val expectedV6 = "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.B.D.0.1.0.0.2.ip6.arpa"
+ .split(".").toTypedArray()
+ assertContentEquals(expectedV6, getReverseDnsAddress(parseNumericAddress("2001:db8::1")))
+ val expectedV4 = "123.2.0.192.in-addr.arpa".split(".").toTypedArray()
+ assertContentEquals(expectedV4, getReverseDnsAddress(parseNumericAddress("192.0.2.123")))
+ }
+
+ @Test
+ fun testGetReply() {
+ val repository = MdnsRecordRepository(thread.looper, deps)
+ repository.initWithService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
+ val questions = listOf(MdnsPointerRecord(arrayOf("_testservice", "_tcp", "local"),
+ 0L /* receiptTimeMillis */,
+ false /* cacheFlush */,
+ // TTL and data is empty for a question
+ 0L /* ttlMillis */,
+ null /* pointer */))
+ val query = MdnsPacket(0 /* flags */, questions, listOf() /* answers */,
+ listOf() /* authorityRecords */, listOf() /* additionalRecords */)
+ val src = InetSocketAddress(parseNumericAddress("192.0.2.123"), 5353)
+ val reply = repository.getReply(query, src)
+
+ assertNotNull(reply)
+ // Source address is IPv4
+ assertEquals(MdnsConstants.getMdnsIPv4Address(), reply.destination.address)
+ assertEquals(MdnsConstants.MDNS_PORT, reply.destination.port)
+
+ // TTLs as per RFC6762 10.
+ val longTtl = 4_500_000L
+ val shortTtl = 120_000L
+ val serviceName = arrayOf("MyTestService", "_testservice", "_tcp", "local")
+
+ assertEquals(listOf(
+ MdnsPointerRecord(
+ arrayOf("_testservice", "_tcp", "local"),
+ 0L /* receiptTimeMillis */,
+ false /* cacheFlush */,
+ longTtl,
+ serviceName),
+ ), reply.answers)
+
+ assertEquals(listOf(
+ MdnsTextRecord(
+ serviceName,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ longTtl,
+ listOf() /* entries */),
+ MdnsServiceRecord(
+ serviceName,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ shortTtl,
+ 0 /* servicePriority */,
+ 0 /* serviceWeight */,
+ TEST_PORT,
+ TEST_HOSTNAME),
+ MdnsInetAddressRecord(
+ TEST_HOSTNAME,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ shortTtl,
+ TEST_ADDRESSES[0].address),
+ MdnsInetAddressRecord(
+ TEST_HOSTNAME,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ shortTtl,
+ TEST_ADDRESSES[1].address),
+ MdnsInetAddressRecord(
+ TEST_HOSTNAME,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ shortTtl,
+ TEST_ADDRESSES[2].address),
+ MdnsNsecRecord(
+ serviceName,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ longTtl,
+ serviceName /* nextDomain */,
+ intArrayOf(MdnsRecord.TYPE_TXT, MdnsRecord.TYPE_SRV)),
+ MdnsNsecRecord(
+ TEST_HOSTNAME,
+ 0L /* receiptTimeMillis */,
+ true /* cacheFlush */,
+ shortTtl,
+ TEST_HOSTNAME /* nextDomain */,
+ intArrayOf(MdnsRecord.TYPE_A, MdnsRecord.TYPE_AAAA)),
+ ), reply.additionalAnswers)
+ }
+
+ @Test
+ fun testGetConflictingServices() {
+ val repository = MdnsRecordRepository(thread.looper, deps)
+ repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
+ repository.addService(TEST_SERVICE_ID_2, TEST_SERVICE_2)
+
+ val packet = MdnsPacket(
+ 0 /* flags */,
+ emptyList() /* questions */,
+ listOf(
+ MdnsServiceRecord(
+ arrayOf("MyTestService", "_testservice", "_tcp", "local"),
+ 0L /* receiptTimeMillis */, true /* cacheFlush */, 0L /* ttlMillis */,
+ 0 /* servicePriority */, 0 /* serviceWeight */,
+ TEST_SERVICE_1.port + 1,
+ TEST_HOSTNAME),
+ MdnsTextRecord(
+ arrayOf("MyOtherTestService", "_testservice", "_tcp", "local"),
+ 0L /* receiptTimeMillis */, true /* cacheFlush */, 0L /* ttlMillis */,
+ listOf(TextEntry.fromString("somedifferent=entry"))),
+ ) /* answers */,
+ emptyList() /* authorityRecords */,
+ emptyList() /* additionalRecords */)
+
+ assertEquals(setOf(TEST_SERVICE_ID_1, TEST_SERVICE_ID_2),
+ repository.getConflictingServices(packet))
+ }
+
+ @Test
+ fun testGetConflictingServices_IdenticalService() {
+ val repository = MdnsRecordRepository(thread.looper, deps)
+ repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
+ repository.addService(TEST_SERVICE_ID_2, TEST_SERVICE_2)
+
+ val otherTtlMillis = 1234L
+ val packet = MdnsPacket(
+ 0 /* flags */,
+ emptyList() /* questions */,
+ listOf(
+ MdnsServiceRecord(
+ arrayOf("MyTestService", "_testservice", "_tcp", "local"),
+ 0L /* receiptTimeMillis */, true /* cacheFlush */,
+ otherTtlMillis, 0 /* servicePriority */, 0 /* serviceWeight */,
+ TEST_SERVICE_1.port,
+ TEST_HOSTNAME),
+ MdnsTextRecord(
+ arrayOf("MyOtherTestService", "_testservice", "_tcp", "local"),
+ 0L /* receiptTimeMillis */, true /* cacheFlush */,
+ otherTtlMillis, emptyList()),
+ ) /* answers */,
+ emptyList() /* authorityRecords */,
+ emptyList() /* additionalRecords */)
+
+ // Above records are identical to the actual registrations: no conflict
+ assertEquals(emptySet(), repository.getConflictingServices(packet))
+ }
+}
+
+private fun MdnsRecordRepository.initWithService(serviceId: Int, serviceInfo: NsdServiceInfo):
+ AnnouncementInfo {
+ updateAddresses(TEST_ADDRESSES)
+ addService(serviceId, serviceInfo)
+ val probingInfo = setServiceProbing(serviceId)
+ assertNotNull(probingInfo)
+ return onProbingSucceeded(probingInfo)
}
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketProviderTest.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketProviderTest.java
index 07bbbb5..635b296 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketProviderTest.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketProviderTest.java
@@ -24,6 +24,7 @@
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -89,7 +90,15 @@
public void setUp() throws IOException {
MockitoAnnotations.initMocks(this);
mockService(mContext, ConnectivityManager.class, Context.CONNECTIVITY_SERVICE, mCm);
+ if (mContext.getSystemService(ConnectivityManager.class) == null) {
+ // Test is using mockito-extended
+ doCallRealMethod().when(mContext).getSystemService(ConnectivityManager.class);
+ }
mockService(mContext, TetheringManager.class, Context.TETHERING_SERVICE, mTm);
+ if (mContext.getSystemService(TetheringManager.class) == null) {
+ // Test is using mockito-extended
+ doCallRealMethod().when(mContext).getSystemService(TetheringManager.class);
+ }
doReturn(true).when(mDeps).canScanOnInterface(any());
doReturn(mTestNetworkIfaceWrapper).when(mDeps).getNetworkInterfaceByName(TEST_IFACE_NAME);
doReturn(mLocalOnlyIfaceWrapper).when(mDeps)
diff --git a/tests/unit/java/com/android/server/net/NetworkStatsServiceTest.java b/tests/unit/java/com/android/server/net/NetworkStatsServiceTest.java
index d7c90d8..13a6a6f 100644
--- a/tests/unit/java/com/android/server/net/NetworkStatsServiceTest.java
+++ b/tests/unit/java/com/android/server/net/NetworkStatsServiceTest.java
@@ -2198,7 +2198,7 @@
private NetworkStatsCollection getLegacyCollection(String prefix, boolean includeTags) {
final NetworkStatsRecorder recorder = makeTestRecorder(mLegacyStatsDir, prefix,
- mSettings.getDevConfig(), includeTags, false);
+ mSettings.getXtConfig(), includeTags, false);
return recorder.getOrLoadCompleteLocked();
}
@@ -2255,14 +2255,9 @@
}
private void mockNetworkStatsSummary(NetworkStats summary) throws Exception {
- mockNetworkStatsSummaryDev(summary.clone());
mockNetworkStatsSummaryXt(summary.clone());
}
- private void mockNetworkStatsSummaryDev(NetworkStats summary) throws Exception {
- doReturn(summary).when(mStatsFactory).readNetworkStatsSummaryDev();
- }
-
private void mockNetworkStatsSummaryXt(NetworkStats summary) throws Exception {
doReturn(summary).when(mStatsFactory).readNetworkStatsSummaryXt();
}
@@ -2293,13 +2288,11 @@
doReturn(false).when(mSettings).getCombineSubtypeEnabled();
final Config config = new Config(bucketDuration, deleteAge, deleteAge);
- doReturn(config).when(mSettings).getDevConfig();
doReturn(config).when(mSettings).getXtConfig();
doReturn(config).when(mSettings).getUidConfig();
doReturn(config).when(mSettings).getUidTagConfig();
doReturn(MB_IN_BYTES).when(mSettings).getGlobalAlertBytes(anyLong());
- doReturn(MB_IN_BYTES).when(mSettings).getDevPersistBytes(anyLong());
doReturn(MB_IN_BYTES).when(mSettings).getXtPersistBytes(anyLong());
doReturn(MB_IN_BYTES).when(mSettings).getUidPersistBytes(anyLong());
doReturn(MB_IN_BYTES).when(mSettings).getUidTagPersistBytes(anyLong());
diff --git a/tools/gn2bp/Android.bp.swp b/tools/gn2bp/Android.bp.swp
index 2398349..9f34b06 100644
--- a/tools/gn2bp/Android.bp.swp
+++ b/tools/gn2bp/Android.bp.swp
@@ -14,6 +14,13 @@
//
// This file is automatically generated by gen_android_bp. Do not edit.
+// GN: PACKAGE
+package {
+ default_applicable_licenses: [
+ "external_cronet_license",
+ ],
+}
+
// GN: //components/cronet/android:cronet_api_java
java_library {
name: "cronet_aml_api_java",
@@ -22,45 +29,38 @@
],
libs: [
"androidx.annotation_annotation",
+ "framework-annotations-lib",
],
sdk_version: "module_current",
}
// GN: //components/cronet/android:cronet_api_java
+// TODO(danstahr): add the API helpers separately after the main API is checked in and thoroughly reviewed
filegroup {
name: "cronet_aml_api_sources",
srcs: [
":cronet_aml_components_cronet_android_interface_api_version",
"components/cronet/android/api/src/android/net/http/BidirectionalStream.java",
"components/cronet/android/api/src/android/net/http/CallbackException.java",
- "components/cronet/android/api/src/android/net/http/CronetEngine.java",
- "components/cronet/android/api/src/android/net/http/CronetException.java",
+ "components/cronet/android/api/src/android/net/http/ConnectionMigrationOptions.java",
+ "components/cronet/android/api/src/android/net/http/DnsOptions.java",
"components/cronet/android/api/src/android/net/http/ExperimentalBidirectionalStream.java",
- "components/cronet/android/api/src/android/net/http/ExperimentalCronetEngine.java",
+ "components/cronet/android/api/src/android/net/http/ExperimentalHttpEngine.java",
"components/cronet/android/api/src/android/net/http/ExperimentalUrlRequest.java",
- "components/cronet/android/api/src/android/net/http/ICronetEngineBuilder.java",
+ "components/cronet/android/api/src/android/net/http/HttpEngine.java",
+ "components/cronet/android/api/src/android/net/http/HttpException.java",
+ "components/cronet/android/api/src/android/net/http/IHttpEngineBuilder.java",
"components/cronet/android/api/src/android/net/http/InlineExecutionProhibitedException.java",
"components/cronet/android/api/src/android/net/http/NetworkException.java",
"components/cronet/android/api/src/android/net/http/NetworkQualityRttListener.java",
"components/cronet/android/api/src/android/net/http/NetworkQualityThroughputListener.java",
"components/cronet/android/api/src/android/net/http/QuicException.java",
+ "components/cronet/android/api/src/android/net/http/QuicOptions.java",
"components/cronet/android/api/src/android/net/http/RequestFinishedInfo.java",
"components/cronet/android/api/src/android/net/http/UploadDataProvider.java",
"components/cronet/android/api/src/android/net/http/UploadDataSink.java",
"components/cronet/android/api/src/android/net/http/UrlRequest.java",
"components/cronet/android/api/src/android/net/http/UrlResponseInfo.java",
- "components/cronet/android/api/src/android/net/http/apihelpers/ByteArrayCronetCallback.java",
- "components/cronet/android/api/src/android/net/http/apihelpers/ContentTypeParametersParser.java",
- "components/cronet/android/api/src/android/net/http/apihelpers/CronetRequestCompletionListener.java",
- "components/cronet/android/api/src/android/net/http/apihelpers/CronetResponse.java",
- "components/cronet/android/api/src/android/net/http/apihelpers/ImplicitFlowControlCallback.java",
- "components/cronet/android/api/src/android/net/http/apihelpers/InMemoryTransformCronetCallback.java",
- "components/cronet/android/api/src/android/net/http/apihelpers/JsonCronetCallback.java",
- "components/cronet/android/api/src/android/net/http/apihelpers/RedirectHandler.java",
- "components/cronet/android/api/src/android/net/http/apihelpers/RedirectHandlers.java",
- "components/cronet/android/api/src/android/net/http/apihelpers/StringCronetCallback.java",
- "components/cronet/android/api/src/android/net/http/apihelpers/UploadDataProviders.java",
- "components/cronet/android/api/src/android/net/http/apihelpers/UrlRequestCallbacks.java",
],
}
@@ -136,7 +136,7 @@
// GN: //base/allocator/partition_allocator:debugging_buildflags
cc_genrule {
name: "cronet_aml_base_allocator_partition_allocator_debugging_buildflags",
- cmd: "echo '--flags PA_DCHECK_IS_ON=\"true\" PA_EXPENSIVE_DCHECKS_ARE_ON=\"true\" PA_DCHECK_IS_CONFIGURABLE=\"false\"' | " +
+ cmd: "echo '--flags PA_DCHECK_IS_ON=\"false\" PA_EXPENSIVE_DCHECKS_ARE_ON=\"false\" PA_DCHECK_IS_CONFIGURABLE=\"false\"' | " +
"$(location build/write_buildflag_header.py) --output " +
"$(out) " +
"--rulename " +
@@ -259,12 +259,14 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DIS_PARTITION_ALLOC_IMPL",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-DPA_PCSCAN_STACK_SUPPORTED",
- "-D_DEBUG",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -381,7 +383,7 @@
"--input_file " +
"java/lang/Runtime.class " +
"--javap " +
- "$$(find out/.path -name javap) " +
+ "$$(find $${OUT_DIR:-out}/.path -name javap) " +
"--package_prefix " +
"android.net.http.internal",
out: [
@@ -405,6 +407,7 @@
cc_library_static {
name: "cronet_aml_base_base",
srcs: [
+ ":cronet_aml_base_nodebug_assertion",
":cronet_aml_third_party_abseil_cpp_absl_base_base",
":cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
":cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
@@ -965,17 +968,19 @@
"-DBASE_IMPLEMENTATION",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-DUSE_CHROMIUM_ICU=1",
"-DU_ENABLE_DYLOAD=0",
"-DU_ENABLE_RESOURCE_TRACING=0",
"-DU_ENABLE_TRACING=1",
"-DU_STATIC_IMPLEMENTATION",
"-DU_USING_ICU_NAMESPACE=0",
- "-D_DEBUG",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -1092,6 +1097,7 @@
"base/android/java/src/org/chromium/base/MemoryPressureListener.java",
"base/android/java/src/org/chromium/base/PathService.java",
"base/android/java/src/org/chromium/base/PathUtils.java",
+ "base/android/java/src/org/chromium/base/PiiElider.java",
"base/android/java/src/org/chromium/base/PowerMonitor.java",
"base/android/java/src/org/chromium/base/RadioUtils.java",
"base/android/java/src/org/chromium/base/SysUtils.java",
@@ -1165,6 +1171,8 @@
"--output_name " +
"PathUtils_jni.h " +
"--output_name " +
+ "PiiElider_jni.h " +
+ "--output_name " +
"PowerMonitor_jni.h " +
"--output_name " +
"RadioUtils_jni.h " +
@@ -1245,6 +1253,8 @@
"--input_file " +
"$(location base/android/java/src/org/chromium/base/PathUtils.java) " +
"--input_file " +
+ "$(location base/android/java/src/org/chromium/base/PiiElider.java) " +
+ "--input_file " +
"$(location base/android/java/src/org/chromium/base/PowerMonitor.java) " +
"--input_file " +
"$(location base/android/java/src/org/chromium/base/RadioUtils.java) " +
@@ -1309,6 +1319,7 @@
"base/base_jni_headers/NativeUmaRecorder_jni.h",
"base/base_jni_headers/PathService_jni.h",
"base/base_jni_headers/PathUtils_jni.h",
+ "base/base_jni_headers/PiiElider_jni.h",
"base/base_jni_headers/PostTask_jni.h",
"base/base_jni_headers/PowerMonitor_jni.h",
"base/base_jni_headers/RadioUtils_jni.h",
@@ -1352,10 +1363,12 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -1387,7 +1400,7 @@
cc_genrule {
name: "cronet_aml_base_build_date",
cmd: "$(location build/write_build_date_header.py) $(out) " +
- "1672549200",
+ "1674804594",
out: [
"base/generated_build_date.h",
],
@@ -1450,7 +1463,7 @@
name: "cronet_aml_base_debugging_buildflags",
cmd: "if [[ ( $$CC_ARCH == 'x86_64' && $$CC_OS == 'android' ) ]]; " +
"then " +
- "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"false\" UNSAFE_DEVELOPER_BUILD=\"true\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"false\" ENABLE_GDBINIT_WARNING=\"true\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"true\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"false\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"false\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
"$(location build/write_buildflag_header.py) --output " +
"$(out) " +
"--rulename " +
@@ -1462,7 +1475,7 @@
"fi; " +
"if [[ ( $$CC_ARCH == 'x86' && $$CC_OS == 'android' ) ]]; " +
"then " +
- "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"true\" UNSAFE_DEVELOPER_BUILD=\"true\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"false\" ENABLE_GDBINIT_WARNING=\"true\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"true\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"true\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"false\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
"$(location build/write_buildflag_header.py) --output " +
"$(out) " +
"--rulename " +
@@ -1474,7 +1487,7 @@
"fi; " +
"if [[ ( $$CC_ARCH == 'arm' && $$CC_OS == 'android' ) ]]; " +
"then " +
- "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"false\" UNSAFE_DEVELOPER_BUILD=\"true\" CAN_UNWIND_WITH_CFI_TABLE=\"true\" EXCLUDE_UNWIND_TABLES=\"false\" ENABLE_GDBINIT_WARNING=\"true\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"true\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"false\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"true\" EXCLUDE_UNWIND_TABLES=\"false\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
"$(location build/write_buildflag_header.py) --output " +
"$(out) " +
"--rulename " +
@@ -1486,7 +1499,7 @@
"fi; " +
"if [[ ( $$CC_ARCH == 'arm64' && $$CC_OS == 'android' ) ]]; " +
"then " +
- "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"true\" UNSAFE_DEVELOPER_BUILD=\"true\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"false\" ENABLE_GDBINIT_WARNING=\"true\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"true\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"true\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"false\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
"$(location build/write_buildflag_header.py) --output " +
"$(out) " +
"--rulename " +
@@ -1651,6 +1664,57 @@
],
}
+// GN: //base:nodebug_assertion
+cc_object {
+ name: "cronet_aml_base_nodebug_assertion",
+ srcs: [
+ "base/nodebug_assertion.cc",
+ ],
+ static_libs: [
+ "cronet_aml_base_base_static",
+ ],
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DBASE_IMPLEMENTATION",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D__STDC_CONSTANT_MACROS",
+ "-D__STDC_FORMAT_MACROS",
+ ],
+ local_include_dirs: [
+ "./",
+ "buildtools/third_party/libc++/",
+ "buildtools/third_party/libc++/trunk/include",
+ "buildtools/third_party/libc++abi/trunk/include",
+ ],
+ cpp_std: "c++17",
+ target: {
+ android_x86: {
+ cflags: [
+ "-msse3",
+ ],
+ },
+ android_x86_64: {
+ cflags: [
+ "-msse3",
+ ],
+ },
+ },
+}
+
// GN: //base:orderfile_buildflags
cc_genrule {
name: "cronet_aml_base_orderfile_buildflags",
@@ -1849,10 +1913,12 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -1894,10 +1960,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -1956,7 +2023,7 @@
"soong_zip",
],
cmd: "cp $(in) $(genDir)/BuildConfig.java && " +
- "$(location soong_zip) -o $(out) -srcjar -f $(genDir)/BuildConfig.java",
+ "$(location soong_zip) -o $(out) -srcjar -C $(genDir) -f $(genDir)/BuildConfig.java",
out: [
"BuildConfig.srcjar",
],
@@ -1970,7 +2037,6 @@
],
cflags: [
"-DANDROID",
- "-D_ENABLE_ASSERTS",
"-E",
"-P",
],
@@ -2153,11 +2219,13 @@
cflags: [
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DLIBCXX_BUILDING_LIBCXXABI",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
+ "-D_LIBCPP_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED=1",
"-D_LIBCPP_BUILDING_LIBRARY",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCPP_OVERRIDABLE_FUNC_VIS=__attribute__((__visibility__(\"default\")))",
@@ -2209,6 +2277,7 @@
host: {
cflags: [
"-DCR_SYSROOT_KEY=20220331T153654Z-0",
+ "-DNO_UNWIND_TABLES",
"-DUSE_AURA=1",
"-DUSE_OZONE=1",
"-DUSE_UDEV",
@@ -2249,10 +2318,11 @@
cflags: [
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DLIBCXXABI_SILENT_TERMINATE",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_BUILDING_LIBRARY",
"-D_LIBCPP_CONSTINIT=constinit",
@@ -2320,6 +2390,7 @@
],
cflags: [
"-DCR_SYSROOT_KEY=20220331T153654Z-0",
+ "-DNO_UNWIND_TABLES",
"-DUSE_AURA=1",
"-DUSE_OZONE=1",
"-DUSE_UDEV",
@@ -2426,14 +2497,16 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -2453,8 +2526,8 @@
"third_party/protobuf/src/",
],
cpp_std: "c++17",
- linker_scripts: [
- "base/android/library_loader/anchor_functions.lds",
+ ldflags: [
+ "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
],
stem: "libcronet.108.0.5359.128",
target: {
@@ -3090,14 +3163,16 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -3153,7 +3228,8 @@
// GN: //components/cronet/android:implementation_api_version
java_genrule {
name: "cronet_aml_components_cronet_android_implementation_api_version",
- cmd: "$(location build/util/version.py) -f " +
+ cmd: "$(location build/util/version.py) --official " +
+ "-f " +
"$(location chrome/VERSION) " +
"-f " +
"$(location build/util/LASTCHANGE) " +
@@ -3184,7 +3260,7 @@
"soong_zip",
],
cmd: "cp $(in) $(genDir)/IntegratedModeState.java && " +
- "$(location soong_zip) -o $(out) -srcjar -f $(genDir)/IntegratedModeState.java",
+ "$(location soong_zip) -o $(out) -srcjar -C $(genDir) -f $(genDir)/IntegratedModeState.java",
out: [
"IntegratedModeState.srcjar",
],
@@ -3219,7 +3295,8 @@
// GN: //components/cronet/android:interface_api_version
java_genrule {
name: "cronet_aml_components_cronet_android_interface_api_version",
- cmd: "$(location build/util/version.py) -f " +
+ cmd: "$(location build/util/version.py) --official " +
+ "-f " +
"$(location chrome/VERSION) " +
"-f " +
"$(location build/util/LASTCHANGE) " +
@@ -3250,7 +3327,7 @@
"soong_zip",
],
cmd: "cp $(in) $(genDir)/LoadState.java && " +
- "$(location soong_zip) -o $(out) -srcjar -f $(genDir)/LoadState.java",
+ "$(location soong_zip) -o $(out) -srcjar -C $(genDir) -f $(genDir)/LoadState.java",
out: [
"LoadState.srcjar",
],
@@ -3452,14 +3529,16 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -3496,7 +3575,8 @@
// GN: //components/cronet:cronet_version_header_action
cc_genrule {
name: "cronet_aml_components_cronet_cronet_version_header_action",
- cmd: "$(location build/util/version.py) -f " +
+ cmd: "$(location build/util/version.py) --official " +
+ "-f " +
"$(location chrome/VERSION) " +
"-e " +
"'VERSION_FULL=\"%s.%s.%s.%s\" % (MAJOR,MINOR,BUILD,PATCH)' " +
@@ -3548,10 +3628,12 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -3618,14 +3700,16 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -3753,10 +3837,12 @@
"-DCOMPONENTS_PREFS_IMPLEMENTATION",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -3864,10 +3950,12 @@
"-DCRYPTO_IMPLEMENTATION",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -3904,7 +3992,6 @@
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-O2",
"-Wno-ambiguous-reversed-operator",
- "-Wno-deprecated-non-prototype",
"-Wno-error=return-type",
"-Wno-macro-redefined",
"-Wno-missing-field-initializers",
@@ -4181,6 +4268,7 @@
apex_available: [
"com.android.tethering",
],
+ min_sdk_version: "30",
libs: [
"androidx.annotation_annotation",
"androidx.annotation_annotation-experimental-nodeps",
@@ -4272,7 +4360,7 @@
"soong_zip",
],
cmd: "cp $(in) $(genDir)/NetError.java && " +
- "$(location soong_zip) -o $(out) -srcjar -f $(genDir)/NetError.java",
+ "$(location soong_zip) -o $(out) -srcjar -C $(genDir) -f $(genDir)/NetError.java",
out: [
"NetError.srcjar",
],
@@ -4507,16 +4595,18 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DENABLE_BUILT_IN_DNS",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
"-DNET_IMPLEMENTATION",
- "-D_DEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -4609,16 +4699,18 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DENABLE_BUILT_IN_DNS",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
"-DNET_IMPLEMENTATION",
- "-D_DEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -4724,16 +4816,18 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DENABLE_BUILT_IN_DNS",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
"-DNET_IMPLEMENTATION",
- "-D_DEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -5390,16 +5484,18 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DENABLE_BUILT_IN_DNS",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
"-DNET_IMPLEMENTATION",
- "-D_DEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -5495,16 +5591,18 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DENABLE_BUILT_IN_DNS",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
"-DNET_IMPLEMENTATION",
- "-D_DEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -5727,14 +5825,16 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -5798,10 +5898,12 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6291,15 +6393,17 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
"-DIS_QUICHE_IMPL",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6366,10 +6470,12 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6429,11 +6535,13 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DIS_URI_TEMPLATE_IMPL",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6482,10 +6590,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6527,10 +6636,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6572,10 +6682,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6617,10 +6728,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6662,10 +6774,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6707,10 +6820,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6752,10 +6866,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6798,10 +6913,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6843,10 +6959,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6890,10 +7007,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6935,10 +7053,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -6980,10 +7099,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7025,10 +7145,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7070,10 +7191,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7115,10 +7237,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7160,10 +7283,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7205,10 +7329,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7250,10 +7375,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7295,10 +7421,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7340,10 +7467,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7386,10 +7514,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7434,10 +7563,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7482,10 +7612,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7530,10 +7661,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7578,10 +7710,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7626,10 +7759,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7674,10 +7808,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7719,10 +7854,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7764,10 +7900,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7812,10 +7949,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7858,10 +7996,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7903,10 +8042,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -7950,10 +8090,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8001,10 +8142,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8046,10 +8188,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8091,10 +8234,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8136,10 +8280,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8183,10 +8328,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8233,10 +8379,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8290,10 +8437,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8335,10 +8483,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8386,10 +8535,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8431,10 +8581,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8484,10 +8635,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8533,10 +8685,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8578,10 +8731,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8623,10 +8777,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8667,10 +8822,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -8711,10 +8867,12 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -9025,11 +9183,12 @@
"-DBORINGSSL_NO_STATIC_INITIALIZER",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-DOPENSSL_SMALL",
- "-D_DEBUG",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -9067,10 +9226,12 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -9189,10 +9350,12 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -9241,10 +9404,11 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -9527,11 +9691,13 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_DLOPEN=0",
"-DHAVE_SYS_UIO_H",
"-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-DUCONFIG_ONLY_HTML_CONVERSION=1",
"-DUCONFIG_USE_WINDOWS_LCID_MAPPING_API=0",
"-DUSE_CHROMIUM_ICU=1",
@@ -9542,7 +9708,6 @@
"-DU_I18N_IMPLEMENTATION",
"-DU_STATIC_IMPLEMENTATION",
"-DU_USING_ICU_NAMESPACE=0",
- "-D_DEBUG",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -9783,11 +9948,13 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_DLOPEN=0",
"-DHAVE_SYS_UIO_H",
"-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-DUCONFIG_ONLY_HTML_CONVERSION=1",
"-DUCONFIG_USE_WINDOWS_LCID_MAPPING_API=0",
"-DUSE_CHROMIUM_ICU=1",
@@ -9799,7 +9966,6 @@
"-DU_ICUDATAENTRY_IN_COMMON",
"-DU_STATIC_IMPLEMENTATION",
"-DU_USING_ICU_NAMESPACE=0",
- "-D_DEBUG",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -9855,11 +10021,12 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_CONFIG_H",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -10045,10 +10212,12 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -10177,17 +10346,19 @@
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
"-DCR_SYSROOT_KEY=20220331T153654Z-0",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_ZLIB",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-DUSE_AURA=1",
"-DUSE_OZONE=1",
"-DUSE_UDEV",
- "-D_DEBUG",
"-D_FILE_OFFSET_BITS=64",
"-D_GNU_SOURCE",
"-D_LARGEFILE64_SOURCE",
@@ -10254,14 +10425,15 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -10312,16 +10484,18 @@
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
"-DCR_SYSROOT_KEY=20220331T153654Z-0",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-DUSE_AURA=1",
"-DUSE_OZONE=1",
"-DUSE_UDEV",
- "-D_DEBUG",
"-D_FILE_OFFSET_BITS=64",
"-D_GNU_SOURCE",
"-D_LARGEFILE64_SOURCE",
@@ -10445,16 +10619,18 @@
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
"-DCR_SYSROOT_KEY=20220331T153654Z-0",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
"-DGOOGLE_PROTOBUF_NO_RTTI",
"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
"-DHAVE_PTHREAD",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
"-DUSE_AURA=1",
"-DUSE_OZONE=1",
"-DUSE_UDEV",
- "-D_DEBUG",
"-D_FILE_OFFSET_BITS=64",
"-D_GNU_SOURCE",
"-D_LARGEFILE64_SOURCE",
@@ -10561,11 +10737,13 @@
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
"-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
- "-DDCHECK_ALWAYS_ON=1",
- "-DDYNAMIC_ANNOTATIONS_ENABLED=1",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DIS_URL_IMPL",
- "-D_DEBUG",
+ "-DNDEBUG",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_FORTIFY_SOURCE=2",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
@@ -10635,3 +10813,55 @@
],
}
+// GN: LICENSE
+license {
+ name: "external_cronet_license",
+ license_kinds: [
+ "SPDX-license-identifier-AFL-2.0",
+ "SPDX-license-identifier-Apache-2.0",
+ "SPDX-license-identifier-BSD",
+ "SPDX-license-identifier-BSL-1.0",
+ "SPDX-license-identifier-GPL",
+ "SPDX-license-identifier-GPL-2.0",
+ "SPDX-license-identifier-GPL-3.0",
+ "SPDX-license-identifier-ICU",
+ "SPDX-license-identifier-ISC",
+ "SPDX-license-identifier-LGPL",
+ "SPDX-license-identifier-LGPL-2.1",
+ "SPDX-license-identifier-MIT",
+ "SPDX-license-identifier-MPL",
+ "SPDX-license-identifier-MPL-2.0",
+ "SPDX-license-identifier-NCSA",
+ "SPDX-license-identifier-OpenSSL",
+ "SPDX-license-identifier-Unicode-DFS",
+ "legacy_unencumbered",
+ ],
+ license_text: [
+ "LICENSE",
+ "base/third_party/double_conversion/LICENSE",
+ "base/third_party/dynamic_annotations/LICENSE",
+ "base/third_party/icu/LICENSE",
+ "base/third_party/nspr/LICENSE",
+ "base/third_party/superfasthash/LICENSE",
+ "base/third_party/symbolize/LICENSE",
+ "base/third_party/valgrind/LICENSE",
+ "base/third_party/xdg_user_dirs/LICENSE",
+ "net/third_party/quiche/src/LICENSE",
+ "net/third_party/uri_template/LICENSE",
+ "third_party/abseil-cpp/LICENSE",
+ "third_party/ashmem/LICENSE",
+ "third_party/boringssl/src/LICENSE",
+ "third_party/boringssl/src/third_party/fiat/LICENSE",
+ "third_party/boringssl/src/third_party/googletest/LICENSE",
+ "third_party/boringssl/src/third_party/wycheproof_testvectors/LICENSE",
+ "third_party/brotli/LICENSE",
+ "third_party/icu/LICENSE",
+ "third_party/icu/scripts/LICENSE",
+ "third_party/libevent/LICENSE",
+ "third_party/metrics_proto/LICENSE",
+ "third_party/modp_b64/LICENSE",
+ "third_party/protobuf/LICENSE",
+ "third_party/protobuf/third_party/utf8_range/LICENSE",
+ ],
+}
+
diff --git a/tools/gn2bp/desc_arm.json b/tools/gn2bp/desc_arm.json
index b59157a..ff1a7e2 100644
--- a/tools/gn2bp/desc_arm.json
+++ b/tools/gn2bp/desc_arm.json
Binary files differ
diff --git a/tools/gn2bp/desc_arm64.json b/tools/gn2bp/desc_arm64.json
index 9881124..20c942f 100644
--- a/tools/gn2bp/desc_arm64.json
+++ b/tools/gn2bp/desc_arm64.json
Binary files differ
diff --git a/tools/gn2bp/desc_x64.json b/tools/gn2bp/desc_x64.json
index 3a2ce2a..b25932b 100644
--- a/tools/gn2bp/desc_x64.json
+++ b/tools/gn2bp/desc_x64.json
Binary files differ
diff --git a/tools/gn2bp/desc_x86.json b/tools/gn2bp/desc_x86.json
index 03bcf2f..b4bc6e9 100644
--- a/tools/gn2bp/desc_x86.json
+++ b/tools/gn2bp/desc_x86.json
Binary files differ
diff --git a/tools/gn2bp/gen_android_bp b/tools/gn2bp/gen_android_bp
index dcf8897..9d2d858 100755
--- a/tools/gn2bp/gen_android_bp
+++ b/tools/gn2bp/gen_android_bp
@@ -128,12 +128,17 @@
"-msse4.2",
]
+def get_linker_script_ldflag(script_path):
+ return f'-Wl,--script,{tree_path}/{script_path}'
+
# Additional arguments to apply to Android.bp rules.
additional_args = {
# TODO: remove if not needed.
'cronet_aml_components_cronet_android_cronet': [
- ('linker_scripts', {
- 'base/android/library_loader/anchor_functions.lds',
+ # linker_scripts property is not available in tm-mainline-prod.
+ # So use ldflags to specify linker script.
+ ('ldflags',{
+ get_linker_script_ldflag('base/android/library_loader/anchor_functions.lds'),
}),
],
'cronet_aml_net_net': [
@@ -370,6 +375,7 @@
self.min_sdk_version = None
self.proto = dict()
self.linker_scripts = set()
+ self.ldflags = set()
# The genrule_XXX below are properties that must to be propagated back
# on the module(s) that depend on the genrule.
self.genrule_headers = set()
@@ -391,6 +397,9 @@
self.processor_class = None
self.sdk_version = None
self.javacflags = set()
+ self.license_kinds = set()
+ self.license_text = set()
+ self.default_applicable_licenses = set()
def to_string(self, output):
if self.comment:
@@ -437,6 +446,7 @@
self._output_field(output, 'stubs')
self._output_field(output, 'proto')
self._output_field(output, 'linker_scripts')
+ self._output_field(output, 'ldflags')
self._output_field(output, 'cppflags')
self._output_field(output, 'libs')
self._output_field(output, 'stem')
@@ -446,6 +456,9 @@
self._output_field(output, 'processor_class')
self._output_field(output, 'sdk_version')
self._output_field(output, 'javacflags')
+ self._output_field(output, 'license_kinds')
+ self._output_field(output, 'license_text')
+ self._output_field(output, 'default_applicable_licenses')
if self.rtti:
self._output_field(output, 'rtti')
@@ -749,7 +762,7 @@
module.out.add(stem + '.srcjar')
module.cmd = NEWLINE.join([
f'cp $(in) $(genDir)/{stem}.java &&',
- f'$(location soong_zip) -o $(out) -srcjar -f $(genDir)/{stem}.java'
+ f'$(location soong_zip) -o $(out) -srcjar -C $(genDir) -f $(genDir)/{stem}.java'
])
module.tools.add('soong_zip')
blueprint.add_module(module)
@@ -956,7 +969,7 @@
def _sanitize_args(self):
self._set_value_arg('--jar_file', '$(location :current_android_jar)', False)
if self._has_arg('--jar_file'):
- self._append_arg('--javap', '$$(find out/.path -name javap)')
+ self._append_arg('--javap', '$$(find $${OUT_DIR:-out}/.path -name javap)')
self._update_value_arg('--output_dir', self._sanitize_filepath)
self._update_value_arg('--includes', self._sanitize_filepath, False)
self._delete_value_arg('--prev_output_dir', False)
@@ -1529,6 +1542,7 @@
module.aidl["include_dirs"] = {"frameworks/base/core/java/"}
module.aidl["local_include_dirs"] = {"base/android/java/src/"}
module.sdk_version = "module_current"
+ module.min_sdk_version = 30
module.apex_available.add(tethering_apex)
# TODO: support for this flag is removed upstream in crrev/c/4062652.
# Consider reverting this change upstream, or worst-case downstream. As an
@@ -1550,8 +1564,12 @@
def create_java_api_module(blueprint, gn):
source_module = Module('filegroup', module_prefix + 'api_sources', java_api_target_name)
+ # TODO add the API helpers separately after the main API is checked in and thoroughly reviewed
source_module.srcs.update([gn_utils.label_to_path(source)
- for source in get_api_java_sources(gn)])
+ for source in get_api_java_sources(gn)
+ if "apihelpers" not in source])
+ source_module.comment += "\n// TODO(danstahr): add the API helpers separately after the main" \
+ " API is checked in and thoroughly reviewed"
source_module.srcs.update([
':' + create_action_module(blueprint, gn.get_target(dep), 'java_genrule').name
for dep in get_api_java_actions(gn)])
@@ -1562,6 +1580,7 @@
java_module.sdk_version = "module_current"
java_module.libs = {
"androidx.annotation_annotation",
+ "framework-annotations-lib",
}
blueprint.add_module(java_module)
return java_module
@@ -1588,7 +1607,6 @@
'-Wno-sign-promo',
'-Wno-unused-parameter',
'-Wno-null-pointer-subtraction', # Needed to libevent
- '-Wno-deprecated-non-prototype', # needed for zlib
'-fvisibility=hidden',
'-Wno-ambiguous-reversed-operator', # needed for icui18n
'-Wno-unreachable-code-loop-increment', # needed for icui18n
@@ -1646,6 +1664,59 @@
return blueprint
+def create_license_module(blueprint):
+ module = Module("license", "external_cronet_license", "LICENSE")
+ module.license_kinds.update({
+ 'SPDX-license-identifier-LGPL-2.1',
+ 'SPDX-license-identifier-GPL-2.0',
+ 'SPDX-license-identifier-MPL',
+ 'SPDX-license-identifier-ISC',
+ 'SPDX-license-identifier-GPL',
+ 'SPDX-license-identifier-AFL-2.0',
+ 'SPDX-license-identifier-MPL-2.0',
+ 'SPDX-license-identifier-BSD',
+ 'SPDX-license-identifier-Apache-2.0',
+ 'SPDX-license-identifier-BSL-1.0',
+ 'SPDX-license-identifier-LGPL',
+ 'SPDX-license-identifier-GPL-3.0',
+ 'SPDX-license-identifier-Unicode-DFS',
+ 'SPDX-license-identifier-NCSA',
+ 'SPDX-license-identifier-OpenSSL',
+ 'SPDX-license-identifier-MIT',
+ "SPDX-license-identifier-ICU",
+ 'legacy_unencumbered', # public domain
+ })
+ module.license_text.update({
+ "LICENSE",
+ "net/third_party/uri_template/LICENSE",
+ "net/third_party/quiche/src/LICENSE",
+ "base/third_party/symbolize/LICENSE",
+ "base/third_party/superfasthash/LICENSE",
+ "base/third_party/xdg_user_dirs/LICENSE",
+ "base/third_party/double_conversion/LICENSE",
+ "base/third_party/nspr/LICENSE",
+ "base/third_party/dynamic_annotations/LICENSE",
+ "base/third_party/icu/LICENSE",
+ "base/third_party/valgrind/LICENSE",
+ "third_party/brotli/LICENSE",
+ "third_party/protobuf/LICENSE",
+ "third_party/protobuf/third_party/utf8_range/LICENSE",
+ "third_party/metrics_proto/LICENSE",
+ "third_party/boringssl/src/LICENSE",
+ "third_party/boringssl/src/third_party/googletest/LICENSE",
+ "third_party/boringssl/src/third_party/wycheproof_testvectors/LICENSE",
+ "third_party/boringssl/src/third_party/fiat/LICENSE",
+ "third_party/libevent/LICENSE",
+ "third_party/ashmem/LICENSE",
+ "third_party/icu/LICENSE",
+ "third_party/icu/scripts/LICENSE",
+ "third_party/abseil-cpp/LICENSE",
+ "third_party/modp_b64/LICENSE",
+ })
+ default_license = Module("package", "", "PACKAGE")
+ default_license.default_applicable_licenses.add(module.name)
+ blueprint.add_module(module)
+ blueprint.add_module(default_license)
def main():
parser = argparse.ArgumentParser(
@@ -1697,7 +1768,7 @@
# Add any proto groups to the blueprint.
for l_name, t_names in proto_groups.items():
create_proto_group_modules(blueprint, gn, l_name, t_names)
-
+ create_license_module(blueprint)
output = [
"""// Copyright (C) 2022 The Android Open Source Project
//
diff --git a/tools/gn2bp/gen_desc_json.sh b/tools/gn2bp/gen_desc_json.sh
index ed684b3..1f60eb9 100755
--- a/tools/gn2bp/gen_desc_json.sh
+++ b/tools/gn2bp/gen_desc_json.sh
@@ -2,11 +2,34 @@
set -x
# Run this script inside a full chromium checkout.
-# TODO: add support for applying local patches.
OUT_PATH="out/cronet"
#######################################
+# Apply patches in external/cronet.
+# Globals:
+# ANDROID_BUILD_TOP
+# Arguments:
+# None
+#######################################
+function apply_patches() {
+ local -r patch_root="${ANDROID_BUILD_TOP}/external/cronet/patches"
+
+ local upstream_patches
+ upstream_patches=$(ls "${patch_root}/upstream-next")
+ local patch
+ for patch in ${upstream_patches}; do
+ git am --3way "${patch_root}/upstream-next/${patch}"
+ done
+
+ local local_patches
+ local_patches=$(ls "${patch_root}/local")
+ for patch in ${local_patches}; do
+ git am --3way "${patch_root}/local/${patch}"
+ done
+}
+
+#######################################
# Generate desc.json for a specified architecture.
# Globals:
# OUT_PATH
@@ -31,6 +54,8 @@
"treat_warnings_as_errors = false"
"enable_base_tracing = false"
"is_cronet_build = true"
+ "is_debug = false"
+ "is_official_build = true"
)
gn_args+=("target_cpu = \"${1}\"")
@@ -48,6 +73,7 @@
gn desc "${OUT_PATH}" --format=json --all-toolchains "//*" > "${out_file}"
}
+apply_patches
gn_desc x86
gn_desc x64
gn_desc arm