diff --git a/Tethering/apex/Android.bp b/Tethering/apex/Android.bp index 565675f3ef..b26911c8a8 100644 --- a/Tethering/apex/Android.bp +++ b/Tethering/apex/Android.bp @@ -59,11 +59,31 @@ cronet_in_tethering_apex_defaults = "CronetInTetheringApexDefaultsEnabled" // 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", @@ -192,6 +212,7 @@ bootclasspath_fragment { "android.app.usage", "android.nearby", "android.net", + "android.net.http", "android.net.netstats", "android.net.util", ], @@ -206,6 +227,8 @@ bootclasspath_fragment { "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 11978cb06f..cbdf0c06a3 100644 --- a/Tethering/common/TetheringLib/Android.bp +++ b/Tethering/common/TetheringLib/Android.bp @@ -17,8 +17,6 @@ package { 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. @@ -39,7 +37,10 @@ cronet_java_defaults_enabled_srcs = [":cronet_aml_api_sources"] java_sdk_library { name: "framework-tethering", - defaults: ["framework-tethering-defaults"], + defaults: [ + "CronetJavaDefaults", + "framework-tethering-defaults", + ], impl_library_visibility: [ "//packages/modules/Connectivity/Tethering:__subpackages__", "//packages/modules/Connectivity/framework", @@ -72,12 +73,61 @@ java_sdk_library { hostdex: true, // for hiddenapi check permitted_packages: ["android.net"], - lint: { strict_updatability_linting: true }, +} + +java_defaults { + name: "CronetJavaDefaults", + defaults: [cronet_java_defaults], +} + +java_defaults { + name: "CronetJavaDefaultsEnabled", + srcs: cronet_java_defaults_enabled_srcs, + 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"], + defaults: [ + "framework-tethering-defaults", + "CronetJavaPrejarjarDefaults", + ], } java_genrule { 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 0000000000..c0157b7981 --- /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, 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 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> getAllHeaders(); + method public abstract java.util.List> 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 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 0000000000..460c21621d --- /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); + 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 getTetherableBluetoothRegexs(); + method @Deprecated @NonNull public java.util.List getTetherableUsbRegexs(); + method @Deprecated @NonNull public java.util.List getTetherableWifiRegexs(); + } + +} + diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-removed.txt b/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-removed.txt new file mode 100644 index 0000000000..d802177e24 --- /dev/null +++ b/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-removed.txt @@ -0,0 +1 @@ +// Signature format: 2.0 diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/removed.txt b/Tethering/common/TetheringLib/cronet_enabled/api/removed.txt new file mode 100644 index 0000000000..d802177e24 --- /dev/null +++ b/Tethering/common/TetheringLib/cronet_enabled/api/removed.txt @@ -0,0 +1 @@ +// Signature format: 2.0 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 0000000000..844ff6471a --- /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, int); + method public int describeContents(); + method @NonNull public java.util.List 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 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 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 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); + 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); + method public default void onLocalOnlyInterfacesChanged(@NonNull java.util.Set); + method public default void onOffloadStatusChanged(int); + method public default void onTetherableInterfacesChanged(@NonNull java.util.List); + method public default void onTetherableInterfacesChanged(@NonNull java.util.Set); + method public default void onTetheredInterfacesChanged(@NonNull java.util.List); + method public default void onTetheredInterfacesChanged(@NonNull java.util.Set); + 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/Tethering/common/TetheringLib/cronet_enabled/api/system-removed.txt b/Tethering/common/TetheringLib/cronet_enabled/api/system-removed.txt new file mode 100644 index 0000000000..d802177e24 --- /dev/null +++ b/Tethering/common/TetheringLib/cronet_enabled/api/system-removed.txt @@ -0,0 +1 @@ +// Signature format: 2.0