• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2023 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.telephony.satellite.cts;
18 
19 import static android.telephony.mockmodem.MockSimService.MOCK_SIM_PROFILE_ID_TWN_CHT;
20 import static android.telephony.satellite.SatelliteManager.SATELLITE_COMMUNICATION_RESTRICTION_REASON_ENTITLEMENT;
21 import static android.telephony.satellite.SatelliteManager.SATELLITE_COMMUNICATION_RESTRICTION_REASON_GEOLOCATION;
22 import static android.telephony.satellite.SatelliteManager.SATELLITE_DISALLOWED_REASON_UNSUPPORTED_DEFAULT_MSG_APP;
23 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_ACCESS_BARRED;
24 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_DISABLE_IN_PROGRESS;
25 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_ENABLE_IN_PROGRESS;
26 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_LOCATION_DISABLED;
27 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_MODEM_ERROR;
28 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_NO_RESOURCES;
29 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_REQUEST_ABORTED;
30 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_REQUEST_IN_PROGRESS;
31 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_REQUEST_NOT_SUPPORTED;
32 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_SUCCESS;
33 
34 import static com.android.internal.telephony.satellite.SatelliteController.TIMEOUT_TYPE_DEMO_POINTING_ALIGNED_DURATION_MILLIS;
35 import static com.android.internal.telephony.satellite.SatelliteController.TIMEOUT_TYPE_DEMO_POINTING_NOT_ALIGNED_DURATION_MILLIS;
36 import static com.android.internal.telephony.satellite.SatelliteController.TIMEOUT_TYPE_EVALUATE_ESOS_PROFILES_PRIORITIZATION_DURATION_MILLIS;
37 import static com.android.internal.telephony.satellite.SatelliteController.TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE;
38 
39 import static com.google.common.truth.Truth.assertThat;
40 
41 import static org.junit.Assert.assertArrayEquals;
42 import static org.junit.Assert.assertEquals;
43 import static org.junit.Assert.assertFalse;
44 import static org.junit.Assert.assertNotEquals;
45 import static org.junit.Assert.assertNotNull;
46 import static org.junit.Assert.assertNull;
47 import static org.junit.Assert.assertTrue;
48 import static org.junit.Assert.fail;
49 import static org.junit.Assume.assumeTrue;
50 
51 import android.Manifest;
52 import android.annotation.NonNull;
53 import android.annotation.Nullable;
54 import android.app.AppOpsManager;
55 import android.app.UiAutomation;
56 import android.bluetooth.BluetoothAdapter;
57 import android.content.BroadcastReceiver;
58 import android.content.ComponentName;
59 import android.content.Context;
60 import android.content.Intent;
61 import android.content.IntentFilter;
62 import android.content.pm.PackageManager;
63 import android.hardware.radio.RadioError;
64 import android.location.Location;
65 import android.location.LocationManager;
66 import android.location.provider.ProviderProperties;
67 import android.net.ConnectivityManager;
68 import android.net.wifi.WifiManager;
69 import android.nfc.NfcAdapter;
70 import android.os.Build;
71 import android.os.CancellationSignal;
72 import android.os.OutcomeReceiver;
73 import android.os.PersistableBundle;
74 import android.os.Process;
75 import android.platform.test.annotations.RequiresFlagsEnabled;
76 import android.platform.test.flag.junit.CheckFlagsRule;
77 import android.platform.test.flag.junit.DeviceFlagsValueProvider;
78 import android.provider.Settings;
79 import android.telephony.CarrierConfigManager;
80 import android.telephony.SubscriptionInfo;
81 import android.telephony.SubscriptionManager;
82 import android.telephony.TelephonyManager;
83 import android.telephony.cts.SatelliteReceiver;
84 import android.telephony.cts.TelephonyManagerTest.ServiceStateRadioStateListener;
85 import android.telephony.mockmodem.MockModemManager;
86 import android.telephony.satellite.AntennaDirection;
87 import android.telephony.satellite.AntennaPosition;
88 import android.telephony.satellite.EarfcnRange;
89 import android.telephony.satellite.NtnSignalStrength;
90 import android.telephony.satellite.PointingInfo;
91 import android.telephony.satellite.SatelliteAccessConfiguration;
92 import android.telephony.satellite.SatelliteCapabilities;
93 import android.telephony.satellite.SatelliteDatagram;
94 import android.telephony.satellite.SatelliteInfo;
95 import android.telephony.satellite.SatelliteManager;
96 import android.telephony.satellite.SatellitePosition;
97 import android.telephony.satellite.SatelliteSessionStats;
98 import android.telephony.satellite.SatelliteStateChangeListener;
99 import android.telephony.satellite.SatelliteSubscriberInfo;
100 import android.telephony.satellite.SatelliteSubscriberProvisionStatus;
101 import android.telephony.satellite.SystemSelectionSpecifier;
102 import android.telephony.satellite.stub.NTRadioTechnology;
103 import android.telephony.satellite.stub.SatelliteModemState;
104 import android.telephony.satellite.stub.SatelliteResult;
105 import android.text.TextUtils;
106 import android.util.Log;
107 import android.util.Pair;
108 import android.uwb.UwbManager;
109 
110 import androidx.test.InstrumentationRegistry;
111 
112 import com.android.compatibility.common.util.LocationUtils;
113 import com.android.compatibility.common.util.ShellIdentityUtils;
114 import com.android.internal.telephony.SmsApplication;
115 import com.android.internal.telephony.flags.Flags;
116 import com.android.internal.telephony.satellite.DatagramController;
117 import com.android.internal.telephony.satellite.SatelliteServiceUtils;
118 
119 import org.junit.After;
120 import org.junit.AfterClass;
121 import org.junit.Before;
122 import org.junit.BeforeClass;
123 import org.junit.Ignore;
124 import org.junit.Rule;
125 import org.junit.Test;
126 
127 import java.time.Duration;
128 import java.util.ArrayList;
129 import java.util.Arrays;
130 import java.util.HashMap;
131 import java.util.HashSet;
132 import java.util.List;
133 import java.util.Map;
134 import java.util.Set;
135 import java.util.UUID;
136 import java.util.concurrent.CountDownLatch;
137 import java.util.concurrent.LinkedBlockingQueue;
138 import java.util.concurrent.TimeUnit;
139 import java.util.concurrent.atomic.AtomicReference;
140 
141 public class SatelliteManagerTestOnMockService extends SatelliteManagerTestBase {
142     private static final String ALLOW_MOCK_MODEM_PROPERTY = "persist.radio.allow_mock_modem";
143     private static final boolean DEBUG = !"user".equals(Build.TYPE);
144     private static final long TEST_SATELLITE_LISTENING_TIMEOUT_MILLIS = 100;
145     private static final long TEST_SATELLITE_LISTENING_FOREVER_TIMEOUT_MILLIS = 60 * 10 * 1000;
146     private static final long TEST_SATELLITE_DEVICE_ALIGN_TIMEOUT_MILLIS = 100;
147     private static final long TEST_SATELLITE_DEVICE_ALIGN_FOREVER_TIMEOUT_MILLIS = 100000;
148     private static final long TEST_DATAGRAM_DELAY_IN_DEMO_MODE_TIMEOUT_MILLIS = 100;
149     private static final long TEST_DATAGRAM_DELAY_IN_DEMO_MODE_TIMEOUT_LONG_MILLIS = 1000;
150     private static final long WAIT_FOREVER_TIMEOUT_MILLIS = Duration.ofMinutes(10).toMillis();
151     private static final long MAX_WAIT_FOR_STATE_CHANGED_SECONDS = 5;
152 
153     private static MockSatelliteServiceManager sMockSatelliteServiceManager;
154 
155     /* SatelliteCapabilities constant indicating that the radio technology is proprietary. */
156     private static final Set<Integer> SUPPORTED_RADIO_TECHNOLOGIES;
157 
158     static {
159         SUPPORTED_RADIO_TECHNOLOGIES = new HashSet<>();
160         SUPPORTED_RADIO_TECHNOLOGIES.add(SatelliteManager.NT_RADIO_TECHNOLOGY_PROPRIETARY);
161     }
162 
163     /* SatelliteCapabilities constant indicating that pointing to satellite is required. */
164     private static final boolean POINTING_TO_SATELLITE_REQUIRED = true;
165     /* SatelliteCapabilities constant indicating the maximum number of characters per datagram. */
166     private static final int MAX_BYTES_PER_DATAGRAM = 339;
167     /* SatelliteCapabilites constant antenna position map received from satellite modem. */
168     private static final Map<Integer, AntennaPosition> ANTENNA_POSITION_MAP;
169 
170     static {
171         ANTENNA_POSITION_MAP = new HashMap<>();
ANTENNA_POSITION_MAP.put(SatelliteManager.DISPLAY_MODE_OPENED, new AntennaPosition(new AntennaDirection(1, 1, 1), SatelliteManager.DEVICE_HOLD_POSITION_PORTRAIT))172         ANTENNA_POSITION_MAP.put(SatelliteManager.DISPLAY_MODE_OPENED,
173                 new AntennaPosition(new AntennaDirection(1, 1, 1),
174                         SatelliteManager.DEVICE_HOLD_POSITION_PORTRAIT));
ANTENNA_POSITION_MAP.put(SatelliteManager.DISPLAY_MODE_CLOSED, new AntennaPosition(new AntennaDirection(2, 2, 2), SatelliteManager.DEVICE_HOLD_POSITION_LANDSCAPE_LEFT))175         ANTENNA_POSITION_MAP.put(SatelliteManager.DISPLAY_MODE_CLOSED,
176                 new AntennaPosition(new AntennaDirection(2, 2, 2),
177                         SatelliteManager.DEVICE_HOLD_POSITION_LANDSCAPE_LEFT));
178     }
179 
180     // The test data is stored at
181     // vendor/google/services/ConfigUpdater/assets/cts_data/telephony_config_update/
182     private static final String TEST_V14_CONFIG_DATA_CONTENT_LOCAL_URI =
183             "file:///cts_test_06122024-test-v14-telephony_config.pb";
184     private static final String TEST_V14_CONFIG_DATA_METADATA_LOCAL_URI =
185             "file:///cts_test_06122024-test-v14-telephony_config-metadata.txt";
186     private static final String TEST_V15_CONFIG_DATA_CONTENT_LOCAL_URI =
187             "file:///cts_test_01212025-test-v15-telephony_config.pb";
188     private static final String TEST_V15_CONFIG_DATA_METADATA_LOCAL_URI =
189             "file:///cts_test_01212025-test-v15-telephony_config-metadata.txt";
190 
191     private static CarrierConfigReceiver sCarrierConfigReceiver;
192 
193     private static final int SUB_ID = SubscriptionManager.DEFAULT_SUBSCRIPTION_ID;
194     private static final String OVERRIDING_COUNTRY_CODES = "US";
195     private static final String SATELLITE_COUNTRY_CODES = "US,UK,CA";
196     private static final String SATELLITE_S2_FILE = "google_us_san_sat_s2.dat";
197     private static final String SATELLITE_S2_FILE_WITH_CONFIG_ID =
198             "google_us_san_mtv_sat_s2.dat";
199     private static final String SATELLITE_ACCESS_CONFIGURATION_FILE =
200             "satellite_access_config.json";
201     private static final String TEST_PROVIDER = LocationManager.FUSED_PROVIDER;
202     private static final float LOCATION_ACCURACY = 95;
203     private static LocationManager sLocationManager;
204 
205     BTWifiNFCStateReceiver mBTWifiNFCSateReceiver = null;
206     UwbAdapterStateCallback mUwbAdapterStateCallback = null;
207     private String mTestSatelliteModeRadios = null;
208     boolean mBTInitState = false;
209     boolean mWifiInitState = false;
210     boolean mNfcInitState = false;
211     boolean mUwbInitState = false;
212     @SuppressWarnings("StaticAssignmentOfThrowable")
213     static AssertionError sInitError = null;
214 
215     // Latch to prevent race condition between mIsEnabled state change and verification
216     private CountDownLatch mIsEnabledStateChangedLatch;
217     private boolean mIsEnabled;
218 
219     public class TestSatelliteStateChangeListener implements SatelliteStateChangeListener {
220         @Override
onEnabledStateChanged(boolean isEnabled)221         public void onEnabledStateChanged(boolean isEnabled) {
222             final boolean isEnabledStateChanged = isEnabled != mIsEnabled;
223             mIsEnabled = isEnabled;
224             if (mIsEnabledStateChangedLatch != null && mIsEnabledStateChangedLatch.getCount() > 0
225                     && isEnabledStateChanged) {
226                 mIsEnabledStateChangedLatch.countDown();
227             }
228         }
229     }
230 
231     @Rule
232     public final CheckFlagsRule mCheckFlagsRule =
233             DeviceFlagsValueProvider.createCheckFlagsRule();
234 
235     @BeforeClass
beforeAllTests()236     public static void beforeAllTests() {
237         logd("beforeAllTests");
238 
239         if (!shouldTestSatelliteWithMockService()) return;
240 
241         beforeAllTestsBase();
242         if (!shouldTestSatellite()) {
243             // FEATURE_TELEPHONY_SATELLITE is missing, so let's set up mock SatelliteManager.
244             sSatelliteManager = new SatelliteManager(getContext());
245         }
246         try {
247             MockModemManager.enforceMockModemDeveloperSetting();
248         } catch (Exception e) {
249             sInitError = new AssertionError("enforceMockModemDeveloperSetting failed", e);
250             return;
251         }
252 
253         grantSatellitePermission();
254 
255         sMockSatelliteServiceManager = new MockSatelliteServiceManager(
256                 InstrumentationRegistry.getInstrumentation());
257         setUpSatelliteAccessAllowed();
258         try {
259             setupMockSatelliteService();
260         } catch (AssertionError e) {
261             sInitError = e;
262             return;
263         }
264 
265         sCarrierConfigReceiver = new CarrierConfigReceiver(SUB_ID);
266         sLocationManager = getContext().getSystemService(LocationManager.class);
267 
268         sMockSatelliteServiceManager.setDatagramControllerBooleanConfig(false,
269                 DatagramController.BOOLEAN_TYPE_WAIT_FOR_DEVICE_ALIGNMENT_IN_DEMO_DATAGRAM, true);
270         sNtnOnlySubId = getNtnOnlySubscriptionId();
271         assumeTrue(sNtnOnlySubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID);
272         setUpNtnOnlySubscription();
273 
274         revokeSatellitePermission();
275     }
276 
setupMockSatelliteService()277     private static void setupMockSatelliteService() {
278         assertTrue(sMockSatelliteServiceManager.connectSatelliteService());
279 
280         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
281         int count = 0;
282         while (sSatelliteManager.registerForModemStateChanged(
283                 getContext().getMainExecutor(), callback)
284                 != SatelliteManager.SATELLITE_RESULT_SUCCESS
285                 && count < 10) {
286             count++;
287             waitFor(500);
288         }
289         assertTrue(callback.waitUntilResult(1));
290         if (callback.modemState == SatelliteManager.SATELLITE_MODEM_STATE_OFF) {
291             waitFor(2000);
292         } else {
293             assertTrue(callback.waitUntilModemOff(EXTERNAL_DEPENDENT_TIMEOUT));
294         }
295         sSatelliteManager.unregisterForModemStateChanged(callback);
296 
297         assertTrue(isSatelliteSupported());
298     }
299 
300     @AfterClass
afterAllTests()301     public static void afterAllTests() {
302         logd("afterAllTests");
303         if (sInitError != null) return;
304         if (!shouldTestSatelliteWithMockService()) return;
305 
306         grantSatellitePermission();
307 
308         sMockSatelliteServiceManager.setDatagramControllerBooleanConfig(true,
309                 DatagramController.BOOLEAN_TYPE_WAIT_FOR_DEVICE_ALIGNMENT_IN_DEMO_DATAGRAM, false);
310 
311         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
312         long registerResult = sSatelliteManager.registerForModemStateChanged(
313                 getContext().getMainExecutor(), callback);
314         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
315         assertTrue(callback.waitUntilResult(1));
316 
317         if (isSatelliteEnabled()) {
318             logd("Disable satellite");
319             // Disable satellite modem to clean up all pending resources and reset telephony states.
320             requestSatelliteEnabled(false);
321             assertTrue(callback.waitUntilModemOff());
322             assertFalse(isSatelliteEnabled());
323         }
324 
325         assertTrue(sMockSatelliteServiceManager.restoreSatelliteServicePackageName());
326         waitFor(2000);
327         sSatelliteManager.unregisterForModemStateChanged(callback);
328         resetSatelliteAccessControlOverlayConfigs();
329         resetSatelliteAccessForNtnOnlySubscription();
330         restoreDefaultSmsAppSupportForNtnOnlySubscription();
331         restoreNtnOnlySubscription();
332         assertTrue(sMockSatelliteServiceManager
333                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache(
334                         "cache_clear_and_not_allowed"));
335         afterAllTestsBase();
336         sMockSatelliteServiceManager = null;
337         sCarrierConfigReceiver = null;
338         revokeSatellitePermission();
339     }
340 
341     @Before
setUp()342     public void setUp() throws Exception {
343         logd("setUp");
344         if (sInitError != null) throw sInitError;
345         assumeTrue(shouldTestSatelliteWithMockService());
346         assumeTrue(sMockSatelliteServiceManager != null);
347 
348         assertTrue(sMockSatelliteServiceManager.setSatelliteIgnoreCellularServiceState(true));
349         assertTrue(sMockSatelliteServiceManager.setSatelliteTnScanningSupport(false, false, true));
350         assertTrue(sMockSatelliteServiceManager.setSupportDisableSatelliteWhileEnableInProgress(
351                 false, true));
352 
353         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_SUCCESS);
354         sMockSatelliteServiceManager.setWaitToSend(false);
355         sMockSatelliteServiceManager.setShouldRespondTelephony(true);
356         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
357         sMockSatelliteServiceManager.mIsPointingUiOverridden = false;
358 
359         // Bypass geofence by enforcing SatelliteAccessController to use on-device data with
360         // mock location
361         assertTrue(sMockSatelliteServiceManager
362                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("cache_allowed"));
363         assertTrue(sMockSatelliteServiceManager.setCountryCodes(false, null, null, null, 0));
364         assertTrue(
365                 sMockSatelliteServiceManager.setSatelliteAccessControlOverlayConfigs(
366                         false, true, SATELLITE_S2_FILE, TimeUnit.MINUTES.toNanos(60), "US", null));
367 
368         // Set location provider and current location to Google San Diego office
369         registerTestLocationProvider();
370         setTestProviderLocation(32.909808231041644, -117.18185788819781);
371         verifyIsSatelliteAllowed(true);
372 
373         // Initialize radio state
374         mBTInitState = false;
375         mWifiInitState = false;
376         mNfcInitState = false;
377         mUwbInitState = false;
378         mTestSatelliteModeRadios = "";
379 
380         SatelliteModeRadiosUpdater satelliteRadiosModeUpdater =
381                 new SatelliteModeRadiosUpdater(getContext());
382         assertTrue(satelliteRadiosModeUpdater.setSatelliteModeRadios(""));
383         setUpNtnOnlySubscription();
384 
385         grantSatellitePermission();
386         if (!isSatelliteEnabled()) {
387             logd("Enable satellite");
388 
389             SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
390             long registerResult = sSatelliteManager.registerForModemStateChanged(
391                     getContext().getMainExecutor(), callback);
392             assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
393             assertTrue(callback.waitUntilResult(1));
394 
395             int i = 0;
396             while (requestSatelliteEnabledWithResult(true, EXTERNAL_DEPENDENT_TIMEOUT)
397                     != SatelliteManager.SATELLITE_RESULT_SUCCESS && i < 3) {
398                 waitFor(500);
399                 i++;
400             }
401 
402             assertTrue(callback.waitUntilResult(1));
403             assertTrue(isSatelliteEnabled());
404             sSatelliteManager.unregisterForModemStateChanged(callback);
405             // Set initial mIsEnabled to match the actual satellite state
406             mIsEnabled = true;
407             mIsEnabledStateChangedLatch = new CountDownLatch(1);
408         }
409         logd("Satellite enabled");
410 
411         revokeSatellitePermission();
412     }
413 
414     @After
tearDown()415     public void tearDown() {
416         logd("tearDown");
417         if (!shouldTestSatelliteWithMockService()) return;
418         assumeTrue(sMockSatelliteServiceManager != null);
419         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_SUCCESS);
420         sMockSatelliteServiceManager.setWaitToSend(false);
421         sMockSatelliteServiceManager.setShouldRespondTelephony(true);
422         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
423         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
424 
425         assertTrue(sMockSatelliteServiceManager.setSatelliteIgnoreCellularServiceState(false));
426         assertTrue(sMockSatelliteServiceManager.setSatelliteTnScanningSupport(true, false, false));
427         assertTrue(sMockSatelliteServiceManager.setSupportDisableSatelliteWhileEnableInProgress(
428                 true, false));
429 
430         // Move satellite to off state to clean up all pending resources
431         // and reset telephony states.
432         moveSatelliteToOffState();
433 
434         grantSatellitePermission();
435         sMockSatelliteServiceManager.restoreSatellitePointingUiClassName();
436         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
437         sMockSatelliteServiceManager.clearMockPointingUiActivityStatusChanges();
438         sMockSatelliteServiceManager.clearListeningEnabledList();
439         revokeSatellitePermission();
440         sMockSatelliteServiceManager.mIsPointingUiOverridden = false;
441     }
442 
443     @Test
444     @RequiresFlagsEnabled(Flags.FLAG_SATELLITE_STATE_CHANGE_LISTENER)
testServiceIsPublicAccessible()445     public void testServiceIsPublicAccessible() {
446         if (!shouldTestSatellite()) {
447             return;
448         }
449         SatelliteManager satelliteManager = (SatelliteManager) getContext().getSystemService(
450                 Context.SATELLITE_SERVICE);
451         assertThat(satelliteManager).isNotNull();
452     }
453 
454     @Test
455     @RequiresFlagsEnabled(Flags.FLAG_SATELLITE_STATE_CHANGE_LISTENER)
testRegisterStateChangeListener_unregisterNotRegistered_noOp()456     public void testRegisterStateChangeListener_unregisterNotRegistered_noOp() {
457         if (!shouldTestSatelliteWithMockService()) {
458             return;
459         }
460         SatelliteStateChangeListener listener = new TestSatelliteStateChangeListener();
461         // listener is not registered, unregistering is no-op
462         sSatelliteManager.unregisterStateChangeListener(listener);
463     }
464 
465     @Ignore("b/405225616 - Need to fix and re-enable it.")
466     @Test
467     @RequiresFlagsEnabled(Flags.FLAG_SATELLITE_STATE_CHANGE_LISTENER)
testRegisterStateChangeListener_withReadPhoneStatePermission_noThrows()468     public void testRegisterStateChangeListener_withReadPhoneStatePermission_noThrows() {
469         if (!shouldTestSatelliteWithMockService()) {
470             return;
471         }
472 
473         // READ_PHONE_STATE has been granted for this test suite in AndroidManifest
474         assertThat(getContext().checkSelfPermission(Manifest.permission.READ_PHONE_STATE))
475                 .isEqualTo(PackageManager.PERMISSION_GRANTED);
476         SatelliteStateChangeListener listener = new TestSatelliteStateChangeListener();
477 
478         try {
479             sSatelliteManager.registerStateChangeListener(getContext().getMainExecutor(), listener);
480         } finally {
481             sSatelliteManager.unregisterStateChangeListener(listener);
482         }
483     }
484 
485     @Test
486     @RequiresFlagsEnabled(Flags.FLAG_SATELLITE_STATE_CHANGE_LISTENER)
testStateChangeListener_onRegistration_getNotified()487     public void testStateChangeListener_onRegistration_getNotified() {
488         if (!shouldTestSatelliteWithMockService()) {
489             return;
490         }
491 
492         assertThat(mIsEnabled).isTrue();
493         SatelliteStateChangeListener listener = new TestSatelliteStateChangeListener();
494         try {
495             grantSatelliteAndReadBasicPhoneStatePermissions();
496             requestSatelliteEnabled(false);
497             assertThat(isSatelliteEnabled()).isFalse();
498 
499             sSatelliteManager.registerStateChangeListener(getContext().getMainExecutor(), listener);
500 
501             assertIsEnabledState(true /* expectedIsEnabledStateChanged */,
502                     false /* expectedIsEnabledState */);
503         } finally {
504             // Clean up
505             sSatelliteManager.unregisterStateChangeListener(listener);
506             requestSatelliteEnabled(true);
507             revokeSatellitePermission();
508         }
509     }
510 
511     @Ignore("b/403572869 - This test is flaky. Need to fix and re-enable it.")
512     @Test
513     @RequiresFlagsEnabled(Flags.FLAG_SATELLITE_STATE_CHANGE_LISTENER)
testStateChangeListener_duringRegistration_getNotified()514     public void testStateChangeListener_duringRegistration_getNotified() {
515         if (!shouldTestSatelliteWithMockService()) {
516             return;
517         }
518 
519         assertThat(mIsEnabled).isTrue();
520         SatelliteStateChangeListener listener = new TestSatelliteStateChangeListener();
521         try {
522             grantSatelliteAndReadBasicPhoneStatePermissions();
523             sSatelliteManager.registerStateChangeListener(getContext().getMainExecutor(), listener);
524 
525             requestSatelliteEnabled(false);
526             assertThat(isSatelliteEnabled()).isFalse();
527 
528             assertIsEnabledState(true /* expectedIsEnabledStateChanged */,
529                     false /* expectedIsEnabledState */);
530         } finally {
531             sSatelliteManager.unregisterStateChangeListener(listener);
532             requestSatelliteEnabled(true);
533             revokeSatellitePermission();
534         }
535     }
536 
537     @Test
538     @RequiresFlagsEnabled(Flags.FLAG_SATELLITE_STATE_CHANGE_LISTENER)
testStateChangeListener_afterRegistration_notNotified()539     public void testStateChangeListener_afterRegistration_notNotified() {
540         if (!shouldTestSatelliteWithMockService()) {
541             return;
542         }
543 
544         assertThat(mIsEnabled).isTrue();
545         SatelliteStateChangeListener listener = new TestSatelliteStateChangeListener();
546         try {
547             grantSatelliteAndReadBasicPhoneStatePermissions();
548             sSatelliteManager.registerStateChangeListener(getContext().getMainExecutor(), listener);
549             sSatelliteManager.unregisterStateChangeListener(listener);
550 
551             requestSatelliteEnabled(false);
552             assertThat(isSatelliteEnabled()).isFalse();
553 
554             assertIsEnabledState(false /* expectedIsEnabledStateChanged */,
555                     true /* expectedIsEnabledState */);
556         } finally {
557             // Clean up. If listener has been unregistered, redo it is a no-op
558             sSatelliteManager.unregisterStateChangeListener(listener);
559             requestSatelliteEnabled(true);
560             revokeSatellitePermission();
561         }
562     }
563 
564     @Test
testProvisionSatelliteService()565     public void testProvisionSatelliteService() {
566         logd("testProvisionSatelliteService: start");
567 
568         grantSatellitePermission();
569         try {
570             LinkedBlockingQueue<Integer> error = new LinkedBlockingQueue<>(1);
571             SatelliteProvisionStateCallbackTest satelliteProvisionStateCallback =
572                     new SatelliteProvisionStateCallbackTest();
573             long registerError = sSatelliteManager.registerForProvisionStateChanged(
574                     getContext().getMainExecutor(), satelliteProvisionStateCallback);
575             assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerError);
576             assertTrue(satelliteProvisionStateCallback.waitUntilResult(1));
577 
578             if (isSatelliteProvisioned()) {
579                 logd("testProvisionSatelliteService: dreprovision the device");
580                 deprovisionSatelliteForDevice();
581                 assertTrue(satelliteProvisionStateCallback.waitUntilResult(1));
582                 assertFalse(satelliteProvisionStateCallback.isProvisioned);
583             }
584 
585             logd("testProvisionSatelliteService: successfully provision");
586             satelliteProvisionStateCallback.clearProvisionedStates();
587             assertTrue(provisionSatellite());
588             assertTrue(satelliteProvisionStateCallback.waitUntilResult(1));
589             assertTrue(satelliteProvisionStateCallback.isProvisioned);
590 
591             logd("testProvisionSatelliteService: successfully deprovision");
592             satelliteProvisionStateCallback.clearProvisionedStates();
593             assertTrue(deprovisionSatellite());
594             assertTrue(satelliteProvisionStateCallback.waitUntilResult(1));
595             assertFalse(satelliteProvisionStateCallback.isProvisioned);
596 
597             logd("testProvisionSatelliteService: provision and cancel");
598             satelliteProvisionStateCallback.clearProvisionedStates();
599             CancellationSignal cancellationSignal = new CancellationSignal();
600             String mText = "This is test provision data.";
601             byte[] testProvisionData = mText.getBytes();
602             sSatelliteManager.provisionService(TOKEN, testProvisionData, cancellationSignal,
603                     getContext().getMainExecutor(), error::offer);
604 
605             Integer errorCode;
606             try {
607                 errorCode = error.poll(TIMEOUT, TimeUnit.MILLISECONDS);
608                 cancellationSignal.cancel();
609             } catch (InterruptedException ex) {
610                 fail("testProvisionSatelliteService: Got InterruptedException ex=" + ex);
611                 return;
612             }
613             assertNotNull(errorCode);
614             assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, (long) errorCode);
615 
616             // Provision succeeded and then got canceled - deprovisioned
617             assertTrue(satelliteProvisionStateCallback.waitUntilResult(2));
618             assertEquals(2, satelliteProvisionStateCallback.getTotalCountOfProvisionedStates());
619             assertTrue(satelliteProvisionStateCallback.getProvisionedState(0));
620             assertFalse(satelliteProvisionStateCallback.getProvisionedState(1));
621             assertFalse(satelliteProvisionStateCallback.isProvisioned);
622             assertFalse(isSatelliteProvisioned());
623         } finally {
624             revokeSatellitePermission();
625         }
626     }
627 
628     @Test
testPointingUICrashHandling()629     public void testPointingUICrashHandling() {
630         grantSatellitePermission();
631 
632         assertTrue(isSatelliteProvisioned());
633         assertTrue(isSatelliteEnabled());
634 
635         assertTrue(sMockSatelliteServiceManager.overrideExternalSatellitePointingUiClassName());
636         sMockSatelliteServiceManager.clearMockPointingUiActivityStatusChanges();
637 
638         // Start Pointing UI app
639         sendSatelliteDatagramSuccess(false, false);
640 
641         // Forcefully stop the Pointing UI app
642         sMockSatelliteServiceManager.clearStopPointingUiActivity();
643         assertTrue(sMockSatelliteServiceManager.stopExternalMockPointingUi());
644         assertTrue(sMockSatelliteServiceManager.waitForEventMockPointingUiActivityStopped(1));
645         sMockSatelliteServiceManager.clearMockPointingUiActivityStatusChanges();
646         // Check if the Pointing UI app restarted
647         assertTrue(sMockSatelliteServiceManager.waitForEventMockPointingUiActivityStarted(1));
648 
649         // Kill the Pointing UI app multiple times and check if it is restarted everytime
650         for (int i = 0; i < 10; i++) {
651             sMockSatelliteServiceManager.clearStopPointingUiActivity();
652             // Forcefully stop the Pointing UI app again
653             assertTrue(sMockSatelliteServiceManager.stopExternalMockPointingUi());
654             assertTrue(sMockSatelliteServiceManager.waitForEventMockPointingUiActivityStopped(1));
655             sMockSatelliteServiceManager.clearMockPointingUiActivityStatusChanges();
656             // Check if the Pointing UI app has restarted
657             assertTrue(sMockSatelliteServiceManager.waitForEventMockPointingUiActivityStarted(1));
658         }
659         assertTrue(sMockSatelliteServiceManager.restoreSatellitePointingUiClassName());
660     }
661 
662     @Test
663     @Ignore
testSatelliteRequestEnabled()664     public void testSatelliteRequestEnabled() {
665         assumeTrue(sMockSatelliteServiceManager != null);
666         grantSatellitePermission();
667 
668         /*
669          * When the LocationManager is disabled :
670          * 1) Set location inside or outside of geofence
671          * 2) Check both requestSatelliteEnabled and requestIsCommunicationAllowedForCurrentLocation
672          *  - result is SATELLITE_RESULT_LOCATION_DISABLED
673          */
674         // LocationManager is disabled
675         sLocationManager.setLocationEnabledForUser(false, Process.myUserHandle());
676 
677         // Set current location inside of the geofence data (San Diego office)
678         setTestProviderLocation(32.909808231041644, -117.18185788819781);
679         verifySatelliteNotAllowedErrorReason(SATELLITE_RESULT_LOCATION_DISABLED);
680 
681         int result = requestSatelliteEnabledWithResult(true, TIMEOUT);
682         assertEquals(SatelliteManager.SATELLITE_RESULT_LOCATION_DISABLED, result);
683 
684         // Set current location outside of the geofence data (Bangalore office)
685         setTestProviderLocation(12.997138153769894, 77.66099948612018);
686         verifySatelliteNotAllowedErrorReason(SATELLITE_RESULT_LOCATION_DISABLED);
687 
688         result = requestSatelliteEnabledWithResult(true, TIMEOUT);
689         assertEquals(SatelliteManager.SATELLITE_RESULT_LOCATION_DISABLED, result);
690 
691         /*
692          * When the LocationManager is enabled and cache is valid :
693          * 1) Set location outside of geofence
694          * - The result of requestIsCommunicationAllowedForCurrentLocation is true due to cache
695          * - The result of requestSatelliteEnabled is SATELLITE_RESULT_ACCESS_BARRED
696          * 2) Check the result of requestIsCommunicationAllowedForCurrentLocation once more
697          * - Since the cache is updated as false in
698          */
699         // LocationManager is disabled and cache is valid
700         sLocationManager.setLocationEnabledForUser(true, Process.myUserHandle());
701         assertTrue(sMockSatelliteServiceManager
702                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("cache_allowed"));
703 
704         // Set current location outside of the geofence data (Bangalore office)
705         setTestProviderLocation(12.997138153769894, 77.66099948612018);
706         verifyIsSatelliteAllowed(true);
707 
708         result = requestSatelliteEnabledWithResult(true, TIMEOUT);
709         assertEquals(SATELLITE_RESULT_ACCESS_BARRED, result);
710 
711         verifyIsSatelliteAllowed(false);
712         revokeSatellitePermission();
713     }
714 
715     @Test
testSatelliteModemStateChanged()716     public void testSatelliteModemStateChanged() {
717         grantSatellitePermission();
718 
719         assertTrue(isSatelliteProvisioned());
720 
721         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
722         boolean originalEnabledState = isSatelliteEnabled();
723         boolean registerCallback = false;
724         if (originalEnabledState) {
725             registerCallback = true;
726 
727             long registerResult = sSatelliteManager.registerForModemStateChanged(
728                     getContext().getMainExecutor(), callback);
729             assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
730             assertTrue(callback.waitUntilResult(1));
731 
732             requestSatelliteEnabled(false);
733 
734             assertTrue(callback.waitUntilModemOff());
735             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
736             assertFalse(isSatelliteEnabled());
737             callback.clearModemStates();
738         }
739         if (!registerCallback) {
740             long registerResult = sSatelliteManager
741                     .registerForModemStateChanged(getContext().getMainExecutor(),
742                             callback);
743             assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
744             assertTrue(callback.waitUntilResult(1));
745             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
746         }
747 
748         assertTrue(sMockSatelliteServiceManager.connectSatelliteGatewayService());
749         assertTrue(sMockSatelliteServiceManager.overrideSatellitePointingUiClassName());
750         sMockSatelliteServiceManager.clearMockPointingUiActivityStatusChanges();
751         requestSatelliteEnabled(true);
752 
753         assertTrue(callback.waitUntilResult(2));
754         assertEquals(2, callback.getTotalCountOfModemStates());
755         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
756                 callback.getModemState(0));
757         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback.getModemState(1));
758         assertTrue(isSatelliteEnabled());
759         assertTrue(sMockSatelliteServiceManager.waitForRemoteSatelliteGatewayServiceConnected(1));
760         assertTrue(sMockSatelliteServiceManager.restoreSatellitePointingUiClassName());
761 
762         SatelliteModemStateCallbackTest
763                 callback1 = new SatelliteModemStateCallbackTest();
764         long registerResult = sSatelliteManager
765                 .registerForModemStateChanged(getContext().getMainExecutor(), callback1);
766         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
767         assertTrue(callback1.waitUntilResult(1));
768         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback1.modemState);
769         sSatelliteManager.unregisterForModemStateChanged(callback);
770 
771         assertTrue(sMockSatelliteServiceManager.setSatelliteListeningTimeoutDuration(
772                 TEST_SATELLITE_LISTENING_TIMEOUT_MILLIS));
773 
774         // Verify state transitions: IDLE -> TRANSFERRING -> LISTENING -> IDLE
775         sendSatelliteDatagramWithSuccessfulResult(callback1, true);
776 
777         assertTrue(sMockSatelliteServiceManager.setSatelliteListeningTimeoutDuration(
778                 TEST_SATELLITE_LISTENING_FOREVER_TIMEOUT_MILLIS));
779 
780         // Move to LISTENING state
781         sendSatelliteDatagramWithSuccessfulResult(callback1, false);
782 
783         // Verify state transitions: LISTENING -> TRANSFERRING -> LISTENING
784         receiveSatelliteDatagramWithSuccessfulResult(callback1);
785 
786         // Verify state transitions: LISTENING -> TRANSFERRING -> IDLE
787         sendSatelliteDatagramWithFailedResult(callback1);
788 
789         // Move to LISTENING state
790         sendSatelliteDatagramWithSuccessfulResult(callback1, false);
791 
792         // Verify state transitions: LISTENING -> TRANSFERRING -> IDLE
793         receiveSatelliteDatagramWithFailedResult(callback1);
794 
795         callback1.clearModemStates();
796         requestSatelliteEnabled(false);
797         assertTrue(callback1.waitUntilModemOff());
798         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback1.modemState);
799         assertFalse(isSatelliteEnabled());
800         assertTrue(
801                 sMockSatelliteServiceManager.waitForRemoteSatelliteGatewayServiceDisconnected(1));
802 
803         sSatelliteManager.unregisterForModemStateChanged(callback1);
804         assertTrue(sMockSatelliteServiceManager.setSatelliteListeningTimeoutDuration(0));
805         assertTrue(sMockSatelliteServiceManager.restoreSatelliteGatewayServicePackageName());
806 
807         revokeSatellitePermission();
808     }
809 
810     @Test
testSatelliteModemStateChangedForNbIot()811     public void testSatelliteModemStateChangedForNbIot() {
812         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
813 
814         try {
815             grantSatellitePermission();
816             assertTrue(isSatelliteProvisioned());
817 
818             SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
819             boolean originalEnabledState = isSatelliteEnabled();
820             boolean registerCallback = false;
821             if (originalEnabledState) {
822                 registerCallback = true;
823 
824                 long registerResult = sSatelliteManager.registerForModemStateChanged(
825                         getContext().getMainExecutor(), callback);
826                 assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
827                 assertTrue(callback.waitUntilResult(1));
828 
829                 requestSatelliteEnabled(false);
830 
831                 assertTrue(callback.waitUntilModemOff());
832                 assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
833                 assertFalse(isSatelliteEnabled());
834                 callback.clearModemStates();
835             }
836             if (!registerCallback) {
837                 long registerResult = sSatelliteManager
838                         .registerForModemStateChanged(getContext().getMainExecutor(),
839                                 callback);
840                 assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
841                 assertTrue(callback.waitUntilResult(1));
842                 assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
843             }
844 
845             assertTrue(sMockSatelliteServiceManager.connectSatelliteGatewayService());
846             assertTrue(sMockSatelliteServiceManager.overrideSatellitePointingUiClassName());
847             sMockSatelliteServiceManager.clearMockPointingUiActivityStatusChanges();
848             requestSatelliteEnabled(true);
849             assertTrue(callback.waitUntilResult(2));
850             assertEquals(2, callback.getTotalCountOfModemStates());
851             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
852                     callback.getModemState(0));
853             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED,
854                     callback.getModemState(1));
855             assertTrue(isSatelliteEnabled());
856             assertTrue(
857                     sMockSatelliteServiceManager.waitForRemoteSatelliteGatewayServiceConnected(1));
858             assertTrue(sMockSatelliteServiceManager.restoreSatellitePointingUiClassName());
859 
860             callback.clearModemStates();
861             requestSatelliteEnabled(false);
862             assertTrue(callback.waitUntilResult(2));
863             assertEquals(2, callback.getTotalCountOfModemStates());
864             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
865                     callback.getModemState(0));
866             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(1));
867             assertFalse(isSatelliteEnabled());
868 
869             assertTrue(sMockSatelliteServiceManager.setSatelliteListeningTimeoutDuration(
870                     TEST_SATELLITE_LISTENING_TIMEOUT_MILLIS));
871 
872             // Verify state transitions: OFF -> ENABLING_SATELLITE -> NOT_CONNECTED -> IDLE
873             callback.clearModemStates();
874             requestSatelliteEnabled(true);
875             assertTrue(callback.waitUntilResult(3));
876             assertTrue(isSatelliteEnabled());
877             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
878                     callback.getModemState(0));
879             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED,
880                     callback.getModemState(1));
881             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE,
882                     callback.getModemState(2));
883 
884             callback.clearModemStates();
885             requestSatelliteEnabled(false);
886             assertTrue(callback.waitUntilResult(2));
887             assertEquals(2, callback.getTotalCountOfModemStates());
888             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
889                     callback.getModemState(0));
890             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(1));
891             assertFalse(isSatelliteEnabled());
892 
893             assertTrue(sMockSatelliteServiceManager.setSatelliteListeningTimeoutDuration(
894                     TEST_SATELLITE_LISTENING_FOREVER_TIMEOUT_MILLIS));
895 
896             callback.clearModemStates();
897             requestSatelliteEnabled(true);
898             assertTrue(callback.waitUntilResult(2));
899             assertEquals(2, callback.getTotalCountOfModemStates());
900             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
901                     callback.getModemState(0));
902             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED,
903                     callback.getModemState(1));
904             assertTrue(isSatelliteEnabled());
905 
906             assertTrue(sMockSatelliteServiceManager.setSatelliteListeningTimeoutDuration(
907                     TEST_SATELLITE_LISTENING_TIMEOUT_MILLIS));
908 
909             // Verify state transitions when sending: NOT_CONNECTED -> CONNECTED -> TRANSFERRING
910             // -> CONNECTED -> IDLE
911             sMockSatelliteServiceManager.clearListeningEnabledList();
912             callback.clearModemStates();
913             sendDatagramWithoutResponse();
914             verifyNbIotStateTransitionsWithSendingOnConnected(callback, true);
915 
916             // Verify state transitions when receiving: IDLE -> NOT_CONNECTED -> CONNECTED
917             // -> TRANSFERRING -> CONNECTED -> IDLE
918             verifyNbIotStateTransitionsWithReceivingOnIdle(callback, true);
919 
920             // TODO (b/399426859): Re-enable this test once the bug is fixed.
921             // Verify no state transition on IDLE state
922             // verifyNbIotStateTransitionsWithTransferringFailureOnIdle(callback);
923 
924             // Verify state transition: IDLE -> NOT_CONNECTED -> POWER_OFF
925             verifyNbIotStateTransitionsWithSendingAborted(callback);
926 
927             // Verify state transitions: POWER_OFF -> NOT_CONNECTED
928             callback.clearModemStates();
929             requestSatelliteEnabled(true);
930             assertTrue(callback.waitUntilResult(2));
931             assertEquals(2, callback.getTotalCountOfModemStates());
932             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
933                     callback.getModemState(0));
934             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED,
935                     callback.getModemState(1));
936             assertTrue(isSatelliteEnabled());
937 
938             assertTrue(sMockSatelliteServiceManager.setSatelliteListeningTimeoutDuration(
939                     TEST_SATELLITE_LISTENING_FOREVER_TIMEOUT_MILLIS));
940 
941             // Verify state transitions when sending: NOT_CONNECTED -> CONNECTED -> TRANSFERRING
942             // -> CONNECTED
943             sMockSatelliteServiceManager.clearListeningEnabledList();
944             callback.clearModemStates();
945             sendDatagramWithoutResponse();
946             verifyNbIotStateTransitionsWithSendingOnConnected(callback, false);
947 
948             // Verify state transitions: CONNECTED -> POWER_OFF
949             callback.clearModemStates();
950             requestSatelliteEnabled(false);
951             assertTrue(callback.waitUntilResult(2));
952             assertEquals(2, callback.getTotalCountOfModemStates());
953             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
954                     callback.getModemState(0));
955             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(1));
956             assertFalse(isSatelliteEnabled());
957             assertTrue(
958                     sMockSatelliteServiceManager.waitForRemoteSatelliteGatewayServiceDisconnected(
959                             1));
960 
961             // Verify state transitions: POWER_OFF -> NOT_CONNECTED
962             callback.clearModemStates();
963             requestSatelliteEnabled(true);
964             assertTrue(callback.waitUntilResult(2));
965             assertEquals(2, callback.getTotalCountOfModemStates());
966             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
967                     callback.getModemState(0));
968             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED,
969                     callback.getModemState(1));
970             assertTrue(isSatelliteEnabled());
971 
972             // Move to CONNECTED state
973             callback.clearModemStates();
974             sMockSatelliteServiceManager.sendOnSatelliteModemStateChanged(
975                     SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED);
976             assertTrue(callback.waitUntilResult(1));
977             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED, callback.modemState);
978 
979             // Verify state transitions: CONNECTED -> TRANSFERRING -> CONNECTED
980             verifyNbIotStateTransitionsWithReceivingOnConnected(callback);
981 
982             sSatelliteManager.unregisterForModemStateChanged(callback);
983             assertTrue(sMockSatelliteServiceManager.setSatelliteListeningTimeoutDuration(0));
984             assertTrue(sMockSatelliteServiceManager.restoreSatelliteGatewayServicePackageName());
985             updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
986         } finally {
987             revokeSatellitePermission();
988         }
989     }
990 
991     @Test
testSendKeepAliveDatagramInNotConnectedState()992     public void testSendKeepAliveDatagramInNotConnectedState() {
993         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
994 
995         grantSatellitePermission();
996         assertTrue(isSatelliteProvisioned());
997 
998         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
999         boolean originalEnabledState = isSatelliteEnabled();
1000         boolean registerCallback = false;
1001         if (originalEnabledState) {
1002             registerCallback = true;
1003 
1004             long registerResult = sSatelliteManager.registerForModemStateChanged(
1005                     getContext().getMainExecutor(), callback);
1006             assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
1007             assertTrue(callback.waitUntilResult(1));
1008 
1009             requestSatelliteEnabled(false);
1010 
1011             assertTrue(callback.waitUntilModemOff());
1012             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
1013             assertFalse(isSatelliteEnabled());
1014             callback.clearModemStates();
1015         }
1016         if (!registerCallback) {
1017             long registerResult = sSatelliteManager
1018                     .registerForModemStateChanged(getContext().getMainExecutor(),
1019                             callback);
1020             assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
1021             assertTrue(callback.waitUntilResult(1));
1022             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
1023         }
1024 
1025         assertTrue(sMockSatelliteServiceManager.connectSatelliteGatewayService());
1026         assertTrue(sMockSatelliteServiceManager.overrideSatellitePointingUiClassName());
1027         sMockSatelliteServiceManager.clearMockPointingUiActivityStatusChanges();
1028         requestSatelliteEnabled(true);
1029         assertTrue(callback.waitUntilResult(2));
1030         assertEquals(2, callback.getTotalCountOfModemStates());
1031         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
1032                 callback.getModemState(0));
1033         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED,
1034                 callback.getModemState(1));
1035         assertTrue(isSatelliteEnabled());
1036         assertTrue(sMockSatelliteServiceManager.waitForRemoteSatelliteGatewayServiceConnected(1));
1037         assertTrue(sMockSatelliteServiceManager.restoreSatellitePointingUiClassName());
1038 
1039         SatelliteTransmissionUpdateCallbackTest datagramCallback = startTransmissionUpdates();
1040         String mText = "This is a test datagram message from user";
1041         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
1042         LinkedBlockingQueue<Integer> sosResultListener = new LinkedBlockingQueue<>(1);
1043         LinkedBlockingQueue<Integer> keepAliveResultListener = new LinkedBlockingQueue<>(1);
1044         sMockSatelliteServiceManager.clearMockPointingUiActivityStatusChanges();
1045         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
1046 
1047         // Send SOS satellite datagram
1048         datagramCallback.clearSendDatagramRequested();
1049         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
1050                 datagram, true, getContext().getMainExecutor(),
1051                 sosResultListener::offer);
1052 
1053         // Expected datagram transfer state transitions: IDLE -> WAITING_FOR_CONNECTED
1054         assertTrue(datagramCallback.waitUntilOnSendDatagramStateChanged(1));
1055         assertThat(datagramCallback.getNumOfSendDatagramStateChanges()).isEqualTo(1);
1056         assertThat(datagramCallback.getSendDatagramStateChange(0)).isEqualTo(
1057                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1058                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_WAITING_TO_CONNECT,
1059                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1060         assertTrue(datagramCallback.waitUntilOnSendDatagramRequested(1));
1061         assertEquals(1, datagramCallback.getNumOfSendDatagramRequestedChanges());
1062         assertEquals(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
1063                 datagramCallback.getSendDatagramRequestedType(0));
1064 
1065         // Send keepAlive satellite datagram
1066         datagramCallback.clearSendDatagramStateChanges();
1067         datagramCallback.clearSendDatagramRequested();
1068         callback.clearModemStates();
1069         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_KEEP_ALIVE,
1070                 datagram, true, getContext().getMainExecutor(),
1071                 keepAliveResultListener::offer);
1072         assertTrue(datagramCallback.waitUntilOnSendDatagramRequested(1));
1073         assertEquals(1, datagramCallback.getNumOfSendDatagramRequestedChanges());
1074         assertEquals(SatelliteManager.DATAGRAM_TYPE_KEEP_ALIVE,
1075                 datagramCallback.getSendDatagramRequestedType(0));
1076 
1077         // Modem state state should not be updated
1078         assertFalse(callback.waitUntilResult(1));
1079         // WAITING_FOR_CONNECTED will be broadcasted again after sending the keepAlive
1080         // datagram
1081         assertTrue(datagramCallback.waitUntilOnSendDatagramStateChanged(1));
1082         assertThat(datagramCallback.getNumOfSendDatagramStateChanges()).isEqualTo(1);
1083         assertThat(datagramCallback.getSendDatagramStateChange(0)).isEqualTo(
1084                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1085                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_WAITING_TO_CONNECT,
1086                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1087 
1088         Integer errorCode;
1089         try {
1090             errorCode = keepAliveResultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
1091         } catch (InterruptedException ex) {
1092             fail("testSendSatelliteDatagram_success: Got InterruptedException in waiting"
1093                     + " for the sendDatagram result code");
1094             return;
1095         }
1096         assertNotNull(errorCode);
1097         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
1098         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
1099 
1100         // Move satellite to CONNECTED state
1101         datagramCallback.clearSendDatagramStateChanges();
1102         sMockSatelliteServiceManager.sendOnSatelliteModemStateChanged(
1103                 SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED);
1104 
1105         // The SOS datagram should be sent
1106         int expectedNumberOfEvents = 3;
1107         assertTrue(callback.waitUntilResult(expectedNumberOfEvents));
1108         assertEquals(expectedNumberOfEvents, callback.getTotalCountOfModemStates());
1109         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED,
1110                 callback.getModemState(0));
1111         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DATAGRAM_TRANSFERRING,
1112                 callback.getModemState(1));
1113         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED,
1114                 callback.getModemState(2));
1115 
1116         // Expected datagram transfer state transitions: WAITING_FOR_CONNECTED -> SENDING
1117         // -> SEND_SUCCESS -> IDLE
1118         assertTrue(datagramCallback.waitUntilOnSendDatagramStateChanged(3));
1119         assertThat(datagramCallback.getNumOfSendDatagramStateChanges()).isEqualTo(3);
1120         assertThat(datagramCallback.getSendDatagramStateChange(0)).isEqualTo(
1121                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1122                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
1123                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1124         assertThat(datagramCallback.getSendDatagramStateChange(1)).isEqualTo(
1125                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1126                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_SUCCESS,
1127                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1128         assertThat(datagramCallback.getSendDatagramStateChange(2)).isEqualTo(
1129                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1130                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
1131                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1132 
1133         sSatelliteManager.stopTransmissionUpdates(datagramCallback, getContext().getMainExecutor(),
1134                 keepAliveResultListener::offer);
1135         sSatelliteManager.unregisterForModemStateChanged(callback);
1136         assertTrue(sMockSatelliteServiceManager.setSatelliteListeningTimeoutDuration(0));
1137         assertTrue(sMockSatelliteServiceManager.restoreSatelliteGatewayServicePackageName());
1138         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
1139         revokeSatellitePermission();
1140     }
1141 
sendDatagramWithoutResponse()1142     private void sendDatagramWithoutResponse() {
1143         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
1144                 startTransmissionUpdates();
1145 
1146         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
1147         String mText = "This is a test datagram message from user";
1148         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
1149 
1150         transmissionUpdateCallback.clearSendDatagramRequested();
1151         sSatelliteManager.sendDatagram(
1152                 SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE, datagram, true,
1153                 getContext().getMainExecutor(), resultListener::offer);
1154         assertTrue(transmissionUpdateCallback.waitUntilOnSendDatagramRequested(1));
1155         assertEquals(1, transmissionUpdateCallback.getNumOfSendDatagramRequestedChanges());
1156         assertEquals(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
1157                 transmissionUpdateCallback.getSendDatagramRequestedType(0));
1158 
1159         Integer errorCode;
1160         try {
1161             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
1162         } catch (InterruptedException ex) {
1163             fail("sendDatagramWithoutResponse: Got InterruptedException in waiting"
1164                     + " for the sendDatagram result code, ex=" + ex);
1165             return;
1166         }
1167         assertNull(errorCode);
1168 
1169         // Expected datagram transfer state transitions: IDLE -> WAITING_FOR_CONNECTED
1170         assertTrue(transmissionUpdateCallback.waitUntilOnSendDatagramStateChanged(1));
1171         assertThat(transmissionUpdateCallback.getNumOfSendDatagramStateChanges()).isEqualTo(1);
1172         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(0)).isEqualTo(
1173                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1174                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_WAITING_TO_CONNECT,
1175                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1176 
1177         stopTransmissionUpdates(transmissionUpdateCallback);
1178     }
1179 
verifyNbIotStateTransitionsWithSendingOnConnected( @onNull SatelliteModemStateCallbackTest callback, boolean moveToIdleState)1180     private void verifyNbIotStateTransitionsWithSendingOnConnected(
1181             @NonNull SatelliteModemStateCallbackTest callback, boolean moveToIdleState) {
1182         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.modemState);
1183         callback.clearModemStates();
1184 
1185         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
1186                 startTransmissionUpdates();
1187 
1188         // Move satellite to CONNECTED state
1189         sMockSatelliteServiceManager.sendOnSatelliteModemStateChanged(
1190                 SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED);
1191 
1192         int expectedNumberOfEvents = moveToIdleState ? 4 : 3;
1193         assertTrue(callback.waitUntilResult(expectedNumberOfEvents));
1194         assertEquals(expectedNumberOfEvents, callback.getTotalCountOfModemStates());
1195         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED,
1196                 callback.getModemState(0));
1197         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DATAGRAM_TRANSFERRING,
1198                 callback.getModemState(1));
1199         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED,
1200                 callback.getModemState(2));
1201         if (moveToIdleState) {
1202             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE,
1203                     callback.getModemState(3));
1204         }
1205 
1206         // Expected datagram transfer state transitions: WAITING_FOR_CONNECTED -> SENDING
1207         // -> SEND_SUCCESS -> IDLE
1208         assertTrue(transmissionUpdateCallback.waitUntilOnSendDatagramStateChanged(3));
1209         assertThat(transmissionUpdateCallback.getNumOfSendDatagramStateChanges()).isEqualTo(3);
1210         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(0)).isEqualTo(
1211                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1212                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
1213                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1214         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(1)).isEqualTo(
1215                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1216                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_SUCCESS,
1217                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1218         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(2)).isEqualTo(
1219                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1220                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
1221                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1222 
1223         stopTransmissionUpdates(transmissionUpdateCallback);
1224     }
1225 
verifyNbIotStateTransitionsWithTransferringFailureOnIdle( @onNull SatelliteModemStateCallbackTest callback)1226     private void verifyNbIotStateTransitionsWithTransferringFailureOnIdle(
1227             @NonNull SatelliteModemStateCallbackTest callback) {
1228         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback.modemState);
1229 
1230         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
1231                 startTransmissionUpdates();
1232 
1233         // Test sending failure
1234         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
1235         String mText = "This is a test datagram message from user";
1236         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
1237 
1238         callback.clearModemStates();
1239         sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(false,
1240                 DatagramController.TIMEOUT_TYPE_DATAGRAM_WAIT_FOR_CONNECTED_STATE, 1000);
1241         // Return failure for the request to disable cellular scanning when exiting IDLE state.
1242         sMockSatelliteServiceManager.setEnableCellularScanningErrorCode(
1243                 SatelliteManager.SATELLITE_RESULT_SERVICE_ERROR);
1244         sSatelliteManager.sendDatagram(
1245                 SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE, datagram, true,
1246                 getContext().getMainExecutor(), resultListener::offer);
1247 
1248         assertFalse(callback.waitUntilResult(1));
1249         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback.modemState);
1250 
1251         // Expected datagram transfer state transitions: IDLE -> WAITING_FOR_CONNECTED -> FAILED
1252         // -> IDLE.
1253         assertTrue(transmissionUpdateCallback.waitUntilOnSendDatagramStateChanged(3));
1254         assertThat(transmissionUpdateCallback.getNumOfSendDatagramStateChanges()).isEqualTo(3);
1255         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(0)).isEqualTo(
1256                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1257                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_WAITING_TO_CONNECT,
1258                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1259         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(1)).isEqualTo(
1260                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1261                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_FAILED,
1262                         1, SatelliteManager.SATELLITE_RESULT_NOT_REACHABLE));
1263         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(2)).isEqualTo(
1264                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1265                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
1266                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1267 
1268         // Datagram wait for connected state timer should have timed out and the send request should
1269         // have been aborted.
1270         Integer errorCode;
1271         try {
1272             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
1273         } catch (InterruptedException ex) {
1274             fail("verifyNbIotStateTransitionsWithTransferringFailureOnIdle: Got "
1275                     + "InterruptedException in waiting for the sendDatagram result code"
1276                     + ", ex=" + ex);
1277             return;
1278         }
1279         assertNotNull(errorCode);
1280         assertEquals(SatelliteManager.SATELLITE_RESULT_NOT_REACHABLE, (long) errorCode);
1281 
1282         // Test receiving failure
1283         resultListener.clear();
1284         sMockSatelliteServiceManager.setEnableCellularScanningErrorCode(
1285                 SatelliteResult.SATELLITE_RESULT_ERROR);
1286         callback.clearModemStates();
1287         sSatelliteManager.pollPendingDatagrams(getContext().getMainExecutor(),
1288                 resultListener::offer);
1289 
1290         assertFalse(callback.waitUntilResult(1));
1291         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback.modemState);
1292 
1293         assertTrue(transmissionUpdateCallback
1294                 .waitUntilOnReceiveDatagramStateChanged(3));
1295         assertThat(transmissionUpdateCallback.getNumOfReceiveDatagramStateChanges())
1296                 .isEqualTo(3);
1297         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(0)).isEqualTo(
1298                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1299                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_WAITING_TO_CONNECT,
1300                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1301         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(1)).isEqualTo(
1302                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1303                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVE_FAILED,
1304                         0, SatelliteManager.SATELLITE_RESULT_NOT_REACHABLE));
1305         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(2)).isEqualTo(
1306                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1307                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
1308                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1309 
1310         // Datagram wait for connected state timer should have timed out and the poll request should
1311         // have been aborted.
1312         try {
1313             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
1314         } catch (InterruptedException ex) {
1315             fail("verifyNbIotStateTransitionsWithTransferringFailureOnIdle: Got "
1316                     + "InterruptedException in waiting for the pollPendingDatagrams result"
1317                     + " code, ex=" + ex);
1318             return;
1319         }
1320         assertNotNull(errorCode);
1321         assertEquals(SatelliteManager.SATELLITE_RESULT_NOT_REACHABLE, (long) errorCode);
1322 
1323         sMockSatelliteServiceManager.setEnableCellularScanningErrorCode(
1324                 SatelliteManager.SATELLITE_RESULT_SUCCESS);
1325         sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(true,
1326                 DatagramController.TIMEOUT_TYPE_DATAGRAM_WAIT_FOR_CONNECTED_STATE, 0);
1327         stopTransmissionUpdates(transmissionUpdateCallback);
1328     }
1329 
verifyNbIotStateTransitionsWithSendingAborted( @onNull SatelliteModemStateCallbackTest callback)1330     private void verifyNbIotStateTransitionsWithSendingAborted(
1331             @NonNull SatelliteModemStateCallbackTest callback) {
1332         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback.modemState);
1333 
1334         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
1335                 startTransmissionUpdates();
1336 
1337         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
1338         String mText = "This is a test datagram message from user";
1339         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
1340 
1341         callback.clearModemStates();
1342         sSatelliteManager.sendDatagram(
1343                 SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE, datagram, true,
1344                 getContext().getMainExecutor(), resultListener::offer);
1345 
1346         Integer errorCode;
1347         try {
1348             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
1349         } catch (InterruptedException ex) {
1350             fail("verifyNbIotStateTransitionsWithSendingAborted: Got InterruptedException"
1351                     + " in waiting for the sendDatagram result code, ex=" + ex);
1352             return;
1353         }
1354         assertNull(errorCode);
1355 
1356         assertTrue(callback.waitUntilResult(1));
1357         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.modemState);
1358 
1359         // Turn off satellite modem. The send request should be aborted.
1360         callback.clearModemStates();
1361         sMockSatelliteServiceManager.sendOnSatelliteModemStateChanged(
1362                 SatelliteManager.SATELLITE_MODEM_STATE_OFF);
1363 
1364         try {
1365             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
1366         } catch (InterruptedException ex) {
1367             fail("verifyNbIotStateTransitionsWithSendingAborted: Got InterruptedException"
1368                     + " in waiting for the sendDatagram result code, ex=" + ex);
1369             return;
1370         }
1371         assertNotNull(errorCode);
1372         assertEquals(SATELLITE_RESULT_REQUEST_ABORTED, (long) errorCode);
1373 
1374         // Expected datagram transfer state transitions: IDLE -> WAITING_FOR_CONNECTED -> FAILED
1375         // -> IDLE.
1376         assertTrue(transmissionUpdateCallback.waitUntilOnSendDatagramStateChanged(3));
1377         assertThat(transmissionUpdateCallback.getNumOfSendDatagramStateChanges()).isEqualTo(3);
1378         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(0)).isEqualTo(
1379                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1380                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_WAITING_TO_CONNECT,
1381                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1382         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(1)).isEqualTo(
1383                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1384                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_FAILED,
1385                         1, SATELLITE_RESULT_REQUEST_ABORTED));
1386         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(2)).isEqualTo(
1387                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1388                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
1389                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1390 
1391         assertTrue(callback.waitUntilResult(1));
1392         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
1393         stopTransmissionUpdates(transmissionUpdateCallback);
1394     }
1395 
verifyNbIotStateTransitionsWithReceivingOnIdle( @onNull SatelliteModemStateCallbackTest callback, boolean moveToIdleState)1396     private void verifyNbIotStateTransitionsWithReceivingOnIdle(
1397             @NonNull SatelliteModemStateCallbackTest callback, boolean moveToIdleState) {
1398         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback.modemState);
1399 
1400         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
1401                 startTransmissionUpdates();
1402 
1403         // Verify state transitions: IDLE -> NOT_CONNECTED
1404         callback.clearModemStates();
1405         sMockSatelliteServiceManager.clearPollPendingDatagramPermits();
1406         sMockSatelliteServiceManager.sendOnPendingDatagrams();
1407         assertFalse(sMockSatelliteServiceManager.waitForEventOnPollPendingSatelliteDatagrams(1));
1408         assertTrue(callback.waitUntilResult(1));
1409         assertEquals(1, callback.getTotalCountOfModemStates());
1410         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.modemState);
1411         // Expected datagram transfer state transitions: IDLE -> WAITING_FOR_CONNECTED
1412         assertTrue(transmissionUpdateCallback
1413                 .waitUntilOnReceiveDatagramStateChanged(1));
1414         assertThat(transmissionUpdateCallback.getNumOfReceiveDatagramStateChanges())
1415                 .isEqualTo(1);
1416         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(0)).isEqualTo(
1417                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1418                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_WAITING_TO_CONNECT,
1419                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1420 
1421         // Verify state transitions: NOT_CONNECTED -> CONNECTED -> TRANSFERRING
1422         callback.clearModemStates();
1423         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
1424         sMockSatelliteServiceManager.sendOnSatelliteModemStateChanged(
1425                 SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED);
1426         assertTrue(callback.waitUntilResult(2));
1427         assertEquals(2, callback.getTotalCountOfModemStates());
1428         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED,
1429                 callback.getModemState(0));
1430         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DATAGRAM_TRANSFERRING,
1431                 callback.getModemState(1));
1432         // Telephony should send the request pollPendingDatagrams to modem
1433         assertTrue(sMockSatelliteServiceManager.waitForEventOnPollPendingSatelliteDatagrams(1));
1434 
1435         // Expected datagram transfer state transitions: WAITING_FOR_CONNECTED -> RECEIVING
1436         assertTrue(transmissionUpdateCallback
1437                 .waitUntilOnReceiveDatagramStateChanged(1));
1438         assertThat(transmissionUpdateCallback.getNumOfReceiveDatagramStateChanges())
1439                 .isEqualTo(1);
1440         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(0)).isEqualTo(
1441                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1442                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVING,
1443                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1444 
1445         verifyNbIotStateTransitionsWithDatagramReceivedOnTransferring(
1446                 callback, moveToIdleState, transmissionUpdateCallback);
1447         stopTransmissionUpdates(transmissionUpdateCallback);
1448     }
1449 
verifyNbIotStateTransitionsWithDatagramReceivedOnTransferring( @onNull SatelliteModemStateCallbackTest callback, boolean moveToIdleState, SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback)1450     private void verifyNbIotStateTransitionsWithDatagramReceivedOnTransferring(
1451             @NonNull SatelliteModemStateCallbackTest callback, boolean moveToIdleState,
1452             SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback) {
1453         assertEquals(
1454                 SatelliteManager.SATELLITE_MODEM_STATE_DATAGRAM_TRANSFERRING, callback.modemState);
1455 
1456         SatelliteDatagramCallbackTest satelliteDatagramCallback =
1457                 new SatelliteDatagramCallbackTest();
1458         sSatelliteManager.registerForIncomingDatagram(
1459                 getContext().getMainExecutor(), satelliteDatagramCallback);
1460 
1461         String receivedText = "This is a test datagram message from satellite";
1462         android.telephony.satellite.stub.SatelliteDatagram receivedDatagram =
1463                 new android.telephony.satellite.stub.SatelliteDatagram();
1464         receivedDatagram.data = receivedText.getBytes();
1465 
1466         callback.clearModemStates();
1467         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
1468         sMockSatelliteServiceManager.sendOnSatelliteDatagramReceived(receivedDatagram, 0);
1469 
1470         assertTrue(satelliteDatagramCallback.waitUntilResult(1));
1471         assertArrayEquals(satelliteDatagramCallback.mDatagram.getSatelliteDatagram(),
1472                 receivedText.getBytes());
1473 
1474         int expectedNumberOfEvents = moveToIdleState ? 2 : 1;
1475         assertTrue(callback.waitUntilResult(expectedNumberOfEvents));
1476         assertEquals(expectedNumberOfEvents, callback.getTotalCountOfModemStates());
1477         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED,
1478                 callback.getModemState(0));
1479         if (moveToIdleState) {
1480             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE,
1481                     callback.getModemState(1));
1482         }
1483 
1484         // Expected datagram transfer state transitions: RECEIVING -> RECEIVE_SUCCESS -> IDLE
1485         assertTrue(transmissionUpdateCallback
1486                 .waitUntilOnReceiveDatagramStateChanged(2));
1487         assertThat(transmissionUpdateCallback.getNumOfReceiveDatagramStateChanges())
1488                 .isEqualTo(2);
1489         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(0)).isEqualTo(
1490                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1491                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVE_SUCCESS,
1492                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1493         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(1)).isEqualTo(
1494                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1495                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
1496                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1497 
1498         sSatelliteManager.unregisterForIncomingDatagram(satelliteDatagramCallback);
1499     }
1500 
verifyNbIotStateTransitionsWithReceivingOnConnected( @onNull SatelliteModemStateCallbackTest callback)1501     private void verifyNbIotStateTransitionsWithReceivingOnConnected(
1502             @NonNull SatelliteModemStateCallbackTest callback) {
1503         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED, callback.modemState);
1504 
1505         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
1506                 startTransmissionUpdates();
1507 
1508         SatelliteDatagramCallbackTest satelliteDatagramCallback =
1509                 new SatelliteDatagramCallbackTest();
1510         sSatelliteManager.registerForIncomingDatagram(
1511                 getContext().getMainExecutor(), satelliteDatagramCallback);
1512 
1513         String receivedText = "This is a test datagram message from satellite";
1514         android.telephony.satellite.stub.SatelliteDatagram receivedDatagram =
1515                 new android.telephony.satellite.stub.SatelliteDatagram();
1516         receivedDatagram.data = receivedText.getBytes();
1517 
1518         // Verify state transitions: CONNECTED -> TRANSFERRING -> CONNECTED
1519         callback.clearModemStates();
1520         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
1521         sMockSatelliteServiceManager.sendOnSatelliteDatagramReceived(receivedDatagram, 0);
1522 
1523         assertTrue(satelliteDatagramCallback.waitUntilResult(1));
1524         assertArrayEquals(satelliteDatagramCallback.mDatagram.getSatelliteDatagram(),
1525                 receivedText.getBytes());
1526 
1527         int expectedNumberOfEvents = 2;
1528         assertTrue(callback.waitUntilResult(expectedNumberOfEvents));
1529         assertEquals(expectedNumberOfEvents, callback.getTotalCountOfModemStates());
1530         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DATAGRAM_TRANSFERRING,
1531                 callback.getModemState(0));
1532         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED,
1533                 callback.getModemState(1));
1534 
1535         // Expected datagram transfer state transitions: IDLE -> RECEIVE_SUCCESS -> IDLE
1536         assertTrue(transmissionUpdateCallback
1537                 .waitUntilOnReceiveDatagramStateChanged(2));
1538         assertThat(transmissionUpdateCallback.getNumOfReceiveDatagramStateChanges())
1539                 .isEqualTo(2);
1540         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(0)).isEqualTo(
1541                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1542                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVE_SUCCESS,
1543                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1544         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(1)).isEqualTo(
1545                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1546                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
1547                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1548 
1549         sSatelliteManager.unregisterForIncomingDatagram(satelliteDatagramCallback);
1550         stopTransmissionUpdates(transmissionUpdateCallback);
1551     }
1552 
1553     @Test
testSatelliteEnableErrorHandling()1554     public void testSatelliteEnableErrorHandling() {
1555         assumeTrue(sTelephonyManager != null);
1556 
1557         grantSatellitePermission();
1558         assertTrue(isSatelliteProvisioned());
1559 
1560         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
1561         boolean originalEnabledState = isSatelliteEnabled();
1562         boolean registerCallback = false;
1563         if (originalEnabledState) {
1564             registerCallback = true;
1565 
1566             long registerResult = sSatelliteManager.registerForModemStateChanged(
1567                     getContext().getMainExecutor(), callback);
1568             assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
1569             assertTrue(callback.waitUntilResult(1));
1570 
1571             requestSatelliteEnabled(false);
1572 
1573             assertTrue(callback.waitUntilModemOff());
1574             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
1575             assertFalse(isSatelliteEnabled());
1576             callback.clearModemStates();
1577         }
1578         if (!registerCallback) {
1579             long registerResult = sSatelliteManager
1580                     .registerForModemStateChanged(getContext().getMainExecutor(),
1581                             callback);
1582             assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
1583             assertTrue(callback.waitUntilResult(1));
1584             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
1585         }
1586 
1587         callback.clearModemStates();
1588         requestSatelliteEnabled(true, true, SatelliteManager.SATELLITE_RESULT_SUCCESS);
1589         assertTrue(callback.waitUntilResult(2));
1590         assertEquals(2, callback.getTotalCountOfModemStates());
1591         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
1592                 callback.getModemState(0));
1593         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback.getModemState(1));
1594         assertTrue(isSatelliteEnabled());
1595 
1596         requestSatelliteEnabled(true, true, SatelliteManager.SATELLITE_RESULT_SUCCESS);
1597         if (Flags.carrierRoamingNbIotNtn()) {
1598             requestSatelliteEnabled(
1599                     true, false, SatelliteManager.SATELLITE_RESULT_SUCCESS);
1600         } else {
1601             requestSatelliteEnabled(
1602                     true, false, SatelliteManager.SATELLITE_RESULT_INVALID_ARGUMENTS);
1603         }
1604 
1605         callback.clearModemStates();
1606         turnRadioOff();
1607         grantSatellitePermission();
1608         assertTrue(callback.waitUntilResult(2));
1609         assertEquals(2, callback.getTotalCountOfModemStates());
1610         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
1611                 callback.getModemState(0));
1612         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(1));
1613         assertFalse(isSatelliteEnabled());
1614 
1615         // Cannot turn on satellite when radio is OFF
1616         requestSatelliteEnabled(true, true, SatelliteManager.SATELLITE_RESULT_INVALID_MODEM_STATE);
1617         requestSatelliteEnabled(false);
1618 
1619         turnRadioOn();
1620         grantSatellitePermission();
1621         assertFalse(callback.waitUntilResult(2));
1622         assertEquals(2, callback.getTotalCountOfModemStates());
1623         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
1624                 callback.getModemState(0));
1625         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(1));
1626         assertFalse(isSatelliteEnabled());
1627 
1628         callback.clearModemStates();
1629         requestSatelliteEnabled(true, true, SatelliteManager.SATELLITE_RESULT_SUCCESS);
1630         assertTrue(callback.waitUntilResult(2));
1631         assertEquals(2, callback.getTotalCountOfModemStates());
1632         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
1633                 callback.getModemState(0));
1634         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback.getModemState(1));
1635         assertTrue(isSatelliteEnabled());
1636 
1637         callback.clearModemStates();
1638         requestSatelliteEnabled(false);
1639         assertTrue(callback.waitUntilModemOff());
1640         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
1641         assertFalse(isSatelliteEnabled());
1642 
1643         sSatelliteManager.unregisterForModemStateChanged(callback);
1644         revokeSatellitePermission();
1645     }
1646 
1647     @Test
testSatelliteDatagramReceivedAck()1648     public void testSatelliteDatagramReceivedAck() {
1649         grantSatellitePermission();
1650 
1651         assertTrue(isSatelliteProvisioned());
1652 
1653         SatelliteDatagramCallbackTest satelliteDatagramCallback =
1654                 new SatelliteDatagramCallbackTest();
1655         sSatelliteManager.registerForIncomingDatagram(
1656                 getContext().getMainExecutor(), satelliteDatagramCallback);
1657 
1658         String receivedText = "This is a test datagram message from satellite";
1659         android.telephony.satellite.stub.SatelliteDatagram receivedDatagram =
1660                 new android.telephony.satellite.stub.SatelliteDatagram();
1661         receivedDatagram.data = receivedText.getBytes();
1662         sMockSatelliteServiceManager.sendOnSatelliteDatagramReceived(receivedDatagram, 0);
1663 
1664         assertTrue(satelliteDatagramCallback.waitUntilResult(1));
1665         assertArrayEquals(satelliteDatagramCallback.mDatagram.getSatelliteDatagram(),
1666                 receivedText.getBytes());
1667 
1668         // Compute next received datagramId using current ID and verify it is correct.
1669         long nextDatagramId = ((satelliteDatagramCallback.mDatagramId + 1)
1670                 % DatagramController.MAX_DATAGRAM_ID);
1671         sMockSatelliteServiceManager.sendOnSatelliteDatagramReceived(receivedDatagram, 0);
1672         assertTrue(satelliteDatagramCallback.waitUntilResult(1));
1673         assertThat(satelliteDatagramCallback.mDatagramId).isEqualTo(nextDatagramId);
1674 
1675         sSatelliteManager.unregisterForIncomingDatagram(satelliteDatagramCallback);
1676         revokeSatellitePermission();
1677     }
1678 
1679     @Ignore("b/377926997 - This test is failing due to the recent change in capabilities.")
1680     @Test
testRequestSatelliteCapabilities()1681     public void testRequestSatelliteCapabilities() {
1682         logd("testRequestSatelliteCapabilities");
1683         grantSatellitePermission();
1684 
1685         assertTrue(isSatelliteProvisioned());
1686 
1687         final AtomicReference<SatelliteCapabilities> capabilities = new AtomicReference<>();
1688         final AtomicReference<Integer> errorCode = new AtomicReference<>();
1689         OutcomeReceiver<SatelliteCapabilities, SatelliteManager.SatelliteException> receiver =
1690                 new OutcomeReceiver<>() {
1691                     @Override
1692                     public void onResult(SatelliteCapabilities result) {
1693                         logd("testRequestSatelliteCapabilities: onResult");
1694                         capabilities.set(result);
1695 
1696                         assertNotNull(result);
1697                         assertNotNull(result.getSupportedRadioTechnologies());
1698                         assertThat(SUPPORTED_RADIO_TECHNOLOGIES)
1699                                 .isEqualTo(result.getSupportedRadioTechnologies());
1700                         assertThat(POINTING_TO_SATELLITE_REQUIRED)
1701                                 .isEqualTo(result.isPointingRequired());
1702                         assertThat(MAX_BYTES_PER_DATAGRAM)
1703                                 .isEqualTo(result.getMaxBytesPerOutgoingDatagram());
1704                         assertNotNull(result.getAntennaPositionMap());
1705                         assertThat(ANTENNA_POSITION_MAP).isEqualTo(result.getAntennaPositionMap());
1706                     }
1707 
1708                     @Override
1709                     public void onError(SatelliteManager.SatelliteException exception) {
1710                         logd("testRequestSatelliteCapabilities: onError");
1711                         errorCode.set(exception.getErrorCode());
1712                     }
1713                 };
1714 
1715         sMockSatelliteServiceManager.setSupportedRadioTechnologies(
1716                 new int[]{NTRadioTechnology.PROPRIETARY});
1717         sSatelliteManager.requestCapabilities(getContext().getMainExecutor(), receiver);
1718 
1719         revokeSatellitePermission();
1720     }
1721 
1722     @Test
testSendSatelliteDatagram_success()1723     public void testSendSatelliteDatagram_success() {
1724         logd("testSendSatelliteDatagram_success");
1725         grantSatellitePermission();
1726         assertTrue(isSatelliteProvisioned());
1727 
1728         for (int i = 0; i < 5; i++) {
1729             logd("testSendSatelliteDatagram_success: moveToSendingState");
1730             assertTrue(isSatelliteEnabled());
1731             moveToSendingState();
1732 
1733             logd("testSendSatelliteDatagram_success: Disable satellite");
1734             SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
1735             long registerResult = sSatelliteManager.registerForModemStateChanged(
1736                     getContext().getMainExecutor(), callback);
1737             assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
1738             assertTrue(callback.waitUntilResult(1));
1739 
1740             SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
1741                     startTransmissionUpdates();
1742             requestSatelliteEnabled(false);
1743             assertTrue(callback.waitUntilModemOff());
1744             assertFalse(isSatelliteEnabled());
1745             callback.clearModemStates();
1746 
1747             // Datagram transfer state should change from SENDING to FAILED and then IDLE.
1748             assertTrue(transmissionUpdateCallback.waitUntilOnSendDatagramStateChanged(2));
1749             assertThat(transmissionUpdateCallback.getNumOfSendDatagramStateChanges()).isEqualTo(2);
1750             assertThat(transmissionUpdateCallback.getSendDatagramStateChange(0)).isEqualTo(
1751                     new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1752                             SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_FAILED,
1753                             1, SATELLITE_RESULT_REQUEST_ABORTED));
1754             assertThat(transmissionUpdateCallback.getSendDatagramStateChange(1)).isEqualTo(
1755                     new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1756                             SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
1757                             0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1758             stopTransmissionUpdates(transmissionUpdateCallback);
1759 
1760             logd("testSendSatelliteDatagram_success: Enable satellite");
1761             requestSatelliteEnabled(true);
1762             assertTrue(callback.waitUntilResult(2));
1763             assertTrue(isSatelliteEnabled());
1764             sSatelliteManager.unregisterForModemStateChanged(callback);
1765 
1766             logd("testSendSatelliteDatagram_success: sendSatelliteDatagramSuccess");
1767             sendSatelliteDatagramSuccess(true, true);
1768         }
1769         revokeSatellitePermission();
1770     }
1771 
1772     @Test
testSendSatelliteDatagram_failure()1773     public void testSendSatelliteDatagram_failure() {
1774         logd("testSendSatelliteDatagram_failure");
1775         grantSatellitePermission();
1776         assertTrue(isSatelliteProvisioned());
1777 
1778         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
1779         SatelliteTransmissionUpdateCallbackTest callback =
1780                 new SatelliteTransmissionUpdateCallbackTest();
1781         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
1782                 resultListener::offer, callback);
1783         Integer errorCode;
1784         try {
1785             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
1786         } catch (InterruptedException ex) {
1787             fail("testSendSatelliteDatagram_failure: Got InterruptedException in waiting"
1788                     + " for the startSatelliteTransmissionUpdates result code");
1789             return;
1790         }
1791         assertNotNull(errorCode);
1792         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
1793 
1794         // Send satellite datagram
1795         String mText = "This is a test datagram message from user";
1796         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
1797         callback.clearSendDatagramStateChanges();
1798         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_ERROR);
1799         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
1800                 datagram, true, getContext().getMainExecutor(),
1801                 resultListener::offer);
1802 
1803         try {
1804             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
1805         } catch (InterruptedException ex) {
1806             fail("testSendSatelliteDatagram_failure: Got InterruptedException in waiting"
1807                     + " for the sendDatagram result code");
1808             return;
1809         }
1810         assertNotNull(errorCode);
1811         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_ERROR);
1812 
1813         /*
1814          * Send datagram transfer state should have the following transitions:
1815          * 1) SENDING to SENDING_FAILED
1816          * 2) SENDING_FAILED to IDLE
1817          */
1818         int expectedNumOfEvents = 3;
1819         assertTrue(callback.waitUntilOnSendDatagramStateChanged(expectedNumOfEvents));
1820         assertThat(callback.getNumOfSendDatagramStateChanges()).isEqualTo(expectedNumOfEvents);
1821         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
1822                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1823                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
1824                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1825         assertThat(callback.getSendDatagramStateChange(1)).isEqualTo(
1826                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1827                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_FAILED,
1828                         0, SatelliteManager.SATELLITE_RESULT_ERROR));
1829         assertThat(callback.getSendDatagramStateChange(2)).isEqualTo(
1830                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1831                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
1832                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1833 
1834         callback.clearSendDatagramStateChanges();
1835         sSatelliteManager.stopTransmissionUpdates(callback, getContext().getMainExecutor(),
1836                 resultListener::offer);
1837         revokeSatellitePermission();
1838     }
1839 
1840     @Test
testSendMultipleSatelliteDatagrams_success()1841     public void testSendMultipleSatelliteDatagrams_success() {
1842         logd("testSendMultipleSatelliteDatagrams_success");
1843         grantSatellitePermission();
1844         assertTrue(isSatelliteProvisioned());
1845 
1846         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
1847         SatelliteTransmissionUpdateCallbackTest callback =
1848                 new SatelliteTransmissionUpdateCallbackTest();
1849         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
1850                 resultListener::offer, callback);
1851         Integer errorCode;
1852         try {
1853             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
1854         } catch (InterruptedException ex) {
1855             fail("testSendMultipleSatelliteDatagrams_success: Got InterruptedException in waiting"
1856                     + " for the sendDatagram result code");
1857             return;
1858         }
1859         assertNotNull(errorCode);
1860         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
1861 
1862         String mText = "This is a test datagram message from user";
1863         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
1864         callback.clearSendDatagramStateChanges();
1865         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
1866 
1867         // Wait to process datagrams so that datagrams are added to pending list.
1868         sMockSatelliteServiceManager.setWaitToSend(true);
1869 
1870         // Send three datagrams to observe how pendingCount is updated
1871         // after processing one datagram at a time.
1872         callback.clearSendDatagramRequested();
1873         LinkedBlockingQueue<Integer> resultListener1 = new LinkedBlockingQueue<>(1);
1874         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
1875                 datagram, true, getContext().getMainExecutor(),
1876                 resultListener1::offer);
1877         assertTrue(callback.waitUntilOnSendDatagramStateChanged(1));
1878         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
1879                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1880                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
1881                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1882         assertTrue(callback.waitUntilOnSendDatagramRequested(1));
1883         assertEquals(1, callback.getNumOfSendDatagramRequestedChanges());
1884         assertEquals(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
1885                 callback.getSendDatagramRequestedType(0));
1886 
1887         callback.clearSendDatagramStateChanges();
1888         callback.clearSendDatagramRequested();
1889         LinkedBlockingQueue<Integer> resultListener2 = new LinkedBlockingQueue<>(1);
1890         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
1891                 datagram, true, getContext().getMainExecutor(),
1892                 resultListener2::offer);
1893         assertTrue(callback.waitUntilOnSendDatagramRequested(1));
1894         assertEquals(1, callback.getNumOfSendDatagramRequestedChanges());
1895         assertEquals(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
1896                 callback.getSendDatagramRequestedType(0));
1897 
1898         callback.clearSendDatagramRequested();
1899         LinkedBlockingQueue<Integer> resultListener3 = new LinkedBlockingQueue<>(1);
1900         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
1901                 datagram, true, getContext().getMainExecutor(),
1902                 resultListener3::offer);
1903         assertTrue(callback.waitUntilOnSendDatagramRequested(1));
1904         assertEquals(1, callback.getNumOfSendDatagramRequestedChanges());
1905         assertEquals(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
1906                 callback.getSendDatagramRequestedType(0));
1907 
1908         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
1909 
1910         // Send first datagram: SENDING to SENDING_SUCCESS
1911         assertTrue(sMockSatelliteServiceManager.sendSavedDatagram());
1912 
1913         try {
1914             errorCode = resultListener1.poll(TIMEOUT, TimeUnit.MILLISECONDS);
1915         } catch (InterruptedException ex) {
1916             fail("testSendMultipleSatelliteDatagrams_success: Got InterruptedException in waiting"
1917                     + " for the sendDatagram result code");
1918             return;
1919         }
1920         assertNotNull(errorCode);
1921         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
1922 
1923         int expectedNumOfEvents = 1;
1924         assertTrue(callback.waitUntilOnSendDatagramStateChanged(expectedNumOfEvents));
1925 
1926         // Pending count is 2 as there are 2 datagrams to be sent.
1927         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
1928                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1929                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_SUCCESS,
1930                         2, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1931 
1932         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
1933 
1934         // Send second datagram: SENDING to SENDING_SUCCESS
1935         // callback.clearSendDatagramStateChanges();
1936         assertTrue(sMockSatelliteServiceManager.sendSavedDatagram());
1937 
1938         try {
1939             errorCode = resultListener2.poll(TIMEOUT, TimeUnit.MILLISECONDS);
1940         } catch (InterruptedException ex) {
1941             fail("testSendMultipleSatelliteDatagrams_success: Got InterruptedException in waiting"
1942                     + " for the sendDatagram result code");
1943             return;
1944         }
1945         assertNotNull(errorCode);
1946         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
1947 
1948         expectedNumOfEvents = 2;
1949         assertTrue(callback.waitUntilOnSendDatagramStateChanged(expectedNumOfEvents));
1950         assertThat(callback.getSendDatagramStateChange(1)).isEqualTo(
1951                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1952                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
1953                         2, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1954         assertThat(callback.getSendDatagramStateChange(2)).isEqualTo(
1955                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1956                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_SUCCESS,
1957                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1958 
1959         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
1960 
1961         // Send third datagram: SENDING - SENDING_SUCCESS - IDLE
1962         assertTrue(sMockSatelliteServiceManager.sendSavedDatagram());
1963 
1964         try {
1965             errorCode = resultListener3.poll(TIMEOUT, TimeUnit.MILLISECONDS);
1966         } catch (InterruptedException ex) {
1967             fail("testSendMultipleSatelliteDatagrams_success: Got InterruptedException in waiting"
1968                     + " for the sendDatagram result code");
1969             return;
1970         }
1971         assertNotNull(errorCode);
1972         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
1973 
1974         expectedNumOfEvents = 3;
1975         assertTrue(callback.waitUntilOnSendDatagramStateChanged(expectedNumOfEvents));
1976         assertThat(callback.getSendDatagramStateChange(3)).isEqualTo(
1977                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1978                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
1979                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1980         assertThat(callback.getSendDatagramStateChange(4)).isEqualTo(
1981                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1982                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_SUCCESS,
1983                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1984         assertThat(callback.getSendDatagramStateChange(5)).isEqualTo(
1985                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
1986                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
1987                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
1988 
1989         callback.clearSendDatagramStateChanges();
1990         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
1991         sMockSatelliteServiceManager.setWaitToSend(false);
1992         sSatelliteManager.stopTransmissionUpdates(callback, getContext().getMainExecutor(),
1993                 resultListener::offer);
1994         revokeSatellitePermission();
1995     }
1996 
1997     @Test
testSendMultipleSatelliteDatagrams_failure()1998     public void testSendMultipleSatelliteDatagrams_failure() {
1999         logd("testSendMultipleSatelliteDatagrams_failure");
2000         grantSatellitePermission();
2001         assertTrue(isSatelliteProvisioned());
2002 
2003         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
2004         SatelliteTransmissionUpdateCallbackTest callback =
2005                 new SatelliteTransmissionUpdateCallbackTest();
2006         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
2007                 resultListener::offer, callback);
2008         Integer errorCode;
2009         try {
2010             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2011         } catch (InterruptedException ex) {
2012             fail("testSendMultipleSatelliteDatagrams_failure: Got InterruptedException in waiting"
2013                     + " for the sendDatagram result code");
2014             return;
2015         }
2016         assertNotNull(errorCode);
2017         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
2018 
2019         String mText = "This is a test datagram message from user";
2020         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
2021         callback.clearSendDatagramStateChanges();
2022         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
2023 
2024         // Wait to process datagrams so that datagrams are added to pending list.
2025         sMockSatelliteServiceManager.setWaitToSend(true);
2026 
2027         // Send three datagrams to observe how pendingCount is updated
2028         // after processing one datagram at a time.
2029         LinkedBlockingQueue<Integer> resultListener1 = new LinkedBlockingQueue<>(1);
2030         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
2031                 datagram, true, getContext().getMainExecutor(),
2032                 resultListener1::offer);
2033         assertTrue(callback.waitUntilOnSendDatagramStateChanged(1));
2034         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
2035                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2036                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
2037                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2038 
2039         callback.clearSendDatagramStateChanges();
2040         LinkedBlockingQueue<Integer> resultListener2 = new LinkedBlockingQueue<>(1);
2041         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
2042                 datagram, true, getContext().getMainExecutor(),
2043                 resultListener2::offer);
2044         LinkedBlockingQueue<Integer> resultListener3 = new LinkedBlockingQueue<>(1);
2045         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
2046                 datagram, true, getContext().getMainExecutor(),
2047                 resultListener3::offer);
2048 
2049         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
2050 
2051         // Set error and send first datagram: SENDING to SENDING_FAILED
2052         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_ERROR);
2053         assertTrue(sMockSatelliteServiceManager.sendSavedDatagram());
2054 
2055         try {
2056             errorCode = resultListener1.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2057         } catch (InterruptedException ex) {
2058             fail("testSendMultipleSatelliteDatagrams_success: Got InterruptedException in waiting"
2059                     + " for the sendDatagram result code");
2060             return;
2061         }
2062         assertNotNull(errorCode);
2063         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_ERROR);
2064 
2065         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
2066 
2067         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_SUCCESS);
2068         assertTrue(sMockSatelliteServiceManager.sendSavedDatagram());
2069         try {
2070             errorCode = resultListener2.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2071         } catch (InterruptedException ex) {
2072             fail("testSendMultipleSatelliteDatagrams_success: Got InterruptedException in waiting"
2073                     + " for the sendDatagram result code");
2074             return;
2075         }
2076         assertNotNull(errorCode);
2077         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
2078 
2079 
2080         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
2081         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_SUCCESS);
2082         assertTrue(sMockSatelliteServiceManager.sendSavedDatagram());
2083         try {
2084             errorCode = resultListener3.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2085         } catch (InterruptedException ex) {
2086             fail("testSendMultipleSatelliteDatagrams_success: Got InterruptedException in waiting"
2087                     + " for the sendDatagram result code");
2088             return;
2089         }
2090         assertNotNull(errorCode);
2091         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
2092 
2093         assertTrue(callback.waitUntilOnSendDatagramStateChanged(5));
2094         // Pending count is 2 as there are 2 datagrams to be sent.
2095         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
2096                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2097                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_FAILED,
2098                         2, SatelliteManager.SATELLITE_RESULT_ERROR));
2099         assertThat(callback.getSendDatagramStateChange(1)).isEqualTo(
2100                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2101                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
2102                         2, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2103         assertThat(callback.getSendDatagramStateChange(2)).isEqualTo(
2104                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2105                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_SUCCESS,
2106                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2107         assertThat(callback.getSendDatagramStateChange(3)).isEqualTo(
2108                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2109                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
2110                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2111         assertThat(callback.getSendDatagramStateChange(4)).isEqualTo(
2112                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2113                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_SUCCESS,
2114                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2115 
2116         callback.clearSendDatagramStateChanges();
2117         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
2118         sMockSatelliteServiceManager.setWaitToSend(false);
2119         sSatelliteManager.stopTransmissionUpdates(callback, getContext().getMainExecutor(),
2120                 resultListener::offer);
2121         revokeSatellitePermission();
2122     }
2123 
2124 
2125     @Test
testReceiveSatelliteDatagram()2126     public void testReceiveSatelliteDatagram() {
2127         logd("testReceiveSatelliteDatagram");
2128         grantSatellitePermission();
2129         assertTrue(isSatelliteProvisioned());
2130 
2131         for (int i = 0; i < 5; i++) {
2132             logd("testReceiveSatelliteDatagram: moveToReceivingState");
2133             assertTrue(isSatelliteEnabled());
2134             moveToReceivingState();
2135 
2136             logd("testReceiveSatelliteDatagram: Disable satellite");
2137             SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
2138             long registerResult = sSatelliteManager.registerForModemStateChanged(
2139                     getContext().getMainExecutor(), callback);
2140             assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
2141             assertTrue(callback.waitUntilResult(1));
2142 
2143             SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
2144                     startTransmissionUpdates();
2145             requestSatelliteEnabled(false);
2146             assertTrue(callback.waitUntilModemOff());
2147             assertFalse(isSatelliteEnabled());
2148             callback.clearModemStates();
2149 
2150             // Datagram transfer state should change from RECEIVING to IDLE.
2151             assertTrue(transmissionUpdateCallback
2152                     .waitUntilOnReceiveDatagramStateChanged(2));
2153             assertThat(transmissionUpdateCallback.getNumOfReceiveDatagramStateChanges())
2154                     .isEqualTo(2);
2155             assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(0)).isEqualTo(
2156                     new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2157                             SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVE_FAILED,
2158                             0, SATELLITE_RESULT_REQUEST_ABORTED));
2159             assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(1)).isEqualTo(
2160                     new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2161                             SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
2162                             0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2163             stopTransmissionUpdates(transmissionUpdateCallback);
2164 
2165             logd("testReceiveSatelliteDatagram: Enable satellite");
2166             requestSatelliteEnabled(true);
2167             assertTrue(callback.waitUntilResult(1));
2168             assertTrue(isSatelliteEnabled());
2169             sSatelliteManager.unregisterForModemStateChanged(callback);
2170 
2171             logd("testReceiveSatelliteDatagram: receiveSatelliteDatagramSuccess");
2172             receiveSatelliteDatagramSuccess();
2173         }
2174         revokeSatellitePermission();
2175     }
2176 
2177     @Test
testReceiveMultipleSatelliteDatagrams()2178     public void testReceiveMultipleSatelliteDatagrams() {
2179         logd("testReceiveMultipleSatelliteDatagrams");
2180         grantSatellitePermission();
2181         assertTrue(isSatelliteProvisioned());
2182 
2183         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
2184         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
2185                 new SatelliteTransmissionUpdateCallbackTest();
2186         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
2187                 resultListener::offer, transmissionUpdateCallback);
2188         Integer errorCode;
2189         try {
2190             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2191         } catch (InterruptedException ex) {
2192             fail("testReceiveMultipleSatelliteDatagrams: Got InterruptedException in waiting"
2193                     + " for the startSatelliteTransmissionUpdates result code");
2194             return;
2195         }
2196         assertNotNull(errorCode);
2197         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
2198 
2199         SatelliteDatagramCallbackTest satelliteDatagramCallback =
2200                 new SatelliteDatagramCallbackTest();
2201         sSatelliteManager.registerForIncomingDatagram(
2202                 getContext().getMainExecutor(), satelliteDatagramCallback);
2203 
2204         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
2205         sMockSatelliteServiceManager.clearPollPendingDatagramPermits();
2206         sMockSatelliteServiceManager.sendOnPendingDatagrams();
2207 
2208         // Wait for the first datagram to be polled.
2209         assertTrue(sMockSatelliteServiceManager.waitForEventOnPollPendingSatelliteDatagrams(1));
2210 
2211         // Receive first datagram: Datagram state changes from RECEIVING to RECEIVE_SUCCESS
2212         String receivedText = "This is a test datagram message from satellite";
2213         android.telephony.satellite.stub.SatelliteDatagram receivedDatagram =
2214                 new android.telephony.satellite.stub.SatelliteDatagram();
2215         receivedDatagram.data = receivedText.getBytes();
2216         sMockSatelliteServiceManager.clearPollPendingDatagramPermits();
2217         sMockSatelliteServiceManager.sendOnSatelliteDatagramReceived(receivedDatagram, 2);
2218         assertTrue(satelliteDatagramCallback.waitUntilResult(1));
2219         assertArrayEquals(satelliteDatagramCallback.mDatagram.getSatelliteDatagram(),
2220                 receivedText.getBytes());
2221         int expectedNumOfEvents = 2;
2222         assertTrue(transmissionUpdateCallback
2223                 .waitUntilOnReceiveDatagramStateChanged(expectedNumOfEvents));
2224         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(0)).isEqualTo(
2225                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2226                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVING,
2227                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2228         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(1)).isEqualTo(
2229                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2230                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVE_SUCCESS,
2231                         2, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2232 
2233         // Wait for the second datagram to be polled.
2234         assertTrue(sMockSatelliteServiceManager.waitForEventOnPollPendingSatelliteDatagrams(1));
2235 
2236         // Receive second datagram: Datagram state changes from RECEIVING to RECEIVE_SUCCESS
2237         sMockSatelliteServiceManager.clearPollPendingDatagramPermits();
2238         sMockSatelliteServiceManager.sendOnSatelliteDatagramReceived(receivedDatagram, 1);
2239         assertTrue(satelliteDatagramCallback.waitUntilResult(1));
2240         assertArrayEquals(satelliteDatagramCallback.mDatagram.getSatelliteDatagram(),
2241                 receivedText.getBytes());
2242         expectedNumOfEvents = 2;
2243         assertTrue(transmissionUpdateCallback
2244                 .waitUntilOnReceiveDatagramStateChanged(2));
2245         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(2)).isEqualTo(
2246                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2247                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVING,
2248                         2, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2249         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(3)).isEqualTo(
2250                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2251                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVE_SUCCESS,
2252                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2253 
2254         // Wait for the third datagram to be polled.
2255         assertTrue(sMockSatelliteServiceManager.waitForEventOnPollPendingSatelliteDatagrams(1));
2256 
2257         // Receive third datagram: Datagram state changes from RECEIVING - RECEIVE_SUCCESS - IDLE
2258         sMockSatelliteServiceManager.sendOnSatelliteDatagramReceived(receivedDatagram, 0);
2259         assertTrue(satelliteDatagramCallback.waitUntilResult(1));
2260         assertArrayEquals(satelliteDatagramCallback.mDatagram.getSatelliteDatagram(),
2261                 receivedText.getBytes());
2262         expectedNumOfEvents = 3;
2263         assertTrue(transmissionUpdateCallback
2264                 .waitUntilOnReceiveDatagramStateChanged(3));
2265         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(4)).isEqualTo(
2266                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2267                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVING,
2268                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2269         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(5)).isEqualTo(
2270                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2271                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVE_SUCCESS,
2272                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2273         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(6)).isEqualTo(
2274                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2275                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
2276                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2277 
2278         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
2279         sSatelliteManager.stopTransmissionUpdates(transmissionUpdateCallback,
2280                 getContext().getMainExecutor(), resultListener::offer);
2281         sSatelliteManager.unregisterForIncomingDatagram(satelliteDatagramCallback);
2282         revokeSatellitePermission();
2283     }
2284 
2285     @Test
testReceiveSatellitePositionUpdate()2286     public void testReceiveSatellitePositionUpdate() {
2287         logd("testReceiveSatellitePositionUpdate");
2288         grantSatellitePermission();
2289         assertTrue(isSatelliteProvisioned());
2290 
2291         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
2292         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
2293                 new SatelliteTransmissionUpdateCallbackTest();
2294         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
2295                 resultListener::offer, transmissionUpdateCallback);
2296         Integer errorCode;
2297         try {
2298             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2299         } catch (InterruptedException ex) {
2300             fail("testReceiveSatellitePositionUpdate: Got InterruptedException in waiting"
2301                     + " for the startSatelliteTransmissionUpdates result code");
2302             return;
2303         }
2304         assertNotNull(errorCode);
2305         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
2306 
2307         transmissionUpdateCallback.clearPointingInfo();
2308         android.telephony.satellite.stub.PointingInfo pointingInfo =
2309                 new android.telephony.satellite.stub.PointingInfo();
2310         pointingInfo.satelliteAzimuth = 10.5f;
2311         pointingInfo.satelliteElevation = 30.23f;
2312         PointingInfo expectedPointingInfo = new PointingInfo(10.5f, 30.23f);
2313         sMockSatelliteServiceManager.sendOnSatellitePositionChanged(pointingInfo);
2314         assertTrue(transmissionUpdateCallback.waitUntilOnSatellitePositionChanged(1));
2315         assertThat(transmissionUpdateCallback.mPointingInfo.getSatelliteAzimuthDegrees())
2316                 .isEqualTo(expectedPointingInfo.getSatelliteAzimuthDegrees());
2317         assertThat(transmissionUpdateCallback.mPointingInfo.getSatelliteElevationDegrees())
2318                 .isEqualTo(expectedPointingInfo.getSatelliteElevationDegrees());
2319 
2320         transmissionUpdateCallback.clearPointingInfo();
2321         sSatelliteManager.stopTransmissionUpdates(transmissionUpdateCallback,
2322                 getContext().getMainExecutor(), resultListener::offer);
2323         revokeSatellitePermission();
2324     }
2325 
2326     @Test
testReceiveMultipleSatellitePositionUpdates()2327     public void testReceiveMultipleSatellitePositionUpdates() {
2328         logd("testReceiveMultipleSatellitePositionUpdates");
2329         grantSatellitePermission();
2330         assertTrue(isSatelliteProvisioned());
2331 
2332         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
2333         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
2334                 new SatelliteTransmissionUpdateCallbackTest();
2335         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
2336                 resultListener::offer, transmissionUpdateCallback);
2337         Integer errorCode;
2338         try {
2339             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2340         } catch (InterruptedException ex) {
2341             fail("testReceiveMultipleSatellitePositionUpdates: Got InterruptedException in waiting"
2342                     + " for the startSatelliteTransmissionUpdates result code");
2343             return;
2344         }
2345         assertNotNull(errorCode);
2346         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
2347 
2348         // Receive first position update
2349         transmissionUpdateCallback.clearPointingInfo();
2350         android.telephony.satellite.stub.PointingInfo pointingInfo =
2351                 new android.telephony.satellite.stub.PointingInfo();
2352         pointingInfo.satelliteAzimuth = 10.5f;
2353         pointingInfo.satelliteElevation = 30.23f;
2354         PointingInfo expectedPointingInfo = new PointingInfo(10.5f, 30.23f);
2355         sMockSatelliteServiceManager.sendOnSatellitePositionChanged(pointingInfo);
2356         assertTrue(transmissionUpdateCallback.waitUntilOnSatellitePositionChanged(1));
2357         assertThat(transmissionUpdateCallback.mPointingInfo.getSatelliteAzimuthDegrees())
2358                 .isEqualTo(expectedPointingInfo.getSatelliteAzimuthDegrees());
2359         assertThat(transmissionUpdateCallback.mPointingInfo.getSatelliteElevationDegrees())
2360                 .isEqualTo(expectedPointingInfo.getSatelliteElevationDegrees());
2361 
2362         // Receive second position update
2363         transmissionUpdateCallback.clearPointingInfo();
2364         pointingInfo.satelliteAzimuth = 100;
2365         pointingInfo.satelliteElevation = 120;
2366         expectedPointingInfo = new PointingInfo(100, 120);
2367         sMockSatelliteServiceManager.sendOnSatellitePositionChanged(pointingInfo);
2368         assertTrue(transmissionUpdateCallback.waitUntilOnSatellitePositionChanged(1));
2369         assertThat(transmissionUpdateCallback.mPointingInfo.getSatelliteAzimuthDegrees())
2370                 .isEqualTo(expectedPointingInfo.getSatelliteAzimuthDegrees());
2371         assertThat(transmissionUpdateCallback.mPointingInfo.getSatelliteElevationDegrees())
2372                 .isEqualTo(expectedPointingInfo.getSatelliteElevationDegrees());
2373 
2374         transmissionUpdateCallback.clearPointingInfo();
2375         sSatelliteManager.stopTransmissionUpdates(transmissionUpdateCallback,
2376                 getContext().getMainExecutor(), resultListener::offer);
2377         revokeSatellitePermission();
2378     }
2379 
2380     @Test
testSendAndReceiveSatelliteDatagram_DemoMode_success()2381     public void testSendAndReceiveSatelliteDatagram_DemoMode_success() {
2382         logd("testSendSatelliteDatagram_DemoMode_success");
2383         grantSatellitePermission();
2384         assertTrue(isSatelliteProvisioned());
2385         assertTrue(sMockSatelliteServiceManager.overrideSatellitePointingUiClassName());
2386 
2387         String mText = "This is a test datagram message from user";
2388         for (int i = 0; i < 5; i++) {
2389             logd("testSendSatelliteDatagram_DemoMode_success: moveToSendingState");
2390             assertTrue(isSatelliteEnabled());
2391             moveToSendingState();
2392 
2393             logd("testSendSatelliteDatagram_DemoMode_success: Disable satellite");
2394             SatelliteModemStateCallbackTest stateCallback = new SatelliteModemStateCallbackTest();
2395             sSatelliteManager.registerForModemStateChanged(
2396                     getContext().getMainExecutor(), stateCallback);
2397             assertTrue(stateCallback.waitUntilResult(1));
2398 
2399             SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
2400                     startTransmissionUpdates();
2401             requestSatelliteEnabled(false);
2402             assertTrue(stateCallback.waitUntilModemOff());
2403             assertFalse(isSatelliteEnabled());
2404             stateCallback.clearModemStates();
2405 
2406             // Datagram transfer state should change from SENDING to FAILED and then IDLE.
2407             assertTrue(transmissionUpdateCallback.waitUntilOnSendDatagramStateChanged(2));
2408             assertThat(transmissionUpdateCallback.getNumOfSendDatagramStateChanges()).isEqualTo(2);
2409             assertThat(transmissionUpdateCallback.getSendDatagramStateChange(0)).isEqualTo(
2410                     new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2411                             SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_FAILED,
2412                             1, SATELLITE_RESULT_REQUEST_ABORTED));
2413             assertThat(transmissionUpdateCallback.getSendDatagramStateChange(1)).isEqualTo(
2414                     new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2415                             SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
2416                             0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2417             stopTransmissionUpdates(transmissionUpdateCallback);
2418 
2419             logd("testSendSatelliteDatagram_DemoMode_success: Enable satellite");
2420             stateCallback.clearModemStates();
2421             requestSatelliteEnabledForDemoMode(true);
2422             assertTrue(stateCallback.waitUntilResult(2));
2423             assertTrue(isSatelliteEnabled());
2424             assertTrue(getIsEmergency());
2425             sSatelliteManager.unregisterForModemStateChanged(stateCallback);
2426 
2427             logd("testSendSatelliteDatagram_DemoMode_success: sendSatelliteDatagramSuccess");
2428             assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(false,
2429                     DatagramController.TIMEOUT_TYPE_DATAGRAM_DELAY_IN_DEMO_MODE,
2430                     TEST_DATAGRAM_DELAY_IN_DEMO_MODE_TIMEOUT_LONG_MILLIS));
2431             sendSatelliteDatagramDemoModeSuccess(mText);
2432 
2433             // Automatically triggering pollPendingSatelliteDatagrams after successfully sending
2434             // a callback back to sendSatelliteDatagram for demo mode
2435             sSatelliteManager.setDeviceAlignedWithSatellite(true);
2436             transmissionUpdateCallback = startTransmissionUpdates();
2437             SatelliteDatagramCallbackTest datagramCallback = new SatelliteDatagramCallbackTest();
2438             assertTrue(SatelliteManager.SATELLITE_RESULT_SUCCESS
2439                     == sSatelliteManager.registerForIncomingDatagram(getContext().getMainExecutor(),
2440                     datagramCallback));
2441 
2442             // Because pending count is 0, datagram transfer state changes from
2443             // IDLE -> RECEIVING -> RECEIVE_SUCCESS -> IDLE.
2444             int expectedNumOfEvents = 3;
2445             assertTrue(transmissionUpdateCallback
2446                     .waitUntilOnReceiveDatagramStateChanged(expectedNumOfEvents));
2447             assertThat(transmissionUpdateCallback.getNumOfReceiveDatagramStateChanges())
2448                     .isEqualTo(expectedNumOfEvents);
2449             assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(0)).isEqualTo(
2450                     new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2451                             SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVING,
2452                             0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2453             assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(1)).isEqualTo(
2454                     new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2455                             SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVE_SUCCESS,
2456                             0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2457             assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(2)).isEqualTo(
2458                     new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2459                             SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
2460                             0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2461 
2462             datagramCallback.waitUntilResult(1);
2463             // Because demo mode is on, the received datagram should be the same as the
2464             // last sent datagram
2465             datagramCallback.waitUntilResult(1);
2466             assertTrue(Arrays.equals(
2467                     datagramCallback.mDatagram.getSatelliteDatagram(), mText.getBytes()));
2468             sSatelliteManager.unregisterForIncomingDatagram(datagramCallback);
2469             transmissionUpdateCallback.clearReceiveDatagramStateChanges();
2470             stopTransmissionUpdates(transmissionUpdateCallback);
2471         }
2472 
2473         sSatelliteManager.setDeviceAlignedWithSatellite(false);
2474         assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(true,
2475                 DatagramController.TIMEOUT_TYPE_DATAGRAM_DELAY_IN_DEMO_MODE, 0));
2476         assertTrue(sMockSatelliteServiceManager.restoreSatellitePointingUiClassName());
2477         revokeSatellitePermission();
2478     }
2479 
2480     @Test
testSendAndReceiveMultipleSatelliteDatagrams_DemoMode_success()2481     public void testSendAndReceiveMultipleSatelliteDatagrams_DemoMode_success() {
2482         logd("testSendAndReceiveMultipleSatelliteDatagrams_DemoMode_success");
2483         grantSatellitePermission();
2484         assertTrue(isSatelliteProvisioned());
2485         assertTrue(sMockSatelliteServiceManager.overrideSatellitePointingUiClassName());
2486         assertTrue(sMockSatelliteServiceManager.setShouldSendDatagramToModemInDemoMode(false));
2487 
2488         // Enable demo mode
2489         SatelliteModemStateCallbackTest stateCallback = new SatelliteModemStateCallbackTest();
2490         sSatelliteManager.registerForModemStateChanged(
2491                 getContext().getMainExecutor(), stateCallback);
2492         assertTrue(stateCallback.waitUntilResult(1));
2493         requestSatelliteEnabled(false);
2494         assertTrue(stateCallback.waitUntilModemOff());
2495         assertFalse(isSatelliteEnabled());
2496         stateCallback.clearModemStates();
2497         requestSatelliteEnabledForDemoMode(true);
2498         assertTrue(stateCallback.waitUntilResult(2));
2499         assertTrue(isSatelliteEnabled());
2500         sSatelliteManager.setDeviceAlignedWithSatellite(true);
2501 
2502         SatelliteDatagramCallbackTest datagramCallback = new SatelliteDatagramCallbackTest();
2503         assertTrue(SatelliteManager.SATELLITE_RESULT_SUCCESS
2504                 == sSatelliteManager.registerForIncomingDatagram(getContext().getMainExecutor(),
2505                 datagramCallback));
2506 
2507         assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(false,
2508                 DatagramController.TIMEOUT_TYPE_DATAGRAM_DELAY_IN_DEMO_MODE,
2509                 TEST_DATAGRAM_DELAY_IN_DEMO_MODE_TIMEOUT_LONG_MILLIS));
2510 
2511         String[] datagramContentArr = new String[5];
2512         LinkedBlockingQueue<Integer>[] resultListenerArr = new LinkedBlockingQueue[5];
2513         for (int i = 0; i < 5; i++) {
2514             datagramContentArr[i] = "This is a test message " + i;
2515             resultListenerArr[i] = new LinkedBlockingQueue<>(1);
2516         }
2517 
2518         // Send satellite datagrams
2519         for (int i = 0; i < 5; i++) {
2520             SatelliteDatagram datagram = new SatelliteDatagram(datagramContentArr[i].getBytes());
2521             sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
2522                     datagram, true, getContext().getMainExecutor(),
2523                     resultListenerArr[i]::offer);
2524         }
2525 
2526         // Wait for the results of the send requests
2527         for (int i = 0; i < 5; i++) {
2528             Integer errorCode;
2529             try {
2530                 errorCode = resultListenerArr[i].poll(TIMEOUT, TimeUnit.MILLISECONDS);
2531             } catch (InterruptedException ex) {
2532                 fail("testSendAndReceiveMultipleSatelliteDatagrams_DemoMode_success: Got "
2533                         + "InterruptedException in waiting for the result of datagram " + i);
2534                 return;
2535             }
2536             assertNotNull(errorCode);
2537             assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
2538         }
2539 
2540         // Wait for the loop-back datagrams
2541         assertTrue(datagramCallback.waitUntilResult(5));
2542         assertEquals(5, datagramCallback.mDatagramList.size());
2543 
2544         // Verify the content of the loop-back datagrams
2545         for (int i = 0; i < 5; i++) {
2546             assertTrue(Arrays.equals(datagramContentArr[i].getBytes(),
2547                     datagramCallback.mDatagramList.get(i).getSatelliteDatagram()));
2548         }
2549 
2550         sSatelliteManager.unregisterForIncomingDatagram(datagramCallback);
2551         sSatelliteManager.setDeviceAlignedWithSatellite(false);
2552         assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(true,
2553                 DatagramController.TIMEOUT_TYPE_DATAGRAM_DELAY_IN_DEMO_MODE, 0));
2554         assertTrue(sMockSatelliteServiceManager.restoreSatellitePointingUiClassName());
2555         requestSatelliteEnabled(false);
2556         assertTrue(stateCallback.waitUntilModemOff());
2557         revokeSatellitePermission();
2558     }
2559 
2560     @Test
testSendSatelliteDatagram_DemoMode_failure()2561     public void testSendSatelliteDatagram_DemoMode_failure() {
2562         logd("testSendSatelliteDatagram_DemoMode_failure");
2563         grantSatellitePermission();
2564         assertTrue(isSatelliteProvisioned());
2565 
2566         SatelliteModemStateCallbackTest stateCallback = new SatelliteModemStateCallbackTest();
2567         sSatelliteManager.registerForModemStateChanged(
2568                 getContext().getMainExecutor(), stateCallback);
2569         assertTrue(stateCallback.waitUntilResult(1));
2570 
2571         // Enable satellite with demo mode on
2572         if (isSatelliteEnabled()) {
2573             requestSatelliteEnabled(false);
2574             assertTrue(stateCallback.waitUntilModemOff());
2575             stateCallback.clearModemStates();
2576         }
2577         requestSatelliteEnabledForDemoMode(true);
2578         assertTrue(stateCallback.waitUntilResult(2));
2579         assertTrue(isSatelliteEnabled());
2580         assertTrue(getIsEmergency());
2581         assertTrue(sMockSatelliteServiceManager.setShouldSendDatagramToModemInDemoMode(true));
2582 
2583         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
2584         SatelliteTransmissionUpdateCallbackTest callback =
2585                 new SatelliteTransmissionUpdateCallbackTest();
2586         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
2587                 resultListener::offer, callback);
2588         Integer errorCode;
2589         try {
2590             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2591         } catch (InterruptedException ex) {
2592             fail("testSendSatelliteDatagram_DemoMode_failure: Got InterruptedException in waiting"
2593                     + " for the startSatelliteTransmissionUpdates result code");
2594             return;
2595         }
2596         assertNotNull(errorCode);
2597         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
2598 
2599         // Send satellite datagram
2600         String mText = "This is a test datagram message from user";
2601         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
2602         callback.clearSendDatagramStateChanges();
2603         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_ERROR);
2604         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
2605                 datagram, true, getContext().getMainExecutor(),
2606                 resultListener::offer);
2607 
2608         try {
2609             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2610         } catch (InterruptedException ex) {
2611             fail("testSendSatelliteDatagram_DemoMode_failure: Got InterruptedException in waiting"
2612                     + " for the sendDatagram result code");
2613             return;
2614         }
2615         assertNotNull(errorCode);
2616         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_ERROR);
2617 
2618         /*
2619          * Send datagram transfer state should have the following transitions:
2620          * 1) IDLE to SENDING
2621          * 2) SENDING to SENDING_FAILED
2622          * 3) SENDING_FAILED to IDLE
2623          */
2624         int expectedNumOfEvents = 3;
2625         assertTrue(callback.waitUntilOnSendDatagramStateChanged(expectedNumOfEvents));
2626         assertThat(callback.getNumOfSendDatagramStateChanges()).isEqualTo(expectedNumOfEvents);
2627         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
2628                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2629                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
2630                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2631         assertThat(callback.getSendDatagramStateChange(1)).isEqualTo(
2632                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2633                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_FAILED,
2634                         0, SatelliteManager.SATELLITE_RESULT_ERROR));
2635         assertThat(callback.getSendDatagramStateChange(2)).isEqualTo(
2636                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2637                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
2638                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2639 
2640         callback.clearSendDatagramStateChanges();
2641         sSatelliteManager.stopTransmissionUpdates(callback, getContext().getMainExecutor(),
2642                 resultListener::offer);
2643         sSatelliteManager.unregisterForModemStateChanged(stateCallback);
2644         revokeSatellitePermission();
2645     }
2646 
2647     @Test
testSatelliteModeRadios()2648     public void testSatelliteModeRadios() {
2649         logd("testSatelliteModeRadios: start");
2650         InstrumentationRegistry.getInstrumentation().getUiAutomation()
2651                 .adoptShellPermissionIdentity(Manifest.permission.SATELLITE_COMMUNICATION,
2652                         Manifest.permission.WRITE_SECURE_SETTINGS,
2653                         Manifest.permission.UWB_PRIVILEGED);
2654         assertTrue(isSatelliteProvisioned());
2655 
2656         SatelliteModemStateCallbackTest stateCallback = new SatelliteModemStateCallbackTest();
2657         sSatelliteManager.registerForModemStateChanged(
2658                 getContext().getMainExecutor(), stateCallback);
2659         assertTrue(stateCallback.waitUntilResult(1));
2660 
2661         boolean originalEnabledState = isSatelliteEnabled();
2662         if (originalEnabledState) {
2663             requestSatelliteEnabled(false);
2664             assertTrue(stateCallback.waitUntilModemOff());
2665             assertSatelliteEnabledInSettings(false);
2666             stateCallback.clearModemStates();
2667         }
2668 
2669         // Get satellite mode radios
2670         String originalSatelliteModeRadios =
2671                 Settings.Global.getString(
2672                         getContext().getContentResolver(), Settings.Global.SATELLITE_MODE_RADIOS);
2673         logd("originalSatelliteModeRadios: " + originalSatelliteModeRadios);
2674         SatelliteModeRadiosUpdater satelliteRadiosModeUpdater =
2675                 new SatelliteModeRadiosUpdater(getContext());
2676 
2677         try {
2678             identifyRadiosSensitiveToSatelliteMode();
2679             mTestSatelliteModeRadios = "";
2680             logd("test satelliteModeRadios: " + mTestSatelliteModeRadios);
2681             assertTrue(satelliteRadiosModeUpdater.setSatelliteModeRadios(mTestSatelliteModeRadios));
2682 
2683             // Enable Satellite and check whether all radios are disabled
2684             requestSatelliteEnabled(true, EXTERNAL_DEPENDENT_TIMEOUT);
2685             assertTrue(stateCallback.waitUntilResult(1));
2686             assertSatelliteEnabledInSettings(true);
2687             assertTrue(areAllRadiosDisabled());
2688 
2689             // Disable satellite and check whether all radios are set to their initial state
2690             setRadioExpectedState();
2691             requestSatelliteEnabled(false);
2692             assertTrue(stateCallback.waitUntilResult(1));
2693             assertSatelliteEnabledInSettings(false);
2694             assertTrue(areAllRadiosResetToInitialState());
2695         } finally {
2696             // Restore original satellite mode radios
2697             logd("restore original satellite mode radios");
2698             assertTrue(satelliteRadiosModeUpdater.setSatelliteModeRadios(
2699                     originalSatelliteModeRadios));
2700             sSatelliteManager.unregisterForModemStateChanged(stateCallback);
2701             unregisterSatelliteModeRadios();
2702             InstrumentationRegistry.getInstrumentation().getUiAutomation()
2703                     .dropShellPermissionIdentity();
2704         }
2705     }
2706 
2707     @Test
testSatelliteModeRadios_noRadiosSensitiveToSatelliteMode()2708     public void testSatelliteModeRadios_noRadiosSensitiveToSatelliteMode() {
2709         logd("testSatelliteModeRadios_noRadiosSensitiveToSatelliteMode: start");
2710         InstrumentationRegistry.getInstrumentation().getUiAutomation()
2711                 .adoptShellPermissionIdentity(Manifest.permission.SATELLITE_COMMUNICATION,
2712                         Manifest.permission.WRITE_SECURE_SETTINGS,
2713                         Manifest.permission.UWB_PRIVILEGED);
2714         assertTrue(isSatelliteProvisioned());
2715 
2716         SatelliteModemStateCallbackTest stateCallback = new SatelliteModemStateCallbackTest();
2717         sSatelliteManager.registerForModemStateChanged(
2718                 getContext().getMainExecutor(), stateCallback);
2719         assertTrue(stateCallback.waitUntilResult(1));
2720 
2721         boolean originalEnabledState = isSatelliteEnabled();
2722         if (originalEnabledState) {
2723             requestSatelliteEnabled(false);
2724             assertTrue(stateCallback.waitUntilModemOff());
2725             assertSatelliteEnabledInSettings(false);
2726             stateCallback.clearModemStates();
2727         }
2728 
2729         // Get satellite mode radios
2730         String originalSatelliteModeRadios =
2731                 Settings.Global.getString(
2732                         getContext().getContentResolver(), Settings.Global.SATELLITE_MODE_RADIOS);
2733         logd("originalSatelliteModeRadios: " + originalSatelliteModeRadios);
2734         SatelliteModeRadiosUpdater satelliteRadiosModeUpdater =
2735                 new SatelliteModeRadiosUpdater(getContext());
2736 
2737         try {
2738             mTestSatelliteModeRadios = "";
2739             logd("test satelliteModeRadios: " + mTestSatelliteModeRadios);
2740             assertTrue(satelliteRadiosModeUpdater.setSatelliteModeRadios(mTestSatelliteModeRadios));
2741 
2742             // Enable Satellite and check whether all radios are disabled
2743             setRadioExpectedState();
2744             requestSatelliteEnabled(true, EXTERNAL_DEPENDENT_TIMEOUT);
2745             assertTrue(stateCallback.waitUntilResult(1));
2746             assertSatelliteEnabledInSettings(true);
2747             assertTrue(areAllRadiosDisabled());
2748             assertTrue(areAllRadiosResetToInitialState());
2749 
2750             // Disable satellite and check whether all radios are set to their initial state
2751             setRadioExpectedState();
2752             stateCallback.clearModemStates();
2753             requestSatelliteEnabled(false);
2754             assertTrue(stateCallback.waitUntilModemOff());
2755             assertSatelliteEnabledInSettings(false);
2756             assertTrue(areAllRadiosResetToInitialState());
2757             stateCallback.clearModemStates();
2758         } finally {
2759             // Restore original satellite mode radios
2760             logd("restore original satellite mode radios");
2761             assertTrue(satelliteRadiosModeUpdater.setSatelliteModeRadios(
2762                     originalSatelliteModeRadios));
2763             sSatelliteManager.unregisterForModemStateChanged(stateCallback);
2764             InstrumentationRegistry.getInstrumentation().getUiAutomation()
2765                     .dropShellPermissionIdentity();
2766         }
2767     }
2768 
2769     @Test
testSatelliteModeRadiosWithAirplaneMode()2770     public void testSatelliteModeRadiosWithAirplaneMode() throws Exception {
2771         logd("testSatelliteModeRadiosWithAirplaneMode: start");
2772         InstrumentationRegistry.getInstrumentation().getUiAutomation()
2773                 .adoptShellPermissionIdentity(Manifest.permission.SATELLITE_COMMUNICATION,
2774                         Manifest.permission.WRITE_SECURE_SETTINGS,
2775                         Manifest.permission.NETWORK_SETTINGS,
2776                         Manifest.permission.ACCESS_FINE_LOCATION,
2777                         Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
2778                         Manifest.permission.UWB_PRIVILEGED);
2779         assertTrue(isSatelliteProvisioned());
2780 
2781         ServiceStateRadioStateListener callback = new ServiceStateRadioStateListener(
2782                 sTelephonyManager.getServiceState(), sTelephonyManager.getRadioPowerState());
2783         sTelephonyManager.registerTelephonyCallback(Runnable::run, callback);
2784         SatelliteModemStateCallbackTest stateCallback = new SatelliteModemStateCallbackTest();
2785         sSatelliteManager.registerForModemStateChanged(
2786                 getContext().getMainExecutor(), stateCallback);
2787         assertTrue(stateCallback.waitUntilResult(1));
2788 
2789         boolean originalEnabledState = isSatelliteEnabled();
2790         if (originalEnabledState) {
2791             requestSatelliteEnabled(false);
2792             assertTrue(stateCallback.waitUntilModemOff());
2793             assertFalse(isSatelliteEnabled());
2794             stateCallback.clearModemStates();
2795         }
2796 
2797         ConnectivityManager connectivityManager =
2798                 getContext().getSystemService(ConnectivityManager.class);
2799 
2800         // Get original satellite mode radios and original airplane mode
2801         String originalSatelliteModeRadios =
2802                 Settings.Global.getString(
2803                         getContext().getContentResolver(), Settings.Global.SATELLITE_MODE_RADIOS);
2804         logd("originalSatelliteModeRadios: " + originalSatelliteModeRadios);
2805         boolean originalAirplaneMode = Settings.Global.getInt(
2806                 getContext().getContentResolver(), Settings.Global.AIRPLANE_MODE_ON) != 0;
2807         SatelliteModeRadiosUpdater satelliteModeRadiosUpdater =
2808                 new SatelliteModeRadiosUpdater(getContext());
2809 
2810         try {
2811             identifyRadiosSensitiveToSatelliteMode();
2812             mTestSatelliteModeRadios = "";
2813             logd("test satelliteModeRadios: " + mTestSatelliteModeRadios);
2814             assertTrue(satelliteModeRadiosUpdater.setSatelliteModeRadios(mTestSatelliteModeRadios));
2815 
2816             // Enable Satellite and check whether all radios are disabled
2817             requestSatelliteEnabled(true, EXTERNAL_DEPENDENT_TIMEOUT);
2818             assertTrue(stateCallback.waitUntilResult(1));
2819             assertTrue(isSatelliteEnabled());
2820             assertSatelliteEnabledInSettings(true);
2821             assertTrue(areAllRadiosDisabled());
2822 
2823             // Enable airplane mode, check whether all radios are disabled and
2824             // also satellite mode is disabled
2825             connectivityManager.setAirplaneMode(true);
2826             // Wait for telephony radio power off
2827             callback.waitForRadioStateIntent(TelephonyManager.RADIO_POWER_OFF);
2828             // Wait for satellite mode state changed
2829             assertTrue(stateCallback.waitUntilResult(1));
2830             assertFalse(isSatelliteEnabled());
2831             assertSatelliteEnabledInSettings(false);
2832             assertTrue(areAllRadiosDisabled());
2833 
2834             // Disable airplane mode, check whether all radios are set to their initial state
2835             setRadioExpectedState();
2836             connectivityManager.setAirplaneMode(false);
2837             callback.waitForRadioStateIntent(TelephonyManager.RADIO_POWER_ON);
2838             assertTrue(areAllRadiosResetToInitialState());
2839         } finally {
2840             // Restore original satellite mode radios
2841             logd("restore original satellite mode radios and original airplane mode");
2842             connectivityManager.setAirplaneMode(originalAirplaneMode);
2843             callback.waitForRadioStateIntent(originalAirplaneMode
2844                     ? TelephonyManager.RADIO_POWER_OFF : TelephonyManager.RADIO_POWER_ON);
2845             assertTrue(satelliteModeRadiosUpdater.setSatelliteModeRadios(
2846                     originalSatelliteModeRadios));
2847             sTelephonyManager.unregisterTelephonyCallback(callback);
2848             sSatelliteManager.unregisterForModemStateChanged(stateCallback);
2849             unregisterSatelliteModeRadios();
2850             InstrumentationRegistry.getInstrumentation().getUiAutomation()
2851                     .dropShellPermissionIdentity();
2852         }
2853     }
2854 
2855     @Test
testSendSatelliteDatagram_DemoMode_not_Aligned()2856     public void testSendSatelliteDatagram_DemoMode_not_Aligned() {
2857         logd("testSendSatelliteDatagram_DemoMode_not_Aligned");
2858         grantSatellitePermission();
2859         assertTrue(isSatelliteProvisioned());
2860 
2861         SatelliteModemStateCallbackTest stateCallback = new SatelliteModemStateCallbackTest();
2862         sSatelliteManager.registerForModemStateChanged(
2863                 getContext().getMainExecutor(), stateCallback);
2864         assertTrue(stateCallback.waitUntilResult(1));
2865         assertTrue(sMockSatelliteServiceManager.setShouldSendDatagramToModemInDemoMode(true));
2866         assertTrue(sMockSatelliteServiceManager.overrideSatellitePointingUiClassName());
2867         // Enable satellite with demo mode on
2868         if (isSatelliteEnabled()) {
2869             requestSatelliteEnabled(false);
2870             assertTrue(stateCallback.waitUntilModemOff());
2871             stateCallback.clearModemStates();
2872         }
2873         requestSatelliteEnabledForDemoMode(true);
2874         assertTrue(stateCallback.waitUntilResult(2));
2875         assertTrue(isSatelliteEnabled());
2876         assertTrue(getIsEmergency());
2877 
2878         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
2879         SatelliteTransmissionUpdateCallbackTest callback =
2880                 new SatelliteTransmissionUpdateCallbackTest();
2881         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
2882                 resultListener::offer, callback);
2883         Integer errorCode;
2884         try {
2885             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2886         } catch (InterruptedException ex) {
2887             fail("testSendSatelliteDatagram_DemoMode_not_Aligned: Got InterruptedException in "
2888                     + "waiting for the startSatelliteTransmissionUpdates result code");
2889             return;
2890         }
2891         assertNotNull(errorCode);
2892         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
2893 
2894         // Send satellite datagram and satellite is not aligned.
2895         assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(false,
2896                 DatagramController.TIMEOUT_TYPE_ALIGN, TEST_SATELLITE_DEVICE_ALIGN_TIMEOUT_MILLIS));
2897         String mText = "This is a test datagram message from user";
2898         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
2899         callback.clearSendDatagramStateChanges();
2900         sSatelliteManager.setDeviceAlignedWithSatellite(false);
2901         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
2902                 datagram, true, getContext().getMainExecutor(),
2903                 resultListener::offer);
2904 
2905         try {
2906             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2907         } catch (InterruptedException ex) {
2908             fail("testSendSatelliteDatagram_DemoMode_not_Aligned: Got InterruptedException in"
2909                     + " waiting for the sendDatagram result code");
2910             return;
2911         }
2912         assertNotNull(errorCode);
2913         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_NOT_REACHABLE);
2914 
2915         /*
2916          * Send datagram transfer state should have the following transitions:
2917          * 1) IDLE to SENDING
2918          * 2) SENDING to SENDING_FAILED
2919          * 3) SENDING_FAILED to IDLE
2920          */
2921         assertTrue(callback.waitUntilOnSendDatagramStateChanged(3));
2922         assertThat(callback.getNumOfSendDatagramStateChanges()).isEqualTo(3);
2923         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
2924                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2925                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
2926                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2927         assertThat(callback.getSendDatagramStateChange(1)).isEqualTo(
2928                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2929                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_FAILED,
2930                         0, SatelliteManager.SATELLITE_RESULT_NOT_REACHABLE));
2931         assertThat(callback.getSendDatagramStateChange(2)).isEqualTo(
2932                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2933                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
2934                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2935 
2936         // Move to sending state and wait for satellite alignment forever
2937         assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(false,
2938                 DatagramController.TIMEOUT_TYPE_ALIGN,
2939                 TEST_SATELLITE_DEVICE_ALIGN_FOREVER_TIMEOUT_MILLIS));
2940         callback.clearSendDatagramStateChanges();
2941         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
2942         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
2943                 datagram, true, getContext().getMainExecutor(),
2944                 resultListener::offer);
2945 
2946         // No response for the request sendDatagram received
2947         try {
2948             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2949         } catch (InterruptedException ex) {
2950             fail("testSendSatelliteDatagram_DemoMode_not_Aligned: Got InterruptedException in"
2951                     + " waiting for the sendDatagram result code");
2952             return;
2953         }
2954         assertNull(errorCode);
2955 
2956         /*
2957          * Send datagram transfer state should have the following transitions:
2958          * 1) IDLE to SENDING
2959          */
2960         assertTrue(callback.waitUntilOnSendDatagramStateChanged(1));
2961         assertThat(callback.getNumOfSendDatagramStateChanges()).isEqualTo(1);
2962         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
2963                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2964                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
2965                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2966 
2967         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
2968         callback.clearSendDatagramStateChanges();
2969         sSatelliteManager.setDeviceAlignedWithSatellite(true);
2970 
2971         // Satellite is aligned now. We should get the response of the request
2972         // sendSatelliteDatagrams.
2973         try {
2974             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
2975         } catch (InterruptedException ex) {
2976             fail("testSendSatelliteDatagram_DemoMode_not_Aligned: Got InterruptedException in"
2977                     + " waiting for the sendDatagram result code");
2978             return;
2979         }
2980         assertNotNull(errorCode);
2981         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
2982 
2983         /*
2984          * Send datagram transfer state should have the following transitions:
2985          * 1) SENDING to SEND_SUCCESS
2986          * 2) SEND_SUCCESS to IDLE
2987          */
2988         assertTrue(callback.waitUntilOnSendDatagramStateChanged(2));
2989         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
2990                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2991                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_SUCCESS,
2992                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2993         assertThat(callback.getSendDatagramStateChange(1)).isEqualTo(
2994                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
2995                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
2996                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
2997 
2998         // Move to sending state and wait for satellite alignment forever again
2999         sSatelliteManager.setDeviceAlignedWithSatellite(false);
3000         callback.clearSendDatagramStateChanges();
3001         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
3002                 datagram, true, getContext().getMainExecutor(),
3003                 resultListener::offer);
3004 
3005         // No response for the request sendDatagram received
3006         try {
3007             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
3008         } catch (InterruptedException ex) {
3009             fail("testSendSatelliteDatagram_DemoMode_not_Aligned: Got InterruptedException in"
3010                     + " waiting for the sendDatagram result code");
3011             return;
3012         }
3013         assertNull(errorCode);
3014 
3015         /*
3016          * Send datagram transfer state should have the following transitions:
3017          * 1) IDLE to SENDING
3018          */
3019         assertTrue(callback.waitUntilOnSendDatagramStateChanged(1));
3020         assertThat(callback.getNumOfSendDatagramStateChanges()).isEqualTo(1);
3021         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
3022                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3023                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
3024                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
3025 
3026         callback.clearSendDatagramStateChanges();
3027         stateCallback.clearModemStates();
3028         requestSatelliteEnabled(false);
3029         assertTrue(stateCallback.waitUntilModemOff());
3030         stateCallback.clearModemStates();
3031 
3032         try {
3033             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
3034         } catch (InterruptedException ex) {
3035             fail("testSendSatelliteDatagram_DemoMode_not_Aligned: Got InterruptedException in"
3036                     + " waiting for the sendDatagram result code");
3037             return;
3038         }
3039         assertNotNull(errorCode);
3040         assertThat(errorCode).isEqualTo(SATELLITE_RESULT_REQUEST_ABORTED);
3041 
3042         /*
3043          * Send datagram transfer state should have the following transitions:
3044          * 1) SENDING to SENDING_FAILED
3045          * 2) SENDING_FAILED to IDLE
3046          */
3047         assertTrue(callback.waitUntilOnSendDatagramStateChanged(2));
3048         assertThat(callback.getNumOfSendDatagramStateChanges()).isEqualTo(2);
3049         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
3050                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3051                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_FAILED,
3052                         1, SATELLITE_RESULT_REQUEST_ABORTED));
3053         assertThat(callback.getSendDatagramStateChange(1)).isEqualTo(
3054                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3055                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
3056                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
3057 
3058         callback.clearSendDatagramStateChanges();
3059         sSatelliteManager.stopTransmissionUpdates(callback, getContext().getMainExecutor(),
3060                 resultListener::offer);
3061 
3062         // Restore satellite device align time out to default value.
3063         assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(true,
3064                 DatagramController.TIMEOUT_TYPE_ALIGN, 0));
3065         assertTrue(sMockSatelliteServiceManager.restoreSatellitePointingUiClassName());
3066         sSatelliteManager.unregisterForModemStateChanged(stateCallback);
3067         revokeSatellitePermission();
3068     }
3069 
3070     @Test
testReceiveSatelliteDatagram_DemoMode_not_Aligned()3071     public void testReceiveSatelliteDatagram_DemoMode_not_Aligned() {
3072         logd("testReceiveSatelliteDatagram_DemoMode_not_Aligned");
3073         grantSatellitePermission();
3074         assertTrue(isSatelliteProvisioned());
3075 
3076         SatelliteModemStateCallbackTest stateCallback = new SatelliteModemStateCallbackTest();
3077         sSatelliteManager.registerForModemStateChanged(
3078                 getContext().getMainExecutor(), stateCallback);
3079         assertTrue(stateCallback.waitUntilResult(1));
3080         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
3081                 startTransmissionUpdates();
3082         assertTrue(sMockSatelliteServiceManager.overrideSatellitePointingUiClassName());
3083 
3084         // Request enable satellite with demo mode on
3085         if (isSatelliteEnabled()) {
3086             requestSatelliteEnabled(false);
3087             assertTrue(stateCallback.waitUntilModemOff());
3088             stateCallback.clearModemStates();
3089         }
3090         requestSatelliteEnabledForDemoMode(true);
3091         assertTrue(stateCallback.waitUntilResult(2));
3092         assertTrue(isSatelliteEnabled());
3093         assertTrue(getIsEmergency());
3094 
3095         sSatelliteManager.setDeviceAlignedWithSatellite(true);
3096         assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(false,
3097                 DatagramController.TIMEOUT_TYPE_DATAGRAM_DELAY_IN_DEMO_MODE,
3098                 TEST_DATAGRAM_DELAY_IN_DEMO_MODE_TIMEOUT_LONG_MILLIS));
3099 
3100         // Send satellite datagram to compare with the received datagram in demo mode
3101         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
3102         String mText = "This is a test datagram message";
3103         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
3104         sSatelliteManager.sendDatagram(
3105                 SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE, datagram, true,
3106                 getContext().getMainExecutor(), resultListener::offer);
3107 
3108         Integer errorCode;
3109         try {
3110             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
3111         } catch (InterruptedException ex) {
3112             fail("testReceiveSatelliteDatagram_DemoMode_not_Aligned: Got InterruptedException in "
3113                     + "waiting for the sendDatagram result code");
3114             return;
3115         }
3116         assertNotNull(errorCode);
3117         Log.d(TAG, "testReceiveSatelliteDatagram_DemoMode_not_Aligned: sendDatagram "
3118                 + "errorCode=" + errorCode);
3119 
3120         // Test poll pending satellite datagram for demo mode while it is not aligned
3121         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
3122         sSatelliteManager.setDeviceAlignedWithSatellite(false);
3123         assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(false,
3124                 DatagramController.TIMEOUT_TYPE_ALIGN, TEST_SATELLITE_DEVICE_ALIGN_TIMEOUT_MILLIS));
3125 
3126         // Datagram transfer state should change from RECEIVING to IDLE.
3127         assertTrue(transmissionUpdateCallback
3128                 .waitUntilOnReceiveDatagramStateChanged(3));
3129         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(0)).isEqualTo(
3130                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3131                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVING,
3132                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
3133         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(1)).isEqualTo(
3134                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3135                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVE_FAILED,
3136                         0, SatelliteManager.SATELLITE_RESULT_NOT_REACHABLE));
3137         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(2)).isEqualTo(
3138                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3139                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
3140                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
3141 
3142         requestSatelliteEnabled(false);
3143         assertTrue(stateCallback.waitUntilModemOff());
3144         stopTransmissionUpdates(transmissionUpdateCallback);
3145         assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(true,
3146                 DatagramController.TIMEOUT_TYPE_ALIGN, 0));
3147         assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(true,
3148                 DatagramController.TIMEOUT_TYPE_DATAGRAM_DELAY_IN_DEMO_MODE, 0));
3149         assertTrue(sMockSatelliteServiceManager.restoreSatellitePointingUiClassName());
3150         sSatelliteManager.unregisterForModemStateChanged(stateCallback);
3151         revokeSatellitePermission();
3152     }
3153 
3154     @Test
testSatelliteModemBusy_modemSendingDatagram_pollingFailure()3155     public void testSatelliteModemBusy_modemSendingDatagram_pollingFailure() {
3156         logd("testSatelliteModemBusy_modemSendingDatagram_pollingFailure");
3157         grantSatellitePermission();
3158         assertTrue(isSatelliteProvisioned());
3159 
3160         String mText = "This is a test datagram message from user";
3161         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
3162         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
3163 
3164         // Wait to process datagrams so that datagrams are added to pending list
3165         // and modem is busy sending datagrams
3166         sMockSatelliteServiceManager.setWaitToSend(true);
3167 
3168         LinkedBlockingQueue<Integer> sendResultListener = new LinkedBlockingQueue<>(1);
3169         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
3170                 datagram, true, getContext().getMainExecutor(),
3171                 sendResultListener::offer);
3172 
3173         LinkedBlockingQueue<Integer> pollResultListener = new LinkedBlockingQueue<>(1);
3174         sSatelliteManager.pollPendingDatagrams(getContext().getMainExecutor(),
3175                 pollResultListener::offer);
3176 
3177         Integer errorCode;
3178         try {
3179             errorCode = pollResultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
3180         } catch (InterruptedException ex) {
3181             fail("testSatelliteModemBusy_modemSendingDatagram_pollingFailure: Got "
3182                     + "InterruptedException in waiting for the pollPendingDatagrams "
3183                     + "result code");
3184             return;
3185         }
3186         assertNotNull(errorCode);
3187         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_MODEM_BUSY);
3188 
3189         // Send datagram successfully to bring sending state back to IDLE.
3190         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
3191         assertTrue(sMockSatelliteServiceManager.sendSavedDatagram());
3192         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
3193         sMockSatelliteServiceManager.setWaitToSend(false);
3194         revokeSatellitePermission();
3195     }
3196 
3197     @Test
testSatelliteModemBusy_modemPollingDatagrams_pollingFailure()3198     public void testSatelliteModemBusy_modemPollingDatagrams_pollingFailure() {
3199         logd("testSatelliteModemBusy_modemPollingDatagrams_pollingFailure");
3200         grantSatellitePermission();
3201         assertTrue(isSatelliteProvisioned());
3202 
3203         LinkedBlockingQueue<Integer> pollResultListener1 = new LinkedBlockingQueue<>(1);
3204         sSatelliteManager.pollPendingDatagrams(getContext().getMainExecutor(),
3205                 pollResultListener1::offer);
3206 
3207         // As we already got one polling request, this second polling request would fail
3208         LinkedBlockingQueue<Integer> pollResultListener2 = new LinkedBlockingQueue<>(1);
3209         sSatelliteManager.pollPendingDatagrams(getContext().getMainExecutor(),
3210                 pollResultListener2::offer);
3211 
3212         Integer errorCode;
3213         try {
3214             errorCode = pollResultListener2.poll(TIMEOUT, TimeUnit.MILLISECONDS);
3215         } catch (InterruptedException ex) {
3216             fail("testSatelliteModemBusy_modemSendingDatagram_pollingFailure: Got "
3217                     + "InterruptedException in waiting for the pollPendingDatagrams "
3218                     + "result code");
3219             return;
3220         }
3221         assertNotNull(errorCode);
3222         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_MODEM_BUSY);
3223 
3224         // Receive one datagram successfully to bring receiving state back to IDLE.
3225         String receivedText = "This is a test datagram message from satellite";
3226         android.telephony.satellite.stub.SatelliteDatagram receivedDatagram =
3227                 new android.telephony.satellite.stub.SatelliteDatagram();
3228         receivedDatagram.data = receivedText.getBytes();
3229         sMockSatelliteServiceManager.sendOnSatelliteDatagramReceived(receivedDatagram, 0);
3230         revokeSatellitePermission();
3231     }
3232 
3233     @Test
testSatelliteModemBusy_modemPollingDatagram_sendingDelayed()3234     public void testSatelliteModemBusy_modemPollingDatagram_sendingDelayed() {
3235         logd("testSatelliteModemBusy_modemPollingDatagram_sendingDelayed");
3236         grantSatellitePermission();
3237         assertTrue(isSatelliteProvisioned());
3238 
3239         String mText = "This is a test datagram message from user";
3240         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
3241         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
3242 
3243         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
3244         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
3245                 new SatelliteTransmissionUpdateCallbackTest();
3246         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
3247                 resultListener::offer, transmissionUpdateCallback);
3248         Integer errorCode;
3249         try {
3250             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
3251         } catch (InterruptedException ex) {
3252             fail("testSatelliteModemBusy_modemPollingDatagram_sendingDelayed: "
3253                     + "Got InterruptedException in waiting for the "
3254                     + "startSatelliteTransmissionUpdates result code");
3255             return;
3256         }
3257         assertNotNull(errorCode);
3258         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
3259 
3260         SatelliteDatagramCallbackTest satelliteDatagramCallback =
3261                 new SatelliteDatagramCallbackTest();
3262         sSatelliteManager.registerForIncomingDatagram(
3263                 getContext().getMainExecutor(), satelliteDatagramCallback);
3264 
3265         transmissionUpdateCallback.clearSendDatagramStateChanges();
3266         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
3267 
3268         LinkedBlockingQueue<Integer> pollResultListener = new LinkedBlockingQueue<>(1);
3269         sSatelliteManager.pollPendingDatagrams(getContext().getMainExecutor(),
3270                 pollResultListener::offer);
3271         // Datagram transfer state changes from IDLE -> RECEIVING.
3272         assertSingleReceiveDatagramStateChanged(transmissionUpdateCallback,
3273                 SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVING,
3274                 0, SatelliteManager.SATELLITE_RESULT_SUCCESS);
3275 
3276         LinkedBlockingQueue<Integer> sendResultListener = new LinkedBlockingQueue<>(1);
3277         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
3278                 datagram, true, getContext().getMainExecutor(),
3279                 sendResultListener::offer);
3280         // Sending datagram will be delayed as modem is in RECEIVING state
3281         assertFalse(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
3282 
3283         String receivedText = "This is a test datagram message from satellite";
3284         android.telephony.satellite.stub.SatelliteDatagram receivedDatagram =
3285                 new android.telephony.satellite.stub.SatelliteDatagram();
3286         receivedDatagram.data = receivedText.getBytes();
3287         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
3288         sMockSatelliteServiceManager.sendOnSatelliteDatagramReceived(receivedDatagram, 0);
3289         // As pending count is 0, datagram transfer state changes from
3290         // RECEIVING -> RECEIVE_SUCCESS -> IDLE.
3291         int expectedNumOfEvents = 2;
3292         assertTrue(transmissionUpdateCallback
3293                 .waitUntilOnReceiveDatagramStateChanged(expectedNumOfEvents));
3294         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(0)).isEqualTo(
3295                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3296                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVE_SUCCESS,
3297                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
3298         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(1)).isEqualTo(
3299                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3300                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
3301                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
3302 
3303         // As polling is completed, now modem will start sending datagrams
3304         expectedNumOfEvents = 3;
3305         assertTrue(transmissionUpdateCallback.
3306                 waitUntilOnSendDatagramStateChanged(expectedNumOfEvents));
3307         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(0)).isEqualTo(
3308                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3309                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
3310                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
3311         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(1)).isEqualTo(
3312                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3313                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_SUCCESS,
3314                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
3315         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(2)).isEqualTo(
3316                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3317                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
3318                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
3319 
3320         transmissionUpdateCallback.clearSendDatagramStateChanges();
3321         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
3322         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
3323         sSatelliteManager.stopTransmissionUpdates(transmissionUpdateCallback,
3324                 getContext().getMainExecutor(), resultListener::offer);
3325         sSatelliteManager.unregisterForIncomingDatagram(satelliteDatagramCallback);
3326         revokeSatellitePermission();
3327     }
3328 
3329     @Ignore("b/399928350 - Need to fix and re-enable this test.")
3330     @Test
testRebindToSatelliteService()3331     public void testRebindToSatelliteService() {
3332         grantSatellitePermission();
3333         assertTrue(isSatelliteSupported());
3334 
3335         assertTrue(sMockSatelliteServiceManager.connectExternalSatelliteService());
3336         assertTrue(sMockSatelliteServiceManager.waitForRemoteSatelliteServiceConnected(1));
3337 
3338         // Forcefully stop the external satellite service.
3339         assertTrue(sMockSatelliteServiceManager.stopExternalSatelliteService());
3340         assertTrue(sMockSatelliteServiceManager
3341                 .waitForExternalSatelliteServiceDisconnected(1));
3342 
3343         // Reconnect CTS to the external satellite service.
3344         assertTrue(sMockSatelliteServiceManager.setupExternalSatelliteService());
3345         // Telephony should rebind to the external satellite service after the binding died.
3346         assertTrue(sMockSatelliteServiceManager.waitForRemoteSatelliteServiceConnected(1));
3347 
3348         // Restore original binding states
3349         sMockSatelliteServiceManager.resetSatelliteService();
3350         assertTrue(sMockSatelliteServiceManager.connectSatelliteService());
3351 
3352         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
3353         long registerResult = sSatelliteManager.registerForModemStateChanged(
3354                 getContext().getMainExecutor(), callback);
3355         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
3356         assertTrue(callback.waitUntilResult(1));
3357         assertTrue(callback.waitUntilModemOff(EXTERNAL_DEPENDENT_TIMEOUT));
3358         callback.clearModemStates();
3359 
3360         // Telephony will disable satellite whenever the vendor service is connected.
3361         // This will interfer the below tests and make the test flaky.
3362         requestSatelliteEnabled(true);
3363         assertTrue(callback.waitUntilResult(2));
3364         assertEquals(2, callback.getTotalCountOfModemStates());
3365         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
3366                 callback.getModemState(0));
3367         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback.getModemState(1));
3368         assertTrue(isSatelliteEnabled());
3369 
3370         assertTrue(sMockSatelliteServiceManager.stopExternalSatelliteService());
3371         assertTrue(sMockSatelliteServiceManager
3372                 .waitForExternalSatelliteServiceDisconnected(1));
3373         sSatelliteManager.unregisterForModemStateChanged(callback);
3374 
3375         revokeSatellitePermission();
3376     }
3377 
3378     @Ignore("b/377927857 - This test is flaky.")
3379     @Test
testRebindToSatelliteGatewayService()3380     public void testRebindToSatelliteGatewayService() {
3381         grantSatellitePermission();
3382         assertTrue(isSatelliteProvisioned());
3383 
3384         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
3385         long registerResult = sSatelliteManager.registerForModemStateChanged(
3386                 getContext().getMainExecutor(), callback);
3387         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
3388         assertTrue(callback.waitUntilResult(1));
3389 
3390         if (isSatelliteEnabled()) {
3391             callback.clearModemStates();
3392             requestSatelliteEnabled(false);
3393             assertTrue(callback.waitUntilResult(2));
3394             assertEquals(2, callback.getTotalCountOfModemStates());
3395             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
3396                     callback.getModemState(0));
3397             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(1));
3398             assertFalse(isSatelliteEnabled());
3399         }
3400 
3401         assertTrue(sMockSatelliteServiceManager.connectExternalSatelliteGatewayService());
3402         callback.clearModemStates();
3403         requestSatelliteEnabled(true);
3404         assertTrue(callback.waitUntilResult(2));
3405         assertEquals(2, callback.getTotalCountOfModemStates());
3406         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
3407                 callback.getModemState(0));
3408         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback.getModemState(1));
3409         assertTrue(isSatelliteEnabled());
3410         assertTrue(sMockSatelliteServiceManager.waitForRemoteSatelliteGatewayServiceConnected(1));
3411 
3412         // Forcefully stop the external satellite gateway service.
3413         assertTrue(sMockSatelliteServiceManager.stopExternalSatelliteGatewayService());
3414         assertTrue(sMockSatelliteServiceManager
3415                 .waitForExternalSatelliteGatewayServiceDisconnected(1));
3416 
3417         // Reconnect CTS to the external satellite gateway service.
3418         assertTrue(sMockSatelliteServiceManager.setupExternalSatelliteGatewayService());
3419         // Telephony should rebind to the external satellite gateway service after the binding died.
3420         assertTrue(sMockSatelliteServiceManager.waitForRemoteSatelliteGatewayServiceConnected(1));
3421 
3422         sSatelliteManager.unregisterForModemStateChanged(callback);
3423         assertTrue(sMockSatelliteServiceManager.restoreSatelliteGatewayServicePackageName());
3424 
3425         revokeSatellitePermission();
3426     }
3427 
3428     @Ignore("b/399928350 - Need to fix and re-enable this test.")
3429     @Test
testSatelliteAttachEnabledForCarrier()3430     public void testSatelliteAttachEnabledForCarrier() {
3431 
3432         logd("testSatelliteAttachEnabledForCarrier");
3433         grantSatellitePermission();
3434         beforeSatelliteForCarrierTest();
3435         @SatelliteManager.SatelliteResult int expectedSuccess =
3436                 SatelliteManager.SATELLITE_RESULT_SUCCESS;
3437         @SatelliteManager.SatelliteResult int expectedError;
3438 
3439         List<String> allPlmnListBeforeCarrierConfigOverride = getCarrierPlmnList();
3440 
3441         /* Test when satellite is not supported in the carrier config */
3442         PersistableBundle bundle = new PersistableBundle();
3443         bundle.putBoolean(
3444                 CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL, false);
3445 
3446         overrideCarrierConfig(sTestSubIDForCarrierSatellite, bundle);
3447         requestSatelliteAttachEnabledForCarrier(true, SatelliteManager.SATELLITE_RESULT_SUCCESS);
3448 
3449         Pair<Boolean, Integer> pair = requestIsSatelliteAttachEnabledForCarrier();
3450         assertEquals(true, pair.first.booleanValue());
3451         assertNull(pair.second);
3452 
3453         /* Test when satellite is supported in the carrier config */
3454         setSatelliteErrorBasedOnHalVersion(expectedSuccess);
3455         bundle = new PersistableBundle();
3456         bundle.putBoolean(
3457                 CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL, true);
3458         PersistableBundle plmnBundle = new PersistableBundle();
3459         int[] intArray1 = {3, 5};
3460         int[] intArray2 = {3};
3461         plmnBundle.putIntArray("123411", intArray1);
3462         plmnBundle.putIntArray("123412", intArray2);
3463         bundle.putPersistableBundle(
3464                 CarrierConfigManager.KEY_CARRIER_SUPPORTED_SATELLITE_SERVICES_PER_PROVIDER_BUNDLE,
3465                 plmnBundle);
3466         overrideCarrierConfig(sTestSubIDForCarrierSatellite, bundle);
3467 
3468         ArrayList<String> expectedCarrierPlmnList = new ArrayList<>();
3469         expectedCarrierPlmnList.add("123411");
3470         expectedCarrierPlmnList.add("123412");
3471         assertTrue(waitForEventOnSetSatellitePlmn(1));
3472 
3473         List<String> carrierPlmnList = getCarrierPlmnList();
3474         assertNotNull(carrierPlmnList);
3475         assertEquals(expectedCarrierPlmnList, carrierPlmnList);
3476         List<String> satellitePlmnListFromOverlayConfig =
3477                 sMockSatelliteServiceManager.getPlmnListFromOverlayConfig();
3478         List<String> expectedAllSatellitePlmnList =
3479                 SatelliteServiceUtils.mergeStrLists(
3480                         carrierPlmnList,
3481                         satellitePlmnListFromOverlayConfig,
3482                         allPlmnListBeforeCarrierConfigOverride);
3483         List<String> allSatellitePlmnList = getAllSatellitePlmnList();
3484         assertNotNull(allSatellitePlmnList);
3485         boolean listsAreEqual =
3486                 expectedAllSatellitePlmnList.containsAll(allSatellitePlmnList)
3487                         && allSatellitePlmnList.containsAll(expectedAllSatellitePlmnList);
3488         assertTrue(listsAreEqual);
3489 
3490         requestSatelliteAttachEnabledForCarrier(true, expectedSuccess);
3491 
3492         pair = requestIsSatelliteAttachEnabledForCarrier();
3493         assertEquals(true, pair.first.booleanValue());
3494         assertNull(pair.second);
3495 
3496         /* Test when satellite is supported, and requested satellite disabled */
3497         requestSatelliteAttachEnabledForCarrier(false, expectedSuccess);
3498         assertEquals(false, getIsSatelliteEnabledForCarrierFromMockService());
3499         pair = requestIsSatelliteAttachEnabledForCarrier();
3500         assertEquals(false, pair.first.booleanValue());
3501         assertNull(pair.second);
3502 
3503         /* Test when satellite is supported, but modem returns INVALID_MODEM_STATE */
3504         expectedError = SatelliteManager.SATELLITE_RESULT_INVALID_MODEM_STATE;
3505         setSatelliteErrorBasedOnHalVersion(expectedError);
3506         requestSatelliteAttachEnabledForCarrier(true, expectedError);
3507 
3508         pair = requestIsSatelliteAttachEnabledForCarrier();
3509         assertEquals(true, pair.first.booleanValue());
3510         assertNull(pair.second);
3511 
3512         /* Test when satellite is supported, and requested satellite disabled */
3513         expectedError = SatelliteManager.SATELLITE_RESULT_SUCCESS;
3514         requestSatelliteAttachEnabledForCarrier(false, expectedError);
3515         assertEquals(false, getIsSatelliteEnabledForCarrierFromMockService());
3516         pair = requestIsSatelliteAttachEnabledForCarrier();
3517         assertEquals(false, pair.first.booleanValue());
3518         assertNull(pair.second);
3519 
3520         /* Test when satellite is supported, but modem returns RADIO_NOT_AVAILABLE */
3521         expectedError = SatelliteManager.SATELLITE_RESULT_RADIO_NOT_AVAILABLE;
3522         setSatelliteErrorBasedOnHalVersion(expectedError);
3523         requestSatelliteAttachEnabledForCarrier(true, expectedError);
3524 
3525         pair = requestIsSatelliteAttachEnabledForCarrier();
3526         assertEquals(true, pair.first.booleanValue());
3527         assertNull(pair.second);
3528 
3529         afterSatelliteForCarrierTest();
3530         revokeSatellitePermission();
3531     }
3532 
3533     @Ignore("b/399928350 - Need to fix and re-enable this test.")
3534     @Test
testSatelliteAttachRestrictionForCarrier()3535     public void testSatelliteAttachRestrictionForCarrier() {
3536         logd("testSatelliteAttachRestrictionForCarrier");
3537         grantSatellitePermission();
3538         beforeSatelliteForCarrierTest();
3539         clearSatelliteEnabledForCarrier();
3540         @SatelliteManager.SatelliteResult int expectedSuccess =
3541                 SatelliteManager.SATELLITE_RESULT_SUCCESS;
3542 
3543         /* Test when satellite is supported but there is a restriction reason */
3544         setSatelliteErrorBasedOnHalVersion(expectedSuccess);
3545         PersistableBundle bundle = new PersistableBundle();
3546         bundle.putBoolean(
3547                 CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL, true);
3548         overrideCarrierConfig(sTestSubIDForCarrierSatellite, bundle);
3549         int restrictionReason = SATELLITE_COMMUNICATION_RESTRICTION_REASON_GEOLOCATION;
3550         requestAddSatelliteAttachRestrictionForCarrier(restrictionReason,
3551                 SatelliteManager.SATELLITE_RESULT_SUCCESS);
3552         verifySatelliteAttachRestrictionForCarrier(restrictionReason, true);
3553         requestSatelliteAttachEnabledForCarrier(true, expectedSuccess);
3554         Pair<Boolean, Integer> pair = requestIsSatelliteAttachEnabledForCarrier();
3555         assertEquals(true, pair.first.booleanValue());
3556         assertNull(pair.second);
3557         assertEquals(false, getIsSatelliteEnabledForCarrierFromMockService());
3558 
3559         /* If the restriction reason 'GEOLOCATION' is removed and the restriction reason is
3560            empty, re-evaluate and trigger enable/disable again */
3561         requestRemoveSatelliteAttachRestrictionForCarrier(restrictionReason,
3562                 SatelliteManager.SATELLITE_RESULT_SUCCESS);
3563         verifySatelliteAttachRestrictionForCarrier(restrictionReason, false);
3564         assertEquals(true, getIsSatelliteEnabledForCarrierFromMockService());
3565 
3566         /* If the restriction reason 'GEOLOCATION' is added and the restriction reason becomes
3567            'GEOLOCATION', re-evaluate and trigger enable/disable again */
3568         requestAddSatelliteAttachRestrictionForCarrier(restrictionReason,
3569                 SatelliteManager.SATELLITE_RESULT_SUCCESS);
3570         verifySatelliteAttachRestrictionForCarrier(restrictionReason, true);
3571         assertEquals(false, getIsSatelliteEnabledForCarrierFromMockService());
3572 
3573         /* If the restriction reason 'ENTITLEMENT' is added and the restriction reasons become
3574            ‘GEOLOCATION’ and ‘ENTITLEMENT.’ re-evaluate and trigger enable/disable again */
3575         restrictionReason = SATELLITE_COMMUNICATION_RESTRICTION_REASON_ENTITLEMENT;
3576         requestAddSatelliteAttachRestrictionForCarrier(restrictionReason,
3577                 SatelliteManager.SATELLITE_RESULT_SUCCESS);
3578         verifySatelliteAttachRestrictionForCarrier(restrictionReason, true);
3579         assertEquals(false, getIsSatelliteEnabledForCarrierFromMockService());
3580 
3581         /* If the restriction reason 'ENTITLEMENT' is removed and the restriction reason becomes
3582            ‘GEOLOCATION’, re-evaluate and trigger enable/disable again */
3583         requestRemoveSatelliteAttachRestrictionForCarrier(restrictionReason,
3584                 SatelliteManager.SATELLITE_RESULT_SUCCESS);
3585         restrictionReason = SATELLITE_COMMUNICATION_RESTRICTION_REASON_GEOLOCATION;
3586         verifySatelliteAttachRestrictionForCarrier(restrictionReason, true);
3587         assertEquals(false, getIsSatelliteEnabledForCarrierFromMockService());
3588 
3589         /* If the restriction reason 'GEOLOCATION' is removed and the restriction reason becomes
3590             empty, re-evaluate and trigger enable/disable again */
3591         requestRemoveSatelliteAttachRestrictionForCarrier(restrictionReason,
3592                 SatelliteManager.SATELLITE_RESULT_SUCCESS);
3593         verifySatelliteAttachRestrictionForCarrier(restrictionReason, false);
3594         assertEquals(true, getIsSatelliteEnabledForCarrierFromMockService());
3595 
3596         afterSatelliteForCarrierTest();
3597         revokeSatellitePermission();
3598     }
3599 
3600     @Test
testNtnSignalStrength()3601     public void testNtnSignalStrength() {
3602         logd("testNtnSignalStrength: start");
3603         grantSatellitePermission();
3604 
3605         NtnSignalStrengthCallbackTest ntnSignalStrengthCallbackTest =
3606                 new NtnSignalStrengthCallbackTest();
3607 
3608         /* register callback for non-terrestrial network signal strength changed event */
3609         sSatelliteManager.registerForNtnSignalStrengthChanged(getContext().getMainExecutor(),
3610                 ntnSignalStrengthCallbackTest);
3611 
3612         @NtnSignalStrength.NtnSignalStrengthLevel int expectedLevel =
3613                 NtnSignalStrength.NTN_SIGNAL_STRENGTH_NONE;
3614         @SatelliteManager.SatelliteResult int expectedError;
3615         setSatelliteError(SatelliteManager.SATELLITE_RESULT_SUCCESS);
3616         setNtnSignalStrength(expectedLevel);
3617         Pair<NtnSignalStrength, Integer> pairResult = requestNtnSignalStrength();
3618         assertEquals(expectedLevel, pairResult.first.getLevel());
3619         assertNull(pairResult.second);
3620 
3621         expectedLevel = NtnSignalStrength.NTN_SIGNAL_STRENGTH_GOOD;
3622         expectedError = SATELLITE_RESULT_MODEM_ERROR;
3623         setSatelliteError(expectedError);
3624         setNtnSignalStrength(expectedLevel);
3625         pairResult = requestNtnSignalStrength();
3626         assertNull(pairResult.first);
3627         assertEquals(expectedError, pairResult.second.intValue());
3628 
3629         expectedLevel = NtnSignalStrength.NTN_SIGNAL_STRENGTH_GOOD;
3630         expectedError = SatelliteManager.SATELLITE_RESULT_SUCCESS;
3631         setSatelliteError(expectedError);
3632         setNtnSignalStrength(expectedLevel);
3633         pairResult = requestNtnSignalStrength();
3634         assertEquals(expectedLevel, pairResult.first.getLevel());
3635         assertNull(pairResult.second);
3636 
3637         /* As non-terrestrial network signal strength is cached in framework, simple set won't
3638         affect cached value */
3639         expectedLevel = NtnSignalStrength.NTN_SIGNAL_STRENGTH_GREAT;
3640         setNtnSignalStrength(expectedLevel);
3641         pairResult = requestNtnSignalStrength();
3642         assertNotEquals(expectedLevel, pairResult.first.getLevel());
3643         assertNull(pairResult.second);
3644 
3645         /* Cache will be updated when non-terrestrial network signal strength changed event comes */
3646         ntnSignalStrengthCallbackTest.drainPermits();
3647         sendOnNtnSignalStrengthChanged(expectedLevel);
3648         assertTrue(ntnSignalStrengthCallbackTest.waitUntilResult(1));
3649         pairResult = requestNtnSignalStrength();
3650         assertEquals(expectedLevel, pairResult.first.getLevel());
3651         assertNull(pairResult.second);
3652         assertEquals(expectedLevel, ntnSignalStrengthCallbackTest.mNtnSignalStrength.getLevel());
3653 
3654         ntnSignalStrengthCallbackTest.drainPermits();
3655         expectedLevel = NtnSignalStrength.NTN_SIGNAL_STRENGTH_MODERATE;
3656         sendOnNtnSignalStrengthChanged(expectedLevel);
3657         assertTrue(ntnSignalStrengthCallbackTest.waitUntilResult(1));
3658         pairResult = requestNtnSignalStrength();
3659         assertEquals(expectedLevel, pairResult.first.getLevel());
3660         assertNull(pairResult.second);
3661         assertEquals(expectedLevel, ntnSignalStrengthCallbackTest.mNtnSignalStrength.getLevel());
3662 
3663         /* Initialize the non-terrestrial signal strength cache in the framework */
3664         ntnSignalStrengthCallbackTest.drainPermits();
3665         expectedLevel = NtnSignalStrength.NTN_SIGNAL_STRENGTH_NONE;
3666         sendOnNtnSignalStrengthChanged(expectedLevel);
3667         assertTrue(ntnSignalStrengthCallbackTest.waitUntilResult(1));
3668         pairResult = requestNtnSignalStrength();
3669         assertEquals(expectedLevel, pairResult.first.getLevel());
3670         assertNull(pairResult.second);
3671         assertEquals(expectedLevel, ntnSignalStrengthCallbackTest.mNtnSignalStrength.getLevel());
3672 
3673         /* unregister non-terrestrial network signal strength changed event callback */
3674         sSatelliteManager.unregisterForNtnSignalStrengthChanged(ntnSignalStrengthCallbackTest);
3675 
3676         revokeSatellitePermission();
3677     }
3678 
3679     @Ignore("b/377926997 - This test is failing due to the recent change in capabilities.")
3680     @Test
testRegisterForCapabilitiesChanged()3681     public void testRegisterForCapabilitiesChanged() {
3682         logd("testRegisterForCapabilitiesChanged: start");
3683         grantSatellitePermission();
3684 
3685         android.telephony.satellite.stub.SatelliteCapabilities capabilities =
3686                 new android.telephony.satellite.stub.SatelliteCapabilities();
3687         int[] supportedRadioTechnologies =
3688                 new int[]{android.telephony.satellite.stub.NTRadioTechnology.NB_IOT_NTN};
3689         capabilities.supportedRadioTechnologies = supportedRadioTechnologies;
3690         int[] antennaPositionKeys = new int[]{
3691                 SatelliteManager.DISPLAY_MODE_OPENED, SatelliteManager.DISPLAY_MODE_CLOSED};
3692         AntennaPosition[] antennaPositionValues =
3693                 new AntennaPosition[] {
3694                     new AntennaPosition(
3695                             new AntennaDirection(1, 1, 1),
3696                             SatelliteManager.DEVICE_HOLD_POSITION_PORTRAIT),
3697                     new AntennaPosition(
3698                             new AntennaDirection(2, 2, 2),
3699                             SatelliteManager.DEVICE_HOLD_POSITION_LANDSCAPE_LEFT)
3700                 };
3701 
3702         capabilities.isPointingRequired = POINTING_TO_SATELLITE_REQUIRED;
3703         capabilities.maxBytesPerOutgoingDatagram = MAX_BYTES_PER_DATAGRAM;
3704         capabilities.antennaPositionKeys = antennaPositionKeys;
3705         capabilities.antennaPositionValues = antennaPositionValues;
3706         SatelliteCapabilities frameworkCapabilities =
3707                 SatelliteServiceUtils.fromSatelliteCapabilities(capabilities);
3708         SatelliteCapabilitiesCallbackTest satelliteCapabilitiesCallbackTest =
3709                 new SatelliteCapabilitiesCallbackTest();
3710 
3711         /* register callback for satellite capabilities changed event */
3712         @SatelliteManager.SatelliteResult int registerError =
3713                 sSatelliteManager.registerForCapabilitiesChanged(
3714                         getContext().getMainExecutor(), satelliteCapabilitiesCallbackTest);
3715         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerError);
3716 
3717         /* Verify whether capability changed event has received */
3718         sendOnSatelliteCapabilitiesChanged(capabilities);
3719         assertTrue(satelliteCapabilitiesCallbackTest.waitUntilResult(1));
3720         assertTrue(frameworkCapabilities
3721                 .equals(satelliteCapabilitiesCallbackTest.mSatelliteCapabilities));
3722 
3723         /* Verify whether notified and requested capabilities are equal */
3724         Pair<SatelliteCapabilities, Integer> pairResult = requestSatelliteCapabilities();
3725         assertTrue(frameworkCapabilities.equals(pairResult.first));
3726         assertNull(pairResult.second);
3727 
3728         /* datagram size has changed */
3729         capabilities.maxBytesPerOutgoingDatagram = MAX_BYTES_PER_DATAGRAM + 1;
3730         frameworkCapabilities = SatelliteServiceUtils.fromSatelliteCapabilities(capabilities);
3731 
3732         /* Verify changed capabilities are reflected */
3733         sendOnSatelliteCapabilitiesChanged(capabilities);
3734         assertTrue(satelliteCapabilitiesCallbackTest.waitUntilResult(1));
3735         assertTrue(frameworkCapabilities
3736                 .equals(satelliteCapabilitiesCallbackTest.mSatelliteCapabilities));
3737 
3738         pairResult = requestSatelliteCapabilities();
3739         assertTrue(frameworkCapabilities.equals(pairResult.first));
3740         assertNull(pairResult.second);
3741 
3742         /* Initialize Radio technology */
3743         supportedRadioTechnologies =
3744                 new int[]{android.telephony.satellite.stub.NTRadioTechnology.PROPRIETARY};
3745         capabilities.supportedRadioTechnologies = supportedRadioTechnologies;
3746         sendOnSatelliteCapabilitiesChanged(capabilities);
3747         /* unregister non-terrestrial network signal strength changed event callback */
3748         sSatelliteManager.unregisterForCapabilitiesChanged(
3749                 satelliteCapabilitiesCallbackTest);
3750 
3751         revokeSatellitePermission();
3752     }
3753 
3754     @Test
testRegisterForSelectedNbIotSatelliteSubscriptionChanged()3755     public void testRegisterForSelectedNbIotSatelliteSubscriptionChanged() {
3756         logd("testRegisterForSelectedNbIotSatelliteSubscriptionChanged: start");
3757         grantSatellitePermission();
3758 
3759         SelectedNbIotSatelliteSubscriptionCallbackTest
3760                 selectedNbIotSatelliteSubscriptionCallbackTest =
3761                         new SelectedNbIotSatelliteSubscriptionCallbackTest();
3762 
3763         /* register callback for satellite subscription id changed event */
3764         @SatelliteManager.SatelliteResult int registerError =
3765                 sSatelliteManager.registerForSelectedNbIotSatelliteSubscriptionChanged(
3766                         getContext().getMainExecutor(),
3767                         selectedNbIotSatelliteSubscriptionCallbackTest);
3768         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerError);
3769 
3770         /* Wait for the callback to be called */
3771         assertTrue(selectedNbIotSatelliteSubscriptionCallbackTest.waitUntilResult(1));
3772 
3773         /* Verify whether notified and requested subscription are equal */
3774         Pair<Integer, Integer> pairResult = requestSelectedNbIotSatelliteSubscriptionId();
3775         assertEquals(selectedNbIotSatelliteSubscriptionCallbackTest.mSelectedSubId,
3776                 (long) pairResult.first);
3777         assertNull(pairResult.second);
3778 
3779         /* unregister */
3780         sSatelliteManager.unregisterForSelectedNbIotSatelliteSubscriptionChanged(
3781                 selectedNbIotSatelliteSubscriptionCallbackTest);
3782 
3783         revokeSatellitePermission();
3784     }
3785 
3786     @Test
testSendSatelliteDatagram_DemoMode_WithDeviceConfig()3787     public void testSendSatelliteDatagram_DemoMode_WithDeviceConfig() {
3788         logd("testSendSatelliteDatagram_DemoMode_WithDeviceConfig");
3789         grantSatellitePermission();
3790         assertTrue(isSatelliteProvisioned());
3791 
3792         SatelliteModemStateCallbackTest stateCallback = new SatelliteModemStateCallbackTest();
3793         sSatelliteManager.registerForModemStateChanged(
3794                 getContext().getMainExecutor(), stateCallback);
3795         assertTrue(stateCallback.waitUntilResult(1));
3796 
3797         // Enable satellite with demo mode on
3798         if (isSatelliteEnabled()) {
3799             requestSatelliteEnabled(false);
3800             assertTrue(stateCallback.waitUntilModemOff());
3801             stateCallback.clearModemStates();
3802         }
3803         requestSatelliteEnabledForDemoMode(true);
3804         assertTrue(stateCallback.waitUntilResult(2));
3805         assertTrue(isSatelliteEnabled());
3806         assertTrue(getIsEmergency());
3807         assertTrue(sMockSatelliteServiceManager.setShouldSendDatagramToModemInDemoMode(false));
3808 
3809         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
3810         SatelliteTransmissionUpdateCallbackTest callback =
3811                 new SatelliteTransmissionUpdateCallbackTest();
3812         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
3813                 resultListener::offer, callback);
3814         Integer errorCode;
3815         try {
3816             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
3817         } catch (InterruptedException ex) {
3818             fail("testSendSatelliteDatagram_DemoMode_WithDeviceConfig: Got InterruptedException "
3819                     + "in waiting for the startSatelliteTransmissionUpdates result code");
3820             return;
3821         }
3822         assertNotNull(errorCode);
3823         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
3824 
3825         // Send satellite datagram
3826         String mText = "This is a test datagram message from user";
3827         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
3828         assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(false,
3829                 DatagramController.TIMEOUT_TYPE_DATAGRAM_DELAY_IN_DEMO_MODE,
3830                 TEST_DATAGRAM_DELAY_IN_DEMO_MODE_TIMEOUT_MILLIS));
3831         callback.clearSendDatagramStateChanges();
3832         sMockSatelliteServiceManager.setErrorCode(SatelliteManager.SATELLITE_RESULT_SUCCESS);
3833         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
3834                 datagram, true, getContext().getMainExecutor(),
3835                 resultListener::offer);
3836         sSatelliteManager.setDeviceAlignedWithSatellite(true);
3837         // Satellite datagram does not send to satellite modem.
3838         sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(0);
3839         try {
3840             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
3841         } catch (InterruptedException ex) {
3842             fail("testSendSatelliteDatagram_DemoMode_WithDeviceConfig: Got InterruptedException "
3843                     + "in waiting for the sendDatagram result code");
3844             return;
3845         }
3846         assertNotNull(errorCode);
3847         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
3848 
3849         /*
3850          * Send datagram transfer state should have the following transitions:
3851          * 1) IDLE to SENDING
3852          * 2) SENDING to SEND_SUCCESS
3853          * 3) SEND_SUCCESS to IDLE
3854          */
3855         int expectedNumOfEvents = 3;
3856         assertTrue(callback.waitUntilOnSendDatagramStateChanged(expectedNumOfEvents));
3857         assertThat(callback.getNumOfSendDatagramStateChanges()).isEqualTo(expectedNumOfEvents);
3858         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
3859                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3860                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
3861                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
3862         assertThat(callback.getSendDatagramStateChange(1)).isEqualTo(
3863                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3864                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_SUCCESS,
3865                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
3866         assertThat(callback.getSendDatagramStateChange(2)).isEqualTo(
3867                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
3868                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
3869                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
3870 
3871         callback.clearSendDatagramStateChanges();
3872         sSatelliteManager.stopTransmissionUpdates(callback, getContext().getMainExecutor(),
3873                 resultListener::offer);
3874         sSatelliteManager.unregisterForModemStateChanged(stateCallback);
3875         assertTrue(sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(true,
3876                 DatagramController.TIMEOUT_TYPE_DATAGRAM_DELAY_IN_DEMO_MODE, 0));
3877         revokeSatellitePermission();
3878     }
3879 
3880     @Test
testSatelliteAccessControl()3881     public void testSatelliteAccessControl() {
3882         grantSatellitePermission();
3883         assertTrue(sMockSatelliteServiceManager
3884                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache(
3885                         "cache_clear_and_not_allowed"));
3886         SatelliteCommunicationAccessStateCallbackTest allowStatecallback =
3887                 new SatelliteCommunicationAccessStateCallbackTest();
3888         long registerResultAllowState =
3889                 sSatelliteManager.registerForCommunicationAccessStateChanged(
3890                         getContext().getMainExecutor(), allowStatecallback);
3891         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResultAllowState);
3892         assertTrue(allowStatecallback.waitUntilResult(1));
3893         assertFalse(allowStatecallback.isAllowed);
3894 
3895         /*
3896         // Test access controller using cached country codes
3897         assertTrue(sMockSatelliteServiceManager.setSatelliteAccessControlOverlayConfigs(
3898                 false, true, null, 0, SATELLITE_COUNTRY_CODES));
3899 
3900         verifyIsSatelliteAllowed(true);
3901 
3902         // Allowed case
3903         assertTrue(sMockSatelliteServiceManager.setCountryCodes(false, null, null, "US",
3904                 SystemClock.elapsedRealtimeNanos()));
3905         verifyIsSatelliteAllowed(true);
3906         assertTrue(allowStatecallback.waitUntilResult(0));
3907 
3908         // Disallowed case
3909         assertTrue(sMockSatelliteServiceManager.setCountryCodes(false, null, null, "IN",
3910                 SystemClock.elapsedRealtimeNanos()));
3911         verifyIsSatelliteAllowed(false);
3912         assertTrue(allowStatecallback.waitUntilResult(1));
3913         assertFalse(allowStatecallback.isAllowed);
3914         */
3915 
3916         // Test access controller using on-device data
3917         assertTrue(sMockSatelliteServiceManager.setCountryCodes(false, null, null, null, 0));
3918         assertTrue(sMockSatelliteServiceManager.setSatelliteAccessControlOverlayConfigs(
3919                 false, true, SATELLITE_S2_FILE, TimeUnit.MINUTES.toNanos(0), "US", null));
3920         registerTestLocationProvider();
3921 
3922         // Set current location to Google San Diego office
3923         setTestProviderLocation(32.909808231041644, -117.18185788819781);
3924         verifyIsSatelliteAllowed(true);
3925         assertTrue(allowStatecallback.waitUntilResult(1));
3926         assertTrue(allowStatecallback.isAllowed);
3927 
3928         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
3929         long registerResult = sSatelliteManager.registerForModemStateChanged(
3930                 getContext().getMainExecutor(), callback);
3931         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
3932         assertTrue(callback.waitUntilResult(1));
3933         callback.clearModemStates();
3934         if (!isSatelliteEnabled()) {
3935             requestSatelliteEnabled(true);
3936             assertTrue(callback.waitUntilResult(2));
3937             assertEquals(2, callback.getTotalCountOfModemStates());
3938             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
3939                     callback.getModemState(0));
3940             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback.getModemState(1));
3941             assertTrue(isSatelliteEnabled());
3942             callback.clearModemStates();
3943         }
3944 
3945         assertTrue(sMockSatelliteServiceManager
3946                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("clear_cache_only"));
3947 
3948         // Set current location to Google Bangalore office
3949         setTestProviderLocation(12.994021769576554, 12.994021769576554);
3950         verifyIsSatelliteAllowed(false);
3951         assertTrue(allowStatecallback.waitUntilResult(1));
3952         assertFalse(allowStatecallback.isAllowed);
3953 
3954         // Since satellite is not allowed at the current location, satellite should be disabled
3955         assertTrue(callback.waitUntilModemOff());
3956         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
3957         assertFalse(isSatelliteEnabled());
3958 
3959         // Restore satellite access allowed
3960         setUpSatelliteAccessAllowed();
3961         revokeSatellitePermission();
3962         unregisterTestLocationProvider();
3963     }
3964 
verifySatelliteAllowedAndEnabledForLocation(double lat, double lng, String countryCode)3965     void verifySatelliteAllowedAndEnabledForLocation(double lat, double lng, String countryCode) {
3966         logd(
3967                 "verifySatelliteAllowedAndEnabledForLocation: verifying if satellite is allowed and"
3968                         + " enabled for location: lat="
3969                         + lat
3970                         + ", lng="
3971                         + lng
3972                         + ", country code="
3973                         + countryCode);
3974 
3975         // setup permission
3976         grantSatellitePermission();
3977 
3978         // set given lat, lng location
3979         logd("verifySatelliteAllowedAndEnabledForLocation: setting test provider location");
3980         setTestProviderLocation(lat, lng);
3981 
3982         // set given country code as network country code
3983         logd("verifySatelliteAllowedAndEnabledForLocation: setting country code: " + countryCode);
3984         assertTrue(sMockSatelliteServiceManager.setCountryCodes(false, countryCode, null, null, 0));
3985 
3986         logd("verifySatelliteAllowedAndEnabledForLocation: Clearing satellite allowed cache");
3987         assertTrue(
3988                 sMockSatelliteServiceManager
3989                         .setIsSatelliteCommunicationAllowedForCurrentLocationCache(
3990                                 "clear_cache_only"));
3991 
3992         // verify satellite is allowed
3993         logd("verifySatelliteAllowedAndEnabledForLocation: verify satellite is allowed");
3994         verifyIsSatelliteAllowed(true);
3995     }
3996 
verifySatelliteNotAllowedAndNotEnabledForLocation( double lat, double lng, String countryCode)3997     void verifySatelliteNotAllowedAndNotEnabledForLocation(
3998             double lat, double lng, String countryCode) {
3999         logd(
4000                 "verifySatelliteNotAllowedAndNotEnabledForLocation: verifying if satellite is not"
4001                         + " allowed and not enabled for location: lat="
4002                         + lat
4003                         + ", lng="
4004                         + lng
4005                         + ", country code="
4006                         + countryCode);
4007 
4008         // setup permission
4009         grantSatellitePermission();
4010 
4011         // set give lat, lng location
4012         logd("verifySatelliteNotAllowedAndNotEnabledForLocation: setting test provider location");
4013         setTestProviderLocation(lat, lng);
4014 
4015         // set given country code as network country code
4016         logd(
4017                 "verifySatelliteNotAllowedAndNotEnabledForLocation: setting country code: "
4018                         + countryCode);
4019         assertTrue(sMockSatelliteServiceManager.setCountryCodes(false, countryCode, null, null, 0));
4020 
4021         logd("verifySatelliteNotAllowedAndNotEnabledForLocation: Clearing satellite allowed cache");
4022         assertTrue(
4023                 sMockSatelliteServiceManager
4024                         .setIsSatelliteCommunicationAllowedForCurrentLocationCache(
4025                                 "clear_cache_only"));
4026 
4027         // verify satellite is not allowed
4028         logd("verifySatelliteNotAllowedAndNotEnabledForLocation: verify satellite is not allowed");
4029         verifyIsSatelliteAllowed(false);
4030     }
4031 
performSatelliteConfigUpdate(String contentUrl, String metadataUrl)4032     private void performSatelliteConfigUpdate(String contentUrl, String metadataUrl)
4033             throws Exception {
4034         logd(
4035                 "performSatelliteConfigUpdate: contentUrl: "
4036                         + contentUrl
4037                         + ", metadataUrl: "
4038                         + metadataUrl);
4039 
4040         Intent intent =
4041                 new Intent("com.google.android.configupdater.TelephonyConfigUpdate.UPDATE_CONFIG");
4042         intent.setPackage("com.google.android.configupdater");
4043         intent.putExtra("CONTENT_URL", contentUrl);
4044         intent.putExtra("METADATA_URL", metadataUrl);
4045 
4046         // Send the broadcast
4047         logd("performSatelliteConfigUpdate: Firing broadcast to trigger satellite config update");
4048         getContext().sendBroadcast(intent);
4049 
4050         logd("performSatelliteConfigUpdate: Sleeping for satellite config to be applied");
4051         // Wait for the config to be applied (3 seconds)
4052         Thread.sleep(3000);
4053     }
4054 
4055     @Ignore("b/399900477 - Need to fix the test and re-enable it.")
4056     @Test
testSatelliteAccessControlWithSatelliteConfigOta()4057     public void testSatelliteAccessControlWithSatelliteConfigOta() throws Exception {
4058         logd("testSatelliteAccessControlWithSatelliteConfigOta");
4059 
4060         // get rid of the overriden test satellite configs, as we are going
4061         // to use actual on-device and ota'd satellite configs in this test
4062         resetSatelliteAccessControlOverlayConfigs();
4063 
4064         // setup permission
4065         grantSatellitePermission();
4066 
4067         // reset satellite allowance state
4068         logd("testSatelliteAccessControlWithSatelliteConfigOta: reset satellite allowance state");
4069         assertTrue(
4070                 sMockSatelliteServiceManager
4071                         .setIsSatelliteCommunicationAllowedForCurrentLocationCache(
4072                                 "cache_clear_and_not_allowed"));
4073 
4074         double latUs = 37.7749, lngUs = -122.4194;
4075         String countryCodeUs = "US";
4076         double latKr = 37.5665, lngKr = 126.9780;
4077         String countryCodeKr = "KR";
4078         double latTw = 25.034, lngTw = 121.565;
4079         String countryCodeTw = "TW";
4080 
4081         // register test location provider
4082         logd("testSatelliteAccessControlWithSatelliteConfigOta: register test location provider");
4083         registerTestLocationProvider();
4084 
4085         // Check satellite allowance for on device satellite config:
4086         // US - allowed; KR - not allowed; TW - not allowed;
4087         logd(
4088                 "testSatelliteAccessControlWithSatelliteConfigOta: checking satellite allowance for"
4089                         + " on device satellite config");
4090         verifySatelliteAllowedAndEnabledForLocation(latUs, lngUs, countryCodeUs);
4091         verifySatelliteNotAllowedAndNotEnabledForLocation(latKr, lngKr, countryCodeKr);
4092         verifySatelliteNotAllowedAndNotEnabledForLocation(latTw, lngTw, countryCodeTw);
4093 
4094         // perform OTA to setup v15 satellite config data
4095         logd("testSatelliteAccessControlWithSatelliteConfigOta: Perform v15 config update");
4096         performSatelliteConfigUpdate(
4097                 "https://www.gstatic.com/android/config_update/satelliteConfigDataTest/01212025"
4098                         + "-test-v15-telephony_config.pb",
4099                 "https://www.gstatic.com/android/config_update/satelliteConfigDataTest/01212025"
4100                         + "-test-v15-telephony_config-metadata.txt");
4101 
4102         // Check satellite allowance and enabled status for v15 satellite config:
4103         // US - allowed; KR - not allowed; TW - not allowed;
4104         logd(
4105                 "testSatelliteAccessControlWithSatelliteConfigOta: checking satellite allowance for"
4106                         + " v15 satellite config");
4107         verifySatelliteAllowedAndEnabledForLocation(latUs, lngUs, countryCodeUs);
4108         verifySatelliteNotAllowedAndNotEnabledForLocation(latKr, lngKr, countryCodeKr);
4109         verifySatelliteNotAllowedAndNotEnabledForLocation(latTw, lngTw, countryCodeTw);
4110 
4111         // perform OTA to setup v16 satellite config data
4112         logd("testSatelliteAccessControlWithSatelliteConfigOta: Perform v16 config update");
4113         performSatelliteConfigUpdate(
4114                 "https://www.gstatic.com/android/config_update/satelliteConfigDataTest/01212025"
4115                         + "-test-v16-telephony_config.pb",
4116                 "https://www.gstatic.com/android/config_update/satelliteConfigDataTest/01212025"
4117                         + "-test-v16-telephony_config-metadata.txt");
4118 
4119         // Check satellite allowance and enabled status for v16 satellite config:
4120         // US - allowed; KR - allowed; TW - allowed;
4121         logd(
4122                 "testSatelliteAccessControlWithSatelliteConfigOta: checking satellite allowance for"
4123                         + " v16 satellite config");
4124         verifySatelliteAllowedAndEnabledForLocation(latUs, lngUs, countryCodeUs);
4125         verifySatelliteAllowedAndEnabledForLocation(latKr, lngKr, countryCodeKr);
4126         verifySatelliteAllowedAndEnabledForLocation(latTw, lngTw, countryCodeTw);
4127 
4128         // perform OTA to setup v17 satellite config data
4129         logd("testSatelliteAccessControlWithSatelliteConfigOta: Perform v17 config update");
4130         performSatelliteConfigUpdate(
4131                 "https://www.gstatic.com/android/config_update/satelliteConfigDataTest/01212025"
4132                         + "-test-v17-telephony_config.pb",
4133                 "https://www.gstatic.com/android/config_update/satelliteConfigDataTest/01212025"
4134                         + "-test-v17-telephony_config-metadata.txt");
4135 
4136         // Check satellite allowance and enabled status for v17 satellite config:
4137         // US - allowed; KR - not allowed; TW - not allowed;
4138         logd(
4139                 "testSatelliteAccessControlWithSatelliteConfigOta: checking satellite allowance for"
4140                         + " v17 satellite config");
4141         verifySatelliteAllowedAndEnabledForLocation(latUs, lngUs, countryCodeUs);
4142         verifySatelliteNotAllowedAndNotEnabledForLocation(latKr, lngKr, countryCodeKr);
4143         verifySatelliteNotAllowedAndNotEnabledForLocation(latTw, lngTw, countryCodeTw);
4144 
4145         revokeSatellitePermission();
4146         unregisterTestLocationProvider();
4147     }
4148 
4149     @Ignore("b/402543255 - Need to fix the test and re-enable it.")
4150     @Test
4151     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testSatelliteAccessControl_UpdateSelectionChannel()4152     public void testSatelliteAccessControl_UpdateSelectionChannel() {
4153         final long timeOut = TimeUnit.SECONDS.toMillis(1);
4154         grantSatellitePermission();
4155         assertTrue(sMockSatelliteServiceManager
4156                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache(
4157                         "cache_clear_and_not_allowed"));
4158         SatelliteCommunicationAccessStateCallbackTest allowStateCallback =
4159                 new SatelliteCommunicationAccessStateCallbackTest();
4160         long registerResultAllowState =
4161                 sSatelliteManager.registerForCommunicationAccessStateChanged(
4162                         getContext().getMainExecutor(), allowStateCallback);
4163         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResultAllowState);
4164         assertTrue(
4165                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4166         assertNull(allowStateCallback.getSatelliteAccessConfiguration());
4167         allowStateCallback.drainPermits();
4168         Pair<SatelliteAccessConfiguration, Integer> resultReceiver =
4169                 requestSatelliteAccessConfigurationForCurrentLocation();
4170         SatelliteAccessConfiguration queriedSatelliteAccessConfiguration = resultReceiver.first;
4171         assertNull(queriedSatelliteAccessConfiguration);
4172         assertEquals(SATELLITE_RESULT_NO_RESOURCES, (int) resultReceiver.second);
4173 
4174         // Test access controller using on-device data
4175         assertTrue(sMockSatelliteServiceManager.setSatelliteAccessControlOverlayConfigs(false, true,
4176                 SATELLITE_S2_FILE_WITH_CONFIG_ID, TimeUnit.MINUTES.toNanos(10), "US",
4177                 SATELLITE_ACCESS_CONFIGURATION_FILE));
4178         registerTestLocationProvider();
4179         grantSatellitePermission();
4180         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
4181         long registerResult = sSatelliteManager.registerForModemStateChanged(
4182                 getContext().getMainExecutor(), callback);
4183         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
4184         assertTrue(callback.waitUntilResult(1));
4185         if (isSatelliteEnabled()) {
4186             requestSatelliteEnabled(false);
4187             assertTrue(callback.waitUntilModemOff());
4188             assertFalse(isSatelliteEnabled());
4189         }
4190 
4191         // Set current location to Google San Diego office
4192         setTestProviderLocation(32.909808231041644, -117.18185788819781);
4193         assertTrue(sMockSatelliteServiceManager
4194                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("clear_cache_only"));
4195         verifyIsSatelliteAllowed(true);
4196         assertTrue(
4197                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4198         SatelliteAccessConfiguration notifiedSatelliteAccessConfiguration =
4199                 allowStateCallback.getSatelliteAccessConfiguration();
4200         assertNotNull(notifiedSatelliteAccessConfiguration);
4201         resultReceiver = requestSatelliteAccessConfigurationForCurrentLocation();
4202         queriedSatelliteAccessConfiguration = resultReceiver.first;
4203         assertNotNull(queriedSatelliteAccessConfiguration);
4204 
4205         // Trigger updateSystemSelectionChannels by enabling satellite.
4206         assertFalse(isSatelliteEnabled());
4207         allowStateCallback.drainPermits();
4208         requestSatelliteEnabled(true);
4209         assertTrue(isSatelliteEnabled());
4210         assertFalse(
4211                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4212 
4213         // Verify system selection info is correct
4214         // Use first configuration for San-Diego Office
4215         SatelliteAccessConfiguration expectedConfiguration =
4216                 getExpectedSatelliteConfiguration().getFirst();
4217         // Verify notified satellite access configuration has same value with expected.
4218         assertEquals(expectedConfiguration, notifiedSatelliteAccessConfiguration);
4219         // Verify return value for requestSatelliteAccessConfigurationForCurrentLocation has same
4220         // value with expected.
4221         assertEquals(expectedConfiguration, queriedSatelliteAccessConfiguration);
4222         // Verify modem received satellite access configuration has same value with expected.
4223         SystemSelectionSpecifier actualSystemSelectionSpecifier =
4224                 sMockSatelliteServiceManager.getSystemSelectionChannels().getFirst();
4225         verifySatelliteAccessConfiguration(expectedConfiguration, actualSystemSelectionSpecifier);
4226 
4227         // Set current location to Google MTV office
4228         assertTrue(sMockSatelliteServiceManager
4229                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("clear_cache_only"));
4230         setTestProviderLocation(37.422570063203494, -122.08560860200116);
4231         verifyIsSatelliteAllowed(true);
4232         assertTrue(
4233                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4234         notifiedSatelliteAccessConfiguration = allowStateCallback.getSatelliteAccessConfiguration();
4235         assertNotNull(notifiedSatelliteAccessConfiguration);
4236         resultReceiver = requestSatelliteAccessConfigurationForCurrentLocation();
4237         queriedSatelliteAccessConfiguration = resultReceiver.first;
4238         assertNotNull(queriedSatelliteAccessConfiguration);
4239 
4240         assertTrue(isSatelliteEnabled());
4241         allowStateCallback.drainPermits();
4242         requestSatelliteEnabled(false);
4243         assertTrue(callback.waitUntilModemOff());
4244         assertFalse(isSatelliteEnabled());
4245         assertFalse(
4246                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4247 
4248         // Trigger updateSystemSelectionChannels() by enabling satellite.
4249         requestSatelliteEnabled(true);
4250         assertTrue(isSatelliteEnabled());
4251 
4252         // Verify system selection info is correct
4253         // Use second configuration for MTV Office
4254         expectedConfiguration = getExpectedSatelliteConfiguration().get(1);
4255         // Verify notified satellite access configuration has same value with expected.
4256         assertEquals(expectedConfiguration, notifiedSatelliteAccessConfiguration);
4257         // Verify return value for requestSatelliteAccessConfigurationForCurrentLocation has same
4258         // value with expected.
4259         assertEquals(expectedConfiguration, queriedSatelliteAccessConfiguration);
4260         // Verify modem received satellite access configuration has same value with expected.
4261         actualSystemSelectionSpecifier =
4262                 sMockSatelliteServiceManager.getSystemSelectionChannels().getFirst();
4263         verifySatelliteAccessConfiguration(expectedConfiguration, actualSystemSelectionSpecifier);
4264 
4265         // Set current location to Hawaii
4266         assertTrue(sMockSatelliteServiceManager
4267                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("clear_cache_only"));
4268         setTestProviderLocation(19.50817482973673, -154.89161639216186);
4269         verifyIsSatelliteAllowed(true);
4270         assertTrue(
4271                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4272         notifiedSatelliteAccessConfiguration = allowStateCallback.getSatelliteAccessConfiguration();
4273         assertNotNull(notifiedSatelliteAccessConfiguration);
4274 
4275         assertTrue(isSatelliteEnabled());
4276         allowStateCallback.drainPermits();
4277         requestSatelliteEnabled(false);
4278         assertTrue(callback.waitUntilModemOff());
4279         assertFalse(isSatelliteEnabled());
4280         assertFalse(
4281                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4282 
4283         // Trigger updateSystemSelectionChannels() by enabling satellite.
4284         requestSatelliteEnabled(true);
4285         assertTrue(isSatelliteEnabled());
4286 
4287         // Verify system selection info is correct
4288         // Use 3rd configuration for Hawaii
4289         expectedConfiguration = getExpectedSatelliteConfiguration().get(2);
4290         // Verify notified satellite access configuration has same value with expected.
4291         assertEquals(expectedConfiguration, notifiedSatelliteAccessConfiguration);
4292         // Verify modem received satellite access configuration has same value with expected.
4293         actualSystemSelectionSpecifier =
4294                 sMockSatelliteServiceManager.getSystemSelectionChannels().getFirst();
4295         verifySatelliteAccessConfiguration(expectedConfiguration, actualSystemSelectionSpecifier);
4296 
4297         // Set current location to Alaska
4298         assertTrue(sMockSatelliteServiceManager
4299                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("clear_cache_only"));
4300         setTestProviderLocation(61.21729700371326, -149.89469126029147);
4301         verifyIsSatelliteAllowed(true);
4302         assertTrue(
4303                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4304         notifiedSatelliteAccessConfiguration = allowStateCallback.getSatelliteAccessConfiguration();
4305         assertNotNull(notifiedSatelliteAccessConfiguration);
4306         resultReceiver = requestSatelliteAccessConfigurationForCurrentLocation();
4307         queriedSatelliteAccessConfiguration = resultReceiver.first;
4308         assertNotNull(queriedSatelliteAccessConfiguration);
4309 
4310         assertTrue(isSatelliteEnabled());
4311         allowStateCallback.drainPermits();
4312         requestSatelliteEnabled(false);
4313         assertTrue(callback.waitUntilModemOff());
4314         assertFalse(isSatelliteEnabled());
4315         assertFalse(
4316                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4317 
4318         // Trigger updateSystemSelectionChannels() by enabling satellite.
4319         requestSatelliteEnabled(true);
4320         assertTrue(isSatelliteEnabled());
4321 
4322         // Verify system selection info is correct
4323         // Use 4th configuration for Alaska
4324         expectedConfiguration = getExpectedSatelliteConfiguration().get(3);
4325         // Verify notified satellite access configuration has same value with expected.
4326         assertEquals(expectedConfiguration, notifiedSatelliteAccessConfiguration);
4327         // Verify return value for requestSatelliteAccessConfigurationForCurrentLocation has same
4328         // value with expected.
4329         assertEquals(expectedConfiguration, queriedSatelliteAccessConfiguration);
4330         // Verify modem received satellite access configuration has same value with expected.
4331         actualSystemSelectionSpecifier =
4332                 sMockSatelliteServiceManager.getSystemSelectionChannels().getFirst();
4333         verifySatelliteAccessConfiguration(expectedConfiguration, actualSystemSelectionSpecifier);
4334 
4335         // Set current location to Puerto Rico
4336         assertTrue(sMockSatelliteServiceManager
4337                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("clear_cache_only"));
4338         setTestProviderLocation(18.466531136579068, -66.11359552551347);
4339         verifyIsSatelliteAllowed(true);
4340         assertTrue(
4341                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4342         notifiedSatelliteAccessConfiguration = allowStateCallback.getSatelliteAccessConfiguration();
4343         assertNotNull(notifiedSatelliteAccessConfiguration);
4344         resultReceiver = requestSatelliteAccessConfigurationForCurrentLocation();
4345         queriedSatelliteAccessConfiguration = resultReceiver.first;
4346         assertNotNull(queriedSatelliteAccessConfiguration);
4347 
4348         assertTrue(isSatelliteEnabled());
4349         allowStateCallback.drainPermits();
4350         requestSatelliteEnabled(false);
4351         assertTrue(callback.waitUntilModemOff());
4352         assertFalse(isSatelliteEnabled());
4353         assertFalse(
4354                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4355 
4356         // Trigger updateSystemSelectionChannels() by enabling satellite.
4357         requestSatelliteEnabled(true);
4358         assertTrue(isSatelliteEnabled());
4359 
4360         // Verify system selection info is correct
4361         // Use 5th configuration for Puerto Rico
4362         expectedConfiguration = getExpectedSatelliteConfiguration().get(4);
4363         // Verify notified satellite access configuration has same value with expected.
4364         assertEquals(expectedConfiguration, notifiedSatelliteAccessConfiguration);
4365         // Verify return value for requestSatelliteAccessConfigurationForCurrentLocation has same
4366         // value with expected.
4367         assertEquals(expectedConfiguration, queriedSatelliteAccessConfiguration);
4368         // Verify modem received satellite access configuration has same value with expected.
4369         actualSystemSelectionSpecifier =
4370                 sMockSatelliteServiceManager.getSystemSelectionChannels().getFirst();
4371         verifySatelliteAccessConfiguration(expectedConfiguration, actualSystemSelectionSpecifier);
4372 
4373         // Move location to not to support Satellite area.
4374         // Set current location to Google Bangalore office
4375         assertTrue(sMockSatelliteServiceManager
4376                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("clear_cache_only"));
4377         setTestProviderLocation(12.994021769576554, 12.994021769576554);
4378         verifyIsSatelliteAllowed(false);
4379         assertTrue(
4380                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4381         notifiedSatelliteAccessConfiguration = allowStateCallback.getSatelliteAccessConfiguration();
4382         // Those location where it does not have config id should return null.
4383         assertNull(notifiedSatelliteAccessConfiguration);
4384 
4385         assertTrue(isSatelliteEnabled());
4386         allowStateCallback.drainPermits();
4387         requestSatelliteEnabled(false);
4388         assertTrue(callback.waitUntilModemOff());
4389         assertFalse(isSatelliteEnabled());
4390         assertFalse(
4391                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4392         assertEquals(SATELLITE_RESULT_ACCESS_BARRED,
4393                 requestSatelliteEnabledWithResult(true, TIMEOUT));
4394         assertFalse(isSatelliteEnabled());
4395         assertFalse(
4396                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4397 
4398         // Even though satellite is not allowed at the current location, disabling satellite should
4399         // succeed
4400         requestSatelliteEnabled(false);
4401         assertFalse(isSatelliteEnabled());
4402         assertFalse(
4403                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4404 
4405         // Restore satellite access allowed
4406         setUpSatelliteAccessAllowed();
4407         revokeSatellitePermission();
4408         unregisterTestLocationProvider();
4409     }
4410 
4411     // The test data is stored at vendor/google/services/ConfigUpdater/assets/cts_data
4412     // /telephony_config_update/cts_test_01212025-test-v15-telephony_config.pb.
4413     // Refer to b/390075624#comment22 for more details.
getV15TestConfigForUs()4414     private SatelliteAccessConfiguration getV15TestConfigForUs() {
4415         // SatellitePosition
4416         SatellitePosition position = new SatellitePosition(-101.3, 35786.0);
4417 
4418         // EarfcnRange List
4419         List<EarfcnRange> earfcnRanges = new ArrayList<>();
4420         earfcnRanges.add(new EarfcnRange(229011, 229011));
4421         earfcnRanges.add(new EarfcnRange(229013, 229013));
4422         earfcnRanges.add(new EarfcnRange(229015, 229015));
4423         earfcnRanges.add(new EarfcnRange(229017, 229017));
4424 
4425         // bands List
4426         List<Integer> bands = List.of(255);
4427 
4428         // SatelliteInfo
4429         SatelliteInfo satelliteInfo =
4430                 new SatelliteInfo(
4431                         UUID.fromString("c9d78ffa-ffa5-4d41-a81b-34693b33b496"),
4432                         position,
4433                         bands,
4434                         earfcnRanges);
4435 
4436         // SatelliteInfo List
4437         List<SatelliteInfo> satelliteInfoList = List.of(satelliteInfo);
4438 
4439         // tagIds List
4440         List<Integer> tagIds = List.of(11, 1001);
4441 
4442         // create SatelliteAccessConfiguration
4443         SatelliteAccessConfiguration verificationConfigForUs =
4444                 new SatelliteAccessConfiguration(satelliteInfoList, tagIds);
4445         logd("getV15TestConfigForUs: " + verificationConfigForUs);
4446         return verificationConfigForUs;
4447     }
4448 
4449     @Ignore("b/404901907 - Need to fix and re-enable this test.")
4450     @Test
testSatelliteAccessControllerLoadSatelliteAccessData()4451     public void testSatelliteAccessControllerLoadSatelliteAccessData() throws Exception {
4452         logd("testSatelliteAccessControllerLoadSatelliteAccessData");
4453 
4454         // Get rid of the overridden test satellite configs, as we are going
4455         // to use actual on-device and ota'd satellite configs in this test
4456         resetSatelliteAccessControlOverlayConfigs();
4457 
4458         grantSatellitePermission();
4459 
4460         logd(
4461                 "testSatelliteAccessControllerLoadSatelliteAccessData: reset satellite allowance"
4462                         + " state");
4463         assertTrue(
4464                 sMockSatelliteServiceManager
4465                         .setIsSatelliteCommunicationAllowedForCurrentLocationCache(
4466                                 "cache_allowed"));
4467 
4468         final long timeOut = TimeUnit.SECONDS.toMillis(5);
4469         SatelliteCommunicationAccessStateCallbackTest allowStateCallback =
4470                 new SatelliteCommunicationAccessStateCallbackTest();
4471         long registerResultAllowState =
4472                 sSatelliteManager.registerForCommunicationAccessStateChanged(
4473                         getContext().getMainExecutor(), allowStateCallback);
4474         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResultAllowState);
4475 
4476         logd(
4477                 "testSatelliteAccessControllerLoadSatelliteAccessData: override the config data "
4478                         + "version so that the new config data can be accepted by Telephony");
4479         assertTrue(sMockSatelliteServiceManager.overrideConfigDataVersion(false, 0));
4480 
4481         logd(
4482                 "testSatelliteAccessControllerLoadSatelliteAccessData:"
4483                         + "request Telephony to download config data v14 which only support KR"
4484                         + "also not supporting satellite access configuration");
4485         assertTrue(
4486                 sMockSatelliteServiceManager.updateTelephonyConfig(
4487                         TEST_V14_CONFIG_DATA_CONTENT_LOCAL_URI,
4488                         TEST_V14_CONFIG_DATA_METADATA_LOCAL_URI));
4489         waitFor(1000);
4490 
4491         assertTrue(
4492                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4493         SatelliteAccessConfiguration notifiedSatelliteAccessConfiguration =
4494                 allowStateCallback.getSatelliteAccessConfiguration();
4495         assertNull(notifiedSatelliteAccessConfiguration);
4496         verifyIsSatelliteAllowed(false);
4497 
4498         double latUs = 37.7749, lngUs = -122.4194;
4499         double latKr = 37.5665, lngKr = 126.9780;
4500         String countryCodeUs = "US";
4501         String countryCodeKr = "KR";
4502 
4503         logd("testSatelliteAccessControllerLoadSatelliteAccessData: check KR");
4504         assertTrue(sMockSatelliteServiceManager.setCountryCodes(false, "KR", null, null, 0));
4505         verifySatelliteAllowedAndEnabledForLocation(latKr, lngKr, countryCodeKr);
4506 
4507         logd("testSatelliteAccessControllerLoadSatelliteAccessData: check US");
4508         assertTrue(sMockSatelliteServiceManager.setCountryCodes(false, "US", null, null, 0));
4509         verifySatelliteNotAllowedAndNotEnabledForLocation(latUs, lngUs, countryCodeUs);
4510 
4511         logd("testSatelliteAccessControllerLoadSatelliteAccessData: restore the original data");
4512         assertTrue(sMockSatelliteServiceManager.overrideConfigDataVersion(true, 0));
4513 
4514         Pair<SatelliteAccessConfiguration, Integer> resultReceiver =
4515                 requestSatelliteAccessConfigurationForCurrentLocation();
4516         SatelliteAccessConfiguration queriedSatelliteAccessConfiguration = resultReceiver.first;
4517         assertNull(queriedSatelliteAccessConfiguration);
4518         assertEquals(SATELLITE_RESULT_NO_RESOURCES, (int) resultReceiver.second);
4519 
4520         logd(
4521                 "testSatelliteAccessControllerLoadSatelliteAccessData: override the config data "
4522                         + "version so that the new config data can be accepted by Telephony");
4523         assertTrue(sMockSatelliteServiceManager.overrideConfigDataVersion(false, 0));
4524 
4525         logd(
4526                 "testSatelliteAccessControllerLoadSatelliteAccessData:"
4527                         + "request Telephony to download config data v15 support only US");
4528         assertTrue(
4529                 sMockSatelliteServiceManager.updateTelephonyConfig(
4530                         TEST_V15_CONFIG_DATA_CONTENT_LOCAL_URI,
4531                         TEST_V15_CONFIG_DATA_METADATA_LOCAL_URI));
4532         waitFor(1000);
4533 
4534         logd("wait for callback for V15");
4535         assertTrue(
4536                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4537         notifiedSatelliteAccessConfiguration = allowStateCallback.getSatelliteAccessConfiguration();
4538         assertNotNull(notifiedSatelliteAccessConfiguration);
4539         assertEquals(getV15TestConfigForUs(), notifiedSatelliteAccessConfiguration);
4540 
4541         verifyIsSatelliteAllowed(true);
4542 
4543         logd("testSatelliteAccessControllerLoadSatelliteAccessData: set KR");
4544         assertTrue(sMockSatelliteServiceManager.setCountryCodes(false, "KR", null, null, 0));
4545         verifySatelliteNotAllowedAndNotEnabledForLocation(latKr, lngKr, countryCodeKr);
4546 
4547         logd("testSatelliteAccessControllerLoadSatelliteAccessData: set US");
4548         assertTrue(sMockSatelliteServiceManager.setCountryCodes(false, "US", null, null, 0));
4549         verifySatelliteAllowedAndEnabledForLocation(latUs, lngUs, countryCodeUs);
4550 
4551         resultReceiver = requestSatelliteAccessConfigurationForCurrentLocation();
4552         queriedSatelliteAccessConfiguration = resultReceiver.first;
4553         logd(
4554                 "testSatelliteAccessControllerLoadSatelliteAccessData:"
4555                         + " queriedSatelliteAccessConfiguration= "
4556                         + queriedSatelliteAccessConfiguration);
4557         assertNotNull(queriedSatelliteAccessConfiguration);
4558         assertEquals(getV15TestConfigForUs(), notifiedSatelliteAccessConfiguration);
4559         assertNull(resultReceiver.second);
4560     }
4561 
4562     @Test
4563     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testSatelliteAccessControl_UpdateSelectionChannel_BackwardCompatibility()4564     public void testSatelliteAccessControl_UpdateSelectionChannel_BackwardCompatibility() {
4565         final long timeOut = TimeUnit.SECONDS.toMillis(1);
4566         grantSatellitePermission();
4567         assertTrue(sMockSatelliteServiceManager
4568                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache(
4569                         "cache_clear_and_not_allowed"));
4570         SatelliteCommunicationAccessStateCallbackTest allowStateCallback =
4571                 new SatelliteCommunicationAccessStateCallbackTest();
4572         long registerResultAllowState =
4573                 sSatelliteManager.registerForCommunicationAccessStateChanged(
4574                         getContext().getMainExecutor(), allowStateCallback);
4575         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResultAllowState);
4576         assertTrue(
4577                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4578         assertNull(allowStateCallback.getSatelliteAccessConfiguration());
4579         allowStateCallback.drainPermits();
4580         Pair<SatelliteAccessConfiguration, Integer> resultReceiver =
4581                 requestSatelliteAccessConfigurationForCurrentLocation();
4582         SatelliteAccessConfiguration queriedSatelliteAccessConfiguration = resultReceiver.first;
4583         assertNull(queriedSatelliteAccessConfiguration);
4584         assertEquals(SATELLITE_RESULT_NO_RESOURCES, (int) resultReceiver.second);
4585 
4586         // Test access controller using on-device data with old format geofence data. no satellite
4587         // access configuration file.
4588         assertTrue(sMockSatelliteServiceManager.setSatelliteAccessControlOverlayConfigs(false, true,
4589                 SATELLITE_S2_FILE, TimeUnit.MINUTES.toNanos(10), "US", null));
4590         registerTestLocationProvider();
4591         grantSatellitePermission();
4592         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
4593         long registerResult = sSatelliteManager.registerForModemStateChanged(
4594                 getContext().getMainExecutor(), callback);
4595         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
4596         assertTrue(callback.waitUntilResult(1));
4597         if (isSatelliteEnabled()) {
4598             requestSatelliteEnabled(false);
4599             assertTrue(callback.waitUntilModemOff());
4600             assertFalse(isSatelliteEnabled());
4601         }
4602 
4603         allowStateCallback.drainPermits();
4604         // Set current location to Google San Diego office
4605         setTestProviderLocation(32.909808231041644, -117.18185788819781);
4606         assertTrue(sMockSatelliteServiceManager
4607                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("clear_cache_only"));
4608         // Satellite is allowed but no satellite access configuration is available.
4609         verifyIsSatelliteAllowed(true);
4610         assertFalse(
4611                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4612         SatelliteAccessConfiguration notifiedSatelliteAccessConfiguration =
4613                 allowStateCallback.getSatelliteAccessConfiguration();
4614         assertNull(notifiedSatelliteAccessConfiguration);
4615         resultReceiver = requestSatelliteAccessConfigurationForCurrentLocation();
4616         queriedSatelliteAccessConfiguration = resultReceiver.first;
4617         assertNull(queriedSatelliteAccessConfiguration);
4618 
4619         assertFalse(isSatelliteEnabled());
4620         requestSatelliteEnabled(true);
4621         assertTrue(isSatelliteEnabled());
4622 
4623         callback.clearModemStates();
4624         // Set current location to Hawaii, where is not supported from old geofence data.
4625         assertTrue(sMockSatelliteServiceManager
4626                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("clear_cache_only"));
4627         setTestProviderLocation(19.50817482973673, -154.89161639216186);
4628         verifyIsSatelliteAllowed(false);
4629         // Notification with null object comes as region changed from allowed to not allowed.
4630         assertTrue(
4631                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4632         notifiedSatelliteAccessConfiguration = allowStateCallback.getSatelliteAccessConfiguration();
4633         assertNull(notifiedSatelliteAccessConfiguration);
4634         resultReceiver = requestSatelliteAccessConfigurationForCurrentLocation();
4635         queriedSatelliteAccessConfiguration = resultReceiver.first;
4636         assertNull(queriedSatelliteAccessConfiguration);
4637 
4638         // Satellite is disabled because satellite is not allowed for current region.
4639         assertTrue(callback.waitUntilModemOff());
4640         assertFalse(isSatelliteEnabled());
4641 
4642         // Enable will fail because satellite is not allowed
4643         int result = requestSatelliteEnabledWithResult(true, TIMEOUT);
4644         assertEquals(SATELLITE_RESULT_ACCESS_BARRED, result);
4645 
4646         allowStateCallback.drainPermits();
4647         // Set current location to Alaska, where is not supported from old geofence data.
4648         assertTrue(sMockSatelliteServiceManager
4649                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("clear_cache_only"));
4650         setTestProviderLocation(61.21729700371326, -149.89469126029147);
4651         verifyIsSatelliteAllowed(false);
4652         assertFalse(
4653                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4654         notifiedSatelliteAccessConfiguration = allowStateCallback.getSatelliteAccessConfiguration();
4655         assertNull(notifiedSatelliteAccessConfiguration);
4656         resultReceiver = requestSatelliteAccessConfigurationForCurrentLocation();
4657         queriedSatelliteAccessConfiguration = resultReceiver.first;
4658         assertNull(queriedSatelliteAccessConfiguration);
4659 
4660         // Enabling satellite will fail because satellite is not allowed for current region.
4661         result = requestSatelliteEnabledWithResult(true, TIMEOUT);
4662         assertEquals(SATELLITE_RESULT_ACCESS_BARRED, result);
4663 
4664         // Moved to supported region again, current location to Google San Diego office
4665         setTestProviderLocation(32.909808231041644, -117.18185788819781);
4666         assertTrue(sMockSatelliteServiceManager
4667                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("clear_cache_only"));
4668         // Satellite is allowed but no satellite access configuration is available.
4669         verifyIsSatelliteAllowed(true);
4670         requestSatelliteEnabled(true);
4671         assertTrue(isSatelliteEnabled());
4672 
4673         allowStateCallback.drainPermits();
4674         callback.clearModemStates();
4675         // Set current location to Puerto Rico, where is not supported from old geofence data.
4676         assertTrue(sMockSatelliteServiceManager
4677                 .setIsSatelliteCommunicationAllowedForCurrentLocationCache("clear_cache_only"));
4678         setTestProviderLocation(18.466531136579068, -66.11359552551347);
4679         verifyIsSatelliteAllowed(false);
4680         // Notification with null configuration comes as region changed from allowed to not allowed
4681         assertTrue(
4682                 allowStateCallback.waitUntilSatelliteAccessConfigurationChangedEvent(1, timeOut));
4683         notifiedSatelliteAccessConfiguration = allowStateCallback.getSatelliteAccessConfiguration();
4684         assertNull(notifiedSatelliteAccessConfiguration);
4685         resultReceiver = requestSatelliteAccessConfigurationForCurrentLocation();
4686         queriedSatelliteAccessConfiguration = resultReceiver.first;
4687         assertNull(queriedSatelliteAccessConfiguration);
4688 
4689         // Satellite is disabled because satellite is not allowed for current region.
4690         assertTrue(callback.waitUntilModemOff());
4691         assertFalse(isSatelliteEnabled());
4692 
4693         // Restore satellite access allowed
4694         setUpSatelliteAccessAllowed();
4695         revokeSatellitePermission();
4696         unregisterTestLocationProvider();
4697     }
4698 
4699     @Ignore("b/399928350 - Need to fix and re-enable this test.")
4700     @Test
testGetSatellitePlmnsForCarrier()4701     public void testGetSatellitePlmnsForCarrier() {
4702         logd("testGetAggregateSatellitePlmnListForCarrier");
4703         grantSatellitePermission();
4704         beforeSatelliteForCarrierTest();
4705         @SatelliteManager.SatelliteResult int expectedSuccess =
4706                 SatelliteManager.SATELLITE_RESULT_SUCCESS;
4707 
4708         List<String> allSatellitePlmnListBeforeCarrierConfigOverride = getAllSatellitePlmnList();
4709 
4710         /* Test when satellite is supported in the carrier config */
4711         setSatelliteErrorBasedOnHalVersion(expectedSuccess);
4712         PersistableBundle bundle = new PersistableBundle();
4713         bundle.putBoolean(
4714                 CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL, true);
4715         PersistableBundle plmnBundle = new PersistableBundle();
4716         int[] intArray1 = {3, 5};
4717         int[] intArray2 = {3};
4718         plmnBundle.putIntArray("123411", intArray1);
4719         plmnBundle.putIntArray("123412", intArray2);
4720         bundle.putPersistableBundle(
4721                 CarrierConfigManager.KEY_CARRIER_SUPPORTED_SATELLITE_SERVICES_PER_PROVIDER_BUNDLE,
4722                 plmnBundle);
4723         overrideCarrierConfig(sTestSubIDForCarrierSatellite, bundle);
4724 
4725         ArrayList<String> expectedCarrierPlmnList = new ArrayList<>();
4726         expectedCarrierPlmnList.add("123411");
4727         expectedCarrierPlmnList.add("123412");
4728         assertTrue(waitForEventOnSetSatellitePlmn(1));
4729         List<String> carrierPlmnList = getCarrierPlmnList();
4730         assertNotNull(carrierPlmnList);
4731         assertEquals(expectedCarrierPlmnList, carrierPlmnList);
4732 
4733         List<String> aggregatedPlmnList = sSatelliteManager.getSatellitePlmnsForCarrier(
4734                 sTestSubIDForCarrierSatellite);
4735         assertEquals(expectedCarrierPlmnList, aggregatedPlmnList);
4736 
4737         List<String> satellitePlmnListFromOverlayConfig =
4738                 sMockSatelliteServiceManager.getPlmnListFromOverlayConfig();
4739         List<String> expectedAllSatellitePlmnList =
4740                 SatelliteServiceUtils.mergeStrLists(
4741                         carrierPlmnList,
4742                         satellitePlmnListFromOverlayConfig,
4743                         allSatellitePlmnListBeforeCarrierConfigOverride);
4744         List<String> allSatellitePlmnList = getAllSatellitePlmnList();
4745 
4746         assertNotNull(allSatellitePlmnList);
4747         boolean listsAreEqual =
4748                 expectedAllSatellitePlmnList.containsAll(allSatellitePlmnList)
4749                         && allSatellitePlmnList.containsAll(expectedAllSatellitePlmnList);
4750         assertTrue(listsAreEqual);
4751 
4752         afterSatelliteForCarrierTest();
4753         revokeSatellitePermission();
4754     }
4755 
4756     @Test
testSendSatelliteDatagrams_timeout()4757     public void testSendSatelliteDatagrams_timeout() {
4758         logd("testSendSatelliteDatagrams_timeout");
4759         grantSatellitePermission();
4760         assertTrue(isSatelliteProvisioned());
4761 
4762         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
4763         SatelliteTransmissionUpdateCallbackTest callback =
4764                 new SatelliteTransmissionUpdateCallbackTest();
4765         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
4766                 resultListener::offer, callback);
4767         Integer errorCode;
4768         try {
4769             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
4770         } catch (InterruptedException ex) {
4771             fail("testSendSatelliteDatagrams_timeout: Got InterruptedException in waiting"
4772                     + " for the sendDatagram result code");
4773             return;
4774         }
4775         assertNotNull(errorCode);
4776         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
4777 
4778         String mText = "This is a test datagram message from user";
4779         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
4780         callback.clearSendDatagramStateChanges();
4781         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
4782 
4783         // Wait to process datagrams so that the send request will time out.
4784         sMockSatelliteServiceManager.setWaitToSend(true);
4785         // Override the sending timeout duration to 1 second
4786         sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(false,
4787                 DatagramController.TIMEOUT_TYPE_WAIT_FOR_DATAGRAM_SENDING_RESPONSE, 1000);
4788 
4789         LinkedBlockingQueue<Integer> resultListener1 = new LinkedBlockingQueue<>(1);
4790         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
4791                 datagram, true, getContext().getMainExecutor(),
4792                 resultListener1::offer);
4793         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
4794 
4795         assertTrue(callback.waitUntilOnSendDatagramStateChanged(3));
4796         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
4797                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
4798                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
4799                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
4800         assertThat(callback.getSendDatagramStateChange(1)).isEqualTo(
4801                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
4802                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_FAILED,
4803                         1, SatelliteManager.SATELLITE_RESULT_MODEM_TIMEOUT));
4804         assertThat(callback.getSendDatagramStateChange(2)).isEqualTo(
4805                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
4806                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
4807                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
4808         try {
4809             errorCode = resultListener1.poll(TIMEOUT, TimeUnit.MILLISECONDS);
4810         } catch (InterruptedException ex) {
4811             fail("testSendSatelliteDatagrams_timeout: Got InterruptedException in waiting"
4812                     + " for the sendDatagram result code");
4813             return;
4814         }
4815         assertNotNull(errorCode);
4816         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_MODEM_TIMEOUT);
4817 
4818         // Respond to the first send request
4819         callback.clearSendDatagramStateChanges();
4820         assertTrue(sMockSatelliteServiceManager.sendSavedDatagram());
4821 
4822         // Telephony should ignore the response
4823         assertFalse(callback.waitUntilOnSendDatagramStateChanged(1));
4824 
4825         // Restore the timeout duration
4826         sMockSatelliteServiceManager.setDatagramControllerTimeoutDuration(true,
4827                 DatagramController.TIMEOUT_TYPE_WAIT_FOR_DATAGRAM_SENDING_RESPONSE, 0);
4828     }
4829 
4830     @Test
testRequestSatelliteEnabled_timeout()4831     public void testRequestSatelliteEnabled_timeout() {
4832         grantSatellitePermission();
4833         assertTrue(isSatelliteProvisioned());
4834 
4835         logd("testRequestSatelliteEnabled_timeout: starting...");
4836         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
4837         long registerResult = sSatelliteManager.registerForModemStateChanged(
4838                 getContext().getMainExecutor(), callback);
4839         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
4840         assertTrue(callback.waitUntilResult(1));
4841         if (isSatelliteEnabled()) {
4842             logd("testRequestSatelliteEnabled_timeout: disabling satellite...");
4843             requestSatelliteEnabled(false);
4844             assertTrue(callback.waitUntilModemOff());
4845             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
4846             assertFalse(isSatelliteEnabled());
4847             callback.clearModemStates();
4848         }
4849 
4850         sMockSatelliteServiceManager.setShouldRespondTelephony(false);
4851         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
4852         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
4853                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 100));
4854 
4855         // Time out to enable satellite
4856         logd("testRequestSatelliteEnabled_timeout: enabling satellite...");
4857         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
4858         int result = requestSatelliteEnabledWithResult(true, TIMEOUT);
4859         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
4860         assertEquals(SatelliteManager.SATELLITE_RESULT_MODEM_TIMEOUT, result);
4861         assertTrue(callback.waitUntilResult(2));
4862         assertEquals(2, callback.getTotalCountOfModemStates());
4863         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
4864                 callback.getModemState(0));
4865         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(1));
4866         assertFalse(isSatelliteEnabled());
4867 
4868         // Respond to the above enable request. Telephony should ignore the event.
4869         logd("testRequestSatelliteEnabled_timeout: Responding the enabling request...");
4870         callback.clearModemStates();
4871         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
4872                 MockSatelliteService.NOT_UPDATED_SATELLITE_MODEM_STATE));
4873         assertFalse(callback.waitUntilResult(1));
4874         assertFalse(isSatelliteEnabled());
4875 
4876         // Restore the original states
4877         sMockSatelliteServiceManager.setShouldRespondTelephony(true);
4878         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
4879         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
4880                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
4881 
4882         // Successfully enable satellite
4883         logd("testRequestSatelliteEnabled_timeout: enabling satellite...");
4884         callback.clearModemStates();
4885         requestSatelliteEnabled(true);
4886         assertTrue(callback.waitUntilResult(2));
4887         assertEquals(2, callback.getTotalCountOfModemStates());
4888         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
4889                 callback.getModemState(0));
4890         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE, callback.getModemState(1));
4891 
4892         sMockSatelliteServiceManager.setShouldRespondTelephony(false);
4893         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
4894         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
4895                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 500));
4896 
4897         // Time out to disable satellite. Telephony should respond SATELLITE_RESULT_MODEM_TIMEOUT to
4898         // clients and stay in SATELLITE_MODEM_STATE_OUT_OF_SERVICE as satellite disable request
4899         // failed.
4900         logd("testRequestSatelliteEnabled_timeout: disabling satellite...");
4901         callback.clearModemStates();
4902         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
4903         result = requestSatelliteEnabledWithResult(false, TIMEOUT);
4904         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
4905         assertEquals(SatelliteManager.SATELLITE_RESULT_MODEM_TIMEOUT, result);
4906         assertTrue(callback.waitUntilResult(2));
4907         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.modemState);
4908         assertTrue(isSatelliteEnabled());
4909 
4910         // Respond to the above disable request. Telephony should ignore the event.
4911         logd("testRequestSatelliteEnabled_timeout: Responding the disabling request...");
4912         callback.clearModemStates();
4913         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(false,
4914                 MockSatelliteService.NOT_UPDATED_SATELLITE_MODEM_STATE));
4915         assertFalse(callback.waitUntilResult(1));
4916         assertTrue(isSatelliteEnabled());
4917 
4918         // Restore the original states
4919         sSatelliteManager.unregisterForModemStateChanged(callback);
4920         sMockSatelliteServiceManager.setShouldRespondTelephony(true);
4921         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
4922         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
4923                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
4924         revokeSatellitePermission();
4925     }
4926 
4927     @Test
4928     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_EnableDisable_NoResponseForEnable()4929     public void testRequestSatelliteEnabled_EnableDisable_NoResponseForEnable() {
4930         /*
4931          * Test scenario:
4932          * 1) Enable request
4933          * 2) Disable request
4934          * 3) Response from modem for the disable request. Note that there is no response for the
4935          *    enable request from modem
4936          * 4) Satellite should move to OFF state and the enable request should be aborted
4937          */
4938         grantSatellitePermission();
4939         assertTrue(isSatelliteProvisioned());
4940 
4941         logd("testRequestSatelliteEnabled_EnableDisable_NoResponseForEnable: starting...");
4942         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
4943         long registerResult = sSatelliteManager.registerForModemStateChanged(
4944                 getContext().getMainExecutor(), callback);
4945         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
4946         assertTrue(callback.waitUntilResult(1));
4947         if (isSatelliteEnabled()) {
4948             logd("testRequestSatelliteEnabled_EnableDisable_NoResponseForEnable: disabling "
4949                     + "satellite... (1)");
4950             requestSatelliteEnabled(false);
4951             assertTrue(callback.waitUntilModemOff());
4952             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
4953             assertFalse(isSatelliteEnabled());
4954             callback.clearModemStates();
4955         }
4956 
4957         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
4958         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
4959                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
4960 
4961         // Move to enabling state
4962         logd("testRequestSatelliteEnabled_EnableDisable_NoResponseForEnable: enabling "
4963                 + "satellite... (2)");
4964         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
4965         LinkedBlockingQueue<Integer> enableResult =
4966                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
4967         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
4968         assertTrue(callback.waitUntilResult(1));
4969         assertEquals(1, callback.getTotalCountOfModemStates());
4970         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
4971                 callback.getModemState(0));
4972         assertFalse(isSatelliteEnabled());
4973 
4974         // Restore the original states
4975         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
4976         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
4977                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
4978 
4979         // Successfully disable satellite while enabling is in progress. No response for enable
4980         // request from modem
4981         logd("testRequestSatelliteEnabled_EnableDisable_NoResponseForEnable: disabling "
4982                 + "satellite... (3)");
4983         callback.clearModemStates();
4984         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
4985         requestSatelliteEnabled(false);
4986         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
4987         assertTrue(callback.waitUntilResult(2));
4988         assertEquals(2, callback.getTotalCountOfModemStates());
4989         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
4990                 callback.getModemState(0));
4991         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(1));
4992         assertFalse(isSatelliteEnabled());
4993         // The enable request right before the disable request should have been aborted
4994         assertResult(enableResult, SATELLITE_RESULT_REQUEST_ABORTED);
4995 
4996         // Restore the original states
4997         sSatelliteManager.unregisterForModemStateChanged(callback);
4998         sMockSatelliteServiceManager.setShouldRespondTelephony(true);
4999         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
5000                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
5001         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
5002         revokeSatellitePermission();
5003     }
5004 
5005     @Test
5006     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_EnableDisable_SuccessfulResponseForEnable()5007     public void testRequestSatelliteEnabled_EnableDisable_SuccessfulResponseForEnable() {
5008         /*
5009          * Test scenario:
5010          * 1) Enable request
5011          * 2) Disable request
5012          * 3) Successful response from modem for the enable request
5013          * 4) Successful response from modem for the disable request
5014          * 5) Satellite should move to OFF state
5015          */
5016         grantSatellitePermission();
5017         assertTrue(isSatelliteProvisioned());
5018 
5019         logd("testRequestSatelliteEnabled_EnableDisable_SuccessfulResponseForEnable: starting...");
5020         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
5021         long registerResult = sSatelliteManager.registerForModemStateChanged(
5022                 getContext().getMainExecutor(), callback);
5023         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
5024         assertTrue(callback.waitUntilResult(1));
5025         if (isSatelliteEnabled()) {
5026             logd("testRequestSatelliteEnabled_EnableDisable_SuccessfulResponseForEnable: disabling"
5027                     + " satellite... (1)");
5028             requestSatelliteEnabled(false);
5029             assertTrue(callback.waitUntilModemOff());
5030             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
5031             assertFalse(isSatelliteEnabled());
5032             callback.clearModemStates();
5033         }
5034 
5035         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
5036         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
5037                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
5038 
5039         // Move to enabling state
5040         logd("testRequestSatelliteEnabled_EnableDisable_SuccessfulResponseForEnable: enabling"
5041                 + " satellite... (2)");
5042         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5043         LinkedBlockingQueue<Integer> enableResult =
5044                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
5045         assertTrue(callback.waitUntilResult(1));
5046         assertEquals(1, callback.getTotalCountOfModemStates());
5047         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
5048                 callback.getModemState(0));
5049         assertFalse(isSatelliteEnabled());
5050         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5051 
5052         // Disable satellite while enabling is in progress
5053         logd("testRequestSatelliteEnabled_EnableDisable_SuccessfulResponseForEnable: disabling"
5054                 + " satellite... (3)");
5055         callback.clearModemStates();
5056         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5057         LinkedBlockingQueue<Integer> disableResult =
5058                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
5059         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5060         assertTrue(callback.waitUntilResult(1));
5061         assertEquals(1, callback.getTotalCountOfModemStates());
5062         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
5063                 callback.getModemState(0));
5064 
5065         // Send a successful response for the enable request
5066         logd("testRequestSatelliteEnabled_EnableDisable_SuccessfulResponseForEnable: responding to"
5067                 + " the enable request... (4)");
5068         callback.clearModemStates();
5069         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
5070                 SatelliteModemState.SATELLITE_MODEM_STATE_OUT_OF_SERVICE));
5071         assertResult(enableResult, SATELLITE_RESULT_SUCCESS);
5072 
5073         // Send a successful response for the disable request
5074         logd("testRequestSatelliteEnabled_EnableDisable_SuccessfulResponseForEnable: responding to"
5075                 + " the disable request... (5)");
5076         callback.clearModemStates();
5077         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(false,
5078                 SatelliteModemState.SATELLITE_MODEM_STATE_OFF));
5079         assertResult(disableResult, SATELLITE_RESULT_SUCCESS);
5080         assertTrue(callback.waitUntilResult(1));
5081         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(0));
5082         assertFalse(isSatelliteEnabled());
5083 
5084         // Restore the original states
5085         sSatelliteManager.unregisterForModemStateChanged(callback);
5086         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
5087         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
5088                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
5089         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
5090         revokeSatellitePermission();
5091     }
5092 
5093     @Test
5094     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_EnableDisable_LateResponseForEnable()5095     public void testRequestSatelliteEnabled_EnableDisable_LateResponseForEnable() {
5096         /*
5097          * Test scenario:
5098          * 1) Enable request
5099          * 2) Disable request
5100          * 3) Successful response from modem for the disable request
5101          * 4) Satellite should move to OFF state and the enable request should be aborted
5102          * 5) Successful response from modem for the enable request
5103          * 6) Framework should ignore the response from modem for the enable request and stay at
5104          *    OFF state
5105          */
5106         grantSatellitePermission();
5107         assertTrue(isSatelliteProvisioned());
5108 
5109         logd("testRequestSatelliteEnabled_EnableDisable_LateResponseForEnable: starting...");
5110         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
5111         long registerResult = sSatelliteManager.registerForModemStateChanged(
5112                 getContext().getMainExecutor(), callback);
5113         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
5114         assertTrue(callback.waitUntilResult(1));
5115         if (isSatelliteEnabled()) {
5116             logd("testRequestSatelliteEnabled_EnableDisable_LateResponseForEnable: disabling"
5117                     + " satellite... (1)");
5118             requestSatelliteEnabled(false);
5119             assertTrue(callback.waitUntilModemOff());
5120             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
5121             assertFalse(isSatelliteEnabled());
5122             callback.clearModemStates();
5123         }
5124 
5125         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
5126         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
5127                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
5128 
5129         // Move to enabling state
5130         logd("testRequestSatelliteEnabled_EnableDisable_LateResponseForEnable: enabling"
5131                 + " satellite... (2)");
5132         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5133         LinkedBlockingQueue<Integer> enableResult =
5134                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
5135         assertTrue(callback.waitUntilResult(1));
5136         assertEquals(1, callback.getTotalCountOfModemStates());
5137         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
5138                 callback.getModemState(0));
5139         assertFalse(isSatelliteEnabled());
5140         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5141 
5142         // Disable satellite while enabling is in progress
5143         logd("testRequestSatelliteEnabled_EnableDisable_LateResponseForEnable: disabling"
5144                 + " satellite... (3)");
5145         callback.clearModemStates();
5146         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5147         LinkedBlockingQueue<Integer> disableResult =
5148                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
5149         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5150         assertTrue(callback.waitUntilResult(1));
5151         assertEquals(1, callback.getTotalCountOfModemStates());
5152         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
5153                 callback.getModemState(0));
5154 
5155         // Send a successful response for the disable request
5156         logd("testRequestSatelliteEnabled_EnableDisable_LateResponseForEnable: responding to"
5157                 + " the disable request... (4)");
5158         callback.clearModemStates();
5159         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(false,
5160                 SatelliteModemState.SATELLITE_MODEM_STATE_OFF));
5161         assertResult(disableResult, SATELLITE_RESULT_SUCCESS);
5162         assertTrue(callback.waitUntilResult(1));
5163         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(0));
5164         assertFalse(isSatelliteEnabled());
5165         // The enable request right before the disable request should have been aborted
5166         assertResult(enableResult, SATELLITE_RESULT_REQUEST_ABORTED);
5167 
5168         // Send a successful response for the enable request
5169         logd("testRequestSatelliteEnabled_EnableDisable_LateResponseForEnable: responding to"
5170                 + " the enable request... (5)");
5171         callback.clearModemStates();
5172         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
5173                 MockSatelliteService.NOT_UPDATED_SATELLITE_MODEM_STATE));
5174         assertFalse(isSatelliteEnabled());
5175 
5176         // Restore the original states
5177         sSatelliteManager.unregisterForModemStateChanged(callback);
5178         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
5179         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
5180                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
5181         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
5182         revokeSatellitePermission();
5183     }
5184 
5185     @Test
5186     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_EnableDisable_FailureResponseForEnable()5187     public void testRequestSatelliteEnabled_EnableDisable_FailureResponseForEnable() {
5188         /*
5189          * Test scenario:
5190          * 1) Enable request
5191          * 2) Satellite should move to ENABLING state
5192          * 3) Disable request
5193          * 4) Satellite should move to DISABLING state
5194          * 5) Failure response from modem for the enable request
5195          * 6) Response from modem for the disable request
5196          * 7) Satellite should move to OFF state
5197          */
5198         grantSatellitePermission();
5199         assertTrue(isSatelliteProvisioned());
5200 
5201         logd("testRequestSatelliteEnabled_EnableDisable_FailureResponseForEnable: starting...");
5202         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
5203         long registerResult = sSatelliteManager.registerForModemStateChanged(
5204                 getContext().getMainExecutor(), callback);
5205         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
5206         assertTrue(callback.waitUntilResult(1));
5207         if (isSatelliteEnabled()) {
5208             logd("testRequestSatelliteEnabled_EnableDisable_FailureResponseForEnable: disabling"
5209                     + " satellite... (1)");
5210             requestSatelliteEnabled(false);
5211             assertTrue(callback.waitUntilModemOff());
5212             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
5213             assertFalse(isSatelliteEnabled());
5214             callback.clearModemStates();
5215         }
5216 
5217         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
5218         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
5219                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
5220 
5221         // Move to enabling state
5222         logd("testRequestSatelliteEnabled_EnableDisable_FailureResponseForEnable: enabling"
5223                 + " satellite... (2)");
5224         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5225         LinkedBlockingQueue<Integer> enableResult =
5226                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
5227         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5228         assertTrue(callback.waitUntilResult(1));
5229         assertEquals(1, callback.getTotalCountOfModemStates());
5230         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
5231                 callback.getModemState(0));
5232         assertFalse(isSatelliteEnabled());
5233 
5234         // Disable satellite while enabling is in progress
5235         logd("testRequestSatelliteEnabled_EnableDisable_FailureResponseForEnable: disabling"
5236                 + " satellite... (3)");
5237         callback.clearModemStates();
5238         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5239         LinkedBlockingQueue<Integer> disableResult =
5240                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
5241         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5242         assertTrue(callback.waitUntilResult(1));
5243         assertEquals(1, callback.getTotalCountOfModemStates());
5244         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
5245                 callback.getModemState(0));
5246 
5247         // Send a failure response for the enable request
5248         logd("testRequestSatelliteEnabled_EnableDisable_FailureResponseForEnable: responding to"
5249                 + " the enable request... (4)");
5250         callback.clearModemStates();
5251         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_REQUEST_ABORTED);
5252         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
5253                 MockSatelliteService.NOT_UPDATED_SATELLITE_MODEM_STATE));
5254         assertResult(enableResult, SATELLITE_RESULT_REQUEST_ABORTED);
5255 
5256         // Send a successful response for the disable request
5257         logd("testRequestSatelliteEnabled_EnableDisable_FailureResponseForEnable: responding to"
5258                 + " the disable request... (5)");
5259         callback.clearModemStates();
5260         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_SUCCESS);
5261         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(false,
5262                 SatelliteModemState.SATELLITE_MODEM_STATE_OFF));
5263         assertResult(disableResult, SATELLITE_RESULT_SUCCESS);
5264         assertTrue(callback.waitUntilResult(1));
5265         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(0));
5266         assertFalse(isSatelliteEnabled());
5267 
5268         // Restore the original states
5269         sSatelliteManager.unregisterForModemStateChanged(callback);
5270         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
5271         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
5272                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
5273         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
5274         revokeSatellitePermission();
5275     }
5276 
5277     @Test
testRequestSatelliteEnabled_EnableDisable_FeatureDisabled()5278     public void testRequestSatelliteEnabled_EnableDisable_FeatureDisabled() {
5279         /*
5280          * Test scenario:
5281          * 1) Enable request
5282          * 2) Satellite should move to ENABLING state
5283          * 3) Disable request
5284          * 4) Telephony should return SATELLITE_RESULT_ENABLE_IN_PROGRESS since the feature flag
5285          *    is not enabled.
5286          * 5) Successful response from modem for the enable request
5287          * 6) Satellite should move to NOT_CONNECTED state
5288          */
5289         if (Flags.carrierRoamingNbIotNtn()) return;
5290 
5291         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
5292         grantSatellitePermission();
5293         assertTrue(isSatelliteProvisioned());
5294 
5295         logd("testRequestSatelliteEnabled_EnableDisable_FeatureDisabled: starting...");
5296         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
5297         long registerResult = sSatelliteManager.registerForModemStateChanged(
5298                 getContext().getMainExecutor(), callback);
5299         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
5300         assertTrue(callback.waitUntilResult(1));
5301         if (isSatelliteEnabled()) {
5302             logd("testRequestSatelliteEnabled_EnableDisable_FeatureDisabled: disabling"
5303                     + " satellite... (1)");
5304             requestSatelliteEnabled(false);
5305             assertTrue(callback.waitUntilModemOff());
5306             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
5307             assertFalse(isSatelliteEnabled());
5308             callback.clearModemStates();
5309         }
5310 
5311         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
5312         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
5313                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
5314 
5315         // Move to enabling state
5316         logd("testRequestSatelliteEnabled_EnableDisable_FeatureDisabled: enabling"
5317                 + " satellite... (2)");
5318         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5319         LinkedBlockingQueue<Integer> enableResult =
5320                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
5321         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5322         assertTrue(callback.waitUntilResult(1));
5323         assertEquals(1, callback.getTotalCountOfModemStates());
5324         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
5325                 callback.getModemState(0));
5326         assertFalse(isSatelliteEnabled());
5327 
5328         // Disable satellite while enabling is in progress
5329         logd("testRequestSatelliteEnabled_EnableDisable_FeatureDisabled: disabling"
5330                 + " satellite... (3)");
5331         callback.clearModemStates();
5332         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5333         LinkedBlockingQueue<Integer> disableResult =
5334                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
5335         assertResult(disableResult, SATELLITE_RESULT_ENABLE_IN_PROGRESS);
5336 
5337         // Send a successful response for the enable request
5338         logd("testRequestSatelliteEnabled_EnableDisable_FeatureDisabled: responding to"
5339                 + " the enable request... (4)");
5340         callback.clearModemStates();
5341         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
5342                 SatelliteModemState.SATELLITE_MODEM_STATE_OUT_OF_SERVICE));
5343         assertResult(enableResult, SATELLITE_RESULT_SUCCESS);
5344         assertTrue(callback.waitUntilResult(1));
5345         assertEquals(
5346                 SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.getModemState(0));
5347 
5348         // Restore the original states
5349         sSatelliteManager.unregisterForModemStateChanged(callback);
5350         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
5351         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
5352                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
5353         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
5354         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
5355         revokeSatellitePermission();
5356     }
5357 
5358     @Test
5359     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_OffToDemoToP2p_SuccessfulResponse()5360     public void testRequestSatelliteEnabled_OffToDemoToP2p_SuccessfulResponse() {
5361         /*
5362          * Test scenario:
5363          * 1) Enable request with demo mode
5364          * 2) Satellite should move to ENABLING state
5365          * 3) Enable request with P2P mode
5366          * 4) Successful response from modem for the first enable request
5367          * 5) Satellite should move to NOT_CONNECTED state and in demo mode
5368          * 6) Successful response from modem for the second enable request
5369          * 7) Satellite should stay at NOT_CONNECTED state and in P2P mode
5370          */
5371         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
5372         grantSatellitePermission();
5373         assertTrue(isSatelliteProvisioned());
5374 
5375         logd("testRequestSatelliteEnabled_OffToDemoToP2p_SuccessfulResponse: starting...");
5376         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
5377         long registerResult = sSatelliteManager.registerForModemStateChanged(
5378                 getContext().getMainExecutor(), callback);
5379         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
5380         assertTrue(callback.waitUntilResult(1));
5381         if (isSatelliteEnabled()) {
5382             logd("testRequestSatelliteEnabled_OffToDemoToP2p_SuccessfulResponse: disabling"
5383                     + " satellite... (1)");
5384             requestSatelliteEnabled(false);
5385             assertTrue(callback.waitUntilModemOff());
5386             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
5387             assertFalse(isSatelliteEnabled());
5388             callback.clearModemStates();
5389         }
5390 
5391         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
5392         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
5393                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
5394 
5395         // Move to enabling state
5396         logd("testRequestSatelliteEnabled_OffToDemoToP2p_SuccessfulResponse: enabling"
5397                 + " satellite with demo mode... (2)");
5398         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5399         LinkedBlockingQueue<Integer> firstEnableResult =
5400                 requestSatelliteEnabledWithoutWaitingForResult(true, true, false);
5401         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5402         assertTrue(callback.waitUntilResult(1));
5403         assertEquals(1, callback.getTotalCountOfModemStates());
5404         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
5405                 callback.getModemState(0));
5406         assertFalse(isSatelliteEnabled());
5407 
5408         // Change to real mode while enabling demo mode is in progress
5409         logd("testRequestSatelliteEnabled_OffToDemoToP2p_SuccessfulResponse: updating to real mode"
5410                 + " ... (3)");
5411         callback.clearModemStates();
5412         LinkedBlockingQueue<Integer> secondEnableResult =
5413                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
5414         // Wait for some time to make sure SatelliteController receive the second request
5415         waitFor(500);
5416 
5417         // Send a successful response for the first enable request
5418         logd("testRequestSatelliteEnabled_OffToDemoToP2p_SuccessfulResponse: responding to"
5419                 + " the first enable request... (4)");
5420         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5421         callback.clearModemStates();
5422         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
5423                 SatelliteModemState.SATELLITE_MODEM_STATE_OUT_OF_SERVICE));
5424         assertResult(firstEnableResult, SATELLITE_RESULT_SUCCESS);
5425         assertTrue(callback.waitUntilResult(1));
5426         assertEquals(
5427                 SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.getModemState(0));
5428         assertTrue(isSatelliteEnabled());
5429         verifyDemoMode(true);
5430         // The second enable request should be pushed to modem now
5431         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5432 
5433         // Send a successful response for the second enable request
5434         logd("testRequestSatelliteEnabled_OffToDemoToP2p_SuccessfulResponse: responding to"
5435                 + " the second enable request... (5)");
5436         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
5437                 MockSatelliteService.NOT_UPDATED_SATELLITE_MODEM_STATE));
5438         assertResult(secondEnableResult, SATELLITE_RESULT_SUCCESS);
5439         assertTrue(isSatelliteEnabled());
5440         verifyDemoMode(false);
5441 
5442         // Restore the original states
5443         sSatelliteManager.unregisterForModemStateChanged(callback);
5444         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
5445         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
5446                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
5447         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
5448         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
5449         revokeSatellitePermission();
5450     }
5451 
5452     @Test
5453     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_OffToDemoToP2p_FailureResponse()5454     public void testRequestSatelliteEnabled_OffToDemoToP2p_FailureResponse() {
5455         /*
5456          * Test scenario:
5457          * 1) Enable request with demo mode
5458          * 2) Satellite should move to ENABLING state
5459          * 3) Enable request with P2P mode
5460          * 4) Failure response from modem for the first enable request
5461          * 5) Satellite should move to OFF state and the second enable request should be aborted
5462          */
5463         grantSatellitePermission();
5464         assertTrue(isSatelliteProvisioned());
5465 
5466         logd("testRequestSatelliteEnabled_OffToDemoToP2p_FailureResponse: starting...");
5467         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
5468         long registerResult = sSatelliteManager.registerForModemStateChanged(
5469                 getContext().getMainExecutor(), callback);
5470         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
5471         assertTrue(callback.waitUntilResult(1));
5472         if (isSatelliteEnabled()) {
5473             logd("testRequestSatelliteEnabled_OffToDemoToP2p_FailureResponse: disabling"
5474                     + " satellite... (1)");
5475             requestSatelliteEnabled(false);
5476             assertTrue(callback.waitUntilModemOff());
5477             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
5478             assertFalse(isSatelliteEnabled());
5479             callback.clearModemStates();
5480         }
5481 
5482         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
5483         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
5484                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
5485 
5486         // Move to enabling state
5487         logd("testRequestSatelliteEnabled_OffToDemoToP2p_FailureResponse: enabling"
5488                 + " satellite with demo mode... (2)");
5489         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5490         LinkedBlockingQueue<Integer> firstEnableResult =
5491                 requestSatelliteEnabledWithoutWaitingForResult(true, true, false);
5492         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5493         assertTrue(callback.waitUntilResult(1));
5494         assertEquals(1, callback.getTotalCountOfModemStates());
5495         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
5496                 callback.getModemState(0));
5497         assertFalse(isSatelliteEnabled());
5498 
5499         // Change to real mode while enabling demo mode is in progress
5500         logd("testRequestSatelliteEnabled_OffToDemoToP2p_FailureResponse: updating to real mode"
5501                 + " ... (3)");
5502         callback.clearModemStates();
5503         LinkedBlockingQueue<Integer> secondEnableResult =
5504                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
5505         // Wait for some time to make sure SatelliteController receive the second request
5506         waitFor(500);
5507 
5508         // Send a failure response for the first enable request
5509         logd("testRequestSatelliteEnabled_OffToDemoToP2p_FailureResponse: responding to"
5510                 + " the first enable request... (4)");
5511         callback.clearModemStates();
5512         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_MODEM_ERROR);
5513         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
5514                 MockSatelliteService.NOT_UPDATED_SATELLITE_MODEM_STATE));
5515         assertResult(firstEnableResult, SATELLITE_RESULT_MODEM_ERROR);
5516         assertTrue(callback.waitUntilResult(1));
5517         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(0));
5518         assertResult(secondEnableResult, SATELLITE_RESULT_REQUEST_ABORTED);
5519         assertFalse(isSatelliteEnabled());
5520 
5521         // Restore the original states
5522         sSatelliteManager.unregisterForModemStateChanged(callback);
5523         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
5524         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_SUCCESS);
5525         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
5526                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
5527         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
5528         revokeSatellitePermission();
5529     }
5530 
5531     @Test
5532     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_OffToP2pToEmergency_SuccessfulResponse()5533     public void testRequestSatelliteEnabled_OffToP2pToEmergency_SuccessfulResponse() {
5534         /*
5535          * Test scenario:
5536          * 1) Enable request with P2P mode
5537          * 2) Satellite should move to ENABLING state
5538          * 3) Enable request with emergency mode
5539          * 4) Successful response from modem for the first enable request
5540          * 5) Satellite should move to NOT_CONNECTED state and in P2P mode
5541          * 6) Successful response from modem for the second enable request
5542          * 7) Satellite should stay at NOT_CONNECTED state and in emergency mode
5543          */
5544         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
5545         grantSatellitePermission();
5546         assertTrue(isSatelliteProvisioned());
5547 
5548         logd("testRequestSatelliteEnabled_OffToP2pToEmergency_SuccessfulResponse: starting...");
5549         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
5550         long registerResult = sSatelliteManager.registerForModemStateChanged(
5551                 getContext().getMainExecutor(), callback);
5552         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
5553         assertTrue(callback.waitUntilResult(1));
5554         if (isSatelliteEnabled()) {
5555             logd("testRequestSatelliteEnabled_OffToP2pToEmergency_SuccessfulResponse: disabling"
5556                     + " satellite... (1)");
5557             requestSatelliteEnabled(false);
5558             assertTrue(callback.waitUntilModemOff());
5559             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
5560             assertFalse(isSatelliteEnabled());
5561             callback.clearModemStates();
5562         }
5563 
5564         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
5565         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
5566                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
5567 
5568         // Move to enabling state
5569         logd("testRequestSatelliteEnabled_OffToP2pToEmergency_SuccessfulResponse: enabling"
5570                 + " satellite for P2P SMS... (2)");
5571         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5572         LinkedBlockingQueue<Integer> firstEnableResult =
5573                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
5574         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5575         assertTrue(callback.waitUntilResult(1));
5576         assertEquals(1, callback.getTotalCountOfModemStates());
5577         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
5578                 callback.getModemState(0));
5579         assertFalse(isSatelliteEnabled());
5580 
5581         // Change to real mode while enabling demo mode is in progress
5582         logd("testRequestSatelliteEnabled_OffToP2pToEmergency_SuccessfulResponse: updating to "
5583                 + "emergency mode... (3)");
5584         callback.clearModemStates();
5585         LinkedBlockingQueue<Integer> secondEnableResult =
5586                 requestSatelliteEnabledWithoutWaitingForResult(true, false, true);
5587         // Wait for some time to make sure SatelliteController receive the second request
5588         waitFor(500);
5589 
5590         // Send a successful response for the first enable request
5591         logd("testRequestSatelliteEnabled_OffToP2pToEmergency_SuccessfulResponse: responding to"
5592                 + " the first enable request... (4)");
5593         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5594         callback.clearModemStates();
5595         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
5596                 SatelliteModemState.SATELLITE_MODEM_STATE_OUT_OF_SERVICE));
5597         assertResult(firstEnableResult, SATELLITE_RESULT_SUCCESS);
5598         assertTrue(callback.waitUntilResult(1));
5599         assertEquals(
5600                 SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.getModemState(0));
5601         assertTrue(isSatelliteEnabled());
5602         verifyEmergencyMode(false);
5603         // The second enable request should be pushed to modem now
5604         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5605 
5606         // Send a successful response for the second enable request
5607         logd("testRequestSatelliteEnabled_OffToP2pToEmergency_SuccessfulResponse: responding to"
5608                 + " the second enable request... (5)");
5609         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
5610                 MockSatelliteService.NOT_UPDATED_SATELLITE_MODEM_STATE));
5611         assertResult(secondEnableResult, SATELLITE_RESULT_SUCCESS);
5612         assertTrue(isSatelliteEnabled());
5613         verifyEmergencyMode(true);
5614 
5615         // Restore the original states
5616         sSatelliteManager.unregisterForModemStateChanged(callback);
5617         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
5618         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
5619                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
5620         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
5621         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
5622         revokeSatellitePermission();
5623     }
5624 
5625     @Test
5626     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_OffToP2pToEmergency_FailureResponse()5627     public void testRequestSatelliteEnabled_OffToP2pToEmergency_FailureResponse() {
5628         /*
5629          * Test scenario:
5630          * 1) Enable request with P2P mode
5631          * 2) Satellite should move to ENABLING state
5632          * 3) Enable request with emergency mode
5633          * 4) Successful response from modem for the first enable request
5634          * 5) Satellite should move to NOT_CONNECTED state and in P2P mode
5635          * 6) Failure response from modem for the second enable request
5636          * 7) Satellite should stay at NOT_CONNECTED state and in P2P mode
5637          */
5638         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
5639         grantSatellitePermission();
5640         assertTrue(isSatelliteProvisioned());
5641 
5642         logd("testRequestSatelliteEnabled_OffToP2pToEmergency_FailureResponse: starting...");
5643         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
5644         long registerResult = sSatelliteManager.registerForModemStateChanged(
5645                 getContext().getMainExecutor(), callback);
5646         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
5647         assertTrue(callback.waitUntilResult(1));
5648         if (isSatelliteEnabled()) {
5649             logd("testRequestSatelliteEnabled_OffToP2pToEmergency_FailureResponse: disabling"
5650                     + " satellite... (1)");
5651             requestSatelliteEnabled(false);
5652             assertTrue(callback.waitUntilModemOff());
5653             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
5654             assertFalse(isSatelliteEnabled());
5655             callback.clearModemStates();
5656         }
5657 
5658         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
5659         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
5660                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
5661 
5662         // Move to enabling state
5663         logd("testRequestSatelliteEnabled_OffToP2pToEmergency_FailureResponse: enabling"
5664                 + " satellite for P2P SMS... (2)");
5665         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5666         LinkedBlockingQueue<Integer> firstEnableResult =
5667                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
5668         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5669         assertTrue(callback.waitUntilResult(1));
5670         assertEquals(1, callback.getTotalCountOfModemStates());
5671         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
5672                 callback.getModemState(0));
5673         assertFalse(isSatelliteEnabled());
5674 
5675         // Change to real mode while enabling demo mode is in progress
5676         logd("testRequestSatelliteEnabled_OffToP2pToEmergency_FailureResponse: updating to "
5677                 + "emergency mode... (3)");
5678         callback.clearModemStates();
5679         LinkedBlockingQueue<Integer> secondEnableResult =
5680                 requestSatelliteEnabledWithoutWaitingForResult(true, false, true);
5681         // Wait for some time to make sure SatelliteController receive the second request
5682         waitFor(500);
5683 
5684         // Send a successful response for the first enable request
5685         logd("testRequestSatelliteEnabled_OffToP2pToEmergency_FailureResponse: responding to"
5686                 + " the first enable request... (4)");
5687         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5688         callback.clearModemStates();
5689         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
5690                 SatelliteModemState.SATELLITE_MODEM_STATE_OUT_OF_SERVICE));
5691         assertResult(firstEnableResult, SATELLITE_RESULT_SUCCESS);
5692         assertTrue(callback.waitUntilResult(1));
5693         assertEquals(
5694                 SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.getModemState(0));
5695         assertTrue(isSatelliteEnabled());
5696         verifyEmergencyMode(false);
5697         // The second enable request should be pushed to modem now
5698         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5699 
5700         // Send a failure response for the second enable request
5701         logd("testRequestSatelliteEnabled_OffToP2pToEmergency_FailureResponse: responding to"
5702                 + " the second enable request... (5)");
5703         sMockSatelliteServiceManager.setErrorCode(
5704                 SatelliteResult.SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
5705         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
5706                 MockSatelliteService.NOT_UPDATED_SATELLITE_MODEM_STATE));
5707         assertResult(secondEnableResult, SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
5708         assertTrue(isSatelliteEnabled());
5709         verifyEmergencyMode(false);
5710 
5711         // Restore the original states
5712         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_SUCCESS);
5713         sSatelliteManager.unregisterForModemStateChanged(callback);
5714         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
5715         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
5716                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
5717         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
5718         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
5719         revokeSatellitePermission();
5720     }
5721 
5722     @Test
5723     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_DemoToP2p_SuccessfulResponse()5724     public void testRequestSatelliteEnabled_DemoToP2p_SuccessfulResponse() {
5725         /*
5726          * Test scenario:
5727          * 1) Enable request with demo mode
5728          * 2) Satellite should move to ENABLING state
5729          * 3) Successful response from modem for the first enable request
5730          * 4) Satellite should move to NOT_CONNECTED state and in demo mode
5731          * 5) Enable request with P2P mode
5732          * 6) Satellite should move to ENABLING state
5733          * 7) Successful response from modem for the second enable request
5734          * 8) Satellite should move to NOT_CONNECTED state and in P2P mode
5735          */
5736         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
5737         grantSatellitePermission();
5738         assertTrue(isSatelliteProvisioned());
5739 
5740         logd("testRequestSatelliteEnabled_DemoToP2p_SuccessfulResponse: starting...");
5741         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
5742         long registerResult = sSatelliteManager.registerForModemStateChanged(
5743                 getContext().getMainExecutor(), callback);
5744         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
5745         assertTrue(callback.waitUntilResult(1));
5746         if (isSatelliteEnabled()) {
5747             logd("testRequestSatelliteEnabled_DemoToP2p_SuccessfulResponse: disabling"
5748                     + " satellite... (1)");
5749             requestSatelliteEnabled(false);
5750             assertTrue(callback.waitUntilModemOff());
5751             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
5752             assertFalse(isSatelliteEnabled());
5753             callback.clearModemStates();
5754         }
5755 
5756         // Enable satellite with demo mode
5757         logd("testRequestSatelliteEnabled_DemoToP2p_SuccessfulResponse: enabling"
5758                 + " satellite with demo mode... (2)");
5759         callback.clearModemStates();
5760         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5761         requestSatelliteEnabled(true, true, SATELLITE_RESULT_SUCCESS);
5762         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5763         assertTrue(callback.waitUntilResult(2));
5764         assertEquals(2, callback.getTotalCountOfModemStates());
5765         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
5766                 callback.getModemState(0));
5767         assertEquals(
5768                 SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.getModemState(1));
5769         assertTrue(isSatelliteEnabled());
5770         verifyDemoMode(true);
5771 
5772         // Change to P2P mode
5773         logd("testRequestSatelliteEnabled_DemoToP2p_SuccessfulResponse: updating to real mode"
5774                 + " ... (3)");
5775         callback.clearModemStates();
5776         requestSatelliteEnabled(true, false, SATELLITE_RESULT_SUCCESS);
5777         verifyDemoMode(false);
5778 
5779         // Restore the original states
5780         sSatelliteManager.unregisterForModemStateChanged(callback);
5781         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
5782         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
5783                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
5784         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
5785         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
5786         revokeSatellitePermission();
5787     }
5788 
5789     @Test
5790     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_P2pToEmergency_SuccessfulResponse()5791     public void testRequestSatelliteEnabled_P2pToEmergency_SuccessfulResponse() {
5792         /*
5793          * Test scenario:
5794          * 1) Enable request with P2P mode
5795          * 2) Satellite should move to ENABLING state
5796          * 3) Successful response from modem for the first enable request
5797          * 4) Satellite should move to NOT_CONNECTED state and in P2P mode
5798          * 5) Enable request with emergency mode
5799          * 6) Satellite should move to ENABLING state
5800          * 7) Successful response from modem for the second enable request
5801          * 8) Satellite should move to NOT_CONNECTED state and in emergency mode
5802          */
5803         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
5804         grantSatellitePermission();
5805         assertTrue(isSatelliteProvisioned());
5806 
5807         logd("testRequestSatelliteEnabled_P2pToEmergency_SuccessfulResponse: starting...");
5808         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
5809         long registerResult = sSatelliteManager.registerForModemStateChanged(
5810                 getContext().getMainExecutor(), callback);
5811         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
5812         assertTrue(callback.waitUntilResult(1));
5813         if (isSatelliteEnabled()) {
5814             logd("testRequestSatelliteEnabled_P2pToEmergency_SuccessfulResponse: disabling"
5815                     + " satellite... (1)");
5816             requestSatelliteEnabled(false);
5817             assertTrue(callback.waitUntilModemOff());
5818             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
5819             assertFalse(isSatelliteEnabled());
5820             callback.clearModemStates();
5821         }
5822 
5823         // Enable satellite with P2P mode
5824         logd("testRequestSatelliteEnabled_P2pToEmergency_SuccessfulResponse: enabling"
5825                 + " satellite with P2P mode... (2)");
5826         callback.clearModemStates();
5827         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5828         requestSatelliteEnabled(true, false, SATELLITE_RESULT_SUCCESS);
5829         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5830         assertTrue(callback.waitUntilResult(2));
5831         assertEquals(2, callback.getTotalCountOfModemStates());
5832         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
5833                 callback.getModemState(0));
5834         assertEquals(
5835                 SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.getModemState(1));
5836         assertTrue(isSatelliteEnabled());
5837         verifyEmergencyMode(false);
5838 
5839         // Change to emergency mode
5840         logd("testRequestSatelliteEnabled_P2pToEmergency_SuccessfulResponse: updating to emergency"
5841                 + " mode... (3)");
5842         callback.clearModemStates();
5843         LinkedBlockingQueue<Integer> secondEnableResult =
5844                 requestSatelliteEnabledWithoutWaitingForResult(true, false, true);
5845         assertResult(secondEnableResult, SATELLITE_RESULT_SUCCESS);
5846         verifyEmergencyMode(true);
5847 
5848         // Restore the original states
5849         sSatelliteManager.unregisterForModemStateChanged(callback);
5850         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
5851         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
5852                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
5853         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
5854         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
5855         revokeSatellitePermission();
5856     }
5857 
5858     @Test
5859     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_OffToDemoToP2pToOff_SuccessfulResponseForEnable()5860     public void testRequestSatelliteEnabled_OffToDemoToP2pToOff_SuccessfulResponseForEnable() {
5861         /*
5862          * Test scenario:
5863          * 1) Enable request with demo mode
5864          * 2) Satellite should move to ENABLING state
5865          * 3) Enable request with P2P mode
5866          * 4) Disable request
5867          * 5) Satellite should move to DISABLING state
5868          * 6) Successful response from modem for the first enable request
5869          * 7) The second enable request is aborted
5870          * 8) Successful response from modem for the disable request
5871          * 9) Satellite should move to OFF state
5872          */
5873         grantSatellitePermission();
5874         assertTrue(isSatelliteProvisioned());
5875 
5876         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_SuccessfulResponseForEnable: "
5877                 + "starting...");
5878         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
5879         long registerResult = sSatelliteManager.registerForModemStateChanged(
5880                 getContext().getMainExecutor(), callback);
5881         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
5882         assertTrue(callback.waitUntilResult(1));
5883         if (isSatelliteEnabled()) {
5884             logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_SuccessfulResponseForEnable: "
5885                     + "disabling satellite... (1)");
5886             requestSatelliteEnabled(false);
5887             assertTrue(callback.waitUntilModemOff());
5888             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
5889             assertFalse(isSatelliteEnabled());
5890             callback.clearModemStates();
5891         }
5892 
5893         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
5894         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
5895                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
5896 
5897         // Move to enabling state
5898         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_SuccessfulResponseForEnable: enabling"
5899                 + " satellite with demo mode... (2)");
5900         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5901         LinkedBlockingQueue<Integer> firstEnableResult =
5902                 requestSatelliteEnabledWithoutWaitingForResult(true, true, false);
5903         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5904         assertTrue(callback.waitUntilResult(1));
5905         assertEquals(1, callback.getTotalCountOfModemStates());
5906         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
5907                 callback.getModemState(0));
5908         assertFalse(isSatelliteEnabled());
5909 
5910         // Change to real mode while enabling demo mode is in progress
5911         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_SuccessfulResponseForEnable: "
5912                 + "updating to real mode ... (3)");
5913         callback.clearModemStates();
5914         LinkedBlockingQueue<Integer> secondEnableResult =
5915                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
5916         // Wait for some time to make sure SatelliteController receive the second request
5917         waitFor(500);
5918 
5919         // Disable satellite while enabling and enable attributes updating are in progress
5920         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_SuccessfulResponseForEnable: "
5921                 + "disabling satellite... (4)");
5922         callback.clearModemStates();
5923         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
5924         LinkedBlockingQueue<Integer> disableResult =
5925                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
5926         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
5927         assertTrue(callback.waitUntilResult(1));
5928         assertEquals(1, callback.getTotalCountOfModemStates());
5929         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
5930                 callback.getModemState(0));
5931 
5932         // Send a successful response for the first enable request
5933         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_SuccessfulResponseForEnable: "
5934                 + "responding to the first enable request... (5)");
5935         callback.clearModemStates();
5936         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
5937                 SatelliteModemState.SATELLITE_MODEM_STATE_OUT_OF_SERVICE));
5938         assertResult(firstEnableResult, SATELLITE_RESULT_SUCCESS);
5939         verifyDemoMode(true);
5940         assertResult(secondEnableResult, SATELLITE_RESULT_REQUEST_ABORTED);
5941 
5942         // Send a successful response for the disable request
5943         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_SuccessfulResponseForEnable: "
5944                 + "responding to the disable request... (6)");
5945         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(false,
5946                 SatelliteModemState.SATELLITE_MODEM_STATE_OFF));
5947         assertResult(disableResult, SATELLITE_RESULT_SUCCESS);
5948         assertTrue(callback.waitUntilResult(1));
5949         assertEquals(1, callback.getTotalCountOfModemStates());
5950         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(0));
5951         assertFalse(isSatelliteEnabled());
5952 
5953         // Restore the original states
5954         sSatelliteManager.unregisterForModemStateChanged(callback);
5955         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
5956         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
5957                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
5958         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
5959         revokeSatellitePermission();
5960     }
5961 
5962     @Test
5963     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_OffToDemoToP2pToOff_NoResponseForEnable()5964     public void testRequestSatelliteEnabled_OffToDemoToP2pToOff_NoResponseForEnable() {
5965         /*
5966          * Test scenario:
5967          * 1) Enable request with demo mode
5968          * 2) Enable request with P2P mode
5969          * 3) Disable request
5970          * 4) Successful response from modem for the disable request
5971          * 5) Satellite should move to OFF state and the two enable requests are aborted
5972          */
5973         grantSatellitePermission();
5974         assertTrue(isSatelliteProvisioned());
5975 
5976         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_NoResponseForEnable: "
5977                 + "starting...");
5978         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
5979         long registerResult = sSatelliteManager.registerForModemStateChanged(
5980                 getContext().getMainExecutor(), callback);
5981         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
5982         assertTrue(callback.waitUntilResult(1));
5983         if (isSatelliteEnabled()) {
5984             logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_NoResponseForEnable: "
5985                     + "disabling satellite... (1)");
5986             requestSatelliteEnabled(false);
5987             assertTrue(callback.waitUntilModemOff());
5988             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
5989             assertFalse(isSatelliteEnabled());
5990             callback.clearModemStates();
5991         }
5992 
5993         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
5994         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
5995                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
5996 
5997         // Move to enabling state
5998         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_NoResponseForEnable: enabling"
5999                 + " satellite with demo mode... (2)");
6000         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6001         LinkedBlockingQueue<Integer> firstEnableResult =
6002                 requestSatelliteEnabledWithoutWaitingForResult(true, true, false);
6003         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6004         assertTrue(callback.waitUntilResult(1));
6005         assertEquals(1, callback.getTotalCountOfModemStates());
6006         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
6007                 callback.getModemState(0));
6008         assertFalse(isSatelliteEnabled());
6009 
6010         // Change to real mode while enabling demo mode is in progress
6011         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_NoResponseForEnable: "
6012                 + "updating to real mode ... (3)");
6013         callback.clearModemStates();
6014         LinkedBlockingQueue<Integer> secondEnableResult =
6015                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
6016         // Wait for some time to make sure SatelliteController receive the second request
6017         waitFor(500);
6018 
6019         // Disable satellite while enabling and enable attributes updating are in progress
6020         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_NoResponseForEnable: disabling"
6021                 + " satellite... (4)");
6022         callback.clearModemStates();
6023         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6024         LinkedBlockingQueue<Integer> disableResult =
6025                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
6026         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6027         assertTrue(callback.waitUntilResult(1));
6028         assertEquals(1, callback.getTotalCountOfModemStates());
6029         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
6030                 callback.getModemState(0));
6031 
6032         // Send a successful response for the disable request
6033         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_NoResponseForEnable: "
6034                 + "responding to the disable request... (5)");
6035         callback.clearModemStates();
6036         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(false,
6037                 SatelliteModemState.SATELLITE_MODEM_STATE_OFF));
6038         assertResult(disableResult, SATELLITE_RESULT_SUCCESS);
6039         assertTrue(callback.waitUntilResult(1));
6040         assertEquals(1, callback.getTotalCountOfModemStates());
6041         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(0));
6042         assertFalse(isSatelliteEnabled());
6043         assertResult(firstEnableResult, SATELLITE_RESULT_REQUEST_ABORTED);
6044         assertResult(secondEnableResult, SATELLITE_RESULT_REQUEST_ABORTED);
6045 
6046         // Restore the original states
6047         sSatelliteManager.unregisterForModemStateChanged(callback);
6048         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
6049         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
6050                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
6051         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
6052         revokeSatellitePermission();
6053     }
6054 
6055     @Test
6056     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_OffToDemoToP2pToOff_FailureResponseForDisable()6057     public void testRequestSatelliteEnabled_OffToDemoToP2pToOff_FailureResponseForDisable() {
6058         /*
6059          * Test scenario:
6060          * 1) Enable request with demo mode
6061          * 2) Satellite should move to ENABLING state
6062          * 3) Enable request with P2P mode
6063          * 4) Disable request
6064          * 5) Satellite should move to DISABLING state
6065          * 6) Failure response from modem for the disable request
6066          * 7) Satellite should move back to ENABLING state
6067          * 8) Successful response for the first enable request
6068          * 9) Satellite should move to NOT_CONNECTED state and in demo mode
6069          * 10) Successful response for the second enable request
6070          * 11) Satellite should stay at NOT_CONNECTED state and in P2P mode
6071          */
6072         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
6073         grantSatellitePermission();
6074         assertTrue(isSatelliteProvisioned());
6075 
6076         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_FailureResponseForDisable: "
6077                 + "starting...");
6078         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
6079         long registerResult = sSatelliteManager.registerForModemStateChanged(
6080                 getContext().getMainExecutor(), callback);
6081         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
6082         assertTrue(callback.waitUntilResult(1));
6083         if (isSatelliteEnabled()) {
6084             logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_FailureResponseForDisable: "
6085                     + "disabling satellite... (1)");
6086             requestSatelliteEnabled(false);
6087             assertTrue(callback.waitUntilModemOff());
6088             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
6089             assertFalse(isSatelliteEnabled());
6090             callback.clearModemStates();
6091         }
6092 
6093         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
6094         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
6095                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
6096 
6097         // Move to enabling state
6098         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_FailureResponseForDisable: enabling"
6099                 + " satellite with demo mode... (2)");
6100         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6101         LinkedBlockingQueue<Integer> firstEnableResult =
6102                 requestSatelliteEnabledWithoutWaitingForResult(true, true, false);
6103         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6104         assertTrue(callback.waitUntilResult(1));
6105         assertEquals(1, callback.getTotalCountOfModemStates());
6106         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
6107                 callback.getModemState(0));
6108         assertFalse(isSatelliteEnabled());
6109 
6110         // Change to real mode while enabling demo mode is in progress
6111         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_FailureResponseForDisable: "
6112                 + "updating to real mode ... (3)");
6113         callback.clearModemStates();
6114         LinkedBlockingQueue<Integer> secondEnableResult =
6115                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
6116         // Wait for some time to make sure SatelliteController receive the second request
6117         waitFor(500);
6118 
6119         // Disable satellite while enabling and enable attributes updating are in progress
6120         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_FailureResponseForDisable: disabling"
6121                 + " satellite... (4)");
6122         callback.clearModemStates();
6123         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6124         LinkedBlockingQueue<Integer> disableResult =
6125                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
6126         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6127         assertTrue(callback.waitUntilResult(1));
6128         assertEquals(1, callback.getTotalCountOfModemStates());
6129         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
6130                 callback.getModemState(0));
6131 
6132         // Send a failure response for the disable request
6133         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_FailureResponseForDisable: "
6134                 + "responding to the disable request... (5)");
6135         callback.clearModemStates();
6136         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_NO_RESOURCES);
6137         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(false,
6138                 MockSatelliteService.NOT_UPDATED_SATELLITE_MODEM_STATE));
6139         assertResult(disableResult, SATELLITE_RESULT_NO_RESOURCES);
6140         assertTrue(callback.waitUntilResult(1));
6141         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
6142                 callback.getModemState(0));
6143 
6144         // Send a successful response for the first enable request
6145         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_FailureResponseForDisable: "
6146                 + "responding to the first enable request... (6)");
6147         callback.clearModemStates();
6148         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6149         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_SUCCESS);
6150         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
6151                 SatelliteModemState.SATELLITE_MODEM_STATE_OUT_OF_SERVICE));
6152         assertResult(firstEnableResult, SATELLITE_RESULT_SUCCESS);
6153         assertTrue(callback.waitUntilResult(1));
6154         assertEquals(1, callback.getTotalCountOfModemStates());
6155         assertEquals(
6156                 SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.getModemState(0));
6157         verifyDemoMode(true);
6158         // The enable attributes update request should be pushed to modem now
6159         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6160 
6161         // Send a successful response for the second enable request
6162         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_FailureResponseForDisable: "
6163                 + "responding to the second enable request... (6)");
6164         callback.clearModemStates();
6165         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(true,
6166                 MockSatelliteService.NOT_UPDATED_SATELLITE_MODEM_STATE));
6167         assertResult(secondEnableResult, SATELLITE_RESULT_SUCCESS);
6168         verifyDemoMode(false);
6169 
6170         // Restore the original states
6171         sSatelliteManager.unregisterForModemStateChanged(callback);
6172         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
6173         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
6174                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
6175         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
6176         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
6177         revokeSatellitePermission();
6178     }
6179 
6180     @Test
6181     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_OffToDemoToP2pToOff_ModemOff_FailureResponseForDisable()6182     public void testRequestSatelliteEnabled_OffToDemoToP2pToOff_ModemOff_FailureResponseForDisable() {
6183         /*
6184          * Test scenario:
6185          * 1) Enable request with demo mode
6186          * 2) Satellite should move to ENABLING state
6187          * 3) Enable request with P2P mode
6188          * 4) Disable request
6189          * 5) Satellite should move to DISABLING state
6190          * 6) Modem report OFF state
6191          * 7) Failure response from modem for the disable request
6192          * 8) Satellite should move to OFF state and the enable requests are aborted
6193          */
6194         grantSatellitePermission();
6195         assertTrue(isSatelliteProvisioned());
6196 
6197         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_ModemOff_FailureResponseForDisable: "
6198                 + "starting...");
6199         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
6200         long registerResult = sSatelliteManager.registerForModemStateChanged(
6201                 getContext().getMainExecutor(), callback);
6202         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
6203         assertTrue(callback.waitUntilResult(1));
6204         if (isSatelliteEnabled()) {
6205             logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_ModemOff_"
6206                     + "FailureResponseForDisable: disabling satellite... (1)");
6207             requestSatelliteEnabled(false);
6208             assertTrue(callback.waitUntilModemOff());
6209             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
6210             assertFalse(isSatelliteEnabled());
6211             callback.clearModemStates();
6212         }
6213 
6214         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
6215         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
6216                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
6217 
6218         // Move to enabling state
6219         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_ModemOff_FailureResponseForDisable: "
6220                 + "enabling satellite with demo mode... (2)");
6221         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6222         LinkedBlockingQueue<Integer> firstEnableResult =
6223                 requestSatelliteEnabledWithoutWaitingForResult(true, true, false);
6224         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6225         assertTrue(callback.waitUntilResult(1));
6226         assertEquals(1, callback.getTotalCountOfModemStates());
6227         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
6228                 callback.getModemState(0));
6229         assertFalse(isSatelliteEnabled());
6230 
6231         // Change to real mode while enabling demo mode is in progress
6232         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_ModemOff_FailureResponseForDisable: "
6233                 + "updating to real mode ... (3)");
6234         callback.clearModemStates();
6235         LinkedBlockingQueue<Integer> secondEnableResult =
6236                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
6237         // Wait for some time to make sure SatelliteController receive the second request
6238         waitFor(500);
6239 
6240         // Disable satellite while enabling and enable attributes updating are in progress
6241         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_ModemOff_FailureResponseForDisable: "
6242                 + "disabling satellite... (4)");
6243         callback.clearModemStates();
6244         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6245         LinkedBlockingQueue<Integer> disableResult =
6246                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
6247         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6248         assertTrue(callback.waitUntilResult(1));
6249         assertEquals(1, callback.getTotalCountOfModemStates());
6250         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
6251                 callback.getModemState(0));
6252 
6253         // Send a failure response for the disable request
6254         logd("testRequestSatelliteEnabled_OffToDemoToP2pToOff_ModemOff_FailureResponseForDisable: "
6255                 + "responding to the disable request... (5)");
6256         callback.clearModemStates();
6257         // Send the OFF state before sending the failure response for the disable request
6258         sMockSatelliteServiceManager.sendOnSatelliteModemStateChanged(
6259                 SatelliteModemState.SATELLITE_MODEM_STATE_OFF);
6260         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_NO_RESOURCES);
6261         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(false,
6262                 MockSatelliteService.NOT_UPDATED_SATELLITE_MODEM_STATE));
6263         assertResult(disableResult, SATELLITE_RESULT_NO_RESOURCES);
6264         assertResult(firstEnableResult, SATELLITE_RESULT_REQUEST_ABORTED);
6265         assertResult(secondEnableResult, SATELLITE_RESULT_REQUEST_ABORTED);
6266         assertTrue(callback.waitUntilResult(2));
6267         assertEquals(2, callback.getTotalCountOfModemStates());
6268         // Satellite modem state should be reverted back to ENABLING state due to the failure of
6269         // the disable request.
6270         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
6271                 callback.getModemState(0));
6272         // Satellite modem state should be changed to OFF state due to the OFF state report from
6273         // modem.
6274         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF,
6275                 callback.getModemState(1));
6276         assertFalse(isSatelliteEnabled());
6277 
6278         // Restore the original states
6279         sSatelliteManager.unregisterForModemStateChanged(callback);
6280         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
6281         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
6282                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
6283         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
6284         revokeSatellitePermission();
6285     }
6286 
6287     @Ignore("b/405228198 - Need to fix and re-enable this test.")
6288     @Test
testRequestSatelliteEnabled_ModemCrashDuringDisable()6289     public void testRequestSatelliteEnabled_ModemCrashDuringDisable() {
6290         /*
6291          * Test scenario:
6292          * 1) Send disable request to modem
6293          * 2) Satellite should move to DISABLING state
6294          * 3) Modem crash before responding to framework
6295          * 4) Modem come back up
6296          * 5) Framework abort the request and move to OFF state
6297          */
6298         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
6299         grantSatellitePermission();
6300         assertTrue(isSatelliteProvisioned());
6301 
6302         logd("testRequestSatelliteEnabled_ModemCrashDuringDisable: starting...");
6303         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
6304         long registerResult = sSatelliteManager.registerForModemStateChanged(
6305                 getContext().getMainExecutor(), callback);
6306         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
6307         assertTrue(callback.waitUntilResult(1));
6308 
6309         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
6310         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
6311                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
6312 
6313         // Move to disabling state
6314         logd("testRequestSatelliteEnabled_ModemCrashDuringDisable: disabling satellite (1)");
6315         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6316         callback.clearModemStates();
6317         LinkedBlockingQueue<Integer> disableResult =
6318                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
6319         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6320         assertTrue(callback.waitUntilResult(1));
6321         assertEquals(1, callback.getTotalCountOfModemStates());
6322         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
6323                 callback.getModemState(0));
6324         assertTrue(isSatelliteEnabled());
6325 
6326         // Mocking modem crash scenario
6327         logd("testRequestSatelliteEnabled_ModemCrashDuringDisable: mocking modem crash (2)");
6328         callback.clearModemStates();
6329         assertTrue(sMockSatelliteServiceManager.connectExternalSatelliteService());
6330         assertTrue(sMockSatelliteServiceManager.waitForRemoteSatelliteServiceConnected(1));
6331 
6332         // The disable request should be aborted
6333         assertResult(disableResult, SATELLITE_RESULT_MODEM_ERROR);
6334         assertTrue(callback.waitUntilResult(1));
6335         assertEquals(1, callback.getTotalCountOfModemStates());
6336         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(0));
6337         assertFalse(isSatelliteEnabled());
6338 
6339         // Restore original binding state
6340         logd("testRequestSatelliteEnabled_ModemCrashDuringDisable: restoring mock satellite "
6341                 + "service (3)");
6342         sMockSatelliteServiceManager.resetSatelliteService();
6343         assertTrue(sMockSatelliteServiceManager.connectSatelliteService());
6344         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
6345         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
6346                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
6347 
6348         // Telephony will disable satellite when vendor service is connected. This will
6349         // interfere with the below test and make the test flaky.
6350         // Enable satellite should succeed
6351         logd("testRequestSatelliteEnabled_ModemCrashDuringDisable: enabling satellite (4)");
6352         callback.clearModemStates();
6353         requestSatelliteEnabled(true);
6354         assertTrue(callback.waitUntilResult(2));
6355         assertEquals(2, callback.getTotalCountOfModemStates());
6356         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
6357                 callback.getModemState(0));
6358         assertEquals(
6359                 SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.getModemState(1));
6360         assertTrue(isSatelliteEnabled());
6361 
6362         assertTrue(sMockSatelliteServiceManager.stopExternalSatelliteService());
6363         assertTrue(sMockSatelliteServiceManager
6364                 .waitForExternalSatelliteServiceDisconnected(1));
6365         sSatelliteManager.unregisterForModemStateChanged(callback);
6366         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
6367         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
6368         revokeSatellitePermission();
6369     }
6370 
6371     @Ignore("b/405228198 - Need to fix and re-enable this test.")
6372     @Test
testRequestSatelliteEnabled_ModemCrashDuringEnable()6373     public void testRequestSatelliteEnabled_ModemCrashDuringEnable() {
6374         /*
6375          * Test scenario:
6376          * 1) Send enable request to modem
6377          * 2) Satellite should move to ENABLING state
6378          * 3) Modem crash before responding to framework
6379          * 4) Modem come back up
6380          * 5) Framework abort the request and move to OFF state
6381          */
6382         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
6383         grantSatellitePermission();
6384         assertTrue(isSatelliteProvisioned());
6385 
6386         logd("testRequestSatelliteEnabled_ModemCrashDuringEnable: starting...");
6387         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
6388         long registerResult = sSatelliteManager.registerForModemStateChanged(
6389                 getContext().getMainExecutor(), callback);
6390         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
6391         assertTrue(callback.waitUntilResult(1));
6392 
6393         if (isSatelliteEnabled()) {
6394             logd("testRequestSatelliteEnabled_ModemCrashDuringEnable: disabling satellite... (1)");
6395             requestSatelliteEnabled(false);
6396             assertTrue(callback.waitUntilModemOff());
6397             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
6398             assertFalse(isSatelliteEnabled());
6399             callback.clearModemStates();
6400         }
6401 
6402         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
6403         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
6404                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
6405 
6406         // Move to enabling state
6407         logd("testRequestSatelliteEnabled_ModemCrashDuringEnable: enabling satellite (2)");
6408         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6409         callback.clearModemStates();
6410         LinkedBlockingQueue<Integer> enableResult =
6411                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
6412         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6413         assertTrue(callback.waitUntilResult(1));
6414         assertEquals(1, callback.getTotalCountOfModemStates());
6415         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
6416                 callback.getModemState(0));
6417 
6418         // Mocking modem crash scenario
6419         logd("testRequestSatelliteEnabled_ModemCrashDuringEnable: mocking modem crash (3)");
6420         callback.clearModemStates();
6421         assertTrue(sMockSatelliteServiceManager.connectExternalSatelliteService());
6422         assertTrue(sMockSatelliteServiceManager.waitForRemoteSatelliteServiceConnected(1));
6423 
6424         // The enable request should be aborted
6425         assertResult(enableResult, SATELLITE_RESULT_MODEM_ERROR);
6426         assertTrue(callback.waitUntilResult(1));
6427         assertEquals(1, callback.getTotalCountOfModemStates());
6428         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(0));
6429         assertFalse(isSatelliteEnabled());
6430 
6431         // Restore original binding state
6432         logd("testRequestSatelliteEnabled_ModemCrashDuringEnable: restoring mock satellite "
6433                 + "service (4)");
6434         sMockSatelliteServiceManager.resetSatelliteService();
6435         assertTrue(sMockSatelliteServiceManager.connectSatelliteService());
6436         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
6437         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
6438                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
6439 
6440         // Enable satellite should succeed
6441         logd("testRequestSatelliteEnabled_ModemCrashDuringEnable: enabling satellite (5)");
6442         callback.clearModemStates();
6443         requestSatelliteEnabled(true);
6444         assertTrue(callback.waitUntilResult(2));
6445         assertEquals(2, callback.getTotalCountOfModemStates());
6446         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
6447                 callback.getModemState(0));
6448         assertEquals(
6449                 SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.getModemState(1));
6450         assertTrue(isSatelliteEnabled());
6451 
6452         assertTrue(sMockSatelliteServiceManager.stopExternalSatelliteService());
6453         assertTrue(sMockSatelliteServiceManager
6454                 .waitForExternalSatelliteServiceDisconnected(1));
6455         sSatelliteManager.unregisterForModemStateChanged(callback);
6456         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
6457         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
6458         revokeSatellitePermission();
6459     }
6460 
6461     @Ignore("b/405228198 - Need to fix and re-enable this test.")
6462     @Test
6463     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteEnabled_ModemCrashDuringEnableEnableDisable()6464     public void testRequestSatelliteEnabled_ModemCrashDuringEnableEnableDisable() {
6465         /*
6466          * Test scenario:
6467          * 1) Send enable request to modem with demo mode
6468          * 2) Send enable request to modem with P2P mode
6469          * 3) Send a disable request to modem
6470          * 4) Modem crash before responding to framework
6471          * 5) Modem come back up
6472          * 6) Framework abort all requests and move to OFF state
6473          */
6474         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
6475         grantSatellitePermission();
6476         assertTrue(isSatelliteProvisioned());
6477 
6478         logd("testRequestSatelliteEnabled_ModemCrashDuringEnableEnableDisable: starting...");
6479         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
6480         long registerResult = sSatelliteManager.registerForModemStateChanged(
6481                 getContext().getMainExecutor(), callback);
6482         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
6483         assertTrue(callback.waitUntilResult(1));
6484 
6485         if (isSatelliteEnabled()) {
6486             logd("testRequestSatelliteEnabled_ModemCrashDuringEnableEnableDisable: disabling"
6487                     + " satellite... (1)");
6488             requestSatelliteEnabled(false);
6489             assertTrue(callback.waitUntilModemOff());
6490             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.modemState);
6491             assertFalse(isSatelliteEnabled());
6492             callback.clearModemStates();
6493         }
6494 
6495         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
6496         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
6497                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
6498 
6499         // Move to enabling state
6500         logd("testRequestSatelliteEnabled_ModemCrashDuringEnableEnableDisable: enabling"
6501                 + " satellite (2)");
6502         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6503         callback.clearModemStates();
6504         LinkedBlockingQueue<Integer> firtEnableResult =
6505                 requestSatelliteEnabledWithoutWaitingForResult(true, true, false);
6506         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6507         assertTrue(callback.waitUntilResult(1));
6508         assertEquals(1, callback.getTotalCountOfModemStates());
6509         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
6510                 callback.getModemState(0));
6511 
6512         // Change to real mode while enabling demo mode is in progress
6513         logd("testRequestSatelliteEnabled_ModemCrashDuringEnableEnableDisable: "
6514                 + "updating to real mode ... (3)");
6515         callback.clearModemStates();
6516         LinkedBlockingQueue<Integer> secondEnableResult =
6517                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
6518         // Wait for some time to make sure SatelliteController receive the second request
6519         waitFor(500);
6520 
6521         // Disable satellite while enabling and enable attributes updating are in progress
6522         logd("testRequestSatelliteEnabled_ModemCrashDuringEnableEnableDisable: disabling"
6523                 + " satellite... (4)");
6524         callback.clearModemStates();
6525         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6526         LinkedBlockingQueue<Integer> disableResult =
6527                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
6528         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6529         assertTrue(callback.waitUntilResult(1));
6530         assertEquals(1, callback.getTotalCountOfModemStates());
6531         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
6532                 callback.getModemState(0));
6533 
6534         // Mocking modem crash scenario
6535         logd("testRequestSatelliteEnabled_ModemCrashDuringEnableEnableDisable: mocking modem"
6536                 + " crash (5)");
6537         callback.clearModemStates();
6538         assertTrue(sMockSatelliteServiceManager.connectExternalSatelliteService());
6539         assertTrue(sMockSatelliteServiceManager.waitForRemoteSatelliteServiceConnected(1));
6540 
6541         // All requests should be aborted
6542         assertResult(firtEnableResult, SATELLITE_RESULT_MODEM_ERROR);
6543         assertResult(secondEnableResult, SATELLITE_RESULT_MODEM_ERROR);
6544         assertResult(disableResult, SATELLITE_RESULT_MODEM_ERROR);
6545         assertTrue(callback.waitUntilResult(1));
6546         assertEquals(1, callback.getTotalCountOfModemStates());
6547         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_OFF, callback.getModemState(0));
6548         assertFalse(isSatelliteEnabled());
6549 
6550         // Restore original binding state
6551         logd("testRequestSatelliteEnabled_ModemCrashDuringEnableEnableDisable: restoring mock  "
6552                 + "satellite service (6)");
6553         sMockSatelliteServiceManager.resetSatelliteService();
6554         assertTrue(sMockSatelliteServiceManager.connectSatelliteService());
6555         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
6556         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
6557                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
6558 
6559         // Enable satellite should succeed
6560         logd("testRequestSatelliteEnabled_ModemCrashDuringEnableEnableDisable: enabling"
6561                 + " satellite (7)");
6562         callback.clearModemStates();
6563         requestSatelliteEnabled(true);
6564         assertTrue(callback.waitUntilResult(2));
6565         assertEquals(2, callback.getTotalCountOfModemStates());
6566         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_ENABLING_SATELLITE,
6567                 callback.getModemState(0));
6568         assertEquals(
6569                 SatelliteManager.SATELLITE_MODEM_STATE_NOT_CONNECTED, callback.getModemState(1));
6570         assertTrue(isSatelliteEnabled());
6571 
6572         assertTrue(sMockSatelliteServiceManager.stopExternalSatelliteService());
6573         assertTrue(sMockSatelliteServiceManager
6574                 .waitForExternalSatelliteServiceDisconnected(1));
6575         sSatelliteManager.unregisterForModemStateChanged(callback);
6576         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
6577         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
6578         revokeSatellitePermission();
6579     }
6580 
6581     @Test
testRequestSatelliteEnabled_DisableEnable()6582     public void testRequestSatelliteEnabled_DisableEnable() {
6583         /*
6584          * Test scenario:
6585          * 1) Send disable request
6586          * 2) Send enable request
6587          * 3) The enable request is rejected
6588          */
6589         grantSatellitePermission();
6590         assertTrue(isSatelliteProvisioned());
6591 
6592         logd("testRequestSatelliteEnabled_DisableEnable: starting...");
6593         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
6594         long registerResult = sSatelliteManager.registerForModemStateChanged(
6595                 getContext().getMainExecutor(), callback);
6596         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
6597         assertTrue(callback.waitUntilResult(1));
6598 
6599         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
6600         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
6601                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
6602 
6603         // Move to disabling state
6604         logd("testRequestSatelliteEnabled_DisableEnable: disabling satellite (1)");
6605         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6606         callback.clearModemStates();
6607         LinkedBlockingQueue<Integer> disableResult =
6608                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
6609         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6610         assertTrue(callback.waitUntilResult(1));
6611         assertEquals(1, callback.getTotalCountOfModemStates());
6612         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
6613                 callback.getModemState(0));
6614         assertTrue(isSatelliteEnabled());
6615 
6616         // Send an enable request
6617         logd("testRequestSatelliteEnabled_DisableEnable: enabling satellite (2)");
6618         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6619         callback.clearModemStates();
6620         LinkedBlockingQueue<Integer> enableResult =
6621                 requestSatelliteEnabledWithoutWaitingForResult(true, false, false);
6622         assertResult(enableResult, SATELLITE_RESULT_DISABLE_IN_PROGRESS);
6623 
6624         // Send a successful response for the disable request
6625         logd("testRequestSatelliteEnabled_DisableEnable: responding to the disable request (3)");
6626         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(
6627                 false, SatelliteModemState.SATELLITE_MODEM_STATE_OFF));
6628         assertResult(disableResult, SATELLITE_RESULT_SUCCESS);
6629         assertFalse(isSatelliteEnabled());
6630 
6631         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
6632         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
6633                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
6634         sSatelliteManager.unregisterForModemStateChanged(callback);
6635         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
6636 
6637         revokeSatellitePermission();
6638     }
6639 
6640     @Test
testRequestSatelliteEnabled_DisableDisable()6641     public void testRequestSatelliteEnabled_DisableDisable() {
6642         /*
6643          * Test scenario:
6644          * 1) Send disable request
6645          * 2) Send another disable request
6646          * 3) The second disable request is rejected
6647          */
6648         grantSatellitePermission();
6649         assertTrue(isSatelliteProvisioned());
6650 
6651         logd("testRequestSatelliteEnabled_DisableDisable: starting...");
6652         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
6653         long registerResult = sSatelliteManager.registerForModemStateChanged(
6654                 getContext().getMainExecutor(), callback);
6655         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
6656         assertTrue(callback.waitUntilResult(1));
6657 
6658         sMockSatelliteServiceManager.setShouldRespondEnableRequest(false);
6659         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
6660                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, WAIT_FOREVER_TIMEOUT_MILLIS));
6661 
6662         // Move to disabling state
6663         logd("testRequestSatelliteEnabled_DisableDisable: disabling satellite (1)");
6664         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6665         callback.clearModemStates();
6666         LinkedBlockingQueue<Integer> disableResult =
6667                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
6668         assertTrue(sMockSatelliteServiceManager.waitForEventOnRequestSatelliteEnabled(1));
6669         assertTrue(callback.waitUntilResult(1));
6670         assertEquals(1, callback.getTotalCountOfModemStates());
6671         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DISABLING_SATELLITE,
6672                 callback.getModemState(0));
6673         assertTrue(isSatelliteEnabled());
6674 
6675         // Send another disable request
6676         logd("testRequestSatelliteEnabled_DisableDisable: disabling satellite (2)");
6677         sMockSatelliteServiceManager.clearRequestSatelliteEnabledPermits();
6678         callback.clearModemStates();
6679         LinkedBlockingQueue<Integer> enableResult =
6680                 requestSatelliteEnabledWithoutWaitingForResult(false, false, false);
6681         assertResult(enableResult, SATELLITE_RESULT_REQUEST_IN_PROGRESS);
6682 
6683         // Send a successful response for the disable request
6684         logd("testRequestSatelliteEnabled_DisableDisable: responding to the disable request (3)");
6685         assertTrue(sMockSatelliteServiceManager.respondToRequestSatelliteEnabled(
6686                 false, SatelliteModemState.SATELLITE_MODEM_STATE_OFF));
6687         assertResult(disableResult, SATELLITE_RESULT_SUCCESS);
6688         assertFalse(isSatelliteEnabled());
6689 
6690         sMockSatelliteServiceManager.setShouldRespondEnableRequest(true);
6691         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
6692                 TIMEOUT_TYPE_WAIT_FOR_SATELLITE_ENABLING_RESPONSE, 0));
6693         sSatelliteManager.unregisterForModemStateChanged(callback);
6694         sMockSatelliteServiceManager.clearSatelliteEnableRequestQueues();
6695 
6696         revokeSatellitePermission();
6697     }
6698 
6699 
6700     @Test
testRegisterForSupportedStateChanged()6701     public void testRegisterForSupportedStateChanged() {
6702         logd("testRegisterForSupportedStateChanged: start");
6703         grantSatellitePermission();
6704 
6705         /* Backup satellite supported state */
6706         final Pair<Boolean, Integer> originalSupportState = requestIsSatelliteSupported();
6707 
6708         SatelliteSupportedStateCallbackTest satelliteSupportedStateCallbackTest =
6709                 new SatelliteSupportedStateCallbackTest();
6710 
6711         /* Register callback for satellite supported state changed event */
6712         @SatelliteManager.SatelliteResult int registerError =
6713                 sSatelliteManager.registerForSupportedStateChanged(
6714                         getContext().getMainExecutor(), satelliteSupportedStateCallbackTest);
6715         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerError);
6716 
6717         /* Verify redundant report is ignored */
6718         sendOnSatelliteSupportedStateChanged(true);
6719         assertFalse(satelliteSupportedStateCallbackTest.waitUntilResult(1));
6720 
6721         /* Satellite is unsupported */
6722         sendOnSatelliteSupportedStateChanged(false);
6723         assertTrue(satelliteSupportedStateCallbackTest.waitUntilResult(1));
6724         assertFalse(satelliteSupportedStateCallbackTest.isSupported);
6725 
6726         /* Verify satellite is disabled */
6727         Pair<Boolean, Integer> pairResult = requestIsSatelliteSupported();
6728         assertFalse(pairResult.first);
6729         assertNull(pairResult.second);
6730 
6731         /* Verify redundant report is ignored */
6732         sendOnSatelliteSupportedStateChanged(false);
6733         assertFalse(satelliteSupportedStateCallbackTest.waitUntilResult(1));
6734 
6735         /* Verify whether satellite support changed event has received */
6736         sendOnSatelliteSupportedStateChanged(true);
6737         assertTrue(satelliteSupportedStateCallbackTest.waitUntilResult(1));
6738         assertTrue(satelliteSupportedStateCallbackTest.isSupported);
6739 
6740         /* Verify whether notified and requested capabilities are equal */
6741         pairResult = requestIsSatelliteSupported();
6742         assertTrue(pairResult.first);
6743         assertNull(pairResult.second);
6744 
6745         /* Verify redundant report is ignored */
6746         sendOnSatelliteSupportedStateChanged(true);
6747         assertFalse(satelliteSupportedStateCallbackTest.waitUntilResult(1));
6748 
6749         /* Restore initial satellite support state */
6750         sendOnSatelliteSupportedStateChanged(originalSupportState.first);
6751         satelliteSupportedStateCallbackTest.clearSupportedStates();
6752 
6753         sSatelliteManager.unregisterForSupportedStateChanged(satelliteSupportedStateCallbackTest);
6754         revokeSatellitePermission();
6755     }
6756 
6757     @Test
testDemoSimulator()6758     public void testDemoSimulator() {
6759         logd("testDemoSimulator: start");
6760         updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.NB_IOT_NTN}, true);
6761 
6762         grantSatellitePermission();
6763         assertTrue(isSatelliteProvisioned());
6764         assertTrue(isSatelliteEnabled());
6765 
6766         SatelliteModemStateCallbackTest stateCallback = new SatelliteModemStateCallbackTest();
6767         sSatelliteManager.registerForModemStateChanged(
6768                 getContext().getMainExecutor(), stateCallback);
6769         assertTrue(stateCallback.waitUntilResult(1));
6770 
6771         NtnSignalStrengthCallbackTest ntnSignalStrengthCallback =
6772                 new NtnSignalStrengthCallbackTest();
6773         /* register callback for non-terrestrial network signal strength changed event */
6774         sSatelliteManager.registerForNtnSignalStrengthChanged(getContext().getMainExecutor(),
6775                 ntnSignalStrengthCallback);
6776 
6777         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
6778                 TIMEOUT_TYPE_DEMO_POINTING_ALIGNED_DURATION_MILLIS, 5));
6779         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
6780                 TIMEOUT_TYPE_DEMO_POINTING_NOT_ALIGNED_DURATION_MILLIS, 10));
6781 
6782         try {
6783             logd("testDemoSimulator: Disable satellite");
6784             requestSatelliteEnabled(false);
6785             assertTrue(stateCallback.waitUntilModemOff());
6786             assertFalse(isSatelliteEnabled());
6787             stateCallback.clearModemStates();
6788 
6789             logd("testDemoSimulator: Enable satellite for demo mode");
6790             stateCallback.clearModemStates();
6791             ntnSignalStrengthCallback.drainPermits();
6792             requestSatelliteEnabledForDemoMode(true);
6793             assertTrue(stateCallback.waitUntilResult(2));
6794             assertTrue(isSatelliteEnabled());
6795             assertTrue(ntnSignalStrengthCallback.waitUntilResult(1));
6796             assertEquals(NtnSignalStrength.NTN_SIGNAL_STRENGTH_NONE,
6797                     ntnSignalStrengthCallback.mNtnSignalStrength.getLevel());
6798 
6799             logd("testDemoSimulator: Set device aligned with satellite");
6800             stateCallback.clearModemStates();
6801             ntnSignalStrengthCallback.drainPermits();
6802             sSatelliteManager.setDeviceAlignedWithSatellite(true);
6803             assertTrue(stateCallback.waitUntilResult(1));
6804             assertTrue(ntnSignalStrengthCallback.waitUntilResult(1));
6805             assertEquals(NtnSignalStrength.NTN_SIGNAL_STRENGTH_MODERATE,
6806                     ntnSignalStrengthCallback.mNtnSignalStrength.getLevel());
6807 
6808             logd("testDemoSimulator: Set device not aligned with satellite");
6809             stateCallback.clearModemStates();
6810             ntnSignalStrengthCallback.drainPermits();
6811             sSatelliteManager.setDeviceAlignedWithSatellite(false);
6812             assertTrue(stateCallback.waitUntilResult(1));
6813             assertTrue(ntnSignalStrengthCallback.waitUntilResult(1));
6814             assertEquals(NtnSignalStrength.NTN_SIGNAL_STRENGTH_NONE,
6815                     ntnSignalStrengthCallback.mNtnSignalStrength.getLevel());
6816 
6817             logd("testDemoSimulator: Disable satellite for demo mode");
6818             stateCallback.clearModemStates();
6819             requestSatelliteEnabledForDemoMode(false);
6820             assertTrue(stateCallback.waitUntilResult(2));
6821             assertFalse(isSatelliteEnabled());
6822         } finally {
6823             assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(
6824                     true, TIMEOUT_TYPE_DEMO_POINTING_ALIGNED_DURATION_MILLIS, 0));
6825             assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(
6826                     true, TIMEOUT_TYPE_DEMO_POINTING_NOT_ALIGNED_DURATION_MILLIS, 0));
6827 
6828             sSatelliteManager.unregisterForNtnSignalStrengthChanged(ntnSignalStrengthCallback);
6829             sSatelliteManager.unregisterForModemStateChanged(stateCallback);
6830             updateSupportedRadioTechnologies(new int[]{NTRadioTechnology.PROPRIETARY}, false);
6831             revokeSatellitePermission();
6832         }
6833     }
6834 
6835     @Test
testRequestSessionStats()6836     public void testRequestSessionStats() {
6837         logd("testRequestSessionStats: start");
6838         grantSatellitePermission();
6839         assertTrue(isSatelliteProvisioned());
6840         assertTrue(isSatelliteEnabled());
6841 
6842         SatelliteModemStateCallbackTest stateCallback = new SatelliteModemStateCallbackTest();
6843         sSatelliteManager.registerForModemStateChanged(
6844                 getContext().getMainExecutor(), stateCallback);
6845         assertTrue(stateCallback.waitUntilResult(1));
6846 
6847         try {
6848             SatelliteSessionStats sessionStats = new SatelliteSessionStats.Builder()
6849                     .setCountOfSuccessfulUserMessages(0)
6850                     .setCountOfUnsuccessfulUserMessages(0)
6851                     .setCountOfTimedOutUserMessagesWaitingForConnection(0)
6852                     .setCountOfTimedOutUserMessagesWaitingForAck(0)
6853                     .setCountOfUserMessagesInQueueToBeSent(0)
6854                     .build();
6855             Pair<SatelliteSessionStats, Integer> result = requestSessionStats();
6856             assertEquals(sessionStats, result.first);
6857 
6858             sessionStats = new SatelliteSessionStats.Builder()
6859                     .setCountOfSuccessfulUserMessages(5)
6860                     .setCountOfUnsuccessfulUserMessages(2)
6861                     .setCountOfTimedOutUserMessagesWaitingForConnection(0)
6862                     .setCountOfTimedOutUserMessagesWaitingForAck(0)
6863                     .setCountOfUserMessagesInQueueToBeSent(4)
6864                     .build();
6865 
6866             for (int i = 0; i < 5; i++) {
6867                 sendSatelliteDatagramSuccess(true, true);
6868             }
6869 
6870             LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
6871             String mText = "This is a test datagram message from user";
6872             SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
6873 
6874             for (int i = 0; i < 2; i++) {
6875                 stateCallback.clearModemStates();
6876                 sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_ERROR);
6877                 sSatelliteManager.sendDatagram(
6878                         SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE, datagram, true,
6879                         getContext().getMainExecutor(), resultListener::offer);
6880 
6881                 Integer errorCode;
6882                 try {
6883                     errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
6884                 } catch (InterruptedException ex) {
6885                     fail("testSendSatelliteDatagram_failure: Got InterruptedException in waiting"
6886                             + " for the sendSatelliteDatagram result code");
6887                     return;
6888                 }
6889                 assertNotNull(errorCode);
6890                 assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_ERROR);
6891             }
6892 
6893             // Wait to process datagrams so that datagrams are added to pending list.
6894             sMockSatelliteServiceManager.setWaitToSend(true);
6895             for (int i = 0; i < 4; i++) {
6896                 // Send 4 user messages
6897                 sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
6898                         datagram, true, getContext().getMainExecutor(),
6899                         resultListener::offer);
6900             }
6901 
6902             // Send 1 keep alive message
6903             // This should be ignored and not be included in pending datagrams count
6904             sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_KEEP_ALIVE,
6905                     datagram, true, getContext().getMainExecutor(),
6906                     resultListener::offer);
6907 
6908             result = requestSessionStats();
6909             assertEquals(sessionStats, result.first);
6910 
6911             sMockSatelliteServiceManager.setWaitToSend(false);
6912         } finally {
6913             revokeSatellitePermission();
6914         }
6915     }
6916 
6917     @Test
6918     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteSubscriberProvisionStatus()6919     public void testRequestSatelliteSubscriberProvisionStatus() {
6920         logd("testRequestSatelliteSubscriberProvisionStatus:");
6921         grantSatellitePermission();
6922         try {
6923             Pair<List<SatelliteSubscriberProvisionStatus>, Integer> pairResult =
6924                     requestSatelliteSubscriberProvisionStatus();
6925             if (pairResult == null) {
6926                 fail("requestSatelliteSubscriberProvisionStatus "
6927                         + "List<SatelliteSubscriberProvisionStatus> null");
6928             }
6929             for (SatelliteSubscriberProvisionStatus status : pairResult.first) {
6930                 SatelliteSubscriberInfo info = status.getSatelliteSubscriberInfo();
6931                 // Check SubscriberIdType is the
6932                 // SatelliteSubscriberInfo.SUBSCRIBER_ID_TYPE_IMSI_MSISDN
6933                 if (info.getSubscriptionId() == sTestSubIDForCarrierSatellite) {
6934                     assertEquals(
6935                             SatelliteSubscriberInfo.SUBSCRIBER_ID_TYPE_IMSI_MSISDN,
6936                             info.getSubscriberIdType());
6937                 }
6938             }
6939         } finally {
6940             revokeSatellitePermission();
6941         }
6942     }
6943 
6944     @Test
6945     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSelectedNbIotSatelliteSubscriptionId()6946     public void testRequestSelectedNbIotSatelliteSubscriptionId() {
6947         logd("testRequestSelectedNbIotSatelliteSubscriptionId:");
6948         grantSatellitePermission();
6949         try {
6950             Pair<Integer, Integer> pairResult =
6951                     requestSelectedNbIotSatelliteSubscriptionId();
6952             if (pairResult == null) {
6953                 fail("requestSelectedNbIotSatelliteSubscriptionId: null");
6954             }
6955             assertNotEquals(SubscriptionManager.INVALID_SUBSCRIPTION_ID, (long) pairResult.first);
6956         } finally {
6957             revokeSatellitePermission();
6958         }
6959     }
6960 
6961     @Test
6962     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testRequestSatelliteDisplayName()6963     public void testRequestSatelliteDisplayName() {
6964         logd("testRequestSatelliteDisplayName: sEsosSubId=" + sEsosSubId);
6965         grantSatellitePermission();
6966         try {
6967             Pair<CharSequence, Integer> pairResult = requestSatelliteDisplayName();
6968             if (pairResult == null) {
6969                 fail("requestSatelliteDisplayName: null");
6970             }
6971             assertNull(pairResult.second);
6972             if (TextUtils.isEmpty(pairResult.first)) {
6973                 assumeTrue(sEsosSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID);
6974 
6975                 String displayName = "Satellite";
6976                 PersistableBundle bundle = new PersistableBundle();
6977                 bundle.putString(
6978                         CarrierConfigManager.KEY_SATELLITE_DISPLAY_NAME_STRING, displayName);
6979                 overrideCarrierConfig(sEsosSubId, bundle);
6980 
6981                 pairResult = requestSatelliteDisplayName();
6982                 if (pairResult == null) {
6983                     fail("requestSatelliteDisplayName: null");
6984                 }
6985                 assertEquals(displayName, pairResult.first);
6986                 assertNull(pairResult.second);
6987             }
6988         } finally {
6989             revokeSatellitePermission();
6990         }
6991     }
6992 
6993     @Test
6994     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testSatelliteSubscriptionProvisionStateChanged()6995     public void testSatelliteSubscriptionProvisionStateChanged() {
6996         logd("testSatelliteSubscriptionProvisionStateChanged:");
6997         assumeTrue(sTestSubIDForCarrierSatellite != SubscriptionManager.INVALID_SUBSCRIPTION_ID);
6998 
6999         SatelliteSubscriptionProvisionStateChangedTest callback =
7000                 registerSubscriberIdProvisionCallback();
7001         assertTrue(provisionSatelliteForSubscriberId(callback));
7002 
7003         afterSubscriberIdTest(callback);
7004     }
7005 
7006     @Ignore("b/405223241 - This test is flaky. Need to fix and re-enable it.")
7007     @Test
7008     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testReceiveIntentActionSatelliteSubscriberIdListChangedAfterCarrierConfigChanged()7009     public void testReceiveIntentActionSatelliteSubscriberIdListChangedAfterCarrierConfigChanged()
7010             throws Exception {
7011         logd("testReceiveIntentActionSatelliteSubscriberIdListChangedAfterCarrierConfigChanged:");
7012         sTestSubIDForCarrierSatellite = getActiveSubIDForCarrierSatelliteTest();
7013         SatelliteReceiverTest receiver = setUpSatelliteReceiverTest();
7014         Context context = getContext();
7015         grantSatellitePermission();
7016         try {
7017             // ACTION_SATELLITE_SUBSCRIBER_ID_LIST_CHANGED is not sent when satellite is enabled.
7018             if (isSatelliteEnabled()) {
7019                 logd("Disable satellite");
7020                 SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
7021                 long registerResult = sSatelliteManager.registerForModemStateChanged(
7022                         getContext().getMainExecutor(), callback);
7023                 assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
7024                 assertTrue(callback.waitUntilResult(1));
7025 
7026                 requestSatelliteEnabled(false);
7027                 assertTrue(callback.waitUntilModemOff());
7028                 assertFalse(isSatelliteEnabled());
7029 
7030                 sSatelliteManager.unregisterForModemStateChanged(callback);
7031             }
7032 
7033             receiver.clearQueue();
7034             // Check if the ACTION_SATELLITE_SUBSCRIBER_ID_LIST_CHANGED intent is sent by reading
7035             // carrier config KEY_SATELLITE_ESOS_SUPPORTED_BOOL value and setting the opposite
7036             // value.
7037             boolean eSosSupported = getConfigForSubId(context, sTestSubIDForCarrierSatellite,
7038                     CarrierConfigManager.KEY_SATELLITE_ESOS_SUPPORTED_BOOL).getBoolean(
7039                     CarrierConfigManager.KEY_SATELLITE_ESOS_SUPPORTED_BOOL, false);
7040             PersistableBundle bundle = new PersistableBundle();
7041             bundle.putBoolean(CarrierConfigManager.KEY_SATELLITE_ESOS_SUPPORTED_BOOL,
7042                     !eSosSupported);
7043             overrideCarrierConfig(sTestSubIDForCarrierSatellite, bundle);
7044             assertTrue(receiver.waitForReceive());
7045         } finally {
7046             resetSatelliteReceiverTest(context, receiver);
7047             revokeSatellitePermission();
7048         }
7049     }
7050 
7051     @Ignore("b/405223241 - This test is flaky. Need to fix and re-enable it.")
7052     @Test
7053     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testReceiveIntentActionSatelliteSubscriberIdListChangedAfterDefaultSmsSubIdChanged()7054     public void testReceiveIntentActionSatelliteSubscriberIdListChangedAfterDefaultSmsSubIdChanged()
7055             throws Exception {
7056         assumeTrue(getContext().getPackageManager().hasSystemFeature(
7057                 PackageManager.FEATURE_TELEPHONY_MESSAGING));
7058 
7059         logd("testReceiveIntentActionSatelliteSubscriberIdListChangedAfterDefaultSmsSubIdChanged:");
7060         SatelliteReceiverTest receiver = setUpSatelliteReceiverTest();
7061         Context context = getContext();
7062         SubscriptionManager subscriptionManager = context.getSystemService(
7063                 SubscriptionManager.class);
7064         int defaultSmsSubId = subscriptionManager.getDefaultSmsSubscriptionId();
7065         grantSatellitePermission();
7066         try {
7067             // ACTION_SATELLITE_SUBSCRIBER_ID_LIST_CHANGED is not sent when satellite is enabled.
7068             if (isSatelliteEnabled()) {
7069                 logd("Disable satellite");
7070                 SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
7071                 long registerResult = sSatelliteManager.registerForModemStateChanged(
7072                         getContext().getMainExecutor(), callback);
7073                 assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
7074                 assertTrue(callback.waitUntilResult(1));
7075 
7076                 requestSatelliteEnabled(false);
7077                 assertTrue(callback.waitUntilModemOff());
7078                 assertFalse(isSatelliteEnabled());
7079 
7080                 sSatelliteManager.unregisterForModemStateChanged(callback);
7081             }
7082 
7083             boolean eSosSupported = getConfigForSubId(context, sTestSubIDForCarrierSatellite,
7084                     CarrierConfigManager.KEY_SATELLITE_ESOS_SUPPORTED_BOOL).getBoolean(
7085                     CarrierConfigManager.KEY_SATELLITE_ESOS_SUPPORTED_BOOL, false);
7086             // Set carrier config KEY_SATELLITE_ESOS_SUPPORTED_BOOL to true.
7087             if (!eSosSupported) {
7088                 PersistableBundle bundle = new PersistableBundle();
7089                 bundle.putBoolean(CarrierConfigManager.KEY_SATELLITE_ESOS_SUPPORTED_BOOL, true);
7090                 overrideCarrierConfig(sTestSubIDForCarrierSatellite, bundle);
7091             }
7092             receiver.clearQueue();
7093             // When the default SMS subId changes, check if the
7094             // ACTION_SATELLITE_SUBSCRIBER_ID_LIST_CHANGED intent has been sent.
7095             setDefaultSmsSubId(context, SubscriptionManager.INVALID_SUBSCRIPTION_ID);
7096             assertTrue(receiver.waitForReceive());
7097         } finally {
7098             resetSatelliteReceiverTest(context, receiver);
7099             setDefaultSmsSubId(context, defaultSmsSubId);
7100             revokeSatellitePermission();
7101         }
7102     }
7103 
7104     @Ignore("b/405223241 - This test is flaky. Need to fix and re-enable it.")
7105     @Test
7106     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testReceiveIntentAfterChangedToOnlyHaveIsNtnOnlyCase()7107     public void testReceiveIntentAfterChangedToOnlyHaveIsNtnOnlyCase() throws Exception {
7108         logd("testReceiveIntentAfterChangedToOnlyHaveIsNtnOnlyCase:");
7109         Context context = getContext();
7110         SubscriptionManager sm = context.getSystemService(SubscriptionManager.class);
7111         List<SubscriptionInfo> subscriptionInfoList = sm.getAllSubscriptionInfoList();
7112         boolean isNtnOnlySimExist = false;
7113         for (SubscriptionInfo info : subscriptionInfoList) {
7114             if (info.isOnlyNonTerrestrialNetwork()) {
7115                 isNtnOnlySimExist = true;
7116             }
7117         }
7118 
7119         if (isNtnOnlySimExist) {
7120             SatelliteReceiverTest receiver = setUpSatelliteReceiverTest();
7121             grantSatellitePermission();
7122             try {
7123                 boolean eSosSupported = getConfigForSubId(context, sTestSubIDForCarrierSatellite,
7124                         CarrierConfigManager.KEY_SATELLITE_ESOS_SUPPORTED_BOOL).getBoolean(
7125                         CarrierConfigManager.KEY_SATELLITE_ESOS_SUPPORTED_BOOL, false);
7126                 PersistableBundle bundle = new PersistableBundle();
7127                 // Set carrier config KEY_SATELLITE_ESOS_SUPPORTED_BOOL to true.
7128                 if (!eSosSupported) {
7129                     bundle.putBoolean(CarrierConfigManager.KEY_SATELLITE_ESOS_SUPPORTED_BOOL, true);
7130                     overrideCarrierConfig(sTestSubIDForCarrierSatellite, bundle);
7131                 }
7132                 // When only is ntn only sim exists for supporting the satellite, check if the
7133                 // ACTION_SATELLITE_SUBSCRIBER_ID_LIST_CHANGED intent has been sent.
7134                 receiver.clearQueue();
7135                 bundle.putBoolean(CarrierConfigManager.KEY_SATELLITE_ESOS_SUPPORTED_BOOL, false);
7136                 overrideCarrierConfig(sTestSubIDForCarrierSatellite, bundle);
7137                 assertTrue(receiver.waitForReceive());
7138             } finally {
7139                 resetSatelliteReceiverTest(context, receiver);
7140                 revokeSatellitePermission();
7141             }
7142         }
7143     }
7144 
registerSubscriberIdProvisionCallback()7145     private static SatelliteSubscriptionProvisionStateChangedTest registerSubscriberIdProvisionCallback() {
7146         logd("getSubscriberIdProvisionCallback");
7147         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
7148                 TIMEOUT_TYPE_EVALUATE_ESOS_PROFILES_PRIORITIZATION_DURATION_MILLIS, 5));
7149         /* Test when this carrier is supported ESOS in the carrier config */
7150         PersistableBundle bundle = new PersistableBundle();
7151         bundle.putBoolean(CarrierConfigManager.KEY_SATELLITE_ESOS_SUPPORTED_BOOL, true);
7152         overrideCarrierConfig(sTestSubIDForCarrierSatellite, bundle);
7153 
7154         grantSatellitePermission();
7155         SatelliteSubscriptionProvisionStateChangedTest callback =
7156                 new SatelliteSubscriptionProvisionStateChangedTest();
7157         long registerError = sSatelliteManager.registerForProvisionStateChanged(
7158                 getContext().getMainExecutor(), callback);
7159         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerError);
7160 
7161         return callback;
7162     }
7163 
afterSubscriberIdTest( SatelliteSubscriptionProvisionStateChangedTest callback)7164     private static void afterSubscriberIdTest(
7165             SatelliteSubscriptionProvisionStateChangedTest callback) {
7166         if (callback != null) {
7167             sSatelliteManager.unregisterForProvisionStateChanged(callback);
7168         }
7169         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
7170                 TIMEOUT_TYPE_EVALUATE_ESOS_PROFILES_PRIORITIZATION_DURATION_MILLIS, 0));
7171         revokeSatellitePermission();
7172     }
7173 
getSatelliteSubscriberInfoList( boolean provisioned)7174     private static List<SatelliteSubscriberInfo> getSatelliteSubscriberInfoList(
7175             boolean provisioned) {
7176         List<SatelliteSubscriberInfo> list = new ArrayList<>();
7177         Pair<List<SatelliteSubscriberProvisionStatus>, Integer> pairResult =
7178                 requestSatelliteSubscriberProvisionStatus();
7179         if (pairResult == null) {
7180             return list;
7181         }
7182         for (SatelliteSubscriberProvisionStatus status : pairResult.first) {
7183             SatelliteSubscriberInfo info = status.getSatelliteSubscriberInfo();
7184             if (provisioned == status.isProvisioned()) {
7185                 list.add(info);
7186             }
7187         }
7188         return list;
7189     }
7190 
deprovisionSatelliteForSubscriberId( SatelliteSubscriptionProvisionStateChangedTest callback)7191     private void deprovisionSatelliteForSubscriberId(
7192             SatelliteSubscriptionProvisionStateChangedTest callback) {
7193         List<SatelliteSubscriberInfo> requestDeprovisionSubscriberId =
7194                 getSatelliteSubscriberInfoList(true);
7195         if (requestDeprovisionSubscriberId.size() == 0) {
7196             logd("already deprovision this subscriberId");
7197             return;
7198         }
7199         callback.clearProvisionedStates();
7200         Pair<Boolean, Integer> pairResult = deprovisionSatellite(requestDeprovisionSubscriberId);
7201         assertTrue(callback.waitUntilResult(1));
7202         assertTrue(pairResult.first);
7203         assertFalse(callback.getResultList().get(0).isProvisioned());
7204 
7205         // Request deprovisioning with the same SatelliteSubscriberInfo that was previously
7206         // requested, and verify that onSatelliteSubscriptionProvisionStateChanged is not called.
7207         pairResult = deprovisionSatellite(requestDeprovisionSubscriberId);
7208         assertFalse(callback.waitUntilResult(1));
7209         assertTrue(pairResult.first);
7210         callback.clearProvisionedStates();
7211     }
7212 
provisionSatelliteForSubscriberId( SatelliteSubscriptionProvisionStateChangedTest callback)7213     private boolean provisionSatelliteForSubscriberId(
7214             SatelliteSubscriptionProvisionStateChangedTest callback) {
7215         Pair<List<SatelliteSubscriberProvisionStatus>, Integer> pairResult =
7216                 requestSatelliteSubscriberProvisionStatus();
7217         if (pairResult == null) {
7218             fail("requestSatelliteSubscriberProvisionStatus "
7219                     + "List<SatelliteSubscriberProvisionStatus> null");
7220             return false;
7221         }
7222         if (pairResult.first.size() > 0) {
7223             // Get the not provisioned subscriberId List.
7224             List<SatelliteSubscriberInfo> notProvisionedSubscriberList =
7225                     getSatelliteSubscriberInfoList(false);
7226             // If all subscriberIds already provisioned then trigger deprovision.
7227             if (notProvisionedSubscriberList.size() == 0) {
7228                 deprovisionSatelliteForSubscriberId(callback);
7229             }
7230 
7231             // Get the not provisioned subscriberId List again.
7232             notProvisionedSubscriberList = getSatelliteSubscriberInfoList(false);
7233             // Request provisioning with SatelliteSubscriberInfo that has not been provisioned
7234             // before, and verify that onSatelliteSubscriptionProvisionStateChanged is called.
7235             if (notProvisionedSubscriberList.size() > 0) {
7236                 Pair<Boolean, Integer> pairResultForProvisionSatellite = provisionSatellite(
7237                         notProvisionedSubscriberList);
7238                 assertTrue(callback.waitUntilResult(1));
7239                 assertTrue(pairResultForProvisionSatellite.first);
7240                 assertTrue(callback.getResultList().get(0).isProvisioned());
7241 
7242                 // Request provisioning with the same SatelliteSubscriberInfo that was previously
7243                 // requested, and verify that onSatelliteSubscriptionProvisionStateChanged is not
7244                 // called.
7245                 pairResultForProvisionSatellite = provisionSatellite(
7246                         notProvisionedSubscriberList);
7247                 assertFalse(callback.waitUntilResult(1));
7248                 assertTrue(pairResultForProvisionSatellite.first);
7249             } else {
7250                 logd("provisionSatelliteForSubscriberId: no provisioning list");
7251                 return false;
7252             }
7253         }
7254 
7255         logd("provisionSatelliteForSubscriberId true");
7256         return true;
7257     }
7258 
7259     @Test
7260     @RequiresFlagsEnabled(Flags.FLAG_CARRIER_ROAMING_NB_IOT_NTN)
testDeprovisionSatellite()7261     public void testDeprovisionSatellite() {
7262         logd("testDeprovisionSatellite:");
7263         sTestSubIDForCarrierSatellite = getActiveSubIDForCarrierSatelliteTest();
7264         assumeTrue(sTestSubIDForCarrierSatellite != SubscriptionManager.INVALID_SUBSCRIPTION_ID);
7265 
7266         SatelliteSubscriptionProvisionStateChangedTest callback =
7267                 registerSubscriberIdProvisionCallback();
7268         assertTrue(provisionSatelliteForSubscriberId(callback));
7269         deprovisionSatelliteForSubscriberId(callback);
7270 
7271         afterSubscriberIdTest(callback);
7272     }
7273 
7274     @Test
7275     @RequiresFlagsEnabled(Flags.FLAG_SATELLITE_25Q4_APIS)
testGetSatelliteDataSupportMode()7276     public void testGetSatelliteDataSupportMode() {
7277         logd("testGetSatelliteDataSupportMode");
7278 
7279         if (!shouldTestSatellite()) return;
7280         grantSatellitePermission();
7281 
7282         if (Flags.carrierRoamingNbIotNtn()) {
7283             sTestSubIDForCarrierSatellite = getActiveSubIDForCarrierSatelliteTest();
7284             logd("sub_id:" + sTestSubIDForCarrierSatellite);
7285             if (sTestSubIDForCarrierSatellite == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
7286                 return;
7287             }
7288 
7289             // Update available services with data for the carrier sub id
7290             PersistableBundle bundle = new PersistableBundle();
7291             int[] defaultSupportedServices = {2, 3, 6};
7292             bundle.putIntArray(
7293                     CarrierConfigManager.KEY_CARRIER_ROAMING_SATELLITE_DEFAULT_SERVICES_INT_ARRAY,
7294                     defaultSupportedServices);
7295             // With data mode: restricted
7296             bundle.putInt(CarrierConfigManager.KEY_SATELLITE_DATA_SUPPORT_MODE_INT,
7297                     SatelliteManager.SATELLITE_DATA_SUPPORT_RESTRICTED);
7298             overrideCarrierConfig(sTestSubIDForCarrierSatellite, bundle);
7299 
7300             assertEquals(SatelliteManager.SATELLITE_DATA_SUPPORT_RESTRICTED,
7301                     sSatelliteManager.getSatelliteDataSupportMode(sTestSubIDForCarrierSatellite));
7302 
7303             // With data mode: constrained
7304             bundle.putInt(CarrierConfigManager.KEY_SATELLITE_DATA_SUPPORT_MODE_INT,
7305                     SatelliteManager.SATELLITE_DATA_SUPPORT_CONSTRAINED);
7306             overrideCarrierConfig(sTestSubIDForCarrierSatellite, bundle);
7307             assertEquals(SatelliteManager.SATELLITE_DATA_SUPPORT_CONSTRAINED,
7308                     sSatelliteManager.getSatelliteDataSupportMode(sTestSubIDForCarrierSatellite));
7309 
7310             // With data mode: UnConstrained
7311             bundle.putInt(CarrierConfigManager.KEY_SATELLITE_DATA_SUPPORT_MODE_INT,
7312                     SatelliteManager.SATELLITE_DATA_SUPPORT_UNCONSTRAINED);
7313             overrideCarrierConfig(sTestSubIDForCarrierSatellite, bundle);
7314             assertEquals(SatelliteManager.SATELLITE_DATA_SUPPORT_UNCONSTRAINED,
7315                     sSatelliteManager.getSatelliteDataSupportMode(sTestSubIDForCarrierSatellite));
7316         }
7317     }
7318 
7319     /*
7320      * Before calling this function, caller need to make sure the modem is in LISTENING or IDLE
7321      * state.
7322      */
sendSatelliteDatagramWithSuccessfulResult( SatelliteModemStateCallbackTest callback, boolean verifyListenToIdleTransition)7323     private void sendSatelliteDatagramWithSuccessfulResult(
7324             SatelliteModemStateCallbackTest callback, boolean verifyListenToIdleTransition) {
7325         if (callback.modemState != SatelliteManager.SATELLITE_MODEM_STATE_LISTENING
7326                 && callback.modemState != SatelliteManager.SATELLITE_MODEM_STATE_IDLE) {
7327             fail("sendSatelliteDatagramWithSuccessfulResult: wrong modem state="
7328                     + callback.modemState);
7329             return;
7330         }
7331 
7332         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
7333         String mText = "This is a test datagram message from user";
7334         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
7335 
7336         sMockSatelliteServiceManager.clearListeningEnabledList();
7337         callback.clearModemStates();
7338         sSatelliteManager.sendDatagram(
7339                 SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE, datagram, true,
7340                 getContext().getMainExecutor(), resultListener::offer);
7341 
7342         Integer errorCode;
7343         try {
7344             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
7345         } catch (InterruptedException ex) {
7346             fail("testSatelliteModemStateChanged: Got InterruptedException in waiting"
7347                     + " for the sendDatagram result code");
7348             return;
7349         }
7350         assertNotNull(errorCode);
7351         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, (long) errorCode);
7352 
7353         /*
7354          * Modem state should have the following transitions:
7355          * 1) IDLE to TRANSFERRING.
7356          * 2) TRANSFERRING to LISTENING.
7357          * 3) LISTENING to IDLE.
7358          *
7359          * When verifyListenToIdleTransition is true, we expect the above 3 state transitions.
7360          * Otherwise, we expect only the first 2 transitions since satellite is still in LISTENING
7361          * state (timeout duration is long when verifyListenToIdleTransition is false).
7362          */
7363         int expectedNumberOfEvents = verifyListenToIdleTransition ? 3 : 2;
7364         assertTrue(callback.waitUntilResult(expectedNumberOfEvents));
7365         assertEquals(expectedNumberOfEvents, callback.getTotalCountOfModemStates());
7366         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DATAGRAM_TRANSFERRING,
7367                 callback.getModemState(0));
7368         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_LISTENING,
7369                 callback.getModemState(1));
7370 
7371         /*
7372          * On entering LISTENING state, we expect one event of EventOnSatelliteListeningEnabled with
7373          * value true. On exiting LISTENING state, we expect one event of
7374          * EventOnSatelliteListeningEnabled with value false.
7375          *
7376          * When verifyListenToIdleTransition is true, we expect satellite entering and then exiting
7377          * LISTENING state. Otherwise, we expect satellite entering and staying at LISTENING state.
7378          */
7379         expectedNumberOfEvents = verifyListenToIdleTransition ? 2 : 1;
7380         assertTrue(sMockSatelliteServiceManager.waitForEventOnSatelliteListeningEnabled(
7381                 expectedNumberOfEvents));
7382         assertEquals(expectedNumberOfEvents,
7383                 sMockSatelliteServiceManager.getTotalCountOfListeningEnabledList());
7384         assertTrue(sMockSatelliteServiceManager.getListeningEnabled(0));
7385 
7386         if (verifyListenToIdleTransition) {
7387             assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE,
7388                     callback.getModemState(2));
7389             assertFalse(sMockSatelliteServiceManager.getListeningEnabled(1));
7390         }
7391         sMockSatelliteServiceManager.clearListeningEnabledList();
7392     }
7393 
7394     /*
7395      * Before calling this function, caller need to make sure the modem is in LISTENING or IDLE
7396      * state.
7397      */
sendSatelliteDatagramWithFailedResult(SatelliteModemStateCallbackTest callback)7398     private void sendSatelliteDatagramWithFailedResult(SatelliteModemStateCallbackTest callback) {
7399         if (callback.modemState != SatelliteManager.SATELLITE_MODEM_STATE_LISTENING
7400                 && callback.modemState != SatelliteManager.SATELLITE_MODEM_STATE_IDLE) {
7401             fail("sendSatelliteDatagramWithFailedResult: wrong modem state=" + callback.modemState);
7402             return;
7403         }
7404         boolean isFirstStateListening =
7405                 (callback.modemState == SatelliteManager.SATELLITE_MODEM_STATE_LISTENING);
7406 
7407         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
7408         String mText = "This is a test datagram message from user";
7409         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
7410 
7411         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_ERROR);
7412         sMockSatelliteServiceManager.clearListeningEnabledList();
7413         callback.clearModemStates();
7414         sSatelliteManager.sendDatagram(
7415                 SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE, datagram, true,
7416                 getContext().getMainExecutor(), resultListener::offer);
7417 
7418         Integer errorCode;
7419         try {
7420             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
7421         } catch (InterruptedException ex) {
7422             fail("testSatelliteModemStateChanged: Got InterruptedException in waiting"
7423                     + " for the sendDatagram result code");
7424             return;
7425         }
7426         assertNotNull(errorCode);
7427         assertEquals(SatelliteManager.SATELLITE_RESULT_ERROR, (long) errorCode);
7428         assertTrue(callback.waitUntilResult(2));
7429         assertEquals(2, callback.getTotalCountOfModemStates());
7430         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DATAGRAM_TRANSFERRING,
7431                 callback.getModemState(0));
7432         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE,
7433                 callback.getModemState(1));
7434 
7435         if (isFirstStateListening) {
7436             assertTrue(sMockSatelliteServiceManager.waitForEventOnSatelliteListeningEnabled(1));
7437             assertEquals(1, sMockSatelliteServiceManager.getTotalCountOfListeningEnabledList());
7438             assertFalse(sMockSatelliteServiceManager.getListeningEnabled(0));
7439         }
7440         sMockSatelliteServiceManager.clearListeningEnabledList();
7441         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_SUCCESS);
7442     }
7443 
7444     /*
7445      * Before calling this function, caller need to make sure the modem is in LISTENING state.
7446      */
receiveSatelliteDatagramWithSuccessfulResult( SatelliteModemStateCallbackTest callback)7447     private void receiveSatelliteDatagramWithSuccessfulResult(
7448             SatelliteModemStateCallbackTest callback) {
7449         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_LISTENING, callback.modemState);
7450 
7451         // TODO (b/275086547): remove the below registerForIncomingDatagram command when the bug
7452         // is resolved.
7453         SatelliteDatagramCallbackTest satelliteDatagramCallback =
7454                 new SatelliteDatagramCallbackTest();
7455         sSatelliteManager.registerForIncomingDatagram(
7456                 getContext().getMainExecutor(), satelliteDatagramCallback);
7457 
7458         sMockSatelliteServiceManager.clearListeningEnabledList();
7459         callback.clearModemStates();
7460         sMockSatelliteServiceManager.sendOnPendingDatagrams();
7461         assertTrue(sMockSatelliteServiceManager.waitForEventOnPollPendingSatelliteDatagrams(1));
7462 
7463         assertTrue(callback.waitUntilResult(1));
7464         assertEquals(1, callback.getTotalCountOfModemStates());
7465         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DATAGRAM_TRANSFERRING,
7466                 callback.getModemState(0));
7467 
7468         assertTrue(sMockSatelliteServiceManager.waitForEventOnSatelliteListeningEnabled(1));
7469         assertEquals(1, sMockSatelliteServiceManager.getTotalCountOfListeningEnabledList());
7470         assertFalse(sMockSatelliteServiceManager.getListeningEnabled(0));
7471 
7472         String receivedText = "This is a test datagram message from satellite";
7473         android.telephony.satellite.stub.SatelliteDatagram receivedDatagram =
7474                 new android.telephony.satellite.stub.SatelliteDatagram();
7475         receivedDatagram.data = receivedText.getBytes();
7476 
7477         sMockSatelliteServiceManager.clearListeningEnabledList();
7478         callback.clearModemStates();
7479         sMockSatelliteServiceManager.sendOnSatelliteDatagramReceived(receivedDatagram, 0);
7480         assertTrue(callback.waitUntilResult(1));
7481         assertEquals(1, callback.getTotalCountOfModemStates());
7482         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_LISTENING,
7483                 callback.getModemState(0));
7484 
7485         assertTrue(sMockSatelliteServiceManager.waitForEventOnSatelliteListeningEnabled(1));
7486         assertEquals(1, sMockSatelliteServiceManager.getTotalCountOfListeningEnabledList());
7487         assertTrue(sMockSatelliteServiceManager.getListeningEnabled(0));
7488         sMockSatelliteServiceManager.clearListeningEnabledList();
7489 
7490         sSatelliteManager.unregisterForIncomingDatagram(satelliteDatagramCallback);
7491     }
7492 
7493     /*
7494      * Before calling this function, caller need to make sure the modem is in LISTENING state.
7495      */
receiveSatelliteDatagramWithFailedResult( SatelliteModemStateCallbackTest callback)7496     private void receiveSatelliteDatagramWithFailedResult(
7497             SatelliteModemStateCallbackTest callback) {
7498         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_LISTENING, callback.modemState);
7499 
7500         // TODO (b/275086547): remove the below registerForIncomingDatagram command when the bug
7501         // is resolved.
7502         SatelliteDatagramCallbackTest satelliteDatagramCallback =
7503                 new SatelliteDatagramCallbackTest();
7504         sSatelliteManager.registerForIncomingDatagram(
7505                 getContext().getMainExecutor(), satelliteDatagramCallback);
7506 
7507         sMockSatelliteServiceManager.clearListeningEnabledList();
7508         callback.clearModemStates();
7509         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_ERROR);
7510         sMockSatelliteServiceManager.sendOnPendingDatagrams();
7511         assertTrue(sMockSatelliteServiceManager.waitForEventOnPollPendingSatelliteDatagrams(1));
7512 
7513         assertTrue(callback.waitUntilResult(2));
7514         assertEquals(2, callback.getTotalCountOfModemStates());
7515         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_DATAGRAM_TRANSFERRING,
7516                 callback.getModemState(0));
7517         assertEquals(SatelliteManager.SATELLITE_MODEM_STATE_IDLE,
7518                 callback.getModemState(1));
7519 
7520         /*
7521          * On entering LISTENING state, we expect one event of EventOnSatelliteListeningEnabled with
7522          * value true. On exiting LISTENING state, we expect one event of
7523          * EventOnSatelliteListeningEnabled with value false.
7524          *
7525          * At the beginning of this function, satellite is in LISTENING state. It then transitions
7526          * to TRANSFERRING state. Thus, we expect one event of EventOnSatelliteListeningEnabled with
7527          * value false.
7528          */
7529         assertTrue(sMockSatelliteServiceManager.waitForEventOnSatelliteListeningEnabled(1));
7530         assertEquals(1, sMockSatelliteServiceManager.getTotalCountOfListeningEnabledList());
7531         assertFalse(sMockSatelliteServiceManager.getListeningEnabled(0));
7532 
7533         sMockSatelliteServiceManager.clearListeningEnabledList();
7534         sSatelliteManager.unregisterForIncomingDatagram(satelliteDatagramCallback);
7535         sMockSatelliteServiceManager.setErrorCode(SatelliteResult.SATELLITE_RESULT_SUCCESS);
7536     }
7537 
moveToSendingState()7538     private void moveToSendingState() {
7539         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
7540         SatelliteTransmissionUpdateCallbackTest callback =
7541                 new SatelliteTransmissionUpdateCallbackTest();
7542         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
7543                 resultListener::offer, callback);
7544         Integer errorCode;
7545         try {
7546             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
7547         } catch (InterruptedException ex) {
7548             fail("moveToSendingState: Got InterruptedException in waiting"
7549                     + " for the startSatelliteTransmissionUpdates result code");
7550             return;
7551         }
7552         assertNotNull(errorCode);
7553         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
7554 
7555         // Send satellite datagram
7556         String mText = "This is a test datagram message from user";
7557         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
7558         callback.clearSendDatagramStateChanges();
7559         sMockSatelliteServiceManager.setShouldRespondTelephony(false);
7560         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
7561         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
7562                 datagram, true, getContext().getMainExecutor(),
7563                 resultListener::offer);
7564 
7565         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
7566 
7567         // Send datagram transfer state should move from IDLE to SENDING.
7568         assertSingleSendDatagramStateChanged(callback,
7569                 SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
7570                 1, SatelliteManager.SATELLITE_RESULT_SUCCESS);
7571 
7572         sMockSatelliteServiceManager.setShouldRespondTelephony(true);
7573         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
7574         callback.clearSendDatagramStateChanges();
7575         sSatelliteManager.stopTransmissionUpdates(callback, getContext().getMainExecutor(),
7576                 resultListener::offer);
7577     }
7578 
sendSatelliteDatagramSuccess( boolean shouldOverridePointingUiClassName, boolean needFullScreenForPointingUi)7579     private void sendSatelliteDatagramSuccess(
7580             boolean shouldOverridePointingUiClassName, boolean needFullScreenForPointingUi) {
7581         SatelliteTransmissionUpdateCallbackTest callback = startTransmissionUpdates();
7582 
7583         // Send satellite datagram
7584         String mText = "This is a test datagram message from user";
7585         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
7586         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
7587         callback.clearSendDatagramStateChanges();
7588         callback.clearSendDatagramRequested();
7589         if (shouldOverridePointingUiClassName) {
7590             assertTrue(sMockSatelliteServiceManager.overrideSatellitePointingUiClassName());
7591         }
7592         sMockSatelliteServiceManager.clearMockPointingUiActivityStatusChanges();
7593         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
7594         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
7595                 datagram, needFullScreenForPointingUi, getContext().getMainExecutor(),
7596                 resultListener::offer);
7597 
7598         Integer errorCode;
7599         try {
7600             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
7601         } catch (InterruptedException ex) {
7602             fail("testSendSatelliteDatagram_success: Got InterruptedException in waiting"
7603                     + " for the sendDatagram result code");
7604             return;
7605         }
7606         assertNotNull(errorCode);
7607         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
7608         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
7609         assertTrue(callback.waitUntilOnSendDatagramRequested(1));
7610         assertEquals(1, callback.getNumOfSendDatagramRequestedChanges());
7611         assertEquals(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
7612                 callback.getSendDatagramRequestedType(0));
7613 
7614         /*
7615          * Send datagram transfer state should have the following transitions:
7616          * 1) IDLE to SENDING
7617          * 2) SENDING to SENDING_SUCCESS
7618          * 3) SENDING_SUCCESS to IDLE
7619          */
7620         int expectedNumOfEvents = 3;
7621         assertTrue(callback.waitUntilOnSendDatagramStateChanged(expectedNumOfEvents));
7622         assertThat(callback.getNumOfSendDatagramStateChanges()).isEqualTo(expectedNumOfEvents);
7623         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
7624                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
7625                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
7626                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
7627         assertThat(callback.getSendDatagramStateChange(1)).isEqualTo(
7628                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
7629                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_SUCCESS,
7630                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
7631         assertThat(callback.getSendDatagramStateChange(2)).isEqualTo(
7632                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
7633                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
7634                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
7635         assertTrue(sMockSatelliteServiceManager.waitForEventMockPointingUiActivityStarted(1));
7636         if (shouldOverridePointingUiClassName) {
7637             assertTrue(sMockSatelliteServiceManager.restoreSatellitePointingUiClassName());
7638         }
7639 
7640         callback.clearSendDatagramStateChanges();
7641         sSatelliteManager.stopTransmissionUpdates(callback, getContext().getMainExecutor(),
7642                 resultListener::offer);
7643     }
7644 
sendSatelliteDatagramDemoModeSuccess(String sampleText)7645     private void sendSatelliteDatagramDemoModeSuccess(String sampleText) {
7646         SatelliteTransmissionUpdateCallbackTest callback = startTransmissionUpdates();
7647 
7648         // Send satellite datagram
7649         SatelliteDatagram datagram = new SatelliteDatagram(sampleText.getBytes());
7650         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
7651         callback.clearSendDatagramStateChanges();
7652         callback.clearSendDatagramRequested();
7653         assertTrue(sMockSatelliteServiceManager.overrideSatellitePointingUiClassName());
7654         sMockSatelliteServiceManager.clearMockPointingUiActivityStatusChanges();
7655         sMockSatelliteServiceManager.clearSentSatelliteDatagramInfo();
7656         sSatelliteManager.setDeviceAlignedWithSatellite(true);
7657         assertTrue(sMockSatelliteServiceManager.setShouldSendDatagramToModemInDemoMode(true));
7658         sSatelliteManager.sendDatagram(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
7659                 datagram, true, getContext().getMainExecutor(),
7660                 resultListener::offer);
7661 
7662         Integer errorCode;
7663         try {
7664             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
7665         } catch (InterruptedException ex) {
7666             fail("testSendSatelliteDatagram_success: Got InterruptedException in waiting"
7667                     + " for the sendDatagram result code");
7668             return;
7669         }
7670         assertNotNull(errorCode);
7671         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
7672         assertTrue(sMockSatelliteServiceManager.waitForEventOnSendSatelliteDatagram(1));
7673         assertTrue(callback.waitUntilOnSendDatagramRequested(1));
7674         assertEquals(1, callback.getNumOfSendDatagramRequestedChanges());
7675         assertEquals(SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
7676                 callback.getSendDatagramRequestedType(0));
7677 
7678         /*
7679          * Send datagram transfer state should have the following transitions:
7680          * 1) IDLE to SENDING
7681          * 2) SENDING to SENDING_SUCCESS
7682          * 3) SENDING_SUCCESS to IDLE
7683          */
7684         int expectedNumOfEvents = 3;
7685         assertTrue(callback.waitUntilOnSendDatagramStateChanged(expectedNumOfEvents));
7686         assertThat(callback.getNumOfSendDatagramStateChanges()).isEqualTo(expectedNumOfEvents);
7687         assertThat(callback.getSendDatagramStateChange(0)).isEqualTo(
7688                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
7689                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SENDING,
7690                         1, SatelliteManager.SATELLITE_RESULT_SUCCESS));
7691         assertThat(callback.getSendDatagramStateChange(1)).isEqualTo(
7692                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
7693                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_SEND_SUCCESS,
7694                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
7695         assertThat(callback.getSendDatagramStateChange(2)).isEqualTo(
7696                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
7697                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
7698                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
7699         assertTrue(sMockSatelliteServiceManager.waitForEventMockPointingUiActivityStarted(1));
7700         assertTrue(sMockSatelliteServiceManager.restoreSatellitePointingUiClassName());
7701 
7702         sSatelliteManager.setDeviceAlignedWithSatellite(false);
7703         callback.clearSendDatagramStateChanges();
7704         sSatelliteManager.stopTransmissionUpdates(callback, getContext().getMainExecutor(),
7705                 resultListener::offer);
7706     }
7707 
moveToReceivingState()7708     private void moveToReceivingState() {
7709         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
7710         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
7711                 new SatelliteTransmissionUpdateCallbackTest();
7712         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
7713                 resultListener::offer, transmissionUpdateCallback);
7714         Integer errorCode;
7715         try {
7716             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
7717         } catch (InterruptedException ex) {
7718             fail("testReceiveSatelliteDatagram: Got InterruptedException in waiting"
7719                     + " for the startSatelliteTransmissionUpdates result code");
7720             return;
7721         }
7722         assertNotNull(errorCode);
7723         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
7724 
7725         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
7726         sMockSatelliteServiceManager.sendOnPendingDatagrams();
7727         assertTrue(sMockSatelliteServiceManager.waitForEventOnPollPendingSatelliteDatagrams(1));
7728 
7729         // Datagram transfer state changes from IDLE to RECEIVING.
7730         assertSingleReceiveDatagramStateChanged(transmissionUpdateCallback,
7731                 SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVING,
7732                 0, SatelliteManager.SATELLITE_RESULT_SUCCESS);
7733 
7734         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
7735         stopTransmissionUpdates(transmissionUpdateCallback);
7736     }
7737 
receiveSatelliteDatagramSuccess()7738     private void receiveSatelliteDatagramSuccess() {
7739         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
7740                 startTransmissionUpdates();
7741 
7742         SatelliteDatagramCallbackTest satelliteDatagramCallback =
7743                 new SatelliteDatagramCallbackTest();
7744         sSatelliteManager.registerForIncomingDatagram(
7745                 getContext().getMainExecutor(), satelliteDatagramCallback);
7746 
7747         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
7748         sMockSatelliteServiceManager.sendOnPendingDatagrams();
7749         assertTrue(sMockSatelliteServiceManager.waitForEventOnPollPendingSatelliteDatagrams(1));
7750 
7751         // Receive one datagram
7752         String receivedText = "This is a test datagram message from satellite";
7753         android.telephony.satellite.stub.SatelliteDatagram receivedDatagram =
7754                 new android.telephony.satellite.stub.SatelliteDatagram();
7755         receivedDatagram.data = receivedText.getBytes();
7756         sMockSatelliteServiceManager.sendOnSatelliteDatagramReceived(receivedDatagram, 0);
7757         assertTrue(satelliteDatagramCallback.waitUntilResult(1));
7758         assertArrayEquals(satelliteDatagramCallback.mDatagram.getSatelliteDatagram(),
7759                 receivedText.getBytes());
7760 
7761         // As pending count is 0, datagram transfer state changes from
7762         // IDLE -> RECEIVING -> RECEIVE_SUCCESS -> IDLE.
7763         int expectedNumOfEvents = 3;
7764         assertTrue(transmissionUpdateCallback
7765                 .waitUntilOnReceiveDatagramStateChanged(expectedNumOfEvents));
7766         assertThat(transmissionUpdateCallback.getNumOfReceiveDatagramStateChanges())
7767                 .isEqualTo(expectedNumOfEvents);
7768         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(0)).isEqualTo(
7769                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
7770                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVING,
7771                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
7772         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(1)).isEqualTo(
7773                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
7774                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_RECEIVE_SUCCESS,
7775                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
7776         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(2)).isEqualTo(
7777                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
7778                         SatelliteManager.SATELLITE_DATAGRAM_TRANSFER_STATE_IDLE,
7779                         0, SatelliteManager.SATELLITE_RESULT_SUCCESS));
7780 
7781         transmissionUpdateCallback.clearReceiveDatagramStateChanges();
7782         stopTransmissionUpdates(transmissionUpdateCallback);
7783         sSatelliteManager.unregisterForIncomingDatagram(satelliteDatagramCallback);
7784     }
7785 
startTransmissionUpdates()7786     private SatelliteTransmissionUpdateCallbackTest startTransmissionUpdates() {
7787         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
7788         SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback =
7789                 new SatelliteTransmissionUpdateCallbackTest();
7790         sSatelliteManager.startTransmissionUpdates(getContext().getMainExecutor(),
7791                 resultListener::offer, transmissionUpdateCallback);
7792         Integer errorCode;
7793         try {
7794             errorCode = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
7795         } catch (InterruptedException ex) {
7796             fail("SatelliteTransmissionUpdateCallbackTest: Got InterruptedException in waiting"
7797                     + " for the startSatelliteTransmissionUpdates result code");
7798             return null;
7799         }
7800         assertNotNull(errorCode);
7801         assertThat(errorCode).isEqualTo(SatelliteManager.SATELLITE_RESULT_SUCCESS);
7802         return transmissionUpdateCallback;
7803     }
7804 
stopTransmissionUpdates( SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback)7805     private void stopTransmissionUpdates(
7806             SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback) {
7807         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
7808         sSatelliteManager.stopTransmissionUpdates(transmissionUpdateCallback,
7809                 getContext().getMainExecutor(), resultListener::offer);
7810     }
7811 
assertSingleSendDatagramStateChanged( SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback, int expectedTransferState, int expectedPendingCount, int expectedErrorCode)7812     private void assertSingleSendDatagramStateChanged(
7813             SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback,
7814             int expectedTransferState, int expectedPendingCount, int expectedErrorCode) {
7815         assertTrue(transmissionUpdateCallback.waitUntilOnSendDatagramStateChanged(1));
7816         assertThat(transmissionUpdateCallback.getNumOfSendDatagramStateChanges()).isEqualTo(1);
7817         assertThat(transmissionUpdateCallback.getSendDatagramStateChange(0)).isEqualTo(
7818                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
7819                         expectedTransferState, expectedPendingCount, expectedErrorCode));
7820     }
7821 
assertSingleReceiveDatagramStateChanged( SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback, int expectedTransferState, int expectedPendingCount, int expectedErrorCode)7822     private void assertSingleReceiveDatagramStateChanged(
7823             SatelliteTransmissionUpdateCallbackTest transmissionUpdateCallback,
7824             int expectedTransferState, int expectedPendingCount, int expectedErrorCode) {
7825         assertTrue(transmissionUpdateCallback
7826                 .waitUntilOnReceiveDatagramStateChanged(1));
7827         assertThat(transmissionUpdateCallback.getNumOfReceiveDatagramStateChanges())
7828                 .isEqualTo(1);
7829         assertThat(transmissionUpdateCallback.getReceiveDatagramStateChange(0)).isEqualTo(
7830                 new SatelliteTransmissionUpdateCallbackTest.DatagramStateChangeArgument(
7831                         expectedTransferState, expectedPendingCount, expectedErrorCode));
7832     }
7833 
identifyRadiosSensitiveToSatelliteMode()7834     private void identifyRadiosSensitiveToSatelliteMode() {
7835         PackageManager packageManager = getContext().getPackageManager();
7836         List<String> satelliteModeRadiosList = new ArrayList<>();
7837         mBTWifiNFCSateReceiver = new BTWifiNFCStateReceiver();
7838         mUwbAdapterStateCallback = new UwbAdapterStateCallback();
7839         IntentFilter radioStateIntentFilter = new IntentFilter();
7840 
7841         if (packageManager.hasSystemFeature(PackageManager.FEATURE_WIFI)) {
7842             satelliteModeRadiosList.add(Settings.Global.RADIO_WIFI);
7843             mWifiManager = getContext().getSystemService(WifiManager.class);
7844             mWifiInitState = mWifiManager.isWifiEnabled();
7845             radioStateIntentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
7846         }
7847 
7848         if (packageManager.hasSystemFeature(PackageManager.FEATURE_BLUETOOTH)) {
7849             satelliteModeRadiosList.add(Settings.Global.RADIO_BLUETOOTH);
7850             mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
7851             mBTInitState = mBluetoothAdapter.isEnabled();
7852             radioStateIntentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
7853         }
7854 
7855         if (packageManager.hasSystemFeature(PackageManager.FEATURE_NFC)) {
7856             satelliteModeRadiosList.add(Settings.Global.RADIO_NFC);
7857             mNfcAdapter = NfcAdapter.getDefaultAdapter(getContext().getApplicationContext());
7858             mNfcInitState = mNfcAdapter.isEnabled();
7859             radioStateIntentFilter.addAction(NfcAdapter.ACTION_ADAPTER_STATE_CHANGED);
7860         }
7861         getContext().registerReceiver(mBTWifiNFCSateReceiver, radioStateIntentFilter);
7862 
7863         if (packageManager.hasSystemFeature(PackageManager.FEATURE_UWB)) {
7864             satelliteModeRadiosList.add(Settings.Global.RADIO_UWB);
7865             mUwbManager = getContext().getSystemService(UwbManager.class);
7866             mUwbInitState = mUwbManager.isUwbEnabled();
7867             mUwbManager.registerAdapterStateCallback(getContext().getMainExecutor(),
7868                     mUwbAdapterStateCallback);
7869         }
7870 
7871         mTestSatelliteModeRadios = String.join(",", satelliteModeRadiosList);
7872     }
7873 
isRadioSatelliteModeSensitive(String radio)7874     private boolean isRadioSatelliteModeSensitive(String radio) {
7875         return mTestSatelliteModeRadios.contains(radio);
7876     }
7877 
areAllRadiosDisabled()7878     private boolean areAllRadiosDisabled() {
7879         logd("areAllRadiosDisabled");
7880         if (isRadioSatelliteModeSensitive(Settings.Global.RADIO_WIFI)) {
7881             assertFalse(mWifiManager.isWifiEnabled());
7882         }
7883 
7884         if (isRadioSatelliteModeSensitive(Settings.Global.RADIO_UWB)) {
7885             assertFalse(mUwbManager.isUwbEnabled());
7886         }
7887 
7888         if (isRadioSatelliteModeSensitive(Settings.Global.RADIO_NFC)) {
7889             assertFalse(mNfcAdapter.isEnabled());
7890         }
7891 
7892         if (isRadioSatelliteModeSensitive(Settings.Global.RADIO_BLUETOOTH)) {
7893             assertFalse(mBluetoothAdapter.isEnabled());
7894         }
7895 
7896         return true;
7897     }
7898 
areAllRadiosResetToInitialState()7899     private boolean areAllRadiosResetToInitialState() {
7900         logd("areAllRadiosResetToInitialState");
7901 
7902         if (mBTWifiNFCSateReceiver != null
7903                 && isRadioSatelliteModeSensitive(Settings.Global.RADIO_WIFI)) {
7904             assertTrue(mBTWifiNFCSateReceiver.waitUntilOnWifiStateChanged());
7905         }
7906 
7907         if (mBTWifiNFCSateReceiver != null
7908                 && isRadioSatelliteModeSensitive(Settings.Global.RADIO_NFC)) {
7909             assertTrue(mBTWifiNFCSateReceiver.waitUntilOnNfcStateChanged());
7910         }
7911 
7912         if (mUwbAdapterStateCallback != null
7913                 && isRadioSatelliteModeSensitive(Settings.Global.RADIO_UWB)) {
7914             assertTrue(mUwbAdapterStateCallback.waitUntilOnUwbStateChanged());
7915         }
7916 
7917         if (mBTWifiNFCSateReceiver != null
7918                 && isRadioSatelliteModeSensitive(Settings.Global.RADIO_BLUETOOTH)) {
7919             assertTrue(mBTWifiNFCSateReceiver.waitUntilOnBTStateChanged());
7920         }
7921 
7922         return true;
7923     }
7924 
setRadioExpectedState()7925     private void setRadioExpectedState() {
7926         // Set expected state of all radios to their initial states
7927         if (mBTWifiNFCSateReceiver != null) {
7928             mBTWifiNFCSateReceiver.setBTExpectedState(mBTInitState);
7929             mBTWifiNFCSateReceiver.setWifiExpectedState(mWifiInitState);
7930             mBTWifiNFCSateReceiver.setNfcExpectedState(mNfcInitState);
7931         }
7932 
7933         if (mUwbAdapterStateCallback != null) {
7934             mUwbAdapterStateCallback.setUwbExpectedState(mUwbInitState);
7935         }
7936     }
7937 
unregisterSatelliteModeRadios()7938     private void unregisterSatelliteModeRadios() {
7939         getContext().unregisterReceiver(mBTWifiNFCSateReceiver);
7940 
7941         if (isRadioSatelliteModeSensitive(Settings.Global.RADIO_UWB)) {
7942             mUwbManager.unregisterAdapterStateCallback(mUwbAdapterStateCallback);
7943         }
7944     }
7945 
requestSatelliteAttachEnabledForCarrier(boolean isEnable, int expectedResult)7946     private void requestSatelliteAttachEnabledForCarrier(boolean isEnable,
7947             int expectedResult) {
7948         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
7949         sSatelliteManager.requestAttachEnabledForCarrier(sTestSubIDForCarrierSatellite,
7950                 isEnable, getContext().getMainExecutor(), resultListener::offer);
7951         Integer result;
7952         try {
7953             result = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
7954         } catch (InterruptedException ex) {
7955             fail("requestAttachEnabledForCarrier failed with ex=" + ex);
7956             return;
7957         }
7958         assertNotNull(result);
7959         assertEquals(expectedResult, (int) result);
7960     }
7961 
requestAddSatelliteAttachRestrictionForCarrier(int reason, int expectedResult)7962     private void requestAddSatelliteAttachRestrictionForCarrier(int reason, int expectedResult) {
7963         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
7964         sSatelliteManager.addAttachRestrictionForCarrier(sTestSubIDForCarrierSatellite,
7965                 reason, getContext().getMainExecutor(), resultListener::offer);
7966         Integer result;
7967         try {
7968             result = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
7969         } catch (InterruptedException ex) {
7970             fail("requestAddSatelliteAttachRestrictionForCarrier failed with ex=" + ex);
7971             return;
7972         }
7973         assertNotNull(result);
7974         assertEquals(expectedResult, (int) result);
7975     }
7976 
verifySatelliteAttachRestrictionForCarrier(int reason, boolean isReasonExpected)7977     private void verifySatelliteAttachRestrictionForCarrier(int reason, boolean isReasonExpected) {
7978         Set<Integer> restrictionReasons = sSatelliteManager
7979                 .getAttachRestrictionReasonsForCarrier(sTestSubIDForCarrierSatellite);
7980         assertNotNull(restrictionReasons);
7981         if (isReasonExpected) {
7982             assertTrue(restrictionReasons.contains(reason));
7983         } else {
7984             assertFalse(restrictionReasons.contains(reason));
7985         }
7986     }
7987 
requestRemoveSatelliteAttachRestrictionForCarrier(int reason, int expectedResult)7988     private void requestRemoveSatelliteAttachRestrictionForCarrier(int reason, int expectedResult) {
7989         LinkedBlockingQueue<Integer> resultListener = new LinkedBlockingQueue<>(1);
7990         sSatelliteManager.removeAttachRestrictionForCarrier(sTestSubIDForCarrierSatellite,
7991                 reason, getContext().getMainExecutor(), resultListener::offer);
7992         Integer result;
7993         try {
7994             result = resultListener.poll(TIMEOUT, TimeUnit.MILLISECONDS);
7995         } catch (InterruptedException ex) {
7996             fail("requestRemoveSatelliteAttachRestrictionForCarrier failed with ex=" + ex);
7997             return;
7998         }
7999         assertNotNull(result);
8000         assertEquals(expectedResult, (int) result);
8001     }
8002 
requestIsSatelliteAttachEnabledForCarrier()8003     private Pair<Boolean, Integer> requestIsSatelliteAttachEnabledForCarrier() {
8004         final AtomicReference<Boolean> enabled = new AtomicReference<>();
8005         final AtomicReference<Integer> callback = new AtomicReference<>();
8006         CountDownLatch latch = new CountDownLatch(1);
8007         OutcomeReceiver<Boolean, SatelliteManager.SatelliteException> receiver =
8008                 new OutcomeReceiver<>() {
8009                     @Override
8010                     public void onResult(Boolean result) {
8011                         logd("onResult: result=" + result);
8012                         enabled.set(result);
8013                         latch.countDown();
8014                     }
8015 
8016                     @Override
8017                     public void onError(SatelliteManager.SatelliteException exception) {
8018                         logd("onError: onError=" + exception);
8019                         callback.set(exception.getErrorCode());
8020                         latch.countDown();
8021                     }
8022                 };
8023 
8024         sSatelliteManager.requestIsAttachEnabledForCarrier(sTestSubIDForCarrierSatellite,
8025                 getContext().getMainExecutor(), receiver);
8026         try {
8027             assertTrue(latch.await(TIMEOUT, TimeUnit.MILLISECONDS));
8028         } catch (InterruptedException e) {
8029             fail(e.toString());
8030         }
8031         return new Pair<>(enabled.get(), callback.get());
8032     }
8033 
requestNtnSignalStrength()8034     private Pair<NtnSignalStrength, Integer> requestNtnSignalStrength() {
8035         final AtomicReference<NtnSignalStrength> ntnSignalStrength = new AtomicReference<>();
8036         final AtomicReference<Integer> callback = new AtomicReference<>();
8037         CountDownLatch latch = new CountDownLatch(1);
8038         OutcomeReceiver<NtnSignalStrength, SatelliteManager.SatelliteException> receiver =
8039                 new OutcomeReceiver<>() {
8040                     @Override
8041                     public void onResult(NtnSignalStrength result) {
8042                         logd("onResult: result=" + result);
8043                         ntnSignalStrength.set(result);
8044                         latch.countDown();
8045                     }
8046 
8047                     @Override
8048                     public void onError(SatelliteManager.SatelliteException exception) {
8049                         logd("onError: onError=" + exception);
8050                         callback.set(exception.getErrorCode());
8051                         latch.countDown();
8052                     }
8053                 };
8054 
8055         sSatelliteManager.requestNtnSignalStrength(getContext().getMainExecutor(), receiver);
8056         try {
8057             assertTrue(latch.await(TIMEOUT, TimeUnit.MILLISECONDS));
8058         } catch (InterruptedException e) {
8059             fail(e.toString());
8060         }
8061         return new Pair<>(ntnSignalStrength.get(), callback.get());
8062     }
8063 
requestSatelliteCapabilities()8064     private Pair<SatelliteCapabilities, Integer> requestSatelliteCapabilities() {
8065         final AtomicReference<SatelliteCapabilities> SatelliteCapabilities =
8066                 new AtomicReference<>();
8067         final AtomicReference<Integer> callback = new AtomicReference<>();
8068         CountDownLatch latch = new CountDownLatch(1);
8069         OutcomeReceiver<SatelliteCapabilities, SatelliteManager.SatelliteException> receiver =
8070                 new OutcomeReceiver<>() {
8071                     @Override
8072                     public void onResult(SatelliteCapabilities result) {
8073                         logd("onResult: result=" + result);
8074                         SatelliteCapabilities.set(result);
8075                         latch.countDown();
8076                     }
8077 
8078                     @Override
8079                     public void onError(SatelliteManager.SatelliteException exception) {
8080                         logd("onError: onError=" + exception);
8081                         callback.set(exception.getErrorCode());
8082                         latch.countDown();
8083                     }
8084                 };
8085 
8086         sSatelliteManager.requestCapabilities(getContext().getMainExecutor(), receiver);
8087         try {
8088             assertTrue(latch.await(TIMEOUT, TimeUnit.MILLISECONDS));
8089         } catch (InterruptedException e) {
8090             fail(e.toString());
8091         }
8092         return new Pair<>(SatelliteCapabilities.get(), callback.get());
8093     }
8094 
requestSessionStats()8095     private Pair<SatelliteSessionStats, Integer> requestSessionStats() {
8096         AtomicReference<SatelliteSessionStats> sessionStats = new AtomicReference<>();
8097         AtomicReference<Integer> callback = new AtomicReference<>();
8098         CountDownLatch latch = new CountDownLatch(1);
8099         OutcomeReceiver<SatelliteSessionStats, SatelliteManager.SatelliteException> receiver =
8100                 new OutcomeReceiver<SatelliteSessionStats, SatelliteManager.SatelliteException>() {
8101                     @Override
8102                     public void onResult(SatelliteSessionStats result) {
8103                         logd("requestSessionStats onResult:" + result);
8104                         sessionStats.set(result);
8105                         latch.countDown();
8106                     }
8107 
8108                     @Override
8109                     public void onError(SatelliteManager.SatelliteException exception) {
8110                         logd("requestSessionStats onError:" + exception);
8111                         callback.set(exception.getErrorCode());
8112                         latch.countDown();
8113                     }
8114 
8115                 };
8116 
8117         InstrumentationRegistry.getInstrumentation().getUiAutomation()
8118                 .adoptShellPermissionIdentity(Manifest.permission.MODIFY_PHONE_STATE,
8119                         Manifest.permission.PACKAGE_USAGE_STATS);
8120         try {
8121             sSatelliteManager.requestSessionStats(getContext().getMainExecutor(), receiver);
8122             assertTrue(latch.await(TIMEOUT, TimeUnit.MILLISECONDS));
8123         } catch (InterruptedException e) {
8124             fail(e.toString());
8125         } finally {
8126             InstrumentationRegistry.getInstrumentation().getUiAutomation()
8127                     .dropShellPermissionIdentity();
8128             grantSatellitePermission();
8129         }
8130 
8131         return new Pair<>(sessionStats.get(), callback.get());
8132     }
8133 
requestIsSatelliteSupported()8134     private Pair<Boolean, Integer> requestIsSatelliteSupported() {
8135         final AtomicReference<Boolean> supported = new AtomicReference<>();
8136         final AtomicReference<Integer> callback = new AtomicReference<>();
8137         CountDownLatch latch = new CountDownLatch(1);
8138         OutcomeReceiver<Boolean, SatelliteManager.SatelliteException> receiver =
8139                 new OutcomeReceiver<>() {
8140                     @Override
8141                     public void onResult(Boolean result) {
8142                         logd("requestIsSatelliteSupported.onResult: result=" + result);
8143                         supported.set(result);
8144                         latch.countDown();
8145                     }
8146 
8147                     @Override
8148                     public void onError(SatelliteManager.SatelliteException exception) {
8149                         logd("requestIsSatelliteSupported.onError: onError="
8150                                 + exception.getErrorCode());
8151                         callback.set(exception.getErrorCode());
8152                         latch.countDown();
8153                     }
8154                 };
8155 
8156         sSatelliteManager.requestIsSupported(getContext().getMainExecutor(), receiver);
8157         try {
8158             assertTrue(latch.await(TIMEOUT, TimeUnit.MILLISECONDS));
8159         } catch (InterruptedException e) {
8160             fail(e.toString());
8161         }
8162         return new Pair<>(supported.get(), callback.get());
8163     }
8164 
8165     private Pair<SatelliteAccessConfiguration,
requestSatelliteAccessConfigurationForCurrentLocation()8166             Integer> requestSatelliteAccessConfigurationForCurrentLocation() {
8167         final AtomicReference<SatelliteAccessConfiguration> satelliteAccessConfiguration =
8168                 new AtomicReference<>();
8169         final AtomicReference<Integer> callback = new AtomicReference<>();
8170         CountDownLatch latch = new CountDownLatch(1);
8171         OutcomeReceiver<SatelliteAccessConfiguration, SatelliteManager.SatelliteException>
8172                 receiver =
8173                 new OutcomeReceiver<>() {
8174                     @Override
8175                     public void onResult(SatelliteAccessConfiguration result) {
8176                         logd("requestSatelliteAccessConfigurationForCurrentLocation: result="
8177                                 + result);
8178                         satelliteAccessConfiguration.set(result);
8179                         latch.countDown();
8180                     }
8181 
8182                     @Override
8183                     public void onError(SatelliteManager.SatelliteException exception) {
8184                         logd("requestSatelliteAccessConfigurationForCurrentLocation: onError="
8185                                 + exception.getErrorCode());
8186                         callback.set(exception.getErrorCode());
8187                         latch.countDown();
8188                     }
8189                 };
8190 
8191         sSatelliteManager.requestSatelliteAccessConfigurationForCurrentLocation(
8192                 getContext().getMainExecutor(), receiver);
8193         try {
8194             assertTrue(latch.await(TIMEOUT, TimeUnit.MILLISECONDS));
8195         } catch (InterruptedException e) {
8196             fail(e.toString());
8197         }
8198         return new Pair<>(satelliteAccessConfiguration.get(), callback.get());
8199     }
8200 
8201     private abstract static class BaseReceiver extends BroadcastReceiver {
8202         protected CountDownLatch mLatch = new CountDownLatch(1);
8203 
clearQueue()8204         void clearQueue() {
8205             mLatch = new CountDownLatch(1);
8206         }
8207 
waitForChanged()8208         void waitForChanged() throws Exception {
8209             mLatch.await(5000, TimeUnit.MILLISECONDS);
8210         }
8211     }
8212 
8213     private static class CarrierConfigReceiver extends BaseReceiver {
8214         private final int mSubId;
8215 
CarrierConfigReceiver(int subId)8216         CarrierConfigReceiver(int subId) {
8217             mSubId = subId;
8218         }
8219 
8220         @Override
onReceive(Context context, Intent intent)8221         public void onReceive(Context context, Intent intent) {
8222             if (CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED.equals(intent.getAction())) {
8223                 int subId = intent.getIntExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX, -1);
8224                 if (mSubId == subId) {
8225                     mLatch.countDown();
8226                 }
8227             }
8228         }
8229     }
8230 
overrideCarrierConfig(int subId, PersistableBundle bundle)8231     private static void overrideCarrierConfig(int subId, PersistableBundle bundle) {
8232         logd("overrideCarrierConfig: subId=" + subId + ", bundle=" + bundle);
8233         try {
8234             CarrierConfigManager carrierConfigManager = InstrumentationRegistry.getInstrumentation()
8235                     .getContext().getSystemService(CarrierConfigManager.class);
8236             sCarrierConfigReceiver.clearQueue();
8237             ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(carrierConfigManager,
8238                     (m) -> m.overrideConfig(subId, bundle));
8239             sCarrierConfigReceiver.waitForChanged();
8240         } catch (Exception ex) {
8241             loge("overrideCarrierConfig(), ex=" + ex);
8242         } finally {
8243             grantSatellitePermission();
8244         }
8245     }
8246 
setSatelliteError(@atelliteManager.SatelliteResult int error)8247     private void setSatelliteError(@SatelliteManager.SatelliteResult int error) {
8248         @RadioError int satelliteError;
8249 
8250         switch (error) {
8251             case SatelliteManager.SATELLITE_RESULT_SUCCESS:
8252                 satelliteError = SatelliteResult.SATELLITE_RESULT_SUCCESS;
8253                 break;
8254             case SatelliteManager.SATELLITE_RESULT_INVALID_MODEM_STATE:
8255                 satelliteError = SatelliteResult.SATELLITE_RESULT_INVALID_MODEM_STATE;
8256                 break;
8257             case SATELLITE_RESULT_MODEM_ERROR:
8258                 satelliteError = SatelliteResult.SATELLITE_RESULT_MODEM_ERROR;
8259                 break;
8260             case SatelliteManager.SATELLITE_RESULT_RADIO_NOT_AVAILABLE:
8261                 satelliteError = SatelliteResult.SATELLITE_RESULT_RADIO_NOT_AVAILABLE;
8262                 break;
8263             case SATELLITE_RESULT_REQUEST_NOT_SUPPORTED:
8264             default:
8265                 satelliteError = SatelliteResult.SATELLITE_RESULT_REQUEST_NOT_SUPPORTED;
8266                 break;
8267         }
8268 
8269         sMockSatelliteServiceManager.setErrorCode(satelliteError);
8270     }
8271 
setSatelliteErrorBasedOnHalVersion(@atelliteResult int error)8272     private void setSatelliteErrorBasedOnHalVersion(@SatelliteResult int error) {
8273         if (getHalVersion(TelephonyManager.HAL_SERVICE_NETWORK) < RADIO_HAL_VERSION_2_3) {
8274             setSatelliteError(error);
8275             return;
8276         }
8277 
8278         @RadioError int satelliteError;
8279         switch (error) {
8280             case SatelliteManager.SATELLITE_RESULT_SUCCESS:
8281                 satelliteError = RadioError.NONE;
8282                 break;
8283             case SatelliteManager.SATELLITE_RESULT_INVALID_MODEM_STATE:
8284                 satelliteError = RadioError.INVALID_MODEM_STATE;
8285                 break;
8286             case SATELLITE_RESULT_MODEM_ERROR:
8287                 satelliteError = RadioError.MODEM_ERR;
8288                 break;
8289             case SatelliteManager.SATELLITE_RESULT_RADIO_NOT_AVAILABLE:
8290                 satelliteError = RadioError.RADIO_NOT_AVAILABLE;
8291                 break;
8292             case SATELLITE_RESULT_REQUEST_NOT_SUPPORTED:
8293                 satelliteError = RadioError.REQUEST_NOT_SUPPORTED;
8294                 break;
8295             default:
8296                 satelliteError = RadioError.GENERIC_FAILURE;
8297                 break;
8298         }
8299 
8300         if (sMockModemManager != null) {
8301             sMockModemManager.setSatelliteErrorCode(SLOT_ID_0, satelliteError);
8302         }
8303     }
8304 
setNtnSignalStrength( @tnSignalStrength.NtnSignalStrengthLevel int ntnSignalStrengthLevel)8305     private void setNtnSignalStrength(
8306             @NtnSignalStrength.NtnSignalStrengthLevel int ntnSignalStrengthLevel) {
8307         sMockSatelliteServiceManager.setNtnSignalStrength(toHAL(ntnSignalStrengthLevel));
8308     }
8309 
sendOnNtnSignalStrengthChanged( @tnSignalStrength.NtnSignalStrengthLevel int ntnSignalStrengthLevel)8310     private void sendOnNtnSignalStrengthChanged(
8311             @NtnSignalStrength.NtnSignalStrengthLevel int ntnSignalStrengthLevel) {
8312         sMockSatelliteServiceManager.sendOnNtnSignalStrengthChanged(toHAL(ntnSignalStrengthLevel));
8313     }
8314 
sendOnSatelliteCapabilitiesChanged( android.telephony.satellite.stub.SatelliteCapabilities satelliteCapabilities)8315     private void sendOnSatelliteCapabilitiesChanged(
8316             android.telephony.satellite.stub.SatelliteCapabilities satelliteCapabilities) {
8317         sMockSatelliteServiceManager.sendOnSatelliteCapabilitiesChanged(satelliteCapabilities);
8318     }
8319 
sendOnSatelliteSupportedStateChanged(boolean supported)8320     private void sendOnSatelliteSupportedStateChanged(boolean supported) {
8321         sMockSatelliteServiceManager.sendOnSatelliteSupportedStateChanged(supported);
8322     }
8323 
8324     @Nullable
toHAL( @tnSignalStrength.NtnSignalStrengthLevel int signalStrengthLevelFromFramework)8325     private android.telephony.satellite.stub.NtnSignalStrength toHAL(
8326             @NtnSignalStrength.NtnSignalStrengthLevel int signalStrengthLevelFromFramework) {
8327         android.telephony.satellite.stub.NtnSignalStrength ntnSignalStrength =
8328                 new android.telephony.satellite.stub.NtnSignalStrength();
8329 
8330         switch (signalStrengthLevelFromFramework) {
8331             case NtnSignalStrength.NTN_SIGNAL_STRENGTH_NONE:
8332                 ntnSignalStrength.signalStrengthLevel = android.telephony.satellite.stub
8333                         .NtnSignalStrengthLevel.NTN_SIGNAL_STRENGTH_NONE;
8334                 break;
8335             case NtnSignalStrength.NTN_SIGNAL_STRENGTH_POOR:
8336                 ntnSignalStrength.signalStrengthLevel = android.telephony.satellite.stub
8337                         .NtnSignalStrengthLevel.NTN_SIGNAL_STRENGTH_POOR;
8338                 break;
8339             case NtnSignalStrength.NTN_SIGNAL_STRENGTH_MODERATE:
8340                 ntnSignalStrength.signalStrengthLevel = android.telephony.satellite.stub
8341                         .NtnSignalStrengthLevel.NTN_SIGNAL_STRENGTH_MODERATE;
8342                 break;
8343             case NtnSignalStrength.NTN_SIGNAL_STRENGTH_GOOD:
8344                 ntnSignalStrength.signalStrengthLevel = android.telephony.satellite.stub
8345                         .NtnSignalStrengthLevel.NTN_SIGNAL_STRENGTH_GOOD;
8346                 break;
8347             case NtnSignalStrength.NTN_SIGNAL_STRENGTH_GREAT:
8348                 ntnSignalStrength.signalStrengthLevel = android.telephony.satellite.stub
8349                         .NtnSignalStrengthLevel.NTN_SIGNAL_STRENGTH_GREAT;
8350                 break;
8351             default:
8352                 ntnSignalStrength.signalStrengthLevel = android.telephony.satellite.stub
8353                         .NtnSignalStrengthLevel.NTN_SIGNAL_STRENGTH_NONE;
8354                 break;
8355         }
8356         return ntnSignalStrength;
8357     }
8358 
getIsSatelliteEnabledForCarrierFromMockService()8359     private boolean getIsSatelliteEnabledForCarrierFromMockService() {
8360         if (getHalVersion(TelephonyManager.HAL_SERVICE_NETWORK) < RADIO_HAL_VERSION_2_3) {
8361             Boolean receivedResult = sMockSatelliteServiceManager.getIsSatelliteEnabledForCarrier();
8362             return receivedResult != null ? receivedResult : false;
8363         }
8364 
8365         return sMockModemManager.getIsSatelliteEnabledForCarrier(SLOT_ID_0);
8366     }
8367 
getIsEmergency()8368     private boolean getIsEmergency() {
8369         Boolean receivedResult = sMockSatelliteServiceManager.getIsEmergency();
8370         return receivedResult != null ? receivedResult : false;
8371     }
8372 
clearSatelliteEnabledForCarrier()8373     private void clearSatelliteEnabledForCarrier() {
8374         if (getHalVersion(TelephonyManager.HAL_SERVICE_NETWORK) < RADIO_HAL_VERSION_2_3) {
8375             sMockSatelliteServiceManager.clearSatelliteEnabledForCarrier();
8376             return;
8377         }
8378         sMockModemManager.clearSatelliteEnabledForCarrier(SLOT_ID_0);
8379     }
8380 
8381 
8382     static int sTestSubIDForCarrierSatellite;
8383     static int sNtnOnlySubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
8384     static int sEsosSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
8385     static SubscriptionManager sSubscriptionManager;
8386     static boolean sPreviousSatelliteAttachEnabled;
8387     static boolean sOriginalNtnOnlyState;
8388     static boolean sPreviousESOSSupported;
8389     static boolean sPreviousESOSSupportedOfNtnOnlySub;
8390     static String[] sPreviousSupportedMsgApps;
8391 
8392     static final int SLOT_ID_0 = 0;
8393     static final int SLOT_ID_1 = 1;
8394     static MockModemManager sMockModemManager;
8395 
beforeSatelliteForCarrierTest()8396     private void beforeSatelliteForCarrierTest() {
8397         try {
8398             MockModemManager.enforceMockModemDeveloperSetting();
8399             sMockModemManager = new MockModemManager();
8400             assertNotNull(sMockModemManager);
8401             assertTrue(sMockModemManager.connectMockModemService());
8402 
8403             assertTrue(sMockModemManager.insertSimCard(SLOT_ID_0, MOCK_SIM_PROFILE_ID_TWN_CHT));
8404             TimeUnit.MILLISECONDS.sleep(TIMEOUT);
8405             sMockModemManager.changeNetworkService(SLOT_ID_0, MOCK_SIM_PROFILE_ID_TWN_CHT, true);
8406         } catch (Exception e) {
8407             loge("beforeSatelliteForCarrierTest: exception=" + e);
8408         }
8409 
8410         sTestSubIDForCarrierSatellite = getActiveSubIDForCarrierSatelliteTest();
8411         sSubscriptionManager = InstrumentationRegistry.getInstrumentation()
8412                 .getContext().getSystemService(SubscriptionManager.class);
8413         // Get the default subscription values for COLUMN_SATELLITE_ATTACH_ENABLED_FOR_CARRIER.
8414         sPreviousSatelliteAttachEnabled =
8415                 sSubscriptionManager.getBooleanSubscriptionProperty(sTestSubIDForCarrierSatellite,
8416                         SubscriptionManager.SATELLITE_ATTACH_ENABLED_FOR_CARRIER,
8417                         false,
8418                         getContext());
8419         UiAutomation ui = InstrumentationRegistry.getInstrumentation().getUiAutomation();
8420         try {
8421             ui.adoptShellPermissionIdentity();
8422             // Set user Setting as false
8423             sSubscriptionManager.setSubscriptionProperty(sTestSubIDForCarrierSatellite,
8424                     SubscriptionManager.SATELLITE_ATTACH_ENABLED_FOR_CARRIER, String.valueOf(0));
8425         } finally {
8426             ui.dropShellPermissionIdentity();
8427         }
8428     }
8429 
enableNtnOnlySubscription()8430     private static void enableNtnOnlySubscription() {
8431         assumeTrue(sNtnOnlySubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID);
8432         sSubscriptionManager = InstrumentationRegistry.getInstrumentation()
8433                 .getContext().getSystemService(SubscriptionManager.class);
8434         sOriginalNtnOnlyState =
8435                 sSubscriptionManager.getBooleanSubscriptionProperty(sNtnOnlySubId,
8436                         SubscriptionManager.IS_ONLY_NTN,
8437                         false,
8438                         getContext());
8439         logd("enableNtnOnlySubscription: sOriginalNtnOnlyState="
8440                         + sOriginalNtnOnlyState
8441                         + ", sNtnOnlySubId="
8442                         + sNtnOnlySubId);
8443         if (sOriginalNtnOnlyState) {
8444             logd("enableNtnOnlySubscription: subId=" + sNtnOnlySubId + " is already NTN only");
8445             return;
8446         }
8447 
8448         UiAutomation ui = InstrumentationRegistry.getInstrumentation().getUiAutomation();
8449         try {
8450             ui.adoptShellPermissionIdentity();
8451             sSubscriptionManager.setSubscriptionProperty(sNtnOnlySubId,
8452                     SubscriptionManager.IS_ONLY_NTN, String.valueOf(1));
8453         } finally {
8454             ui.dropShellPermissionIdentity();
8455         }
8456         waitForNtnOnlySubscriptionAvailable();
8457     }
8458 
afterSatelliteForCarrierTest()8459     private void afterSatelliteForCarrierTest() {
8460         // Set user Setting value to previous one.
8461         UiAutomation ui = InstrumentationRegistry.getInstrumentation().getUiAutomation();
8462         try {
8463             ui.adoptShellPermissionIdentity();
8464             sSubscriptionManager.setSubscriptionProperty(sTestSubIDForCarrierSatellite,
8465                     SubscriptionManager.SATELLITE_ATTACH_ENABLED_FOR_CARRIER,
8466                     sPreviousSatelliteAttachEnabled ? "1" : "0");
8467 
8468             // Leave service
8469             sMockModemManager.changeNetworkService(SLOT_ID_0, MOCK_SIM_PROFILE_ID_TWN_CHT, false);
8470             // Remove the SIM
8471             sMockModemManager.removeSimCard(SLOT_ID_0);
8472             if (sMockModemManager != null) {
8473                 assertTrue(sMockModemManager.disconnectMockModemService());
8474                 sMockModemManager = null;
8475             }
8476         } catch (Exception e) {
8477             loge("afterSatelliteForCarrierTest: exception=" + e);
8478         } finally {
8479             ui.dropShellPermissionIdentity();
8480             sTestSubIDForCarrierSatellite = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
8481         }
8482     }
8483 
restoreNtnOnlySubscription()8484     private static void restoreNtnOnlySubscription() {
8485         logd("restoreNtnOnlySubscription: sOriginalNtnOnlyState="
8486                         + sOriginalNtnOnlyState
8487                         + ", sNtnOnlySubId="
8488                         + sNtnOnlySubId);
8489         if (sNtnOnlySubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
8490             logd("restoreNtnOnlySubscription: no need to restore");
8491             return;
8492         }
8493 
8494         UiAutomation ui = InstrumentationRegistry.getInstrumentation().getUiAutomation();
8495         try {
8496             ui.adoptShellPermissionIdentity();
8497             sSubscriptionManager.setSubscriptionProperty(sNtnOnlySubId,
8498                     SubscriptionManager.IS_ONLY_NTN,
8499                     sOriginalNtnOnlyState ? "1" : "0");
8500         } finally {
8501             ui.dropShellPermissionIdentity();
8502         }
8503     }
8504 
updateSupportedRadioTechnologies( @onNull int[] supportedRadioTechnologies, boolean needSetUp)8505     private void updateSupportedRadioTechnologies(
8506             @NonNull int[] supportedRadioTechnologies, boolean needSetUp) {
8507         logd("updateSupportedRadioTechnologies: supportedRadioTechnologies="
8508                 + supportedRadioTechnologies[0]);
8509         grantSatellitePermission();
8510 
8511         SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
8512         long registerResult = sSatelliteManager.registerForModemStateChanged(
8513                 getContext().getMainExecutor(), callback);
8514         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
8515         assertTrue(callback.waitUntilResult(1));
8516 
8517         assertTrue(sMockSatelliteServiceManager.restoreSatelliteServicePackageName());
8518         waitFor(2000);
8519         sSatelliteManager.unregisterForModemStateChanged(callback);
8520         sMockSatelliteServiceManager.setSupportedRadioTechnologies(supportedRadioTechnologies);
8521         try {
8522             setupMockSatelliteService();
8523             if (needSetUp) {
8524                 setUp();
8525             }
8526         } catch (Exception e) {
8527             loge("Fail to set up mock satellite service after updating supported radio "
8528                     + "technologies, e=" + e);
8529         }
8530 
8531         revokeSatellitePermission();
8532     }
8533 
requestIsCommunicationAllowedForCurrentLocation()8534     private Pair<Boolean, Integer> requestIsCommunicationAllowedForCurrentLocation() {
8535         final AtomicReference<Boolean> enabled = new AtomicReference<>();
8536         final AtomicReference<Integer> callback = new AtomicReference<>();
8537         CountDownLatch latch = new CountDownLatch(1);
8538         OutcomeReceiver<Boolean, SatelliteManager.SatelliteException> receiver =
8539                 new OutcomeReceiver<>() {
8540                     @Override
8541                     public void onResult(Boolean result) {
8542                         logd("isSatelliteAllowed.onResult: result=" + result);
8543                         enabled.set(result);
8544                         latch.countDown();
8545                     }
8546 
8547                     @Override
8548                     public void onError(SatelliteManager.SatelliteException exception) {
8549                         logd("isSatelliteAllowed.onError: onError=" + exception);
8550                         callback.set(exception.getErrorCode());
8551                         latch.countDown();
8552                     }
8553                 };
8554 
8555         sSatelliteManager.requestIsCommunicationAllowedForCurrentLocation(
8556                 getContext().getMainExecutor(), receiver);
8557         try {
8558             assertTrue(latch.await(TIMEOUT, TimeUnit.MILLISECONDS));
8559         } catch (InterruptedException e) {
8560             fail("isSatelliteAllowed: ex=" + e);
8561         }
8562         return new Pair<>(enabled.get(), callback.get());
8563     }
8564 
verifyIsSatelliteAllowed(boolean allowed)8565     private void verifyIsSatelliteAllowed(boolean allowed) {
8566         grantSatellitePermission();
8567         logd("verifyIsSatelliteAllowed: calling requestIsCommunicationAllowedForCurrentLocation");
8568         Pair<Boolean, Integer> result =
8569                 requestIsCommunicationAllowedForCurrentLocation();
8570         logd(
8571                 "verifyIsSatelliteAllowed: result of"
8572                         + " requestIsCommunicationAllowedForCurrentLocation: "
8573                         + result.first
8574                         + ", "
8575                         + result.second);
8576         assertNotNull(result.first);
8577         assertEquals(allowed, result.first);
8578     }
8579 
verifySatelliteNotAllowedErrorReason(int expectedError)8580     private void verifySatelliteNotAllowedErrorReason(int expectedError) {
8581         grantSatellitePermission();
8582         logd(
8583                 "verifySatelliteNotAllowedErrorReason: calling"
8584                         + " requestIsCommunicationAllowedForCurrentLocation");
8585         Pair<Boolean, Integer> result =
8586                 requestIsCommunicationAllowedForCurrentLocation();
8587         logd(
8588                 "verifySatelliteNotAllowedErrorReason: result of"
8589                         + " requestIsCommunicationAllowedForCurrentLocation: "
8590                         + result.first
8591                         + ", "
8592                         + result.second);
8593         assertNotNull(result.second);
8594         assertEquals(expectedError, (int) result.second);
8595     }
8596 
registerTestLocationProvider()8597     private static void registerTestLocationProvider() {
8598         requestMockLocationPermission(true);
8599         sLocationManager.setLocationEnabledForUser(true, Process.myUserHandle());
8600         sLocationManager.addTestProvider(TEST_PROVIDER,
8601                 new ProviderProperties.Builder().build());
8602         sLocationManager.setTestProviderEnabled(TEST_PROVIDER, true);
8603     }
8604 
unregisterTestLocationProvider()8605     private static void unregisterTestLocationProvider() {
8606         requestMockLocationPermission(true);
8607         sLocationManager.removeTestProvider(TEST_PROVIDER);
8608         requestMockLocationPermission(false);
8609     }
8610 
setTestProviderLocation(double latitude, double longitude)8611     private void setTestProviderLocation(double latitude, double longitude) {
8612         logd(
8613                 "setTestProviderLocation: setting test provider location to: latitude="
8614                         + latitude
8615                         + ", longitude="
8616                         + longitude);
8617         requestMockLocationPermission(true);
8618         Location loc = LocationUtils.createLocation(
8619                 TEST_PROVIDER, latitude, longitude, LOCATION_ACCURACY);
8620         logd("setTestProviderLocation: loc=" + loc);
8621         sLocationManager.setTestProviderLocation(TEST_PROVIDER, loc);
8622     }
8623 
requestMockLocationPermission(boolean allowed)8624     private static void requestMockLocationPermission(boolean allowed) {
8625         AppOpsManager aom = getContext().getSystemService(AppOpsManager.class);
8626         ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(aom, (appOpsMan) -> appOpsMan
8627                 .setUidMode(AppOpsManager.OPSTR_MOCK_LOCATION, Process.myUid(),
8628                         allowed ? AppOpsManager.MODE_ALLOWED : AppOpsManager.MODE_ERRORED));
8629     }
8630 
setUpSatelliteAccessAllowed()8631     private static void setUpSatelliteAccessAllowed() {
8632         logd("setUpSatelliteAccessAllowed...");
8633         assertTrue(sMockSatelliteServiceManager.setCountryCodes(false,
8634                 OVERRIDING_COUNTRY_CODES, null, null, 0));
8635         assertTrue(sMockSatelliteServiceManager.setSatelliteAccessControlOverlayConfigs(
8636                 false, true, null, 0, SATELLITE_COUNTRY_CODES, null));
8637     }
8638 
resetSatelliteAccessControlOverlayConfigs()8639     private static void resetSatelliteAccessControlOverlayConfigs() {
8640         logd("resetSatelliteAccessControlOverlayConfigs");
8641         assertTrue(sMockSatelliteServiceManager.setCountryCodes(true, null, null, null, 0));
8642         assertTrue(sMockSatelliteServiceManager.setSatelliteAccessControlOverlayConfigs(
8643                 true, true, null, 0, null, null));
8644     }
8645 
setUpSatelliteReceiverTest()8646     private static SatelliteReceiverTest setUpSatelliteReceiverTest() {
8647         SatelliteReceiverTest receiver = new SatelliteReceiverTest();
8648         sTestSubIDForCarrierSatellite = getActiveSubIDForCarrierSatelliteTest();
8649         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
8650                 TIMEOUT_TYPE_EVALUATE_ESOS_PROFILES_PRIORITIZATION_DURATION_MILLIS, 5));
8651         Context context = getContext();
8652         assertTrue(sMockSatelliteServiceManager.setSatelliteSubscriberIdListChangedIntentComponent(
8653                 "package"));
8654         assertTrue(sMockSatelliteServiceManager.setSatelliteSubscriberIdListChangedIntentComponent(
8655                 "class"));
8656         context.registerReceiver(receiver, new IntentFilter(SatelliteReceiver.TEST_INTENT),
8657                 Context.RECEIVER_EXPORTED);
8658         return receiver;
8659     }
8660 
resetSatelliteReceiverTest(Context context, SatelliteReceiverTest receiver)8661     private static void resetSatelliteReceiverTest(Context context, SatelliteReceiverTest receiver) {
8662         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
8663                 TIMEOUT_TYPE_EVALUATE_ESOS_PROFILES_PRIORITIZATION_DURATION_MILLIS, 0));
8664         assertTrue(sMockSatelliteServiceManager
8665                 .setSatelliteSubscriberIdListChangedIntentComponent("reset"));
8666         context.unregisterReceiver(receiver);
8667     }
8668 
waitForNtnOnlySubscriptionAvailable()8669     private static void waitForNtnOnlySubscriptionAvailable() {
8670         Context context = getContext();
8671         SubscriptionManager sm = context.getSystemService(SubscriptionManager.class);
8672         int i = 0;
8673         while (i < 10) {
8674             List<SubscriptionInfo> subscriptionInfoList = sm.getAllSubscriptionInfoList();
8675             for (SubscriptionInfo info : subscriptionInfoList) {
8676                 if (info.isOnlyNonTerrestrialNetwork()) {
8677                     logd("waitForNtnOnlySubscriptionAvailable: NTN only subscription  " + info
8678                             + " is available");
8679                     return;
8680                 }
8681             }
8682             i++;
8683             waitFor(500);
8684         }
8685         fail("NTN only subscription is not available");
8686     }
8687 
overrideSatelliteAccessForNtnOnlySubscription()8688     private static void overrideSatelliteAccessForNtnOnlySubscription() {
8689         assumeTrue(sNtnOnlySubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID);
8690         // Check if device has selected a binding satellite subscription
8691         grantSatellitePermission();
8692         Pair<Integer, Integer> selectedSatelliteSubIdPairResult =
8693                 requestSelectedNbIotSatelliteSubscriptionId();
8694         boolean shouldWaitForSelectedSatelliteSubChanged =
8695             (selectedSatelliteSubIdPairResult.first == null
8696                 || selectedSatelliteSubIdPairResult.first
8697                 == SubscriptionManager.INVALID_SUBSCRIPTION_ID);
8698 
8699         // Register callback for satellite subscription id changed event
8700         SelectedNbIotSatelliteSubscriptionCallbackTest
8701         selectedNbIotSatelliteSubscriptionCallbackTest =
8702                 new SelectedNbIotSatelliteSubscriptionCallbackTest();
8703         long registerError =
8704                 sSatelliteManager.registerForSelectedNbIotSatelliteSubscriptionChanged(
8705                         getContext().getMainExecutor(),
8706                         selectedNbIotSatelliteSubscriptionCallbackTest);
8707         assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerError);
8708         assertTrue(selectedNbIotSatelliteSubscriptionCallbackTest.waitUntilResult(1));
8709         selectedNbIotSatelliteSubscriptionCallbackTest.drainPermits();
8710 
8711         String subIdListStr = String.valueOf(sNtnOnlySubId);
8712         logd("overrideSatelliteAccessForNtnOnlySubscription: subIdListStr=" + subIdListStr);
8713         assertTrue(sMockSatelliteServiceManager.setSatelliteAccessAllowedForSubscriptions(
8714                 subIdListStr));
8715 
8716         if (shouldWaitForSelectedSatelliteSubChanged)  {
8717             // Overrding satellite access should trigger the selected satellite subscription
8718             // changed event.
8719             assertTrue(selectedNbIotSatelliteSubscriptionCallbackTest.waitUntilResult(1));
8720             logd("overrideSatelliteAccessForNtnOnlySubscription: selectedSatelliteSubId="
8721                     + selectedNbIotSatelliteSubscriptionCallbackTest.mSelectedSubId);
8722             assertNotEquals(SubscriptionManager.INVALID_SUBSCRIPTION_ID,
8723                     selectedNbIotSatelliteSubscriptionCallbackTest.mSelectedSubId);
8724         }
8725     }
8726 
resetSatelliteAccessForNtnOnlySubscription()8727     private static void resetSatelliteAccessForNtnOnlySubscription() {
8728         logd("resetSatelliteAccessForNtnOnlySubscription");
8729         assertTrue(sMockSatelliteServiceManager.setSatelliteAccessAllowedForSubscriptions(null));
8730     }
8731 
enableDefaultSmsAppSupportForNtnOnlySubscription()8732     private static void enableDefaultSmsAppSupportForNtnOnlySubscription() {
8733         // Assume that binding satellite subscription is already selected before this step
8734         assumeTrue(sNtnOnlySubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID);
8735 
8736         logd("enableDefaultSmsAppSupportForNtnOnlySubscription");
8737         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(false,
8738                 TIMEOUT_TYPE_EVALUATE_ESOS_PROFILES_PRIORITIZATION_DURATION_MILLIS, 5));
8739 
8740         sPreviousSupportedMsgApps = getConfigForSubId(getContext(), sNtnOnlySubId,
8741             CarrierConfigManager.KEY_SATELLITE_SUPPORTED_MSG_APPS_STRING_ARRAY)
8742             .getStringArray(
8743                 CarrierConfigManager.KEY_SATELLITE_SUPPORTED_MSG_APPS_STRING_ARRAY);
8744 
8745         String defaultSmsApp = null;
8746         ComponentName defaultSmsAppComp =
8747                 SmsApplication.getDefaultSmsApplication(getContext(), false);
8748         if (defaultSmsAppComp != null) {
8749             defaultSmsApp = defaultSmsAppComp.getPackageName();
8750         }
8751         logd("enableDefaultSmsAppSupportForNtnOnlySubscription: defaultSmsApp=" + defaultSmsApp
8752                  + ", sPreviousSupportedMsgApps=" + (sPreviousSupportedMsgApps == null
8753                      ? "null" : Arrays.toString(sPreviousSupportedMsgApps)));
8754 
8755         int existingLength =
8756                 sPreviousSupportedMsgApps == null ? 0 : sPreviousSupportedMsgApps.length;
8757         int newLength = existingLength;
8758         boolean isDefaultSmsAppSupported = false;
8759         if (defaultSmsApp != null) {
8760             if (sPreviousSupportedMsgApps == null
8761                     || !containString(sPreviousSupportedMsgApps, defaultSmsApp)) {
8762                 newLength++;
8763             } else {
8764                 logd("enableDefaultSmsAppSupportForNtnOnlySubscription: defaultSmsApp="
8765                         + defaultSmsApp + " is already supported");
8766                 isDefaultSmsAppSupported = true;
8767             }
8768         } else {
8769             fail("Device does not have a default SMS app");
8770             return;
8771         }
8772 
8773         String[] newSupportedMsgApps = new String[newLength];
8774         if (existingLength > 0) {
8775             System.arraycopy(sPreviousSupportedMsgApps, 0, newSupportedMsgApps, 0,
8776                     sPreviousSupportedMsgApps.length);
8777         }
8778         if (newLength > existingLength) {
8779             newSupportedMsgApps[newSupportedMsgApps.length - 1] = defaultSmsApp;
8780         }
8781         logd("enableDefaultSmsAppSupportForNtnOnlySubscription: newSupportedMsgApps="
8782                  + Arrays.toString(newSupportedMsgApps));
8783 
8784         SatelliteDisallowedReasonsCallbackTest callback =
8785                 registerForSatelliteDisallowedReasonsChanged();
8786         boolean hasUnsupportedDefaultMsgAppDisallowedReason = callback.hasSatelliteDisabledReason(
8787                 SATELLITE_DISALLOWED_REASON_UNSUPPORTED_DEFAULT_MSG_APP);
8788         callback.drainPermits();
8789 
8790         if (!isDefaultSmsAppSupported || hasUnsupportedDefaultMsgAppDisallowedReason) {
8791             logd("enableDefaultSmsAppSupportForNtnOnlySubscription: updating default SMS app...");
8792 
8793             PersistableBundle bundle = new PersistableBundle();
8794             bundle.putStringArray(CarrierConfigManager.KEY_SATELLITE_SUPPORTED_MSG_APPS_STRING_ARRAY,
8795                     newSupportedMsgApps);
8796             overrideCarrierConfig(sNtnOnlySubId, bundle);
8797 
8798             if (hasUnsupportedDefaultMsgAppDisallowedReason) {
8799                 assertTrue(callback.waitUntilResult(1));
8800                 assertFalse(callback.hasSatelliteDisabledReason(
8801                                 SATELLITE_DISALLOWED_REASON_UNSUPPORTED_DEFAULT_MSG_APP));
8802             }
8803         } else {
8804             logd("enableDefaultSmsAppSupportForNtnOnlySubscription: no need to update default SMS app");
8805         }
8806     }
8807 
containString(String[] strArray, String str)8808     private static boolean containString(String[] strArray, String str) {
8809         for (String element : strArray) {
8810             if (TextUtils.equals(element, str)) {
8811                 return true;
8812             }
8813         }
8814         return false;
8815     }
8816 
restoreDefaultSmsAppSupportForNtnOnlySubscription()8817     private static void restoreDefaultSmsAppSupportForNtnOnlySubscription() {
8818         logd("restoreDefaultSmsAppSupportForNtnOnlySubscription");
8819         if (sNtnOnlySubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
8820             logd("restoreDefaultSmsAppSupportForNtnOnlySubscription: no need to restore");
8821             return;
8822         }
8823 
8824         PersistableBundle bundle = new PersistableBundle();
8825         bundle.putStringArray(CarrierConfigManager.KEY_SATELLITE_SUPPORTED_MSG_APPS_STRING_ARRAY,
8826                 sPreviousSupportedMsgApps);
8827         overrideCarrierConfig(sNtnOnlySubId, bundle);
8828 
8829         assertTrue(sMockSatelliteServiceManager.setSatelliteControllerTimeoutDuration(true,
8830                 TIMEOUT_TYPE_EVALUATE_ESOS_PROFILES_PRIORITIZATION_DURATION_MILLIS, 0));
8831     }
8832 
setUpNtnOnlySubscription()8833     private static void setUpNtnOnlySubscription() {
8834         logd("setUpNtnOnlySubscription");
8835         assumeTrue(sNtnOnlySubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID);
8836         enableNtnOnlySubscription();
8837         overrideSatelliteAccessForNtnOnlySubscription();
8838         if (!isSatelliteProvisioned()) {
8839             logd("setUpNtnOnlySubscription: Provision satellite");
8840             assertTrue(provisionSatellite());
8841         } else {
8842             logd("setUpNtnOnlySubscription: Satellite already provisioned");
8843         }
8844         // Binding satellite subscription need to be selected before this step
8845         enableDefaultSmsAppSupportForNtnOnlySubscription();
8846     }
8847 
8848     private static SatelliteDisallowedReasonsCallbackTest
registerForSatelliteDisallowedReasonsChanged()8849             registerForSatelliteDisallowedReasonsChanged() {
8850         SatelliteDisallowedReasonsCallbackTest callback =
8851                 new SatelliteDisallowedReasonsCallbackTest();
8852         sSatelliteManager.registerForSatelliteDisallowedReasonsChanged(
8853                 getContext().getMainExecutor(), callback);
8854         assertTrue(callback.waitUntilResult(1));
8855         return callback;
8856     }
8857 
deprovisionSatelliteForDevice()8858     private static void deprovisionSatelliteForDevice() {
8859         List<SatelliteSubscriberInfo> provisionedSubscriberList =
8860                 getSatelliteSubscriberInfoList(true);
8861         if (provisionedSubscriberList.size() == 0) {
8862             logd("Device is not provisioned");
8863             return;
8864         }
8865         Pair<Boolean, Integer> pairResult = deprovisionSatellite(provisionedSubscriberList);
8866         assertNotNull(pairResult);
8867         assertTrue(pairResult.first);
8868     }
8869 
assertIsEnabledState(boolean expectedIsEnabledStateChanged, boolean expectedIsEnabledState)8870     private void assertIsEnabledState(boolean expectedIsEnabledStateChanged,
8871             boolean expectedIsEnabledState) {
8872         try {
8873             final boolean isEnabledStateChanged = mIsEnabledStateChangedLatch.await(
8874                     MAX_WAIT_FOR_STATE_CHANGED_SECONDS, TimeUnit.SECONDS);
8875 
8876             assertThat(isEnabledStateChanged).isEqualTo(expectedIsEnabledStateChanged);
8877             assertThat(mIsEnabled).isEqualTo(expectedIsEnabledState);
8878         } catch (InterruptedException e) {
8879             Thread.currentThread().interrupt();
8880             throw new AssertionError("InterruptedException while waiting for state change.");
8881         }
8882     }
8883 
waitForEventOnSetSatellitePlmn(int expectedNumOfEvents)8884     private boolean waitForEventOnSetSatellitePlmn(int expectedNumOfEvents) {
8885         if (getHalVersion(TelephonyManager.HAL_SERVICE_NETWORK) < RADIO_HAL_VERSION_2_3) {
8886             return sMockSatelliteServiceManager.waitForEventOnSetSatellitePlmn(expectedNumOfEvents);
8887         }
8888 
8889         return sMockModemManager.waitForEventOnSetSatellitePlmn(expectedNumOfEvents);
8890     }
8891 
8892     @Nullable
getCarrierPlmnList()8893     List<String> getCarrierPlmnList() {
8894         if (getHalVersion(TelephonyManager.HAL_SERVICE_NETWORK) < RADIO_HAL_VERSION_2_3) {
8895             return sMockSatelliteServiceManager.getCarrierPlmnList();
8896         }
8897 
8898         return sMockModemManager.getCarrierPlmnList(SLOT_ID_0);
8899     }
8900 
8901     @Nullable
getAllSatellitePlmnList()8902     List<String> getAllSatellitePlmnList() {
8903         if (getHalVersion(TelephonyManager.HAL_SERVICE_NETWORK) < RADIO_HAL_VERSION_2_3) {
8904             return sMockSatelliteServiceManager.getAllSatellitePlmnList();
8905         }
8906 
8907         return sMockModemManager.getAllSatellitePlmnList(SLOT_ID_0);
8908     }
8909 
moveSatelliteToOffState()8910     private static void moveSatelliteToOffState() {
8911         grantSatellitePermission();
8912         if (isSatelliteEnabled()) {
8913             SatelliteModemStateCallbackTest callback = new SatelliteModemStateCallbackTest();
8914             long registerResult = sSatelliteManager.registerForModemStateChanged(
8915                     getContext().getMainExecutor(), callback);
8916             assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerResult);
8917             assertTrue(callback.waitUntilResult(1));
8918 
8919             logd("moveSatelliteToOffState: Moving satellite to off state");
8920             callback.clearModemStates();
8921             sMockSatelliteServiceManager.sendOnSatelliteModemStateChanged(
8922                 SatelliteModemState.SATELLITE_MODEM_STATE_OFF);
8923             assertTrue(callback.waitUntilModemOff());
8924             sSatelliteManager.unregisterForModemStateChanged(callback);
8925         } else {
8926             logd("moveSatelliteToOffState: Satellite is already off");
8927         }
8928     }
8929 }