Merge "Add vonr_enabled to voice call metric" into main
diff --git a/flags/ims.aconfig b/flags/ims.aconfig
index 94c933c..4638194 100644
--- a/flags/ims.aconfig
+++ b/flags/ims.aconfig
@@ -34,3 +34,10 @@
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"
+}
diff --git a/src/java/com/android/internal/telephony/GsmCdmaPhone.java b/src/java/com/android/internal/telephony/GsmCdmaPhone.java
index 6fd13fb..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 &
@@ -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..d944738 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;
/**
@@ -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/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/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/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/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 21b2cea..8bd2547 100644
--- a/src/java/com/android/internal/telephony/metrics/MetricsCollector.java
+++ b/src/java/com/android/internal/telephony/metrics/MetricsCollector.java
@@ -53,6 +53,7 @@
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;
@@ -138,16 +139,33 @@
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;
@@ -521,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)
@@ -941,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,
@@ -1377,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/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/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaPhoneTest.java b/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaPhoneTest.java
index c8510eb..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;
@@ -2858,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/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/metrics/MetricsCollectorTest.java b/tests/telephonytests/src/com/android/internal/telephony/metrics/MetricsCollectorTest.java
index 2a8c597..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
@@ -401,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);
}