Remove more unused classes (ac2158f9) · Commits · e / os / Message

android-smsmms/src/main/java/android/net/NetworkIdentity.java

deleted100755 → 0

+0 −227

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2011 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.content.Context;
		import android.net.wifi.WifiInfo;
		import android.net.wifi.WifiManager;
		import android.os.Build;
		import android.telephony.TelephonyManager;
		import com.android.internal.util.Objects;

		import static android.net.ConnectivityManager.TYPE_WIFI;

		/**
		* Network definition that includes strong identity. Analogous to combining
		* {@link NetworkInfo} and an IMSI.
		*
		* @hide
		*/
		public class NetworkIdentity {
		/**
		* When enabled, combine all {@link #mSubType} together under
		* {@link #SUBTYPE_COMBINED}.
		*/
		public static final boolean COMBINE_SUBTYPE_ENABLED = true;

		public static final int SUBTYPE_COMBINED = -1;

		final int mType;
		final int mSubType;
		final String mSubscriberId;
		final String mNetworkId;
		final boolean mRoaming;

		public NetworkIdentity(
		int type, int subType, String subscriberId, String networkId, boolean roaming) {
		mType = type;
		mSubType = COMBINE_SUBTYPE_ENABLED ? SUBTYPE_COMBINED : subType;
		mSubscriberId = subscriberId;
		mNetworkId = networkId;
		mRoaming = roaming;
		}

		/**
		* {@hide}
		*/
		public static String getNetworkTypeName(int type) {
		switch (type) {
		case 0:
		return "MOBILE";
		case TYPE_WIFI:
		return "WIFI";
		case 2:
		return "MOBILE_MMS";
		case 3:
		return "MOBILE_SUPL";
		case 4:
		return "MOBILE_DUN";
		case 5:
		return "MOBILE_HIPRI";
		case 6:
		return "WIMAX";
		case 7:
		return "BLUETOOTH";
		case 8:
		return "DUMMY";
		case 9:
		return "ETHERNET";
		case 10:
		return "MOBILE_FOTA";
		case 11:
		return "MOBILE_IMS";
		case 12:
		return "MOBILE_CBS";
		case 13:
		return "WIFI_P2P";
		default:
		return Integer.toString(type);
		}
		}

		/**
		* {@hide}
		*/
		public static boolean isNetworkTypeMobile(int networkType) {
		switch (networkType) {
		case 0:
		case 2:
		case 3:
		case 4:
		case 5:
		case 10:
		case 11:
		case 12:
		return true;
		default:
		return false;
		}
		}

		@Override
		public int hashCode() {
		return Objects.hashCode(mType, mSubType, mSubscriberId, mNetworkId, mRoaming);
		}

		@Override
		public boolean equals(Object obj) {
		if (obj instanceof NetworkIdentity) {
		final NetworkIdentity ident = (NetworkIdentity) obj;
		return mType == ident.mType && mSubType == ident.mSubType && mRoaming == ident.mRoaming
		&& Objects.equal(mSubscriberId, ident.mSubscriberId)
		&& Objects.equal(mNetworkId, ident.mNetworkId);
		}
		return false;
		}

		@Override
		public String toString() {
		final StringBuilder builder = new StringBuilder("[");
		builder.append("type=").append(getNetworkTypeName(mType));
		builder.append(", subType=");
		if (COMBINE_SUBTYPE_ENABLED) {
		builder.append("COMBINED");
		} else if (isNetworkTypeMobile(mType)) {
		builder.append(getNetworkTypeName(mSubType));
		} else {
		builder.append(mSubType);
		}
		if (mSubscriberId != null) {
		builder.append(", subscriberId=").append(scrubSubscriberId(mSubscriberId));
		}
		if (mNetworkId != null) {
		builder.append(", networkId=").append(mNetworkId);
		}
		if (mRoaming) {
		builder.append(", ROAMING");
		}
		return builder.append("]").toString();
		}

		public int getType() {
		return mType;
		}

		public int getSubType() {
		return mSubType;
		}

		public String getSubscriberId() {
		return mSubscriberId;
		}

		public String getNetworkId() {
		return mNetworkId;
		}

		public boolean getRoaming() {
		return mRoaming;
		}

		/**
		* Scrub given IMSI on production builds.
		*/
		public static String scrubSubscriberId(String subscriberId) {
		if ("eng".equals(Build.TYPE)) {
		return subscriberId;
		} else if (subscriberId != null) {
		// TODO: parse this as MCC+MNC instead of hard-coding
		return subscriberId.substring(0, Math.min(6, subscriberId.length())) + "...";
		} else {
		return "null";
		}
		}

		/**
		* Build a {@link NetworkIdentity} from the given {@link NetworkState},
		* assuming that any mobile networks are using the current IMSI.
		*/
		public static NetworkIdentity buildNetworkIdentity(Context context, NetworkState state) {
		final int type = state.networkInfo.getType();
		final int subType = state.networkInfo.getSubtype();

		// TODO: consider moving subscriberId over to LinkCapabilities, so it
		// comes from an authoritative source.

		String subscriberId = null;
		String networkId = null;
		boolean roaming = false;

		if (isNetworkTypeMobile(type)) {
		final TelephonyManager telephony = (TelephonyManager) context.getSystemService(
		Context.TELEPHONY_SERVICE);
		roaming = telephony.isNetworkRoaming();
		if (state.subscriberId != null) {
		subscriberId = state.subscriberId;
		} else {
		subscriberId = telephony.getSubscriberId();
		}

		} else if (type == TYPE_WIFI) {
		if (state.networkId != null) {
		networkId = state.networkId;
		} else {
		final WifiManager wifi = (WifiManager) context.getSystemService(
		Context.WIFI_SERVICE);
		final WifiInfo info = wifi.getConnectionInfo();
		networkId = info != null ? info.getSSID() : null;
		}
		}

		return new NetworkIdentity(type, subType, subscriberId, networkId, roaming);
		}
		}

