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

Merge changes from topic "PSL_TelephonyCallback"

Browse Source 
* changes:
  [Telephony] Use TelephonyCallback instead of PhoneStateListener part1
  [PhoneStateListener] Redesign PhoneStateListener: Use TelephonyCallback
This commit is contained in:
Zoey Chen
2021-03-09 10:36:03 +00:00
committed by Gerrit Code Review
parent c4f2a30c20 809f500e0d
commit 456069019e
13 changed files with 2453 additions and 2024 deletions
Download Patch File Download Diff File Expand all files Collapse all files

224
core/api/current.txt
View File

@@ -40325,29 +40325,29 @@ package android.telephony {
field public static final char WILD = 78; // 0x004e 'N'
}
public class PhoneStateListener {
ctor public PhoneStateListener();
@Deprecated public class PhoneStateListener {
ctor @Deprecated public PhoneStateListener();
ctor @Deprecated public PhoneStateListener(@NonNull java.util.concurrent.Executor);
method public void onActiveDataSubscriptionIdChanged(int);
method public void onBarringInfoChanged(@NonNull android.telephony.BarringInfo);
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onCallDisconnectCauseChanged(int, int);
method public void onCallForwardingIndicatorChanged(boolean);
method public void onCallStateChanged(int, String);
method public void onCellInfoChanged(java.util.List<android.telephony.CellInfo>);
method public void onCellLocationChanged(android.telephony.CellLocation);
method public void onDataActivity(int);
method public void onDataConnectionStateChanged(int);
method public void onDataConnectionStateChanged(int, int);
method @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public void onDisplayInfoChanged(@NonNull android.telephony.TelephonyDisplayInfo);
method public void onEmergencyNumberListChanged(@NonNull java.util.Map<java.lang.Integer,java.util.List<android.telephony.emergency.EmergencyNumber>>);
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onImsCallDisconnectCauseChanged(@NonNull android.telephony.ims.ImsReasonInfo);
method public void onMessageWaitingIndicatorChanged(boolean);
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onPreciseDataConnectionStateChanged(@NonNull android.telephony.PreciseDataConnectionState);
method public void onRegistrationFailed(@NonNull android.telephony.CellIdentity, @NonNull String, int, int, int);
method public void onServiceStateChanged(android.telephony.ServiceState);
method @Deprecated public void onActiveDataSubscriptionIdChanged(int);
method @Deprecated public void onBarringInfoChanged(@NonNull android.telephony.BarringInfo);
method @Deprecated @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onCallDisconnectCauseChanged(int, int);
method @Deprecated public void onCallForwardingIndicatorChanged(boolean);
method @Deprecated public void onCallStateChanged(int, String);
method @Deprecated public void onCellInfoChanged(java.util.List<android.telephony.CellInfo>);
method @Deprecated public void onCellLocationChanged(android.telephony.CellLocation);
method @Deprecated public void onDataActivity(int);
method @Deprecated public void onDataConnectionStateChanged(int);
method @Deprecated public void onDataConnectionStateChanged(int, int);
method @Deprecated @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public void onDisplayInfoChanged(@NonNull android.telephony.TelephonyDisplayInfo);
method @Deprecated public void onEmergencyNumberListChanged(@NonNull java.util.Map<java.lang.Integer,java.util.List<android.telephony.emergency.EmergencyNumber>>);
method @Deprecated @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onImsCallDisconnectCauseChanged(@NonNull android.telephony.ims.ImsReasonInfo);
method @Deprecated public void onMessageWaitingIndicatorChanged(boolean);
method @Deprecated @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onPreciseDataConnectionStateChanged(@NonNull android.telephony.PreciseDataConnectionState);
method @Deprecated public void onRegistrationFailed(@NonNull android.telephony.CellIdentity, @NonNull String, int, int, int);
method @Deprecated public void onServiceStateChanged(android.telephony.ServiceState);
method @Deprecated public void onSignalStrengthChanged(int);
method public void onSignalStrengthsChanged(android.telephony.SignalStrength);
method public void onUserMobileDataStateChanged(boolean);
method @Deprecated public void onSignalStrengthsChanged(android.telephony.SignalStrength);
method @Deprecated public void onUserMobileDataStateChanged(boolean);
field @Deprecated public static final int LISTEN_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGE = 4194304; // 0x400000
field @Deprecated @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int LISTEN_BARRING_INFO = -2147483648; // 0x80000000
field @Deprecated @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int LISTEN_CALL_DISCONNECT_CAUSES = 33554432; // 0x2000000
@@ -40361,7 +40361,7 @@ package android.telephony {
field @Deprecated public static final int LISTEN_EMERGENCY_NUMBER_LIST = 16777216; // 0x1000000
field @Deprecated @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int LISTEN_IMS_CALL_DISCONNECT_CAUSES = 134217728; // 0x8000000
field @Deprecated public static final int LISTEN_MESSAGE_WAITING_INDICATOR = 4; // 0x4
field public static final int LISTEN_NONE = 0; // 0x0
field @Deprecated public static final int LISTEN_NONE = 0; // 0x0
field @Deprecated @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int LISTEN_PRECISE_DATA_CONNECTION_STATE = 4096; // 0x1000
field @Deprecated @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int LISTEN_REGISTRATION_FAILURE = 1073741824; // 0x40000000
field @Deprecated public static final int LISTEN_SERVICE_STATE = 1; // 0x1
@@ -40370,94 +40370,6 @@ package android.telephony {
field @Deprecated public static final int LISTEN_USER_MOBILE_DATA_STATE = 524288; // 0x80000
}
public static interface PhoneStateListener.ActiveDataSubscriptionIdChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public void onActiveDataSubscriptionIdChanged(int);
}
public static interface PhoneStateListener.AlwaysReportedSignalStrengthChangedListener {
method @RequiresPermission("android.permission.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH") public void onSignalStrengthsChanged(@NonNull android.telephony.SignalStrength);
}
public static interface PhoneStateListener.BarringInfoChangedListener {
method @RequiresPermission(allOf={android.Manifest.permission.READ_PRECISE_PHONE_STATE, android.Manifest.permission.ACCESS_FINE_LOCATION}) public void onBarringInfoChanged(@NonNull android.telephony.BarringInfo);
}
public static interface PhoneStateListener.CallDisconnectCauseChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onCallDisconnectCauseChanged(int, int);
}
public static interface PhoneStateListener.CallForwardingIndicatorChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public void onCallForwardingIndicatorChanged(boolean);
}
public static interface PhoneStateListener.CallStateChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_CALL_LOG) public void onCallStateChanged(int, @Nullable String);
}
public static interface PhoneStateListener.CarrierNetworkChangeListener {
method public void onCarrierNetworkChange(boolean);
}
public static interface PhoneStateListener.CellInfoChangedListener {
method @RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public void onCellInfoChanged(@NonNull java.util.List<android.telephony.CellInfo>);
}
public static interface PhoneStateListener.CellLocationChangedListener {
method @RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public void onCellLocationChanged(@NonNull android.telephony.CellLocation);
}
public static interface PhoneStateListener.DataActivationStateChangedListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onDataActivationStateChanged(int);
}
public static interface PhoneStateListener.DataActivityListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onDataActivity(int);
}
public static interface PhoneStateListener.DataConnectionStateChangedListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onDataConnectionStateChanged(int, int);
}
public static interface PhoneStateListener.DisplayInfoChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public void onDisplayInfoChanged(@NonNull android.telephony.TelephonyDisplayInfo);
}
public static interface PhoneStateListener.EmergencyNumberListChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public void onEmergencyNumberListChanged(@NonNull java.util.Map<java.lang.Integer,java.util.List<android.telephony.emergency.EmergencyNumber>>);
}
public static interface PhoneStateListener.ImsCallDisconnectCauseChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onImsCallDisconnectCauseChanged(@NonNull android.telephony.ims.ImsReasonInfo);
}
public static interface PhoneStateListener.MessageWaitingIndicatorChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public void onMessageWaitingIndicatorChanged(boolean);
}
public static interface PhoneStateListener.PhoneCapabilityChangedListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onPhoneCapabilityChanged(@NonNull android.telephony.PhoneCapability);
}
public static interface PhoneStateListener.PreciseDataConnectionStateChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onPreciseDataConnectionStateChanged(@NonNull android.telephony.PreciseDataConnectionState);
}
public static interface PhoneStateListener.RegistrationFailedListener {
method @RequiresPermission(allOf={android.Manifest.permission.READ_PRECISE_PHONE_STATE, android.Manifest.permission.ACCESS_FINE_LOCATION}) public void onRegistrationFailed(@NonNull android.telephony.CellIdentity, @NonNull String, int, int, int);
}
public static interface PhoneStateListener.ServiceStateChangedListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onServiceStateChanged(@NonNull android.telephony.ServiceState);
}
public static interface PhoneStateListener.SignalStrengthsChangedListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onSignalStrengthsChanged(@NonNull android.telephony.SignalStrength);
}
public static interface PhoneStateListener.UserMobileDataStateChangedListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onUserMobileDataStateChanged(boolean);
}
public final class PhysicalChannelConfig implements android.os.Parcelable {
method public int describeContents();
method @IntRange(from=1, to=261) public int getBand();
@@ -40929,6 +40841,94 @@ package android.telephony {
method public android.telephony.SubscriptionPlan.Builder setTitle(@Nullable CharSequence);
}
public class TelephonyCallback {
ctor public TelephonyCallback();
}
public static interface TelephonyCallback.ActiveDataSubscriptionIdListener {
method @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public void onActiveDataSubscriptionIdChanged(int);
}
public static interface TelephonyCallback.AlwaysReportedSignalStrengthListener {
method @RequiresPermission("android.permission.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH") public void onSignalStrengthsChanged(@NonNull android.telephony.SignalStrength);
}
public static interface TelephonyCallback.BarringInfoListener {
method @RequiresPermission(allOf={android.Manifest.permission.READ_PRECISE_PHONE_STATE, android.Manifest.permission.ACCESS_FINE_LOCATION}) public void onBarringInfoChanged(@NonNull android.telephony.BarringInfo);
}
public static interface TelephonyCallback.CallDisconnectCauseListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onCallDisconnectCauseChanged(int, int);
}
public static interface TelephonyCallback.CallForwardingIndicatorListener {
method @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public void onCallForwardingIndicatorChanged(boolean);
}
public static interface TelephonyCallback.CallStateListener {
method @RequiresPermission(android.Manifest.permission.READ_CALL_LOG) public void onCallStateChanged(int, @Nullable String);
}
public static interface TelephonyCallback.CarrierNetworkListener {
method public void onCarrierNetworkChange(boolean);
}
public static interface TelephonyCallback.CellInfoListener {
method @RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public void onCellInfoChanged(@NonNull java.util.List<android.telephony.CellInfo>);
}
public static interface TelephonyCallback.CellLocationListener {
method @RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public void onCellLocationChanged(@NonNull android.telephony.CellLocation);
}
public static interface TelephonyCallback.DataActivationStateListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onDataActivationStateChanged(int);
}
public static interface TelephonyCallback.DataActivityListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onDataActivity(int);
}
public static interface TelephonyCallback.DataConnectionStateListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onDataConnectionStateChanged(int, int);
}
public static interface TelephonyCallback.DisplayInfoListener {
method @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public void onDisplayInfoChanged(@NonNull android.telephony.TelephonyDisplayInfo);
}
public static interface TelephonyCallback.EmergencyNumberListListener {
method @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public void onEmergencyNumberListChanged(@NonNull java.util.Map<java.lang.Integer,java.util.List<android.telephony.emergency.EmergencyNumber>>);
}
public static interface TelephonyCallback.ImsCallDisconnectCauseListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onImsCallDisconnectCauseChanged(@NonNull android.telephony.ims.ImsReasonInfo);
}
public static interface TelephonyCallback.MessageWaitingIndicatorListener {
method @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public void onMessageWaitingIndicatorChanged(boolean);
}
public static interface TelephonyCallback.PreciseDataConnectionStateListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onPreciseDataConnectionStateChanged(@NonNull android.telephony.PreciseDataConnectionState);
}
public static interface TelephonyCallback.RegistrationFailedListener {
method @RequiresPermission(allOf={android.Manifest.permission.READ_PRECISE_PHONE_STATE, android.Manifest.permission.ACCESS_FINE_LOCATION}) public void onRegistrationFailed(@NonNull android.telephony.CellIdentity, @NonNull String, int, int, int);
}
public static interface TelephonyCallback.ServiceStateListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onServiceStateChanged(@NonNull android.telephony.ServiceState);
}
public static interface TelephonyCallback.SignalStrengthsListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onSignalStrengthsChanged(@NonNull android.telephony.SignalStrength);
}
public static interface TelephonyCallback.UserMobileDataStateListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onUserMobileDataStateChanged(boolean);
}
public final class TelephonyDisplayInfo implements android.os.Parcelable {
method public int describeContents();
method public int getNetworkType();
@@ -41039,7 +41039,7 @@ package android.telephony {
method public boolean isVoicemailVibrationEnabled(android.telecom.PhoneAccountHandle);
method public boolean isWorldPhone();
method @Deprecated public void listen(android.telephony.PhoneStateListener, int);
method public void registerPhoneStateListener(@NonNull java.util.concurrent.Executor, @NonNull android.telephony.PhoneStateListener);
method public void registerTelephonyCallback(@NonNull java.util.concurrent.Executor, @NonNull android.telephony.TelephonyCallback);
method @RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public void requestCellInfoUpdate(@NonNull java.util.concurrent.Executor, @NonNull android.telephony.TelephonyManager.CellInfoCallback);
method @RequiresPermission(allOf={android.Manifest.permission.MODIFY_PHONE_STATE, android.Manifest.permission.ACCESS_FINE_LOCATION}) public android.telephony.NetworkScan requestNetworkScan(android.telephony.NetworkScanRequest, java.util.concurrent.Executor, android.telephony.TelephonyScanManager.NetworkScanCallback);
method public void sendDialerSpecialCode(String);
@@ -41063,7 +41063,7 @@ package android.telephony {
method @Deprecated public void setVoicemailRingtoneUri(android.telecom.PhoneAccountHandle, android.net.Uri);
method @Deprecated public void setVoicemailVibrationEnabled(android.telecom.PhoneAccountHandle, boolean);
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void switchMultiSimConfig(int);
method public void unregisterPhoneStateListener(@NonNull android.telephony.PhoneStateListener);
method public void unregisterTelephonyCallback(@NonNull android.telephony.TelephonyCallback);
method public void updateAvailableNetworks(@NonNull java.util.List<android.telephony.AvailableNetworkInfo>, @Nullable java.util.concurrent.Executor, @Nullable java.util.function.Consumer<java.lang.Integer>);
field public static final String ACTION_CARRIER_MESSAGING_CLIENT_SERVICE = "android.telephony.action.CARRIER_MESSAGING_CLIENT_SERVICE";
field public static final String ACTION_CARRIER_SIGNAL_DEFAULT_NETWORK_AVAILABLE = "android.telephony.action.CARRIER_SIGNAL_DEFAULT_NETWORK_AVAILABLE";

173
core/api/system-current.txt
View File

@@ -9607,51 +9607,16 @@ package android.telephony {
method public static boolean isVoiceMailNumber(@NonNull android.content.Context, int, @Nullable String);
}
public class PhoneStateListener {
method public void onCallAttributesChanged(@NonNull android.telephony.CallAttributes);
@Deprecated public class PhoneStateListener {
method @Deprecated public void onCallAttributesChanged(@NonNull android.telephony.CallAttributes);
method @Deprecated public void onOutgoingEmergencyCall(@NonNull android.telephony.emergency.EmergencyNumber);
method public void onOutgoingEmergencyCall(@NonNull android.telephony.emergency.EmergencyNumber, int);
method @Deprecated public void onOutgoingEmergencyCall(@NonNull android.telephony.emergency.EmergencyNumber, int);
method @Deprecated public void onOutgoingEmergencySms(@NonNull android.telephony.emergency.EmergencyNumber);
method public void onOutgoingEmergencySms(@NonNull android.telephony.emergency.EmergencyNumber, int);
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onPreciseCallStateChanged(@NonNull android.telephony.PreciseCallState);
method public void onRadioPowerStateChanged(int);
method public void onSrvccStateChanged(int);
method public void onVoiceActivationStateChanged(int);
field @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public static final int EVENT_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGED = 23; // 0x17
field @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public static final int EVENT_ALLOWED_NETWORK_TYPE_LIST_CHANGED = 35; // 0x23
field @RequiresPermission("android.permission.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH") public static final int EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED = 10; // 0xa
field @RequiresPermission(allOf={android.Manifest.permission.READ_PRECISE_PHONE_STATE, android.Manifest.permission.ACCESS_FINE_LOCATION}) public static final int EVENT_BARRING_INFO_CHANGED = 32; // 0x20
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_CALL_ATTRIBUTES_CHANGED = 27; // 0x1b
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_CALL_DISCONNECT_CAUSE_CHANGED = 26; // 0x1a
field @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public static final int EVENT_CALL_FORWARDING_INDICATOR_CHANGED = 4; // 0x4
field @RequiresPermission(android.Manifest.permission.READ_CALL_LOG) public static final int EVENT_CALL_STATE_CHANGED = 6; // 0x6
field public static final int EVENT_CARRIER_NETWORK_CHANGED = 17; // 0x11
field @RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public static final int EVENT_CELL_INFO_CHANGED = 11; // 0xb
field @RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public static final int EVENT_CELL_LOCATION_CHANGED = 5; // 0x5
field public static final int EVENT_DATA_ACTIVATION_STATE_CHANGED = 19; // 0x13
field public static final int EVENT_DATA_ACTIVITY_CHANGED = 8; // 0x8
field @Deprecated @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_DATA_CONNECTION_REAL_TIME_INFO_CHANGED = 14; // 0xe
field public static final int EVENT_DATA_CONNECTION_STATE_CHANGED = 7; // 0x7
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_DATA_ENABLED_CHANGED = 34; // 0x22
field public static final int EVENT_DISPLAY_INFO_CHANGED = 21; // 0x15
field @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public static final int EVENT_EMERGENCY_NUMBER_LIST_CHANGED = 25; // 0x19
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_IMS_CALL_DISCONNECT_CAUSE_CHANGED = 28; // 0x1c
field @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public static final int EVENT_MESSAGE_WAITING_INDICATOR_CHANGED = 3; // 0x3
field @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public static final int EVENT_OEM_HOOK_RAW = 15; // 0xf
field @RequiresPermission(android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION) public static final int EVENT_OUTGOING_EMERGENCY_CALL = 29; // 0x1d
field @RequiresPermission(android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION) public static final int EVENT_OUTGOING_EMERGENCY_SMS = 30; // 0x1e
field public static final int EVENT_PHONE_CAPABILITY_CHANGED = 22; // 0x16
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_PHYSICAL_CHANNEL_CONFIG_CHANGED = 33; // 0x21
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_PRECISE_CALL_STATE_CHANGED = 12; // 0xc
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_PRECISE_DATA_CONNECTION_STATE_CHANGED = 13; // 0xd
field @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public static final int EVENT_RADIO_POWER_STATE_CHANGED = 24; // 0x18
field @RequiresPermission(allOf={android.Manifest.permission.READ_PRECISE_PHONE_STATE, android.Manifest.permission.ACCESS_FINE_LOCATION}) public static final int EVENT_REGISTRATION_FAILURE = 31; // 0x1f
field public static final int EVENT_SERVICE_STATE_CHANGED = 1; // 0x1
field public static final int EVENT_SIGNAL_STRENGTHS_CHANGED = 9; // 0x9
field public static final int EVENT_SIGNAL_STRENGTH_CHANGED = 2; // 0x2
field @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public static final int EVENT_SRVCC_STATE_CHANGED = 16; // 0x10
field public static final int EVENT_USER_MOBILE_DATA_STATE_CHANGED = 20; // 0x14
field @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public static final int EVENT_VOICE_ACTIVATION_STATE_CHANGED = 18; // 0x12
method @Deprecated public void onOutgoingEmergencySms(@NonNull android.telephony.emergency.EmergencyNumber, int);
method @Deprecated @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onPreciseCallStateChanged(@NonNull android.telephony.PreciseCallState);
method @Deprecated public void onRadioPowerStateChanged(int);
method @Deprecated public void onSrvccStateChanged(int);
method @Deprecated public void onVoiceActivationStateChanged(int);
field @Deprecated @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int LISTEN_CALL_ATTRIBUTES_CHANGED = 67108864; // 0x4000000
field @Deprecated @RequiresPermission(android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION) public static final int LISTEN_OUTGOING_EMERGENCY_CALL = 268435456; // 0x10000000
field @Deprecated @RequiresPermission(android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION) public static final int LISTEN_OUTGOING_EMERGENCY_SMS = 536870912; // 0x20000000
@@ -9661,46 +9626,6 @@ package android.telephony {
field @Deprecated @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public static final int LISTEN_VOICE_ACTIVATION_STATE = 131072; // 0x20000
}
public static interface PhoneStateListener.AllowedNetworkTypesChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public void onAllowedNetworkTypesChanged(@NonNull java.util.Map<java.lang.Integer,java.lang.Long>);
}
public static interface PhoneStateListener.CallAttributesChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onCallAttributesChanged(@NonNull android.telephony.CallAttributes);
}
public static interface PhoneStateListener.DataEnabledChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onDataEnabledChanged(boolean, int);
}
public static interface PhoneStateListener.OutgoingEmergencyCallListener {
method @RequiresPermission(android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION) public void onOutgoingEmergencyCall(@NonNull android.telephony.emergency.EmergencyNumber, int);
}
public static interface PhoneStateListener.OutgoingEmergencySmsListener {
method @RequiresPermission(android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION) public void onOutgoingEmergencySms(@NonNull android.telephony.emergency.EmergencyNumber, int);
}
public static interface PhoneStateListener.PhysicalChannelConfigChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onPhysicalChannelConfigChanged(@NonNull java.util.List<android.telephony.PhysicalChannelConfig>);
}
public static interface PhoneStateListener.PreciseCallStateChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onPreciseCallStateChanged(@NonNull android.telephony.PreciseCallState);
}
public static interface PhoneStateListener.RadioPowerStateChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public void onRadioPowerStateChanged(int);
}
public static interface PhoneStateListener.SrvccStateChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public void onSrvccStateChanged(int);
}
public static interface PhoneStateListener.VoiceActivationStateChangedListener {
method @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public void onVoiceActivationStateChanged(int);
}
public final class PinResult implements android.os.Parcelable {
method public int describeContents();
method public int getAttemptsRemaining();
@@ -10034,6 +9959,88 @@ package android.telephony {
method @Deprecated public static android.telephony.SubscriptionPlan.Builder createRecurringWeekly(java.time.ZonedDateTime);
}
public class TelephonyCallback {
field @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public static final int EVENT_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGED = 23; // 0x17
field @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public static final int EVENT_ALLOWED_NETWORK_TYPE_LIST_CHANGED = 35; // 0x23
field @RequiresPermission("android.permission.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH") public static final int EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED = 10; // 0xa
field @RequiresPermission(allOf={android.Manifest.permission.READ_PRECISE_PHONE_STATE, android.Manifest.permission.ACCESS_FINE_LOCATION}) public static final int EVENT_BARRING_INFO_CHANGED = 32; // 0x20
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_CALL_ATTRIBUTES_CHANGED = 27; // 0x1b
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_CALL_DISCONNECT_CAUSE_CHANGED = 26; // 0x1a
field @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public static final int EVENT_CALL_FORWARDING_INDICATOR_CHANGED = 4; // 0x4
field @RequiresPermission(android.Manifest.permission.READ_CALL_LOG) public static final int EVENT_CALL_STATE_CHANGED = 6; // 0x6
field public static final int EVENT_CARRIER_NETWORK_CHANGED = 17; // 0x11
field @RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public static final int EVENT_CELL_INFO_CHANGED = 11; // 0xb
field @RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public static final int EVENT_CELL_LOCATION_CHANGED = 5; // 0x5
field public static final int EVENT_DATA_ACTIVATION_STATE_CHANGED = 19; // 0x13
field public static final int EVENT_DATA_ACTIVITY_CHANGED = 8; // 0x8
field @Deprecated @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_DATA_CONNECTION_REAL_TIME_INFO_CHANGED = 14; // 0xe
field public static final int EVENT_DATA_CONNECTION_STATE_CHANGED = 7; // 0x7
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_DATA_ENABLED_CHANGED = 34; // 0x22
field public static final int EVENT_DISPLAY_INFO_CHANGED = 21; // 0x15
field @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public static final int EVENT_EMERGENCY_NUMBER_LIST_CHANGED = 25; // 0x19
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_IMS_CALL_DISCONNECT_CAUSE_CHANGED = 28; // 0x1c
field @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public static final int EVENT_MESSAGE_WAITING_INDICATOR_CHANGED = 3; // 0x3
field @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public static final int EVENT_OEM_HOOK_RAW = 15; // 0xf
field @RequiresPermission(android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION) public static final int EVENT_OUTGOING_EMERGENCY_CALL = 29; // 0x1d
field @RequiresPermission(android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION) public static final int EVENT_OUTGOING_EMERGENCY_SMS = 30; // 0x1e
field public static final int EVENT_PHONE_CAPABILITY_CHANGED = 22; // 0x16
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_PHYSICAL_CHANNEL_CONFIG_CHANGED = 33; // 0x21
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_PRECISE_CALL_STATE_CHANGED = 12; // 0xc
field @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public static final int EVENT_PRECISE_DATA_CONNECTION_STATE_CHANGED = 13; // 0xd
field @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public static final int EVENT_RADIO_POWER_STATE_CHANGED = 24; // 0x18
field @RequiresPermission(allOf={android.Manifest.permission.READ_PRECISE_PHONE_STATE, android.Manifest.permission.ACCESS_FINE_LOCATION}) public static final int EVENT_REGISTRATION_FAILURE = 31; // 0x1f
field public static final int EVENT_SERVICE_STATE_CHANGED = 1; // 0x1
field public static final int EVENT_SIGNAL_STRENGTHS_CHANGED = 9; // 0x9
field public static final int EVENT_SIGNAL_STRENGTH_CHANGED = 2; // 0x2
field @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public static final int EVENT_SRVCC_STATE_CHANGED = 16; // 0x10
field public static final int EVENT_USER_MOBILE_DATA_STATE_CHANGED = 20; // 0x14
field @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public static final int EVENT_VOICE_ACTIVATION_STATE_CHANGED = 18; // 0x12
}
public static interface TelephonyCallback.AllowedNetworkTypesListener {
method @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public void onAllowedNetworkTypesChanged(@NonNull java.util.Map<java.lang.Integer,java.lang.Long>);
}
public static interface TelephonyCallback.CallAttributesListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onCallAttributesChanged(@NonNull android.telephony.CallAttributes);
}
public static interface TelephonyCallback.DataEnabledListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onDataEnabledChanged(boolean, int);
}
public static interface TelephonyCallback.OutgoingEmergencyCallListener {
method @RequiresPermission(android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION) public void onOutgoingEmergencyCall(@NonNull android.telephony.emergency.EmergencyNumber, int);
}
public static interface TelephonyCallback.OutgoingEmergencySmsListener {
method @RequiresPermission(android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION) public void onOutgoingEmergencySms(@NonNull android.telephony.emergency.EmergencyNumber, int);
}
public static interface TelephonyCallback.PhoneCapabilityListener {
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void onPhoneCapabilityChanged(@NonNull android.telephony.PhoneCapability);
}
public static interface TelephonyCallback.PhysicalChannelConfigListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onPhysicalChannelConfigChanged(@NonNull java.util.List<android.telephony.PhysicalChannelConfig>);
}
public static interface TelephonyCallback.PreciseCallStateListener {
method @RequiresPermission(android.Manifest.permission.READ_PRECISE_PHONE_STATE) public void onPreciseCallStateChanged(@NonNull android.telephony.PreciseCallState);
}
public static interface TelephonyCallback.RadioPowerStateListener {
method @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public void onRadioPowerStateChanged(int);
}
public static interface TelephonyCallback.SrvccStateListener {
method @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public void onSrvccStateChanged(int);
}
public static interface TelephonyCallback.VoiceActivationStateListener {
method @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public void onVoiceActivationStateChanged(int);
}
public final class TelephonyHistogram implements android.os.Parcelable {
ctor public TelephonyHistogram(int, int, int);
ctor public TelephonyHistogram(android.telephony.TelephonyHistogram);

6
core/api/test-current.txt
View File

@@ -1629,10 +1629,10 @@ package android.telephony {
method public static void setMinMatchForTest(int);
}
public class PhoneStateListener {
method public void onOutgoingEmergencyCall(@NonNull android.telephony.emergency.EmergencyNumber, int);
@Deprecated public class PhoneStateListener {
method @Deprecated public void onOutgoingEmergencyCall(@NonNull android.telephony.emergency.EmergencyNumber, int);
method @Deprecated public void onOutgoingEmergencySms(@NonNull android.telephony.emergency.EmergencyNumber);
method public void onOutgoingEmergencySms(@NonNull android.telephony.emergency.EmergencyNumber, int);
method @Deprecated public void onOutgoingEmergencySms(@NonNull android.telephony.emergency.EmergencyNumber, int);
}
public final class PreciseDataConnectionState implements android.os.Parcelable {

1529
core/java/android/telephony/PhoneStateListener.java
View File

File diff suppressed because it is too large Load Diff

1710
core/java/android/telephony/TelephonyCallback.java Normal file
View File

File diff suppressed because it is too large Load Diff

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

@@ -209,7 +209,7 @@ public class TelephonyRegistryManager {
}
/**
* To check the SDK version for {@link #listenWithEventList}.
* To check the SDK version for {@link #listenFromListener}.
*/
@ChangeId
@EnabledAfter(targetSdkVersion = Build.VERSION_CODES.P)
@@ -221,24 +221,49 @@ public class TelephonyRegistryManager {
* @param pkg Package name
* @param featureId Feature ID
* @param listener Listener providing callback
* @param events List events
* @param events Events
* @param notifyNow Whether to notify instantly
*/
public void listenWithEventList(int subId, @NonNull String pkg, @NonNull String featureId,
@NonNull PhoneStateListener listener, @NonNull int[] events, boolean notifyNow) {
public void listenFromListener(int subId, @NonNull String pkg, @NonNull String featureId,
@NonNull PhoneStateListener listener, @NonNull int events, boolean notifyNow) {
if (listener == null) {
throw new IllegalStateException("telephony service is null.");
}
try {
int[] eventsList = getEventsFromBitmask(events).stream().mapToInt(i -> i).toArray();
// subId from PhoneStateListener is deprecated Q on forward, use the subId from
// TelephonyManager instance. Keep using subId from PhoneStateListener for pre-Q.
if (Compatibility.isChangeEnabled(LISTEN_CODE_CHANGE)) {
// Since mSubId in PhoneStateListener is deprecated from Q on forward, this is
// the only place to set mSubId and its for "informational" only.
listener.mSubId = (events.length == 0)
listener.mSubId = (eventsList.length == 0)
? SubscriptionManager.INVALID_SUBSCRIPTION_ID : subId;
} else if (listener.mSubId != null) {
subId = listener.mSubId;
}
sRegistry.listenWithEventList(
subId, pkg, featureId, listener.callback, events, notifyNow);
subId, pkg, featureId, listener.callback, eventsList, notifyNow);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Listen for incoming subscriptions
* @param subId Subscription ID
* @param pkg Package name
* @param featureId Feature ID
* @param telephonyCallback Listener providing callback
* @param events List events
* @param notifyNow Whether to notify instantly
*/
private void listenFromCallback(int subId, @NonNull String pkg, @NonNull String featureId,
@NonNull TelephonyCallback telephonyCallback, @NonNull int[] events,
boolean notifyNow) {
try {
sRegistry.listenWithEventList(
subId, pkg, featureId, telephonyCallback.callback, events, notifyNow);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
@@ -802,11 +827,11 @@ public class TelephonyRegistryManager {
/**
* Notify emergency number list changed on certain subscription.
*
* @param subId for which emergency number list changed.
* @param slotIndex for which emergency number list changed. Can be derived from subId except
* when subId is invalid.
* @param subId for which emergency number list changed.
*/
public void notifyAllowedNetworkTypesChanged(int subId, int slotIndex,
public void notifyAllowedNetworkTypesChanged(int slotIndex, int subId,
Map<Integer, Long> allowedNetworkTypeList) {
try {
sRegistry.notifyAllowedNetworkTypesChanged(slotIndex, subId, allowedNetworkTypeList);
@@ -815,136 +840,137 @@ public class TelephonyRegistryManager {
}
}
public @NonNull Set<Integer> getEventsFromListener(@NonNull PhoneStateListener listener) {
public @NonNull Set<Integer> getEventsFromCallback(
@NonNull TelephonyCallback telephonyCallback) {
Set<Integer> eventList = new ArraySet<>();
if (listener instanceof PhoneStateListener.ServiceStateChangedListener) {
eventList.add(PhoneStateListener.EVENT_SERVICE_STATE_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.ServiceStateListener) {
eventList.add(TelephonyCallback.EVENT_SERVICE_STATE_CHANGED);
}
if (listener instanceof PhoneStateListener.MessageWaitingIndicatorChangedListener) {
eventList.add(PhoneStateListener.EVENT_MESSAGE_WAITING_INDICATOR_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.MessageWaitingIndicatorListener) {
eventList.add(TelephonyCallback.EVENT_MESSAGE_WAITING_INDICATOR_CHANGED);
}
if (listener instanceof PhoneStateListener.CallForwardingIndicatorChangedListener) {
eventList.add(PhoneStateListener.EVENT_CALL_FORWARDING_INDICATOR_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.CallForwardingIndicatorListener) {
eventList.add(TelephonyCallback.EVENT_CALL_FORWARDING_INDICATOR_CHANGED);
}
if (listener instanceof PhoneStateListener.CellLocationChangedListener) {
eventList.add(PhoneStateListener.EVENT_CELL_LOCATION_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.CellLocationListener) {
eventList.add(TelephonyCallback.EVENT_CELL_LOCATION_CHANGED);
}
if (listener instanceof PhoneStateListener.CallStateChangedListener) {
eventList.add(PhoneStateListener.EVENT_CALL_STATE_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.CallStateListener) {
eventList.add(TelephonyCallback.EVENT_CALL_STATE_CHANGED);
}
if (listener instanceof PhoneStateListener.DataConnectionStateChangedListener) {
eventList.add(PhoneStateListener.EVENT_DATA_CONNECTION_STATE_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.DataConnectionStateListener) {
eventList.add(TelephonyCallback.EVENT_DATA_CONNECTION_STATE_CHANGED);
}
if (listener instanceof PhoneStateListener.DataActivityListener) {
eventList.add(PhoneStateListener.EVENT_DATA_ACTIVITY_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.DataActivityListener) {
eventList.add(TelephonyCallback.EVENT_DATA_ACTIVITY_CHANGED);
}
if (listener instanceof PhoneStateListener.SignalStrengthsChangedListener) {
eventList.add(PhoneStateListener.EVENT_SIGNAL_STRENGTHS_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.SignalStrengthsListener) {
eventList.add(TelephonyCallback.EVENT_SIGNAL_STRENGTHS_CHANGED);
}
if (listener instanceof PhoneStateListener.AlwaysReportedSignalStrengthChangedListener) {
eventList.add(PhoneStateListener.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.AlwaysReportedSignalStrengthListener) {
eventList.add(TelephonyCallback.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED);
}
if (listener instanceof PhoneStateListener.CellInfoChangedListener) {
eventList.add(PhoneStateListener.EVENT_CELL_INFO_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.CellInfoListener) {
eventList.add(TelephonyCallback.EVENT_CELL_INFO_CHANGED);
}
if (listener instanceof PhoneStateListener.PreciseCallStateChangedListener) {
eventList.add(PhoneStateListener.EVENT_PRECISE_CALL_STATE_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.PreciseCallStateListener) {
eventList.add(TelephonyCallback.EVENT_PRECISE_CALL_STATE_CHANGED);
}
if (listener instanceof PhoneStateListener.CallDisconnectCauseChangedListener) {
eventList.add(PhoneStateListener.EVENT_CALL_DISCONNECT_CAUSE_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.CallDisconnectCauseListener) {
eventList.add(TelephonyCallback.EVENT_CALL_DISCONNECT_CAUSE_CHANGED);
}
if (listener instanceof PhoneStateListener.ImsCallDisconnectCauseChangedListener) {
eventList.add(PhoneStateListener.EVENT_IMS_CALL_DISCONNECT_CAUSE_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.ImsCallDisconnectCauseListener) {
eventList.add(TelephonyCallback.EVENT_IMS_CALL_DISCONNECT_CAUSE_CHANGED);
}
if (listener instanceof PhoneStateListener.PreciseDataConnectionStateChangedListener) {
eventList.add(PhoneStateListener.EVENT_PRECISE_DATA_CONNECTION_STATE_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.PreciseDataConnectionStateListener) {
eventList.add(TelephonyCallback.EVENT_PRECISE_DATA_CONNECTION_STATE_CHANGED);
}
if (listener instanceof PhoneStateListener.SrvccStateChangedListener) {
eventList.add(PhoneStateListener.EVENT_SRVCC_STATE_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.SrvccStateListener) {
eventList.add(TelephonyCallback.EVENT_SRVCC_STATE_CHANGED);
}
if (listener instanceof PhoneStateListener.VoiceActivationStateChangedListener) {
eventList.add(PhoneStateListener.EVENT_VOICE_ACTIVATION_STATE_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.VoiceActivationStateListener) {
eventList.add(TelephonyCallback.EVENT_VOICE_ACTIVATION_STATE_CHANGED);
}
if (listener instanceof PhoneStateListener.DataActivationStateChangedListener) {
eventList.add(PhoneStateListener.EVENT_DATA_ACTIVATION_STATE_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.DataActivationStateListener) {
eventList.add(TelephonyCallback.EVENT_DATA_ACTIVATION_STATE_CHANGED);
}
if (listener instanceof PhoneStateListener.UserMobileDataStateChangedListener) {
eventList.add(PhoneStateListener.EVENT_USER_MOBILE_DATA_STATE_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.UserMobileDataStateListener) {
eventList.add(TelephonyCallback.EVENT_USER_MOBILE_DATA_STATE_CHANGED);
}
if (listener instanceof PhoneStateListener.DisplayInfoChangedListener) {
eventList.add(PhoneStateListener.EVENT_DISPLAY_INFO_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.DisplayInfoListener) {
eventList.add(TelephonyCallback.EVENT_DISPLAY_INFO_CHANGED);
}
if (listener instanceof PhoneStateListener.EmergencyNumberListChangedListener) {
eventList.add(PhoneStateListener.EVENT_EMERGENCY_NUMBER_LIST_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.EmergencyNumberListListener) {
eventList.add(TelephonyCallback.EVENT_EMERGENCY_NUMBER_LIST_CHANGED);
}
if (listener instanceof PhoneStateListener.OutgoingEmergencyCallListener) {
eventList.add(PhoneStateListener.EVENT_OUTGOING_EMERGENCY_CALL);
if (telephonyCallback instanceof TelephonyCallback.OutgoingEmergencyCallListener) {
eventList.add(TelephonyCallback.EVENT_OUTGOING_EMERGENCY_CALL);
}
if (listener instanceof PhoneStateListener.OutgoingEmergencySmsListener) {
eventList.add(PhoneStateListener.EVENT_OUTGOING_EMERGENCY_SMS);
if (telephonyCallback instanceof TelephonyCallback.OutgoingEmergencySmsListener) {
eventList.add(TelephonyCallback.EVENT_OUTGOING_EMERGENCY_SMS);
}
if (listener instanceof PhoneStateListener.PhoneCapabilityChangedListener) {
eventList.add(PhoneStateListener.EVENT_PHONE_CAPABILITY_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.PhoneCapabilityListener) {
eventList.add(TelephonyCallback.EVENT_PHONE_CAPABILITY_CHANGED);
}
if (listener instanceof PhoneStateListener.ActiveDataSubscriptionIdChangedListener) {
eventList.add(PhoneStateListener.EVENT_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.ActiveDataSubscriptionIdListener) {
eventList.add(TelephonyCallback.EVENT_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGED);
}
if (listener instanceof PhoneStateListener.RadioPowerStateChangedListener) {
eventList.add(PhoneStateListener.EVENT_RADIO_POWER_STATE_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.RadioPowerStateListener) {
eventList.add(TelephonyCallback.EVENT_RADIO_POWER_STATE_CHANGED);
}
if (listener instanceof PhoneStateListener.CarrierNetworkChangeListener) {
eventList.add(PhoneStateListener.EVENT_CARRIER_NETWORK_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.CarrierNetworkListener) {
eventList.add(TelephonyCallback.EVENT_CARRIER_NETWORK_CHANGED);
}
if (listener instanceof PhoneStateListener.RegistrationFailedListener) {
eventList.add(PhoneStateListener.EVENT_REGISTRATION_FAILURE);
if (telephonyCallback instanceof TelephonyCallback.RegistrationFailedListener) {
eventList.add(TelephonyCallback.EVENT_REGISTRATION_FAILURE);
}
if (listener instanceof PhoneStateListener.CallAttributesChangedListener) {
eventList.add(PhoneStateListener.EVENT_CALL_ATTRIBUTES_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.CallAttributesListener) {
eventList.add(TelephonyCallback.EVENT_CALL_ATTRIBUTES_CHANGED);
}
if (listener instanceof PhoneStateListener.BarringInfoChangedListener) {
eventList.add(PhoneStateListener.EVENT_BARRING_INFO_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.BarringInfoListener) {
eventList.add(TelephonyCallback.EVENT_BARRING_INFO_CHANGED);
}
if (listener instanceof PhoneStateListener.PhysicalChannelConfigChangedListener) {
eventList.add(PhoneStateListener.EVENT_PHYSICAL_CHANNEL_CONFIG_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.PhysicalChannelConfigListener) {
eventList.add(TelephonyCallback.EVENT_PHYSICAL_CHANNEL_CONFIG_CHANGED);
}
if (listener instanceof PhoneStateListener.DataEnabledChangedListener) {
eventList.add(PhoneStateListener.EVENT_DATA_ENABLED_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.DataEnabledListener) {
eventList.add(TelephonyCallback.EVENT_DATA_ENABLED_CHANGED);
}
if (listener instanceof PhoneStateListener.AllowedNetworkTypesChangedListener) {
eventList.add(PhoneStateListener.EVENT_ALLOWED_NETWORK_TYPE_LIST_CHANGED);
if (telephonyCallback instanceof TelephonyCallback.AllowedNetworkTypesListener) {
eventList.add(TelephonyCallback.EVENT_ALLOWED_NETWORK_TYPE_LIST_CHANGED);
}
return eventList;
@@ -955,200 +981,183 @@ public class TelephonyRegistryManager {
Set<Integer> eventList = new ArraySet<>();
if ((eventMask & PhoneStateListener.LISTEN_SERVICE_STATE) != 0) {
eventList.add(PhoneStateListener.EVENT_SERVICE_STATE_CHANGED);
eventList.add(TelephonyCallback.EVENT_SERVICE_STATE_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_SIGNAL_STRENGTH) != 0) {
eventList.add(PhoneStateListener.EVENT_SIGNAL_STRENGTH_CHANGED);
eventList.add(TelephonyCallback.EVENT_SIGNAL_STRENGTH_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_MESSAGE_WAITING_INDICATOR) != 0) {
eventList.add(PhoneStateListener.EVENT_MESSAGE_WAITING_INDICATOR_CHANGED);
eventList.add(TelephonyCallback.EVENT_MESSAGE_WAITING_INDICATOR_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_CALL_FORWARDING_INDICATOR) != 0) {
eventList.add(PhoneStateListener.EVENT_CALL_FORWARDING_INDICATOR_CHANGED);
eventList.add(TelephonyCallback.EVENT_CALL_FORWARDING_INDICATOR_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_CELL_LOCATION) != 0) {
eventList.add(PhoneStateListener.EVENT_CELL_LOCATION_CHANGED);
eventList.add(TelephonyCallback.EVENT_CELL_LOCATION_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_CALL_STATE) != 0) {
eventList.add(PhoneStateListener.EVENT_CALL_STATE_CHANGED);
eventList.add(TelephonyCallback.EVENT_CALL_STATE_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_DATA_CONNECTION_STATE) != 0) {
eventList.add(PhoneStateListener.EVENT_DATA_CONNECTION_STATE_CHANGED);
eventList.add(TelephonyCallback.EVENT_DATA_CONNECTION_STATE_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_DATA_ACTIVITY) != 0) {
eventList.add(PhoneStateListener.EVENT_DATA_ACTIVITY_CHANGED);
eventList.add(TelephonyCallback.EVENT_DATA_ACTIVITY_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_SIGNAL_STRENGTHS) != 0) {
eventList.add(PhoneStateListener.EVENT_SIGNAL_STRENGTHS_CHANGED);
eventList.add(TelephonyCallback.EVENT_SIGNAL_STRENGTHS_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH) != 0) {
eventList.add(PhoneStateListener.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED);
eventList.add(TelephonyCallback.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_CELL_INFO) != 0) {
eventList.add(PhoneStateListener.EVENT_CELL_INFO_CHANGED);
eventList.add(TelephonyCallback.EVENT_CELL_INFO_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_PRECISE_CALL_STATE) != 0) {
eventList.add(PhoneStateListener.EVENT_PRECISE_CALL_STATE_CHANGED);
eventList.add(TelephonyCallback.EVENT_PRECISE_CALL_STATE_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_PRECISE_DATA_CONNECTION_STATE) != 0) {
eventList.add(PhoneStateListener.EVENT_PRECISE_DATA_CONNECTION_STATE_CHANGED);
eventList.add(TelephonyCallback.EVENT_PRECISE_DATA_CONNECTION_STATE_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_DATA_CONNECTION_REAL_TIME_INFO) != 0) {
eventList.add(PhoneStateListener.EVENT_DATA_CONNECTION_REAL_TIME_INFO_CHANGED);
eventList.add(TelephonyCallback.EVENT_DATA_CONNECTION_REAL_TIME_INFO_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_OEM_HOOK_RAW_EVENT) != 0) {
eventList.add(PhoneStateListener.EVENT_OEM_HOOK_RAW);
eventList.add(TelephonyCallback.EVENT_OEM_HOOK_RAW);
}
if ((eventMask & PhoneStateListener.LISTEN_SRVCC_STATE_CHANGED) != 0) {
eventList.add(PhoneStateListener.EVENT_SRVCC_STATE_CHANGED);
eventList.add(TelephonyCallback.EVENT_SRVCC_STATE_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_CARRIER_NETWORK_CHANGE) != 0) {
eventList.add(PhoneStateListener.EVENT_CARRIER_NETWORK_CHANGED);
eventList.add(TelephonyCallback.EVENT_CARRIER_NETWORK_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_VOICE_ACTIVATION_STATE) != 0) {
eventList.add(PhoneStateListener.EVENT_VOICE_ACTIVATION_STATE_CHANGED);
eventList.add(TelephonyCallback.EVENT_VOICE_ACTIVATION_STATE_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_DATA_ACTIVATION_STATE) != 0) {
eventList.add(PhoneStateListener.EVENT_DATA_ACTIVATION_STATE_CHANGED);
eventList.add(TelephonyCallback.EVENT_DATA_ACTIVATION_STATE_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_USER_MOBILE_DATA_STATE) != 0) {
eventList.add(PhoneStateListener.EVENT_USER_MOBILE_DATA_STATE_CHANGED);
eventList.add(TelephonyCallback.EVENT_USER_MOBILE_DATA_STATE_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_DISPLAY_INFO_CHANGED) != 0) {
eventList.add(PhoneStateListener.EVENT_DISPLAY_INFO_CHANGED);
eventList.add(TelephonyCallback.EVENT_DISPLAY_INFO_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_PHONE_CAPABILITY_CHANGE) != 0) {
eventList.add(PhoneStateListener.EVENT_PHONE_CAPABILITY_CHANGED);
eventList.add(TelephonyCallback.EVENT_PHONE_CAPABILITY_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGE) != 0) {
eventList.add(PhoneStateListener.EVENT_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGED);
eventList.add(TelephonyCallback.EVENT_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_RADIO_POWER_STATE_CHANGED) != 0) {
eventList.add(PhoneStateListener.EVENT_RADIO_POWER_STATE_CHANGED);
eventList.add(TelephonyCallback.EVENT_RADIO_POWER_STATE_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_EMERGENCY_NUMBER_LIST) != 0) {
eventList.add(PhoneStateListener.EVENT_EMERGENCY_NUMBER_LIST_CHANGED);
eventList.add(TelephonyCallback.EVENT_EMERGENCY_NUMBER_LIST_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_CALL_DISCONNECT_CAUSES) != 0) {
eventList.add(PhoneStateListener.EVENT_CALL_DISCONNECT_CAUSE_CHANGED);
eventList.add(TelephonyCallback.EVENT_CALL_DISCONNECT_CAUSE_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_CALL_ATTRIBUTES_CHANGED) != 0) {
eventList.add(PhoneStateListener.EVENT_CALL_ATTRIBUTES_CHANGED);
eventList.add(TelephonyCallback.EVENT_CALL_ATTRIBUTES_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_IMS_CALL_DISCONNECT_CAUSES) != 0) {
eventList.add(PhoneStateListener.EVENT_IMS_CALL_DISCONNECT_CAUSE_CHANGED);
eventList.add(TelephonyCallback.EVENT_IMS_CALL_DISCONNECT_CAUSE_CHANGED);
}
if ((eventMask & PhoneStateListener.LISTEN_OUTGOING_EMERGENCY_CALL) != 0) {
eventList.add(PhoneStateListener.EVENT_OUTGOING_EMERGENCY_CALL);
eventList.add(TelephonyCallback.EVENT_OUTGOING_EMERGENCY_CALL);
}
if ((eventMask & PhoneStateListener.LISTEN_OUTGOING_EMERGENCY_SMS) != 0) {
eventList.add(PhoneStateListener.EVENT_OUTGOING_EMERGENCY_SMS);
eventList.add(TelephonyCallback.EVENT_OUTGOING_EMERGENCY_SMS);
}
if ((eventMask & PhoneStateListener.LISTEN_REGISTRATION_FAILURE) != 0) {
eventList.add(PhoneStateListener.EVENT_REGISTRATION_FAILURE);
eventList.add(TelephonyCallback.EVENT_REGISTRATION_FAILURE);
}
if ((eventMask & PhoneStateListener.LISTEN_BARRING_INFO) != 0) {
eventList.add(PhoneStateListener.EVENT_BARRING_INFO_CHANGED);
eventList.add(TelephonyCallback.EVENT_BARRING_INFO_CHANGED);
}
return eventList;
}
/**
* Registers a listener object to receive notification of changes
* in specified telephony states.
* Registers a callback object to receive notification of changes in specified telephony states.
* <p>
* To register a listener, pass a {@link PhoneStateListener} which implements
* To register a callback, pass a {@link TelephonyCallback} which implements
* interfaces of events. For example,
* FakeServiceStateChangedListener extends {@link PhoneStateListener} implements
* {@link PhoneStateListener.ServiceStateChangedListener}.
* FakeServiceStateCallback extends {@link TelephonyCallback} implements
* {@link TelephonyCallback.ServiceStateListener}.
*
* At registration, and when a specified telephony state changes, the telephony manager invokes
* the appropriate callback method on the listener object and passes the current (updated)
* the appropriate callback method on the callback object and passes the current (updated)
* values.
* <p>
*
* If this TelephonyManager object has been created with
* {@link TelephonyManager#createForSubscriptionId}, applies to the given subId.
* Otherwise, applies to {@link SubscriptionManager#getDefaultSubscriptionId()}.
* To listen events for multiple subIds, pass a separate listener object to
* To register events for multiple subIds, pass a separate callback object to
* each TelephonyManager object created with {@link TelephonyManager#createForSubscriptionId}.
*
* Note: if you call this method while in the middle of a binder transaction, you <b>must</b>
* call {@link android.os.Binder#clearCallingIdentity()} before calling this method. A
* {@link SecurityException} will be thrown otherwise.
*
* This API should be used sparingly -- large numbers of listeners will cause system
* instability. If a process has registered too many listeners without unregistering them, it
* may encounter an {@link IllegalStateException} when trying to register more listeners.
* This API should be used sparingly -- large numbers of callbacks will cause system
* instability. If a process has registered too many callbacks without unregistering them, it
* may encounter an {@link IllegalStateException} when trying to register more callbacks.
*
* @param listener The {@link PhoneStateListener} object to register.
* @param callback The {@link TelephonyCallback} object to register.
*/
public void registerPhoneStateListener(@NonNull @CallbackExecutor Executor executor, int subId,
String pkgName, String attributionTag, @NonNull PhoneStateListener listener,
public void registerTelephonyCallback(@NonNull @CallbackExecutor Executor executor,
int subId, String pkgName, String attributionTag, @NonNull TelephonyCallback callback,
boolean notifyNow) {
listener.setExecutor(executor);
registerPhoneStateListener(subId, pkgName, attributionTag, listener,
getEventsFromListener(listener), notifyNow);
}
public void registerPhoneStateListenerWithEvents(int subId, String pkgName,
String attributionTag, @NonNull PhoneStateListener listener, int events,
boolean notifyNow) {
registerPhoneStateListener(
subId, pkgName, attributionTag, listener, getEventsFromBitmask(events), notifyNow);
}
private void registerPhoneStateListener(int subId,
String pkgName, String attributionTag, @NonNull PhoneStateListener listener,
@NonNull Set<Integer> events, boolean notifyNow) {
if (listener == null) {
if (callback == null) {
throw new IllegalStateException("telephony service is null.");
}
listenWithEventList(subId, pkgName, attributionTag, listener,
events.stream().mapToInt(i -> i).toArray(), notifyNow);
callback.init(executor);
listenFromCallback(subId, pkgName, attributionTag, callback,
getEventsFromCallback(callback).stream().mapToInt(i -> i).toArray(), notifyNow);
}
/**
* Unregister an existing {@link PhoneStateListener}.
* Unregister an existing {@link TelephonyCallback}.
*
* @param listener The {@link PhoneStateListener} object to unregister.
* @param callback The {@link TelephonyCallback} object to unregister.
*/
public void unregisterPhoneStateListener(int subId, String pkgName, String attributionTag,
@NonNull PhoneStateListener listener,
boolean notifyNow) {
listenWithEventList(subId, pkgName, attributionTag, listener, new int[0], notifyNow);
public void unregisterTelephonyCallback(int subId, String pkgName, String attributionTag,
@NonNull TelephonyCallback callback, boolean notifyNow) {
listenFromCallback(subId, pkgName, attributionTag, callback, new int[0], notifyNow);
}
}

10
packages/Connectivity/framework/src/android/net/util/MultinetworkPolicyTracker.java
View File

@@ -30,8 +30,8 @@ import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.provider.Settings;
import android.telephony.PhoneStateListener;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyCallback;
import android.telephony.TelephonyManager;
import android.util.Log;
@@ -92,8 +92,8 @@ public class MultinetworkPolicyTracker {
}
@VisibleForTesting
protected class ActiveDataSubscriptionIdChangedListener extends PhoneStateListener
implements PhoneStateListener.ActiveDataSubscriptionIdChangedListener {
protected class ActiveDataSubscriptionIdListener extends TelephonyCallback
implements TelephonyCallback.ActiveDataSubscriptionIdListener {
@Override
public void onActiveDataSubscriptionIdChanged(int subId) {
mActiveSubId = subId;
@@ -121,8 +121,8 @@ public class MultinetworkPolicyTracker {
}
};
ctx.getSystemService(TelephonyManager.class).registerPhoneStateListener(
new HandlerExecutor(handler), new ActiveDataSubscriptionIdChangedListener());
ctx.getSystemService(TelephonyManager.class).registerTelephonyCallback(
new HandlerExecutor(handler), new ActiveDataSubscriptionIdListener());
updateAvoidBadWifi();
updateMeteredMultipathPreference();

34
packages/SystemUI/src/com/android/systemui/statusbar/policy/MobileSignalController.java
View File

@@ -25,11 +25,11 @@ import android.provider.Settings.Global;
import android.telephony.Annotation;
import android.telephony.CellSignalStrength;
import android.telephony.CellSignalStrengthCdma;
import android.telephony.PhoneStateListener;
import android.telephony.ServiceState;
import android.telephony.SignalStrength;
import android.telephony.SubscriptionInfo;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyCallback;
import android.telephony.TelephonyDisplayInfo;
import android.telephony.TelephonyManager;
import android.text.Html;
@@ -63,7 +63,7 @@ public class MobileSignalController extends SignalController<
private final String mNetworkNameSeparator;
private final ContentObserver mObserver;
@VisibleForTesting
final PhoneStateListener mPhoneStateListener;
final MobileTelephonyCallback mTelephonyCallback;
// Save entire info for logging, we only use the id.
final SubscriptionInfo mSubscriptionInfo;
@@ -83,6 +83,7 @@ public class MobileSignalController extends SignalController<
private Config mConfig;
@VisibleForTesting
boolean mInflateSignalStrengths = false;
final Handler mHandler;
// TODO: Reduce number of vars passed in, if we have the NetworkController, probably don't
// need listener lists anymore.
@@ -98,7 +99,8 @@ public class MobileSignalController extends SignalController<
mPhone = phone;
mDefaults = defaults;
mSubscriptionInfo = info;
mPhoneStateListener = new MobilePhoneStateListener((new Handler(receiverLooper))::post);
mHandler = new Handler(receiverLooper);
mTelephonyCallback = new MobileTelephonyCallback();
mNetworkNameSeparator = getTextIfExists(R.string.status_bar_network_name_separator)
.toString();
mNetworkNameDefault = getTextIfExists(
@@ -157,15 +159,7 @@ public class MobileSignalController extends SignalController<
* Start listening for phone state changes.
*/
public void registerListener() {
mPhone.listen(mPhoneStateListener,
PhoneStateListener.LISTEN_SERVICE_STATE
| PhoneStateListener.LISTEN_SIGNAL_STRENGTHS
| PhoneStateListener.LISTEN_CALL_STATE
| PhoneStateListener.LISTEN_DATA_CONNECTION_STATE
| PhoneStateListener.LISTEN_DATA_ACTIVITY
| PhoneStateListener.LISTEN_CARRIER_NETWORK_CHANGE
| PhoneStateListener.LISTEN_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGE
| PhoneStateListener.LISTEN_DISPLAY_INFO_CHANGED);
mPhone.registerTelephonyCallback(mHandler::post, mTelephonyCallback);
mContext.getContentResolver().registerContentObserver(Global.getUriFor(Global.MOBILE_DATA),
true, mObserver);
mContext.getContentResolver().registerContentObserver(Global.getUriFor(
@@ -177,7 +171,7 @@ public class MobileSignalController extends SignalController<
* Stop listening for phone state changes.
*/
public void unregisterListener() {
mPhone.listen(mPhoneStateListener, 0);
mPhone.unregisterTelephonyCallback(mTelephonyCallback);
mContext.getContentResolver().unregisterContentObserver(mObserver);
}
@@ -622,11 +616,15 @@ public class MobileSignalController extends SignalController<
pw.println(" isDataDisabled=" + isDataDisabled() + ",");
}
class MobilePhoneStateListener extends PhoneStateListener {
public MobilePhoneStateListener(Executor executor) {
super(executor);
}
class MobileTelephonyCallback extends TelephonyCallback implements
TelephonyCallback.SignalStrengthsListener,
TelephonyCallback.ServiceStateListener,
TelephonyCallback.DataConnectionStateListener,
TelephonyCallback.DataActivityListener,
TelephonyCallback.CarrierNetworkListener,
TelephonyCallback.ActiveDataSubscriptionIdListener,
TelephonyCallback.DisplayInfoListener
{
@Override
public void onSignalStrengthsChanged(SignalStrength signalStrength) {
if (DEBUG) {

25
packages/SystemUI/tests/src/com/android/systemui/statusbar/policy/NetworkControllerBaseTest.java
View File

@@ -47,11 +47,11 @@ import android.provider.Settings;
import android.provider.Settings.Global;
import android.telephony.CellSignalStrength;
import android.telephony.NetworkRegistrationInfo;
import android.telephony.PhoneStateListener;
import android.telephony.ServiceState;
import android.telephony.SignalStrength;
import android.telephony.SubscriptionInfo;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyCallback;
import android.telephony.TelephonyDisplayInfo;
import android.telephony.TelephonyManager;
import android.testing.TestableLooper;
@@ -95,7 +95,6 @@ public class NetworkControllerBaseTest extends SysuiTestCase {
protected NetworkControllerImpl mNetworkController;
protected MobileSignalController mMobileSignalController;
protected PhoneStateListener mPhoneStateListener;
protected SignalStrength mSignalStrength;
protected ServiceState mServiceState;
protected TelephonyDisplayInfo mTelephonyDisplayInfo;
@@ -211,8 +210,6 @@ public class NetworkControllerBaseTest extends SysuiTestCase {
setDefaultSubId(mSubId);
setSubscriptions(mSubId);
mMobileSignalController = mNetworkController.mMobileSignalControllers.get(mSubId);
mPhoneStateListener = mMobileSignalController.mPhoneStateListener;
ArgumentCaptor<ConnectivityManager.NetworkCallback> callbackArg =
ArgumentCaptor.forClass(ConnectivityManager.NetworkCallback.class);
verify(mMockCm, atLeastOnce())
@@ -340,18 +337,15 @@ public class NetworkControllerBaseTest extends SysuiTestCase {
private void updateSignalStrength() {
Log.d(TAG, "Sending Signal Strength: " + mSignalStrength);
mPhoneStateListener.onSignalStrengthsChanged(mSignalStrength);
mMobileSignalController.mTelephonyCallback
.onSignalStrengthsChanged(mSignalStrength);
}
protected void updateServiceState() {
Log.d(TAG, "Sending Service State: " + mServiceState);
mPhoneStateListener.onServiceStateChanged(mServiceState);
mPhoneStateListener.onDisplayInfoChanged(mTelephonyDisplayInfo);
}
public void updateCallState(int state) {
// Inputs not currently used in NetworkControllerImpl.
mPhoneStateListener.onCallStateChanged(state, "0123456789");
mMobileSignalController.mTelephonyCallback.onServiceStateChanged(mServiceState);
mMobileSignalController.mTelephonyCallback
.onDisplayInfoChanged(mTelephonyDisplayInfo);
}
public void updateDataConnectionState(int dataState, int dataNetType) {
@@ -363,16 +357,17 @@ public class NetworkControllerBaseTest extends SysuiTestCase {
when(mServiceState.getNetworkRegistrationInfo(DOMAIN_PS, TRANSPORT_TYPE_WWAN))
.thenReturn(fakeRegInfo);
when(mTelephonyDisplayInfo.getNetworkType()).thenReturn(dataNetType);
mPhoneStateListener.onDataConnectionStateChanged(dataState, dataNetType);
mMobileSignalController.mTelephonyCallback
.onDataConnectionStateChanged(dataState, dataNetType);
}
public void updateDataActivity(int dataActivity) {
mPhoneStateListener.onDataActivity(dataActivity);
mMobileSignalController.mTelephonyCallback.onDataActivity(dataActivity);
}
public void setCarrierNetworkChange(boolean enable) {
Log.d(TAG, "setCarrierNetworkChange(" + enable + ")");
mPhoneStateListener.onCarrierNetworkChange(enable);
mMobileSignalController.mTelephonyCallback.onCarrierNetworkChange(enable);
}
protected void verifyHasNoSims(boolean hasNoSimsVisible) {

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

@@ -72,6 +72,7 @@ import android.telephony.ServiceState;
import android.telephony.SignalStrength;
import android.telephony.SubscriptionInfo;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyCallback;
import android.telephony.TelephonyDisplayInfo;
import android.telephony.TelephonyManager;
import android.telephony.data.ApnSetting;
@@ -153,7 +154,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
int phoneId = SubscriptionManager.INVALID_SIM_SLOT_INDEX;
boolean matchPhoneStateListenerEvent(int event) {
boolean matchTelephonyCallbackEvent(int event) {
return (callback != null) && (this.eventList.contains(event));
}
@@ -198,8 +199,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
public int getRegistrationLimit() {
return Binder.withCleanCallingIdentity(() ->
DeviceConfig.getInt(DeviceConfig.NAMESPACE_TELEPHONY,
PhoneStateListener.FLAG_PER_PID_REGISTRATION_LIMIT,
PhoneStateListener.DEFAULT_PER_PID_REGISTRATION_LIMIT));
TelephonyCallback.FLAG_PER_PID_REGISTRATION_LIMIT,
TelephonyCallback.DEFAULT_PER_PID_REGISTRATION_LIMIT));
}
/**
@@ -210,7 +211,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
*/
public boolean isRegistrationLimitEnabledInPlatformCompat(int uid) {
return Binder.withCleanCallingIdentity(() -> CompatChanges.isChangeEnabled(
PhoneStateListener.PHONE_STATE_LISTENER_LIMIT_CHANGE_ID, uid));
TelephonyCallback.PHONE_STATE_LISTENER_LIMIT_CHANGE_ID, uid));
}
}
@@ -332,37 +333,37 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
static {
REQUIRE_PRECISE_PHONE_STATE_PERMISSION = new HashSet<Integer>();
REQUIRE_PRECISE_PHONE_STATE_PERMISSION.add(
PhoneStateListener.EVENT_PRECISE_DATA_CONNECTION_STATE_CHANGED);
TelephonyCallback.EVENT_PRECISE_DATA_CONNECTION_STATE_CHANGED);
REQUIRE_PRECISE_PHONE_STATE_PERMISSION.add(
PhoneStateListener.EVENT_DATA_CONNECTION_REAL_TIME_INFO_CHANGED);
TelephonyCallback.EVENT_DATA_CONNECTION_REAL_TIME_INFO_CHANGED);
REQUIRE_PRECISE_PHONE_STATE_PERMISSION.add(
PhoneStateListener.EVENT_PRECISE_CALL_STATE_CHANGED);
TelephonyCallback.EVENT_PRECISE_CALL_STATE_CHANGED);
REQUIRE_PRECISE_PHONE_STATE_PERMISSION.add(
PhoneStateListener.EVENT_CALL_DISCONNECT_CAUSE_CHANGED);
TelephonyCallback.EVENT_CALL_DISCONNECT_CAUSE_CHANGED);
REQUIRE_PRECISE_PHONE_STATE_PERMISSION.add(
PhoneStateListener.EVENT_CALL_ATTRIBUTES_CHANGED);
TelephonyCallback.EVENT_CALL_ATTRIBUTES_CHANGED);
REQUIRE_PRECISE_PHONE_STATE_PERMISSION.add(
PhoneStateListener.EVENT_IMS_CALL_DISCONNECT_CAUSE_CHANGED);
REQUIRE_PRECISE_PHONE_STATE_PERMISSION.add(PhoneStateListener.EVENT_REGISTRATION_FAILURE);
REQUIRE_PRECISE_PHONE_STATE_PERMISSION.add(PhoneStateListener.EVENT_BARRING_INFO_CHANGED);
TelephonyCallback.EVENT_IMS_CALL_DISCONNECT_CAUSE_CHANGED);
REQUIRE_PRECISE_PHONE_STATE_PERMISSION.add(TelephonyCallback.EVENT_REGISTRATION_FAILURE);
REQUIRE_PRECISE_PHONE_STATE_PERMISSION.add(TelephonyCallback.EVENT_BARRING_INFO_CHANGED);
REQUIRE_PRECISE_PHONE_STATE_PERMISSION.add(
PhoneStateListener.EVENT_PHYSICAL_CHANNEL_CONFIG_CHANGED);
TelephonyCallback.EVENT_PHYSICAL_CHANNEL_CONFIG_CHANGED);
REQUIRE_PRECISE_PHONE_STATE_PERMISSION.add(
PhoneStateListener.EVENT_DATA_ENABLED_CHANGED);
TelephonyCallback.EVENT_DATA_ENABLED_CHANGED);
}
private boolean isLocationPermissionRequired(Set<Integer> events) {
return events.contains(PhoneStateListener.EVENT_CELL_LOCATION_CHANGED)
|| events.contains(PhoneStateListener.EVENT_CELL_INFO_CHANGED)
|| events.contains(PhoneStateListener.EVENT_REGISTRATION_FAILURE)
|| events.contains(PhoneStateListener.EVENT_BARRING_INFO_CHANGED);
return events.contains(TelephonyCallback.EVENT_CELL_LOCATION_CHANGED)
|| events.contains(TelephonyCallback.EVENT_CELL_INFO_CHANGED)
|| events.contains(TelephonyCallback.EVENT_REGISTRATION_FAILURE)
|| events.contains(TelephonyCallback.EVENT_BARRING_INFO_CHANGED);
}
private boolean isPhoneStatePermissionRequired(Set<Integer> events) {
return events.contains(PhoneStateListener.EVENT_CALL_FORWARDING_INDICATOR_CHANGED)
|| events.contains(PhoneStateListener.EVENT_MESSAGE_WAITING_INDICATOR_CHANGED)
|| events.contains(PhoneStateListener.EVENT_EMERGENCY_NUMBER_LIST_CHANGED)
|| events.contains(PhoneStateListener.EVENT_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGED);
return events.contains(TelephonyCallback.EVENT_CALL_FORWARDING_INDICATOR_CHANGED)
|| events.contains(TelephonyCallback.EVENT_MESSAGE_WAITING_INDICATOR_CHANGED)
|| events.contains(TelephonyCallback.EVENT_EMERGENCY_NUMBER_LIST_CHANGED)
|| events.contains(TelephonyCallback.EVENT_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGED);
}
private boolean isPrecisePhoneStatePermissionRequired(Set<Integer> events) {
@@ -375,14 +376,14 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
private boolean isActiveEmergencySessionPermissionRequired(Set<Integer> events) {
return events.contains(PhoneStateListener.EVENT_OUTGOING_EMERGENCY_CALL)
|| events.contains(PhoneStateListener.EVENT_OUTGOING_EMERGENCY_SMS);
return events.contains(TelephonyCallback.EVENT_OUTGOING_EMERGENCY_CALL)
|| events.contains(TelephonyCallback.EVENT_OUTGOING_EMERGENCY_SMS);
}
private boolean isPrivilegedPhoneStatePermissionRequired(Set<Integer> events) {
return events.contains(PhoneStateListener.EVENT_SRVCC_STATE_CHANGED)
|| events.contains(PhoneStateListener.EVENT_VOICE_ACTIVATION_STATE_CHANGED)
|| events.contains(PhoneStateListener.EVENT_RADIO_POWER_STATE_CHANGED);
return events.contains(TelephonyCallback.EVENT_SRVCC_STATE_CHANGED)
|| events.contains(TelephonyCallback.EVENT_VOICE_ACTIVATION_STATE_CHANGED)
|| events.contains(TelephonyCallback.EVENT_RADIO_POWER_STATE_CHANGED);
}
private static final int MSG_USER_SWITCHED = 1;
@@ -903,7 +904,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
log("listen: Register r=" + r + " r.subId=" + r.subId + " phoneId=" + phoneId);
}
if (notifyNow && validatePhoneId(phoneId)) {
if (events.contains(PhoneStateListener.EVENT_SERVICE_STATE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_SERVICE_STATE_CHANGED)){
try {
if (VDBG) log("listen: call onSSC state=" + mServiceState[phoneId]);
ServiceState rawSs = new ServiceState(mServiceState[phoneId]);
@@ -920,7 +921,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_SIGNAL_STRENGTH_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_SIGNAL_STRENGTH_CHANGED)) {
try {
if (mSignalStrength[phoneId] != null) {
int gsmSignalStrength = mSignalStrength[phoneId]
@@ -933,7 +934,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(
PhoneStateListener.EVENT_MESSAGE_WAITING_INDICATOR_CHANGED)) {
TelephonyCallback.EVENT_MESSAGE_WAITING_INDICATOR_CHANGED)) {
try {
r.callback.onMessageWaitingIndicatorChanged(
mMessageWaiting[phoneId]);
@@ -942,7 +943,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(
PhoneStateListener.EVENT_CALL_FORWARDING_INDICATOR_CHANGED)) {
TelephonyCallback.EVENT_CALL_FORWARDING_INDICATOR_CHANGED)) {
try {
r.callback.onCallForwardingIndicatorChanged(
mCallForwarding[phoneId]);
@@ -951,7 +952,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (validateEventAndUserLocked(
r, PhoneStateListener.EVENT_CELL_LOCATION_CHANGED)) {
r, TelephonyCallback.EVENT_CELL_LOCATION_CHANGED)) {
try {
if (DBG_LOC) log("listen: mCellIdentity = " + mCellIdentity[phoneId]);
if (checkCoarseLocationAccess(r, Build.VERSION_CODES.BASE)
@@ -963,7 +964,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_CALL_STATE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_CALL_STATE_CHANGED)) {
try {
r.callback.onCallStateChanged(mCallState[phoneId],
getCallIncomingNumber(r, phoneId));
@@ -971,7 +972,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_DATA_CONNECTION_STATE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_DATA_CONNECTION_STATE_CHANGED)) {
try {
r.callback.onDataConnectionStateChanged(mDataConnectionState[phoneId],
mDataConnectionNetworkType[phoneId]);
@@ -979,14 +980,14 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_DATA_ACTIVITY_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_DATA_ACTIVITY_CHANGED)) {
try {
r.callback.onDataActivity(mDataActivity[phoneId]);
} catch (RemoteException ex) {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_SIGNAL_STRENGTHS_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_SIGNAL_STRENGTHS_CHANGED)) {
try {
if (mSignalStrength[phoneId] != null) {
r.callback.onSignalStrengthsChanged(mSignalStrength[phoneId]);
@@ -996,7 +997,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(
PhoneStateListener.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED)) {
TelephonyCallback.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED)) {
updateReportSignalStrengthDecision(r.subId);
try {
if (mSignalStrength[phoneId] != null) {
@@ -1007,7 +1008,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (validateEventAndUserLocked(
r, PhoneStateListener.EVENT_CELL_INFO_CHANGED)) {
r, TelephonyCallback.EVENT_CELL_INFO_CHANGED)) {
try {
if (DBG_LOC) log("listen: mCellInfo[" + phoneId + "] = "
+ mCellInfo.get(phoneId));
@@ -1019,14 +1020,14 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_PRECISE_CALL_STATE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_PRECISE_CALL_STATE_CHANGED)) {
try {
r.callback.onPreciseCallStateChanged(mPreciseCallState[phoneId]);
} catch (RemoteException ex) {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_CALL_DISCONNECT_CAUSE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_CALL_DISCONNECT_CAUSE_CHANGED)) {
try {
r.callback.onCallDisconnectCauseChanged(mCallDisconnectCause[phoneId],
mCallPreciseDisconnectCause[phoneId]);
@@ -1034,7 +1035,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_IMS_CALL_DISCONNECT_CAUSE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_IMS_CALL_DISCONNECT_CAUSE_CHANGED)) {
try {
r.callback.onImsCallDisconnectCauseChanged(mImsReasonInfo.get(phoneId));
} catch (RemoteException ex) {
@@ -1042,7 +1043,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(
PhoneStateListener.EVENT_PRECISE_DATA_CONNECTION_STATE_CHANGED)) {
TelephonyCallback.EVENT_PRECISE_DATA_CONNECTION_STATE_CHANGED)) {
try {
for (PreciseDataConnectionState pdcs
: mPreciseDataConnectionStates.get(phoneId).values()) {
@@ -1052,14 +1053,14 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_CARRIER_NETWORK_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_CARRIER_NETWORK_CHANGED)) {
try {
r.callback.onCarrierNetworkChange(mCarrierNetworkChangeState);
} catch (RemoteException ex) {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_VOICE_ACTIVATION_STATE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_VOICE_ACTIVATION_STATE_CHANGED)) {
try {
r.callback.onVoiceActivationStateChanged(
mVoiceActivationState[phoneId]);
@@ -1067,21 +1068,21 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_DATA_ACTIVATION_STATE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_DATA_ACTIVATION_STATE_CHANGED)) {
try {
r.callback.onDataActivationStateChanged(mDataActivationState[phoneId]);
} catch (RemoteException ex) {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_USER_MOBILE_DATA_STATE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_USER_MOBILE_DATA_STATE_CHANGED)) {
try {
r.callback.onUserMobileDataStateChanged(mUserMobileDataState[phoneId]);
} catch (RemoteException ex) {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_DISPLAY_INFO_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_DISPLAY_INFO_CHANGED)) {
try {
if (mTelephonyDisplayInfos[phoneId] != null) {
r.callback.onDisplayInfoChanged(mTelephonyDisplayInfos[phoneId]);
@@ -1090,14 +1091,14 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_EMERGENCY_NUMBER_LIST_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_EMERGENCY_NUMBER_LIST_CHANGED)) {
try {
r.callback.onEmergencyNumberListChanged(mEmergencyNumberList);
} catch (RemoteException ex) {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_PHONE_CAPABILITY_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_PHONE_CAPABILITY_CHANGED)) {
try {
r.callback.onPhoneCapabilityChanged(mPhoneCapability);
} catch (RemoteException ex) {
@@ -1105,35 +1106,35 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(
PhoneStateListener.EVENT_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGED)) {
TelephonyCallback.EVENT_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGED)) {
try {
r.callback.onActiveDataSubIdChanged(mActiveDataSubId);
} catch (RemoteException ex) {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_RADIO_POWER_STATE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_RADIO_POWER_STATE_CHANGED)) {
try {
r.callback.onRadioPowerStateChanged(mRadioPowerState);
} catch (RemoteException ex) {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_SRVCC_STATE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_SRVCC_STATE_CHANGED)) {
try {
r.callback.onSrvccStateChanged(mSrvccState[phoneId]);
} catch (RemoteException ex) {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_CALL_ATTRIBUTES_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_CALL_ATTRIBUTES_CHANGED)) {
try {
r.callback.onCallAttributesChanged(mCallAttributes[phoneId]);
} catch (RemoteException ex) {
remove(r.binder);
}
}
if (events.contains(PhoneStateListener.EVENT_BARRING_INFO_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_BARRING_INFO_CHANGED)) {
BarringInfo barringInfo = mBarringInfo.get(phoneId);
BarringInfo biNoLocation = barringInfo != null
? barringInfo.createLocationInfoSanitizedCopy() : null;
@@ -1147,7 +1148,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(
PhoneStateListener.EVENT_PHYSICAL_CHANNEL_CONFIG_CHANGED)) {
TelephonyCallback.EVENT_PHYSICAL_CHANNEL_CONFIG_CHANGED)) {
try {
r.callback.onPhysicalChannelConfigChanged(
mPhysicalChannelConfigs);
@@ -1156,7 +1157,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(
PhoneStateListener.EVENT_DATA_ENABLED_CHANGED)) {
TelephonyCallback.EVENT_DATA_ENABLED_CHANGED)) {
try {
r.callback.onDataEnabledChanged(
mIsDataEnabled[phoneId], mDataEnabledReason[phoneId]);
@@ -1165,7 +1166,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(
PhoneStateListener.EVENT_ALLOWED_NETWORK_TYPE_LIST_CHANGED)) {
TelephonyCallback.EVENT_ALLOWED_NETWORK_TYPE_LIST_CHANGED)) {
try {
r.callback.onAllowedNetworkTypesChanged(mAllowedNetworkTypesList);
} catch (RemoteException ex) {
@@ -1183,8 +1184,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
for (Record r : mRecords) {
// If any of the system clients wants to always listen to signal strength,
// we need to set it on.
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED)) {
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED)) {
telephonyManager.createForSubscriptionId(subscriptionId)
.setAlwaysReportSignalStrength(true);
return;
@@ -1233,7 +1234,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
throw new IllegalStateException(errorMsg);
}
} else if (doesLimitApply && numRecordsForPid
>= PhoneStateListener.DEFAULT_PER_PID_REGISTRATION_LIMIT / 2) {
>= TelephonyCallback.DEFAULT_PER_PID_REGISTRATION_LIMIT / 2) {
// Log the warning independently of the dynamically set limit -- apps shouldn't be
// doing this regardless of whether we're throwing them an exception for it.
Rlog.w(TAG, "Pid " + callingPid + " has exceeded half the number of permissible"
@@ -1284,8 +1285,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
// Every time a client that is registrating to always receive the signal
// strength is removed from registry records, we need to check if
// the signal strength decision needs to update on its slot.
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED)) {
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED)) {
updateReportSignalStrengthDecision(r.subId);
}
return;
@@ -1305,7 +1306,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
synchronized (mRecords) {
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(PhoneStateListener.EVENT_CALL_STATE_CHANGED)
if (r.matchTelephonyCallbackEvent(TelephonyCallback.EVENT_CALL_STATE_CHANGED)
&& (r.subId == SubscriptionManager.DEFAULT_SUBSCRIPTION_ID)) {
try {
// Ensure the listener has read call log permission; if they do not return
@@ -1340,7 +1341,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mCallState[phoneId] = state;
mCallIncomingNumber[phoneId] = incomingNumber;
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(PhoneStateListener.EVENT_CALL_STATE_CHANGED)
if (r.matchTelephonyCallbackEvent(TelephonyCallback.EVENT_CALL_STATE_CHANGED)
&& (r.subId == subId)
&& (r.subId != SubscriptionManager.DEFAULT_SUBSCRIPTION_ID)) {
try {
@@ -1382,8 +1383,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
log("notifyServiceStateForSubscriber: r=" + r + " subId=" + subId
+ " phoneId=" + phoneId + " state=" + state);
}
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_SERVICE_STATE_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_SERVICE_STATE_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
@@ -1444,8 +1445,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
try {
if ((activationType == SIM_ACTIVATION_TYPE_VOICE)
&& r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_VOICE_ACTIVATION_STATE_CHANGED)
&& r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_VOICE_ACTIVATION_STATE_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
if (DBG) {
log("notifyVoiceActivationStateForPhoneId: callback.onVASC r=" + r
@@ -1455,8 +1456,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
r.callback.onVoiceActivationStateChanged(activationState);
}
if ((activationType == SIM_ACTIVATION_TYPE_DATA)
&& r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_DATA_ACTIVATION_STATE_CHANGED)
&& r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_DATA_ACTIVATION_STATE_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
if (DBG) {
log("notifyDataActivationStateForPhoneId: callback.onDASC r=" + r
@@ -1495,11 +1496,10 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
log("notifySignalStrengthForPhoneId: r=" + r + " subId=" + subId
+ " phoneId=" + phoneId + " ss=" + signalStrength);
}
if ((r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_SIGNAL_STRENGTHS_CHANGED)
|| r.matchPhoneStateListenerEvent(
PhoneStateListener.
EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED))
if ((r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_SIGNAL_STRENGTHS_CHANGED)
|| r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED))
&& idMatch(r.subId, subId, phoneId)) {
try {
if (DBG) {
@@ -1512,8 +1512,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mRemoveList.add(r.binder);
}
}
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_SIGNAL_STRENGTH_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_SIGNAL_STRENGTH_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
int gsmSignalStrength = signalStrength.getGsmSignalStrength();
@@ -1559,8 +1559,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
log("notifyCarrierNetworkChange: active=" + active + "subId: " + subId);
}
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_CARRIER_NETWORK_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_CARRIER_NETWORK_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onCarrierNetworkChange(active);
@@ -1592,7 +1592,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mCellInfo.set(phoneId, cellInfo);
for (Record r : mRecords) {
if (validateEventAndUserLocked(
r, PhoneStateListener.EVENT_CELL_INFO_CHANGED)
r, TelephonyCallback.EVENT_CELL_INFO_CHANGED)
&& idMatch(r.subId, subId, phoneId)
&& (checkCoarseLocationAccess(r, Build.VERSION_CODES.BASE)
&& checkFineLocationAccess(r, Build.VERSION_CODES.Q))) {
@@ -1625,8 +1625,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
if (validatePhoneId(phoneId)) {
mMessageWaiting[phoneId] = mwi;
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_MESSAGE_WAITING_INDICATOR_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_MESSAGE_WAITING_INDICATOR_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onMessageWaitingIndicatorChanged(mwi);
@@ -1652,8 +1652,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
if (validatePhoneId(phoneId)) {
mUserMobileDataState[phoneId] = state;
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_USER_MOBILE_DATA_STATE_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_USER_MOBILE_DATA_STATE_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onUserMobileDataStateChanged(state);
@@ -1691,8 +1691,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
if (validatePhoneId(phoneId)) {
mTelephonyDisplayInfos[phoneId] = telephonyDisplayInfo;
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_DISPLAY_INFO_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_DISPLAY_INFO_CHANGED)
&& idMatchWithoutDefaultPhoneCheck(r.subId, subId)) {
try {
r.callback.onDisplayInfoChanged(telephonyDisplayInfo);
@@ -1723,8 +1723,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
if (validatePhoneId(phoneId)) {
mCallForwarding[phoneId] = cfi;
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_CALL_FORWARDING_INDICATOR_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_CALL_FORWARDING_INDICATOR_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onCallForwardingIndicatorChanged(cfi);
@@ -1752,8 +1752,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mDataActivity[phoneId] = state;
for (Record r : mRecords) {
// Notify by correct subId.
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_DATA_ACTIVITY_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_DATA_ACTIVITY_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onDataActivity(state);
@@ -1800,8 +1800,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
log(str);
mLocalLog.log(str);
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_DATA_CONNECTION_STATE_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_DATA_CONNECTION_STATE_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
if (DBG) {
@@ -1825,8 +1825,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
.remove(key);
if (!Objects.equals(oldState, preciseState)) {
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_PRECISE_DATA_CONNECTION_STATE_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_PRECISE_DATA_CONNECTION_STATE_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onPreciseDataConnectionStateChanged(preciseState);
@@ -1872,7 +1872,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mCellIdentity[phoneId] = cellIdentity;
for (Record r : mRecords) {
if (validateEventAndUserLocked(
r, PhoneStateListener.EVENT_CELL_LOCATION_CHANGED)
r, TelephonyCallback.EVENT_CELL_LOCATION_CHANGED)
&& idMatch(r.subId, subId, phoneId)
&& (checkCoarseLocationAccess(r, Build.VERSION_CODES.BASE)
&& checkFineLocationAccess(r, Build.VERSION_CODES.Q))) {
@@ -1925,8 +1925,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_PRECISE_CALL_STATE_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_PRECISE_CALL_STATE_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onPreciseCallStateChanged(mPreciseCallState[phoneId]);
@@ -1934,8 +1934,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mRemoveList.add(r.binder);
}
}
if (notifyCallAttributes && r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_CALL_ATTRIBUTES_CHANGED)
if (notifyCallAttributes && r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_CALL_ATTRIBUTES_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onCallAttributesChanged(mCallAttributes[phoneId]);
@@ -1959,8 +1959,9 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mCallDisconnectCause[phoneId] = disconnectCause;
mCallPreciseDisconnectCause[phoneId] = preciseDisconnectCause;
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(PhoneStateListener
.LISTEN_CALL_DISCONNECT_CAUSES) && idMatch(r.subId, subId, phoneId)) {
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_CALL_DISCONNECT_CAUSE_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onCallDisconnectCauseChanged(mCallDisconnectCause[phoneId],
mCallPreciseDisconnectCause[phoneId]);
@@ -1983,8 +1984,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
if (validatePhoneId(phoneId)) {
mImsReasonInfo.set(phoneId, imsReasonInfo);
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_IMS_CALL_DISCONNECT_CAUSE_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_IMS_CALL_DISCONNECT_CAUSE_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
if (DBG_LOC) {
@@ -2015,8 +2016,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
if (validatePhoneId(phoneId)) {
mSrvccState[phoneId] = state;
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_SRVCC_STATE_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_SRVCC_STATE_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
if (DBG_LOC) {
@@ -2044,8 +2045,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
if (VDBG) {
log("notifyOemHookRawEventForSubscriber: r=" + r + " subId=" + subId);
}
if ((r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_OEM_HOOK_RAW))
if ((r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_OEM_HOOK_RAW))
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onOemHookRawEvent(rawData);
@@ -2072,8 +2073,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mPhoneCapability = capability;
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_PHONE_CAPABILITY_CHANGED)) {
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_PHONE_CAPABILITY_CHANGED)) {
try {
r.callback.onPhoneCapabilityChanged(capability);
} catch (RemoteException ex) {
@@ -2097,8 +2098,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mActiveDataSubId = activeDataSubId;
synchronized (mRecords) {
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGED)) {
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGED)) {
try {
r.callback.onActiveDataSubIdChanged(activeDataSubId);
} catch (RemoteException ex) {
@@ -2124,8 +2125,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mRadioPowerState = state;
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_RADIO_POWER_STATE_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_RADIO_POWER_STATE_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onRadioPowerStateChanged(state);
@@ -2153,8 +2154,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mEmergencyNumberList = tm.getEmergencyNumberList();
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_EMERGENCY_NUMBER_LIST_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_EMERGENCY_NUMBER_LIST_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onEmergencyNumberListChanged(mEmergencyNumberList);
@@ -2185,8 +2186,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
for (Record r : mRecords) {
// Send to all listeners regardless of subscription
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_OUTGOING_EMERGENCY_CALL)) {
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_OUTGOING_EMERGENCY_CALL)) {
try {
r.callback.onOutgoingEmergencyCall(emergencyNumber, subId);
} catch (RemoteException ex) {
@@ -2204,13 +2205,14 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
if (!checkNotifyPermission("notifyOutgoingEmergencySms()")) {
return;
}
synchronized (mRecords) {
if (validatePhoneId(phoneId)) {
mOutgoingSmsEmergencyNumber[phoneId] = emergencyNumber;
for (Record r : mRecords) {
// Send to all listeners regardless of subscription
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_OUTGOING_EMERGENCY_SMS)) {
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_OUTGOING_EMERGENCY_SMS)) {
try {
r.callback.onOutgoingEmergencySms(emergencyNumber, subId);
} catch (RemoteException ex) {
@@ -2239,8 +2241,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
callNetworkType, callQuality);
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_CALL_ATTRIBUTES_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_CALL_ATTRIBUTES_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onCallAttributesChanged(mCallAttributes[phoneId]);
@@ -2270,8 +2272,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
synchronized (mRecords) {
if (validatePhoneId(phoneId)) {
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_REGISTRATION_FAILURE)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_REGISTRATION_FAILURE)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onRegistrationFailed(
@@ -2313,8 +2315,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
BarringInfo biNoLocation = barringInfo.createLocationInfoSanitizedCopy();
if (VDBG) log("listen: call onBarringInfoChanged=" + barringInfo);
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_BARRING_INFO_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_BARRING_INFO_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
if (DBG_LOC) {
@@ -2356,8 +2358,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
if (validatePhoneId(phoneId)) {
mPhysicalChannelConfigs.set(phoneId, configs.get(phoneId));
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_PHYSICAL_CHANNEL_CONFIG_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_PHYSICAL_CHANNEL_CONFIG_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
if (DBG_LOC) {
@@ -2386,7 +2388,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
* {@link TelephonyManager}.
*/
public void notifyDataEnabled(int phoneId, int subId, boolean enabled,
@TelephonyManager.DataEnabledReason int reason) {
@TelephonyManager.DataEnabledReason int reason) {
if (!checkNotifyPermission("notifyDataEnabled()")) {
return;
}
@@ -2401,8 +2403,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mIsDataEnabled[phoneId] = enabled;
mDataEnabledReason[phoneId] = reason;
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_DATA_ENABLED_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_DATA_ENABLED_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
r.callback.onDataEnabledChanged(enabled, reason);
@@ -2435,8 +2437,8 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
mAllowedNetworkTypesList = allowedNetworkTypesList;
for (Record r : mRecords) {
if (r.matchPhoneStateListenerEvent(
PhoneStateListener.EVENT_ALLOWED_NETWORK_TYPE_LIST_CHANGED)
if (r.matchTelephonyCallbackEvent(
TelephonyCallback.EVENT_ALLOWED_NETWORK_TYPE_LIST_CHANGED)
&& idMatch(r.subId, subId, phoneId)) {
try {
if (VDBG) {
@@ -2815,7 +2817,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION, null);
}
if ((events.contains(PhoneStateListener.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED))) {
if ((events.contains(TelephonyCallback.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED))) {
mContext.enforceCallingOrSelfPermission(
android.Manifest.permission.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH, null);
}
@@ -2845,7 +2847,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
try {
foregroundUser = ActivityManager.getCurrentUser();
valid = UserHandle.getUserId(r.callerUid) == foregroundUser
&& r.matchPhoneStateListenerEvent(event);
&& r.matchTelephonyCallbackEvent(event);
if (DBG | DBG_LOC) {
log("validateEventAndUserLocked: valid=" + valid
+ " r.callerUid=" + r.callerUid + " foregroundUser=" + foregroundUser
@@ -2956,7 +2958,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
return;
}
if ((events.contains(PhoneStateListener.EVENT_SERVICE_STATE_CHANGED))) {
if ((events.contains(TelephonyCallback.EVENT_SERVICE_STATE_CHANGED))) {
try {
if (VDBG) log("checkPossibleMissNotify: onServiceStateChanged state=" +
mServiceState[phoneId]);
@@ -2975,9 +2977,9 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(PhoneStateListener.EVENT_SIGNAL_STRENGTHS_CHANGED)
if (events.contains(TelephonyCallback.EVENT_SIGNAL_STRENGTHS_CHANGED)
|| events.contains(
PhoneStateListener.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED)) {
TelephonyCallback.EVENT_ALWAYS_REPORTED_SIGNAL_STRENGTH_CHANGED)) {
try {
if (mSignalStrength[phoneId] != null) {
SignalStrength signalStrength = mSignalStrength[phoneId];
@@ -2992,7 +2994,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(PhoneStateListener.EVENT_SIGNAL_STRENGTH_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_SIGNAL_STRENGTH_CHANGED)) {
try {
if (mSignalStrength[phoneId] != null) {
int gsmSignalStrength = mSignalStrength[phoneId]
@@ -3009,7 +3011,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (validateEventAndUserLocked(r, PhoneStateListener.EVENT_CELL_INFO_CHANGED)) {
if (validateEventAndUserLocked(r, TelephonyCallback.EVENT_CELL_INFO_CHANGED)) {
try {
if (DBG_LOC) {
log("checkPossibleMissNotify: onCellInfoChanged[" + phoneId + "] = "
@@ -3024,7 +3026,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(PhoneStateListener.EVENT_USER_MOBILE_DATA_STATE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_USER_MOBILE_DATA_STATE_CHANGED)) {
try {
if (VDBG) {
log("checkPossibleMissNotify: onUserMobileDataStateChanged phoneId="
@@ -3036,7 +3038,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(PhoneStateListener.EVENT_DISPLAY_INFO_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_DISPLAY_INFO_CHANGED)) {
try {
if (VDBG) {
log("checkPossibleMissNotify: onDisplayInfoChanged phoneId="
@@ -3050,7 +3052,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(PhoneStateListener.EVENT_MESSAGE_WAITING_INDICATOR_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_MESSAGE_WAITING_INDICATOR_CHANGED)) {
try {
if (VDBG) {
log("checkPossibleMissNotify: onMessageWaitingIndicatorChanged phoneId="
@@ -3063,7 +3065,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(PhoneStateListener.EVENT_CALL_FORWARDING_INDICATOR_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_CALL_FORWARDING_INDICATOR_CHANGED)) {
try {
if (VDBG) {
log("checkPossibleMissNotify: onCallForwardingIndicatorChanged phoneId="
@@ -3076,7 +3078,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (validateEventAndUserLocked(r, PhoneStateListener.EVENT_CELL_LOCATION_CHANGED)) {
if (validateEventAndUserLocked(r, TelephonyCallback.EVENT_CELL_LOCATION_CHANGED)) {
try {
if (DBG_LOC) {
log("checkPossibleMissNotify: onCellLocationChanged mCellIdentity = "
@@ -3092,7 +3094,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub {
}
}
if (events.contains(PhoneStateListener.EVENT_DATA_CONNECTION_STATE_CHANGED)) {
if (events.contains(TelephonyCallback.EVENT_DATA_CONNECTION_STATE_CHANGED)) {
try {
if (DBG) {
log("checkPossibleMissNotify: onDataConnectionStateChanged(mDataConnectionState"

4
telephony/java/android/telephony/TelephonyDisplayInfo.java
View File

@@ -30,8 +30,8 @@ import java.util.Objects;
* necessarily a precise or accurate representation of the current state and should be treated
* accordingly.
* To be notified of changes in TelephonyDisplayInfo, use
* {@link TelephonyManager#registerPhoneStateListener} with a {@link PhoneStateListener}
* that implements {@link PhoneStateListener.DisplayInfoChangedListener}.
* {@link TelephonyManager#registerTelephonyCallback} with a {@link TelephonyCallback}
* that implements {@link TelephonyCallback.DisplayInfoListener}.
* Override the onDisplayInfoChanged() method to handle the broadcast.
*/
public final class TelephonyDisplayInfo implements Parcelable {

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

@@ -5580,28 +5580,25 @@ public class TelephonyManager {
* instability. If a process has registered too many listeners without unregistering them, it
* may encounter an {@link IllegalStateException} when trying to register more listeners.
*
* @param listener The {@link PhoneStateListener} object to register (or unregister)
* @param events The telephony state(s) of interest to the listener, as a bitwise-OR combination
* of {@link PhoneStateListener} LISTEN_ flags.
* @deprecated Use {@link #registerPhoneStateListener(Executor, PhoneStateListener)}.
* @param listener The {@link PhoneStateListener} object to register
* (or unregister)
* @param events The telephony state(s) of interest to the listener,
* as a bitwise-OR combination of {@link PhoneStateListener}
* LISTEN_ flags.
* @deprecated Use {@link #registerTelephonyCallback(Executor, TelephonyCallback)}.
*/
@Deprecated
public void listen(PhoneStateListener listener, int events) {
if (!listener.isExecutorSet()) {
throw new IllegalStateException("PhoneStateListener should be created on a thread "
+ "with Looper.myLooper() != null");
}
boolean notifyNow = getITelephony() != null;
mTelephonyRegistryMgr = mContext.getSystemService(TelephonyRegistryManager.class);
if (mTelephonyRegistryMgr != null) {
if (events != PhoneStateListener.LISTEN_NONE) {
mTelephonyRegistryMgr.registerPhoneStateListenerWithEvents(mSubId,
getOpPackageName(), getAttributionTag(), listener, events, notifyNow);
} else {
unregisterPhoneStateListener(listener);
}
if (mContext == null) return;
boolean notifyNow = (getITelephony() != null);
TelephonyRegistryManager telephonyRegistry =
(TelephonyRegistryManager)
mContext.getSystemService(Context.TELEPHONY_REGISTRY_SERVICE);
if (telephonyRegistry != null) {
telephonyRegistry.listenFromListener(mSubId, getOpPackageName(),
getAttributionTag(), listener, events, notifyNow);
} else {
throw new IllegalStateException("telephony service is null.");
Rlog.w(TAG, "telephony registry not ready.");
}
}
@@ -14548,6 +14545,75 @@ public class TelephonyManager {
return THERMAL_MITIGATION_RESULT_UNKNOWN_ERROR;
}
/**
* Registers a callback object to receive notification of changes in specified telephony states.
* <p>
* To register a callback, pass a {@link TelephonyCallback} which implements
* interfaces of events. For example,
* FakeServiceStateCallback extends {@link TelephonyCallback} implements
* {@link TelephonyCallback.ServiceStateListener}.
*
* At registration, and when a specified telephony state changes, the telephony manager invokes
* the appropriate callback method on the callback object and passes the current (updated)
* values.
* <p>
*
* If this TelephonyManager object has been created with {@link #createForSubscriptionId},
* applies to the given subId. Otherwise, applies to
* {@link SubscriptionManager#getDefaultSubscriptionId()}. To register events for multiple
* subIds, pass a separate callback object to each TelephonyManager object created with
* {@link #createForSubscriptionId}.
*
* Note: if you call this method while in the middle of a binder transaction, you <b>must</b>
* call {@link android.os.Binder#clearCallingIdentity()} before calling this method. A
* {@link SecurityException} will be thrown otherwise.
*
* This API should be used sparingly -- large numbers of callbacks will cause system
* instability. If a process has registered too many callbacks without unregistering them, it
* may encounter an {@link IllegalStateException} when trying to register more callbacks.
*
* @param executor The executor of where the callback will execute.
* @param callback The {@link TelephonyCallback} object to register.
*/
public void registerTelephonyCallback(@NonNull @CallbackExecutor Executor executor,
@NonNull TelephonyCallback callback) {
if (executor == null || callback == null) {
throw new IllegalArgumentException("TelephonyCallback and executor must be non-null");
}
mTelephonyRegistryMgr = (TelephonyRegistryManager)
mContext.getSystemService(Context.TELEPHONY_REGISTRY_SERVICE);
if (mTelephonyRegistryMgr != null) {
mTelephonyRegistryMgr.registerTelephonyCallback(executor, mSubId, getOpPackageName(),
getAttributionTag(), callback, getITelephony() != null);
} else {
throw new IllegalStateException("telephony service is null.");
}
}
/**
* Unregister an existing {@link TelephonyCallback}.
*
* @param callback The {@link TelephonyCallback} object to unregister.
*/
public void unregisterTelephonyCallback(@NonNull TelephonyCallback callback) {
if (mContext == null) {
throw new IllegalStateException("telephony service is null.");
}
if (callback.callback == null) {
return;
}
mTelephonyRegistryMgr = mContext.getSystemService(TelephonyRegistryManager.class);
if (mTelephonyRegistryMgr != null) {
mTelephonyRegistryMgr.unregisterTelephonyCallback(mSubId, getOpPackageName(),
getAttributionTag(), callback, getITelephony() != null);
} else {
throw new IllegalStateException("telephony service is null.");
}
}
/** @hide */
@Retention(RetentionPolicy.SOURCE)
@IntDef(prefix = {"GBA_FAILURE_REASON_"}, value = {
@@ -14723,73 +14789,6 @@ public class TelephonyManager {
}
}
/**
* Registers a listener object to receive notification of changes in specified telephony states.
* <p>
* To register a listener, pass a {@link PhoneStateListener} which implements
* interfaces of events. For example,
* FakeServiceStateChangedListener extends {@link PhoneStateListener} implements
* {@link PhoneStateListener.ServiceStateChangedListener}.
*
* At registration, and when a specified telephony state changes, the telephony manager invokes
* the appropriate callback method on the listener object and passes the current (updated)
* values.
* <p>
*
* If this TelephonyManager object has been created with {@link #createForSubscriptionId},
* applies to the given subId. Otherwise, applies to
* {@link SubscriptionManager#DEFAULT_SUBSCRIPTION_ID}. To listen events for multiple subIds,
* pass a separate listener object to each TelephonyManager object created with
* {@link #createForSubscriptionId}. Only {@link PhoneStateListener.CallStateChangedListener}
* can be used to receive changes for all subIds through
* {@link SubscriptionManager#DEFAULT_SUBSCRIPTION_ID}.
*
* Note: if you call this method while in the middle of a binder transaction, you <b>must</b>
* call {@link android.os.Binder#clearCallingIdentity()} before calling this method. A
* {@link SecurityException} will be thrown otherwise.
*
* This API should be used sparingly -- large numbers of listeners will cause system
* instability. If a process has registered too many listeners without unregistering them, it
* may encounter an {@link IllegalStateException} when trying to register more listeners.
*
* @param executor The executor of where the callback will execute.
* @param listener The {@link PhoneStateListener} object to register.
*/
public void registerPhoneStateListener(@NonNull @CallbackExecutor Executor executor,
@NonNull PhoneStateListener listener) {
if (executor == null || listener == null) {
throw new IllegalArgumentException("PhoneStateListener and executor must be non-null");
}
mTelephonyRegistryMgr = (TelephonyRegistryManager)
mContext.getSystemService(Context.TELEPHONY_REGISTRY_SERVICE);
if (mTelephonyRegistryMgr != null) {
mTelephonyRegistryMgr.registerPhoneStateListener(executor, mSubId,
getOpPackageName(), getAttributionTag(), listener, getITelephony() != null);
} else {
throw new IllegalStateException("telephony service is null.");
}
}
/**
* Unregister an existing {@link PhoneStateListener}.
*
* @param listener The {@link PhoneStateListener} object to unregister.
*/
public void unregisterPhoneStateListener(@NonNull PhoneStateListener listener) {
if (mContext == null) {
throw new IllegalStateException("telephony service is null.");
}
mTelephonyRegistryMgr = mContext.getSystemService(TelephonyRegistryManager.class);
if (mTelephonyRegistryMgr != null) {
mTelephonyRegistryMgr.unregisterPhoneStateListener(mSubId, getOpPackageName(),
getAttributionTag(), listener, getITelephony() != null);
} else {
throw new IllegalStateException("telephony service is null.");
}
}
/**
* The network type is valid or not.
*

6
tests/net/java/android/net/util/MultinetworkPolicyTrackerTest.kt
View File

@@ -21,7 +21,7 @@ import android.content.res.Resources
import android.net.ConnectivityManager.MULTIPATH_PREFERENCE_HANDOVER
import android.net.ConnectivityManager.MULTIPATH_PREFERENCE_PERFORMANCE
import android.net.ConnectivityManager.MULTIPATH_PREFERENCE_RELIABILITY
import android.net.util.MultinetworkPolicyTracker.ActiveDataSubscriptionIdChangedListener
import android.net.util.MultinetworkPolicyTracker.ActiveDataSubscriptionIdListener
import android.provider.Settings
import android.provider.Settings.Global.NETWORK_AVOID_BAD_WIFI
import android.provider.Settings.Global.NETWORK_METERED_MULTIPATH_PREFERENCE
@@ -120,9 +120,9 @@ class MultinetworkPolicyTrackerTest {
MULTIPATH_PREFERENCE_PERFORMANCE.toString())
val listenerCaptor = ArgumentCaptor.forClass(
ActiveDataSubscriptionIdChangedListener::class.java)
ActiveDataSubscriptionIdListener::class.java)
verify(telephonyManager, times(1))
.registerPhoneStateListener(any(), listenerCaptor.capture())
.registerTelephonyCallback(any(), listenerCaptor.capture())
val listener = listenerCaptor.value
listener.onActiveDataSubscriptionIdChanged(testSubId)