Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Introduce CarrierPrivilegesCallback to replace CarrierPrivilegesListener"

Browse Source
This commit is contained in:
Rambo Wang
2022-03-23 13:44:09 +00:00
committed by Gerrit Code Review
parent 14087b39d1 aa1e3b0a67
commit cabb6b9362
5 changed files with 270 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

203
core/java/android/telephony/TelephonyRegistryManager.java
View File

@@ -27,6 +27,7 @@ import android.os.Binder;
import android.os.Build;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.service.carrier.CarrierService;
import android.telephony.Annotation.CallState;
import android.telephony.Annotation.DataActivityType;
import android.telephony.Annotation.DisconnectCauses;
@@ -36,6 +37,7 @@ import android.telephony.Annotation.PreciseDisconnectCauses;
import android.telephony.Annotation.RadioPowerState;
import android.telephony.Annotation.SimActivationState;
import android.telephony.Annotation.SrvccState;
import android.telephony.TelephonyManager.CarrierPrivilegesCallback;
import android.telephony.TelephonyManager.CarrierPrivilegesListener;
import android.telephony.emergency.EmergencyNumber;
import android.telephony.ims.ImsReasonInfo;
@@ -44,17 +46,19 @@ import android.util.Log;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.listeners.ListenerExecutor;
import com.android.internal.telephony.ICarrierPrivilegesListener;
import com.android.internal.telephony.ICarrierPrivilegesCallback;
import com.android.internal.telephony.IOnSubscriptionsChangedListener;
import com.android.internal.telephony.ITelephonyRegistry;
import java.lang.ref.WeakReference;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import java.util.concurrent.Executor;
import java.util.stream.Collectors;
/**
* A centralized place to notify telephony related status changes, e.g, {@link ServiceState} update
@@ -1258,34 +1262,78 @@ public class TelephonyRegistryManager {
pkgName, attributionTag, callback, new int[0], notifyNow);
}
private static class CarrierPrivilegesListenerWrapper extends ICarrierPrivilegesListener.Stub
// TODO(b/216549778): Remove listener logic once all clients switch to CarrierPrivilegesCallback
private static class CarrierPrivilegesCallbackWrapper extends ICarrierPrivilegesCallback.Stub
implements ListenerExecutor {
private final WeakReference<CarrierPrivilegesListener> mListener;
private final Executor mExecutor;
// Either mListener or mCallback may be null, never both
@Nullable private final WeakReference<CarrierPrivilegesListener> mListener;
@Nullable private final WeakReference<CarrierPrivilegesCallback> mCallback;
@NonNull private final Executor mExecutor;
CarrierPrivilegesListenerWrapper(CarrierPrivilegesListener listener, Executor executor) {
CarrierPrivilegesCallbackWrapper(
@NonNull CarrierPrivilegesCallback callback, @NonNull Executor executor) {
mListener = null;
mCallback = new WeakReference<>(callback);
mExecutor = executor;
}
CarrierPrivilegesCallbackWrapper(
@NonNull CarrierPrivilegesListener listener, @NonNull Executor executor) {
mListener = new WeakReference<>(listener);
mCallback = null;
mExecutor = executor;
}
@Override
public void onCarrierPrivilegesChanged(
List<String> privilegedPackageNames, int[] privilegedUids) {
Binder.withCleanCallingIdentity(
() ->
executeSafely(
mExecutor,
mListener::get,
cpl ->
cpl.onCarrierPrivilegesChanged(
privilegedPackageNames, privilegedUids)));
@NonNull List<String> privilegedPackageNames, @NonNull int[] privilegedUids) {
if (mListener != null) {
Binder.withCleanCallingIdentity(
() ->
executeSafely(
mExecutor,
mListener::get,
cpl ->
cpl.onCarrierPrivilegesChanged(
privilegedPackageNames, privilegedUids)));
}
if (mCallback != null) {
// AIDL interface does not support Set, keep the List/Array and translate them here
Set<String> privilegedPkgNamesSet = Set.copyOf(privilegedPackageNames);
Set<Integer> privilegedUidsSet = Arrays.stream(privilegedUids).boxed().collect(
Collectors.toSet());
Binder.withCleanCallingIdentity(
() ->
executeSafely(
mExecutor,
mCallback::get,
cpc ->
cpc.onCarrierPrivilegesChanged(
privilegedPkgNamesSet, privilegedUidsSet)));
}
}
@Override
public void onCarrierServiceChanged(@Nullable String packageName, int uid) {
if (mCallback != null) {
Binder.withCleanCallingIdentity(
() ->
executeSafely(
mExecutor,
mCallback::get,
cpc -> cpc.onCarrierServiceChanged(packageName, uid)));
}
}
}
@GuardedBy("sCarrierPrivilegeListeners")
private static final WeakHashMap<
CarrierPrivilegesListener, WeakReference<CarrierPrivilegesListenerWrapper>>
sCarrierPrivilegeListeners = new WeakHashMap<>();
// TODO(b/216549778): Change the map key to CarrierPrivilegesCallback once all clients switch to
// CarrierPrivilegesCallback. Before that, the key is either CarrierPrivilegesCallback or
// CarrierPrivilegesListener, no logic actually depends on the type.
@NonNull
@GuardedBy("sCarrierPrivilegeCallbacks")
private static final WeakHashMap<Object, WeakReference<CarrierPrivilegesCallbackWrapper>>
sCarrierPrivilegeCallbacks = new WeakHashMap<>();
/**
* Registers a {@link CarrierPrivilegesListener} on the given {@code logicalSlotIndex} to
@@ -1295,7 +1343,11 @@ public class TelephonyRegistryManager {
* @param logicalSlotIndex The SIM slot to listen on
* @param executor The executor where {@code listener} will be invoked
* @param listener The callback to register
*
* @deprecated Use {@link #addCarrierPrivilegesCallback} instead. This API will be removed
* prior to API finalization.
*/
@Deprecated
public void addCarrierPrivilegesListener(
int logicalSlotIndex,
@NonNull @CallbackExecutor Executor executor,
@@ -1303,18 +1355,18 @@ public class TelephonyRegistryManager {
if (listener == null || executor == null) {
throw new IllegalArgumentException("listener and executor must be non-null");
}
synchronized (sCarrierPrivilegeListeners) {
WeakReference<CarrierPrivilegesListenerWrapper> existing =
sCarrierPrivilegeListeners.get(listener);
synchronized (sCarrierPrivilegeCallbacks) {
WeakReference<CarrierPrivilegesCallbackWrapper> existing =
sCarrierPrivilegeCallbacks.get(listener);
if (existing != null && existing.get() != null) {
Log.d(TAG, "addCarrierPrivilegesListener: listener already registered");
return;
}
CarrierPrivilegesListenerWrapper wrapper =
new CarrierPrivilegesListenerWrapper(listener, executor);
sCarrierPrivilegeListeners.put(listener, new WeakReference<>(wrapper));
CarrierPrivilegesCallbackWrapper wrapper =
new CarrierPrivilegesCallbackWrapper(listener, executor);
sCarrierPrivilegeCallbacks.put(listener, new WeakReference<>(wrapper));
try {
sRegistry.addCarrierPrivilegesListener(
sRegistry.addCarrierPrivilegesCallback(
logicalSlotIndex,
wrapper,
mContext.getOpPackageName(),
@@ -1329,19 +1381,84 @@ public class TelephonyRegistryManager {
* Unregisters a {@link CarrierPrivilegesListener}.
*
* @param listener The callback to unregister
*
* @deprecated Use {@link #removeCarrierPrivilegesCallback} instead. The callback will prior
* to API finalization.
*/
@Deprecated
public void removeCarrierPrivilegesListener(@NonNull CarrierPrivilegesListener listener) {
if (listener == null) {
throw new IllegalArgumentException("listener must be non-null");
}
synchronized (sCarrierPrivilegeListeners) {
WeakReference<CarrierPrivilegesListenerWrapper> ref =
sCarrierPrivilegeListeners.remove(listener);
synchronized (sCarrierPrivilegeCallbacks) {
WeakReference<CarrierPrivilegesCallbackWrapper> ref =
sCarrierPrivilegeCallbacks.remove(listener);
if (ref == null) return;
CarrierPrivilegesListenerWrapper wrapper = ref.get();
CarrierPrivilegesCallbackWrapper wrapper = ref.get();
if (wrapper == null) return;
try {
sRegistry.removeCarrierPrivilegesListener(wrapper, mContext.getOpPackageName());
sRegistry.removeCarrierPrivilegesCallback(wrapper, mContext.getOpPackageName());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}
/**
* Registers a {@link CarrierPrivilegesCallback} on the given {@code logicalSlotIndex} to
* receive callbacks when the set of packages with carrier privileges changes. The callback will
* immediately be called with the latest state.
*
* @param logicalSlotIndex The SIM slot to listen on
* @param executor The executor where {@code listener} will be invoked
* @param callback The callback to register
*/
public void addCarrierPrivilegesCallback(
int logicalSlotIndex,
@NonNull @CallbackExecutor Executor executor,
@NonNull CarrierPrivilegesCallback callback) {
if (callback == null || executor == null) {
throw new IllegalArgumentException("callback and executor must be non-null");
}
synchronized (sCarrierPrivilegeCallbacks) {
WeakReference<CarrierPrivilegesCallbackWrapper> existing =
sCarrierPrivilegeCallbacks.get(callback);
if (existing != null && existing.get() != null) {
Log.d(TAG, "addCarrierPrivilegesCallback: callback already registered");
return;
}
CarrierPrivilegesCallbackWrapper wrapper =
new CarrierPrivilegesCallbackWrapper(callback, executor);
sCarrierPrivilegeCallbacks.put(callback, new WeakReference<>(wrapper));
try {
sRegistry.addCarrierPrivilegesCallback(
logicalSlotIndex,
wrapper,
mContext.getOpPackageName(),
mContext.getAttributionTag());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}
/**
* Unregisters a {@link CarrierPrivilegesCallback}.
*
* @param callback The callback to unregister
*/
public void removeCarrierPrivilegesCallback(@NonNull CarrierPrivilegesCallback callback) {
if (callback == null) {
throw new IllegalArgumentException("listener must be non-null");
}
synchronized (sCarrierPrivilegeCallbacks) {
WeakReference<CarrierPrivilegesCallbackWrapper> ref =
sCarrierPrivilegeCallbacks.remove(callback);
if (ref == null) return;
CarrierPrivilegesCallbackWrapper wrapper = ref.get();
if (wrapper == null) return;
try {
sRegistry.removeCarrierPrivilegesCallback(wrapper, mContext.getOpPackageName());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
@@ -1357,15 +1474,33 @@ public class TelephonyRegistryManager {
*/
public void notifyCarrierPrivilegesChanged(
int logicalSlotIndex,
@NonNull List<String> privilegedPackageNames,
@NonNull int[] privilegedUids) {
@NonNull Set<String> privilegedPackageNames,
@NonNull Set<Integer> privilegedUids) {
if (privilegedPackageNames == null || privilegedUids == null) {
throw new IllegalArgumentException(
"privilegedPackageNames and privilegedUids must be non-null");
}
try {
sRegistry.notifyCarrierPrivilegesChanged(
logicalSlotIndex, privilegedPackageNames, privilegedUids);
// AIDL doesn't support Set yet. Convert Set to List/Array
List<String> pkgList = List.copyOf(privilegedPackageNames);
int[] uids = privilegedUids.stream().mapToInt(Number::intValue).toArray();
sRegistry.notifyCarrierPrivilegesChanged(logicalSlotIndex, pkgList, uids);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Notify listeners that the {@link CarrierService} for current user has changed.
*
* @param logicalSlotIndex the SIM slot the change occurred on
* @param packageName the package name of the changed {@link CarrierService}
* @param uid the UID of the changed {@link CarrierService}
*/
public void notifyCarrierServiceChanged(int logicalSlotIndex, @Nullable String packageName,
int uid) {
try {
sRegistry.notifyCarrierServiceChanged(logicalSlotIndex, packageName, uid);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}

3
core/java/com/android/internal/telephony/ICarrierPrivilegesListener.aidl → core/java/com/android/internal/telephony/ICarrierPrivilegesCallback.aidl
View File

@@ -16,7 +16,8 @@
package com.android.internal.telephony;
oneway interface ICarrierPrivilegesListener {
oneway interface ICarrierPrivilegesCallback {
void onCarrierPrivilegesChanged(
in List<String> privilegedPackageNames, in int[] privilegedUids);
void onCarrierServiceChanged(in String carrierServicePackageName, in int carrierServiceUid);
}

10
core/java/com/android/internal/telephony/ITelephonyRegistry.aidl
View File

@@ -32,7 +32,7 @@ import android.telephony.PreciseDataConnectionState;
import android.telephony.ServiceState;
import android.telephony.SignalStrength;
import android.telephony.emergency.EmergencyNumber;
import com.android.internal.telephony.ICarrierPrivilegesListener;
import com.android.internal.telephony.ICarrierPrivilegesCallback;
import com.android.internal.telephony.IPhoneStateListener;
import com.android.internal.telephony.IOnSubscriptionsChangedListener;
@@ -102,9 +102,11 @@ interface ITelephonyRegistry {
void notifyLinkCapacityEstimateChanged(in int phoneId, in int subId,
in List<LinkCapacityEstimate> linkCapacityEstimateList);
void addCarrierPrivilegesListener(
int phoneId, ICarrierPrivilegesListener callback, String pkg, String featureId);
void removeCarrierPrivilegesListener(ICarrierPrivilegesListener callback, String pkg);
void addCarrierPrivilegesCallback(
int phoneId, ICarrierPrivilegesCallback callback, String pkg, String featureId);
void removeCarrierPrivilegesCallback(ICarrierPrivilegesCallback callback, String pkg);
void notifyCarrierPrivilegesChanged(
int phoneId, in List<String> privilegedPackageNames, in int[] privilegedUids);
void notifyCarrierServiceChanged(int phoneId, in String packageName, int uid);
}

97
services/core/java/com/android/server/TelephonyRegistry.java
View File

@@ -91,7 +91,7 @@ import android.util.Pair;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.app.IBatteryStats;
import com.android.internal.telephony.ICarrierPrivilegesListener;
import com.android.internal.telephony.ICarrierPrivilegesCallback;
import com.android.internal.telephony.IOnSubscriptionsChangedListener;
import com.android.internal.telephony.IPhoneStateListener;
import com.android.internal.telephony.ITelephonyRegistry;
@@ -151,7 +151,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
IPhoneStateListener callback;
IOnSubscriptionsChangedListener onSubscriptionsChangedListenerCallback;
IOnSubscriptionsChangedListener onOpportunisticSubscriptionsChangedListenerCallback;
ICarrierPrivilegesListener carrierPrivilegesListener;
ICarrierPrivilegesCallback carrierPrivilegesCallback;
int callerUid;
int callerPid;
@@ -176,8 +176,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
return (onOpportunisticSubscriptionsChangedListenerCallback != null);
}
boolean matchCarrierPrivilegesListener() {
return carrierPrivilegesListener != null;
boolean matchCarrierPrivilegesCallback() {
return carrierPrivilegesCallback != null;
}
boolean canReadCallLog() {
@@ -197,7 +197,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
+ onSubscriptionsChangedListenerCallback
+ " onOpportunisticSubscriptionsChangedListenererCallback="
+ onOpportunisticSubscriptionsChangedListenerCallback
+ " carrierPrivilegesListener=" + carrierPrivilegesListener
+ " carrierPrivilegesCallback=" + carrierPrivilegesCallback
+ " subId=" + subId + " phoneId=" + phoneId + " events=" + eventList + "}";
}
}
@@ -412,7 +412,9 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mPreciseDataConnectionStates;
/** Per-phoneId snapshot of privileged packages (names + UIDs). */
private List<Pair<List<String>, int[]>> mCarrierPrivilegeStates;
@NonNull private List<Pair<List<String>, int[]>> mCarrierPrivilegeStates;
/** Per-phoneId of CarrierService (PackageName, UID) pair. */
@NonNull private List<Pair<String, Integer>> mCarrierServiceStates;
/**
* Support backward compatibility for {@link android.telephony.TelephonyDisplayInfo}.
@@ -702,22 +704,23 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
cutListToSize(mPhysicalChannelConfigs, mNumPhones);
cutListToSize(mLinkCapacityEstimateLists, mNumPhones);
cutListToSize(mCarrierPrivilegeStates, mNumPhones);
cutListToSize(mCarrierServiceStates, mNumPhones);
return;
}
// mNumPhones > oldNumPhones: ss -> ds switch
for (int i = oldNumPhones; i < mNumPhones; i++) {
mCallState[i] = TelephonyManager.CALL_STATE_IDLE;
mCallState[i] = TelephonyManager.CALL_STATE_IDLE;
mDataActivity[i] = TelephonyManager.DATA_ACTIVITY_NONE;
mDataConnectionState[i] = TelephonyManager.DATA_UNKNOWN;
mVoiceActivationState[i] = TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
mDataActivationState[i] = TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
mCallIncomingNumber[i] = "";
mServiceState[i] = new ServiceState();
mSignalStrength[i] = null;
mCallIncomingNumber[i] = "";
mServiceState[i] = new ServiceState();
mSignalStrength[i] = null;
mUserMobileDataState[i] = false;
mMessageWaiting[i] = false;
mCallForwarding[i] = false;
mMessageWaiting[i] = false;
mCallForwarding[i] = false;
mCellIdentity[i] = null;
mCellInfo.add(i, null);
mImsReasonInfo.add(i, null);
@@ -743,6 +746,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mAllowedNetworkTypeValue[i] = -1;
mLinkCapacityEstimateLists.add(i, INVALID_LCE_LIST);
mCarrierPrivilegeStates.add(i, new Pair<>(Collections.emptyList(), new int[0]));
mCarrierServiceStates.add(i, new Pair<>(null, Process.INVALID_UID));
}
}
@@ -809,6 +813,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mDataEnabledReason = new int[numPhones];
mLinkCapacityEstimateLists = new ArrayList<>();
mCarrierPrivilegeStates = new ArrayList<>();
mCarrierServiceStates = new ArrayList<>();
for (int i = 0; i < numPhones; i++) {
mCallState[i] = TelephonyManager.CALL_STATE_IDLE;
@@ -847,6 +852,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mAllowedNetworkTypeValue[i] = -1;
mLinkCapacityEstimateLists.add(i, INVALID_LCE_LIST);
mCarrierPrivilegeStates.add(i, new Pair<>(Collections.emptyList(), new int[0]));
mCarrierServiceStates.add(i, new Pair<>(null, Process.INVALID_UID));
}
mAppOps = mContext.getSystemService(AppOpsManager.class);
@@ -2780,16 +2786,16 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
@Override
public void addCarrierPrivilegesListener(
public void addCarrierPrivilegesCallback(
int phoneId,
ICarrierPrivilegesListener callback,
String callingPackage,
String callingFeatureId) {
@NonNull ICarrierPrivilegesCallback callback,
@NonNull String callingPackage,
@NonNull String callingFeatureId) {
int callerUserId = UserHandle.getCallingUserId();
mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
mContext.enforceCallingOrSelfPermission(
android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
"addCarrierPrivilegesListener");
"addCarrierPrivilegesCallback");
if (VDBG) {
log(
"listen carrier privs: E pkg=" + pii(callingPackage) + " phoneId=" + phoneId
@@ -2809,7 +2815,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
if (r == null) return;
r.context = mContext;
r.carrierPrivilegesListener = callback;
r.carrierPrivilegesCallback = callback;
r.callingPackage = callingPackage;
r.callingFeatureId = callingFeatureId;
r.callerUid = Binder.getCallingUid();
@@ -2821,10 +2827,18 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
Pair<List<String>, int[]> state = mCarrierPrivilegeStates.get(phoneId);
Pair<String, Integer> carrierServiceState = mCarrierServiceStates.get(phoneId);
try {
r.carrierPrivilegesListener.onCarrierPrivilegesChanged(
Collections.unmodifiableList(state.first),
Arrays.copyOf(state.second, state.second.length));
if (r.matchCarrierPrivilegesCallback()) {
// Here, two callbacks are triggered in quick succession on the same binder.
// In typical case, we expect the callers to care about only one or the other.
r.carrierPrivilegesCallback.onCarrierPrivilegesChanged(
Collections.unmodifiableList(state.first),
Arrays.copyOf(state.second, state.second.length));
r.carrierPrivilegesCallback.onCarrierServiceChanged(carrierServiceState.first,
carrierServiceState.second);
}
} catch (RemoteException ex) {
remove(r.binder);
}
@@ -2832,12 +2846,12 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
@Override
public void removeCarrierPrivilegesListener(
ICarrierPrivilegesListener callback, String callingPackage) {
public void removeCarrierPrivilegesCallback(
@NonNull ICarrierPrivilegesCallback callback, @NonNull String callingPackage) {
mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
mContext.enforceCallingOrSelfPermission(
android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
"removeCarrierPrivilegesListener");
"removeCarrierPrivilegesCallback");
remove(callback.asBinder());
}
@@ -2860,13 +2874,13 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
for (Record r : mRecords) {
// Listeners are per-slot, not per-subscription. This is to provide a stable
// view across SIM profile switches.
if (!r.matchCarrierPrivilegesListener()
if (!r.matchCarrierPrivilegesCallback()
|| !idMatch(r, SubscriptionManager.INVALID_SUBSCRIPTION_ID, phoneId)) {
continue;
}
try {
// Make sure even in-process listeners can't modify the values.
r.carrierPrivilegesListener.onCarrierPrivilegesChanged(
r.carrierPrivilegesCallback.onCarrierPrivilegesChanged(
Collections.unmodifiableList(privilegedPackageNames),
Arrays.copyOf(privilegedUids, privilegedUids.length));
} catch (RemoteException ex) {
@@ -2877,6 +2891,34 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
@Override
public void notifyCarrierServiceChanged(int phoneId, @Nullable String packageName, int uid) {
if (!checkNotifyPermission("notifyCarrierServiceChanged")) return;
if (!validatePhoneId(phoneId)) return;
if (VDBG) {
log("notifyCarrierServiceChanged: phoneId=" + phoneId
+ ", package=" + pii(packageName) + ", uid=" + uid);
}
synchronized (mRecords) {
mCarrierServiceStates.set(
phoneId, new Pair<>(packageName, uid));
for (Record r : mRecords) {
// Listeners are per-slot, not per-subscription.
if (!r.matchCarrierPrivilegesCallback()
|| !idMatch(r, SubscriptionManager.INVALID_SUBSCRIPTION_ID, phoneId)) {
continue;
}
try {
r.carrierPrivilegesCallback.onCarrierServiceChanged(packageName, uid);
} catch (RemoteException ex) {
mRemoveList.add(r.binder);
}
}
handleRemoveListLocked();
}
}
@Override
public void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
final IndentingPrintWriter pw = new IndentingPrintWriter(writer, " ");
@@ -2931,6 +2973,9 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
pw.println(
"mCarrierPrivilegeState=<packages=" + pii(carrierPrivilegeState.first)
+ ", uids=" + Arrays.toString(carrierPrivilegeState.second) + ">");
Pair<String, Integer> carrierServiceState = mCarrierServiceStates.get(i);
pw.println("mCarrierServiceState=<package=" + pii(carrierServiceState.first)
+ ", uid=" + carrierServiceState.second + ">");
pw.decreaseIndent();
}

26
telephony/java/android/telephony/TelephonyManager.java
View File

@@ -16252,6 +16252,7 @@ public class TelephonyManager {
* @deprecated Use {@link CarrierPrivilegesCallback} instead. This API will be removed soon
* prior to API finalization.
*/
@Deprecated
@SystemApi
public interface CarrierPrivilegesListener {
/**
@@ -16389,8 +16390,17 @@ public class TelephonyManager {
int logicalSlotIndex,
@NonNull @CallbackExecutor Executor executor,
@NonNull CarrierPrivilegesCallback callback) {
// TODO(b/216549778): cherry-pick implementation once merge conflict is resolved
throw new UnsupportedOperationException("Not implemented, yet");
if (mContext == null) {
throw new IllegalStateException("Telephony service is null");
} else if (executor == null || callback == null) {
throw new IllegalArgumentException(
"CarrierPrivilegesCallback and executor must be non-null");
}
mTelephonyRegistryMgr = mContext.getSystemService(TelephonyRegistryManager.class);
if (mTelephonyRegistryMgr == null) {
throw new IllegalStateException("Telephony registry service is null");
}
mTelephonyRegistryMgr.addCarrierPrivilegesCallback(logicalSlotIndex, executor, callback);
}
/**
@@ -16401,7 +16411,15 @@ public class TelephonyManager {
@SystemApi
@RequiresPermission(Manifest.permission.READ_PRIVILEGED_PHONE_STATE)
public void unregisterCarrierPrivilegesCallback(@NonNull CarrierPrivilegesCallback callback) {
// TODO(b/216549778): cherry-pick implementation once merge conflict is resolved
throw new UnsupportedOperationException("Not implemented, yet");
if (mContext == null) {
throw new IllegalStateException("Telephony service is null");
} else if (callback == null) {
throw new IllegalArgumentException("CarrierPrivilegesCallback must be non-null");
}
mTelephonyRegistryMgr = mContext.getSystemService(TelephonyRegistryManager.class);
if (mTelephonyRegistryMgr == null) {
throw new IllegalStateException("Telephony registry service is null");
}
mTelephonyRegistryMgr.removeCarrierPrivilegesCallback(callback);
}
}