diff options
author | Hyosun Kim <hyosunkim@google.com> | 2023-12-07 23:58:32 +0000 |
---|---|---|
committer | Android (Google) Code Review <android-gerrit@google.com> | 2023-12-07 23:58:32 +0000 |
commit | 6a7e1d77b8ed973a222d1933b4e57f5ba4c96d7b (patch) | |
tree | 0ffc972649179647ce732111e32e1a83bc59070c | |
parent | f3faa1aa47979fe5447019bfde3c4cb3d3ee56c7 (diff) | |
parent | d7f62a55b903b0dbf95dd7c9ce2a8dc8a24c0910 (diff) | |
download | telephony-6a7e1d77b8ed973a222d1933b4e57f5ba4c96d7b.tar.gz |
Merge "Check if the NTN is connected or not and change the signal threshold criteria." into main
3 files changed, 813 insertions, 6 deletions
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/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()); } } |