Merge "Add the flag for the new carrier config prefer_3g_visibility_bool" into main
diff --git a/flags/data.aconfig b/flags/data.aconfig
index 152660b..a74d279 100644
--- a/flags/data.aconfig
+++ b/flags/data.aconfig
@@ -83,3 +83,17 @@
description: "notify data activity changed for slot id"
bug: "309896936"
}
+
+flag {
+ name: "vonr_enabled_metric"
+ namespace: "telephony"
+ description: "Collect vonr status in voice call metric"
+ bug:"288449751"
+}
+
+flag {
+ name: "ignore_existing_networks_for_internet_allowed_checking"
+ namespace: "telephony"
+ description: "Ignore existing networks when checking if internet is allowed"
+ bug: "284420611"
+}
diff --git a/flags/ims.aconfig b/flags/ims.aconfig
index 94c933c..92d003d 100644
--- a/flags/ims.aconfig
+++ b/flags/ims.aconfig
@@ -34,3 +34,17 @@
description: "This flag is for adding suggested actions related to RAT to ims registration"
bug:"290573256"
}
+
+flag {
+ name: "terminate_active_video_call_when_accepting_second_video_call_as_audio_only"
+ namespace: "telephony"
+ description: "This flag terminates active video call instead holding when accepting 2nd incoming video call as audio only"
+ bug:"309548300"
+}
+
+flag {
+ name: "emergency_registration_state"
+ namespace: "telephony"
+ description: "This flag is created to notify emergency registration state changed."
+ bug:"312101946"
+}
diff --git a/flags/misc.aconfig b/flags/misc.aconfig
index c7140f5..ba9772b 100644
--- a/flags/misc.aconfig
+++ b/flags/misc.aconfig
@@ -51,13 +51,6 @@
}
flag {
- name: "load_dds_on_create"
- namespace: "telephony"
- description: "Load default data subid on create in PhoneGlobals."
- bug: "310591561"
-}
-
-flag {
name: "enable_telephony_analytics"
namespace: "telephony"
description: "Enable Telephony Analytics information of Service State , Sms and Call scenarios"
diff --git a/flags/telephony.aconfig b/flags/telephony.aconfig
index f60885b..b849d53 100644
--- a/flags/telephony.aconfig
+++ b/flags/telephony.aconfig
@@ -5,4 +5,11 @@
namespace: "telephony"
description: "This flag controls telephony feature flags mapping."
bug:"297989574"
-}
\ No newline at end of file
+}
+
+flag {
+ name: "enforce_telephony_feature_mapping_for_public_apis"
+ namespace: "telephony"
+ description: "This flag controls telephony feature flags mapping for public APIs and CTS."
+ bug:"297989574"
+}
diff --git a/flags/uicc.aconfig b/flags/uicc.aconfig
index 3ef2301..b2024b0 100644
--- a/flags/uicc.aconfig
+++ b/flags/uicc.aconfig
@@ -11,4 +11,10 @@
namespace: "telephony"
description: "This flag controls to download the IMSI encryption keys after user unlocks the phone."
bug:"303780982"
+}
+flag {
+ name: "carrier_restriction_status"
+ namespace: "telephony"
+ description: "This flag control the visibility of the getCarrierRestrictionStatus in carrierRestrictionRules class."
+ bug:"313553044"
}
\ No newline at end of file
diff --git a/proto/src/persist_atoms.proto b/proto/src/persist_atoms.proto
index 6d1008b..d7a6062 100644
--- a/proto/src/persist_atoms.proto
+++ b/proto/src/persist_atoms.proto
@@ -280,6 +280,7 @@
optional bool is_iwlan_cross_sim_at_start = 37;
optional bool is_iwlan_cross_sim_at_end = 38;
optional bool is_iwlan_cross_sim_at_connected = 39;
+ optional bool vonr_enabled = 40;
// Internal use only
optional int64 setup_begin_millis = 10001;
diff --git a/src/java/com/android/internal/telephony/GsmCdmaPhone.java b/src/java/com/android/internal/telephony/GsmCdmaPhone.java
index 3ef7164..620b871 100644
--- a/src/java/com/android/internal/telephony/GsmCdmaPhone.java
+++ b/src/java/com/android/internal/telephony/GsmCdmaPhone.java
@@ -254,6 +254,7 @@
CellBroadcastConfigTracker.make(this, null, true);
private boolean mIsNullCipherAndIntegritySupported = false;
+ private boolean mIsIdentifierDisclosureTransparencySupported = false;
// Create Cfu (Call forward unconditional) so that dialing number &
// mOnComplete (Message object passed by client) can be packed &
@@ -341,7 +342,7 @@
// phone type needs to be set before other initialization as other objects rely on it
mPrecisePhoneType = precisePhoneType;
- mVoiceCallSessionStats = new VoiceCallSessionStats(mPhoneId, this);
+ mVoiceCallSessionStats = new VoiceCallSessionStats(mPhoneId, this, featureFlags);
mImsManagerFactory = imsManagerFactory;
initOnce(ci);
initRatSpecific(precisePhoneType);
@@ -3144,6 +3145,7 @@
mCi.areUiccApplicationsEnabled(obtainMessage(EVENT_GET_UICC_APPS_ENABLEMENT_DONE));
handleNullCipherEnabledChange();
+ handleIdentifierDisclosureNotificationPreferenceChange();
}
private void handleRadioOn() {
@@ -3610,14 +3612,7 @@
case EVENT_SET_NULL_CIPHER_AND_INTEGRITY_DONE:
logd("EVENT_SET_NULL_CIPHER_AND_INTEGRITY_DONE");
ar = (AsyncResult) msg.obj;
- // Only test for a success here in order to flip the support flag.
- // Testing for the negative case, e.g. REQUEST_NOT_SUPPORTED, is insufficient
- // because the modem or the RIL could still return exceptions for temporary
- // failures even when the feature is unsupported.
- if (ar == null || ar.exception == null) {
- mIsNullCipherAndIntegritySupported = true;
- return;
- }
+ mIsNullCipherAndIntegritySupported = doesResultIndicateModemSupport(ar);
break;
case EVENT_IMS_DEREGISTRATION_TRIGGERED:
@@ -3701,11 +3696,25 @@
}
break;
+ case EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE:
+ logd("EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE");
+ ar = (AsyncResult) msg.obj;
+ mIsIdentifierDisclosureTransparencySupported = doesResultIndicateModemSupport(ar);
+ break;
+
default:
super.handleMessage(msg);
}
}
+ private boolean doesResultIndicateModemSupport(AsyncResult ar) {
+ // We can only say that the modem supports a call without ambiguity if there
+ // is no exception set on the response. Testing for REQUEST_NOT_SUPPORTED, is
+ // insufficient because the modem or the RIL could still return exceptions for temporary
+ // failures even when the feature is unsupported.
+ return (ar == null || ar.exception == null);
+ }
+
private void parseImeiInfo(Message msg) {
AsyncResult ar = (AsyncResult)msg.obj;
if (ar.exception != null || ar.result == null) {
@@ -5298,7 +5307,31 @@
}
@Override
+ public void handleIdentifierDisclosureNotificationPreferenceChange() {
+ if (!mFeatureFlags.enableIdentifierDisclosureTransparency()) {
+ logi("Not handling identifier disclosure preference change. Feature flag "
+ + "ENABLE_IDENTIFIER_DISCLOSURE_TRANSPARENCY disabled");
+ return;
+ }
+ boolean prefEnabled = getIdentifierDisclosureNotificationsPreferenceEnabled();
+
+ if (prefEnabled) {
+ mIdentifierDisclosureNotifier.enable();
+ } else {
+ mIdentifierDisclosureNotifier.disable();
+ }
+
+ mCi.setCellularIdentifierTransparencyEnabled(prefEnabled,
+ obtainMessage(EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE));
+ }
+
+ @Override
public boolean isNullCipherAndIntegritySupported() {
return mIsNullCipherAndIntegritySupported;
}
+
+ @Override
+ public boolean isIdentifierDisclosureTransparencySupported() {
+ return mIsIdentifierDisclosureTransparencySupported;
+ }
}
diff --git a/src/java/com/android/internal/telephony/Phone.java b/src/java/com/android/internal/telephony/Phone.java
index cc1d4a4..f062908 100644
--- a/src/java/com/android/internal/telephony/Phone.java
+++ b/src/java/com/android/internal/telephony/Phone.java
@@ -255,7 +255,8 @@
protected static final int EVENT_SET_N1_MODE_ENABLED_DONE = 70;
protected static final int EVENT_IMEI_MAPPING_CHANGED = 71;
protected static final int EVENT_CELL_IDENTIFIER_DISCLOSURE = 72;
- protected static final int EVENT_LAST = EVENT_CELL_IDENTIFIER_DISCLOSURE;
+ protected static final int EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE = 73;
+ protected static final int EVENT_LAST = EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE;
// For shared prefs.
private static final String GSM_ROAMING_LIST_OVERRIDE_PREFIX = "gsm_roaming_list_";
@@ -286,6 +287,9 @@
"pref_null_cipher_and_integrity_enabled";
private final TelephonyAdminReceiver m2gAdminUpdater;
+ public static final String PREF_IDENTIFIER_DISCLOSURE_NOTIFICATIONS_ENABLED =
+ "pref_identifier_disclosure_notifications_enabled";
+
protected final FeatureFlags mFeatureFlags;
/**
@@ -3745,7 +3749,7 @@
* @return {@code true} if internet data is allowed to be established.
*/
public boolean isDataAllowed() {
- return getDataNetworkController().isInternetDataAllowed();
+ return getDataNetworkController().isInternetDataAllowed(false/* ignoreExistingNetworks */);
}
/**
@@ -5149,6 +5153,28 @@
}
/**
+ * @return whether or not this Phone interacts with a modem that supports the cellular
+ * identifier disclosure transparency feature.
+ */
+ public boolean isIdentifierDisclosureTransparencySupported() {
+ return false;
+ }
+
+ /**
+ * @return global cellular identifier disclosure transparency enabled preference
+ */
+ public boolean getIdentifierDisclosureNotificationsPreferenceEnabled() {
+ SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext());
+ return sp.getBoolean(PREF_IDENTIFIER_DISCLOSURE_NOTIFICATIONS_ENABLED, false);
+ }
+
+ /**
+ * Override to handle an update to the cellular identifier disclosure transparency preference.
+ */
+ public void handleIdentifierDisclosureNotificationPreferenceChange() {
+ }
+
+ /**
* Notifies the IMS call status to the modem.
*
* @param imsCallInfo The list of {@link ImsCallInfo}.
diff --git a/src/java/com/android/internal/telephony/PhoneConfigurationManager.java b/src/java/com/android/internal/telephony/PhoneConfigurationManager.java
index 78d1387..26aeaca 100644
--- a/src/java/com/android/internal/telephony/PhoneConfigurationManager.java
+++ b/src/java/com/android/internal/telephony/PhoneConfigurationManager.java
@@ -43,8 +43,10 @@
import com.android.telephony.Rlog;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.Map;
import java.util.NoSuchElementException;
+import java.util.Set;
/**
* This class manages phone's configuration which defines the potential capability (static) of the
@@ -65,10 +67,14 @@
private static final int EVENT_GET_MODEM_STATUS_DONE = 102;
private static final int EVENT_GET_PHONE_CAPABILITY_DONE = 103;
private static final int EVENT_DEVICE_CONFIG_CHANGED = 104;
+ private static final int EVENT_GET_SIMULTANEOUS_CALLING_SUPPORT_DONE = 105;
+ private static final int EVENT_SIMULTANEOUS_CALLING_SUPPORT_CHANGED = 106;
+
private static PhoneConfigurationManager sInstance = null;
private final Context mContext;
private PhoneCapability mStaticCapability;
+ private Set<Integer> mSlotsSupportingSimultaneousCellularCalls = new HashSet<>();
private final RadioConfig mRadioConfig;
private final Handler mHandler;
// mPhones is obtained from PhoneFactory and can have phones corresponding to inactive modems as
@@ -152,18 +158,36 @@
}
}
- // If virtual DSDA is enabled for this UE, then updates maxActiveVoiceSubscriptions to 2.
+ /**
+ * If virtual DSDA is enabled for this UE, then increase maxActiveVoiceSubscriptions to 2.
+ */
private PhoneCapability maybeUpdateMaxActiveVoiceSubscriptions(
final PhoneCapability staticCapability) {
if (staticCapability.getLogicalModemList().size() > 1 && mVirtualDsdaEnabled) {
+ // Since we already initialized maxActiveVoiceSubscriptions to the count the
+ // modem is capable of, vDSDA is only able to increase that count via this method. We do
+ // not allow vDSDA to decrease maxActiveVoiceSubscriptions:
+ int updatedMaxActiveVoiceSubscriptions =
+ Math.max(staticCapability.getMaxActiveVoiceSubscriptions(), 2);
return new PhoneCapability.Builder(staticCapability)
- .setMaxActiveVoiceSubscriptions(2)
+ .setMaxActiveVoiceSubscriptions(updatedMaxActiveVoiceSubscriptions)
.build();
} else {
return staticCapability;
}
}
+ private void maybeEnableCellularDSDASupport() {
+ if (mRadioConfig != null && mRadioConfig.getRadioConfigProxy(null)
+ .getVersion().greaterOrEqual(RIL.RADIO_HAL_VERSION_2_2) &&
+ getPhoneCount() > 1 &&
+ mStaticCapability.getMaxActiveVoiceSubscriptions() > 1) {
+ updateSimultaneousCallingSupport();
+ mRadioConfig.registerForSimultaneousCallingSupportStatusChanged(mHandler,
+ EVENT_SIMULTANEOUS_CALLING_SUPPORT_CHANGED, null);
+ }
+ }
+
/**
* Static method to get instance.
*/
@@ -223,6 +247,7 @@
if (ar != null && ar.exception == null) {
mStaticCapability = (PhoneCapability) ar.result;
notifyCapabilityChanged();
+ maybeEnableCellularDSDASupport();
} else {
log(msg.what + " failure. Not getting phone capability." + ar.exception);
}
@@ -236,6 +261,41 @@
mVirtualDsdaEnabled = isVirtualDsdaEnabled;
}
break;
+ case EVENT_SIMULTANEOUS_CALLING_SUPPORT_CHANGED:
+ case EVENT_GET_SIMULTANEOUS_CALLING_SUPPORT_DONE:
+ log("Received EVENT_SLOTS_SUPPORTING_SIMULTANEOUS_CALL_CHANGED/DONE");
+ if (getPhoneCount() < 2) {
+ if (!mSlotsSupportingSimultaneousCellularCalls.isEmpty()) {
+ mSlotsSupportingSimultaneousCellularCalls.clear();
+ }
+ break;
+ }
+ ar = (AsyncResult) msg.obj;
+ if (ar != null && ar.exception == null) {
+ int[] returnedIntArray = (int[]) ar.result;
+ if (!mSlotsSupportingSimultaneousCellularCalls.isEmpty()) {
+ mSlotsSupportingSimultaneousCellularCalls.clear();
+ }
+ int maxValidPhoneSlot = getPhoneCount() - 1;
+ for (int i : returnedIntArray) {
+ if (i < 0 || i > maxValidPhoneSlot) {
+ loge("Invalid slot supporting DSDA =" + i + ". Disabling DSDA.");
+ mSlotsSupportingSimultaneousCellularCalls.clear();
+ break;
+ }
+ mSlotsSupportingSimultaneousCellularCalls.add(i);
+ }
+ // Ensure the slots supporting cellular DSDA does not exceed the phone count
+ if (mSlotsSupportingSimultaneousCellularCalls.size() > getPhoneCount()) {
+ loge("Invalid size of DSDA slots. Disabling cellular DSDA.");
+ mSlotsSupportingSimultaneousCellularCalls.clear();
+ break;
+ }
+ } else {
+ log(msg.what + " failure. Not getting logical slots that support "
+ + "simultaneous calling." + ar.exception);
+ }
+ break;
default:
log("Unknown event: " + msg.what);
}
@@ -341,6 +401,27 @@
return mTelephonyManager.getActiveModemCount();
}
+ @VisibleForTesting
+ public Set<Integer> getSlotsSupportingSimultaneousCellularCalls() {
+ return mSlotsSupportingSimultaneousCellularCalls;
+ }
+
+ /**
+ * Get the current the list of logical slots supporting simultaneous cellular calling from the
+ * modem based on current network conditions.
+ */
+ @VisibleForTesting
+ public void updateSimultaneousCallingSupport() {
+ log("updateSimultaneousCallingSupport: sending the request for "
+ + "getting the list of logical slots supporting simultaneous cellular calling");
+ Message callback = Message.obtain(
+ mHandler, EVENT_GET_SIMULTANEOUS_CALLING_SUPPORT_DONE);
+ mRadioConfig.updateSimultaneousCallingSupport(callback);
+ log("updateSimultaneousCallingSupport: "
+ + "mSlotsSupportingSimultaneousCellularCalls = " +
+ mSlotsSupportingSimultaneousCellularCalls);
+ }
+
/**
* get static overall phone capabilities for all phones.
*/
@@ -446,6 +527,16 @@
phone.mCi.onSlotActiveStatusChange(SubscriptionManager.isValidPhoneId(phoneId));
}
+ if (numOfActiveModems > 1) {
+ // Check if cellular DSDA is supported. If it is, then send a request to the
+ // modem to refresh the list of SIM slots that currently support DSDA based on
+ // current network conditions
+ maybeEnableCellularDSDASupport();
+ } else {
+ // The number of active modems is 0 or 1, disable cellular DSDA:
+ mSlotsSupportingSimultaneousCellularCalls.clear();
+ }
+
// When the user enables DSDS mode, the default VOICE and SMS subId should be switched
// to "No Preference". Doing so will sync the network/sim settings and telephony.
// (see b/198123192)
diff --git a/src/java/com/android/internal/telephony/PhoneFactory.java b/src/java/com/android/internal/telephony/PhoneFactory.java
index 0cbc035..4705d43 100644
--- a/src/java/com/android/internal/telephony/PhoneFactory.java
+++ b/src/java/com/android/internal/telephony/PhoneFactory.java
@@ -161,7 +161,7 @@
}
// register statsd pullers.
- sMetricsCollector = new MetricsCollector(context);
+ sMetricsCollector = new MetricsCollector(context, sFeatureFlags);
sPhoneNotifier = new DefaultPhoneNotifier(context, featureFlags);
@@ -268,7 +268,7 @@
makePhoneSwitcher(maxActivePhones, sContext, Looper.myLooper(),
featureFlags);
- sProxyController = ProxyController.getInstance(context);
+ sProxyController = ProxyController.getInstance(context, featureFlags);
sIntentBroadcaster = IntentBroadcaster.getInstance(context);
@@ -276,7 +276,7 @@
for (int i = 0; i < numPhones; i++) {
sTelephonyNetworkFactories[i] = new TelephonyNetworkFactory(
- Looper.myLooper(), sPhones[i]);
+ Looper.myLooper(), sPhones[i], featureFlags);
}
}
}
@@ -285,8 +285,9 @@
/**
* Upon single SIM to dual SIM switch or vice versa, we dynamically allocate or de-allocate
* Phone and CommandInterface objects.
- * @param context
- * @param activeModemCount
+ *
+ * @param context The context
+ * @param activeModemCount The number of active modems
*/
public static void onMultiSimConfigChanged(Context context, int activeModemCount) {
synchronized (sLockProxyPhones) {
@@ -313,7 +314,7 @@
sPhones[i].createImsPhone();
}
sTelephonyNetworkFactories[i] = new TelephonyNetworkFactory(
- Looper.myLooper(), sPhones[i]);
+ Looper.myLooper(), sPhones[i], sFeatureFlags);
}
}
}
diff --git a/src/java/com/android/internal/telephony/ProxyController.java b/src/java/com/android/internal/telephony/ProxyController.java
index ed9982e..01aed07 100644
--- a/src/java/com/android/internal/telephony/ProxyController.java
+++ b/src/java/com/android/internal/telephony/ProxyController.java
@@ -18,6 +18,7 @@
import static java.util.Arrays.copyOf;
+import android.annotation.NonNull;
import android.compat.annotation.UnsupportedAppUsage;
import android.content.Context;
import android.content.Intent;
@@ -33,6 +34,7 @@
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.telephony.data.PhoneSwitcher;
+import com.android.internal.telephony.flags.FeatureFlags;
import com.android.telephony.Rlog;
import java.util.ArrayList;
@@ -111,11 +113,12 @@
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
private int[] mOldRadioAccessFamily;
+ @NonNull
+ private final FeatureFlags mFlags;
- //***** Class Methods
- public static ProxyController getInstance(Context context) {
+ public static ProxyController getInstance(Context context, FeatureFlags flags) {
if (sProxyController == null) {
- sProxyController = new ProxyController(context);
+ sProxyController = new ProxyController(context, flags);
}
return sProxyController;
}
@@ -125,16 +128,23 @@
return sProxyController;
}
- private ProxyController(Context context) {
+ /**
+ * Constructor
+ *
+ * @param context The context
+ * @param featureFlags Feature flags
+ */
+ public ProxyController(@NonNull Context context, @NonNull FeatureFlags featureFlags) {
logd("Constructor - Enter");
mContext = context;
+ mFlags = featureFlags;
mPhones = PhoneFactory.getPhones();
mPhoneSwitcher = PhoneSwitcher.getInstance();
mUiccPhoneBookController = new UiccPhoneBookController();
mPhoneSubInfoController = new PhoneSubInfoController(mContext);
- mSmsController = new SmsController(mContext);
+ mSmsController = new SmsController(mContext, featureFlags);
mSetRadioAccessFamilyStatus = new int[mPhones.length];
mNewRadioAccessFamily = new int[mPhones.length];
mOldRadioAccessFamily = new int[mPhones.length];
diff --git a/src/java/com/android/internal/telephony/RIL.java b/src/java/com/android/internal/telephony/RIL.java
index e608e4d..5177adb 100644
--- a/src/java/com/android/internal/telephony/RIL.java
+++ b/src/java/com/android/internal/telephony/RIL.java
@@ -1559,7 +1559,7 @@
public void getSystemSelectionChannels(Message result) {
RadioNetworkProxy networkProxy = getRadioServiceProxy(RadioNetworkProxy.class);
if (!canMakeRequest("getSystemSelectionChannels", networkProxy, result,
- RADIO_HAL_VERSION_1_4)) {
+ RADIO_HAL_VERSION_1_6)) {
return;
}
diff --git a/src/java/com/android/internal/telephony/RILUtils.java b/src/java/com/android/internal/telephony/RILUtils.java
index 94f2e96..dff8997 100644
--- a/src/java/com/android/internal/telephony/RILUtils.java
+++ b/src/java/com/android/internal/telephony/RILUtils.java
@@ -98,6 +98,7 @@
import static com.android.internal.telephony.RILConstants.RIL_REQUEST_GET_PHONE_CAPABILITY;
import static com.android.internal.telephony.RILConstants.RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE;
import static com.android.internal.telephony.RILConstants.RIL_REQUEST_GET_RADIO_CAPABILITY;
+import static com.android.internal.telephony.RILConstants.RIL_REQUEST_GET_SIMULTANEOUS_CALLING_SUPPORT;
import static com.android.internal.telephony.RILConstants.RIL_REQUEST_GET_SIM_PHONEBOOK_CAPACITY;
import static com.android.internal.telephony.RILConstants.RIL_REQUEST_GET_SIM_PHONEBOOK_RECORDS;
import static com.android.internal.telephony.RILConstants.RIL_REQUEST_GET_SIM_STATUS;
@@ -273,6 +274,7 @@
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_RIL_CONNECTED;
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_RINGBACK_TONE;
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_SIGNAL_STRENGTH;
+import static com.android.internal.telephony.RILConstants.RIL_UNSOL_SIMULTANEOUS_CALLING_SUPPORT_CHANGED;
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_SIM_REFRESH;
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_SIM_SMS_STORAGE_FULL;
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_SLICING_CONFIG_CHANGED;
@@ -4381,14 +4383,20 @@
public static PhoneCapability convertHalPhoneCapability(int[] deviceNrCapabilities, Object o) {
int maxActiveVoiceCalls = 0;
int maxActiveData = 0;
- int maxActiveInternetData = 0;
boolean validationBeforeSwitchSupported = false;
List<ModemInfo> logicalModemList = new ArrayList<>();
if (o instanceof android.hardware.radio.config.PhoneCapability) {
final android.hardware.radio.config.PhoneCapability phoneCapability =
(android.hardware.radio.config.PhoneCapability) o;
maxActiveData = phoneCapability.maxActiveData;
- maxActiveInternetData = phoneCapability.maxActiveInternetData;
+ // If the maxActiveVoice field has been set, use that value. Otherwise, default to the
+ // legacy behavior and rely on the maxActiveInternetData field:
+ if (phoneCapability.maxActiveVoice ==
+ android.hardware.radio.config.PhoneCapability.UNKNOWN) {
+ maxActiveVoiceCalls = phoneCapability.maxActiveInternetData;
+ } else {
+ maxActiveVoiceCalls = phoneCapability.maxActiveVoice;
+ }
validationBeforeSwitchSupported = phoneCapability.isInternetLingeringSupported;
for (int modemId : phoneCapability.logicalModemIds) {
logicalModemList.add(new ModemInfo(modemId));
@@ -4397,16 +4405,15 @@
final android.hardware.radio.config.V1_1.PhoneCapability phoneCapability =
(android.hardware.radio.config.V1_1.PhoneCapability) o;
maxActiveData = phoneCapability.maxActiveData;
- maxActiveInternetData = phoneCapability.maxActiveInternetData;
+ // maxActiveInternetData defines how many logical modems can have internet PDN
+ // connections simultaneously. For L+L DSDS modem it’s 1, and for DSDA modem it’s 2.
+ maxActiveVoiceCalls = phoneCapability.maxActiveInternetData;
validationBeforeSwitchSupported = phoneCapability.isInternetLingeringSupported;
for (android.hardware.radio.config.V1_1.ModemInfo modemInfo :
phoneCapability.logicalModemList) {
logicalModemList.add(new ModemInfo(modemInfo.modemId));
}
}
- // maxActiveInternetData defines how many logical modems can have internet PDN connections
- // simultaneously. For L+L DSDS modem it’s 1, and for DSDA modem it’s 2.
- maxActiveVoiceCalls = maxActiveInternetData;
return new PhoneCapability(maxActiveVoiceCalls, maxActiveData, logicalModemList,
validationBeforeSwitchSupported, deviceNrCapabilities);
}
@@ -5128,6 +5135,8 @@
return "SET_LOCATION_PRIVACY_SETTING";
case RIL_REQUEST_GET_LOCATION_PRIVACY_SETTING:
return "GET_LOCATION_PRIVACY_SETTING";
+ case RIL_REQUEST_GET_SIMULTANEOUS_CALLING_SUPPORT:
+ return "GET_SIMULTANEOUS_CALLING_SUPPORT";
default:
return "<unknown request " + request + ">";
}
@@ -5273,6 +5282,8 @@
return "UNSOL_TRIGGER_IMS_DEREGISTRATION";
case RIL_UNSOL_IMEI_MAPPING_CHANGED:
return "UNSOL_IMEI_MAPPING_CHANGED";
+ case RIL_UNSOL_SIMULTANEOUS_CALLING_SUPPORT_CHANGED:
+ return "UNSOL_SIMULTANEOUS_CALLING_SUPPORT_CHANGED";
default:
return "<unknown response " + response + ">";
}
diff --git a/src/java/com/android/internal/telephony/RadioConfig.java b/src/java/com/android/internal/telephony/RadioConfig.java
index 6bf0203..13f6502 100644
--- a/src/java/com/android/internal/telephony/RadioConfig.java
+++ b/src/java/com/android/internal/telephony/RadioConfig.java
@@ -23,6 +23,7 @@
import static com.android.internal.telephony.RILConstants.REQUEST_NOT_SUPPORTED;
import static com.android.internal.telephony.RILConstants.RIL_REQUEST_GET_HAL_DEVICE_CAPABILITIES;
import static com.android.internal.telephony.RILConstants.RIL_REQUEST_GET_PHONE_CAPABILITY;
+import static com.android.internal.telephony.RILConstants.RIL_REQUEST_GET_SIMULTANEOUS_CALLING_SUPPORT;
import static com.android.internal.telephony.RILConstants.RIL_REQUEST_GET_SLOT_STATUS;
import static com.android.internal.telephony.RILConstants.RIL_REQUEST_SET_LOGICAL_TO_PHYSICAL_SLOT_MAPPING;
import static com.android.internal.telephony.RILConstants.RIL_REQUEST_SET_PREFERRED_DATA_MODEM;
@@ -79,6 +80,8 @@
protected Registrant mSimSlotStatusRegistrant;
+ protected Registrant mSimultaneousCallingSupportStatusRegistrant;
+
private boolean isMobileDataCapable(Context context) {
final TelephonyManager tm = context.getSystemService(TelephonyManager.class);
return tm != null && tm.isDataCapable();
@@ -478,6 +481,34 @@
}
/**
+ * Wrapper function for IRadioConfig.getSimultaneousCallingSupport().
+ */
+ public void updateSimultaneousCallingSupport(Message result) {
+ RadioConfigProxy proxy = getRadioConfigProxy(null);
+ if (proxy.isEmpty()) return;
+
+ if (proxy.getVersion().less(RIL.RADIO_HAL_VERSION_2_2)) {
+ if (result != null) {
+ AsyncResult.forMessage(result, null,
+ CommandException.fromRilErrno(REQUEST_NOT_SUPPORTED));
+ result.sendToTarget();
+ }
+ return;
+ }
+
+ RILRequest rr = obtainRequest(RIL_REQUEST_GET_SIMULTANEOUS_CALLING_SUPPORT, result,
+ mDefaultWorkSource);
+ if (DBG) {
+ logd(rr.serialString() + "> " + RILUtils.requestToString(rr.mRequest));
+ }
+ try {
+ proxy.updateSimultaneousCallingSupport(rr.mSerial);
+ } catch (RemoteException | RuntimeException e) {
+ resetProxyAndRequestList("updateSimultaneousCallingSupport", e);
+ }
+ }
+
+ /**
* Wrapper function for IRadioConfig.getPhoneCapability().
*/
public void getPhoneCapability(Message result) {
@@ -566,6 +597,14 @@
}
/**
+ * Register a handler to get SIM slots that support simultaneous calling changed notifications.
+ */
+ public void registerForSimultaneousCallingSupportStatusChanged(Handler h, int what,
+ Object obj) {
+ mSimultaneousCallingSupportStatusRegistrant = new Registrant(h, what, obj);
+ }
+
+ /**
* Register a handler to get SIM slot status changed notifications.
*/
public void registerForSimSlotStatusChanged(Handler h, int what, Object obj) {
diff --git a/src/java/com/android/internal/telephony/RadioConfigIndicationAidl.java b/src/java/com/android/internal/telephony/RadioConfigIndicationAidl.java
index 76e6d5e..9aa1aaa 100644
--- a/src/java/com/android/internal/telephony/RadioConfigIndicationAidl.java
+++ b/src/java/com/android/internal/telephony/RadioConfigIndicationAidl.java
@@ -17,12 +17,14 @@
package com.android.internal.telephony;
import android.os.AsyncResult;
+import android.os.RemoteException;
import android.os.Trace;
import com.android.internal.telephony.uicc.IccSlotStatus;
import com.android.telephony.Rlog;
import java.util.ArrayList;
+import java.util.Arrays;
/**
* This class is the AIDL implementation of IRadioConfigIndication interface.
@@ -51,6 +53,19 @@
}
}
+ /**
+ * Indication that the logical slots that support simultaneous calling has changed.
+ */
+ @Override
+ public void onSimultaneousCallingSupportChanged(int[] enabledLogicalSlots) {
+ ArrayList<Integer> ret = RILUtils.primitiveArrayToArrayList(enabledLogicalSlots);
+ logd("onSimultaneousCallingSupportChanged: enabledLogicalSlots = " + ret);
+ if (mRadioConfig.mSimultaneousCallingSupportStatusRegistrant != null) {
+ mRadioConfig.mSimultaneousCallingSupportStatusRegistrant.notifyRegistrant(
+ new AsyncResult(null, ret, null));
+ }
+ }
+
private static void logd(String log) {
Rlog.d(TAG, "[UNSL]< " + log);
Trace.instantForTrack(Trace.TRACE_TAG_NETWORK, "RIL", log);
diff --git a/src/java/com/android/internal/telephony/RadioConfigProxy.java b/src/java/com/android/internal/telephony/RadioConfigProxy.java
index 9d05fc5..b6c6d68 100644
--- a/src/java/com/android/internal/telephony/RadioConfigProxy.java
+++ b/src/java/com/android/internal/telephony/RadioConfigProxy.java
@@ -225,6 +225,16 @@
}
/**
+ * Wrapper function for IRadioConfig.getSimultaneousCallingSupport()
+ */
+ public void updateSimultaneousCallingSupport(int serial) throws RemoteException {
+ if (isAidl()) {
+ getAidl().getSimultaneousCallingSupport(serial);
+ }
+ // Only supported on AIDL.
+ }
+
+ /**
* Wrapper function for using IRadioConfig.setNumOfLiveModems(int32_t serial,
* byte numOfLiveModems) to switch between single-sim and multi-sim.
*/
diff --git a/src/java/com/android/internal/telephony/RadioConfigResponseAidl.java b/src/java/com/android/internal/telephony/RadioConfigResponseAidl.java
index 2049654..0a41b11 100644
--- a/src/java/com/android/internal/telephony/RadioConfigResponseAidl.java
+++ b/src/java/com/android/internal/telephony/RadioConfigResponseAidl.java
@@ -16,6 +16,7 @@
package com.android.internal.telephony;
+import android.hardware.radio.RadioResponseInfo;
import android.os.RemoteException;
import android.telephony.PhoneCapability;
@@ -23,6 +24,7 @@
import com.android.telephony.Rlog;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Set;
/**
@@ -112,6 +114,30 @@
}
/**
+ * Response function for IRadioConfig.getSimultaneousCallingSupport().
+ */
+ @Override
+ public void getSimultaneousCallingSupportResponse(
+ android.hardware.radio.RadioResponseInfo info,
+ int[] enabledLogicalSlots)
+ throws RemoteException {
+ RILRequest rr = mRadioConfig.processResponse(info);
+ if (rr != null) {
+ ArrayList<Integer> ret = RILUtils.primitiveArrayToArrayList(enabledLogicalSlots);
+ if (info.error == android.hardware.radio.RadioError.NONE) {
+ // send response
+ RadioResponse.sendMessageResponse(rr.mResult, ret);
+ logd(rr, RILUtils.requestToString(rr.mRequest) + " " + ret);
+ } else {
+ rr.onError(info.error, enabledLogicalSlots);
+ loge(rr, RILUtils.requestToString(rr.mRequest) + " error " + info.error);
+ }
+ } else {
+ loge("getSimultaneousCallingSupportResponse: Error " + info.toString());
+ }
+ }
+
+ /**
* Response function for IRadioConfig.getSimSlotsStatus().
*/
@Override
diff --git a/src/java/com/android/internal/telephony/ServiceStateTracker.java b/src/java/com/android/internal/telephony/ServiceStateTracker.java
index 01d6e4c..d19e4cb 100644
--- a/src/java/com/android/internal/telephony/ServiceStateTracker.java
+++ b/src/java/com/android/internal/telephony/ServiceStateTracker.java
@@ -94,6 +94,8 @@
import com.android.internal.telephony.data.AccessNetworksManager.AccessNetworksManagerCallback;
import com.android.internal.telephony.data.DataNetwork;
import com.android.internal.telephony.data.DataNetworkController.DataNetworkControllerCallback;
+import com.android.internal.telephony.domainselection.DomainSelectionResolver;
+import com.android.internal.telephony.emergency.EmergencyStateTracker;
import com.android.internal.telephony.flags.FeatureFlags;
import com.android.internal.telephony.imsphone.ImsPhone;
import com.android.internal.telephony.metrics.RadioPowerStateStats;
@@ -4969,6 +4971,9 @@
public void powerOffRadioSafely() {
synchronized (this) {
SatelliteController.getInstance().onCellularRadioPowerOffRequested();
+ if (DomainSelectionResolver.getInstance().isDomainSelectionSupported()) {
+ EmergencyStateTracker.getInstance().onCellularRadioPowerOffRequested();
+ }
if (!mPendingRadioPowerOffAfterDataOff) {
// hang up all active voice calls first
if (mPhone.isPhoneTypeGsm() && mPhone.isInCall()) {
diff --git a/src/java/com/android/internal/telephony/SignalStrengthController.java b/src/java/com/android/internal/telephony/SignalStrengthController.java
index 387c501..b11d7e5 100644
--- a/src/java/com/android/internal/telephony/SignalStrengthController.java
+++ b/src/java/com/android/internal/telephony/SignalStrengthController.java
@@ -64,6 +64,7 @@
import java.util.TreeSet;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
import java.util.regex.PatternSyntaxException;
/**
@@ -101,6 +102,7 @@
private static final int EVENT_POLL_SIGNAL_STRENGTH = 7;
private static final int EVENT_SIGNAL_STRENGTH_UPDATE = 8;
private static final int EVENT_POLL_SIGNAL_STRENGTH_DONE = 9;
+ private static final int EVENT_SERVICE_STATE_CHANGED = 10;
@NonNull
private final Phone mPhone;
@@ -146,6 +148,8 @@
@NonNull
private final LocalLog mLocalLog = new LocalLog(64);
+ private final AtomicBoolean mNTNConnected = new AtomicBoolean(false);
+
public SignalStrengthController(@NonNull Phone phone) {
mPhone = phone;
mCi = mPhone.mCi;
@@ -161,6 +165,8 @@
ccm.registerCarrierConfigChangeListener(this::post,
(slotIndex, subId, carrierId, specificCarrierId) ->
onCarrierConfigurationChanged(slotIndex));
+
+ mPhone.registerForServiceStateChanged(this, EVENT_SERVICE_STATE_CHANGED, null);
}
@Override
@@ -273,6 +279,11 @@
break;
}
+ case EVENT_SERVICE_STATE_CHANGED: {
+ onServiceStateChanged((ServiceState) ((AsyncResult) msg.obj).result);
+ break;
+ }
+
default:
log("Unhandled message with number: " + msg.what);
break;
@@ -406,10 +417,13 @@
true));
}
- int lteMeasurementEnabled = mCarrierConfig.getInt(CarrierConfigManager
- .KEY_PARAMETERS_USED_FOR_LTE_SIGNAL_BAR_INT, CellSignalStrengthLte.USE_RSRP);
- int[] lteRsrpThresholds = mCarrierConfig.getIntArray(
- CarrierConfigManager.KEY_LTE_RSRP_THRESHOLDS_INT_ARRAY);
+ int lteMeasurementEnabled = mCarrierConfig.getInt(isUsingNonTerrestrialNetwork()
+ ? CarrierConfigManager.KEY_PARAMETERS_USED_FOR_NTN_LTE_SIGNAL_BAR_INT
+ : CarrierConfigManager.KEY_PARAMETERS_USED_FOR_LTE_SIGNAL_BAR_INT,
+ CellSignalStrengthLte.USE_RSRP);
+ int[] lteRsrpThresholds = mCarrierConfig.getIntArray(isUsingNonTerrestrialNetwork()
+ ? CarrierConfigManager.KEY_NTN_LTE_RSRP_THRESHOLDS_INT_ARRAY
+ : CarrierConfigManager.KEY_LTE_RSRP_THRESHOLDS_INT_ARRAY);
if (lteRsrpThresholds != null) {
signalThresholdInfos.add(
validateAndCreateSignalThresholdInfo(
@@ -421,7 +435,8 @@
}
if (mPhone.getHalVersion(HAL_SERVICE_NETWORK).greaterOrEqual(RIL.RADIO_HAL_VERSION_1_5)) {
- int[] lteRsrqThresholds = mCarrierConfig.getIntArray(
+ int[] lteRsrqThresholds = mCarrierConfig.getIntArray(isUsingNonTerrestrialNetwork()
+ ? CarrierConfigManager.KEY_NTN_LTE_RSRQ_THRESHOLDS_INT_ARRAY :
CarrierConfigManager.KEY_LTE_RSRQ_THRESHOLDS_INT_ARRAY);
if (lteRsrqThresholds != null) {
signalThresholdInfos.add(
@@ -433,7 +448,8 @@
(lteMeasurementEnabled & CellSignalStrengthLte.USE_RSRQ) != 0));
}
- int[] lteRssnrThresholds = mCarrierConfig.getIntArray(
+ int[] lteRssnrThresholds = mCarrierConfig.getIntArray(isUsingNonTerrestrialNetwork()
+ ? CarrierConfigManager.KEY_NTN_LTE_RSSNR_THRESHOLDS_INT_ARRAY :
CarrierConfigManager.KEY_LTE_RSSNR_THRESHOLDS_INT_ARRAY);
if (lteRssnrThresholds != null) {
signalThresholdInfos.add(
@@ -1322,6 +1338,25 @@
};
}
+ private void onServiceStateChanged(ServiceState state) {
+ if (state.getState() != ServiceState.STATE_IN_SERVICE) {
+ return;
+ }
+
+ if (mNTNConnected.get() != state.isUsingNonTerrestrialNetwork()) {
+ log("onServiceStateChanged: update it to " + state.isUsingNonTerrestrialNetwork());
+ updateReportingCriteria();
+ mNTNConnected.set(state.isUsingNonTerrestrialNetwork());
+ }
+ }
+
+ private boolean isUsingNonTerrestrialNetwork() {
+ if (mPhone.getServiceState() == null) {
+ return false;
+ }
+ return mPhone.getServiceState().isUsingNonTerrestrialNetwork();
+ }
+
private static void log(String msg) {
if (DBG) Rlog.d(TAG, msg);
}
diff --git a/src/java/com/android/internal/telephony/SmsController.java b/src/java/com/android/internal/telephony/SmsController.java
index 97161f8..251a1fd 100644
--- a/src/java/com/android/internal/telephony/SmsController.java
+++ b/src/java/com/android/internal/telephony/SmsController.java
@@ -22,6 +22,7 @@
import static com.android.internal.telephony.util.TelephonyUtils.checkDumpPermission;
+import android.annotation.NonNull;
import android.annotation.Nullable;
import android.app.ActivityManager;
import android.app.AppOpsManager;
@@ -44,6 +45,7 @@
import android.telephony.TelephonyManager;
import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.telephony.flags.FeatureFlags;
import com.android.internal.telephony.subscription.SubscriptionManagerService;
import com.android.internal.telephony.util.TelephonyUtils;
import com.android.internal.util.IndentingPrintWriter;
@@ -62,10 +64,11 @@
static final String LOG_TAG = "SmsController";
private final Context mContext;
-
+ private final FeatureFlags mFlags;
@VisibleForTesting
- public SmsController(Context context) {
+ public SmsController(Context context, @NonNull FeatureFlags flags) {
mContext = context;
+ mFlags = flags;
ServiceRegisterer smsServiceRegisterer = TelephonyFrameworkInitializer
.getTelephonyServiceManager()
.getSmsServiceRegisterer();
@@ -1114,4 +1117,20 @@
// Check if smscAddr is present in FDN list
return FdnUtils.isNumberBlockedByFDN(phoneId, smscAddr, defaultCountryIso);
}
+
+ /**
+ * Gets the message size of WAP from the cache.
+ *
+ * @param locationUrl the location to use as a key for looking up the size in the cache.
+ * The locationUrl may or may not have the transactionId appended to the url.
+ *
+ * @return long representing the message size
+ * @throws java.util.NoSuchElementException if the WAP push doesn't exist in the cache
+ * @throws IllegalArgumentException if the locationUrl is empty
+ */
+ @Override
+ public long getWapMessageSize(@NonNull String locationUrl) {
+ byte[] bytes = locationUrl.getBytes(StandardCharsets.ISO_8859_1);
+ return WapPushCache.getWapMessageSize(bytes);
+ }
}
\ No newline at end of file
diff --git a/src/java/com/android/internal/telephony/TelephonyComponentFactory.java b/src/java/com/android/internal/telephony/TelephonyComponentFactory.java
index 74094a3..f09b9ae 100644
--- a/src/java/com/android/internal/telephony/TelephonyComponentFactory.java
+++ b/src/java/com/android/internal/telephony/TelephonyComponentFactory.java
@@ -342,8 +342,9 @@
* Create a new UiccProfile object.
*/
public UiccProfile makeUiccProfile(Context context, CommandsInterface ci, IccCardStatus ics,
- int phoneId, UiccCard uiccCard, Object lock) {
- return new UiccProfile(context, ci, ics, phoneId, uiccCard, lock);
+ int phoneId, UiccCard uiccCard, Object lock,
+ @NonNull FeatureFlags flags) {
+ return new UiccProfile(context, ci, ics, phoneId, uiccCard, lock, flags);
}
public EriManager makeEriManager(Phone phone, int eriFileSource) {
diff --git a/src/java/com/android/internal/telephony/WapPushCache.java b/src/java/com/android/internal/telephony/WapPushCache.java
new file mode 100644
index 0000000..70d12e2
--- /dev/null
+++ b/src/java/com/android/internal/telephony/WapPushCache.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony;
+
+import android.annotation.NonNull;
+import android.telephony.Rlog;
+
+import com.android.internal.annotations.VisibleForTesting;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.NoSuchElementException;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Caches WAP push PDU data for retrieval during MMS downloading.
+ * When on a satellite connection, the cached message size will be used to prevent downloading
+ * messages that exceed a threshold.
+ *
+ * The cache uses a circular buffer and will start invalidating the oldest entries after 250
+ * message sizes have been inserted.
+ * The cache also invalidates entries that have been in the cache for over 14 days.
+ */
+public class WapPushCache {
+ private static final String TAG = "WAP PUSH CACHE";
+
+ // Because we store each size twice, this represents 250 messages. That limit is chosen so
+ // that the memory footprint of the cache stays reasonably small while still supporting what
+ // we guess will be the vast majority of real use cases.
+ private static final int MAX_CACHE_SIZE = 500;
+
+ // WAP push PDUs have an expiry property, but we can't be certain that it is set accurately
+ // by the carrier. We will use our own expiry for this cache to keep it small. One example
+ // carrier has an expiry of 7 days so 14 will give us room for those with longer times as well.
+ private static final long CACHE_EXPIRY_TIME = TimeUnit.DAYS.toMillis(14);
+
+ private static final HashMap<String, CacheEntry> sMessageSizes = new LinkedHashMap<>() {
+ @Override
+ protected boolean removeEldestEntry(Entry<String, CacheEntry> eldest) {
+ return size() > MAX_CACHE_SIZE;
+ }
+ };
+
+ @VisibleForTesting
+ public static TelephonyFacade sTelephonyFacade = new TelephonyFacade();
+
+ /**
+ * Puts a WAP push PDU's messageSize in the cache.
+ *
+ * The data is stored twice, once using just locationUrl as the key and once
+ * using transactionId appended to the locationUrl. For some carriers, xMS apps
+ * append the transactionId to the location and we need to support lookup using either the
+ * original location or one modified in this way.
+
+ *
+ * @param locationUrl location of the message used as part of the cache key.
+ * @param transactionId message transaction ID used as part of the cache key.
+ * @param messageSize size of the message to be stored in the cache.
+ */
+ public static void putWapMessageSize(
+ @NonNull byte[] locationUrl,
+ @NonNull byte[] transactionId,
+ long messageSize
+ ) {
+ long expiry = sTelephonyFacade.getElapsedSinceBootMillis() + CACHE_EXPIRY_TIME;
+ if (messageSize <= 0) {
+ Rlog.e(TAG, "Invalid message size of " + messageSize + ". Not inserting.");
+ return;
+ }
+ synchronized (sMessageSizes) {
+ sMessageSizes.put(Arrays.toString(locationUrl), new CacheEntry(messageSize, expiry));
+
+ // concatenate the locationUrl and transactionId
+ byte[] joinedKey = ByteBuffer
+ .allocate(locationUrl.length + transactionId.length)
+ .put(locationUrl)
+ .put(transactionId)
+ .array();
+ sMessageSizes.put(Arrays.toString(joinedKey), new CacheEntry(messageSize, expiry));
+ invalidateOldEntries();
+ }
+ }
+
+ /**
+ * Remove entries from the cache that are older than CACHE_EXPIRY_TIME
+ */
+ private static void invalidateOldEntries() {
+ long currentTime = sTelephonyFacade.getElapsedSinceBootMillis();
+
+ // We can just remove elements from the start until one is found that does not exceed the
+ // expiry since the elements are in order of insertion.
+ for (Iterator<CacheEntry> it = sMessageSizes.values().iterator(); it.hasNext(); ) {
+ CacheEntry entry = it.next();
+ if (entry.mExpiry < currentTime) {
+ it.remove();
+ } else {
+ break;
+ }
+ }
+ }
+
+ /**
+ * Gets the message size of a WAP from the cache.
+ *
+ * Because we stored the size both using the location+transactionId key and using the
+ * location only key, we should be able to find the size whether the xMS app modified
+ * the location or not.
+ *
+ * @param locationUrl the location to use as a key for looking up the size in the cache.
+ *
+ * @return long representing the message size of the WAP
+ * @throws NoSuchElementException if the WAP doesn't exist in the cache
+ * @throws IllegalArgumentException if the locationUrl is empty
+ */
+ public static long getWapMessageSize(@NonNull byte[] locationUrl) {
+ if (locationUrl.length == 0) {
+ throw new IllegalArgumentException("Found empty locationUrl");
+ }
+ CacheEntry entry = sMessageSizes.get(Arrays.toString(locationUrl));
+ if (entry == null) {
+ throw new NoSuchElementException(
+ "No cached WAP size for locationUrl " + Arrays.toString(locationUrl)
+ );
+ }
+ return entry.mSize;
+ }
+
+ /**
+ * Clears all elements from the cache
+ */
+ @VisibleForTesting
+ public static void clear() {
+ sMessageSizes.clear();
+ }
+
+ /**
+ * Returns a count of the number of elements in the cache
+ * @return count of elements
+ */
+ @VisibleForTesting
+ public static int size() {
+ return sMessageSizes.size();
+ }
+
+
+
+ private static class CacheEntry {
+ CacheEntry(long size, long expiry) {
+ mSize = size;
+ mExpiry = expiry;
+ }
+ private final long mSize;
+ private final long mExpiry;
+ }
+}
diff --git a/src/java/com/android/internal/telephony/WapPushOverSms.java b/src/java/com/android/internal/telephony/WapPushOverSms.java
index d6ea4ad..7669411 100644
--- a/src/java/com/android/internal/telephony/WapPushOverSms.java
+++ b/src/java/com/android/internal/telephony/WapPushOverSms.java
@@ -262,6 +262,13 @@
if (parsedPdu != null && parsedPdu.getMessageType() == MESSAGE_TYPE_NOTIFICATION_IND) {
final NotificationInd nInd = (NotificationInd) parsedPdu;
+ // save the WAP push message size so that if a download request is made for it
+ // while on a satellite connection we can check if the size is under the threshold
+ WapPushCache.putWapMessageSize(
+ nInd.getContentLocation(),
+ nInd.getTransactionId(),
+ nInd.getMessageSize()
+ );
if (nInd.getFrom() != null
&& BlockChecker.isBlocked(mContext, nInd.getFrom().getString(), null)) {
result.statusCode = Intents.RESULT_SMS_HANDLED;
diff --git a/src/java/com/android/internal/telephony/cat/CatService.java b/src/java/com/android/internal/telephony/cat/CatService.java
index fa2b19b..cadb02e 100644
--- a/src/java/com/android/internal/telephony/cat/CatService.java
+++ b/src/java/com/android/internal/telephony/cat/CatService.java
@@ -49,6 +49,8 @@
import com.android.internal.telephony.PhoneConstants;
import com.android.internal.telephony.ProxyController;
import com.android.internal.telephony.SmsController;
+import com.android.internal.telephony.flags.FeatureFlags;
+import com.android.internal.telephony.flags.FeatureFlagsImpl;
import com.android.internal.telephony.subscription.SubscriptionManagerService;
import com.android.internal.telephony.uicc.IccCardStatus.CardState;
import com.android.internal.telephony.uicc.IccFileHandler;
@@ -104,6 +106,8 @@
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
private static CatService[] sInstance = null;
@UnsupportedAppUsage
+ private static final FeatureFlags sFlags = new FeatureFlagsImpl();
+ @UnsupportedAppUsage
private CommandsInterface mCmdIf;
@UnsupportedAppUsage
private Context mContext;
@@ -487,7 +491,8 @@
destAddr = ((SendSMSParams) cmdParams).mDestAddress.text;
}
if (text != null && destAddr != null) {
- ProxyController proxyController = ProxyController.getInstance(mContext);
+ ProxyController proxyController = ProxyController
+ .getInstance(mContext, sFlags);
SubscriptionManager subscriptionManager = (SubscriptionManager)
mContext.getSystemService(
Context.TELEPHONY_SUBSCRIPTION_SERVICE);
diff --git a/src/java/com/android/internal/telephony/data/DataNetworkController.java b/src/java/com/android/internal/telephony/data/DataNetworkController.java
index 63fe7e5..7f70e32 100644
--- a/src/java/com/android/internal/telephony/data/DataNetworkController.java
+++ b/src/java/com/android/internal/telephony/data/DataNetworkController.java
@@ -1408,22 +1408,26 @@
/**
* Evaluate if telephony frameworks would allow data setup for internet in current environment.
*
+ * @param ignoreExistingNetworks {@code true} to skip the existing network check.
* @return {@code true} if the environment is allowed for internet data. {@code false} if not
* allowed. For example, if SIM is absent, or airplane mode is on, then data is NOT allowed.
* This API does not reflect the currently internet data network status. It's possible there is
* no internet data due to weak cellular signal or network side issue, but internet data is
* still allowed in this case.
*/
- public boolean isInternetDataAllowed() {
+ public boolean isInternetDataAllowed(boolean ignoreExistingNetworks) {
TelephonyNetworkRequest internetRequest = new TelephonyNetworkRequest(
new NetworkRequest.Builder()
.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
.build(), mPhone);
- // If one of the existing networks can satisfy the internet request, then internet is
- // allowed.
- if (mDataNetworkList.stream().anyMatch(dataNetwork -> internetRequest.canBeSatisfiedBy(
- dataNetwork.getNetworkCapabilities()))) {
+ // If we don't skip checking existing network, then we should check If one of the
+ // existing networks can satisfy the internet request, then internet is allowed.
+ if ((!mFeatureFlags.ignoreExistingNetworksForInternetAllowedChecking()
+ || !ignoreExistingNetworks)
+ && mDataNetworkList.stream().anyMatch(
+ dataNetwork -> internetRequest.canBeSatisfiedBy(
+ dataNetwork.getNetworkCapabilities()))) {
return true;
}
diff --git a/src/java/com/android/internal/telephony/data/DataStallRecoveryManager.java b/src/java/com/android/internal/telephony/data/DataStallRecoveryManager.java
index f2b6776..fb9d32f 100644
--- a/src/java/com/android/internal/telephony/data/DataStallRecoveryManager.java
+++ b/src/java/com/android/internal/telephony/data/DataStallRecoveryManager.java
@@ -781,7 +781,7 @@
return false;
}
- if (!mDataNetworkController.isInternetDataAllowed()) {
+ if (!mDataNetworkController.isInternetDataAllowed(true/* ignoreExistingNetworks */)) {
logl("skip data stall recovery as data not allowed.");
return false;
}
diff --git a/src/java/com/android/internal/telephony/data/TelephonyNetworkFactory.java b/src/java/com/android/internal/telephony/data/TelephonyNetworkFactory.java
index 2cdf807..377c219 100644
--- a/src/java/com/android/internal/telephony/data/TelephonyNetworkFactory.java
+++ b/src/java/com/android/internal/telephony/data/TelephonyNetworkFactory.java
@@ -16,6 +16,7 @@
package com.android.internal.telephony.data;
+import android.annotation.NonNull;
import android.net.NetworkCapabilities;
import android.net.NetworkFactory;
import android.net.NetworkRequest;
@@ -29,6 +30,7 @@
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.telephony.Phone;
+import com.android.internal.telephony.flags.FeatureFlags;
import com.android.internal.telephony.metrics.NetworkRequestsStats;
import com.android.internal.util.IndentingPrintWriter;
import com.android.telephony.Rlog;
@@ -77,11 +79,22 @@
@VisibleForTesting
public final Handler mInternalHandler;
+ private final @NonNull FeatureFlags mFlags;
- public TelephonyNetworkFactory(Looper looper, Phone phone) {
+
+ /**
+ * Constructor
+ *
+ * @param looper The looper for the handler
+ * @param phone The phone instance
+ * @param featureFlags The feature flags
+ */
+ public TelephonyNetworkFactory(@NonNull Looper looper, @NonNull Phone phone,
+ @NonNull FeatureFlags featureFlags) {
super(looper, phone.getContext(), "TelephonyNetworkFactory[" + phone.getPhoneId()
+ "]", null);
mPhone = phone;
+ mFlags = featureFlags;
mInternalHandler = new InternalHandler(looper);
mAccessNetworksManager = mPhone.getAccessNetworksManager();
diff --git a/src/java/com/android/internal/telephony/domainselection/NormalCallDomainSelectionConnection.java b/src/java/com/android/internal/telephony/domainselection/NormalCallDomainSelectionConnection.java
index 516d6b9..0532a05 100644
--- a/src/java/com/android/internal/telephony/domainselection/NormalCallDomainSelectionConnection.java
+++ b/src/java/com/android/internal/telephony/domainselection/NormalCallDomainSelectionConnection.java
@@ -22,9 +22,11 @@
import android.annotation.Nullable;
import android.telephony.AccessNetworkConstants.RadioAccessNetworkType;
import android.telephony.Annotation.DisconnectCauses;
+import android.telephony.DisconnectCause;
import android.telephony.DomainSelectionService;
import android.telephony.DomainSelectionService.EmergencyScanType;
import android.telephony.NetworkRegistrationInfo;
+import android.telephony.PreciseDisconnectCause;
import android.telephony.ims.ImsReasonInfo;
import com.android.internal.telephony.Phone;
@@ -37,6 +39,9 @@
public class NormalCallDomainSelectionConnection extends DomainSelectionConnection {
private static final boolean DBG = false;
+ private int mDisconnectCause = DisconnectCause.NOT_VALID;
+ private int mPreciseDisconnectCause = PreciseDisconnectCause.NOT_VALID;
+ private String mReasonMessage = null;
private @Nullable DomainSelectionConnectionCallback mCallback;
@@ -123,4 +128,49 @@
}
return builder.build();
}
+
+ /**
+ * Save call disconnect info for error propagation.
+ * @param disconnectCause The code for the reason for the disconnect.
+ * @param preciseDisconnectCause The code for the precise reason for the disconnect.
+ * @param reasonMessage Description of the reason for the disconnect, not intended for the user
+ * to see.
+ */
+ public void setDisconnectCause(int disconnectCause, int preciseDisconnectCause,
+ String reasonMessage) {
+ mDisconnectCause = disconnectCause;
+ mPreciseDisconnectCause = preciseDisconnectCause;
+ mReasonMessage = reasonMessage;
+ }
+
+ public int getDisconnectCause() {
+ return mDisconnectCause;
+ }
+
+ public int getPreciseDisconnectCause() {
+ return mPreciseDisconnectCause;
+ }
+
+ public String getReasonMessage() {
+ return mReasonMessage;
+ }
+
+ /**
+ * @return imsReasonInfo Reason for the IMS call failure.
+ */
+ public @Nullable ImsReasonInfo getImsReasonInfo() {
+ if (getSelectionAttributes() == null) {
+ // Neither selectDomain(...) nor reselectDomain(...) has been called yet.
+ return null;
+ }
+
+ return getSelectionAttributes().getPsDisconnectCause();
+ }
+
+ /**
+ * @return phoneId To support localized message based on phoneId
+ */
+ public int getPhoneId() {
+ return getPhone().getPhoneId();
+ }
}
diff --git a/src/java/com/android/internal/telephony/emergency/EmergencyStateTracker.java b/src/java/com/android/internal/telephony/emergency/EmergencyStateTracker.java
index 3023501..0692f7d 100644
--- a/src/java/com/android/internal/telephony/emergency/EmergencyStateTracker.java
+++ b/src/java/com/android/internal/telephony/emergency/EmergencyStateTracker.java
@@ -892,6 +892,18 @@
}
}
+ /**
+ * Handles the radio power off request.
+ */
+ public void onCellularRadioPowerOffRequested() {
+ synchronized (mLock) {
+ if (isInEcm()) {
+ exitEmergencyCallbackMode(null);
+ }
+ exitEmergencyModeIfDelayed();
+ }
+ }
+
private static boolean isVoWiFi(int properties) {
return (properties & android.telecom.Connection.PROPERTY_WIFI) > 0
|| (properties & android.telecom.Connection.PROPERTY_CROSS_SIM) > 0;
diff --git a/src/java/com/android/internal/telephony/imsphone/ImsPhoneCallTracker.java b/src/java/com/android/internal/telephony/imsphone/ImsPhoneCallTracker.java
index 4f9b69d..e95433c 100644
--- a/src/java/com/android/internal/telephony/imsphone/ImsPhoneCallTracker.java
+++ b/src/java/com/android/internal/telephony/imsphone/ImsPhoneCallTracker.java
@@ -311,8 +311,11 @@
// activeCall could be null if the foreground call is in a disconnected
// state. If either of the calls is null there is no need to check if
// one will be disconnected on answer.
+ // Use VideoProfile.STATE_BIDIRECTIONAL to not affect existing
+ // implementation. Video state of user response is handled in acceptCall().
boolean answeringWillDisconnect =
- shouldDisconnectActiveCallOnAnswer(activeCall, imsCall);
+ shouldDisconnectActiveCallOnAnswer(activeCall, imsCall,
+ VideoProfile.STATE_BIDIRECTIONAL);
conn.setActiveCallDisconnectedOnAnswer(answeringWillDisconnect);
}
}
@@ -2215,7 +2218,7 @@
ImsCall ringingCall = mRingingCall.getImsCall();
if (mForegroundCall.hasConnections() && mRingingCall.hasConnections()) {
answeringWillDisconnect =
- shouldDisconnectActiveCallOnAnswer(activeCall, ringingCall);
+ shouldDisconnectActiveCallOnAnswer(activeCall, ringingCall, videoState);
}
// Cache video state for pending MT call.
@@ -5499,11 +5502,13 @@
*
* @param activeCall The active call.
* @param incomingCall The incoming call.
+ * @param incomingCallVideoState The media type of incoming call acceptance.
+ * {@link VideoProfile.VideoState}
* @return {@code true} if answering the incoming call will cause the active call to be
* disconnected, {@code false} otherwise.
*/
private boolean shouldDisconnectActiveCallOnAnswer(ImsCall activeCall,
- ImsCall incomingCall) {
+ ImsCall incomingCall, int incomingCallVideoState) {
if (activeCall == null || incomingCall == null) {
return false;
@@ -5518,7 +5523,14 @@
boolean isActiveCallOnWifi = activeCall.isWifiCall();
boolean isVoWifiEnabled = mImsManager.isWfcEnabledByPlatform()
&& mImsManager.isWfcEnabledByUser();
- boolean isIncomingCallAudio = !incomingCall.isVideoCall();
+ boolean isIncomingCallAudio = true;
+ if (!mFeatureFlags.terminateActiveVideoCallWhenAcceptingSecondVideoCallAsAudioOnly()) {
+ isIncomingCallAudio = !incomingCall.isVideoCall();
+ } else {
+ isIncomingCallAudio = !incomingCall.isVideoCall()
+ || incomingCallVideoState == VideoProfile.STATE_AUDIO_ONLY;
+ }
+
log("shouldDisconnectActiveCallOnAnswer : isActiveCallVideo=" + isActiveCallVideo +
" isActiveCallOnWifi=" + isActiveCallOnWifi + " isIncomingCallAudio=" +
isIncomingCallAudio + " isVowifiEnabled=" + isVoWifiEnabled);
diff --git a/src/java/com/android/internal/telephony/metrics/MetricsCollector.java b/src/java/com/android/internal/telephony/metrics/MetricsCollector.java
index 9866c74..8bd2547 100644
--- a/src/java/com/android/internal/telephony/metrics/MetricsCollector.java
+++ b/src/java/com/android/internal/telephony/metrics/MetricsCollector.java
@@ -53,7 +53,9 @@
import static com.android.internal.telephony.TelephonyStatsLog.VOICE_CALL_RAT_USAGE;
import static com.android.internal.telephony.TelephonyStatsLog.VOICE_CALL_SESSION;
import static com.android.internal.telephony.TelephonyStatsLog.VOICE_CALL_SESSION__CALL_DURATION__CALL_DURATION_UNKNOWN;
+import static com.android.internal.telephony.util.TelephonyUtils.IS_DEBUGGABLE;
+import android.annotation.NonNull;
import android.app.StatsManager;
import android.content.Context;
import android.telephony.SubscriptionManager;
@@ -65,6 +67,7 @@
import com.android.internal.telephony.PhoneFactory;
import com.android.internal.telephony.TelephonyStatsLog;
import com.android.internal.telephony.emergency.EmergencyNumberTracker;
+import com.android.internal.telephony.flags.FeatureFlags;
import com.android.internal.telephony.imsphone.ImsPhone;
import com.android.internal.telephony.nano.PersistAtomsProto.CellularDataServiceSwitch;
import com.android.internal.telephony.nano.PersistAtomsProto.CellularServiceState;
@@ -136,34 +139,55 @@
DBG ? 10L * MILLIS_PER_SECOND : 23L * MILLIS_PER_HOUR;
/**
+ * Sets atom pull cool down to 4 minutes for userdebug build.
+ *
+ * <p>Applies to certain atoms: CellularServiceState.
+ */
+ private static final long CELL_SERVICE_MIN_COOLDOWN_MILLIS =
+ DBG ? 10L * MILLIS_PER_SECOND :
+ IS_DEBUGGABLE ? 4L * MILLIS_PER_MINUTE : 23L * MILLIS_PER_HOUR;
+
+ /**
* Buckets with less than these many calls will be dropped.
*
* <p>Applies to metrics with duration fields. Currently used by voice call RAT usages.
*/
private static final long MIN_CALLS_PER_BUCKET = DBG ? 0L : 5L;
- /** Bucket size in milliseconds to round call durations into. */
+ /** Bucket size in milliseconds to round call durations info. */
private static final long DURATION_BUCKET_MILLIS =
DBG ? 2L * MILLIS_PER_SECOND : 5L * MILLIS_PER_MINUTE;
+ /**
+ * Sets smaller bucket size to round call durations for userdebug build.
+ *
+ * <p>Applies to certain atoms: CellularServiceState.
+ */
+ private static final long CELL_SERVICE_DURATION_BUCKET_MILLIS =
+ DBG || IS_DEBUGGABLE ? 2L * MILLIS_PER_SECOND : 5L * MILLIS_PER_MINUTE;
+
private final PersistAtomsStorage mStorage;
private final DeviceStateHelper mDeviceStateHelper;
private final StatsManager mStatsManager;
+ private final VonrHelper mVonrHelper;
private final AirplaneModeStats mAirplaneModeStats;
private final Set<DataCallSessionStats> mOngoingDataCallStats = ConcurrentHashMap.newKeySet();
private static final Random sRandom = new Random();
- public MetricsCollector(Context context) {
- this(context, new PersistAtomsStorage(context), new DeviceStateHelper(context));
+ public MetricsCollector(Context context, @NonNull FeatureFlags featureFlags) {
+ this(context, new PersistAtomsStorage(context),
+ new DeviceStateHelper(context), new VonrHelper(featureFlags));
}
/** Allows dependency injection. Used during unit tests. */
@VisibleForTesting
public MetricsCollector(
- Context context, PersistAtomsStorage storage, DeviceStateHelper deviceStateHelper) {
+ Context context, PersistAtomsStorage storage, DeviceStateHelper deviceStateHelper,
+ VonrHelper vonrHelper) {
mStorage = storage;
mDeviceStateHelper = deviceStateHelper;
mStatsManager = (StatsManager) context.getSystemService(Context.STATS_MANAGER);
+ mVonrHelper = vonrHelper;
if (mStatsManager != null) {
// Most (but not all) of these are subject to cooldown specified by MIN_COOLDOWN_MILLIS.
registerAtom(CELLULAR_DATA_SERVICE_SWITCH);
@@ -308,6 +332,11 @@
return mDeviceStateHelper;
}
+ /** Returns the {@link VonrHelper}. */
+ public VonrHelper getVonrHelper() {
+ return mVonrHelper;
+ }
+
/** Updates duration segments and calls {@link PersistAtomsStorage#flushAtoms()}. */
public void flushAtomsStorage() {
concludeAll();
@@ -510,7 +539,7 @@
// Include the latest durations
concludeServiceStateStats();
CellularServiceState[] persistAtoms =
- mStorage.getCellularServiceStates(MIN_COOLDOWN_MILLIS);
+ mStorage.getCellularServiceStates(CELL_SERVICE_MIN_COOLDOWN_MILLIS);
if (persistAtoms != null) {
// list is already shuffled when instances were inserted
Arrays.stream(persistAtoms)
@@ -930,7 +959,8 @@
state.simSlotIndex,
state.isMultiSim,
state.carrierId,
- roundAndConvertMillisToSeconds(state.totalTimeMillis),
+ roundAndConvertMillisToSeconds(state.totalTimeMillis,
+ CELL_SERVICE_DURATION_BUCKET_MILLIS),
state.isEmergencyOnly,
state.isInternetPdnUp,
state.foldState,
@@ -993,7 +1023,9 @@
session.handoverInProgress,
session.isIwlanCrossSimAtStart,
session.isIwlanCrossSimAtEnd,
- session.isIwlanCrossSimAtConnected);
+ session.isIwlanCrossSimAtConnected,
+ session.vonrEnabled);
+
}
private static StatsEvent buildStatsEvent(IncomingSms sms) {
@@ -1364,8 +1396,15 @@
* Rounds the duration and converts it from milliseconds to seconds.
*/
private static int roundAndConvertMillisToSeconds(long valueMillis) {
- long roundedValueMillis = Math.round((double) valueMillis / DURATION_BUCKET_MILLIS)
- * DURATION_BUCKET_MILLIS;
+ return roundAndConvertMillisToSeconds(valueMillis, DURATION_BUCKET_MILLIS);
+ }
+
+ /**
+ * Rounds the duration and converts it from milliseconds to seconds.
+ */
+ private static int roundAndConvertMillisToSeconds(long valueMillis, long durationBucketSize) {
+ long roundedValueMillis = Math.round((double) valueMillis / durationBucketSize)
+ * durationBucketSize;
return (int) (roundedValueMillis / MILLIS_PER_SECOND);
}
diff --git a/src/java/com/android/internal/telephony/metrics/PerSimStatus.java b/src/java/com/android/internal/telephony/metrics/PerSimStatus.java
index a8c7421..70ff491 100644
--- a/src/java/com/android/internal/telephony/metrics/PerSimStatus.java
+++ b/src/java/com/android/internal/telephony/metrics/PerSimStatus.java
@@ -303,7 +303,7 @@
}
/** Returns true if VoNR is enabled */
- private static boolean isVonrEnabled(Phone phone) {
+ static boolean isVonrEnabled(Phone phone) {
TelephonyManager telephonyManager =
phone.getContext()
.getSystemService(TelephonyManager.class);
diff --git a/src/java/com/android/internal/telephony/metrics/VoiceCallSessionStats.java b/src/java/com/android/internal/telephony/metrics/VoiceCallSessionStats.java
index 5dbf645..9cf53c9 100644
--- a/src/java/com/android/internal/telephony/metrics/VoiceCallSessionStats.java
+++ b/src/java/com/android/internal/telephony/metrics/VoiceCallSessionStats.java
@@ -36,6 +36,7 @@
import static com.android.internal.telephony.TelephonyStatsLog.VOICE_CALL_SESSION__SIGNAL_STRENGTH_AT_END__SIGNAL_STRENGTH_GREAT;
import static com.android.internal.telephony.TelephonyStatsLog.VOICE_CALL_SESSION__SIGNAL_STRENGTH_AT_END__SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
+import android.annotation.NonNull;
import android.annotation.Nullable;
import android.content.Context;
import android.net.wifi.WifiInfo;
@@ -69,6 +70,7 @@
import com.android.internal.telephony.ServiceStateTracker;
import com.android.internal.telephony.analytics.TelephonyAnalytics;
import com.android.internal.telephony.analytics.TelephonyAnalytics.CallAnalytics;
+import com.android.internal.telephony.flags.FeatureFlags;
import com.android.internal.telephony.imsphone.ImsPhone;
import com.android.internal.telephony.imsphone.ImsPhoneConnection;
import com.android.internal.telephony.nano.PersistAtomsProto.VoiceCallSession;
@@ -156,6 +158,7 @@
*/
private final VoiceCallRatTracker mRatUsage = new VoiceCallRatTracker();
+ private final @NonNull FeatureFlags mFlags;
private final int mPhoneId;
private final Phone mPhone;
@@ -165,10 +168,13 @@
private final DeviceStateHelper mDeviceStateHelper =
PhoneFactory.getMetricsCollector().getDeviceStateHelper();
- public VoiceCallSessionStats(int phoneId, Phone phone) {
+ private final VonrHelper mVonrHelper =
+ PhoneFactory.getMetricsCollector().getVonrHelper();
+
+ public VoiceCallSessionStats(int phoneId, Phone phone, @NonNull FeatureFlags featureFlags) {
mPhoneId = phoneId;
mPhone = phone;
-
+ mFlags = featureFlags;
DataConnectionStateTracker.getInstance(phoneId).start(phone);
}
@@ -457,6 +463,10 @@
@VideoState int videoState = conn.getVideoState();
VoiceCallSession proto = new VoiceCallSession();
+ if (mFlags.vonrEnabledMetric()) {
+ mVonrHelper.updateVonrEnabledState();
+ }
+
proto.bearerAtStart = bearer;
proto.bearerAtEnd = bearer;
proto.direction = getDirection(conn);
@@ -556,6 +566,10 @@
// Set device fold state
proto.foldState = mDeviceStateHelper.getFoldState();
+ if (mFlags.vonrEnabledMetric()) {
+ proto.vonrEnabled = mVonrHelper.getVonrEnabled(mPhone.getSubId());
+ }
+
mAtomsStorage.addVoiceCallSession(proto);
// merge RAT usages to PersistPullers when the call session ends (i.e. no more active calls)
diff --git a/src/java/com/android/internal/telephony/metrics/VonrHelper.java b/src/java/com/android/internal/telephony/metrics/VonrHelper.java
new file mode 100644
index 0000000..8f14a86
--- /dev/null
+++ b/src/java/com/android/internal/telephony/metrics/VonrHelper.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony.metrics;
+
+import static com.android.internal.telephony.metrics.MetricsCollector.getPhonesIfAny;
+import static com.android.internal.telephony.metrics.PerSimStatus.isVonrEnabled;
+
+import android.annotation.NonNull;
+import android.os.Handler;
+import android.os.HandlerThread;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.telephony.Phone;
+import com.android.internal.telephony.flags.FeatureFlags;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Vonr state handler.
+ *
+ * <p>This class is instantiated in {@link MetricsCollector}.
+*/
+public class VonrHelper {
+ private final @NonNull FeatureFlags mFlags;
+
+ private Handler mHandler;
+ private Map<Integer, Boolean> mPhoneVonrState = new ConcurrentHashMap<>();
+
+ public VonrHelper(@NonNull FeatureFlags featureFlags) {
+ this.mFlags = featureFlags;
+ if (mFlags.vonrEnabledMetric()) {
+ HandlerThread mHandlerThread = new HandlerThread("VonrHelperThread");
+ mHandlerThread.start();
+ mHandler = new Handler(mHandlerThread.getLooper());
+ }
+ }
+
+ /** Update vonr_enabled state */
+ public void updateVonrEnabledState() {
+ if (mFlags.vonrEnabledMetric()) {
+ mHandler.post(mVonrRunnable);
+ }
+ }
+
+ @VisibleForTesting
+ protected Runnable mVonrRunnable =
+ new Runnable() {
+ @Override
+ public void run() {
+ mPhoneVonrState.clear();
+ for (Phone phone : getPhonesIfAny()) {
+ mPhoneVonrState.put(phone.getSubId(), isVonrEnabled(phone));
+ }
+ }
+ };
+
+ /** Get vonr_enabled per subId */
+ public boolean getVonrEnabled(int subId) {
+ if (mFlags.vonrEnabledMetric()) {
+ return mPhoneVonrState.getOrDefault(subId, false);
+ } else {
+ return false;
+ }
+ }
+}
diff --git a/src/java/com/android/internal/telephony/nitz/TEST_MAPPING b/src/java/com/android/internal/telephony/nitz/TEST_MAPPING
index 2bcb04e..4063803 100644
--- a/src/java/com/android/internal/telephony/nitz/TEST_MAPPING
+++ b/src/java/com/android/internal/telephony/nitz/TEST_MAPPING
@@ -1,6 +1,5 @@
{
- // TODO(b/182461754): Change to "presubmit" when go/test-mapping-slo-guide allows.
- "postsubmit": [
+ "presubmit": [
{
"name": "FrameworksTelephonyTests",
"options": [
diff --git a/src/java/com/android/internal/telephony/satellite/SatelliteController.java b/src/java/com/android/internal/telephony/satellite/SatelliteController.java
index b29cf26..b4ce9c7 100644
--- a/src/java/com/android/internal/telephony/satellite/SatelliteController.java
+++ b/src/java/com/android/internal/telephony/satellite/SatelliteController.java
@@ -56,6 +56,7 @@
import android.os.PersistableBundle;
import android.os.RemoteException;
import android.os.ResultReceiver;
+import android.os.ServiceSpecificException;
import android.os.SystemClock;
import android.os.SystemProperties;
import android.provider.Settings;
@@ -2005,23 +2006,29 @@
}
/**
- * Registers for NTN signal strength changed from satellite modem.
+ * Registers for NTN signal strength changed from satellite modem. If the registration operation
+ * is not successful, a {@link ServiceSpecificException} that contains
+ * {@link SatelliteManager.SatelliteResult} will be thrown.
*
* @param subId The id of the subscription to request for.
- * @param callback The callback to handle the non-terrestrial network signal strength changed
- * event.
+ * @param callback The callback to handle the NTN signal strength changed event. If the
+ * operation is successful, {@link INtnSignalStrengthCallback#onNtnSignalStrengthChanged(
+ * NtnSignalStrength)} will return an instance of {@link NtnSignalStrength} with a value of
+ * {@link NtnSignalStrength.NtnSignalStrengthLevel} when the signal strength of non-terrestrial
+ * network has changed.
*
- * @return The {@link SatelliteManager.SatelliteResult} result of the operation.
+ * @throws ServiceSpecificException If the callback registration operation fails.
*/
- @SatelliteManager.SatelliteResult public int registerForNtnSignalStrengthChanged(
- int subId, @NonNull INtnSignalStrengthCallback callback) {
+ public void registerForNtnSignalStrengthChanged(int subId,
+ @NonNull INtnSignalStrengthCallback callback) throws RemoteException {
if (DBG) logd("registerForNtnSignalStrengthChanged()");
int error = evaluateOemSatelliteRequestAllowed(true);
- if (error != SATELLITE_RESULT_SUCCESS) return error;
-
- mNtnSignalStrengthChangedListeners.put(callback.asBinder(), callback);
- return SATELLITE_RESULT_SUCCESS;
+ if (error == SATELLITE_RESULT_SUCCESS) {
+ mNtnSignalStrengthChangedListeners.put(callback.asBinder(), callback);
+ } else {
+ throw new ServiceSpecificException(error);
+ }
}
/**
diff --git a/src/java/com/android/internal/telephony/security/CellularIdentifierDisclosureNotifier.java b/src/java/com/android/internal/telephony/security/CellularIdentifierDisclosureNotifier.java
index 46e6a28..f1845c5 100644
--- a/src/java/com/android/internal/telephony/security/CellularIdentifierDisclosureNotifier.java
+++ b/src/java/com/android/internal/telephony/security/CellularIdentifierDisclosureNotifier.java
@@ -34,6 +34,7 @@
private static final String TAG = "CellularIdentifierDisclosureNotifier";
private static CellularIdentifierDisclosureNotifier sInstance = null;
+ private boolean mEnabled = false;
@VisibleForTesting
public CellularIdentifierDisclosureNotifier() {}
@@ -59,4 +60,27 @@
return sInstance;
}
+
+ /**
+ * Re-enable if previously disabled. This means that {@code addDisclsoure} will start tracking
+ * disclosures again and potentially emitting notifications.
+ */
+ public void enable() {
+ Rlog.d(TAG, "enabled");
+ mEnabled = true;
+ }
+
+ /**
+ * Clear all internal state and prevent further notifications until optionally re-enabled.
+ * This can be used to in response to a user disabling the feature to emit notifications.
+ * If {@code addDisclosure} is called while in a disabled state, disclosures will be dropped.
+ */
+ public void disable() {
+ Rlog.d(TAG, "disabled");
+ mEnabled = false;
+ }
+
+ public boolean isEnabled() {
+ return mEnabled;
+ }
}
diff --git a/src/java/com/android/internal/telephony/uicc/UiccPort.java b/src/java/com/android/internal/telephony/uicc/UiccPort.java
index d89eab1..fd8f1c4 100644
--- a/src/java/com/android/internal/telephony/uicc/UiccPort.java
+++ b/src/java/com/android/internal/telephony/uicc/UiccPort.java
@@ -29,6 +29,8 @@
import com.android.internal.telephony.CommandsInterface;
import com.android.internal.telephony.IccLogicalChannelRequest;
import com.android.internal.telephony.TelephonyComponentFactory;
+import com.android.internal.telephony.flags.FeatureFlags;
+import com.android.internal.telephony.flags.FeatureFlagsImpl;
import com.android.telephony.Rlog;
import java.io.FileDescriptor;
@@ -39,6 +41,7 @@
public class UiccPort {
protected static final String LOG_TAG = "UiccPort";
protected static final boolean DBG = true;
+ private static @NonNull FeatureFlags sFlags = new FeatureFlagsImpl();
// The lock object is created by UiccSlot that owns this UiccCard - this is to share the lock
// between UiccSlot, UiccCard, EuiccCard, UiccPort, EuiccPort and UiccProfile for now.
@@ -80,7 +83,7 @@
if (mUiccProfile == null) {
mUiccProfile = TelephonyComponentFactory.getInstance()
.inject(UiccProfile.class.getName()).makeUiccProfile(
- mContext, mCi, ics, mPhoneId, uiccCard, mLock);
+ mContext, mCi, ics, mPhoneId, uiccCard, mLock, sFlags);
} else {
mUiccProfile.update(mContext, mCi, ics);
}
diff --git a/src/java/com/android/internal/telephony/uicc/UiccProfile.java b/src/java/com/android/internal/telephony/uicc/UiccProfile.java
index 83db022..0457971 100644
--- a/src/java/com/android/internal/telephony/uicc/UiccProfile.java
+++ b/src/java/com/android/internal/telephony/uicc/UiccProfile.java
@@ -20,6 +20,7 @@
import static com.android.internal.telephony.TelephonyStatsLog.PIN_STORAGE_EVENT__EVENT__PIN_VERIFICATION_FAILURE;
import static com.android.internal.telephony.TelephonyStatsLog.PIN_STORAGE_EVENT__EVENT__PIN_VERIFICATION_SUCCESS;
+import android.annotation.NonNull;
import android.annotation.Nullable;
import android.app.ActivityManager;
import android.app.usage.UsageStatsManager;
@@ -65,6 +66,7 @@
import com.android.internal.telephony.PhoneFactory;
import com.android.internal.telephony.TelephonyStatsLog;
import com.android.internal.telephony.cat.CatService;
+import com.android.internal.telephony.flags.FeatureFlags;
import com.android.internal.telephony.subscription.SubscriptionInfoInternal;
import com.android.internal.telephony.subscription.SubscriptionManagerService;
import com.android.internal.telephony.uicc.IccCardApplicationStatus.AppType;
@@ -103,6 +105,7 @@
private static final String OPERATOR_BRAND_OVERRIDE_PREFIX = "operator_branding_";
+ private final @NonNull FeatureFlags mFlags;
// The lock object is created by UiccSlot that owns the UiccCard that owns this UiccProfile.
// This is to share the lock between UiccSlot, UiccCard and UiccProfile for now.
private final Object mLock;
@@ -326,8 +329,9 @@
};
public UiccProfile(Context c, CommandsInterface ci, IccCardStatus ics, int phoneId,
- UiccCard uiccCard, Object lock) {
+ UiccCard uiccCard, Object lock, @NonNull FeatureFlags flags) {
if (DBG) log("Creating profile");
+ mFlags = flags;
mLock = lock;
mUiccCard = uiccCard;
mPhoneId = phoneId;
diff --git a/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaCallTrackerTest.java b/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaCallTrackerTest.java
index 2fdff9e..369980c 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaCallTrackerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaCallTrackerTest.java
@@ -41,7 +41,6 @@
import androidx.test.filters.FlakyTest;
import com.android.internal.telephony.PhoneInternalInterface.DialArgs;
-import com.android.internal.telephony.domainselection.DomainSelectionResolver;
import org.junit.After;
import org.junit.Assert;
@@ -67,16 +66,12 @@
// Mocked classes
private GsmCdmaConnection mConnection;
private Handler mHandler;
- private DomainSelectionResolver mDomainSelectionResolver;
@Before
public void setUp() throws Exception {
super.setUp(getClass().getSimpleName());
mConnection = mock(GsmCdmaConnection.class);
mHandler = mock(Handler.class);
- mDomainSelectionResolver = mock(DomainSelectionResolver.class);
- doReturn(false).when(mDomainSelectionResolver).isDomainSelectionSupported();
- DomainSelectionResolver.setDomainSelectionResolver(mDomainSelectionResolver);
mSimulatedCommands.setRadioPower(true, null);
mPhone.mCi = this.mSimulatedCommands;
@@ -91,7 +86,6 @@
@After
public void tearDown() throws Exception {
mCTUT = null;
- DomainSelectionResolver.setDomainSelectionResolver(null);
super.tearDown();
}
diff --git a/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaPhoneTest.java b/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaPhoneTest.java
index 34087b6..935da5a 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaPhoneTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaPhoneTest.java
@@ -21,6 +21,7 @@
import static com.android.internal.telephony.Phone.EVENT_ICC_CHANGED;
import static com.android.internal.telephony.Phone.EVENT_IMS_DEREGISTRATION_TRIGGERED;
import static com.android.internal.telephony.Phone.EVENT_RADIO_AVAILABLE;
+import static com.android.internal.telephony.Phone.EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE;
import static com.android.internal.telephony.Phone.EVENT_SET_NULL_CIPHER_AND_INTEGRITY_DONE;
import static com.android.internal.telephony.Phone.EVENT_SRVCC_STATE_CHANGED;
import static com.android.internal.telephony.Phone.EVENT_UICC_APPS_ENABLEMENT_STATUS_CHANGED;
@@ -132,7 +133,6 @@
private UiccSlot mUiccSlot;
private CommandsInterface mMockCi;
private AdnRecordCache adnRecordCache;
- private DomainSelectionResolver mDomainSelectionResolver;
//mPhoneUnderTest
private GsmCdmaPhone mPhoneUT;
@@ -173,13 +173,10 @@
mUiccPort = Mockito.mock(UiccPort.class);
mMockCi = Mockito.mock(CommandsInterface.class);
adnRecordCache = Mockito.mock(AdnRecordCache.class);
- mDomainSelectionResolver = Mockito.mock(DomainSelectionResolver.class);
mFeatureFlags = Mockito.mock(FeatureFlags.class);
doReturn(false).when(mSST).isDeviceShuttingDown();
doReturn(true).when(mImsManager).isVolteEnabledByPlatform();
- doReturn(false).when(mDomainSelectionResolver).isDomainSelectionSupported();
- DomainSelectionResolver.setDomainSelectionResolver(mDomainSelectionResolver);
mPhoneUT = new GsmCdmaPhone(mContext, mSimulatedCommands, mNotifier, true, 0,
PhoneConstants.PHONE_TYPE_GSM, mTelephonyComponentFactory, (c, p) -> mImsManager,
@@ -198,7 +195,6 @@
public void tearDown() throws Exception {
mPhoneUT.removeCallbacksAndMessages(null);
mPhoneUT = null;
- DomainSelectionResolver.setDomainSelectionResolver(null);
try {
DeviceConfig.setProperties(mPreTestProperties);
} catch (DeviceConfig.BadConfigException e) {
@@ -2863,4 +2859,82 @@
verify(mIdentifierDisclosureNotifier, never())
.addDisclosure(any(CellularIdentifierDisclosure.class));
}
+
+ @Test
+ public void testCellularIdentifierDisclosure_noModemCallOnRadioAvailable_FlagOff() {
+ when(mFeatureFlags.enableIdentifierDisclosureTransparency()).thenReturn(false);
+ GsmCdmaPhone phoneUT = makeNewPhoneUT();
+ assertFalse(phoneUT.isIdentifierDisclosureTransparencySupported());
+
+ sendRadioAvailableToPhone(phoneUT);
+
+ verify(mMockCi, never()).setCellularIdentifierTransparencyEnabled(anyBoolean(),
+ any(Message.class));
+ assertFalse(phoneUT.isIdentifierDisclosureTransparencySupported());
+ }
+
+ @Test
+ public void testCellularIdentifierDisclosure_unsupportedByModemOnRadioAvailable() {
+ when(mFeatureFlags.enableIdentifierDisclosureTransparency()).thenReturn(true);
+ GsmCdmaPhone phoneUT = makeNewPhoneUT();
+ assertFalse(phoneUT.isIdentifierDisclosureTransparencySupported());
+
+ // The following block emulates incoming messages from the modem in the case that
+ // the modem does not support the new HAL APIs. We expect the phone instance to attempt
+ // to set cipher-identifier-transparency-enabled state when the radio becomes available.
+ sendRadioAvailableToPhone(phoneUT);
+ verify(mMockCi, times(1)).setCellularIdentifierTransparencyEnabled(anyBoolean(),
+ any(Message.class));
+ sendRequestNotSupportedToPhone(phoneUT, EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE);
+
+ assertFalse(phoneUT.isIdentifierDisclosureTransparencySupported());
+ }
+
+ @Test
+ public void testCellularIdentifierDisclosure_supportedByModem() {
+ when(mFeatureFlags.enableIdentifierDisclosureTransparency()).thenReturn(true);
+ GsmCdmaPhone phoneUT = makeNewPhoneUT();
+ assertFalse(phoneUT.isIdentifierDisclosureTransparencySupported());
+
+ // The following block emulates incoming messages from the modem in the case that
+ // the modem supports the new HAL APIs. We expect the phone instance to attempt
+ // to set cipher-identifier-transparency-enabled state when the radio becomes available.
+ sendRadioAvailableToPhone(phoneUT);
+ verify(mMockCi, times(1)).setCellularIdentifierTransparencyEnabled(anyBoolean(),
+ any(Message.class));
+ sendIdentifierDisclosureEnabledSuccessToPhone(phoneUT);
+
+ assertTrue(phoneUT.isIdentifierDisclosureTransparencySupported());
+ }
+
+ private void sendRadioAvailableToPhone(GsmCdmaPhone phone) {
+ phone.sendMessage(phone.obtainMessage(EVENT_RADIO_AVAILABLE,
+ new AsyncResult(null, new int[]{ServiceState.RIL_RADIO_TECHNOLOGY_GSM}, null)));
+ processAllMessages();
+ }
+
+ private void sendRequestNotSupportedToPhone(GsmCdmaPhone phone, int eventId) {
+ phone.sendMessage(phone.obtainMessage(eventId, new AsyncResult(null, null,
+ new CommandException(CommandException.Error.REQUEST_NOT_SUPPORTED))));
+ processAllMessages();
+ }
+
+ private void sendIdentifierDisclosureEnabledSuccessToPhone(GsmCdmaPhone phone) {
+ phone.sendMessage(phone.obtainMessage(EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE,
+ new AsyncResult(null, null, null)));
+ processAllMessages();
+ }
+
+ private GsmCdmaPhone makeNewPhoneUT() {
+ return new GsmCdmaPhone(
+ mContext,
+ mMockCi,
+ mNotifier,
+ true,
+ 0,
+ PhoneConstants.PHONE_TYPE_GSM,
+ mTelephonyComponentFactory,
+ (c, p) -> mImsManager,
+ mFeatureFlags);
+ }
}
diff --git a/tests/telephonytests/src/com/android/internal/telephony/PhoneConfigurationManagerTest.java b/tests/telephonytests/src/com/android/internal/telephony/PhoneConfigurationManagerTest.java
index 4f2d8db..ea4705c 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/PhoneConfigurationManagerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/PhoneConfigurationManagerTest.java
@@ -20,6 +20,7 @@
import static android.telephony.TelephonyManager.EXTRA_ACTIVE_SIM_SUPPORTED_COUNT;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt;
@@ -42,6 +43,7 @@
import android.test.suitebuilder.annotation.SmallTest;
import android.testing.AndroidTestingRunner;
import android.testing.TestableLooper;
+import android.util.Log;
import com.android.internal.telephony.flags.FeatureFlags;
@@ -52,6 +54,9 @@
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
+import java.util.ArrayList;
+import java.util.HashSet;
+
@RunWith(AndroidTestingRunner.class)
@TestableLooper.RunWithLooper
public class PhoneConfigurationManagerTest extends TelephonyTest {
@@ -78,6 +83,7 @@
mPhone.mCi = mMockCi0;
mCT.mCi = mMockCi0;
mPhone1.mCi = mMockCi1;
+ doReturn(RIL.RADIO_HAL_VERSION_2_1).when(mMockRadioConfigProxy).getVersion();
}
@After
@@ -163,6 +169,45 @@
@Test
@SmallTest
+ public void testUpdateSimultaneousCallingSupport() throws Exception {
+ init(2);
+ mPcm.updateSimultaneousCallingSupport();
+
+ int[] enabledLogicalSlots = {0, 1};
+ ArgumentCaptor<Message> captor = ArgumentCaptor.forClass(Message.class);
+ verify(mMockRadioConfig).updateSimultaneousCallingSupport(captor.capture());
+ Message msg = captor.getValue();
+ AsyncResult.forMessage(msg, enabledLogicalSlots, null);
+ msg.sendToTarget();
+ processAllMessages();
+
+ HashSet<Integer> expectedSlots = new HashSet<>();
+ for (int i : enabledLogicalSlots) { expectedSlots.add(i); }
+ assertEquals(expectedSlots, mPcm.getSlotsSupportingSimultaneousCellularCalls());
+ }
+
+ @Test
+ @SmallTest
+ public void testUpdateSimultaneousCallingSupport_invalidResponse_shouldFail() throws Exception {
+ init(2);
+ mPcm.updateSimultaneousCallingSupport();
+
+ // Have the modem send invalid phone slots -1 and 5:
+ int[] invalidEnabledLogicalSlots = {-1, 5};
+ ArgumentCaptor<Message> captor = ArgumentCaptor.forClass(Message.class);
+ verify(mMockRadioConfig).updateSimultaneousCallingSupport(captor.capture());
+ Message msg = captor.getValue();
+ AsyncResult.forMessage(msg, invalidEnabledLogicalSlots, null);
+ msg.sendToTarget();
+ processAllMessages();
+
+ // We would expect to DSDA to be disabled and mSlotsSupportingSimultaneousCellularCalls to
+ // have been cleared:
+ assertTrue(mPcm.getSlotsSupportingSimultaneousCellularCalls().isEmpty());
+ }
+
+ @Test
+ @SmallTest
public void testSwitchMultiSimConfig_notDsdsCapable_shouldFail() throws Exception {
init(1);
assertEquals(PhoneCapability.DEFAULT_SSSS_CAPABILITY, mPcm.getStaticPhoneCapability());
diff --git a/tests/telephonytests/src/com/android/internal/telephony/ProxyControllerTest.java b/tests/telephonytests/src/com/android/internal/telephony/ProxyControllerTest.java
index 65ab664..180a5e7 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/ProxyControllerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/ProxyControllerTest.java
@@ -55,7 +55,7 @@
public void setUp() throws Exception {
super.setUp(getClass().getSimpleName());
replaceInstance(ProxyController.class, "sProxyController", null, null);
- mProxyController = ProxyController.getInstance(mContext);
+ mProxyController = new ProxyController(mContext, mFeatureFlags);
}
@After
diff --git a/tests/telephonytests/src/com/android/internal/telephony/ServiceStateTrackerTest.java b/tests/telephonytests/src/com/android/internal/telephony/ServiceStateTrackerTest.java
index 9e067a2..c542857 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/ServiceStateTrackerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/ServiceStateTrackerTest.java
@@ -99,6 +99,7 @@
import com.android.internal.telephony.cdma.CdmaSubscriptionSourceManager;
import com.android.internal.telephony.data.AccessNetworksManager;
import com.android.internal.telephony.data.DataNetworkController;
+import com.android.internal.telephony.emergency.EmergencyStateTracker;
import com.android.internal.telephony.metrics.ServiceStateStats;
import com.android.internal.telephony.satellite.SatelliteController;
import com.android.internal.telephony.subscription.SubscriptionInfoInternal;
@@ -145,6 +146,7 @@
private ServiceStateTrackerTestHandler mSSTTestHandler;
private PersistableBundle mBundle;
private SatelliteController mSatelliteController;
+ private EmergencyStateTracker mEmergencyStateTracker;
private static final int EVENT_REGISTERED_TO_NETWORK = 1;
private static final int EVENT_SUBSCRIPTION_INFO_READY = 2;
@@ -390,6 +392,9 @@
sendCarrierConfigUpdate(PHONE_ID);
waitForLastHandlerAction(mSSTTestHandler.getThreadHandler());
+ mEmergencyStateTracker = Mockito.mock(EmergencyStateTracker.class);
+ replaceInstance(EmergencyStateTracker.class, "INSTANCE", null, mEmergencyStateTracker);
+
logd("ServiceStateTrackerTest -Setup!");
}
@@ -480,6 +485,66 @@
waitForLastHandlerAction(mSSTTestHandler.getThreadHandler());
verify(mDataNetworkController, times(1)).unregisterDataNetworkControllerCallback(any());
assertEquals(TelephonyManager.RADIO_POWER_OFF, mSimulatedCommands.getRadioState());
+ verify(mEmergencyStateTracker, never()).onCellularRadioPowerOffRequested();
+ }
+
+ @Test
+ public void testSetRadioPowerExitEmergencyMode() throws Exception {
+ doReturn(true).when(mDomainSelectionResolver).isDomainSelectionSupported();
+
+ // Set up DSDS environment
+ GsmCdmaPhone phone2 = Mockito.mock(GsmCdmaPhone.class);
+ DataNetworkController dataNetworkController_phone2 =
+ Mockito.mock(DataNetworkController.class);
+ mPhones = new Phone[] {mPhone, phone2};
+ replaceInstance(PhoneFactory.class, "sPhones", null, mPhones);
+ doReturn(dataNetworkController_phone2).when(phone2).getDataNetworkController();
+ doReturn(mSST).when(phone2).getServiceStateTracker();
+ doReturn(false).when(mDataNetworkController).areAllDataDisconnected();
+ doReturn(false).when(dataNetworkController_phone2).areAllDataDisconnected();
+ doReturn(1).when(mPhone).getSubId();
+ doReturn(2).when(phone2).getSubId();
+
+ // Start with radio on
+ sst.setRadioPower(true);
+ waitForLastHandlerAction(mSSTTestHandler.getThreadHandler());
+ assertEquals(TelephonyManager.RADIO_POWER_ON, mSimulatedCommands.getRadioState());
+
+ // Turn on APM
+ sst.setRadioPower(false);
+ waitForLastHandlerAction(mSSTTestHandler.getThreadHandler());
+ assertEquals(TelephonyManager.RADIO_POWER_ON, mSimulatedCommands.getRadioState());
+
+ // Verify checking emergency mode
+ verify(mEmergencyStateTracker).onCellularRadioPowerOffRequested();
+
+ // Verify that both subs are waiting for all data disconnected
+ verify(mDataNetworkController).tearDownAllDataNetworks(
+ eq(3 /* TEAR_DOWN_REASON_AIRPLANE_MODE_ON */));
+ verify(dataNetworkController_phone2, never()).tearDownAllDataNetworks(anyInt());
+ ArgumentCaptor<DataNetworkController.DataNetworkControllerCallback> callback1 =
+ ArgumentCaptor.forClass(DataNetworkController.DataNetworkControllerCallback.class);
+ ArgumentCaptor<DataNetworkController.DataNetworkControllerCallback> callback2 =
+ ArgumentCaptor.forClass(DataNetworkController.DataNetworkControllerCallback.class);
+ verify(mDataNetworkController, times(1)).registerDataNetworkControllerCallback(
+ callback1.capture());
+ verify(dataNetworkController_phone2, times(1)).registerDataNetworkControllerCallback(
+ callback2.capture());
+
+ // Data disconnected on sub 2, still waiting for data disconnected on sub 1
+ doReturn(true).when(dataNetworkController_phone2).areAllDataDisconnected();
+ callback2.getValue().onAnyDataNetworkExistingChanged(false);
+ waitForLastHandlerAction(mSSTTestHandler.getThreadHandler());
+ assertEquals(TelephonyManager.RADIO_POWER_ON, mSimulatedCommands.getRadioState());
+ verify(dataNetworkController_phone2, times(1)).unregisterDataNetworkControllerCallback(
+ any());
+
+ // Data disconnected on sub 1, radio should power off now
+ doReturn(true).when(mDataNetworkController).areAllDataDisconnected();
+ callback1.getValue().onAnyDataNetworkExistingChanged(false);
+ waitForLastHandlerAction(mSSTTestHandler.getThreadHandler());
+ verify(mDataNetworkController, times(1)).unregisterDataNetworkControllerCallback(any());
+ assertEquals(TelephonyManager.RADIO_POWER_OFF, mSimulatedCommands.getRadioState());
}
@Test
diff --git a/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthControllerTest.java b/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthControllerTest.java
index 98980a1..fa89082 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthControllerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthControllerTest.java
@@ -16,6 +16,9 @@
package com.android.internal.telephony;
+import static android.telephony.ServiceState.STATE_IN_SERVICE;
+import static android.telephony.ServiceState.STATE_OUT_OF_SERVICE;
+import static android.telephony.ServiceState.STATE_POWER_OFF;
import static android.telephony.SignalThresholdInfo.SIGNAL_MEASUREMENT_TYPE_RSRP;
import static android.telephony.SignalThresholdInfo.SIGNAL_MEASUREMENT_TYPE_RSSI;
import static android.telephony.SignalThresholdInfo.SIGNAL_MEASUREMENT_TYPE_SSRSRP;
@@ -27,14 +30,19 @@
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.content.Context;
+import android.os.AsyncResult;
import android.os.Handler;
import android.os.Message;
import android.os.PersistableBundle;
@@ -1269,6 +1277,238 @@
sendCarrierConfigUpdate();
}
+ @Test
+ public void testInvalidCarrierConfig_NTN_LTE_RSRP_thresholdIsTooSmall() {
+ // 4 threshold integers must be within the boundaries [-140, -44]
+ mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSRP_THRESHOLDS_INT_ARRAY,
+ new int[]{
+ -141, /* SIGNAL_STRENGTH_POOR */
+ -118, /* SIGNAL_STRENGTH_MODERATE */
+ -108, /* SIGNAL_STRENGTH_GOOD */
+ -98 /* SIGNAL_STRENGTH_GREAT */
+ });
+ sendCarrierConfigUpdate();
+ }
+
+
+ @Test
+ public void testInvalidCarrierConfig_NTN_LTE_RSRP_thresholdIsTooLarge() {
+ // 4 threshold integers must be within the boundaries [-140, -44]
+ mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSRQ_THRESHOLDS_INT_ARRAY,
+ new int[]{
+ -128, /* SIGNAL_STRENGTH_POOR */
+ -118, /* SIGNAL_STRENGTH_MODERATE */
+ -108, /* SIGNAL_STRENGTH_GOOD */
+ -43, /* SIGNAL_STRENGTH_GREAT */
+ });
+ sendCarrierConfigUpdate();
+ }
+
+ @Test
+ public void testInvalidCarrierConfig_NTN_LTE_RSRQ_thresholdIsTooSmall() {
+ // 4 threshold integers must be within the boundaries [-34, 3]
+ mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSRQ_THRESHOLDS_INT_ARRAY,
+ new int[]{
+ -35, /* SIGNAL_STRENGTH_POOR */
+ -17, /* SIGNAL_STRENGTH_MODERATE */
+ -14, /* SIGNAL_STRENGTH_GOOD */
+ -11 /* SIGNAL_STRENGTH_GREAT */
+ });
+ sendCarrierConfigUpdate();
+ }
+
+
+ @Test
+ public void testInvalidCarrierConfig_NTN_LTE_RSRQ_thresholdIsTooLarge() {
+ // 4 threshold integers must be within the boundaries [-34, 3]
+ mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSRQ_THRESHOLDS_INT_ARRAY,
+ new int[]{
+ -20, /* SIGNAL_STRENGTH_POOR */
+ -17, /* SIGNAL_STRENGTH_MODERATE */
+ -14, /* SIGNAL_STRENGTH_GOOD */
+ 4 /* SIGNAL_STRENGTH_GREAT */
+ });
+ sendCarrierConfigUpdate();
+ }
+
+ @Test
+ public void testInvalidCarrierConfig_NTN_LTE_RSSNR_thresholdIsTooSmall() {
+ // 4 threshold integers must be within the boundaries [-20, 30]
+ mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSSNR_THRESHOLDS_INT_ARRAY,
+ new int[]{
+ -21, /* SIGNAL_STRENGTH_POOR */
+ 1, /* SIGNAL_STRENGTH_MODERATE */
+ 5, /* SIGNAL_STRENGTH_GOOD */
+ 13 /* SIGNAL_STRENGTH_GREAT */
+ });
+ sendCarrierConfigUpdate();
+ }
+
+ @Test
+ public void testInvalidCarrierConfig_NTN_LTE_RSSNR_thresholdIsTooLarge() {
+ // 4 threshold integers must be within the boundaries [-20, 30]
+ mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSSNR_THRESHOLDS_INT_ARRAY,
+ new int[]{
+ -3, /* SIGNAL_STRENGTH_POOR */
+ 1, /* SIGNAL_STRENGTH_MODERATE */
+ 5, /* SIGNAL_STRENGTH_GOOD */
+ 31 /* SIGNAL_STRENGTH_GREAT */
+ });
+ sendCarrierConfigUpdate();
+ }
+
+ @Test
+ public void testLteSignalStrengthReportingCriteriaWhenServiceStateChanged() {
+ SignalStrength ss = new SignalStrength(
+ new CellSignalStrengthCdma(),
+ new CellSignalStrengthGsm(),
+ new CellSignalStrengthWcdma(),
+ new CellSignalStrengthTdscdma(),
+ new CellSignalStrengthLte(
+ -110, /* rssi */
+ -114, /* rsrp */
+ -5, /* rsrq */
+ 0, /* rssnr */
+ SignalStrength.INVALID, /* cqi */
+ SignalStrength.INVALID /* ta */),
+ new CellSignalStrengthNr());
+
+ // RSRP NTN_LTE threshold set to Good and LTE threshold set to poor.
+ mBundle.putInt(CarrierConfigManager.KEY_PARAMETERS_USED_FOR_NTN_LTE_SIGNAL_BAR_INT,
+ CellSignalStrengthLte.USE_RSRP);
+ mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSRP_THRESHOLDS_INT_ARRAY,
+ new int[]{-125 /* SIGNAL_STRENGTH_POOR */, -120 /* SIGNAL_STRENGTH_MODERATE */,
+ -115 /* SIGNAL_STRENGTH_GOOD */, -110/* SIGNAL_STRENGTH_GREAT */});
+ mBundle.putIntArray(CarrierConfigManager.KEY_LTE_RSRP_THRESHOLDS_INT_ARRAY,
+ new int[]{-114, /* SIGNAL_STRENGTH_POOR */ -110, /* SIGNAL_STRENGTH_MODERATE */
+ -105, /* SIGNAL_STRENGTH_GOOD */ -100, /* SIGNAL_STRENGTH_GREAT */});
+ CarrierConfigManager mockConfigManager = Mockito.mock(CarrierConfigManager.class);
+ when(mContext.getSystemService(Context.CARRIER_CONFIG_SERVICE))
+ .thenReturn(mockConfigManager);
+ when(mockConfigManager.getConfigForSubId(anyInt())).thenReturn(mBundle);
+
+ // When NTN is connected, check the signal strength is GOOD
+ AsyncResult asyncResult = mock(AsyncResult.class);
+ asyncResult.result = mServiceState;
+ doReturn(true).when(mServiceState).isUsingNonTerrestrialNetwork();
+ mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+ processAllMessages();
+
+ mSimulatedCommands.setSignalStrength(ss);
+ mSimulatedCommands.notifySignalStrength();
+ processAllMessages();
+ assertEquals(CellSignalStrength.SIGNAL_STRENGTH_GOOD, mSsc.getSignalStrength().getLevel());
+
+ // When TN connected, check the signal strength is POOR
+ doReturn(false).when(mServiceState).isUsingNonTerrestrialNetwork();
+ mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+ processAllMessages();
+
+ mSimulatedCommands.setSignalStrength(ss);
+ mSimulatedCommands.notifySignalStrength();
+ processAllMessages();
+ assertEquals(CellSignalStrength.SIGNAL_STRENGTH_POOR, mSsc.getSignalStrength().getLevel());
+
+ // RSRP NTN_LTE threshold set to Moderate and LTE threshold set to poor.
+ // When TN connected, check the signal strength is POOR.
+ mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSRP_THRESHOLDS_INT_ARRAY,
+ new int[]{-130 /* SIGNAL_STRENGTH_POOR */, -120 /* SIGNAL_STRENGTH_MODERATE */,
+ -110 /* SIGNAL_STRENGTH_GOOD */, -100/* SIGNAL_STRENGTH_GREAT */});
+ mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+ processAllMessages();
+
+ mSimulatedCommands.setSignalStrength(ss);
+ mSimulatedCommands.notifySignalStrength();
+ processAllMessages();
+ assertEquals(CellSignalStrength.SIGNAL_STRENGTH_POOR, mSsc.getSignalStrength().getLevel());
+
+ // Service State Changed with OUT_OF_SERVICE, then no update
+ // SignalStrengthReportingCriteria.
+ reset(mSimulatedCommandsVerifier);
+ doReturn(STATE_OUT_OF_SERVICE).when(mServiceState).getState();
+ mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+ processAllMessages();
+
+ mSimulatedCommands.setSignalStrength(ss);
+ mSimulatedCommands.notifySignalStrength();
+ processAllMessages();
+ assertEquals(CellSignalStrength.SIGNAL_STRENGTH_POOR, mSsc.getSignalStrength().getLevel());
+ verify(mSimulatedCommandsVerifier, never()).setSignalStrengthReportingCriteria(anyList(),
+ isNull());
+
+ // Service State Changed with POWER_OFF, then no update SignalStrengthReportingCriteria.
+ reset(mSimulatedCommandsVerifier);
+ doReturn(STATE_POWER_OFF).when(mServiceState).getState();
+ mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+ processAllMessages();
+
+ mSimulatedCommands.setSignalStrength(ss);
+ mSimulatedCommands.notifySignalStrength();
+ processAllMessages();
+ assertEquals(CellSignalStrength.SIGNAL_STRENGTH_POOR, mSsc.getSignalStrength().getLevel());
+ verify(mSimulatedCommandsVerifier, never()).setSignalStrengthReportingCriteria(anyList(),
+ isNull());
+
+ // Service State Changed with IN_SERVICE, then update SignalStrengthReportingCriteria.
+ // When NTN is connected, check the signal strength is MODERATE
+ reset(mSimulatedCommandsVerifier);
+ doReturn(true).when(mServiceState).isUsingNonTerrestrialNetwork();
+ doReturn(STATE_IN_SERVICE).when(mServiceState).getState();
+ mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+ processAllMessages();
+
+ mSimulatedCommands.setSignalStrength(ss);
+ mSimulatedCommands.notifySignalStrength();
+ processAllMessages();
+ assertEquals(CellSignalStrength.SIGNAL_STRENGTH_MODERATE,
+ mSsc.getSignalStrength().getLevel());
+ verify(mSimulatedCommandsVerifier).setSignalStrengthReportingCriteria(anyList(), isNull());
+
+ // Service State Changed with IN_SERVICE and still NTN is connected,
+ // verify not update SignalStrengthReportingCriteria and the signal strength is MODERATE.
+ reset(mSimulatedCommandsVerifier);
+ mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+ processAllMessages();
+
+ mSimulatedCommands.setSignalStrength(ss);
+ mSimulatedCommands.notifySignalStrength();
+ processAllMessages();
+ assertEquals(CellSignalStrength.SIGNAL_STRENGTH_MODERATE,
+ mSsc.getSignalStrength().getLevel());
+ verify(mSimulatedCommandsVerifier, never()).setSignalStrengthReportingCriteria(anyList(),
+ isNull());
+
+ // Service State Changed with IN_SERVICE, then update SignalStrengthReportingCriteria.
+ // When TN is connected, check the signal strength is POOR.
+ reset(mSimulatedCommandsVerifier);
+ doReturn(false).when(mServiceState).isUsingNonTerrestrialNetwork();
+ mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+ processAllMessages();
+
+ mSimulatedCommands.setSignalStrength(ss);
+ mSimulatedCommands.notifySignalStrength();
+ processAllMessages();
+ assertEquals(CellSignalStrength.SIGNAL_STRENGTH_POOR,
+ mSsc.getSignalStrength().getLevel());
+ verify(mSimulatedCommandsVerifier).setSignalStrengthReportingCriteria(anyList(), isNull());
+
+ // Service State Changed with IN_SERVICE and still TN is connected,
+ // verify not update SignalStrengthReportingCriteria and the signal strength is POOR.
+ reset(mSimulatedCommandsVerifier);
+ mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+ processAllMessages();
+
+ mSimulatedCommands.setSignalStrength(ss);
+ mSimulatedCommands.notifySignalStrength();
+ processAllMessages();
+ assertEquals(CellSignalStrength.SIGNAL_STRENGTH_POOR,
+ mSsc.getSignalStrength().getLevel());
+ verify(mSimulatedCommandsVerifier, never()).setSignalStrengthReportingCriteria(anyList(),
+ isNull());
+
+ reset(mSimulatedCommandsVerifier);
+ }
+
private void verifyAllEmptyThresholdAreDisabledWhenSetSignalStrengthReportingCriteria(
int expectedNonEmptyThreshold) {
ArgumentCaptor<List<SignalThresholdInfo>> signalThresholdInfoCaptor =
diff --git a/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthTest.java b/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthTest.java
index 96184c5..8df4052 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthTest.java
@@ -21,6 +21,7 @@
import android.os.Parcel;
import android.os.PersistableBundle;
+import android.platform.test.flag.junit.SetFlagsRule;
import android.telephony.CarrierConfigManager;
import android.telephony.CellInfo;
import android.telephony.CellSignalStrength;
@@ -30,10 +31,16 @@
import android.telephony.CellSignalStrengthNr;
import android.telephony.CellSignalStrengthTdscdma;
import android.telephony.CellSignalStrengthWcdma;
+import android.telephony.NetworkRegistrationInfo;
+import android.telephony.ServiceState;
import android.telephony.SignalStrength;
import androidx.test.filters.SmallTest;
+import com.android.internal.telephony.flags.Flags;
+
+import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -46,6 +53,7 @@
@SmallTest
@RunWith(JUnit4.class)
public class SignalStrengthTest {
+ @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
private static final int[] DEFAULT_LTE_RSRP_THRESHOLDS = {
-128, // SIGNAL_STRENGTH_POOR
-118, // SIGNAL_STRENGTH_MODERATE
@@ -70,6 +78,42 @@
-105, // SIGNAL_STRENGTH_GOOD
-95 }; // SIGNAL_STRENGTH_GREAT
+ private static final int[] DEFAULT_NTN_LTE_RSRP_THRESHOLDS = {
+ -118, // SIGNAL_STRENGTH_POOR
+ -108, // SIGNAL_STRENGTH_MODERATE
+ -98, // SIGNAL_STRENGTH_GOOD
+ -88 }; // SIGNAL_STRENGTH_GREAT
+
+ private static final int[] DEFAULT_NTN_LTE_RSRQ_THRESHOLDS = {
+ -17, // SIGNAL_STRENGTH_POOR
+ -14, // SIGNAL_STRENGTH_MODERATE
+ -12, // SIGNAL_STRENGTH_GOOD
+ -10 }; // SIGNAL_STRENGTH_GREAT
+
+ private static final int[] DEFAULT_NTN_LTE_RSSNR_THRESHOLDS = {
+ 1, // SIGNAL_STRENGTH_POOR
+ 5, // SIGNAL_STRENGTH_MODERATE
+ 13, // SIGNAL_STRENGTH_GOOD
+ 17 }; // SIGNAL_STRENGTH_GREAT
+
+ // RSRP, RSSNR thresholds boundaries
+ private static final int MIN_RSRP = -140;
+ private static final int MIN_RSRQ = -34;
+ private static final int MAX_RSRQ = 3;
+ private static final int MIN_RSSNR = -20;
+ private static final int MAX_RSSNR = 30;
+
+ // Default NTN & TN LTE thresholds's index
+ private static final int INDEX_SIGNAL_STRENGTH_POOR = 0;
+ private static final int INDEX_SIGNAL_STRENGTH_MODERATE = 1;
+ private static final int INDEX_SIGNAL_STRENGTH_GOOD = 2;
+ private static final int INDEX_SIGNAL_STRENGTH_GREAT = 3;
+
+ @Before
+ public void setUp() {
+ mSetFlagsRule.enableFlags(Flags.FLAG_CARRIER_ENABLED_SATELLITE_FLAG);
+ }
+
@Test
public void testDefaults() throws Exception {
SignalStrength s = new SignalStrength();
@@ -229,6 +273,58 @@
return signalStrength;
}
+ private static SignalStrength createSignalStrengthLteReport(int lteRsrp, int lteRsrq,
+ int lteRssnr, boolean isNTN) {
+ CellSignalStrengthLte lte = new CellSignalStrengthLte(
+ -89, // rssi
+ lteRsrp, // rsrp
+ lteRsrq, // rsrq
+ lteRssnr, // rssnr
+ CellInfo.UNAVAILABLE, // cqiTableIndex
+ CellInfo.UNAVAILABLE, // cqi
+ CellInfo.UNAVAILABLE); // timingAdvance
+
+ SignalStrength signalStrength = new SignalStrength(
+ new CellSignalStrengthCdma(),
+ new CellSignalStrengthGsm(),
+ new CellSignalStrengthWcdma(),
+ new CellSignalStrengthTdscdma(),
+ lte,
+ new CellSignalStrengthNr());
+
+ PersistableBundle bundle = new PersistableBundle();
+ bundle.putInt(
+ CarrierConfigManager.KEY_PARAMETERS_USED_FOR_LTE_SIGNAL_BAR_INT,
+ CellSignalStrengthLte.USE_RSRP | CellSignalStrengthLte.USE_RSRQ
+ | CellSignalStrengthLte.USE_RSSNR);
+ bundle.putIntArray(CarrierConfigManager.KEY_LTE_RSRP_THRESHOLDS_INT_ARRAY,
+ DEFAULT_LTE_RSRP_THRESHOLDS);
+ bundle.putIntArray(CarrierConfigManager.KEY_LTE_RSRQ_THRESHOLDS_INT_ARRAY,
+ DEFAULT_LTE_RSRQ_THRESHOLDS);
+ bundle.putIntArray(CarrierConfigManager.KEY_LTE_RSSNR_THRESHOLDS_INT_ARRAY,
+ DEFAULT_LTE_RSSNR_THRESHOLDS);
+ bundle.putInt(
+ CarrierConfigManager.KEY_PARAMETERS_USED_FOR_NTN_LTE_SIGNAL_BAR_INT,
+ CellSignalStrengthLte.USE_RSRP | CellSignalStrengthLte.USE_RSRQ
+ | CellSignalStrengthLte.USE_RSSNR);
+ bundle.putIntArray(
+ CarrierConfigManager.KEY_NTN_LTE_RSRP_THRESHOLDS_INT_ARRAY,
+ DEFAULT_NTN_LTE_RSRP_THRESHOLDS);
+ bundle.putIntArray(
+ CarrierConfigManager.KEY_NTN_LTE_RSRQ_THRESHOLDS_INT_ARRAY,
+ DEFAULT_NTN_LTE_RSRQ_THRESHOLDS);
+ bundle.putIntArray(
+ CarrierConfigManager.KEY_NTN_LTE_RSSNR_THRESHOLDS_INT_ARRAY,
+ DEFAULT_NTN_LTE_RSSNR_THRESHOLDS);
+ ServiceState serviceState = new ServiceState();
+ NetworkRegistrationInfo nri = new NetworkRegistrationInfo.Builder()
+ .setIsNonTerrestrialNetwork(isNTN)
+ .build();
+ serviceState.addNetworkRegistrationInfo(nri);
+ signalStrength.updateLevel(bundle, serviceState);
+ return signalStrength;
+ }
+
@Test
public void testValidateInput() throws Exception {
@@ -265,6 +361,44 @@
// Input value of RSSNR: -21[dB]
ss = createSignalStrengthLteReportRssnr(60, -21);
assertEquals(SignalStrength.INVALID, ss.getLteRssnr());
+
+ // Test for NTN LTE RSRQ Thresholds based on Boundaries [-34 dB, 3 dB]
+ boolean isNTN = true;
+ int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rsrq = MAX_RSRQ + 1;
+ ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+ assertEquals(SignalStrength.INVALID, ss.getLteRsrq());
+
+ rsrq = MAX_RSRQ;
+ ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+ assertEquals(3, ss.getLteRsrq());
+
+ rsrq = MIN_RSRQ - 1;
+ ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+ assertEquals(SignalStrength.INVALID, ss.getLteRsrq());
+
+ rsrq = MIN_RSRQ;
+ ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+ assertEquals(-34, ss.getLteRsrq());
+
+ // Test for NTN LTE RSSNR Thresholds based on Boundaries [-20 dBm, 30 dBm]
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT]; // or 3 ?
+ rssnr = MAX_RSSNR + 1;
+ ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+ assertEquals(SignalStrength.INVALID, ss.getLteRssnr());
+
+ rssnr = MAX_RSSNR;
+ ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+ assertEquals(30, ss.getLteRssnr());
+
+ rssnr = MIN_RSSNR - 1;
+ ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+ assertEquals(SignalStrength.INVALID, ss.getLteRssnr());
+
+ rssnr = MIN_RSSNR;
+ ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+ assertEquals(-20, ss.getLteRssnr());
}
@Test
@@ -279,6 +413,46 @@
createSignalStrengthLteReportRsrq(-98, -14).getLteLevel());
assertEquals(SignalStrength.SIGNAL_STRENGTH_GREAT,
createSignalStrengthLteReportRsrq(-98, -12).getLteLevel());
+
+ // When NTN is connected, check the signal strength
+ boolean isNTN = true;
+ int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rsrq = MIN_RSRQ;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GREAT,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+ // When NTN is disconnected, check the signal strength
+ isNTN = false;
+ rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ rsrq = MIN_RSRQ;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GREAT,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
}
@Test
@@ -293,6 +467,46 @@
createSignalStrengthLteReportRsrq(-108, -14).getLteLevel());
assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
createSignalStrengthLteReportRsrq(-108, -12).getLteLevel());
+
+ // When NTN is connected, check the signal strength
+ boolean isNTN = true;
+ int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ int rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rsrq = MIN_RSRQ;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+ // When NTN is disconnected, check the signal strength
+ isNTN = false;
+ rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ rsrq = MIN_RSRQ;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
}
@Test
@@ -307,6 +521,46 @@
createSignalStrengthLteReportRsrq(-118, -14).getLteLevel());
assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
createSignalStrengthLteReportRsrq(-118, -12).getLteLevel());
+
+ // When NTN is connected, check the signal strength
+ boolean isNTN = true;
+ int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ int rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rsrq = MIN_RSRQ;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+ // When NTN is disconnected, check the signal strength
+ isNTN = false;
+ rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ rsrq = MIN_RSRQ;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
}
@Test
@@ -321,6 +575,46 @@
createSignalStrengthLteReportRsrq(-128, -14).getLteLevel());
assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
createSignalStrengthLteReportRsrq(-128, -12).getLteLevel());
+
+ // When NTN is connected, check the signal strength
+ boolean isNTN = true;
+ int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ int rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rsrq = MIN_RSRQ;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+ // When NTN is disconnected, check the signal strength
+ isNTN = false;
+ rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ rsrq = MIN_RSRQ;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
}
@Test
@@ -335,6 +629,45 @@
createSignalStrengthLteReportRsrq(-138, -14).getLteLevel());
assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
createSignalStrengthLteReportRsrq(-138, -12).getLteLevel());
+
+ // When NTN is connected, check the signal strength
+ boolean isNTN = true;
+ int rsrp = MIN_RSRP;
+ int rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rsrq = MIN_RSRQ;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+ // When NTN is disconnected, check the signal strength
+ isNTN = false;
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ rsrq = MIN_RSRQ;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
}
@Test
@@ -349,6 +682,46 @@
createSignalStrengthLteReportRssnr(-98, 5).getLteLevel());
assertEquals(SignalStrength.SIGNAL_STRENGTH_GREAT,
createSignalStrengthLteReportRssnr(-98, 13).getLteLevel());
+
+ // When NTN is connected, check the signal strength
+ boolean isNTN = true;
+ int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rssnr = MIN_RSSNR;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GREAT,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+ // When NTN is disconnected, check the signal strength
+ isNTN = false;
+ rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ rssnr = MIN_RSSNR;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GREAT,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
}
@Test
@@ -363,6 +736,46 @@
createSignalStrengthLteReportRssnr(-108, 5).getLteLevel());
assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
createSignalStrengthLteReportRssnr(-108, 13).getLteLevel());
+
+ // When NTN is connected, check the signal strength
+ boolean isNTN = true;
+ int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ int rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rssnr = MIN_RSSNR;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+ // When NTN is disconnected, check the signal strength
+ isNTN = false;
+ rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ rssnr = MIN_RSSNR;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
}
@Test
@@ -377,6 +790,46 @@
createSignalStrengthLteReportRssnr(-118, 5).getLteLevel());
assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
createSignalStrengthLteReportRssnr(-118, 13).getLteLevel());
+
+ // When NTN is connected, check the signal strength
+ boolean isNTN = true;
+ int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ int rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rssnr = MIN_RSSNR;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+ // When NTN is disconnected, check the signal strength
+ isNTN = false;
+ rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ rssnr = MIN_RSSNR;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
}
@Test
@@ -391,6 +844,46 @@
createSignalStrengthLteReportRssnr(-128, 5).getLteLevel());
assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
createSignalStrengthLteReportRssnr(-128, 13).getLteLevel());
+
+ // When NTN is connected, check the signal strength
+ boolean isNTN = true;
+ int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ int rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rssnr = MIN_RSSNR;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+ // When NTN is disconnected, check the signal strength
+ isNTN = false;
+ rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ rssnr = MIN_RSSNR;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
}
@Test
@@ -405,6 +898,45 @@
createSignalStrengthLteReportRssnr(-138, 5).getLteLevel());
assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
createSignalStrengthLteReportRssnr(-138, 13).getLteLevel());
+
+ // When NTN is connected, check the signal strength
+ boolean isNTN = true;
+ int rsrp = MIN_RSRP;
+ int rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ int rssnr = MIN_RSSNR;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+ // When NTN is disconnected, check the signal strength
+ isNTN = false;
+ rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ rssnr = MIN_RSSNR;
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+ rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+ assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+ createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
}
}
diff --git a/tests/telephonytests/src/com/android/internal/telephony/SmsControllerTest.java b/tests/telephonytests/src/com/android/internal/telephony/SmsControllerTest.java
index 09c4173..972df5d 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/SmsControllerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/SmsControllerTest.java
@@ -16,7 +16,10 @@
package com.android.internal.telephony;
+import static junit.framework.Assert.assertEquals;
+
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.anyInt;
@@ -40,7 +43,9 @@
import org.junit.runner.RunWith;
import org.mockito.Mockito;
+import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
+import java.util.NoSuchElementException;
@RunWith(AndroidTestingRunner.class)
@TestableLooper.RunWithLooper
@@ -58,13 +63,14 @@
public void setUp() throws Exception {
super.setUp(getClass().getSimpleName());
mAdnRecordCache = Mockito.mock(AdnRecordCache.class);
- mSmsControllerUT = new SmsController(mContext);
+ mSmsControllerUT = new SmsController(mContext, mFeatureFlags);
mCallingPackage = mContext.getOpPackageName();
}
@After
public void tearDown() throws Exception {
mAdnRecordCache = null;
+ WapPushCache.clear();
super.tearDown();
}
@@ -239,4 +245,40 @@
verify(mIccSmsInterfaceManager, Mockito.times(0))
.sendText(mCallingPackage, "1234", null, "text", null, null, false, 0L, true);
}
+
+ @Test
+ public void testGetWapMessageSize() {
+ long expectedSize = 100L;
+ String location = "content://mms";
+ byte[] locationBytes = location.getBytes(StandardCharsets.ISO_8859_1);
+ byte[] transactionId = "123".getBytes(StandardCharsets.ISO_8859_1);
+
+ WapPushCache.putWapMessageSize(locationBytes, transactionId, expectedSize);
+ long size = mSmsControllerUT.getWapMessageSize(location);
+
+ assertEquals(expectedSize, size);
+ }
+
+ @Test
+ public void testGetWapMessageSize_withTransactionIdAppended() {
+ long expectedSize = 100L;
+ byte[] location = "content://mms".getBytes(StandardCharsets.ISO_8859_1);
+ byte[] transactionId = "123".getBytes(StandardCharsets.ISO_8859_1);
+ byte[] joinedKey = new byte[location.length + transactionId.length];
+ System.arraycopy(location, 0, joinedKey, 0, location.length);
+ System.arraycopy(transactionId, 0, joinedKey, location.length, transactionId.length);
+ String joinedKeyString = new String(joinedKey, StandardCharsets.ISO_8859_1);
+
+ WapPushCache.putWapMessageSize(location, transactionId, expectedSize);
+ long size = mSmsControllerUT.getWapMessageSize(joinedKeyString);
+
+ assertEquals(expectedSize, size);
+ }
+
+ @Test
+ public void testGetWapMessageSize_nonexistentThrows() {
+ assertThrows(NoSuchElementException.class, () ->
+ mSmsControllerUT.getWapMessageSize("content://mms")
+ );
+ }
}
\ No newline at end of file
diff --git a/tests/telephonytests/src/com/android/internal/telephony/TelephonyTest.java b/tests/telephonytests/src/com/android/internal/telephony/TelephonyTest.java
index 1ebe96d..89e9075 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/TelephonyTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/TelephonyTest.java
@@ -108,6 +108,7 @@
import com.android.internal.telephony.data.DataSettingsManager;
import com.android.internal.telephony.data.LinkBandwidthEstimator;
import com.android.internal.telephony.data.PhoneSwitcher;
+import com.android.internal.telephony.domainselection.DomainSelectionResolver;
import com.android.internal.telephony.emergency.EmergencyNumberTracker;
import com.android.internal.telephony.flags.FeatureFlags;
import com.android.internal.telephony.imsphone.ImsExternalCallTracker;
@@ -251,6 +252,7 @@
protected IntentBroadcaster mIntentBroadcaster;
protected NitzStateMachine mNitzStateMachine;
protected RadioConfig mMockRadioConfig;
+ protected RadioConfigProxy mMockRadioConfigProxy;
protected LocaleTracker mLocaleTracker;
protected RestrictedState mRestrictedState;
protected PhoneConfigurationManager mPhoneConfigurationManager;
@@ -281,6 +283,7 @@
protected SatelliteController mSatelliteController;
protected DeviceStateHelper mDeviceStateHelper;
protected CellularIdentifierDisclosureNotifier mIdentifierDisclosureNotifier;
+ protected DomainSelectionResolver mDomainSelectionResolver;
// Initialized classes
protected ActivityManager mActivityManager;
@@ -522,6 +525,7 @@
mIntentBroadcaster = Mockito.mock(IntentBroadcaster.class);
mNitzStateMachine = Mockito.mock(NitzStateMachine.class);
mMockRadioConfig = Mockito.mock(RadioConfig.class);
+ mMockRadioConfigProxy = Mockito.mock(RadioConfigProxy.class);
mLocaleTracker = Mockito.mock(LocaleTracker.class);
mRestrictedState = Mockito.mock(RestrictedState.class);
mPhoneConfigurationManager = Mockito.mock(PhoneConfigurationManager.class);
@@ -552,6 +556,7 @@
mSatelliteController = Mockito.mock(SatelliteController.class);
mDeviceStateHelper = Mockito.mock(DeviceStateHelper.class);
mIdentifierDisclosureNotifier = Mockito.mock(CellularIdentifierDisclosureNotifier.class);
+ mDomainSelectionResolver = Mockito.mock(DomainSelectionResolver.class);
TelephonyManager.disableServiceHandleCaching();
PropertyInvalidatedCache.disableForTestMode();
@@ -622,7 +627,7 @@
doReturn(mUiccProfile).when(mTelephonyComponentFactory)
.makeUiccProfile(nullable(Context.class), nullable(CommandsInterface.class),
nullable(IccCardStatus.class), anyInt(), nullable(UiccCard.class),
- nullable(Object.class));
+ nullable(Object.class), any(FeatureFlags.class));
doReturn(mCT).when(mTelephonyComponentFactory)
.makeGsmCdmaCallTracker(nullable(GsmCdmaPhone.class));
doReturn(mIccPhoneBookIntManager).when(mTelephonyComponentFactory)
@@ -809,6 +814,7 @@
anyInt(), anyInt());
doReturn(RIL.RADIO_HAL_VERSION_2_0).when(mPhone).getHalVersion(anyInt());
doReturn(2).when(mSignalStrength).getLevel();
+ doReturn(mMockRadioConfigProxy).when(mMockRadioConfig).getRadioConfigProxy(any());
// WiFi
doReturn(mWifiInfo).when(mWifiManager).getConnectionInfo();
@@ -888,6 +894,9 @@
.getFoldState();
doReturn(null).when(mContext).getSystemService(eq(Context.DEVICE_STATE_SERVICE));
+ doReturn(false).when(mDomainSelectionResolver).isDomainSelectionSupported();
+ DomainSelectionResolver.setDomainSelectionResolver(mDomainSelectionResolver);
+
//Use reflection to mock singletons
replaceInstance(CallManager.class, "INSTANCE", null, mCallManager);
replaceInstance(TelephonyComponentFactory.class, "sInstance", null,
@@ -990,6 +999,7 @@
mTestableLoopers.clear();
mTestableLoopers = null;
mTestableLooper = null;
+ DomainSelectionResolver.setDomainSelectionResolver(null);
}
protected static void logd(String s) {
diff --git a/tests/telephonytests/src/com/android/internal/telephony/WapPushCacheTest.java b/tests/telephonytests/src/com/android/internal/telephony/WapPushCacheTest.java
new file mode 100644
index 0000000..f572c08
--- /dev/null
+++ b/tests/telephonytests/src/com/android/internal/telephony/WapPushCacheTest.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony;
+
+import static junit.framework.Assert.assertEquals;
+
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.time.Clock;
+import java.util.NoSuchElementException;
+import java.util.concurrent.TimeUnit;
+
+public class WapPushCacheTest extends TelephonyTest {
+
+ @Before
+ public void setUp() throws Exception {
+ super.setUp(getClass().getSimpleName());
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ WapPushCache.clear();
+ WapPushCache.sTelephonyFacade = new TelephonyFacade();
+ super.tearDown();
+ }
+
+ @Test
+ public void testGetWapMessageSize() {
+ long expectedSize = 100L;
+ byte[] location = "content://mms".getBytes();
+ byte[] transactionId = "123".getBytes();
+
+ WapPushCache.putWapMessageSize(location, transactionId, expectedSize);
+ long size = WapPushCache.getWapMessageSize(location);
+
+ assertEquals(expectedSize, size);
+ }
+
+ @Test
+ public void testGetWapMessageSize_withTransactionIdAppended() {
+ long expectedSize = 100L;
+ byte[] location = "content://mms".getBytes();
+ byte[] transactionId = "123".getBytes();
+ byte[] joinedKey = new byte[location.length + transactionId.length];
+ System.arraycopy(location, 0, joinedKey, 0, location.length);
+ System.arraycopy(transactionId, 0, joinedKey, location.length, transactionId.length);
+
+ WapPushCache.putWapMessageSize(location, transactionId, expectedSize);
+ long size = WapPushCache.getWapMessageSize(joinedKey);
+
+ assertEquals(expectedSize, size);
+ }
+
+ @Test
+ public void testGetWapMessageSize_nonexistentThrows() {
+ assertThrows(NoSuchElementException.class, () ->
+ WapPushCache.getWapMessageSize("content://mms".getBytes())
+ );
+ }
+ @Test
+ public void testGetWapMessageSize_emptyLocationUrlThrows() {
+ assertThrows(IllegalArgumentException.class, () ->
+ WapPushCache.getWapMessageSize(new byte[0])
+ );
+ }
+
+ @Test
+ public void testPutWapMessageSize_invalidValuePreventsInsert() {
+ long expectedSize = 0L;
+ byte[] location = "content://mms".getBytes();
+ byte[] transactionId = "123".getBytes();
+
+ WapPushCache.putWapMessageSize(location, transactionId, expectedSize);
+
+ assertEquals(0, WapPushCache.size());
+ }
+
+ @Test
+ public void testPutWapMessageSize_sizeLimitExceeded_oldestEntryRemoved() {
+ long expectedSize = 100L;
+ for (int i = 0; i < 251; i++) {
+ byte[] location = ("" + i).getBytes();
+ byte[] transactionId = "abc".getBytes();
+ WapPushCache.putWapMessageSize(location, transactionId, expectedSize);
+ }
+
+ // assert one of the entries inserted above has been removed
+ assertEquals(500, WapPushCache.size());
+ // assert last entry added exists
+ assertEquals(expectedSize, WapPushCache.getWapMessageSize("250".getBytes()));
+ // assert the first entry added was removed
+ assertThrows(NoSuchElementException.class, () ->
+ WapPushCache.getWapMessageSize("0".getBytes())
+ );
+ }
+
+ @Test
+ public void testPutWapMessageSize_expiryExceeded_entryRemoved() {
+ long currentTime = Clock.systemUTC().millis();
+ TelephonyFacade facade = mock(TelephonyFacade.class);
+ when(facade.getElapsedSinceBootMillis()).thenReturn(currentTime);
+ WapPushCache.sTelephonyFacade = facade;
+
+ long expectedSize = 100L;
+ byte[] transactionId = "abc".getBytes();
+ byte[] location1 = "old".getBytes();
+ byte[] location2 = "new".getBytes();
+
+ WapPushCache.putWapMessageSize(location1, transactionId, expectedSize);
+ assertEquals(2, WapPushCache.size());
+
+ // advance time
+ when(facade.getElapsedSinceBootMillis())
+ .thenReturn(currentTime + TimeUnit.DAYS.toMillis(14) + 1);
+
+ WapPushCache.putWapMessageSize(location2, transactionId, expectedSize);
+
+ assertEquals(2, WapPushCache.size());
+ assertEquals(expectedSize, WapPushCache.getWapMessageSize(location2));
+ assertThrows(NoSuchElementException.class, () ->
+ WapPushCache.getWapMessageSize(location1)
+ );
+ }
+}
diff --git a/tests/telephonytests/src/com/android/internal/telephony/WapPushOverSmsTest.java b/tests/telephonytests/src/com/android/internal/telephony/WapPushOverSmsTest.java
index 8e40271..f5d4e95 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/WapPushOverSmsTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/WapPushOverSmsTest.java
@@ -62,6 +62,7 @@
@After
public void tearDown() throws Exception {
+ WapPushCache.clear();
mWapPushOverSmsUT = null;
super.tearDown();
}
@@ -150,4 +151,29 @@
any(UserHandle.class),
anyInt());
}
+
+ @Test @SmallTest
+ public void testDispatchWapPdu_notificationIndInsertedToCache() throws Exception {
+ assertEquals(0, WapPushCache.size());
+ when(mISmsStub.getCarrierConfigValuesForSubscriber(anyInt())).thenReturn(new Bundle());
+
+ doReturn(true).when(mWspTypeDecoder).decodeUintvarInteger(anyInt());
+ doReturn(true).when(mWspTypeDecoder).decodeContentType(anyInt());
+ doReturn((long) 2).when(mWspTypeDecoder).getValue32();
+ doReturn(2).when(mWspTypeDecoder).getDecodedDataLength();
+ doReturn(WspTypeDecoder.CONTENT_TYPE_B_PUSH_CO).when(mWspTypeDecoder).getValueString();
+
+ byte[] pdu = {1, 6, 0, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47,
+ 118, 110, 100, 46, 119, 97, 112, 46, 109, 109, 115, 45, 109, 101, 115, 115,
+ 97, 103, 101, 0, -116, -126, -104, 77, 109, 115, 84, 114, 97, 110, 115, 97,
+ 99, 116, 105, 111, 110, 73, 68, 0, -115, 18, -119, 8, -128, 49, 54, 49, 55,
+ 56, 50, 54, 57, 49, 54, 56, 47, 84, 89, 80, 69, 61, 80, 76, 77, 78, 0, -118,
+ -128, -114, 2, 3, -24, -120, 3, -127, 3, 3, -12, -128, -106, 84, 101, 115,
+ 116, 32, 77, 109, 115, 32, 83, 117, 98, 106, 101, 99, 116, 0, -125, 104, 116,
+ 116, 112, 58, 47, 47, 119, 119, 119, 46, 103, 111, 111, 103, 108, 101, 46, 99,
+ 111, 109, 47, 115, 97, 100, 102, 100, 100, 0};
+
+ mWapPushOverSmsUT.dispatchWapPdu(pdu, null, mInboundSmsHandler, null, 0, 0L);
+ assertEquals(2, WapPushCache.size());
+ }
}
diff --git a/tests/telephonytests/src/com/android/internal/telephony/cat/CATServiceTest.java b/tests/telephonytests/src/com/android/internal/telephony/cat/CATServiceTest.java
index f2c1870..a07ddbe 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/cat/CATServiceTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/cat/CATServiceTest.java
@@ -144,7 +144,7 @@
mSimulatedCommands = mock(SimulatedCommands.class);
mSimulatedCommands.setIccIoResultForApduLogicalChannel(mIccIoResult);
mUiccProfile = new UiccProfile(mContext, mSimulatedCommands, mIccCardStatus,
- 0 /* phoneId */, mUiccCard, new Object());
+ 0 /* phoneId */, mUiccCard, new Object(), mFeatureFlags);
processAllMessages();
logd("Created UiccProfile");
processAllMessages();
diff --git a/tests/telephonytests/src/com/android/internal/telephony/data/ApnSettingTest.java b/tests/telephonytests/src/com/android/internal/telephony/data/ApnSettingTest.java
index 98d3ce5..378df4b 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/data/ApnSettingTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/data/ApnSettingTest.java
@@ -16,6 +16,9 @@
package com.android.internal.telephony.data;
+import static android.telephony.data.ApnSetting.INFRASTRUCTURE_CELLULAR;
+import static android.telephony.data.ApnSetting.INFRASTRUCTURE_SATELLITE;
+
import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertTrue;
import static junit.framework.Assert.fail;
@@ -381,4 +384,34 @@
.build();
assertEquals("proxy.mobile.att.net", apn3.getMmsProxyAddressAsString());
}
+
+ @Test
+ public void testBuild_InfrastructureBitmask() {
+ int infrastructureBitmask = INFRASTRUCTURE_CELLULAR | INFRASTRUCTURE_SATELLITE;
+ ApnSetting apn1 = new ApnSetting.Builder()
+ .setId(1234)
+ .setOperatorNumeric("310260")
+ .setEntryName("mms")
+ .setApnName("mms")
+ .setApnTypeBitmask(ApnSetting.TYPE_MMS | ApnSetting.TYPE_DEFAULT)
+ .setProtocol(ApnSetting.PROTOCOL_IPV4V6)
+ .setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE))
+ .build();
+ // InfrastructureBitmask default value set to '3(cellular|satellite)'
+ assertEquals(infrastructureBitmask, apn1.getInfrastructureBitmask());
+
+ infrastructureBitmask = INFRASTRUCTURE_CELLULAR;
+ ApnSetting apn2 = new ApnSetting.Builder()
+ .setId(1235)
+ .setOperatorNumeric("310260")
+ .setEntryName("mms")
+ .setApnName("mms")
+ .setApnTypeBitmask(ApnSetting.TYPE_MMS | ApnSetting.TYPE_DEFAULT)
+ .setProtocol(ApnSetting.PROTOCOL_IPV4V6)
+ .setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE))
+ .setInfrastructureBitmask(infrastructureBitmask)
+ .build();
+ // InfrastructureBitmask value set to '1(cellular)'
+ assertEquals(infrastructureBitmask, apn2.getInfrastructureBitmask());
+ }
}
diff --git a/tests/telephonytests/src/com/android/internal/telephony/data/DataProfileManagerTest.java b/tests/telephonytests/src/com/android/internal/telephony/data/DataProfileManagerTest.java
index ff14f9a..e556cb8 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/data/DataProfileManagerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/data/DataProfileManagerTest.java
@@ -1611,6 +1611,7 @@
| TelephonyManager.NETWORK_TYPE_BITMASK_NR))
.setMvnoMatchData("")
.setApnSetId(DEFAULT_APN_SET_ID)
+ .setInfrastructureBitmask(1)
.build())
.build();
@@ -1646,6 +1647,7 @@
.setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_NR))
.setMvnoMatchData("")
.setApnSetId(DEFAULT_APN_SET_ID)
+ .setInfrastructureBitmask(1)
.build())
.build();
@@ -1674,6 +1676,7 @@
| TelephonyManager.NETWORK_TYPE_BITMASK_NR))
.setMvnoMatchData("")
.setApnSetId(APN_SET_ID_1)
+ .setInfrastructureBitmask(1)
.build())
.build();
@@ -1702,6 +1705,7 @@
| TelephonyManager.NETWORK_TYPE_BITMASK_NR))
.setMvnoMatchData("")
.setApnSetId(MATCH_ALL_APN_SET_ID)
+ .setInfrastructureBitmask(1)
.build())
.build();
@@ -1737,6 +1741,7 @@
| TelephonyManager.NETWORK_TYPE_BITMASK_NR))
.setMvnoMatchData("")
.setApnSetId(APN_SET_ID_1)
+ .setInfrastructureBitmask(1)
.build())
.build();
@@ -1765,6 +1770,7 @@
.setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_NR))
.setMvnoMatchData("")
.setApnSetId(DEFAULT_APN_SET_ID)
+ .setInfrastructureBitmask(1)
.build())
.build();
@@ -1793,6 +1799,7 @@
| TelephonyManager.NETWORK_TYPE_BITMASK_NR))
.setMvnoMatchData("")
.setApnSetId(MATCH_ALL_APN_SET_ID)
+ .setInfrastructureBitmask(1)
.build())
.build();
diff --git a/tests/telephonytests/src/com/android/internal/telephony/data/DataStallRecoveryManagerTest.java b/tests/telephonytests/src/com/android/internal/telephony/data/DataStallRecoveryManagerTest.java
index e1e238e..28c6cd6 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/data/DataStallRecoveryManagerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/data/DataStallRecoveryManagerTest.java
@@ -107,7 +107,7 @@
doReturn(dataStallRecoveryStepsArray)
.when(mDataConfigManager)
.getDataStallRecoveryShouldSkipArray();
- doReturn(true).when(mDataNetworkController).isInternetDataAllowed();
+ doReturn(true).when(mDataNetworkController).isInternetDataAllowed(true);
doAnswer(invocation -> {
((Runnable) invocation.getArguments()[0]).run();
@@ -347,7 +347,7 @@
mDataStallRecoveryManager.setRecoveryAction(1);
doReturn(mSignalStrength).when(mPhone).getSignalStrength();
doReturn(PhoneConstants.State.IDLE).when(mPhone).getState();
- doReturn(false).when(mDataNetworkController).isInternetDataAllowed();
+ doReturn(false).when(mDataNetworkController).isInternetDataAllowed(true);
logd("Sending validation failed callback");
sendValidationStatusCallback(NetworkAgent.VALIDATION_STATUS_NOT_VALID);
diff --git a/tests/telephonytests/src/com/android/internal/telephony/data/TelephonyNetworkFactoryTest.java b/tests/telephonytests/src/com/android/internal/telephony/data/TelephonyNetworkFactoryTest.java
index 5941f06..eff274c 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/data/TelephonyNetworkFactoryTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/data/TelephonyNetworkFactoryTest.java
@@ -190,7 +190,8 @@
private void createMockedTelephonyComponents() throws Exception {
replaceInstance(PhoneSwitcher.class, "sPhoneSwitcher", null, mPhoneSwitcher);
- mTelephonyNetworkFactoryUT = new TelephonyNetworkFactory(Looper.myLooper(), mPhone);
+ mTelephonyNetworkFactoryUT = new TelephonyNetworkFactory(Looper.myLooper(), mPhone,
+ mFeatureFlags);
final ArgumentCaptor<NetworkProvider> providerCaptor =
ArgumentCaptor.forClass(NetworkProvider.class);
verify(mConnectivityManager).registerNetworkProvider(providerCaptor.capture());
diff --git a/tests/telephonytests/src/com/android/internal/telephony/domainselection/DomainSelectionResolverTest.java b/tests/telephonytests/src/com/android/internal/telephony/domainselection/DomainSelectionResolverTest.java
index 7095909..eaf11a4 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/domainselection/DomainSelectionResolverTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/domainselection/DomainSelectionResolverTest.java
@@ -83,6 +83,8 @@
@Test
@SmallTest
public void testGetInstance() throws IllegalStateException {
+ DomainSelectionResolver.setDomainSelectionResolver(null);
+
assertThrows(IllegalStateException.class, () -> {
DomainSelectionResolver.getInstance();
});
diff --git a/tests/telephonytests/src/com/android/internal/telephony/emergency/EmergencyStateTrackerTest.java b/tests/telephonytests/src/com/android/internal/telephony/emergency/EmergencyStateTrackerTest.java
index 1eff979..fff1b68 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/emergency/EmergencyStateTrackerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/emergency/EmergencyStateTrackerTest.java
@@ -886,6 +886,42 @@
}
/**
+ * Test that once endCall() is called and we enter ECM, then we exit ECM when turning on
+ * airplane mode.
+ */
+ @Test
+ @SmallTest
+ public void endCall_entersEcm_thenExitsEcmWhenTurnOnAirplaneMode() {
+ // Setup EmergencyStateTracker
+ EmergencyStateTracker emergencyStateTracker = setupEmergencyStateTracker(
+ /* isSuplDdsSwitchRequiredForEmergencyCall= */ true);
+ // Create test Phone
+ Phone testPhone = setupTestPhoneForEmergencyCall(/* isRoaming= */ true,
+ /* isRadioOn= */ true);
+ setUpAsyncResultForSetEmergencyMode(testPhone, E_REG_RESULT);
+ setUpAsyncResultForExitEmergencyMode(testPhone);
+ CompletableFuture<Integer> unused = emergencyStateTracker.startEmergencyCall(testPhone,
+ TEST_CALL_ID, false);
+ // Set call to ACTIVE
+ emergencyStateTracker.onEmergencyCallStateChanged(Call.State.ACTIVE, TEST_CALL_ID);
+ // Set ecm as supported
+ setEcmSupportedConfig(testPhone, /* ecmSupported= */ true);
+
+ processAllMessages();
+
+ emergencyStateTracker.endCall(TEST_CALL_ID);
+
+ assertTrue(emergencyStateTracker.isInEcm());
+
+ emergencyStateTracker.onCellularRadioPowerOffRequested();
+
+ // Verify exitEmergencyMode() is called.
+ verify(testPhone).exitEmergencyMode(any(Message.class));
+ assertFalse(emergencyStateTracker.isInEcm());
+ assertFalse(emergencyStateTracker.isInEmergencyMode());
+ }
+
+ /**
* Test that after exitEmergencyCallbackMode() is called, the correct intents are sent and
* emergency mode is exited on the modem.
*/
diff --git a/tests/telephonytests/src/com/android/internal/telephony/imsphone/ImsPhoneCallTrackerTest.java b/tests/telephonytests/src/com/android/internal/telephony/imsphone/ImsPhoneCallTrackerTest.java
index 04ae9d0..bfa702c 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/imsphone/ImsPhoneCallTrackerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/imsphone/ImsPhoneCallTrackerTest.java
@@ -126,7 +126,6 @@
import com.android.internal.telephony.SrvccConnection;
import com.android.internal.telephony.TelephonyTest;
import com.android.internal.telephony.d2d.RtpTransport;
-import com.android.internal.telephony.domainselection.DomainSelectionResolver;
import com.android.internal.telephony.imsphone.ImsPhoneCallTracker.VtDataUsageProvider;
import com.android.internal.telephony.subscription.SubscriptionInfoInternal;
@@ -174,7 +173,6 @@
private INetworkStatsProviderCallback mVtDataUsageProviderCb;
private ImsPhoneCallTracker.ConnectorFactory mConnectorFactory;
private CommandsInterface mMockCi;
- private DomainSelectionResolver mDomainSelectionResolver;
private CarrierConfigManager.CarrierConfigChangeListener mCarrierConfigChangeListener;
private final Executor mExecutor = Runnable::run;
@@ -242,7 +240,6 @@
doReturn(ImsFeature.STATE_READY).when(mImsManager).getImsServiceState();
doReturn(mImsCallProfile).when(mImsManager).createCallProfile(anyInt(), anyInt());
mContextFixture.addSystemFeature(PackageManager.FEATURE_TELEPHONY_IMS);
- mDomainSelectionResolver = mock(DomainSelectionResolver.class);
doReturn(new SubscriptionInfoInternal.Builder().setSimSlotIndex(0).setId(1).build())
.when(mSubscriptionManagerService).getSubscriptionInfoInternal(anyInt());
@@ -281,9 +278,6 @@
return mMockConnector;
}).when(mConnectorFactory).create(any(), anyInt(), anyString(), any(), any());
- DomainSelectionResolver.setDomainSelectionResolver(mDomainSelectionResolver);
- doReturn(false).when(mDomainSelectionResolver).isDomainSelectionSupported();
-
doReturn(false)
.when(mFeatureFlags).updateImsServiceByGatheringProvisioningChanges();
diff --git a/tests/telephonytests/src/com/android/internal/telephony/imsphone/ImsPhoneTest.java b/tests/telephonytests/src/com/android/internal/telephony/imsphone/ImsPhoneTest.java
index fbb30ff..f491041 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/imsphone/ImsPhoneTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/imsphone/ImsPhoneTest.java
@@ -125,7 +125,6 @@
private ImsPhoneCall mBackgroundCall;
private ImsPhoneCall mRingingCall;
private Handler mTestHandler;
- private DomainSelectionResolver mDomainSelectionResolver;
Connection mConnection;
ImsUtInterface mImsUtInterface;
private FeatureFlags mFeatureFlags;
@@ -152,10 +151,7 @@
mTestHandler = mock(Handler.class);
mConnection = mock(Connection.class);
mImsUtInterface = mock(ImsUtInterface.class);
- mDomainSelectionResolver = mock(DomainSelectionResolver.class);
mFeatureFlags = mock(FeatureFlags.class);
- doReturn(false).when(mDomainSelectionResolver).isDomainSelectionSupported();
- DomainSelectionResolver.setDomainSelectionResolver(mDomainSelectionResolver);
mImsCT.mForegroundCall = mForegroundCall;
mImsCT.mBackgroundCall = mBackgroundCall;
@@ -200,7 +196,6 @@
public void tearDown() throws Exception {
mImsPhoneUT = null;
mBundle = null;
- DomainSelectionResolver.setDomainSelectionResolver(null);
super.tearDown();
}
diff --git a/tests/telephonytests/src/com/android/internal/telephony/metrics/MetricsCollectorTest.java b/tests/telephonytests/src/com/android/internal/telephony/metrics/MetricsCollectorTest.java
index 66bf482..0e1135e 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/metrics/MetricsCollectorTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/metrics/MetricsCollectorTest.java
@@ -23,6 +23,7 @@
import static com.android.internal.telephony.TelephonyStatsLog.SUPPORTED_RADIO_ACCESS_FAMILY;
import static com.android.internal.telephony.TelephonyStatsLog.VOICE_CALL_RAT_USAGE;
import static com.android.internal.telephony.TelephonyStatsLog.VOICE_CALL_SESSION;
+import static com.android.internal.telephony.util.TelephonyUtils.IS_DEBUGGABLE;
import static com.google.common.truth.Truth.assertThat;
@@ -67,6 +68,8 @@
.setCoolDownMillis(24L * 3600L * 1000L)
.build();
private static final long MIN_COOLDOWN_MILLIS = 23L * 3600L * 1000L;
+ private static final long CELL_SERVICE_MIN_COOLDOWN_MILLIS =
+ IS_DEBUGGABLE ? 4L * 60L * 1000L : MIN_COOLDOWN_MILLIS;
private static final long MIN_CALLS_PER_BUCKET = 5L;
// NOTE: these fields are currently 32-bit internally and padded to 64-bit by TelephonyManager
@@ -92,6 +95,7 @@
private UiccCard mActiveCard;
private UiccPort mActivePort;
private ServiceStateStats mServiceStateStats;
+ private VonrHelper mVonrHelper;
private MetricsCollector mMetricsCollector;
@@ -104,8 +108,10 @@
mActiveCard = mock(UiccCard.class);
mActivePort = mock(UiccPort.class);
mServiceStateStats = mock(ServiceStateStats.class);
+ mVonrHelper = mock(VonrHelper.class);
mMetricsCollector =
- new MetricsCollector(mContext, mPersistAtomsStorage, mDeviceStateHelper);
+ new MetricsCollector(mContext, mPersistAtomsStorage,
+ mDeviceStateHelper, mVonrHelper);
doReturn(mSST).when(mSecondPhone).getServiceStateTracker();
doReturn(mServiceStateStats).when(mSST).getServiceStateStats();
}
@@ -398,7 +404,8 @@
assertThat(actualAtoms).hasSize(0);
assertThat(result).isEqualTo(StatsManager.PULL_SKIP);
- verify(mPersistAtomsStorage, times(1)).getCellularServiceStates(eq(MIN_COOLDOWN_MILLIS));
+ verify(mPersistAtomsStorage, times(1)).getCellularServiceStates(
+ eq(CELL_SERVICE_MIN_COOLDOWN_MILLIS));
verifyNoMoreInteractions(mPersistAtomsStorage);
}
diff --git a/tests/telephonytests/src/com/android/internal/telephony/metrics/VoiceCallSessionStatsTest.java b/tests/telephonytests/src/com/android/internal/telephony/metrics/VoiceCallSessionStatsTest.java
index 00ba0f8..1498eb4 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/metrics/VoiceCallSessionStatsTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/metrics/VoiceCallSessionStatsTest.java
@@ -44,6 +44,7 @@
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
+import android.annotation.NonNull;
import android.os.Looper;
import android.telephony.AccessNetworkConstants;
import android.telephony.Annotation.NetworkType;
@@ -68,6 +69,7 @@
import com.android.internal.telephony.PhoneFactory;
import com.android.internal.telephony.ServiceStateTracker;
import com.android.internal.telephony.TelephonyTest;
+import com.android.internal.telephony.flags.FeatureFlags;
import com.android.internal.telephony.imsphone.ImsPhoneCall;
import com.android.internal.telephony.imsphone.ImsPhoneConnection;
import com.android.internal.telephony.nano.PersistAtomsProto.VoiceCallRatUsage;
@@ -114,12 +116,14 @@
private GsmCdmaCall mCsCall1;
private ImsPhoneCall mImsCall0;
private ImsPhoneCall mImsCall1;
+ private VonrHelper mVonrHelper;
private static class TestableVoiceCallSessionStats extends VoiceCallSessionStats {
private long mTimeMillis = 0L;
- TestableVoiceCallSessionStats(int phoneId, Phone phone) {
- super(phoneId, phone);
+ TestableVoiceCallSessionStats(int phoneId, Phone phone,
+ @NonNull FeatureFlags featureFlags) {
+ super(phoneId, phone, featureFlags);
}
@Override
@@ -160,6 +164,7 @@
mCsCall1 = mock(GsmCdmaCall.class);
mImsCall0 = mock(ImsPhoneCall.class);
mImsCall1 = mock(ImsPhoneCall.class);
+ mVonrHelper = mock(VonrHelper.class);
replaceInstance(PhoneFactory.class, "sPhones", null, new Phone[] {mPhone, mSecondPhone});
doReturn(CARRIER_ID_SLOT_0).when(mPhone).getCarrierId();
// mPhone's mContext/mSST/mServiceState has been set up by TelephonyTest
@@ -212,10 +217,14 @@
Looper.prepare();
}
- mVoiceCallSessionStats0 = new TestableVoiceCallSessionStats(0, mPhone);
+ doReturn(mVonrHelper).when(mMetricsCollector).getVonrHelper();
+
+ mVoiceCallSessionStats0 = new TestableVoiceCallSessionStats(0, mPhone, mFeatureFlags);
mVoiceCallSessionStats0.onServiceStateChanged(mServiceState);
- mVoiceCallSessionStats1 = new TestableVoiceCallSessionStats(1, mSecondPhone);
+ mVoiceCallSessionStats1 = new TestableVoiceCallSessionStats(1, mSecondPhone, mFeatureFlags);
mVoiceCallSessionStats1.onServiceStateChanged(mSecondServiceState);
+
+ doReturn(true).when(mFeatureFlags).vonrEnabledMetric();
}
@After
@@ -2686,6 +2695,63 @@
assertProtoEquals(expectedRatUsage, ratUsage.get()[0]);
}
+ @Test
+ @SmallTest
+ public void singleCall_vonrEnabled() {
+ setServiceState(mServiceState, TelephonyManager.NETWORK_TYPE_LTE);
+ doReturn(TelephonyManager.NETWORK_TYPE_LTE).when(mImsStats).getImsVoiceRadioTech();
+ doReturn(mImsPhone).when(mPhone).getImsPhone();
+ doReturn(false).when(mImsConnection0).isIncoming();
+ doReturn(2000L).when(mImsConnection0).getCreateTime();
+ doReturn(0L).when(mImsConnection0).getDurationMillis();
+ doReturn(mImsCall0).when(mImsConnection0).getCall();
+ doReturn(true).when(mVonrHelper).getVonrEnabled(anyInt());
+ doReturn(new ArrayList(List.of(mImsConnection0))).when(mImsCall0).getConnections();
+ VoiceCallSession expectedCall =
+ makeSlot0CallProto(
+ VOICE_CALL_SESSION__BEARER_AT_END__CALL_BEARER_IMS,
+ VOICE_CALL_SESSION__DIRECTION__CALL_DIRECTION_MO,
+ TelephonyManager.NETWORK_TYPE_LTE,
+ ImsReasonInfo.CODE_REMOTE_CALL_DECLINE);
+ expectedCall.setupDurationMillis = 200;
+ expectedCall.setupFailed = true;
+ expectedCall.ratAtConnected = TelephonyManager.NETWORK_TYPE_UNKNOWN;
+ expectedCall.codecBitmask = 1L << AudioCodec.AUDIO_CODEC_EVS_SWB;
+ expectedCall.mainCodecQuality =
+ VOICE_CALL_SESSION__MAIN_CODEC_QUALITY__CODEC_QUALITY_SUPER_WIDEBAND;
+ expectedCall.ratAtConnected = TelephonyManager.NETWORK_TYPE_UNKNOWN;
+ expectedCall.callDuration = VOICE_CALL_SESSION__CALL_DURATION__CALL_DURATION_UNKNOWN;
+ expectedCall.vonrEnabled = true;
+ VoiceCallRatUsage expectedRatUsage =
+ makeRatUsageProto(
+ CARRIER_ID_SLOT_0, TelephonyManager.NETWORK_TYPE_LTE, 2000L, 12000L, 1L);
+ final AtomicReference<VoiceCallRatUsage[]> ratUsage = setupRatUsageCapture();
+
+ mVoiceCallSessionStats0.setTimeMillis(2000L);
+ doReturn(Call.State.DIALING).when(mImsCall0).getState();
+ doReturn(Call.State.DIALING).when(mImsConnection0).getState();
+ mVoiceCallSessionStats0.onImsDial(mImsConnection0);
+ mVoiceCallSessionStats0.setTimeMillis(2100L);
+ mVoiceCallSessionStats0.onAudioCodecChanged(
+ mImsConnection0, ImsStreamMediaProfile.AUDIO_QUALITY_EVS_SWB);
+ mVoiceCallSessionStats0.setTimeMillis(2200L);
+ doReturn(Call.State.ALERTING).when(mImsCall0).getState();
+ doReturn(Call.State.ALERTING).when(mImsConnection0).getState();
+ mVoiceCallSessionStats0.onCallStateChanged(mImsCall0);
+ mVoiceCallSessionStats0.setTimeMillis(12000L);
+ mVoiceCallSessionStats0.onImsCallTerminated(
+ mImsConnection0, new ImsReasonInfo(ImsReasonInfo.CODE_REMOTE_CALL_DECLINE, 0));
+
+ ArgumentCaptor<VoiceCallSession> callCaptor =
+ ArgumentCaptor.forClass(VoiceCallSession.class);
+ verify(mPersistAtomsStorage, times(1)).addVoiceCallSession(callCaptor.capture());
+ verify(mPersistAtomsStorage, times(1)).addVoiceCallRatUsage(any());
+ verifyNoMoreInteractions(mPersistAtomsStorage);
+ assertProtoEquals(expectedCall, callCaptor.getValue());
+ assertThat(ratUsage.get()).hasLength(1);
+ assertProtoEquals(expectedRatUsage, ratUsage.get()[0]);
+ }
+
private AtomicReference<VoiceCallRatUsage[]> setupRatUsageCapture() {
final AtomicReference<VoiceCallRatUsage[]> ratUsage = new AtomicReference<>(null);
doAnswer(
@@ -2773,6 +2839,7 @@
call.isRoaming = false;
call.setupBeginMillis = 0L;
call.signalStrengthAtEnd = 2;
+ call.vonrEnabled = false;
return call;
}
diff --git a/tests/telephonytests/src/com/android/internal/telephony/metrics/VonrHelperTest.java b/tests/telephonytests/src/com/android/internal/telephony/metrics/VonrHelperTest.java
new file mode 100644
index 0000000..04cd925
--- /dev/null
+++ b/tests/telephonytests/src/com/android/internal/telephony/metrics/VonrHelperTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony.metrics;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.doReturn;
+
+import android.annotation.NonNull;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import com.android.internal.telephony.TelephonyTest;
+import com.android.internal.telephony.flags.FeatureFlags;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class VonrHelperTest extends TelephonyTest {
+ private static final int SUBID = 1;
+
+ private static class TestableVonrHelper extends VonrHelper {
+ TestableVonrHelper(@NonNull FeatureFlags featureFlags) {
+ super(featureFlags);
+ }
+
+ @Override
+ public void updateVonrEnabledState() {
+ mVonrRunnable.run();
+ }
+ }
+
+ private TestableVonrHelper mVonrHelper;
+
+ @Before
+ public void setUp() throws Exception {
+ super.setUp(getClass().getSimpleName());
+ doReturn(SUBID).when(mPhone).getSubId();
+ doReturn(false).when(mTelephonyManager).isVoNrEnabled();
+ mVonrHelper = new TestableVonrHelper(mFeatureFlags);
+ doReturn(true).when(mFeatureFlags).vonrEnabledMetric();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ super.tearDown();
+ }
+
+ @Test
+ @SmallTest
+ public void vonr_enabled() {
+ doReturn(true).when(mTelephonyManager).isVoNrEnabled();
+
+ mVonrHelper.updateVonrEnabledState();
+
+ assertThat(mVonrHelper.getVonrEnabled(SUBID)).isTrue();
+ }
+
+ @Test
+ @SmallTest
+ public void vonr_disabled() {
+ mVonrHelper.updateVonrEnabledState();
+
+ assertThat(mVonrHelper.getVonrEnabled(SUBID)).isFalse();
+ }
+}
diff --git a/tests/telephonytests/src/com/android/internal/telephony/nitz/TEST_MAPPING b/tests/telephonytests/src/com/android/internal/telephony/nitz/TEST_MAPPING
index 2bcb04e..4063803 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/nitz/TEST_MAPPING
+++ b/tests/telephonytests/src/com/android/internal/telephony/nitz/TEST_MAPPING
@@ -1,6 +1,5 @@
{
- // TODO(b/182461754): Change to "presubmit" when go/test-mapping-slo-guide allows.
- "postsubmit": [
+ "presubmit": [
{
"name": "FrameworksTelephonyTests",
"options": [
diff --git a/tests/telephonytests/src/com/android/internal/telephony/satellite/SatelliteControllerTest.java b/tests/telephonytests/src/com/android/internal/telephony/satellite/SatelliteControllerTest.java
index eebd04c..55532cc 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/satellite/SatelliteControllerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/satellite/SatelliteControllerTest.java
@@ -61,6 +61,7 @@
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
@@ -91,7 +92,9 @@
import android.os.Looper;
import android.os.Message;
import android.os.PersistableBundle;
+import android.os.RemoteException;
import android.os.ResultReceiver;
+import android.os.ServiceSpecificException;
import android.telephony.CarrierConfigManager;
import android.telephony.Rlog;
import android.telephony.ServiceState;
@@ -491,7 +494,7 @@
doReturn(mMockProvisionMetricsStats).when(mMockProvisionMetricsStats)
.setResultCode(anyInt());
doReturn(mMockProvisionMetricsStats).when(mMockProvisionMetricsStats)
- .setIsProvisionRequest(eq(false));
+ .setIsProvisionRequest(eq(false));
doNothing().when(mMockProvisionMetricsStats).reportProvisionMetrics();
doNothing().when(mMockControllerMetricsStats).reportDeprovisionCount(anyInt());
when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(true);
@@ -1036,7 +1039,7 @@
assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
(long) mIIntegerConsumerResults.get(0));
verify(mMockPointingAppController).unregisterForSatelliteTransmissionUpdates(anyInt(),
- any(), eq(mStartTransmissionUpdateCallback));
+ any(), eq(mStartTransmissionUpdateCallback));
verify(mMockPointingAppController).setStartedSatelliteTransmissionUpdates(eq(false));
}
@@ -1095,7 +1098,7 @@
mSatelliteControllerUT.stopSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
mStopTransmissionUpdateCallback);
verify(mMockPointingAppController).unregisterForSatelliteTransmissionUpdates(anyInt(),
- any(), eq(mStopTransmissionUpdateCallback));
+ any(), eq(mStopTransmissionUpdateCallback));
processAllMessages();
assertTrue(waitForIIntegerConsumerResult(1));
assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
@@ -1519,7 +1522,7 @@
resetSatelliteControllerUT();
mIIntegerConsumerResults.clear();
mSatelliteControllerUT.deprovisionSatelliteService(SUB_ID,
- TEST_SATELLITE_TOKEN, mIIntegerConsumer);
+ TEST_SATELLITE_TOKEN, mIIntegerConsumer);
processAllMessages();
assertTrue(waitForIIntegerConsumerResult(1));
assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
@@ -2156,16 +2159,16 @@
}
};
- int errorCode = mSatelliteControllerUT.registerForNtnSignalStrengthChanged(SUB_ID,
- callback);
- assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE, errorCode);
- @NtnSignalStrength.NtnSignalStrengthLevel int expectedLevel = NTN_SIGNAL_STRENGTH_NONE;
+ verifyRegisterForNtnSignalStrengthChanged(SUB_ID, callback,
+ SATELLITE_RESULT_INVALID_TELEPHONY_STATE);
setUpResponseForRequestIsSatelliteSupported(false,
SATELLITE_RESULT_SUCCESS);
verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
- errorCode = mSatelliteControllerUT.registerForNtnSignalStrengthChanged(SUB_ID, callback);
- assertEquals(SATELLITE_RESULT_NOT_SUPPORTED, errorCode);
+ verifyRegisterForNtnSignalStrengthChanged(SUB_ID, callback,
+ SATELLITE_RESULT_NOT_SUPPORTED);
+
+ @NtnSignalStrength.NtnSignalStrengthLevel int expectedLevel = NTN_SIGNAL_STRENGTH_NONE;
verifyRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_NOT_SUPPORTED);
resetSatelliteControllerUT();
@@ -2173,8 +2176,8 @@
setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
setUpResponseForRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
- errorCode = mSatelliteControllerUT.registerForNtnSignalStrengthChanged(SUB_ID, callback);
- assertEquals(SATELLITE_RESULT_SUCCESS, errorCode);
+ verifyRegisterForNtnSignalStrengthChanged(SUB_ID, callback,
+ SATELLITE_RESULT_SUCCESS);
verifyRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
expectedLevel = NTN_SIGNAL_STRENGTH_GOOD;
@@ -2225,15 +2228,14 @@
}
};
- int errorCode = mSatelliteControllerUT.registerForNtnSignalStrengthChanged(SUB_ID,
- callback);
- assertEquals(SATELLITE_RESULT_REQUEST_NOT_SUPPORTED, errorCode);
+ verifyRegisterForNtnSignalStrengthChanged(SUB_ID, callback,
+ SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
setUpResponseForRequestIsSatelliteSupported(false,
SATELLITE_RESULT_SUCCESS);
verifySatelliteSupported(false, SATELLITE_RESULT_NOT_SUPPORTED);
- errorCode = mSatelliteControllerUT.registerForNtnSignalStrengthChanged(SUB_ID, callback);
- assertEquals(SATELLITE_RESULT_REQUEST_NOT_SUPPORTED, errorCode);
+ verifyRegisterForNtnSignalStrengthChanged(SUB_ID, callback,
+ SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
setUpResponseForRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_NONE,
SATELLITE_RESULT_SUCCESS);
verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_NONE,
@@ -2242,8 +2244,8 @@
resetSatelliteControllerUT();
setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
verifySatelliteSupported(false, SATELLITE_RESULT_NOT_SUPPORTED);
- errorCode = mSatelliteControllerUT.registerForNtnSignalStrengthChanged(SUB_ID, callback);
- assertEquals(SATELLITE_RESULT_REQUEST_NOT_SUPPORTED, errorCode);
+ verifyRegisterForNtnSignalStrengthChanged(SUB_ID, callback,
+ SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_NONE,
SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
@@ -2660,7 +2662,7 @@
int satelliteVisibilityTime, @SatelliteManager.SatelliteResult int error) {
SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
? null : new SatelliteException(error);
- int[] visibilityTime = new int[] {satelliteVisibilityTime};
+ int[] visibilityTime = new int[]{satelliteVisibilityTime};
doAnswer(invocation -> {
Message message = (Message) invocation.getArguments()[0];
AsyncResult.forMessage(message, visibilityTime, exception);
@@ -2687,7 +2689,7 @@
boolean isSatelliteProvisioned, @SatelliteManager.SatelliteResult int error) {
SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
? null : new SatelliteException(error);
- int[] provisioned = new int[] {isSatelliteProvisioned ? 1 : 0};
+ int[] provisioned = new int[]{isSatelliteProvisioned ? 1 : 0};
doAnswer(invocation -> {
Message message = (Message) invocation.getArguments()[0];
AsyncResult.forMessage(message, provisioned, exception);
@@ -3101,6 +3103,22 @@
mSimulatedCommands.setRadioPower(on, false, false, null);
}
+ private void verifyRegisterForNtnSignalStrengthChanged(int subId,
+ INtnSignalStrengthCallback callback, int expectedError) {
+ if (expectedError == SATELLITE_RESULT_SUCCESS) {
+ try {
+ mSatelliteControllerUT.registerForNtnSignalStrengthChanged(subId, callback);
+ } catch (RemoteException ex) {
+ throw new AssertionError();
+ }
+ } else {
+ ServiceSpecificException ex = assertThrows(ServiceSpecificException.class,
+ () -> mSatelliteControllerUT.registerForNtnSignalStrengthChanged(subId,
+ callback));
+ assertEquals(expectedError, ex.errorCode);
+ }
+ }
+
private static void loge(String message) {
Rlog.e(TAG, message);
}
diff --git a/tests/telephonytests/src/com/android/internal/telephony/uicc/UiccProfileTest.java b/tests/telephonytests/src/com/android/internal/telephony/uicc/UiccProfileTest.java
index a9034eb..ca322e0 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/uicc/UiccProfileTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/uicc/UiccProfileTest.java
@@ -129,7 +129,7 @@
ArgumentCaptor<CarrierConfigManager.CarrierConfigChangeListener> listenerArgumentCaptor =
ArgumentCaptor.forClass(CarrierConfigManager.CarrierConfigChangeListener.class);
mUiccProfile = new UiccProfile(mContext, mSimulatedCommands, mIccCardStatus,
- 0 /* phoneId */, mUiccCard, new Object());
+ 0 /* phoneId */, mUiccCard, new Object(), mFeatureFlags);
verify(mCarrierConfigManager).registerCarrierConfigChangeListener(any(),
listenerArgumentCaptor.capture());
mCarrierConfigChangeListener = listenerArgumentCaptor.getAllValues().get(0);
diff --git a/tests/telephonytests/src/com/android/internal/telephony/uicc/UiccSlotTest.java b/tests/telephonytests/src/com/android/internal/telephony/uicc/UiccSlotTest.java
index 1d320a3..671f273 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/uicc/UiccSlotTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/uicc/UiccSlotTest.java
@@ -428,7 +428,7 @@
mUiccSlot.update(mSimulatedCommands, mIccCardStatus, phoneId, slotIndex);
verify(mTelephonyComponentFactory).makeUiccProfile(
anyObject(), eq(mSimulatedCommands), eq(mIccCardStatus), anyInt(), anyObject(),
- anyObject());
+ anyObject(), anyObject());
assertEquals(IccCardStatus.CardState.CARDSTATE_PRESENT, mUiccSlot.getCardState());
assertNotNull(mUiccSlot.getUiccCard());
@@ -451,7 +451,7 @@
mUiccSlot.update(mSimulatedCommands, mIccCardStatus, phoneId, slotIndex);
verify(mTelephonyComponentFactory).makeUiccProfile(
anyObject(), eq(mSimulatedCommands), eq(mIccCardStatus), anyInt(), anyObject(),
- anyObject());
+ anyObject(), anyObject());
assertEquals(IccCardStatus.CardState.CARDSTATE_PRESENT, mUiccSlot.getCardState());
assertNotNull(mUiccSlot.getUiccCard());