Add NetworkCapabilities part of API. (1448f054) · Commits · e / os / android_frameworks_base

core/java/android/net/NetworkCapabilities.aidl

0 → 100644

+21 −0

Original line number	Diff line number	Diff line
		/*
		**
		** Copyright (C) 2014 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 NetworkCapabilities;

core/java/android/net/NetworkCapabilities.java

0 → 100644

+312 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 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.Parcel;
		import android.os.Parcelable;
		import android.util.Log;

		import java.lang.IllegalArgumentException;
		import java.util.ArrayList;
		import java.util.Collection;
		import java.util.HashMap;
		import java.util.Iterator;
		import java.util.Map;
		import java.util.Map.Entry;
		import java.util.Set;

		/**
		* A class representing the capabilities of a network
		* @hide
		*/
		public final class NetworkCapabilities implements Parcelable {
		private static final String TAG = "NetworkCapabilities";
		private static final boolean DBG = false;


		/**
		* Represents the network's capabilities. If any are specified they will be satisfied
		* by any Network that matches all of them.
		*/
		private long mNetworkCapabilities = (1 << NET_CAPABILITY_NOT_RESTRICTED);

		/**
		* Values for NetworkCapabilities. Roughly matches/extends deprecated
		* ConnectivityManager TYPE_*
		*/
		public static final int NET_CAPABILITY_MMS = 0;
		public static final int NET_CAPABILITY_SUPL = 1;
		public static final int NET_CAPABILITY_DUN = 2;
		public static final int NET_CAPABILITY_FOTA = 3;
		public static final int NET_CAPABILITY_IMS = 4;
		public static final int NET_CAPABILITY_CBS = 5;
		public static final int NET_CAPABILITY_WIFI_P2P = 6;
		public static final int NET_CAPABILITY_IA = 7;
		public static final int NET_CAPABILITY_RCS = 8;
		public static final int NET_CAPABILITY_XCAP = 9;
		public static final int NET_CAPABILITY_EIMS = 10;
		public static final int NET_CAPABILITY_NOT_METERED = 11;
		public static final int NET_CAPABILITY_INTERNET = 12;
		/** Set by default */
		public static final int NET_CAPABILITY_NOT_RESTRICTED = 13;

		private static final int MIN_NET_CAPABILITY = NET_CAPABILITY_MMS;
		private static final int MAX_NET_CAPABILITY = NET_CAPABILITY_NOT_RESTRICTED;

		public void addNetworkCapability(int networkCapability) {
		if (networkCapability < MIN_NET_CAPABILITY \|\|
		networkCapability > MAX_NET_CAPABILITY) {
		throw new IllegalArgumentException("NetworkCapability out of range");
		}
		mNetworkCapabilities \|= 1 << networkCapability;
		}
		public void removeNetworkCapability(int networkCapability) {
		if (networkCapability < MIN_NET_CAPABILITY \|\|
		networkCapability > MAX_NET_CAPABILITY) {
		throw new IllegalArgumentException("NetworkCapability out of range");
		}
		mNetworkCapabilities &= ~(1 << networkCapability);
		}
		public Collection<Integer> getNetworkCapabilities() {
		return enumerateBits(mNetworkCapabilities);
		}

		private Collection<Integer> enumerateBits(long val) {
		ArrayList<Integer> result = new ArrayList<Integer>();
		int resource = 0;
		while (val > 0) {
		if ((val & 1) == 1) result.add(resource);
		val = val >> 1;
		resource++;
		}
		return result;
		}

		private void combineNetCapabilities(NetworkCapabilities nc) {
		this.mNetworkCapabilities \|= nc.mNetworkCapabilities;
		}

		private boolean satisfiedByNetCapabilities(NetworkCapabilities nc) {
		return ((nc.mNetworkCapabilities & this.mNetworkCapabilities) == this.mNetworkCapabilities);
		}

		private boolean equalsNetCapabilities(NetworkCapabilities nc) {
		return (nc.mNetworkCapabilities == this.mNetworkCapabilities);
		}

		/**
		* Representing the transport type. Apps should generally not care about transport. A
		* request for a fast internet connection could be satisfied by a number of different
		* transports. If any are specified here it will be satisfied a Network that matches
		* any of them. If a caller doesn't care about the transport it should not specify any.
		*/
		private long mTransportTypes;

		/**
		* Values for TransportType
		*/
		public static final int TRANSPORT_CELLULAR = 0;
		public static final int TRANSPORT_WIFI = 1;
		public static final int TRANSPORT_BLUETOOTH = 2;
		public static final int TRANSPORT_ETHERNET = 3;

		private static final int MIN_TRANSPORT = TRANSPORT_CELLULAR;
		private static final int MAX_TRANSPORT = TRANSPORT_ETHERNET;

		public void addTransportType(int transportType) {
		if (transportType < MIN_TRANSPORT \|\| transportType > MAX_TRANSPORT) {
		throw new IllegalArgumentException("TransportType out of range");
		}
		mTransportTypes \|= 1 << transportType;
		}
		public void removeTransportType(int transportType) {
		if (transportType < MIN_TRANSPORT \|\| transportType > MAX_TRANSPORT) {
		throw new IllegalArgumentException("TransportType out of range");
		}
		mTransportTypes &= ~(1 << transportType);
		}
		public Collection<Integer> getTransportTypes() {
		return enumerateBits(mTransportTypes);
		}

		private void combineTransportTypes(NetworkCapabilities nc) {
		this.mTransportTypes \|= nc.mTransportTypes;
		}
		private boolean satisfiedByTransportTypes(NetworkCapabilities nc) {
		return ((this.mTransportTypes == 0) \|\|
		((this.mTransportTypes & nc.mTransportTypes) != 0));
		}
		private boolean equalsTransportTypes(NetworkCapabilities nc) {
		return (nc.mTransportTypes == this.mTransportTypes);
		}

		/**
		* Passive link bandwidth. This is a rough guide of the expected peak bandwidth
		* for the first hop on the given transport. It is not measured, but may take into account
		* link parameters (Radio technology, allocated channels, etc).
		*/
		private int mLinkUpBandwidthKbps;
		private int mLinkDownBandwidthKbps;

		public void setLinkUpstreamBandwidthKbps(int upKbps) {
		mLinkUpBandwidthKbps = upKbps;
		}
		public int getLinkUpstreamBandwidthKbps() {
		return mLinkUpBandwidthKbps;
		}
		public void setLinkDownstreamBandwidthKbps(int downKbps) {
		mLinkDownBandwidthKbps = downKbps;
		}
		public int getLinkDownstreamBandwidthKbps() {
		return mLinkDownBandwidthKbps;
		}

		private void combineLinkBandwidths(NetworkCapabilities nc) {
		this.mLinkUpBandwidthKbps =
		Math.max(this.mLinkUpBandwidthKbps, nc.mLinkUpBandwidthKbps);
		this.mLinkDownBandwidthKbps =
		Math.max(this.mLinkDownBandwidthKbps, nc.mLinkDownBandwidthKbps);
		}
		private boolean satisfiedByLinkBandwidths(NetworkCapabilities nc) {
		return !(this.mLinkUpBandwidthKbps > nc.mLinkUpBandwidthKbps \|\|
		this.mLinkDownBandwidthKbps > nc.mLinkDownBandwidthKbps);
		}
		private boolean equalsLinkBandwidths(NetworkCapabilities nc) {
		return (this.mLinkUpBandwidthKbps == nc.mLinkUpBandwidthKbps &&
		this.mLinkDownBandwidthKbps == nc.mLinkDownBandwidthKbps);
		}

		/**
		* Combine a set of Capabilities to this one. Useful for coming up with the complete set
		* {@hide}
		*/
		public void combineCapabilities(NetworkCapabilities nc) {
		combineNetCapabilities(nc);
		combineTransportTypes(nc);
		combineLinkBandwidths(nc);
		}

		/**
		* Check if our requirements are satisfied by the given Capabilities.
		* {@hide}
		*/
		public boolean satisfiedByNetworkCapabilities(NetworkCapabilities nc) {
		return (satisfiedByNetCapabilities(nc) &&
		satisfiedByTransportTypes(nc) &&
		satisfiedByLinkBandwidths(nc));
		}

		@Override
		public boolean equals(Object obj) {
		if (obj == null \|\| (obj instanceof NetworkCapabilities == false)) return false;
		NetworkCapabilities that = (NetworkCapabilities)obj;
		return (equalsNetCapabilities(that) &&
		equalsTransportTypes(that) &&
		equalsLinkBandwidths(that));
		}

		@Override
		public int hashCode() {
		return ((int)(mNetworkCapabilities & 0xFFFFFFFF) +
		((int)(mNetworkCapabilities >> 32) * 3) +
		((int)(mTransportTypes & 0xFFFFFFFF) * 5) +
		((int)(mTransportTypes >> 32) * 7) +
		(mLinkUpBandwidthKbps * 11) +
		(mLinkDownBandwidthKbps * 13));
		}

		public NetworkCapabilities() {
		}

		public NetworkCapabilities(NetworkCapabilities nc) {
		mNetworkCapabilities = nc.mNetworkCapabilities;
		mTransportTypes = nc.mTransportTypes;
		mLinkUpBandwidthKbps = nc.mLinkUpBandwidthKbps;
		mLinkDownBandwidthKbps = nc.mLinkDownBandwidthKbps;
		}

		// Parcelable
		public int describeContents() {
		return 0;
		}
		public void writeToParcel(Parcel dest, int flags) {
		dest.writeLong(mNetworkCapabilities);
		dest.writeLong(mTransportTypes);
		dest.writeInt(mLinkUpBandwidthKbps);
		dest.writeInt(mLinkDownBandwidthKbps);
		}
		public static final Creator<NetworkCapabilities> CREATOR =
		new Creator<NetworkCapabilities>() {
		public NetworkCapabilities createFromParcel(Parcel in) {
		NetworkCapabilities netCap = new NetworkCapabilities();

		netCap.mNetworkCapabilities = in.readLong();
		netCap.mTransportTypes = in.readLong();
		netCap.mLinkUpBandwidthKbps = in.readInt();
		netCap.mLinkDownBandwidthKbps = in.readInt();
		return netCap;
		}
		public NetworkCapabilities[] newArray(int size) {
		return new NetworkCapabilities[size];
		}
		};

		public String toString() {
		Collection<Integer> types = getTransportTypes();
		String transports = (types.size() > 0 ? " Transports: " : "");
		Iterator<Integer> i = types.iterator();
		while (i.hasNext()) {
		switch (i.next()) {
		case TRANSPORT_CELLULAR: transports += "CELLULAR"; break;
		case TRANSPORT_WIFI: transports += "WIFI"; break;
		case TRANSPORT_BLUETOOTH: transports += "BLUETOOTH"; break;
		case TRANSPORT_ETHERNET: transports += "ETHERNET"; break;
		}
		if (i.hasNext()) transports += "\|";
		}

		types = getNetworkCapabilities();
		String capabilities = (types.size() > 0 ? " Capabilities: " : "");
		i = types.iterator();
		while (i.hasNext()) {
		switch (i.next().intValue()) {
		case NET_CAPABILITY_MMS: capabilities += "MMS"; break;
		case NET_CAPABILITY_SUPL: capabilities += "SUPL"; break;
		case NET_CAPABILITY_DUN: capabilities += "DUN"; break;
		case NET_CAPABILITY_FOTA: capabilities += "FOTA"; break;
		case NET_CAPABILITY_IMS: capabilities += "IMS"; break;
		case NET_CAPABILITY_CBS: capabilities += "CBS"; break;
		case NET_CAPABILITY_WIFI_P2P: capabilities += "WIFI_P2P"; break;
		case NET_CAPABILITY_IA: capabilities += "IA"; break;
		case NET_CAPABILITY_RCS: capabilities += "RCS"; break;
		case NET_CAPABILITY_XCAP: capabilities += "XCAP"; break;
		case NET_CAPABILITY_EIMS: capabilities += "EIMS"; break;
		case NET_CAPABILITY_NOT_METERED: capabilities += "NOT_METERED"; break;
		case NET_CAPABILITY_INTERNET: capabilities += "INTERNET"; break;
		case NET_CAPABILITY_NOT_RESTRICTED: capabilities += "NOT_RESTRICTED"; break;
		}
		if (i.hasNext()) capabilities += "&";
		}

		String upBand = ((mLinkUpBandwidthKbps > 0) ? " LinkUpBandwidth>=" +
		mLinkUpBandwidthKbps + "Kbps" : "");
		String dnBand = ((mLinkDownBandwidthKbps > 0) ? " LinkDnBandwidth>=" +
		mLinkDownBandwidthKbps + "Kbps" : "");

		return "NetworkCapabilities: [" + transports + capabilities + upBand + dnBand + "]";
		}
		}