android-smsmms/src/main/java/com/android/internal/util/ArrayUtils.java

deleted100755 → 0

+0 −243

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2006 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.internal.util;

		import java.lang.reflect.Array;

		// XXX these should be changed to reflect the actual memory allocator we use.
		// it looks like right now objects want to be powers of 2 minus 8
		// and the array size eats another 4 bytes

		/**
		* ArrayUtils contains some methods that you can call to find out
		* the most efficient increments by which to grow arrays.
		*/
		public class ArrayUtils {
		private static Object[] EMPTY = new Object[0];
		private static final int CACHE_SIZE = 73;
		private static Object[] sCache = new Object[CACHE_SIZE];

		private ArrayUtils() { /* cannot be instantiated */ }

		public static int idealByteArraySize(int need) {
		for (int i = 4; i < 32; i++)
		if (need <= (1 << i) - 12)
		return (1 << i) - 12;

		return need;
		}

		public static int idealBooleanArraySize(int need) {
		return idealByteArraySize(need);
		}

		public static int idealShortArraySize(int need) {
		return idealByteArraySize(need * 2) / 2;
		}

		public static int idealCharArraySize(int need) {
		return idealByteArraySize(need * 2) / 2;
		}

		public static int idealIntArraySize(int need) {
		return idealByteArraySize(need * 4) / 4;
		}

		public static int idealFloatArraySize(int need) {
		return idealByteArraySize(need * 4) / 4;
		}

		public static int idealObjectArraySize(int need) {
		return idealByteArraySize(need * 4) / 4;
		}

		public static int idealLongArraySize(int need) {
		return idealByteArraySize(need * 8) / 8;
		}

		/**
		* Checks if the beginnings of two byte arrays are equal.
		*
		* @param array1 the first byte array
		* @param array2 the second byte array
		* @param length the number of bytes to check
		* @return true if they're equal, false otherwise
		*/
		public static boolean equals(byte[] array1, byte[] array2, int length) {
		if (array1 == array2) {
		return true;
		}
		if (array1 == null \|\| array2 == null \|\| array1.length < length \|\| array2.length < length) {
		return false;
		}
		for (int i = 0; i < length; i++) {
		if (array1[i] != array2[i]) {
		return false;
		}
		}
		return true;
		}

		/**
		* Returns an empty array of the specified type. The intent is that
		* it will return the same empty array every time to avoid reallocation,
		* although this is not guaranteed.
		*/
		@SuppressWarnings("unchecked")
		public static <T> T[] emptyArray(Class<T> kind) {
		if (kind == Object.class) {
		return (T[]) EMPTY;
		}

		int bucket = ((System.identityHashCode(kind) / 8) & 0x7FFFFFFF) % CACHE_SIZE;
		Object cache = sCache[bucket];

		if (cache == null \|\| cache.getClass().getComponentType() != kind) {
		cache = Array.newInstance(kind, 0);
		sCache[bucket] = cache;

		// Log.e("cache", "new empty " + kind.getName() + " at " + bucket);
		}

		return (T[]) cache;
		}

		/**
		* Checks that value is present as at least one of the elements of the array.
		*
		* @param array the array to check in
		* @param value the value to check for
		* @return true if the value is present in the array
		*/
		public static <T> boolean contains(T[] array, T value) {
		for (T element : array) {
		if (element == null) {
		if (value == null) return true;
		} else {
		if (value != null && element.equals(value)) return true;
		}
		}
		return false;
		}

		public static boolean contains(int[] array, int value) {
		for (int element : array) {
		if (element == value) {
		return true;
		}
		}
		return false;
		}

		public static long total(long[] array) {
		long total = 0;
		for (long value : array) {
		total += value;
		}
		return total;
		}

		/**
		* Appends an element to a copy of the array and returns the copy.
		*
		* @param array The original array, or null to represent an empty array.
		* @param element The element to add.
		* @return A new array that contains all of the elements of the original array
		* with the specified element added at the end.
		*/
		@SuppressWarnings("unchecked")
		public static <T> T[] appendElement(Class<T> kind, T[] array, T element) {
		final T[] result;
		final int end;
		if (array != null) {
		end = array.length;
		result = (T[]) Array.newInstance(kind, end + 1);
		System.arraycopy(array, 0, result, 0, end);
		} else {
		end = 0;
		result = (T[]) Array.newInstance(kind, 1);
		}
		result[end] = element;
		return result;
		}

		/**
		* Removes an element from a copy of the array and returns the copy.
		* If the element is not present, then the original array is returned unmodified.
		*
		* @param array The original array, or null to represent an empty array.
		* @param element The element to remove.
		* @return A new array that contains all of the elements of the original array
		* except the first copy of the specified element removed. If the specified element
		* was not present, then returns the original array. Returns null if the result
		* would be an empty array.
		*/
		@SuppressWarnings("unchecked")
		public static <T> T[] removeElement(Class<T> kind, T[] array, T element) {
		if (array != null) {
		final int length = array.length;
		for (int i = 0; i < length; i++) {
		if (array[i] == element) {
		if (length == 1) {
		return null;
		}
		T[] result = (T[]) Array.newInstance(kind, length - 1);
		System.arraycopy(array, 0, result, 0, i);
		System.arraycopy(array, i + 1, result, i, length - i - 1);
		return result;
		}
		}
		}
		return array;
		}

		public static int[] appendInt(int[] cur, int val) {
		if (cur == null) {
		return new int[]{val};
		}
		final int N = cur.length;
		for (int i = 0; i < N; i++) {
		if (cur[i] == val) {
		return cur;
		}
		}
		int[] ret = new int[N + 1];
		System.arraycopy(cur, 0, ret, 0, N);
		ret[N] = val;
		return ret;
		}

		public static int[] removeInt(int[] cur, int val) {
		if (cur == null) {
		return null;
		}
		final int N = cur.length;
		for (int i = 0; i < N; i++) {
		if (cur[i] == val) {
		int[] ret = new int[N - 1];
		if (i > 0) {
		System.arraycopy(cur, 0, ret, 0, i);
		}
		if (i < (N - 1)) {
		System.arraycopy(cur, i + 1, ret, i, N - i - 1);
		}
		return ret;
		}
		}
		return cur;
		}
		}

