summaryrefslogtreecommitdiffstats
path: root/core
diff options
context:
space:
mode:
Diffstat (limited to 'core')
-rw-r--r--core/java/android/net/LinkCapabilities.aidl22
-rw-r--r--core/java/android/net/LinkCapabilities.java362
-rw-r--r--core/java/android/net/MobileDataStateTracker.java21
-rw-r--r--core/java/android/net/NetworkStateTracker.java12
4 files changed, 414 insertions, 3 deletions
diff --git a/core/java/android/net/LinkCapabilities.aidl b/core/java/android/net/LinkCapabilities.aidl
new file mode 100644
index 0000000..5f47baf
--- /dev/null
+++ b/core/java/android/net/LinkCapabilities.aidl
@@ -0,0 +1,22 @@
+/*
+**
+** Copyright (C) 2009 Qualcomm Innovation Center, Inc. All Rights Reserved.
+** Copyright (C) 2009 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;
+
+parcelable LinkCapabilities;
+
diff --git a/core/java/android/net/LinkCapabilities.java b/core/java/android/net/LinkCapabilities.java
new file mode 100644
index 0000000..d10a759
--- /dev/null
+++ b/core/java/android/net/LinkCapabilities.java
@@ -0,0 +1,362 @@
+/*
+ * Copyright (C) 2010 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;
+
+import android.os.Parcelable;
+import android.os.Parcel;
+import android.util.Log;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+/**
+ * A class representing the capabilities of a link
+ *
+ * @hide
+ */
+public class LinkCapabilities implements Parcelable {
+ private static final String TAG = "LinkCapabilities";
+ private static final boolean DBG = false;
+
+ /** The Map of Keys to Values */
+ private HashMap<Integer, String> mCapabilities;
+
+
+ /**
+ * The set of keys defined for a links capabilities.
+ *
+ * Keys starting with RW are read + write, i.e. the application
+ * can request for a certain requirement corresponding to that key.
+ * Keys starting with RO are read only, i.e. the the application
+ * can read the value of that key from the socket but cannot request
+ * a corresponding requirement.
+ *
+ * TODO: Provide a documentation technique for concisely and precisely
+ * define the syntax for each value string associated with a key.
+ */
+ public static final class Key {
+ /** No constructor */
+ private Key() {}
+
+ /**
+ * An integer representing the network type.
+ * @see ConnectivityManager
+ */
+ public final static int RO_NETWORK_TYPE = 1;
+
+ /**
+ * Desired minimum forward link (download) bandwidth for the
+ * in kilobits per second (kbps). Values should be strings such
+ * "50", "100", "1500", etc.
+ */
+ public final static int RW_DESIRED_FWD_BW = 2;
+
+ /**
+ * Required minimum forward link (download) bandwidth, in
+ * per second (kbps), below which the socket cannot function.
+ * Values should be strings such as "50", "100", "1500", etc.
+ */
+ public final static int RW_REQUIRED_FWD_BW = 3;
+
+ /**
+ * Available forward link (download) bandwidth for the socket.
+ * This value is in kilobits per second (kbps).
+ * Values will be strings such as "50", "100", "1500", etc.
+ */
+ public final static int RO_AVAILABLE_FWD_BW = 4;
+
+ /**
+ * Desired minimum reverse link (upload) bandwidth for the socket
+ * in kilobits per second (kbps).
+ * Values should be strings such as "50", "100", "1500", etc.
+ * <p>
+ * This key is set via the needs map.
+ */
+ public final static int RW_DESIRED_REV_BW = 5;
+
+ /**
+ * Required minimum reverse link (upload) bandwidth, in kilobits
+ * per second (kbps), below which the socket cannot function.
+ * If a rate is not specified, the default rate of kbps will be
+ * Values should be strings such as "50", "100", "1500", etc.
+ */
+ public final static int RW_REQUIRED_REV_BW = 6;
+
+ /**
+ * Available reverse link (upload) bandwidth for the socket.
+ * This value is in kilobits per second (kbps).
+ * Values will be strings such as "50", "100", "1500", etc.
+ */
+ public final static int RO_AVAILABLE_REV_BW = 7;
+
+ /**
+ * Maximum latency for the socket, in milliseconds, above which
+ * socket cannot function.
+ * Values should be strings such as "50", "300", "500", etc.
+ */
+ public final static int RW_MAX_ALLOWED_LATENCY = 8;
+
+ /**
+ * Interface that the socket is bound to. This can be a virtual
+ * interface (e.g. VPN or Mobile IP) or a physical interface
+ * (e.g. wlan0 or rmnet0).
+ * Values will be strings such as "wlan0", "rmnet0"
+ */
+ public final static int RO_BOUND_INTERFACE = 9;
+
+ /**
+ * Physical interface that the socket is routed on.
+ * This can be different from BOUND_INTERFACE in cases such as
+ * VPN or Mobile IP. The physical interface may change over time
+ * if seamless mobility is supported.
+ * Values will be strings such as "wlan0", "rmnet0"
+ */
+ public final static int RO_PHYSICAL_INTERFACE = 10;
+ }
+
+ /**
+ * Role informs the LinkSocket about the data usage patterns of your
+ * application.
+ * <P>
+ * {@code Role.DEFAULT} is the default role, and is used whenever
+ * a role isn't set.
+ */
+ public static final class Role {
+ /** No constructor */
+ private Role() {}
+
+ // examples only, discuss which roles should be defined, and then
+ // code these to match
+
+ /** Default Role */
+ public static final String DEFAULT = "0";
+ /** Bulk down load */
+ public static final String BULK_DOWNLOAD = "bulk.download";
+ /** Bulk upload */
+ public static final String BULK_UPLOAD = "bulk.upload";
+
+ /** VoIP Application at 24kbps */
+ public static final String VOIP_24KBPS = "voip.24k";
+ /** VoIP Application at 32kbps */
+ public static final String VOIP_32KBPS = "voip.32k";
+
+ /** Video Streaming at 480p */
+ public static final String VIDEO_STREAMING_480P = "video.streaming.480p";
+ /** Video Streaming at 720p */
+ public static final String VIDEO_STREAMING_720I = "video.streaming.720i";
+
+ /** Video Chat Application at 360p */
+ public static final String VIDEO_CHAT_360P = "video.chat.360p";
+ /** Video Chat Application at 480p */
+ public static final String VIDEO_CHAT_480P = "video.chat.480i";
+ }
+
+ /**
+ * Constructor
+ */
+ public LinkCapabilities() {
+ mCapabilities = new HashMap<Integer, String>();
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param source
+ */
+ public LinkCapabilities(LinkCapabilities source) {
+ if (source != null) {
+ mCapabilities = new HashMap<Integer, String>(source.mCapabilities);
+ } else {
+ mCapabilities = new HashMap<Integer, String>();
+ }
+ }
+
+ /**
+ * Create the {@code LinkCapabilities} with values depending on role type.
+ * @param applicationRole a {@code LinkSocket.Role}
+ * @return the {@code LinkCapabilities} associated with the applicationRole, empty if none
+ */
+ public static LinkCapabilities createNeedsMap(String applicationRole) {
+ if (DBG) log("createNeededCapabilities(applicationRole) EX");
+ return new LinkCapabilities();
+ }
+
+ /**
+ * Remove all capabilities
+ */
+ public void clear() {
+ mCapabilities.clear();
+ }
+
+ /**
+ * Returns whether this map is empty.
+ */
+ public boolean isEmpty() {
+ return mCapabilities.isEmpty();
+ }
+
+ /**
+ * Returns the number of elements in this map.
+ *
+ * @return the number of elements in this map.
+ */
+ public int size() {
+ return mCapabilities.size();
+ }
+
+ /**
+ * Given the key return the capability string
+ *
+ * @param key
+ * @return the capability string
+ */
+ public String get(int key) {
+ return mCapabilities.get(key);
+ }
+
+ /**
+ * Store the key/value capability pair
+ *
+ * @param key
+ * @param value
+ */
+ public void put(int key, String value) {
+ mCapabilities.put(key, value);
+ }
+
+ /**
+ * Returns whether this map contains the specified key.
+ *
+ * @param key to search for.
+ * @return {@code true} if this map contains the specified key,
+ * {@code false} otherwise.
+ */
+ public boolean containsKey(int key) {
+ return mCapabilities.containsKey(key);
+ }
+
+ /**
+ * Returns whether this map contains the specified value.
+ *
+ * @param value to search for.
+ * @return {@code true} if this map contains the specified value,
+ * {@code false} otherwise.
+ */
+ public boolean containsValue(String value) {
+ return mCapabilities.containsValue(value);
+ }
+
+ /**
+ * Returns a set containing all of the mappings in this map. Each mapping is
+ * an instance of {@link Map.Entry}. As the set is backed by this map,
+ * changes in one will be reflected in the other.
+ *
+ * @return a set of the mappings.
+ */
+ public Set<Entry<Integer, String>> entrySet() {
+ return mCapabilities.entrySet();
+ }
+
+ /**
+ * @return the set of the keys.
+ */
+ public Set<Integer> keySet() {
+ return mCapabilities.keySet();
+ }
+
+ /**
+ * @return the set of values
+ */
+ public Collection<String> values() {
+ return mCapabilities.values();
+ }
+
+ /**
+ * Implement the Parcelable interface
+ * @hide
+ */
+ public int describeContents() {
+ return 0;
+ }
+
+ /**
+ * Convert to string for debugging
+ */
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("{");
+ boolean firstTime = true;
+ for (Entry<Integer, String> entry : mCapabilities.entrySet()) {
+ if (firstTime) {
+ firstTime = false;
+ } else {
+ sb.append(",");
+ }
+ sb.append(entry.getKey());
+ sb.append(":\"");
+ sb.append(entry.getValue());
+ sb.append("\"");
+ return mCapabilities.toString();
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Implement the Parcelable interface.
+ * @hide
+ */
+ public void writeToParcel(Parcel dest, int flags) {
+ dest.writeInt(mCapabilities.size());
+ for (Entry<Integer, String> entry : mCapabilities.entrySet()) {
+ dest.writeInt(entry.getKey().intValue());
+ dest.writeString(entry.getValue());
+ }
+ }
+
+ /**
+ * Implement the Parcelable interface.
+ * @hide
+ */
+ public static final Creator<LinkCapabilities> CREATOR =
+ new Creator<LinkCapabilities>() {
+ public LinkCapabilities createFromParcel(Parcel in) {
+ LinkCapabilities capabilities = new LinkCapabilities();
+ int size = in.readInt();
+ while (size-- != 0) {
+ int key = in.readInt();
+ String value = in.readString();
+ capabilities.mCapabilities.put(key, value);
+ }
+ return capabilities;
+ }
+
+ public LinkCapabilities[] newArray(int size) {
+ return new LinkCapabilities[size];
+ }
+ };
+
+ /**
+ * Debug logging
+ */
+ protected static void log(String s) {
+ Log.d(TAG, s);
+ }
+}
diff --git a/core/java/android/net/MobileDataStateTracker.java b/core/java/android/net/MobileDataStateTracker.java
index 63bdf8d..3df8ec0 100644
--- a/core/java/android/net/MobileDataStateTracker.java
+++ b/core/java/android/net/MobileDataStateTracker.java
@@ -57,6 +57,7 @@ public class MobileDataStateTracker implements NetworkStateTracker {
private Handler mTarget;
private Context mContext;
private LinkProperties mLinkProperties;
+ private LinkCapabilities mLinkCapabilities;
private boolean mPrivateDnsRouteSet = false;
private int mDefaultGatewayAddr = 0;
private boolean mDefaultRouteSet = false;
@@ -231,8 +232,14 @@ public class MobileDataStateTracker implements NetworkStateTracker {
mLinkProperties = intent.getParcelableExtra(
Phone.DATA_LINK_PROPERTIES_KEY);
if (mLinkProperties == null) {
- Log.d(TAG,
- "CONNECTED event did not supply link properties.");
+ Log.d(TAG, "CONNECTED event did not supply link properties.");
+ mLinkProperties = new LinkProperties();
+ }
+ mLinkCapabilities = intent.getParcelableExtra(
+ Phone.DATA_LINK_CAPABILITIES_KEY);
+ if (mLinkCapabilities == null) {
+ Log.d(TAG, "CONNECTED event did not supply link capabilities.");
+ mLinkCapabilities = new LinkCapabilities();
}
setDetailedState(DetailedState.CONNECTED, reason, apnName);
break;
@@ -517,7 +524,17 @@ public class MobileDataStateTracker implements NetworkStateTracker {
}
}
+ /**
+ * @see android.net.NetworkStateTracker#getLinkProperties()
+ */
public LinkProperties getLinkProperties() {
return new LinkProperties(mLinkProperties);
}
+
+ /**
+ * @see android.net.NetworkStateTracker#getLinkCapabilities()
+ */
+ public LinkCapabilities getLinkCapabilities() {
+ return new LinkCapabilities(mLinkCapabilities);
+ }
}
diff --git a/core/java/android/net/NetworkStateTracker.java b/core/java/android/net/NetworkStateTracker.java
index 5420d8f..97c31fa 100644
--- a/core/java/android/net/NetworkStateTracker.java
+++ b/core/java/android/net/NetworkStateTracker.java
@@ -103,11 +103,21 @@ public interface NetworkStateTracker {
public NetworkInfo getNetworkInfo();
/**
- * Fetch LinkProperties for the network
+ * Return the LinkProperties for the connection.
+ *
+ * @return a copy of the LinkProperties, is never null.
*/
public LinkProperties getLinkProperties();
/**
+ * A capability is an Integer/String pair, the capabilities
+ * are defined in the class LinkSocket#Key.
+ *
+ * @return a copy of this connections capabilities, may be empty but never null.
+ */
+ public LinkCapabilities getLinkCapabilities();
+
+ /**
* Return the system properties name associated with the tcp buffer sizes
* for this network.
*/
generated by cgit v1.1 at 2025-08-18 05:48:35 +0000