Merge "Cache getPhoneId and getSlotIndex binder calls." (affdc7fb) · Commits · e / os / android_frameworks_base

core/java/com/android/internal/util/FunctionalUtils.java

+27 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@ import android.os.RemoteException;
		import android.util.ExceptionUtils;

		import java.util.function.BiConsumer;
		import java.util.function.BiFunction;
		import java.util.function.Consumer;
		import java.util.function.Function;
		import java.util.function.Supplier;
		@@ -195,6 +196,32 @@ public class FunctionalUtils {
		}
		}

		/**
		* A {@link BiFunction} that allows throwing checked exceptions from its single abstract method.
		*
		* Can be used together with {@link #uncheckExceptions} to effectively turn a lambda expression
		* that throws a checked exception into a regular {@link BiFunction}
		*
		* @param <T> see {@link BiFunction}
		* @param <U> see {@link BiFunction}
		* @param <R> see {@link BiFunction}
		*/
		@FunctionalInterface
		@SuppressWarnings("FunctionalInterfaceMethodChanged")
		public interface ThrowingBiFunction<T, U, R> extends BiFunction<T, U, R> {
		/** @see ThrowingFunction */
		R applyOrThrow(T t, U u) throws Exception;

		@Override
		default R apply(T t, U u) {
		try {
		return applyOrThrow(t, u);
		} catch (Exception ex) {
		throw ExceptionUtils.propagate(ex);
		}
		}
		}

		/**
		* A {@link BiConsumer} that allows throwing checked exceptions from its single abstract method.
		*

telephony/java/android/telephony/SubscriptionManager.java

+84 −54

Original line number	Diff line number	Diff line
		@@ -148,20 +148,24 @@ public class SubscriptionManager {
		public static final String CACHE_KEY_ACTIVE_DATA_SUB_ID_PROPERTY =
		"cache_key.telephony.get_active_data_sub_id";

		/** @hide */
		public static final String CACHE_KEY_SLOT_INDEX_PROPERTY =
		"cache_key.telephony.get_slot_index";

		private static final int MAX_CACHE_SIZE = 4;

		private static class SubscriptionPropertyInvalidatedCache<T>
		private static class VoidPropertyInvalidatedCache<T>
		extends PropertyInvalidatedCache<Void, T> {
		private final FunctionalUtils.ThrowingFunction<ISub, T> mSubscriptionInterfaceMethod;
		private final FunctionalUtils.ThrowingFunction<ISub, T> mInterfaceMethod;
		private final String mCacheKeyProperty;
		private final T mDefaultValue;

		SubscriptionPropertyInvalidatedCache(
		VoidPropertyInvalidatedCache(
		FunctionalUtils.ThrowingFunction<ISub, T> subscriptionInterfaceMethod,
		String cacheKeyProperty,
		T defaultValue) {
		super(MAX_CACHE_SIZE, cacheKeyProperty);
		mSubscriptionInterfaceMethod = subscriptionInterfaceMethod;
		mInterfaceMethod = subscriptionInterfaceMethod;
		mCacheKeyProperty = cacheKeyProperty;
		mDefaultValue = defaultValue;
		}
		@@ -173,7 +177,7 @@ public class SubscriptionManager {
		try {
		ISub iSub = TelephonyManager.getSubscriptionService();
		if (iSub != null) {
		result = mSubscriptionInterfaceMethod.applyOrThrow(iSub);
		result = mInterfaceMethod.applyOrThrow(iSub);
		}
		} catch (Exception ex) {
		Rlog.w(LOG_TAG, "Failed to recompute cache key for " + mCacheKeyProperty);
		@@ -184,26 +188,71 @@ public class SubscriptionManager {
		}
		}

		private static SubscriptionPropertyInvalidatedCache<Integer> sDefaultSubIdCache =
		new SubscriptionPropertyInvalidatedCache<>(ISub::getDefaultSubId,
		private static class IntegerPropertyInvalidatedCache<T>
		extends PropertyInvalidatedCache<Integer, T> {
		private final FunctionalUtils.ThrowingBiFunction<ISub, Integer, T> mInterfaceMethod;
		private final String mCacheKeyProperty;
		private final T mDefaultValue;

		IntegerPropertyInvalidatedCache(
		FunctionalUtils.ThrowingBiFunction<ISub, Integer, T> subscriptionInterfaceMethod,
		String cacheKeyProperty,
		T defaultValue) {
		super(MAX_CACHE_SIZE, cacheKeyProperty);
		mInterfaceMethod = subscriptionInterfaceMethod;
		mCacheKeyProperty = cacheKeyProperty;
		mDefaultValue = defaultValue;
		}

		@Override
		protected T recompute(Integer query) {
		T result = mDefaultValue;

		try {
		ISub iSub = TelephonyManager.getSubscriptionService();
		if (iSub != null) {
		result = mInterfaceMethod.applyOrThrow(iSub, query);
		}
		} catch (Exception ex) {
		Rlog.w(LOG_TAG, "Failed to recompute cache key for " + mCacheKeyProperty);
		}

		if (VDBG) logd("recomputing " + mCacheKeyProperty + ", result = " + result);
		return result;
		}
		}

		private static VoidPropertyInvalidatedCache<Integer> sDefaultSubIdCache =
		new VoidPropertyInvalidatedCache<>(ISub::getDefaultSubId,
		CACHE_KEY_DEFAULT_SUB_ID_PROPERTY,
		INVALID_SUBSCRIPTION_ID);

		private static SubscriptionPropertyInvalidatedCache<Integer> sDefaultDataSubIdCache =
		new SubscriptionPropertyInvalidatedCache<>(ISub::getDefaultDataSubId,
		private static VoidPropertyInvalidatedCache<Integer> sDefaultDataSubIdCache =
		new VoidPropertyInvalidatedCache<>(ISub::getDefaultDataSubId,
		CACHE_KEY_DEFAULT_DATA_SUB_ID_PROPERTY,
		INVALID_SUBSCRIPTION_ID);

		private static PropertyInvalidatedCache<Void, Integer> sDefaultSmsSubIdCache =
		new SubscriptionPropertyInvalidatedCache<>(ISub::getDefaultSmsSubId,
		private static VoidPropertyInvalidatedCache<Integer> sDefaultSmsSubIdCache =
		new VoidPropertyInvalidatedCache<>(ISub::getDefaultSmsSubId,
		CACHE_KEY_DEFAULT_SMS_SUB_ID_PROPERTY,
		INVALID_SUBSCRIPTION_ID);

		private static PropertyInvalidatedCache<Void, Integer> sActiveDataSubIdCache =
		new SubscriptionPropertyInvalidatedCache<>(ISub::getActiveDataSubscriptionId,
		private static VoidPropertyInvalidatedCache<Integer> sActiveDataSubIdCache =
		new VoidPropertyInvalidatedCache<>(ISub::getActiveDataSubscriptionId,
		CACHE_KEY_ACTIVE_DATA_SUB_ID_PROPERTY,
		INVALID_SUBSCRIPTION_ID);

		private static IntegerPropertyInvalidatedCache<Integer> sSlotIndexCache =
		new IntegerPropertyInvalidatedCache<>(ISub::getSlotIndex,
		CACHE_KEY_SLOT_INDEX_PROPERTY,
		INVALID_SIM_SLOT_INDEX);

		/** Cache depends on getDefaultSubId, so we use the defaultSubId cache key */
		private static IntegerPropertyInvalidatedCache<Integer> sPhoneIdCache =
		new IntegerPropertyInvalidatedCache<>(ISub::getPhoneId,
		CACHE_KEY_DEFAULT_SUB_ID_PROPERTY,
		INVALID_PHONE_INDEX);

		/**
		* Generates a content {@link Uri} used to receive updates on simInfo change
		* on the given subscriptionId
		@@ -1250,7 +1299,6 @@ public class SubscriptionManager {
		}

		return subInfo;

		}

		/**
		@@ -1820,25 +1868,7 @@ public class SubscriptionManager {
		* subscriptionId doesn't have an associated slot index.
		*/
		public static int getSlotIndex(int subscriptionId) {
		if (!isValidSubscriptionId(subscriptionId)) {
		if (DBG) {
		logd("[getSlotIndex]- supplied subscriptionId is invalid.");
		}
		}

		int result = INVALID_SIM_SLOT_INDEX;

		try {
		ISub iSub = TelephonyManager.getSubscriptionService();
		if (iSub != null) {
		result = iSub.getSlotIndex(subscriptionId);
		}
		} catch (RemoteException ex) {
		// ignore it
		}

		return result;

		return sSlotIndexCache.query(subscriptionId);
		}

		/**
		@@ -1877,27 +1907,7 @@ public class SubscriptionManager {
		/** @hide */
		@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
		public static int getPhoneId(int subId) {
		if (!isValidSubscriptionId(subId)) {
		if (DBG) {
		logd("[getPhoneId]- fail");
		}
		return INVALID_PHONE_INDEX;
		}

		int result = INVALID_PHONE_INDEX;

		try {
		ISub iSub = TelephonyManager.getSubscriptionService();
		if (iSub != null) {
		result = iSub.getPhoneId(subId);
		}
		} catch (RemoteException ex) {
		// ignore it
		}

		if (VDBG) logd("[getPhoneId]- phoneId=" + result);
		return result;

		return sPhoneIdCache.query(subId);
		}

		private static void logd(String msg) {
		@@ -3330,6 +3340,11 @@ public class SubscriptionManager {
		PropertyInvalidatedCache.invalidateCache(CACHE_KEY_ACTIVE_DATA_SUB_ID_PROPERTY);
		}

		/** @hide */
		public static void invalidateSlotIndexCaches() {
		PropertyInvalidatedCache.invalidateCache(CACHE_KEY_SLOT_INDEX_PROPERTY);
		}

		/**
		* Allows a test process to disable client-side caching operations.
		*
		@@ -3340,5 +3355,20 @@ public class SubscriptionManager {
		sDefaultDataSubIdCache.disableLocal();
		sActiveDataSubIdCache.disableLocal();
		sDefaultSmsSubIdCache.disableLocal();
		sSlotIndexCache.disableLocal();
		sPhoneIdCache.disableLocal();
		}

		/**
		* Clears all process-local binder caches.
		*
		* @hide */
		public static void clearCaches() {
		sDefaultSubIdCache.clear();
		sDefaultDataSubIdCache.clear();
		sActiveDataSubIdCache.clear();
		sDefaultSmsSubIdCache.clear();
		sSlotIndexCache.clear();
		sPhoneIdCache.clear();
		}
		}

telephony/java/android/telephony/TelephonyManager.java

+1 −4

Original line number	Diff line number	Diff line
		@@ -13101,10 +13101,7 @@ public class TelephonyManager {
		if (sISub != null) {
		sISub.asBinder().unlinkToDeath(sServiceDeath, 0);
		sISub = null;
		SubscriptionManager.invalidateDefaultSubIdCaches();
		SubscriptionManager.invalidateDefaultDataSubIdCaches();
		SubscriptionManager.invalidateActiveDataSubIdCaches();
		SubscriptionManager.invalidateDefaultSmsSubIdCaches();
		SubscriptionManager.clearCaches();
		}
		if (sISms != null) {
		sISms.asBinder().unlinkToDeath(sServiceDeath, 0);