android-smsmms/src/main/java/com/android/internal/util/Objects.java

deleted100755 → 0

+0 −62

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2007 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.internal.util;

		import java.util.Arrays;

		/**
		* Object utility methods.
		*/
		public class Objects {

		/**
		* Determines whether two possibly-null objects are equal. Returns:
		* <p/>
		* <ul>
		* <li>{@code true} if {@code a} and {@code b} are both null.
		* <li>{@code true} if {@code a} and {@code b} are both non-null and they are
		* equal according to {@link Object#equals(Object)}.
		* <li>{@code false} in all other situations.
		* </ul>
		* <p/>
		* <p>This assumes that any non-null objects passed to this function conform
		* to the {@code equals()} contract.
		*/
		public static boolean equal(Object a, Object b) {
		return a == b \|\| (a != null && a.equals(b));
		}

		/**
		* Generates a hash code for multiple values. The hash code is generated by
		* calling {@link Arrays#hashCode(Object[])}.
		* <p/>
		* <p>This is useful for implementing {@link Object#hashCode()}. For example,
		* in an object that has three properties, {@code x}, {@code y}, and
		* {@code z}, one could write:
		* <pre>
		* public int hashCode() {
		* return Objects.hashCode(getX(), getY(), getZ());
		* }</pre>
		*
		* <b>Warning</b>: When a single object is supplied, the returned hash code
		* does not equal the hash code of that object.
		*/
		public static int hashCode(Object... objects) {
		return Arrays.hashCode(objects);
		}

		}

android-smsmms/src/main/java/com/android/internal/util/Preconditions.java

deleted100755 → 0

+0 −69

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2011 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.internal.util;

		/**
		* Simple static methods to be called at the start of your own methods to verify
		* correct arguments and state.
		*/
		public class Preconditions {

		/**
		* Ensures that an object reference passed as a parameter to the calling
		* method is not null.
		*
		* @param reference an object reference
		* @return the non-null reference that was validated
		* @throws NullPointerException if {@code reference} is null
		*/
		public static <T> T checkNotNull(T reference) {
		if (reference == null) {
		throw new NullPointerException();
		}
		return reference;
		}

		/**
		* Ensures that an object reference passed as a parameter to the calling
		* method is not null.
		*
		* @param reference an object reference
		* @param errorMessage the exception message to use if the check fails; will
		* be converted to a string using {@link String#valueOf(Object)}
		* @return the non-null reference that was validated
		* @throws NullPointerException if {@code reference} is null
		*/
		public static <T> T checkNotNull(T reference, Object errorMessage) {
		if (reference == null) {
		throw new NullPointerException(String.valueOf(errorMessage));
		}
		return reference;
		}

		/**
		* Ensures the truth of an expression involving the state of the calling
		* instance, but not involving any parameters to the calling method.
		*
		* @param expression a boolean expression
		* @throws IllegalStateException if {@code expression} is false
		*/
		public static void checkState(boolean expression) {
		if (!expression) {
		throw new IllegalStateException();
		}
		}
		}