1 files changed, 362 insertions, 0 deletions
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);
+    }
+}