diff options
author | Android Build Coastguard Worker <android-build-coastguard-worker@google.com> | 2023-12-09 04:17:42 +0000 |
---|---|---|
committer | Android Build Coastguard Worker <android-build-coastguard-worker@google.com> | 2023-12-09 04:17:42 +0000 |
commit | 11594514a7d864eb31573d39f3fe54509a78c6b5 (patch) | |
tree | fd3752be7f6c31843105db42d3f37540b78c48e7 | |
parent | f67e0fee03495eaa66d06fa39349386c0ba943f0 (diff) | |
parent | 218e04b03dc1decb2d452a7b100314aea7f205b4 (diff) | |
download | telephony-11594514a7d864eb31573d39f3fe54509a78c6b5.tar.gz |
Snap for 11200327 from 218e04b03dc1decb2d452a7b100314aea7f205b4 to 24Q1-release
Change-Id: I298ef7e270d01b20608c1743b5ba63f2a887dd37
5 files changed, 836 insertions, 10 deletions
diff --git a/flags/ims.aconfig b/flags/ims.aconfig index 94c933cb4f..4638194f81 100644 --- a/flags/ims.aconfig +++ b/flags/ims.aconfig @@ -34,3 +34,10 @@ flag { 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/SignalStrengthController.java b/src/java/com/android/internal/telephony/SignalStrengthController.java index 387c501c61..b11d7e564f 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.Set; 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 @@ public class SignalStrengthController extends Handler { 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 @@ public class SignalStrengthController extends Handler { @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 @@ public class SignalStrengthController extends Handler { ccm.registerCarrierConfigChangeListener(this::post, (slotIndex, subId, carrierId, specificCarrierId) -> onCarrierConfigurationChanged(slotIndex)); + + mPhone.registerForServiceStateChanged(this, EVENT_SERVICE_STATE_CHANGED, null); } @Override @@ -273,6 +279,11 @@ public class SignalStrengthController extends Handler { 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 @@ public class SignalStrengthController extends Handler { 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 @@ public class SignalStrengthController extends Handler { } 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 @@ public class SignalStrengthController extends Handler { (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 @@ public class SignalStrengthController extends Handler { }; } + 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/imsphone/ImsPhoneCallTracker.java b/src/java/com/android/internal/telephony/imsphone/ImsPhoneCallTracker.java index 4f9b69d7d4..e95433c2ee 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 @@ public class ImsPhoneCallTracker extends CallTracker implements ImsPullCall { // 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 @@ public class ImsPhoneCallTracker extends CallTracker implements ImsPullCall { 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 @@ public class ImsPhoneCallTracker extends CallTracker implements ImsPullCall { * * @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 @@ public class ImsPhoneCallTracker extends CallTracker implements ImsPullCall { 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/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthControllerTest.java b/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthControllerTest.java index 98980a1bf0..fa890825f7 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 com.google.common.truth.Truth.assertThat; 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 @@ public class SignalStrengthControllerTest extends TelephonyTest { 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 96184c5ec7..8df40527dc 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 static org.junit.Assert.assertTrue; 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.CellSignalStrengthLte; 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 @@ import java.util.List; @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 @@ public class SignalStrengthTest { -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 @@ public class SignalStrengthTest { 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 @@ public class SignalStrengthTest { // 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 @@ public class SignalStrengthTest { 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 @@ public class SignalStrengthTest { 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 @@ public class SignalStrengthTest { 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 @@ public class SignalStrengthTest { 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 @@ public class SignalStrengthTest { 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 @@ public class SignalStrengthTest { 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 @@ public class SignalStrengthTest { 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 @@ public class SignalStrengthTest { 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 @@ public class SignalStrengthTest { 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 @@ public class SignalStrengthTest { 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()); } } |