diff options
13 files changed, 1094 insertions, 26 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/GsmCdmaPhone.java b/src/java/com/android/internal/telephony/GsmCdmaPhone.java index 6fd13fbc74..620b8711e2 100644 --- a/src/java/com/android/internal/telephony/GsmCdmaPhone.java +++ b/src/java/com/android/internal/telephony/GsmCdmaPhone.java @@ -254,6 +254,7 @@ public class GsmCdmaPhone extends Phone { CellBroadcastConfigTracker.make(this, null, true); private boolean mIsNullCipherAndIntegritySupported = false; + private boolean mIsIdentifierDisclosureTransparencySupported = false; // Create Cfu (Call forward unconditional) so that dialing number & // mOnComplete (Message object passed by client) can be packed & @@ -3144,6 +3145,7 @@ public class GsmCdmaPhone extends Phone { mCi.areUiccApplicationsEnabled(obtainMessage(EVENT_GET_UICC_APPS_ENABLEMENT_DONE)); handleNullCipherEnabledChange(); + handleIdentifierDisclosureNotificationPreferenceChange(); } private void handleRadioOn() { @@ -3610,14 +3612,7 @@ public class GsmCdmaPhone extends Phone { case EVENT_SET_NULL_CIPHER_AND_INTEGRITY_DONE: logd("EVENT_SET_NULL_CIPHER_AND_INTEGRITY_DONE"); ar = (AsyncResult) msg.obj; - // Only test for a success here in order to flip the support flag. - // Testing for the negative case, e.g. REQUEST_NOT_SUPPORTED, is insufficient - // because the modem or the RIL could still return exceptions for temporary - // failures even when the feature is unsupported. - if (ar == null || ar.exception == null) { - mIsNullCipherAndIntegritySupported = true; - return; - } + mIsNullCipherAndIntegritySupported = doesResultIndicateModemSupport(ar); break; case EVENT_IMS_DEREGISTRATION_TRIGGERED: @@ -3701,11 +3696,25 @@ public class GsmCdmaPhone extends Phone { } break; + case EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE: + logd("EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE"); + ar = (AsyncResult) msg.obj; + mIsIdentifierDisclosureTransparencySupported = doesResultIndicateModemSupport(ar); + break; + default: super.handleMessage(msg); } } + private boolean doesResultIndicateModemSupport(AsyncResult ar) { + // We can only say that the modem supports a call without ambiguity if there + // is no exception set on the response. Testing for REQUEST_NOT_SUPPORTED, is + // insufficient because the modem or the RIL could still return exceptions for temporary + // failures even when the feature is unsupported. + return (ar == null || ar.exception == null); + } + private void parseImeiInfo(Message msg) { AsyncResult ar = (AsyncResult)msg.obj; if (ar.exception != null || ar.result == null) { @@ -5298,7 +5307,31 @@ public class GsmCdmaPhone extends Phone { } @Override + public void handleIdentifierDisclosureNotificationPreferenceChange() { + if (!mFeatureFlags.enableIdentifierDisclosureTransparency()) { + logi("Not handling identifier disclosure preference change. Feature flag " + + "ENABLE_IDENTIFIER_DISCLOSURE_TRANSPARENCY disabled"); + return; + } + boolean prefEnabled = getIdentifierDisclosureNotificationsPreferenceEnabled(); + + if (prefEnabled) { + mIdentifierDisclosureNotifier.enable(); + } else { + mIdentifierDisclosureNotifier.disable(); + } + + mCi.setCellularIdentifierTransparencyEnabled(prefEnabled, + obtainMessage(EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE)); + } + + @Override public boolean isNullCipherAndIntegritySupported() { return mIsNullCipherAndIntegritySupported; } + + @Override + public boolean isIdentifierDisclosureTransparencySupported() { + return mIsIdentifierDisclosureTransparencySupported; + } } diff --git a/src/java/com/android/internal/telephony/Phone.java b/src/java/com/android/internal/telephony/Phone.java index cc1d4a4297..d94473824e 100644 --- a/src/java/com/android/internal/telephony/Phone.java +++ b/src/java/com/android/internal/telephony/Phone.java @@ -255,7 +255,8 @@ public abstract class Phone extends Handler implements PhoneInternalInterface { protected static final int EVENT_SET_N1_MODE_ENABLED_DONE = 70; protected static final int EVENT_IMEI_MAPPING_CHANGED = 71; protected static final int EVENT_CELL_IDENTIFIER_DISCLOSURE = 72; - protected static final int EVENT_LAST = EVENT_CELL_IDENTIFIER_DISCLOSURE; + protected static final int EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE = 73; + protected static final int EVENT_LAST = EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE; // For shared prefs. private static final String GSM_ROAMING_LIST_OVERRIDE_PREFIX = "gsm_roaming_list_"; @@ -286,6 +287,9 @@ public abstract class Phone extends Handler implements PhoneInternalInterface { "pref_null_cipher_and_integrity_enabled"; private final TelephonyAdminReceiver m2gAdminUpdater; + public static final String PREF_IDENTIFIER_DISCLOSURE_NOTIFICATIONS_ENABLED = + "pref_identifier_disclosure_notifications_enabled"; + protected final FeatureFlags mFeatureFlags; /** @@ -5149,6 +5153,28 @@ public abstract class Phone extends Handler implements PhoneInternalInterface { } /** + * @return whether or not this Phone interacts with a modem that supports the cellular + * identifier disclosure transparency feature. + */ + public boolean isIdentifierDisclosureTransparencySupported() { + return false; + } + + /** + * @return global cellular identifier disclosure transparency enabled preference + */ + public boolean getIdentifierDisclosureNotificationsPreferenceEnabled() { + SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext()); + return sp.getBoolean(PREF_IDENTIFIER_DISCLOSURE_NOTIFICATIONS_ENABLED, false); + } + + /** + * Override to handle an update to the cellular identifier disclosure transparency preference. + */ + public void handleIdentifierDisclosureNotificationPreferenceChange() { + } + + /** * Notifies the IMS call status to the modem. * * @param imsCallInfo The list of {@link ImsCallInfo}. diff --git a/src/java/com/android/internal/telephony/RIL.java b/src/java/com/android/internal/telephony/RIL.java index e608e4dfe7..5177adb3b9 100644 --- a/src/java/com/android/internal/telephony/RIL.java +++ b/src/java/com/android/internal/telephony/RIL.java @@ -1559,7 +1559,7 @@ public class RIL extends BaseCommands implements CommandsInterface { public void getSystemSelectionChannels(Message result) { RadioNetworkProxy networkProxy = getRadioServiceProxy(RadioNetworkProxy.class); if (!canMakeRequest("getSystemSelectionChannels", networkProxy, result, - RADIO_HAL_VERSION_1_4)) { + RADIO_HAL_VERSION_1_6)) { return; } diff --git a/src/java/com/android/internal/telephony/SignalStrengthController.java b/src/java/com/android/internal/telephony/SignalStrengthController.java index 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/domainselection/NormalCallDomainSelectionConnection.java b/src/java/com/android/internal/telephony/domainselection/NormalCallDomainSelectionConnection.java index 516d6b9b89..0532a05d41 100644 --- a/src/java/com/android/internal/telephony/domainselection/NormalCallDomainSelectionConnection.java +++ b/src/java/com/android/internal/telephony/domainselection/NormalCallDomainSelectionConnection.java @@ -22,9 +22,11 @@ import android.annotation.NonNull; import android.annotation.Nullable; import android.telephony.AccessNetworkConstants.RadioAccessNetworkType; import android.telephony.Annotation.DisconnectCauses; +import android.telephony.DisconnectCause; import android.telephony.DomainSelectionService; import android.telephony.DomainSelectionService.EmergencyScanType; import android.telephony.NetworkRegistrationInfo; +import android.telephony.PreciseDisconnectCause; import android.telephony.ims.ImsReasonInfo; import com.android.internal.telephony.Phone; @@ -37,6 +39,9 @@ import java.util.concurrent.CompletableFuture; public class NormalCallDomainSelectionConnection extends DomainSelectionConnection { private static final boolean DBG = false; + private int mDisconnectCause = DisconnectCause.NOT_VALID; + private int mPreciseDisconnectCause = PreciseDisconnectCause.NOT_VALID; + private String mReasonMessage = null; private @Nullable DomainSelectionConnectionCallback mCallback; @@ -123,4 +128,49 @@ public class NormalCallDomainSelectionConnection extends DomainSelectionConnecti } return builder.build(); } + + /** + * Save call disconnect info for error propagation. + * @param disconnectCause The code for the reason for the disconnect. + * @param preciseDisconnectCause The code for the precise reason for the disconnect. + * @param reasonMessage Description of the reason for the disconnect, not intended for the user + * to see. + */ + public void setDisconnectCause(int disconnectCause, int preciseDisconnectCause, + String reasonMessage) { + mDisconnectCause = disconnectCause; + mPreciseDisconnectCause = preciseDisconnectCause; + mReasonMessage = reasonMessage; + } + + public int getDisconnectCause() { + return mDisconnectCause; + } + + public int getPreciseDisconnectCause() { + return mPreciseDisconnectCause; + } + + public String getReasonMessage() { + return mReasonMessage; + } + + /** + * @return imsReasonInfo Reason for the IMS call failure. + */ + public @Nullable ImsReasonInfo getImsReasonInfo() { + if (getSelectionAttributes() == null) { + // Neither selectDomain(...) nor reselectDomain(...) has been called yet. + return null; + } + + return getSelectionAttributes().getPsDisconnectCause(); + } + + /** + * @return phoneId To support localized message based on phoneId + */ + public int getPhoneId() { + return getPhone().getPhoneId(); + } } diff --git a/src/java/com/android/internal/telephony/imsphone/ImsPhoneCallTracker.java b/src/java/com/android/internal/telephony/imsphone/ImsPhoneCallTracker.java index 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/src/java/com/android/internal/telephony/metrics/MetricsCollector.java b/src/java/com/android/internal/telephony/metrics/MetricsCollector.java index 21b2cea397..8bd25475b0 100644 --- a/src/java/com/android/internal/telephony/metrics/MetricsCollector.java +++ b/src/java/com/android/internal/telephony/metrics/MetricsCollector.java @@ -53,6 +53,7 @@ import static com.android.internal.telephony.TelephonyStatsLog.UCE_EVENT_STATS; import static com.android.internal.telephony.TelephonyStatsLog.VOICE_CALL_RAT_USAGE; import static com.android.internal.telephony.TelephonyStatsLog.VOICE_CALL_SESSION; import static com.android.internal.telephony.TelephonyStatsLog.VOICE_CALL_SESSION__CALL_DURATION__CALL_DURATION_UNKNOWN; +import static com.android.internal.telephony.util.TelephonyUtils.IS_DEBUGGABLE; import android.annotation.NonNull; import android.app.StatsManager; @@ -138,16 +139,33 @@ public class MetricsCollector implements StatsManager.StatsPullAtomCallback { DBG ? 10L * MILLIS_PER_SECOND : 23L * MILLIS_PER_HOUR; /** + * Sets atom pull cool down to 4 minutes for userdebug build. + * + * <p>Applies to certain atoms: CellularServiceState. + */ + private static final long CELL_SERVICE_MIN_COOLDOWN_MILLIS = + DBG ? 10L * MILLIS_PER_SECOND : + IS_DEBUGGABLE ? 4L * MILLIS_PER_MINUTE : 23L * MILLIS_PER_HOUR; + + /** * Buckets with less than these many calls will be dropped. * * <p>Applies to metrics with duration fields. Currently used by voice call RAT usages. */ private static final long MIN_CALLS_PER_BUCKET = DBG ? 0L : 5L; - /** Bucket size in milliseconds to round call durations into. */ + /** Bucket size in milliseconds to round call durations info. */ private static final long DURATION_BUCKET_MILLIS = DBG ? 2L * MILLIS_PER_SECOND : 5L * MILLIS_PER_MINUTE; + /** + * Sets smaller bucket size to round call durations for userdebug build. + * + * <p>Applies to certain atoms: CellularServiceState. + */ + private static final long CELL_SERVICE_DURATION_BUCKET_MILLIS = + DBG || IS_DEBUGGABLE ? 2L * MILLIS_PER_SECOND : 5L * MILLIS_PER_MINUTE; + private final PersistAtomsStorage mStorage; private final DeviceStateHelper mDeviceStateHelper; private final StatsManager mStatsManager; @@ -521,7 +539,7 @@ public class MetricsCollector implements StatsManager.StatsPullAtomCallback { // Include the latest durations concludeServiceStateStats(); CellularServiceState[] persistAtoms = - mStorage.getCellularServiceStates(MIN_COOLDOWN_MILLIS); + mStorage.getCellularServiceStates(CELL_SERVICE_MIN_COOLDOWN_MILLIS); if (persistAtoms != null) { // list is already shuffled when instances were inserted Arrays.stream(persistAtoms) @@ -941,7 +959,8 @@ public class MetricsCollector implements StatsManager.StatsPullAtomCallback { state.simSlotIndex, state.isMultiSim, state.carrierId, - roundAndConvertMillisToSeconds(state.totalTimeMillis), + roundAndConvertMillisToSeconds(state.totalTimeMillis, + CELL_SERVICE_DURATION_BUCKET_MILLIS), state.isEmergencyOnly, state.isInternetPdnUp, state.foldState, @@ -1377,8 +1396,15 @@ public class MetricsCollector implements StatsManager.StatsPullAtomCallback { * Rounds the duration and converts it from milliseconds to seconds. */ private static int roundAndConvertMillisToSeconds(long valueMillis) { - long roundedValueMillis = Math.round((double) valueMillis / DURATION_BUCKET_MILLIS) - * DURATION_BUCKET_MILLIS; + return roundAndConvertMillisToSeconds(valueMillis, DURATION_BUCKET_MILLIS); + } + + /** + * Rounds the duration and converts it from milliseconds to seconds. + */ + private static int roundAndConvertMillisToSeconds(long valueMillis, long durationBucketSize) { + long roundedValueMillis = Math.round((double) valueMillis / durationBucketSize) + * durationBucketSize; return (int) (roundedValueMillis / MILLIS_PER_SECOND); } diff --git a/src/java/com/android/internal/telephony/security/CellularIdentifierDisclosureNotifier.java b/src/java/com/android/internal/telephony/security/CellularIdentifierDisclosureNotifier.java index 46e6a28e97..f1845c5bdf 100644 --- a/src/java/com/android/internal/telephony/security/CellularIdentifierDisclosureNotifier.java +++ b/src/java/com/android/internal/telephony/security/CellularIdentifierDisclosureNotifier.java @@ -34,6 +34,7 @@ public class CellularIdentifierDisclosureNotifier { private static final String TAG = "CellularIdentifierDisclosureNotifier"; private static CellularIdentifierDisclosureNotifier sInstance = null; + private boolean mEnabled = false; @VisibleForTesting public CellularIdentifierDisclosureNotifier() {} @@ -59,4 +60,27 @@ public class CellularIdentifierDisclosureNotifier { return sInstance; } + + /** + * Re-enable if previously disabled. This means that {@code addDisclsoure} will start tracking + * disclosures again and potentially emitting notifications. + */ + public void enable() { + Rlog.d(TAG, "enabled"); + mEnabled = true; + } + + /** + * Clear all internal state and prevent further notifications until optionally re-enabled. + * This can be used to in response to a user disabling the feature to emit notifications. + * If {@code addDisclosure} is called while in a disabled state, disclosures will be dropped. + */ + public void disable() { + Rlog.d(TAG, "disabled"); + mEnabled = false; + } + + public boolean isEnabled() { + return mEnabled; + } } diff --git a/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaPhoneTest.java b/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaPhoneTest.java index c8510eb0eb..935da5ac7b 100644 --- a/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaPhoneTest.java +++ b/tests/telephonytests/src/com/android/internal/telephony/GsmCdmaPhoneTest.java @@ -21,6 +21,7 @@ import static com.android.internal.telephony.CommandsInterface.CF_REASON_UNCONDI import static com.android.internal.telephony.Phone.EVENT_ICC_CHANGED; import static com.android.internal.telephony.Phone.EVENT_IMS_DEREGISTRATION_TRIGGERED; import static com.android.internal.telephony.Phone.EVENT_RADIO_AVAILABLE; +import static com.android.internal.telephony.Phone.EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE; import static com.android.internal.telephony.Phone.EVENT_SET_NULL_CIPHER_AND_INTEGRITY_DONE; import static com.android.internal.telephony.Phone.EVENT_SRVCC_STATE_CHANGED; import static com.android.internal.telephony.Phone.EVENT_UICC_APPS_ENABLEMENT_STATUS_CHANGED; @@ -2858,4 +2859,82 @@ public class GsmCdmaPhoneTest extends TelephonyTest { verify(mIdentifierDisclosureNotifier, never()) .addDisclosure(any(CellularIdentifierDisclosure.class)); } + + @Test + public void testCellularIdentifierDisclosure_noModemCallOnRadioAvailable_FlagOff() { + when(mFeatureFlags.enableIdentifierDisclosureTransparency()).thenReturn(false); + GsmCdmaPhone phoneUT = makeNewPhoneUT(); + assertFalse(phoneUT.isIdentifierDisclosureTransparencySupported()); + + sendRadioAvailableToPhone(phoneUT); + + verify(mMockCi, never()).setCellularIdentifierTransparencyEnabled(anyBoolean(), + any(Message.class)); + assertFalse(phoneUT.isIdentifierDisclosureTransparencySupported()); + } + + @Test + public void testCellularIdentifierDisclosure_unsupportedByModemOnRadioAvailable() { + when(mFeatureFlags.enableIdentifierDisclosureTransparency()).thenReturn(true); + GsmCdmaPhone phoneUT = makeNewPhoneUT(); + assertFalse(phoneUT.isIdentifierDisclosureTransparencySupported()); + + // The following block emulates incoming messages from the modem in the case that + // the modem does not support the new HAL APIs. We expect the phone instance to attempt + // to set cipher-identifier-transparency-enabled state when the radio becomes available. + sendRadioAvailableToPhone(phoneUT); + verify(mMockCi, times(1)).setCellularIdentifierTransparencyEnabled(anyBoolean(), + any(Message.class)); + sendRequestNotSupportedToPhone(phoneUT, EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE); + + assertFalse(phoneUT.isIdentifierDisclosureTransparencySupported()); + } + + @Test + public void testCellularIdentifierDisclosure_supportedByModem() { + when(mFeatureFlags.enableIdentifierDisclosureTransparency()).thenReturn(true); + GsmCdmaPhone phoneUT = makeNewPhoneUT(); + assertFalse(phoneUT.isIdentifierDisclosureTransparencySupported()); + + // The following block emulates incoming messages from the modem in the case that + // the modem supports the new HAL APIs. We expect the phone instance to attempt + // to set cipher-identifier-transparency-enabled state when the radio becomes available. + sendRadioAvailableToPhone(phoneUT); + verify(mMockCi, times(1)).setCellularIdentifierTransparencyEnabled(anyBoolean(), + any(Message.class)); + sendIdentifierDisclosureEnabledSuccessToPhone(phoneUT); + + assertTrue(phoneUT.isIdentifierDisclosureTransparencySupported()); + } + + private void sendRadioAvailableToPhone(GsmCdmaPhone phone) { + phone.sendMessage(phone.obtainMessage(EVENT_RADIO_AVAILABLE, + new AsyncResult(null, new int[]{ServiceState.RIL_RADIO_TECHNOLOGY_GSM}, null))); + processAllMessages(); + } + + private void sendRequestNotSupportedToPhone(GsmCdmaPhone phone, int eventId) { + phone.sendMessage(phone.obtainMessage(eventId, new AsyncResult(null, null, + new CommandException(CommandException.Error.REQUEST_NOT_SUPPORTED)))); + processAllMessages(); + } + + private void sendIdentifierDisclosureEnabledSuccessToPhone(GsmCdmaPhone phone) { + phone.sendMessage(phone.obtainMessage(EVENT_SET_IDENTIFIER_DISCLOSURE_ENABLED_DONE, + new AsyncResult(null, null, null))); + processAllMessages(); + } + + private GsmCdmaPhone makeNewPhoneUT() { + return new GsmCdmaPhone( + mContext, + mMockCi, + mNotifier, + true, + 0, + PhoneConstants.PHONE_TYPE_GSM, + mTelephonyComponentFactory, + (c, p) -> mImsManager, + mFeatureFlags); + } } diff --git a/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthControllerTest.java b/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthControllerTest.java index 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()); } } diff --git a/tests/telephonytests/src/com/android/internal/telephony/metrics/MetricsCollectorTest.java b/tests/telephonytests/src/com/android/internal/telephony/metrics/MetricsCollectorTest.java index 2a8c597287..0e1135e3f7 100644 --- a/tests/telephonytests/src/com/android/internal/telephony/metrics/MetricsCollectorTest.java +++ b/tests/telephonytests/src/com/android/internal/telephony/metrics/MetricsCollectorTest.java @@ -23,6 +23,7 @@ import static com.android.internal.telephony.TelephonyStatsLog.SIM_SLOT_STATE; import static com.android.internal.telephony.TelephonyStatsLog.SUPPORTED_RADIO_ACCESS_FAMILY; import static com.android.internal.telephony.TelephonyStatsLog.VOICE_CALL_RAT_USAGE; import static com.android.internal.telephony.TelephonyStatsLog.VOICE_CALL_SESSION; +import static com.android.internal.telephony.util.TelephonyUtils.IS_DEBUGGABLE; import static com.google.common.truth.Truth.assertThat; @@ -67,6 +68,8 @@ public class MetricsCollectorTest extends TelephonyTest { .setCoolDownMillis(24L * 3600L * 1000L) .build(); private static final long MIN_COOLDOWN_MILLIS = 23L * 3600L * 1000L; + private static final long CELL_SERVICE_MIN_COOLDOWN_MILLIS = + IS_DEBUGGABLE ? 4L * 60L * 1000L : MIN_COOLDOWN_MILLIS; private static final long MIN_CALLS_PER_BUCKET = 5L; // NOTE: these fields are currently 32-bit internally and padded to 64-bit by TelephonyManager @@ -401,7 +404,8 @@ public class MetricsCollectorTest extends TelephonyTest { assertThat(actualAtoms).hasSize(0); assertThat(result).isEqualTo(StatsManager.PULL_SKIP); - verify(mPersistAtomsStorage, times(1)).getCellularServiceStates(eq(MIN_COOLDOWN_MILLIS)); + verify(mPersistAtomsStorage, times(1)).getCellularServiceStates( + eq(CELL_SERVICE_MIN_COOLDOWN_MILLIS)); verifyNoMoreInteractions(mPersistAtomsStorage); } |