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 com.android.internal.telephony.satellite;
18 
19 import static android.telephony.CarrierConfigManager.KEY_EMERGENCY_CALL_TO_SATELLITE_T911_HANDOVER_TIMEOUT_MILLIS_INT;
20 import static android.telephony.CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL;
21 import static android.telephony.CarrierConfigManager.KEY_SATELLITE_CONNECTION_HYSTERESIS_SEC_INT;
22 import static android.telephony.NetworkRegistrationInfo.SERVICE_TYPE_DATA;
23 import static android.telephony.SubscriptionManager.SATELLITE_ENTITLEMENT_STATUS;
24 import static android.telephony.satellite.NtnSignalStrength.NTN_SIGNAL_STRENGTH_GOOD;
25 import static android.telephony.satellite.NtnSignalStrength.NTN_SIGNAL_STRENGTH_GREAT;
26 import static android.telephony.satellite.NtnSignalStrength.NTN_SIGNAL_STRENGTH_NONE;
27 import static android.telephony.satellite.NtnSignalStrength.NTN_SIGNAL_STRENGTH_POOR;
28 import static android.telephony.satellite.SatelliteManager.KEY_DEMO_MODE_ENABLED;
29 import static android.telephony.satellite.SatelliteManager.KEY_NTN_SIGNAL_STRENGTH;
30 import static android.telephony.satellite.SatelliteManager.KEY_SATELLITE_CAPABILITIES;
31 import static android.telephony.satellite.SatelliteManager.KEY_SATELLITE_COMMUNICATION_ALLOWED;
32 import static android.telephony.satellite.SatelliteManager.KEY_SATELLITE_ENABLED;
33 import static android.telephony.satellite.SatelliteManager.KEY_SATELLITE_NEXT_VISIBILITY;
34 import static android.telephony.satellite.SatelliteManager.KEY_SATELLITE_PROVISIONED;
35 import static android.telephony.satellite.SatelliteManager.KEY_SATELLITE_SUPPORTED;
36 import static android.telephony.satellite.SatelliteManager.NT_RADIO_TECHNOLOGY_EMTC_NTN;
37 import static android.telephony.satellite.SatelliteManager.NT_RADIO_TECHNOLOGY_NB_IOT_NTN;
38 import static android.telephony.satellite.SatelliteManager.NT_RADIO_TECHNOLOGY_NR_NTN;
39 import static android.telephony.satellite.SatelliteManager.NT_RADIO_TECHNOLOGY_PROPRIETARY;
40 import static android.telephony.satellite.SatelliteManager.SATELLITE_COMMUNICATION_RESTRICTION_REASON_ENTITLEMENT;
41 import static android.telephony.satellite.SatelliteManager.SATELLITE_COMMUNICATION_RESTRICTION_REASON_GEOLOCATION;
42 import static android.telephony.satellite.SatelliteManager.SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER;
43 import static android.telephony.satellite.SatelliteManager.SATELLITE_MODEM_STATE_CONNECTED;
44 import static android.telephony.satellite.SatelliteManager.SATELLITE_MODEM_STATE_OFF;
45 import static android.telephony.satellite.SatelliteManager.SATELLITE_MODEM_STATE_UNAVAILABLE;
46 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_ERROR;
47 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_INVALID_ARGUMENTS;
48 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_INVALID_MODEM_STATE;
49 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_INVALID_TELEPHONY_STATE;
50 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_MODEM_ERROR;
51 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_MODEM_TIMEOUT;
52 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_NOT_AUTHORIZED;
53 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_NOT_SUPPORTED;
54 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_NO_RESOURCES;
55 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_RADIO_NOT_AVAILABLE;
56 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_REQUEST_IN_PROGRESS;
57 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_REQUEST_NOT_SUPPORTED;
58 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_SERVICE_NOT_PROVISIONED;
59 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_SERVICE_PROVISION_IN_PROGRESS;
60 import static android.telephony.satellite.SatelliteManager.SATELLITE_RESULT_SUCCESS;
61 
62 import static com.android.internal.telephony.satellite.SatelliteController.DEFAULT_CARRIER_EMERGENCY_CALL_WAIT_FOR_CONNECTION_TIMEOUT_MILLIS;
63 import static com.android.internal.telephony.satellite.SatelliteController.SATELLITE_MODE_ENABLED_FALSE;
64 import static com.android.internal.telephony.satellite.SatelliteController.SATELLITE_MODE_ENABLED_TRUE;
65 
66 import static org.junit.Assert.assertEquals;
67 import static org.junit.Assert.assertFalse;
68 import static org.junit.Assert.assertNotNull;
69 import static org.junit.Assert.assertNull;
70 import static org.junit.Assert.assertThrows;
71 import static org.junit.Assert.assertTrue;
72 import static org.mockito.ArgumentMatchers.any;
73 import static org.mockito.ArgumentMatchers.anyBoolean;
74 import static org.mockito.ArgumentMatchers.anyInt;
75 import static org.mockito.ArgumentMatchers.anyList;
76 import static org.mockito.ArgumentMatchers.anyLong;
77 import static org.mockito.ArgumentMatchers.anyString;
78 import static org.mockito.ArgumentMatchers.anyVararg;
79 import static org.mockito.ArgumentMatchers.eq;
80 import static org.mockito.Mockito.clearInvocations;
81 import static org.mockito.Mockito.doAnswer;
82 import static org.mockito.Mockito.doNothing;
83 import static org.mockito.Mockito.doReturn;
84 import static org.mockito.Mockito.never;
85 import static org.mockito.Mockito.reset;
86 import static org.mockito.Mockito.times;
87 import static org.mockito.Mockito.verify;
88 import static org.mockito.Mockito.verifyZeroInteractions;
89 import static org.mockito.Mockito.when;
90 
91 import android.annotation.NonNull;
92 import android.app.NotificationManager;
93 import android.content.Context;
94 import android.content.SharedPreferences;
95 import android.os.AsyncResult;
96 import android.os.Bundle;
97 import android.os.CancellationSignal;
98 import android.os.Handler;
99 import android.os.ICancellationSignal;
100 import android.os.Looper;
101 import android.os.Message;
102 import android.os.PersistableBundle;
103 import android.os.RemoteException;
104 import android.os.ResultReceiver;
105 import android.telephony.CarrierConfigManager;
106 import android.telephony.CellSignalStrength;
107 import android.telephony.NetworkRegistrationInfo;
108 import android.telephony.Rlog;
109 import android.telephony.ServiceState;
110 import android.telephony.satellite.INtnSignalStrengthCallback;
111 import android.telephony.satellite.ISatelliteCapabilitiesCallback;
112 import android.telephony.satellite.ISatelliteDatagramCallback;
113 import android.telephony.satellite.ISatelliteModemStateCallback;
114 import android.telephony.satellite.ISatelliteProvisionStateCallback;
115 import android.telephony.satellite.ISatelliteSupportedStateCallback;
116 import android.telephony.satellite.ISatelliteTransmissionUpdateCallback;
117 import android.telephony.satellite.NtnSignalStrength;
118 import android.telephony.satellite.SatelliteCapabilities;
119 import android.telephony.satellite.SatelliteDatagram;
120 import android.telephony.satellite.SatelliteManager;
121 import android.telephony.satellite.SatelliteManager.SatelliteException;
122 import android.testing.AndroidTestingRunner;
123 import android.testing.TestableLooper;
124 import android.util.Pair;
125 import android.util.SparseArray;
126 import android.util.SparseBooleanArray;
127 
128 import com.android.internal.R;
129 import com.android.internal.telephony.IIntegerConsumer;
130 import com.android.internal.telephony.IVoidConsumer;
131 import com.android.internal.telephony.Phone;
132 import com.android.internal.telephony.PhoneFactory;
133 import com.android.internal.telephony.TelephonyTest;
134 import com.android.internal.telephony.configupdate.ConfigProviderAdaptor;
135 import com.android.internal.telephony.configupdate.TelephonyConfigUpdateInstallReceiver;
136 import com.android.internal.telephony.flags.FeatureFlags;
137 import com.android.internal.telephony.satellite.metrics.ControllerMetricsStats;
138 import com.android.internal.telephony.satellite.metrics.ProvisionMetricsStats;
139 import com.android.internal.telephony.satellite.metrics.SessionMetricsStats;
140 import com.android.internal.telephony.subscription.SubscriptionManagerService;
141 
142 import org.junit.After;
143 import org.junit.Before;
144 import org.junit.Test;
145 import org.junit.runner.RunWith;
146 import org.mockito.ArgumentCaptor;
147 import org.mockito.Mock;
148 import org.mockito.Mockito;
149 import org.mockito.MockitoAnnotations;
150 
151 import java.util.ArrayList;
152 import java.util.Arrays;
153 import java.util.HashMap;
154 import java.util.HashSet;
155 import java.util.List;
156 import java.util.Map;
157 import java.util.Set;
158 import java.util.concurrent.Executor;
159 import java.util.concurrent.Semaphore;
160 import java.util.concurrent.TimeUnit;
161 
162 @RunWith(AndroidTestingRunner.class)
163 @TestableLooper.RunWithLooper
164 public class SatelliteControllerTest extends TelephonyTest {
165     private static final String TAG = "SatelliteControllerTest";
166 
167     private static final long TIMEOUT = 500;
168     private static final int SUB_ID = 0;
169     private static final int SUB_ID1 = 1;
170     private static final int MAX_BYTES_PER_OUT_GOING_DATAGRAM = 339;
171     private static final String TEST_SATELLITE_TOKEN = "TEST_SATELLITE_TOKEN";
172     private static final String TEST_NEXT_SATELLITE_TOKEN = "TEST_NEXT_SATELLITE_TOKEN";
173     private static final String[] EMPTY_STRING_ARRAY = {};
174     private static final List<String> EMPTY_STRING_LIST = new ArrayList<>();
175     private static final String SATELLITE_SYSTEM_NOTIFICATION_DONE_KEY =
176             "satellite_system_notification_done_key";
177     private static final int[] ACTIVE_SUB_IDS = {SUB_ID};
178     private static final int TEST_WAIT_FOR_SATELLITE_ENABLING_RESPONSE_TIMEOUT_MILLIS =
179             (int) TimeUnit.SECONDS.toMillis(60);
180 
181     private static final String SATELLITE_PLMN = "00103";
182     private List<Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener>>
183             mCarrierConfigChangedListenerList = new ArrayList<>();
184 
185     private TestSatelliteController mSatelliteControllerUT;
186     private TestSharedPreferences mSharedPreferences;
187     private PersistableBundle mCarrierConfigBundle;
188     private ServiceState mServiceState2;
189 
190     @Mock private DatagramController mMockDatagramController;
191     @Mock private SatelliteModemInterface mMockSatelliteModemInterface;
192     @Mock private SatelliteSessionController mMockSatelliteSessionController;
193     @Mock private PointingAppController mMockPointingAppController;
194     @Mock private ControllerMetricsStats mMockControllerMetricsStats;
195     @Mock private ProvisionMetricsStats mMockProvisionMetricsStats;
196     @Mock private SessionMetricsStats mMockSessionMetricsStats;
197     @Mock private SubscriptionManagerService mMockSubscriptionManagerService;
198     @Mock private NotificationManager mMockNotificationManager;
199     private List<Integer> mIIntegerConsumerResults =  new ArrayList<>();
200     @Mock private ISatelliteTransmissionUpdateCallback mStartTransmissionUpdateCallback;
201     @Mock private ISatelliteTransmissionUpdateCallback mStopTransmissionUpdateCallback;
202     @Mock private FeatureFlags mFeatureFlags;
203     @Mock private TelephonyConfigUpdateInstallReceiver mMockTelephonyConfigUpdateInstallReceiver;
204     @Mock private SatelliteConfigParser mMockConfigParser;
205     @Mock private CellSignalStrength mCellSignalStrength;
206     @Mock private SatelliteConfig mMockConfig;
207     @Mock private DemoSimulator mMockDemoSimulator;
208 
209     private Semaphore mIIntegerConsumerSemaphore = new Semaphore(0);
210     private IIntegerConsumer mIIntegerConsumer = new IIntegerConsumer.Stub() {
211         @Override
212         public void accept(int result) {
213             logd("mIIntegerConsumer: result=" + result);
214             mIIntegerConsumerResults.add(result);
215             try {
216                 mIIntegerConsumerSemaphore.release();
217             } catch (Exception ex) {
218                 loge("mIIntegerConsumer: Got exception in releasing semaphore, ex=" + ex);
219             }
220         }
221     };
222 
223     private boolean mIsSatelliteServiceSupported = true;
224     private boolean mIsPointingRequired = true;
225     private Set<Integer> mSupportedRadioTechnologies = new HashSet<>(Arrays.asList(
226             NT_RADIO_TECHNOLOGY_NR_NTN,
227             NT_RADIO_TECHNOLOGY_EMTC_NTN,
228             NT_RADIO_TECHNOLOGY_NB_IOT_NTN,
229             NT_RADIO_TECHNOLOGY_PROPRIETARY));
230     private SatelliteCapabilities mSatelliteCapabilities = new SatelliteCapabilities(
231             mSupportedRadioTechnologies, mIsPointingRequired, MAX_BYTES_PER_OUT_GOING_DATAGRAM,
232             new HashMap<>());
233     private SatelliteCapabilities mEmptySatelliteCapabilities = new SatelliteCapabilities(
234             new HashSet<>(), mIsPointingRequired, MAX_BYTES_PER_OUT_GOING_DATAGRAM,
235             new HashMap<>());
236     private Semaphore mSatelliteCapabilitiesSemaphore = new Semaphore(0);
237     private SatelliteCapabilities mQueriedSatelliteCapabilities = null;
238     private int mQueriedSatelliteCapabilitiesResultCode = SATELLITE_RESULT_SUCCESS;
239     private ResultReceiver mSatelliteCapabilitiesReceiver = new ResultReceiver(null) {
240         @Override
241         protected void onReceiveResult(int resultCode, Bundle resultData) {
242             mQueriedSatelliteCapabilitiesResultCode = resultCode;
243             logd("mSatelliteCapabilitiesReceiver: resultCode=" + resultCode);
244             if (resultCode == SATELLITE_RESULT_SUCCESS) {
245                 if (resultData.containsKey(KEY_SATELLITE_CAPABILITIES)) {
246                     mQueriedSatelliteCapabilities = resultData.getParcelable(
247                             KEY_SATELLITE_CAPABILITIES, SatelliteCapabilities.class);
248                 } else {
249                     loge("KEY_SATELLITE_SUPPORTED does not exist.");
250                     mQueriedSatelliteCapabilities = null;
251                 }
252             } else {
253                 mQueriedSatelliteCapabilities = null;
254             }
255             try {
256                 mSatelliteCapabilitiesSemaphore.release();
257             } catch (Exception ex) {
258                 loge("mSatelliteCapabilitiesReceiver: Got exception in releasing semaphore, ex="
259                         + ex);
260             }
261         }
262     };
263 
264     private boolean mQueriedSatelliteSupported = false;
265     private int mQueriedSatelliteSupportedResultCode = SATELLITE_RESULT_SUCCESS;
266     private Semaphore mSatelliteSupportSemaphore = new Semaphore(0);
267     private ResultReceiver mSatelliteSupportReceiver = new ResultReceiver(null) {
268         @Override
269         protected void onReceiveResult(int resultCode, Bundle resultData) {
270             mQueriedSatelliteSupportedResultCode = resultCode;
271             logd("mSatelliteSupportReceiver: resultCode=" + resultCode);
272             if (resultCode == SATELLITE_RESULT_SUCCESS) {
273                 if (resultData.containsKey(KEY_SATELLITE_SUPPORTED)) {
274                     mQueriedSatelliteSupported = resultData.getBoolean(KEY_SATELLITE_SUPPORTED);
275                 } else {
276                     loge("KEY_SATELLITE_SUPPORTED does not exist.");
277                     mQueriedSatelliteSupported = false;
278                 }
279             } else {
280                 mQueriedSatelliteSupported = false;
281             }
282             try {
283                 mSatelliteSupportSemaphore.release();
284             } catch (Exception ex) {
285                 loge("mSatelliteSupportReceiver: Got exception in releasing semaphore, ex=" + ex);
286             }
287         }
288     };
289 
290     private boolean mQueriedIsSatelliteEnabled = false;
291     private int mQueriedIsSatelliteEnabledResultCode = SATELLITE_RESULT_SUCCESS;
292     private Semaphore mIsSatelliteEnabledSemaphore = new Semaphore(0);
293     private ResultReceiver mIsSatelliteEnabledReceiver = new ResultReceiver(null) {
294         @Override
295         protected void onReceiveResult(int resultCode, Bundle resultData) {
296             logd("mIsSatelliteEnabledReceiver: resultCode=" + resultCode);
297             mQueriedIsSatelliteEnabledResultCode = resultCode;
298             if (resultCode == SATELLITE_RESULT_SUCCESS) {
299                 if (resultData.containsKey(KEY_SATELLITE_ENABLED)) {
300                     mQueriedIsSatelliteEnabled = resultData.getBoolean(KEY_SATELLITE_ENABLED);
301                 } else {
302                     loge("KEY_SATELLITE_ENABLED does not exist.");
303                     mQueriedIsSatelliteEnabled = false;
304                 }
305             } else {
306                 mQueriedIsSatelliteEnabled = false;
307             }
308             try {
309                 mIsSatelliteEnabledSemaphore.release();
310             } catch (Exception ex) {
311                 loge("mIsSatelliteEnabledReceiver: Got exception in releasing semaphore, ex=" + ex);
312             }
313         }
314     };
315 
316     private boolean mQueriedIsDemoModeEnabled = false;
317     private int mQueriedIsDemoModeEnabledResultCode = SATELLITE_RESULT_SUCCESS;
318     private Semaphore mIsDemoModeEnabledSemaphore = new Semaphore(0);
319     private ResultReceiver mIsDemoModeEnabledReceiver = new ResultReceiver(null) {
320         @Override
321         protected void onReceiveResult(int resultCode, Bundle resultData) {
322             mQueriedIsDemoModeEnabledResultCode = resultCode;
323             logd("mIsDemoModeEnabledReceiver: resultCode=" + resultCode);
324             if (resultCode == SATELLITE_RESULT_SUCCESS) {
325                 if (resultData.containsKey(KEY_DEMO_MODE_ENABLED)) {
326                     mQueriedIsDemoModeEnabled = resultData.getBoolean(KEY_DEMO_MODE_ENABLED);
327                 } else {
328                     loge("KEY_DEMO_MODE_ENABLED does not exist.");
329                     mQueriedIsDemoModeEnabled = false;
330                 }
331             } else {
332                 mQueriedIsDemoModeEnabled = false;
333             }
334             try {
335                 mIsDemoModeEnabledSemaphore.release();
336             } catch (Exception ex) {
337                 loge("mIsDemoModeEnabledReceiver: Got exception in releasing semaphore, ex=" + ex);
338             }
339         }
340     };
341 
342     private boolean mQueriedIsSatelliteProvisioned = false;
343     private int mQueriedIsSatelliteProvisionedResultCode = SATELLITE_RESULT_SUCCESS;
344     private Semaphore mIsSatelliteProvisionedSemaphore = new Semaphore(0);
345     private ResultReceiver mIsSatelliteProvisionedReceiver = new ResultReceiver(null) {
346         @Override
347         protected void onReceiveResult(int resultCode, Bundle resultData) {
348             mQueriedIsSatelliteProvisionedResultCode = resultCode;
349             logd("mIsSatelliteProvisionedReceiver: resultCode=" + resultCode);
350             if (resultCode == SATELLITE_RESULT_SUCCESS) {
351                 if (resultData.containsKey(KEY_SATELLITE_PROVISIONED)) {
352                     mQueriedIsSatelliteProvisioned =
353                             resultData.getBoolean(KEY_SATELLITE_PROVISIONED);
354                 } else {
355                     loge("KEY_SATELLITE_PROVISIONED does not exist.");
356                     mQueriedIsSatelliteProvisioned = false;
357                 }
358             } else {
359                 mQueriedIsSatelliteProvisioned = false;
360             }
361             try {
362                 mIsSatelliteProvisionedSemaphore.release();
363             } catch (Exception ex) {
364                 loge("mIsSatelliteProvisionedReceiver: Got exception in releasing semaphore ex="
365                         + ex);
366             }
367         }
368     };
369 
370     private boolean mQueriedSatelliteAllowed = false;
371     private int mQueriedSatelliteAllowedResultCode = SATELLITE_RESULT_SUCCESS;
372     private Semaphore mSatelliteAllowedSemaphore = new Semaphore(0);
373     private ResultReceiver mSatelliteAllowedReceiver = new ResultReceiver(null) {
374         @Override
375         protected void onReceiveResult(int resultCode, Bundle resultData) {
376             mQueriedSatelliteAllowedResultCode = resultCode;
377             logd("mSatelliteAllowedReceiver: resultCode=" + resultCode);
378             if (resultCode == SATELLITE_RESULT_SUCCESS) {
379                 if (resultData.containsKey(KEY_SATELLITE_COMMUNICATION_ALLOWED)) {
380                     mQueriedSatelliteAllowed = resultData.getBoolean(
381                             KEY_SATELLITE_COMMUNICATION_ALLOWED);
382                 } else {
383                     loge("KEY_SATELLITE_COMMUNICATION_ALLOWED does not exist.");
384                     mQueriedSatelliteAllowed = false;
385                 }
386             } else {
387                 mQueriedSatelliteAllowed = false;
388             }
389             try {
390                 mSatelliteAllowedSemaphore.release();
391             } catch (Exception ex) {
392                 loge("mSatelliteAllowedReceiver: Got exception in releasing semaphore, ex=" + ex);
393             }
394         }
395     };
396 
397     private int mQueriedSatelliteVisibilityTime = -1;
398     private int mSatelliteNextVisibilityTime = 3600;
399     private int mQueriedSatelliteVisibilityTimeResultCode = SATELLITE_RESULT_SUCCESS;
400     private Semaphore mSatelliteVisibilityTimeSemaphore = new Semaphore(0);
401     private ResultReceiver mSatelliteVisibilityTimeReceiver = new ResultReceiver(null) {
402         @Override
403         protected void onReceiveResult(int resultCode, Bundle resultData) {
404             mQueriedSatelliteVisibilityTimeResultCode = resultCode;
405             logd("mSatelliteVisibilityTimeReceiver: resultCode=" + resultCode);
406             if (resultCode == SATELLITE_RESULT_SUCCESS) {
407                 if (resultData.containsKey(KEY_SATELLITE_NEXT_VISIBILITY)) {
408                     mQueriedSatelliteVisibilityTime = resultData.getInt(
409                             KEY_SATELLITE_NEXT_VISIBILITY);
410                 } else {
411                     loge("KEY_SATELLITE_NEXT_VISIBILITY does not exist.");
412                     mQueriedSatelliteVisibilityTime = -1;
413                 }
414             } else {
415                 mQueriedSatelliteVisibilityTime = -1;
416             }
417             try {
418                 mSatelliteVisibilityTimeSemaphore.release();
419             } catch (Exception ex) {
420                 loge("mSatelliteVisibilityTimeReceiver: Got exception in releasing semaphore, ex="
421                         + ex);
422             }
423         }
424     };
425 
426     private @NtnSignalStrength.NtnSignalStrengthLevel int mQueriedNtnSignalStrengthLevel =
427             NTN_SIGNAL_STRENGTH_NONE;
428     private int mQueriedNtnSignalStrengthResultCode = SATELLITE_RESULT_SUCCESS;
429     private Semaphore mRequestNtnSignalStrengthSemaphore = new Semaphore(0);
430     private ResultReceiver mRequestNtnSignalStrengthReceiver = new ResultReceiver(null) {
431         @Override
432         protected void onReceiveResult(int resultCode, Bundle resultData) {
433             mQueriedNtnSignalStrengthResultCode = resultCode;
434             logd("KEY_NTN_SIGNAL_STRENGTH: resultCode=" + resultCode);
435             if (resultCode == SATELLITE_RESULT_SUCCESS) {
436                 if (resultData.containsKey(KEY_NTN_SIGNAL_STRENGTH)) {
437                     NtnSignalStrength result = resultData.getParcelable(KEY_NTN_SIGNAL_STRENGTH);
438                     logd("result.getLevel()=" + result.getLevel());
439                     mQueriedNtnSignalStrengthLevel = result.getLevel();
440                 } else {
441                     loge("KEY_NTN_SIGNAL_STRENGTH does not exist.");
442                     mQueriedNtnSignalStrengthLevel = NTN_SIGNAL_STRENGTH_NONE;
443                 }
444             } else {
445                 mQueriedNtnSignalStrengthLevel = NTN_SIGNAL_STRENGTH_NONE;
446             }
447             try {
448                 mRequestNtnSignalStrengthSemaphore.release();
449             } catch (Exception ex) {
450                 loge("mRequestNtnSignalStrengthReceiver: Got exception in releasing semaphore, ex="
451                         + ex);
452             }
453         }
454     };
455 
456     @Before
setUp()457     public void setUp() throws Exception {
458         super.setUp(getClass().getSimpleName());
459         MockitoAnnotations.initMocks(this);
460         logd(TAG + " Setup!");
461 
462         replaceInstance(DatagramController.class, "sInstance", null,
463                 mMockDatagramController);
464         replaceInstance(SatelliteModemInterface.class, "sInstance", null,
465                 mMockSatelliteModemInterface);
466         replaceInstance(SatelliteSessionController.class, "sInstance", null,
467                 mMockSatelliteSessionController);
468         replaceInstance(PointingAppController.class, "sInstance", null,
469                 mMockPointingAppController);
470         replaceInstance(ControllerMetricsStats.class, "sInstance", null,
471                 mMockControllerMetricsStats);
472         replaceInstance(ProvisionMetricsStats.class, "sInstance", null,
473                 mMockProvisionMetricsStats);
474         replaceInstance(SessionMetricsStats.class, "sInstance", null,
475                 mMockSessionMetricsStats);
476         replaceInstance(SubscriptionManagerService.class, "sInstance", null,
477                 mMockSubscriptionManagerService);
478         replaceInstance(PhoneFactory.class, "sPhones", null, new Phone[]{mPhone, mPhone2});
479         replaceInstance(TelephonyConfigUpdateInstallReceiver.class, "sReceiverAdaptorInstance",
480                 null, mMockTelephonyConfigUpdateInstallReceiver);
481         replaceInstance(DemoSimulator.class, "sInstance", null, mMockDemoSimulator);
482 
483         mServiceState2 = Mockito.mock(ServiceState.class);
484         when(mPhone.getServiceState()).thenReturn(mServiceState);
485         when(mPhone.getSubId()).thenReturn(SUB_ID);
486         when(mPhone.getPhoneId()).thenReturn(0);
487         when(mPhone2.getServiceState()).thenReturn(mServiceState2);
488         when(mPhone2.getSubId()).thenReturn(SUB_ID1);
489         when(mPhone2.getPhoneId()).thenReturn(1);
490 
491         mContextFixture.putStringArrayResource(
492                 R.array.config_satellite_providers,
493                 EMPTY_STRING_ARRAY);
494         mContextFixture.putIntResource(
495                 R.integer.config_wait_for_satellite_enabling_response_timeout_millis,
496                 TEST_WAIT_FOR_SATELLITE_ENABLING_RESPONSE_TIMEOUT_MILLIS);
497         doReturn(ACTIVE_SUB_IDS).when(mMockSubscriptionManagerService).getActiveSubIdList(true);
498 
499         mCarrierConfigBundle = mContextFixture.getCarrierConfigBundle();
500         doReturn(mCarrierConfigBundle)
501                 .when(mCarrierConfigManager).getConfigForSubId(anyInt(), anyVararg());
502         doAnswer(invocation -> {
503             Executor executor = invocation.getArgument(0);
504             CarrierConfigManager.CarrierConfigChangeListener listener = invocation.getArgument(1);
505             mCarrierConfigChangedListenerList.add(new Pair<>(executor, listener));
506             return null;
507         }).when(mCarrierConfigManager).registerCarrierConfigChangeListener(
508                 any(Executor.class),
509                 any(CarrierConfigManager.CarrierConfigChangeListener.class));
510 
511         mSharedPreferences = new TestSharedPreferences();
512         when(mContext.getSharedPreferences(anyString(), anyInt())).thenReturn(mSharedPreferences);
513         doReturn(mIsSatelliteServiceSupported)
514                 .when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
515         setUpResponseForRequestSatelliteCapabilities(
516                 mSatelliteCapabilities, SATELLITE_RESULT_SUCCESS);
517         setUpResponseForRequestIsSatelliteSupported(false,
518                 SATELLITE_RESULT_RADIO_NOT_AVAILABLE);
519         doNothing().when(mMockDatagramController).setDemoMode(anyBoolean());
520         doNothing().when(mMockSatelliteSessionController)
521                 .onSatelliteEnabledStateChanged(anyBoolean());
522         doNothing().when(mMockSatelliteSessionController).onSatelliteModemStateChanged(anyInt());
523         doNothing().when(mMockSatelliteSessionController).setDemoMode(anyBoolean());
524         doNothing().when(mMockControllerMetricsStats).onSatelliteEnabled();
525         doNothing().when(mMockControllerMetricsStats).reportServiceEnablementSuccessCount();
526         doNothing().when(mMockControllerMetricsStats).reportServiceEnablementFailCount();
527         doReturn(mMockSessionMetricsStats)
528                 .when(mMockSessionMetricsStats).setInitializationResult(anyInt());
529         doReturn(mMockSessionMetricsStats)
530                 .when(mMockSessionMetricsStats).setSatelliteTechnology(anyInt());
531         doReturn(mMockSessionMetricsStats)
532                 .when(mMockSessionMetricsStats).setTerminationResult(anyInt());
533         doReturn(mMockSessionMetricsStats)
534                 .when(mMockSessionMetricsStats).setInitializationProcessingTime(anyLong());
535         doReturn(mMockSessionMetricsStats)
536                 .when(mMockSessionMetricsStats).setTerminationProcessingTime(anyLong());
537         doReturn(mMockSessionMetricsStats)
538                 .when(mMockSessionMetricsStats).setSessionDurationSec(anyInt());
539         doReturn(mMockSessionMetricsStats)
540                 .when(mMockSessionMetricsStats).setIsDemoMode(anyBoolean());
541         doNothing().when(mMockSessionMetricsStats).reportSessionMetrics();
542 
543         doReturn(mMockProvisionMetricsStats).when(mMockProvisionMetricsStats)
544                 .setResultCode(anyInt());
545         doReturn(mMockProvisionMetricsStats).when(mMockProvisionMetricsStats)
546                 .setIsProvisionRequest(anyBoolean());
547         doNothing().when(mMockProvisionMetricsStats).reportProvisionMetrics();
548         doNothing().when(mMockControllerMetricsStats).reportDeprovisionCount(anyInt());
549         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(true);
550         doReturn(mSST).when(mPhone).getServiceStateTracker();
551         doReturn(mSST).when(mPhone2).getServiceStateTracker();
552         doReturn(mServiceState).when(mSST).getServiceState();
553         doReturn(Context.NOTIFICATION_SERVICE).when(mContext).getSystemServiceName(
554                 NotificationManager.class);
555         doReturn(mMockNotificationManager).when(mContext).getSystemService(
556                 Context.NOTIFICATION_SERVICE);
557         mSatelliteControllerUT =
558                 new TestSatelliteController(mContext, Looper.myLooper(), mFeatureFlags);
559         verify(mMockSatelliteModemInterface).registerForSatelliteProvisionStateChanged(
560                 any(Handler.class),
561                 eq(26) /* EVENT_SATELLITE_PROVISION_STATE_CHANGED */,
562                 eq(null));
563         verify(mMockSatelliteModemInterface).registerForPendingDatagrams(
564                 any(Handler.class),
565                 eq(27) /* EVENT_PENDING_DATAGRAMS */,
566                 eq(null));
567         verify(mMockSatelliteModemInterface).registerForSatelliteModemStateChanged(
568                 any(Handler.class),
569                 eq(28) /* EVENT_SATELLITE_MODEM_STATE_CHANGED */,
570                 eq(null));
571 
572         doReturn(mMockConfigParser).when(mMockTelephonyConfigUpdateInstallReceiver)
573                 .getConfigParser(ConfigProviderAdaptor.DOMAIN_SATELLITE);
574     }
575 
576     @After
tearDown()577     public void tearDown() throws Exception {
578         logd(TAG + " tearDown");
579         mSatelliteControllerUT = null;
580         super.tearDown();
581     }
582 
583     @Test
testRequestTimeForNextSatelliteVisibility()584     public void testRequestTimeForNextSatelliteVisibility() {
585         mSatelliteVisibilityTimeSemaphore.drainPermits();
586         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
587         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
588         mSatelliteControllerUT.requestTimeForNextSatelliteVisibility(SUB_ID,
589                 mSatelliteVisibilityTimeReceiver);
590         processAllMessages();
591         assertTrue(waitForRequestTimeForNextSatelliteVisibilityResult(1));
592         assertEquals(SATELLITE_RESULT_NOT_SUPPORTED, mQueriedSatelliteVisibilityTimeResultCode);
593 
594         resetSatelliteControllerUT();
595         mSatelliteControllerUT.requestTimeForNextSatelliteVisibility(SUB_ID,
596                 mSatelliteVisibilityTimeReceiver);
597         processAllMessages();
598         assertTrue(waitForRequestTimeForNextSatelliteVisibilityResult(1));
599         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
600                 mQueriedSatelliteVisibilityTimeResultCode);
601 
602         resetSatelliteControllerUT();
603         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
604         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
605         setUpResponseForRequestTimeForNextSatelliteVisibility(mSatelliteNextVisibilityTime,
606                 SATELLITE_RESULT_SUCCESS);
607         mSatelliteControllerUT.requestTimeForNextSatelliteVisibility(SUB_ID,
608                 mSatelliteVisibilityTimeReceiver);
609         processAllMessages();
610         assertTrue(waitForRequestTimeForNextSatelliteVisibilityResult(1));
611         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
612                 mQueriedSatelliteVisibilityTimeResultCode);
613 
614         resetSatelliteControllerUT();
615         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
616         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
617         setUpResponseForRequestIsSatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
618         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
619         setUpResponseForRequestTimeForNextSatelliteVisibility(mSatelliteNextVisibilityTime,
620                 SATELLITE_RESULT_SUCCESS);
621         mSatelliteControllerUT.requestTimeForNextSatelliteVisibility(SUB_ID,
622                 mSatelliteVisibilityTimeReceiver);
623         processAllMessages();
624         assertTrue(waitForRequestTimeForNextSatelliteVisibilityResult(1));
625         assertEquals(SATELLITE_RESULT_SERVICE_NOT_PROVISIONED,
626                 mQueriedSatelliteVisibilityTimeResultCode);
627 
628         resetSatelliteControllerUT();
629         provisionSatelliteService();
630         setUpResponseForRequestTimeForNextSatelliteVisibility(mSatelliteNextVisibilityTime,
631                 SATELLITE_RESULT_SUCCESS);
632         mSatelliteControllerUT.requestTimeForNextSatelliteVisibility(SUB_ID,
633                 mSatelliteVisibilityTimeReceiver);
634         processAllMessages();
635         assertTrue(waitForRequestTimeForNextSatelliteVisibilityResult(1));
636         assertEquals(SATELLITE_RESULT_SUCCESS, mQueriedSatelliteVisibilityTimeResultCode);
637         assertEquals(mSatelliteNextVisibilityTime, mQueriedSatelliteVisibilityTime);
638 
639         resetSatelliteControllerUT();
640         provisionSatelliteService();
641         setUpNullResponseForRequestTimeForNextSatelliteVisibility(
642                 SATELLITE_RESULT_SUCCESS);
643         mSatelliteControllerUT.requestTimeForNextSatelliteVisibility(SUB_ID,
644                 mSatelliteVisibilityTimeReceiver);
645         processAllMessages();
646         assertTrue(waitForRequestTimeForNextSatelliteVisibilityResult(1));
647         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
648                 mQueriedSatelliteVisibilityTimeResultCode);
649 
650         resetSatelliteControllerUT();
651         provisionSatelliteService();
652         setUpNullResponseForRequestTimeForNextSatelliteVisibility(
653                 SATELLITE_RESULT_INVALID_MODEM_STATE);
654         mSatelliteControllerUT.requestTimeForNextSatelliteVisibility(SUB_ID,
655                 mSatelliteVisibilityTimeReceiver);
656         processAllMessages();
657         assertTrue(waitForRequestTimeForNextSatelliteVisibilityResult(1));
658         assertEquals(SATELLITE_RESULT_INVALID_MODEM_STATE,
659                 mQueriedSatelliteVisibilityTimeResultCode);
660     }
661 
662     @Test
testRadioStateChanged()663     public void testRadioStateChanged() {
664         mIsSatelliteEnabledSemaphore.drainPermits();
665 
666         when(mMockSatelliteModemInterface.isSatelliteServiceConnected()).thenReturn(false);
667         setRadioPower(false);
668         processAllMessages();
669         verify(mMockSatelliteModemInterface, never())
670                 .requestIsSatelliteSupported(any(Message.class));
671 
672         setRadioPower(true);
673         processAllMessages();
674         verify(mMockSatelliteModemInterface, never())
675                 .requestIsSatelliteSupported(any(Message.class));
676 
677         when(mMockSatelliteModemInterface.isSatelliteServiceConnected()).thenReturn(true);
678         setRadioPower(false);
679         processAllMessages();
680         verify(mMockSatelliteModemInterface, times(1))
681                 .requestIsSatelliteSupported(any(Message.class));
682 
683         setRadioPower(true);
684         processAllMessages();
685         verify(mMockSatelliteModemInterface, times(2))
686                 .requestIsSatelliteSupported(any(Message.class));
687 
688         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
689         setRadioPower(false);
690         processAllMessages();
691         verify(mMockSatelliteModemInterface, times(3))
692                 .requestIsSatelliteSupported(any(Message.class));
693 
694         setRadioPower(true);
695         processAllMessages();
696         verify(mMockSatelliteModemInterface, times(4))
697                 .requestIsSatelliteSupported(any(Message.class));
698 
699         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
700         setRadioPower(false);
701         processAllMessages();
702         verify(mMockSatelliteModemInterface, times(5))
703                 .requestIsSatelliteSupported(any(Message.class));
704 
705         setRadioPower(true);
706         processAllMessages();
707         verify(mMockSatelliteModemInterface, times(5))
708                 .requestIsSatelliteSupported(any(Message.class));
709     }
710 
711     @Test
testRadioPowerOff()712     public void testRadioPowerOff() {
713         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
714         NetworkRegistrationInfo satelliteNri = new NetworkRegistrationInfo.Builder()
715                 .setIsNonTerrestrialNetwork(true)
716                 .setAvailableServices(List.of(NetworkRegistrationInfo.SERVICE_TYPE_DATA))
717                 .build();
718         mCarrierConfigBundle.putInt(KEY_SATELLITE_CONNECTION_HYSTERESIS_SEC_INT, 1 * 60);
719         mCarrierConfigBundle.putBoolean(KEY_SATELLITE_ATTACH_SUPPORTED_BOOL, true);
720         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
721                 : mCarrierConfigChangedListenerList) {
722             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
723                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
724             );
725         }
726         when(mServiceState.getNetworkRegistrationInfoList()).thenReturn(List.of(satelliteNri));
727         when(mServiceState.isUsingNonTerrestrialNetwork()).thenReturn(true);
728         sendServiceStateChangedEvent();
729         processAllMessages();
730         assertTrue(mSatelliteControllerUT.isInSatelliteModeForCarrierRoaming(mPhone));
731         assertEquals(List.of(SERVICE_TYPE_DATA),
732                 mSatelliteControllerUT.getCapabilitiesForCarrierRoamingSatelliteMode(mPhone));
733 
734         when(mServiceState.isUsingNonTerrestrialNetwork()).thenReturn(false);
735         setRadioPower(false);
736         processAllMessages();
737         assertFalse(mSatelliteControllerUT.isInSatelliteModeForCarrierRoaming(mPhone));
738         assertEquals(new ArrayList<>(),
739                 mSatelliteControllerUT.getCapabilitiesForCarrierRoamingSatelliteMode(mPhone));
740     }
741 
742     @Test
testRequestSatelliteEnabled()743     public void testRequestSatelliteEnabled() {
744         mIsSatelliteEnabledSemaphore.drainPermits();
745 
746         // Fail to enable satellite when SatelliteController is not fully loaded yet.
747         mIIntegerConsumerResults.clear();
748         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
749                 mIIntegerConsumer);
750         processAllMessages();
751         assertTrue(waitForIIntegerConsumerResult(1));
752         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
753                 (long) mIIntegerConsumerResults.get(0));
754 
755         // Fail to enable satellite when the device does not support satellite.
756         mIIntegerConsumerResults.clear();
757         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
758         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
759         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
760                 mIIntegerConsumer);
761         processAllMessages();
762         assertTrue(waitForIIntegerConsumerResult(1));
763         assertEquals(SATELLITE_RESULT_NOT_SUPPORTED, (long) mIIntegerConsumerResults.get(0));
764 
765         // Fail to enable satellite when the device is not provisioned yet.
766         mIIntegerConsumerResults.clear();
767         resetSatelliteControllerUT();
768         verify(mMockSatelliteSessionController, times(1)).onSatelliteEnabledStateChanged(eq(false));
769         verify(mMockSatelliteSessionController, times(1)).setDemoMode(eq(false));
770         verify(mMockDatagramController, times(1)).setDemoMode(eq(false));
771         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
772         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
773         setUpResponseForRequestIsSatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
774         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
775         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
776                 mIIntegerConsumer);
777         processAllMessages();
778         assertTrue(waitForIIntegerConsumerResult(1));
779         assertEquals(SATELLITE_RESULT_SERVICE_NOT_PROVISIONED,
780                 (long) mIIntegerConsumerResults.get(0));
781 
782         sendProvisionedStateChangedEvent(true, null);
783         processAllMessages();
784         verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
785 
786         // Successfully enable satellite
787         mIIntegerConsumerResults.clear();
788         mSatelliteControllerUT.setSettingsKeyForSatelliteModeCalled = false;
789         mSatelliteControllerUT.setSettingsKeyToAllowDeviceRotationCalled = false;
790         setUpResponseForRequestSatelliteEnabled(true, false, false, SATELLITE_RESULT_SUCCESS);
791         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
792                 mIIntegerConsumer);
793         mSatelliteControllerUT.setSatelliteSessionController(mMockSatelliteSessionController);
794         processAllMessages();
795         assertTrue(waitForIIntegerConsumerResult(1));
796         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
797         verifySatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
798         assertTrue(mSatelliteControllerUT.setSettingsKeyForSatelliteModeCalled);
799         assertTrue(mSatelliteControllerUT.setSettingsKeyToAllowDeviceRotationCalled);
800         assertEquals(
801                 SATELLITE_MODE_ENABLED_TRUE, mSatelliteControllerUT.satelliteModeSettingValue);
802         verify(mMockSatelliteSessionController, times(1)).onSatelliteEnabledStateChanged(eq(true));
803         verify(mMockSatelliteSessionController, times(2)).setDemoMode(eq(false));
804         verify(mMockDatagramController, times(2)).setDemoMode(eq(false));
805         verify(mMockControllerMetricsStats, times(1)).onSatelliteEnabled();
806         verify(mMockControllerMetricsStats, times(1)).reportServiceEnablementSuccessCount();
807 
808         // Successfully disable satellite when radio is turned off.
809         mSatelliteControllerUT.setSettingsKeyForSatelliteModeCalled = false;
810         mSatelliteControllerUT.setSettingsKeyToAllowDeviceRotationCalled = false;
811         setUpResponseForRequestSatelliteEnabled(false, false, false, SATELLITE_RESULT_SUCCESS);
812         setRadioPower(false);
813         mSatelliteControllerUT.onCellularRadioPowerOffRequested();
814         processAllMessages();
815         sendSatelliteModemStateChangedEvent(SATELLITE_MODEM_STATE_OFF, null);
816         processAllMessages();
817         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
818         assertTrue(mSatelliteControllerUT.setSettingsKeyForSatelliteModeCalled);
819         assertTrue(mSatelliteControllerUT.setSettingsKeyToAllowDeviceRotationCalled);
820         assertEquals(
821                 SATELLITE_MODE_ENABLED_FALSE, mSatelliteControllerUT.satelliteModeSettingValue);
822         verify(mMockSatelliteSessionController, times(2)).onSatelliteEnabledStateChanged(eq(false));
823         verify(mMockSatelliteSessionController, times(3)).setDemoMode(eq(false));
824         verify(mMockDatagramController, times(3)).setDemoMode(eq(false));
825         verify(mMockControllerMetricsStats, times(1)).onSatelliteDisabled();
826 
827         // Fail to enable satellite when radio is off.
828         mIIntegerConsumerResults.clear();
829         setUpResponseForRequestSatelliteEnabled(true, false, false, SATELLITE_RESULT_SUCCESS);
830         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
831                 mIIntegerConsumer);
832         processAllMessages();
833         assertTrue(waitForIIntegerConsumerResult(1));
834         // Radio is not on, can not enable satellite
835         assertEquals(SATELLITE_RESULT_INVALID_MODEM_STATE, (long) mIIntegerConsumerResults.get(0));
836 
837         setRadioPower(true);
838         processAllMessages();
839         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
840 
841         // Fail to enable satellite with an error response from modem when radio is on.
842         mIIntegerConsumerResults.clear();
843         clearInvocations(mMockPointingAppController);
844         mSatelliteControllerUT.setSettingsKeyForSatelliteModeCalled = false;
845         mSatelliteControllerUT.setSettingsKeyToAllowDeviceRotationCalled = false;
846         setUpResponseForRequestSatelliteEnabled(true, false, false,
847                 SATELLITE_RESULT_INVALID_MODEM_STATE);
848         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
849                 mIIntegerConsumer);
850         processAllMessages();
851         assertTrue(waitForIIntegerConsumerResult(1));
852         assertEquals(SATELLITE_RESULT_INVALID_MODEM_STATE, (long) mIIntegerConsumerResults.get(0));
853         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
854         verify(mMockPointingAppController, never()).startPointingUI(anyBoolean(), anyBoolean(),
855                 anyBoolean());
856         assertFalse(mSatelliteControllerUT.setSettingsKeyForSatelliteModeCalled);
857         assertFalse(mSatelliteControllerUT.setSettingsKeyToAllowDeviceRotationCalled);
858         verify(mMockControllerMetricsStats, times(1)).reportServiceEnablementFailCount();
859 
860         // Successfully enable satellite when radio is on.
861         mIIntegerConsumerResults.clear();
862         mSatelliteControllerUT.setSettingsKeyForSatelliteModeCalled = false;
863         mSatelliteControllerUT.setSettingsKeyToAllowDeviceRotationCalled = false;
864         setUpResponseForRequestSatelliteEnabled(true, false, false, SATELLITE_RESULT_SUCCESS);
865         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
866                 mIIntegerConsumer);
867         processAllMessages();
868         assertTrue(waitForIIntegerConsumerResult(1));
869         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
870         verifySatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
871         assertTrue(mSatelliteControllerUT.setSettingsKeyForSatelliteModeCalled);
872         assertTrue(mSatelliteControllerUT.setSettingsKeyToAllowDeviceRotationCalled);
873         assertEquals(SATELLITE_MODE_ENABLED_TRUE, mSatelliteControllerUT.satelliteModeSettingValue);
874         verify(mMockSatelliteSessionController, times(2)).onSatelliteEnabledStateChanged(eq(true));
875         verify(mMockSatelliteSessionController, times(4)).setDemoMode(eq(false));
876         verify(mMockDatagramController, times(4)).setDemoMode(eq(false));
877         verify(mMockControllerMetricsStats, times(2)).onSatelliteEnabled();
878         verify(mMockControllerMetricsStats, times(2)).reportServiceEnablementSuccessCount();
879 
880         // Successfully enable satellite when it is already enabled.
881         mIIntegerConsumerResults.clear();
882         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
883                 mIIntegerConsumer);
884         processAllMessages();
885         assertTrue(waitForIIntegerConsumerResult(1));
886         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
887         verifySatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
888 
889         // Fail to enable satellite with a different demo mode when it is already enabled.
890         mIIntegerConsumerResults.clear();
891         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, true, false,
892                 mIIntegerConsumer);
893         processAllMessages();
894         assertTrue(waitForIIntegerConsumerResult(1));
895         assertEquals(SATELLITE_RESULT_INVALID_ARGUMENTS, (long) mIIntegerConsumerResults.get(0));
896         verifySatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
897 
898         // Successfully disable satellite.
899         mIIntegerConsumerResults.clear();
900         setUpResponseForRequestSatelliteEnabled(false, false, false, SATELLITE_RESULT_SUCCESS);
901         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, false, false, false,
902                 mIIntegerConsumer);
903         processAllMessages();
904         assertTrue(waitForIIntegerConsumerResult(1));
905         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
906         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
907 
908         // Disable satellite when satellite is already disabled.
909         mIIntegerConsumerResults.clear();
910         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, false, false, false,
911                 mIIntegerConsumer);
912         processAllMessages();
913         assertTrue(waitForIIntegerConsumerResult(1));
914         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
915         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
916 
917         // Disable satellite with a different demo mode when satellite is already disabled.
918         mIIntegerConsumerResults.clear();
919         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, false, true, false,
920                 mIIntegerConsumer);
921         processAllMessages();
922         assertTrue(waitForIIntegerConsumerResult(1));
923         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
924         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
925 
926         // Send a second request while the first request in progress
927         mIIntegerConsumerResults.clear();
928         setUpNoResponseForRequestSatelliteEnabled(true, false, false);
929         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
930                 mIIntegerConsumer);
931         processAllMessages();
932         assertFalse(waitForIIntegerConsumerResult(1));
933         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
934                 mIIntegerConsumer);
935         processAllMessages();
936         assertTrue(waitForIIntegerConsumerResult(1));
937         assertEquals(SATELLITE_RESULT_REQUEST_IN_PROGRESS, (long) mIIntegerConsumerResults.get(0));
938 
939         mIIntegerConsumerResults.clear();
940         resetSatelliteControllerUTToSupportedAndProvisionedState();
941         // Should receive callback for the above request when satellite modem is turned off.
942         assertTrue(waitForIIntegerConsumerResult(1));
943         assertEquals(SATELLITE_RESULT_INVALID_MODEM_STATE, (long) mIIntegerConsumerResults.get(0));
944 
945         // Move to satellite-disabling in progress.
946         setUpNoResponseForRequestSatelliteEnabled(false, false, false);
947         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, false, false, false,
948                 mIIntegerConsumer);
949         processAllMessages();
950         assertFalse(waitForIIntegerConsumerResult(1));
951 
952         // Disable is in progress. Thus, a new request to enable satellite will be rejected.
953         mIIntegerConsumerResults.clear();
954         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
955                 mIIntegerConsumer);
956         processAllMessages();
957         assertTrue(waitForIIntegerConsumerResult(1));
958         assertEquals(SATELLITE_RESULT_ERROR, (long) mIIntegerConsumerResults.get(0));
959 
960         mIIntegerConsumerResults.clear();
961         resetSatelliteControllerUTToOffAndProvisionedState();
962         // Should receive callback for the above request when satellite modem is turned off.
963         assertTrue(waitForIIntegerConsumerResult(1));
964         assertEquals(SATELLITE_RESULT_INVALID_MODEM_STATE, (long) mIIntegerConsumerResults.get(0));
965 
966         verify(mMockSessionMetricsStats, times(15)).setInitializationResult(anyInt());
967         verify(mMockSessionMetricsStats, times(15)).setSatelliteTechnology(anyInt());
968         verify(mMockSessionMetricsStats, times(3)).setInitializationProcessingTime(anyLong());
969         verify(mMockSessionMetricsStats, times(2)).setTerminationResult(anyInt());
970         verify(mMockSessionMetricsStats, times(2)).setTerminationProcessingTime(anyLong());
971         verify(mMockSessionMetricsStats, times(2)).setSessionDurationSec(anyInt());
972         verify(mMockSessionMetricsStats, times(15)).reportSessionMetrics();
973 
974         /**
975          * Make areAllRadiosDisabled return false and move mWaitingForRadioDisabled to true, which
976          * will lead to no response for requestSatelliteEnabled.
977          */
978         mSatelliteControllerUT.allRadiosDisabled = false;
979         setUpResponseForRequestSatelliteEnabled(true, false, false, SATELLITE_RESULT_SUCCESS);
980         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
981                 mIIntegerConsumer);
982         processAllMessages();
983         assertFalse(waitForIIntegerConsumerResult(1));
984 
985         resetSatelliteControllerUTEnabledState();
986         mIIntegerConsumerResults.clear();
987         setUpResponseForRequestSatelliteEnabled(false, false, false, SATELLITE_RESULT_SUCCESS);
988         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, false, false, false,
989                 mIIntegerConsumer);
990         processAllMessages();
991         // We should receive 2 callbacks for the above 2 requests.
992         assertTrue(waitForIIntegerConsumerResult(2));
993         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
994         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(1));
995 
996         resetSatelliteControllerUTToOffAndProvisionedState();
997 
998         // Repeat the same test as above but with error response from modem for the second request
999         mSatelliteControllerUT.allRadiosDisabled = false;
1000         setUpResponseForRequestSatelliteEnabled(true, false, false, SATELLITE_RESULT_SUCCESS);
1001         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
1002                 mIIntegerConsumer);
1003         processAllMessages();
1004         assertFalse(waitForIIntegerConsumerResult(1));
1005 
1006         resetSatelliteControllerUTEnabledState();
1007         mIIntegerConsumerResults.clear();
1008         setUpResponseForRequestSatelliteEnabled(false, false, false, SATELLITE_RESULT_NO_RESOURCES);
1009         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, false, false, false,
1010                 mIIntegerConsumer);
1011         processAllMessages();
1012         // We should receive 2 callbacks for the above 2 requests.
1013         assertTrue(waitForIIntegerConsumerResult(2));
1014         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
1015         assertEquals(SATELLITE_RESULT_NO_RESOURCES, (long) mIIntegerConsumerResults.get(1));
1016         mSatelliteControllerUT.allRadiosDisabled = true;
1017 
1018         resetSatelliteControllerUTToOnAndProvisionedState();
1019         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(false);
1020         mSatelliteControllerUT.onCellularRadioPowerOffRequested();
1021         processAllMessages();
1022         // Satellite should not be powered off since the feature flag oemEnabledSatelliteFlag is
1023         // disabled
1024         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(true);
1025         verifySatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
1026     }
1027 
1028     @Test
testRequestSatelliteCapabilities()1029     public void testRequestSatelliteCapabilities() {
1030         mSatelliteCapabilitiesSemaphore.drainPermits();
1031         mSatelliteControllerUT.requestSatelliteCapabilities(SUB_ID, mSatelliteCapabilitiesReceiver);
1032         processAllMessages();
1033         assertTrue(waitForRequestSatelliteCapabilitiesResult(1));
1034         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1035                 mQueriedSatelliteCapabilitiesResultCode);
1036 
1037         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1038         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1039         mSatelliteControllerUT.requestSatelliteCapabilities(SUB_ID, mSatelliteCapabilitiesReceiver);
1040         processAllMessages();
1041         assertTrue(waitForRequestSatelliteCapabilitiesResult(1));
1042         assertEquals(SATELLITE_RESULT_NOT_SUPPORTED, mQueriedSatelliteCapabilitiesResultCode);
1043 
1044         resetSatelliteControllerUT();
1045         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1046         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1047         setUpResponseForRequestSatelliteCapabilities(mSatelliteCapabilities,
1048                 SATELLITE_RESULT_SUCCESS);
1049         mSatelliteControllerUT.requestSatelliteCapabilities(SUB_ID, mSatelliteCapabilitiesReceiver);
1050         processAllMessages();
1051         assertTrue(waitForRequestSatelliteCapabilitiesResult(1));
1052         assertEquals(SATELLITE_RESULT_SUCCESS, mQueriedSatelliteCapabilitiesResultCode);
1053         assertEquals(mSatelliteCapabilities, mQueriedSatelliteCapabilities);
1054         assertTrue(
1055                 mQueriedSatelliteCapabilities.getSupportedRadioTechnologies().contains(
1056                         mSatelliteControllerUT.getSupportedNtnRadioTechnology()));
1057 
1058         resetSatelliteControllerUT();
1059         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1060         setUpNullResponseForRequestSatelliteCapabilities(SATELLITE_RESULT_SUCCESS);
1061         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1062         mSatelliteControllerUT.requestSatelliteCapabilities(SUB_ID, mSatelliteCapabilitiesReceiver);
1063         processAllMessages();
1064         assertTrue(waitForRequestSatelliteCapabilitiesResult(1));
1065         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1066                 mQueriedSatelliteCapabilitiesResultCode);
1067 
1068         resetSatelliteControllerUT();
1069         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1070         setUpNullResponseForRequestSatelliteCapabilities(SATELLITE_RESULT_INVALID_MODEM_STATE);
1071         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1072         mSatelliteControllerUT.requestSatelliteCapabilities(SUB_ID, mSatelliteCapabilitiesReceiver);
1073         processAllMessages();
1074         assertTrue(waitForRequestSatelliteCapabilitiesResult(1));
1075         assertEquals(SATELLITE_RESULT_INVALID_MODEM_STATE, mQueriedSatelliteCapabilitiesResultCode);
1076     }
1077 
1078     @Test
testStartSatelliteTransmissionUpdates()1079     public void testStartSatelliteTransmissionUpdates() {
1080         mIIntegerConsumerSemaphore.drainPermits();
1081         mIIntegerConsumerResults.clear();
1082         mSatelliteControllerUT.startSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
1083                 mStartTransmissionUpdateCallback);
1084         processAllMessages();
1085         assertTrue(waitForIIntegerConsumerResult(1));
1086         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1087                 (long) mIIntegerConsumerResults.get(0));
1088 
1089         mIIntegerConsumerResults.clear();
1090         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1091         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1092         mSatelliteControllerUT.startSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
1093                 mStartTransmissionUpdateCallback);
1094         processAllMessages();
1095         assertTrue(waitForIIntegerConsumerResult(1));
1096         assertEquals(SATELLITE_RESULT_NOT_SUPPORTED, (long) mIIntegerConsumerResults.get(0));
1097 
1098         resetSatelliteControllerUT();
1099         mIIntegerConsumerResults.clear();
1100         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1101         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1102         mSatelliteControllerUT.startSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
1103                 mStartTransmissionUpdateCallback);
1104         processAllMessages();
1105         assertTrue(waitForIIntegerConsumerResult(1));
1106         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1107                 (long) mIIntegerConsumerResults.get(0));
1108 
1109         resetSatelliteControllerUT();
1110         mIIntegerConsumerResults.clear();
1111         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1112         setUpResponseForRequestIsSatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1113         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1114         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1115         setUpResponseForStartSatelliteTransmissionUpdates(SATELLITE_RESULT_SUCCESS);
1116         mSatelliteControllerUT.startSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
1117                 mStartTransmissionUpdateCallback);
1118         processAllMessages();
1119         assertTrue(waitForIIntegerConsumerResult(1));
1120         assertEquals(SATELLITE_RESULT_SERVICE_NOT_PROVISIONED,
1121                 (long) mIIntegerConsumerResults.get(0));
1122 
1123         resetSatelliteControllerUT();
1124         provisionSatelliteService();
1125         mIIntegerConsumerResults.clear();
1126         setUpResponseForStartSatelliteTransmissionUpdates(SATELLITE_RESULT_SUCCESS);
1127         mSatelliteControllerUT.startSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
1128                 mStartTransmissionUpdateCallback);
1129         verify(mMockPointingAppController).registerForSatelliteTransmissionUpdates(anyInt(),
1130                 eq(mStartTransmissionUpdateCallback));
1131         processAllMessages();
1132         assertTrue(waitForIIntegerConsumerResult(1));
1133         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
1134         verify(mMockPointingAppController).startSatelliteTransmissionUpdates(any(Message.class));
1135         verify(mMockPointingAppController).setStartedSatelliteTransmissionUpdates(eq(true));
1136 
1137         resetSatelliteControllerUT();
1138         provisionSatelliteService();
1139         mIIntegerConsumerResults.clear();
1140         setUpResponseForStartSatelliteTransmissionUpdates(SATELLITE_RESULT_INVALID_TELEPHONY_STATE);
1141         mSatelliteControllerUT.startSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
1142                 mStartTransmissionUpdateCallback);
1143         processAllMessages();
1144         assertTrue(waitForIIntegerConsumerResult(1));
1145         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1146                 (long) mIIntegerConsumerResults.get(0));
1147         verify(mMockPointingAppController).unregisterForSatelliteTransmissionUpdates(anyInt(),
1148                 any(), eq(mStartTransmissionUpdateCallback));
1149         verify(mMockPointingAppController).setStartedSatelliteTransmissionUpdates(eq(false));
1150     }
1151 
1152     @Test
testStopSatelliteTransmissionUpdates()1153     public void testStopSatelliteTransmissionUpdates() {
1154         mIIntegerConsumerSemaphore.drainPermits();
1155         mIIntegerConsumerResults.clear();
1156         mSatelliteControllerUT.stopSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
1157                 mStopTransmissionUpdateCallback);
1158         processAllMessages();
1159         assertTrue(waitForIIntegerConsumerResult(1));
1160         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1161                 (long) mIIntegerConsumerResults.get(0));
1162 
1163         mIIntegerConsumerResults.clear();
1164         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1165         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1166         mSatelliteControllerUT.stopSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
1167                 mStopTransmissionUpdateCallback);
1168         processAllMessages();
1169         assertTrue(waitForIIntegerConsumerResult(1));
1170         assertEquals(SATELLITE_RESULT_NOT_SUPPORTED, (long) mIIntegerConsumerResults.get(0));
1171 
1172         resetSatelliteControllerUT();
1173         mIIntegerConsumerResults.clear();
1174         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1175         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1176         mSatelliteControllerUT.stopSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
1177                 mStopTransmissionUpdateCallback);
1178         processAllMessages();
1179         assertTrue(waitForIIntegerConsumerResult(1));
1180         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1181                 (long) mIIntegerConsumerResults.get(0));
1182 
1183         resetSatelliteControllerUT();
1184         mIIntegerConsumerResults.clear();
1185         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1186         setUpResponseForRequestIsSatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1187         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1188         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1189         setUpResponseForStopSatelliteTransmissionUpdates(SATELLITE_RESULT_SUCCESS);
1190         mSatelliteControllerUT.stopSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
1191                 mStopTransmissionUpdateCallback);
1192         processAllMessages();
1193         assertTrue(waitForIIntegerConsumerResult(1));
1194         assertEquals(SATELLITE_RESULT_SERVICE_NOT_PROVISIONED,
1195                 (long) mIIntegerConsumerResults.get(0));
1196 
1197         resetSatelliteControllerUT();
1198         mIIntegerConsumerResults.clear();
1199         provisionSatelliteService();
1200         setUpResponseForStopSatelliteTransmissionUpdates(SATELLITE_RESULT_SUCCESS);
1201         mSatelliteControllerUT.stopSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
1202                 mStopTransmissionUpdateCallback);
1203         verify(mMockPointingAppController).unregisterForSatelliteTransmissionUpdates(anyInt(),
1204                 any(), eq(mStopTransmissionUpdateCallback));
1205         processAllMessages();
1206         assertTrue(waitForIIntegerConsumerResult(1));
1207         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
1208         verify(mMockPointingAppController).stopSatelliteTransmissionUpdates(any(Message.class));
1209 
1210         resetSatelliteControllerUT();
1211         provisionSatelliteService();
1212         mIIntegerConsumerResults.clear();
1213         setUpResponseForStopSatelliteTransmissionUpdates(SATELLITE_RESULT_INVALID_TELEPHONY_STATE);
1214         mSatelliteControllerUT.stopSatelliteTransmissionUpdates(SUB_ID, mIIntegerConsumer,
1215                 mStopTransmissionUpdateCallback);
1216         processAllMessages();
1217         assertTrue(waitForIIntegerConsumerResult(1));
1218         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1219                 (long) mIIntegerConsumerResults.get(0));
1220     }
1221 
1222     @Test
testRequestIsDemoModeEnabled()1223     public void testRequestIsDemoModeEnabled() {
1224         mIsDemoModeEnabledSemaphore.drainPermits();
1225         resetSatelliteControllerUT();
1226         mSatelliteControllerUT.requestIsDemoModeEnabled(SUB_ID, mIsDemoModeEnabledReceiver);
1227         assertTrue(waitForRequestIsDemoModeEnabledResult(1));
1228         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE, mQueriedIsDemoModeEnabledResultCode);
1229         assertFalse(mQueriedIsDemoModeEnabled);
1230 
1231         resetSatelliteControllerUT();
1232         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1233         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1234         mSatelliteControllerUT.requestIsDemoModeEnabled(SUB_ID, mIsDemoModeEnabledReceiver);
1235         assertTrue(waitForRequestIsDemoModeEnabledResult(1));
1236         assertEquals(SATELLITE_RESULT_NOT_SUPPORTED, mQueriedIsDemoModeEnabledResultCode);
1237         assertFalse(mQueriedIsDemoModeEnabled);
1238 
1239         resetSatelliteControllerUT();
1240         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1241         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1242         mSatelliteControllerUT.requestIsDemoModeEnabled(SUB_ID, mIsDemoModeEnabledReceiver);
1243         assertTrue(waitForRequestIsDemoModeEnabledResult(1));
1244         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE, mQueriedIsDemoModeEnabledResultCode);
1245         assertFalse(mQueriedIsDemoModeEnabled);
1246 
1247         resetSatelliteControllerUT();
1248         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1249         setUpResponseForRequestIsSatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1250         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1251         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1252         mSatelliteControllerUT.requestIsDemoModeEnabled(SUB_ID, mIsDemoModeEnabledReceiver);
1253         assertTrue(waitForRequestIsDemoModeEnabledResult(1));
1254         assertEquals(SATELLITE_RESULT_SERVICE_NOT_PROVISIONED, mQueriedIsDemoModeEnabledResultCode);
1255         assertFalse(mQueriedIsDemoModeEnabled);
1256 
1257         resetSatelliteControllerUT();
1258         boolean isDemoModeEnabled = mSatelliteControllerUT.isDemoModeEnabled();
1259         provisionSatelliteService();
1260         mSatelliteControllerUT.requestIsDemoModeEnabled(SUB_ID, mIsDemoModeEnabledReceiver);
1261         assertTrue(waitForRequestIsDemoModeEnabledResult(1));
1262         assertEquals(SATELLITE_RESULT_SUCCESS, mQueriedIsDemoModeEnabledResultCode);
1263         assertEquals(isDemoModeEnabled, mQueriedIsDemoModeEnabled);
1264     }
1265 
1266     @Test
testIsSatelliteEnabled()1267     public void testIsSatelliteEnabled() {
1268         setUpResponseForRequestIsSatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
1269         assertFalse(mSatelliteControllerUT.isSatelliteEnabled());
1270         mIsSatelliteEnabledSemaphore.drainPermits();
1271         mSatelliteControllerUT.requestIsSatelliteEnabled(SUB_ID, mIsSatelliteEnabledReceiver);
1272         processAllMessages();
1273         assertTrue(waitForRequestIsSatelliteEnabledResult(1));
1274         assertEquals(
1275                 SATELLITE_RESULT_INVALID_TELEPHONY_STATE, mQueriedIsSatelliteEnabledResultCode);
1276 
1277 
1278         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1279         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1280         mSatelliteControllerUT.requestIsSatelliteEnabled(SUB_ID, mIsSatelliteEnabledReceiver);
1281         processAllMessages();
1282         assertEquals(SATELLITE_RESULT_SUCCESS, mQueriedIsSatelliteEnabledResultCode);
1283         assertEquals(mSatelliteControllerUT.isSatelliteEnabled(), mQueriedIsSatelliteEnabled);
1284     }
1285 
1286     @Test
testOnSatelliteServiceConnected()1287     public void testOnSatelliteServiceConnected() {
1288         verifySatelliteSupported(false, SATELLITE_RESULT_RADIO_NOT_AVAILABLE);
1289         verifySatelliteEnabled(false, SATELLITE_RESULT_INVALID_TELEPHONY_STATE);
1290         verifySatelliteProvisioned(false, SATELLITE_RESULT_INVALID_TELEPHONY_STATE);
1291 
1292         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1293         setUpResponseForRequestIsSatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
1294         setUpResponseForRequestSatelliteEnabled(false, false, false, SATELLITE_RESULT_SUCCESS);
1295 
1296         setUpResponseForRequestIsSatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
1297         mSatelliteControllerUT.onSatelliteServiceConnected();
1298         processAllMessages();
1299 
1300         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1301         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
1302         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1303     }
1304 
1305     @Test
testRegisterForSatelliteModemStateChanged()1306     public void testRegisterForSatelliteModemStateChanged() {
1307         ISatelliteModemStateCallback callback = new ISatelliteModemStateCallback.Stub() {
1308             @Override
1309             public void onSatelliteModemStateChanged(int state) {
1310                 logd("onSatelliteModemStateChanged: state=" + state);
1311             }
1312         };
1313         int errorCode = mSatelliteControllerUT.registerForSatelliteModemStateChanged(
1314                 SUB_ID, callback);
1315         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE, errorCode);
1316         verify(mMockSatelliteSessionController, never())
1317                 .registerForSatelliteModemStateChanged(callback);
1318 
1319         resetSatelliteControllerUTToSupportedAndProvisionedState();
1320         mSatelliteControllerUT.setSatelliteSessionController(mMockSatelliteSessionController);
1321 
1322         errorCode = mSatelliteControllerUT.registerForSatelliteModemStateChanged(
1323                 SUB_ID, callback);
1324         assertEquals(SATELLITE_RESULT_SUCCESS, errorCode);
1325         verify(mMockSatelliteSessionController).registerForSatelliteModemStateChanged(callback);
1326     }
1327 
1328     @Test
testUnregisterForSatelliteModemStateChanged()1329     public void testUnregisterForSatelliteModemStateChanged() {
1330         ISatelliteModemStateCallback callback = new ISatelliteModemStateCallback.Stub() {
1331             @Override
1332             public void onSatelliteModemStateChanged(int state) {
1333                 logd("onSatelliteModemStateChanged: state=" + state);
1334             }
1335         };
1336         mSatelliteControllerUT.unregisterForModemStateChanged(SUB_ID, callback);
1337         verify(mMockSatelliteSessionController, never())
1338                 .unregisterForSatelliteModemStateChanged(callback);
1339 
1340         resetSatelliteControllerUTToSupportedAndProvisionedState();
1341         mSatelliteControllerUT.setSatelliteSessionController(mMockSatelliteSessionController);
1342         mSatelliteControllerUT.unregisterForModemStateChanged(SUB_ID, callback);
1343         verify(mMockSatelliteSessionController).unregisterForSatelliteModemStateChanged(callback);
1344     }
1345 
1346     @Test
testRegisterForSatelliteProvisionStateChanged()1347     public void testRegisterForSatelliteProvisionStateChanged() {
1348         Semaphore semaphore = new Semaphore(0);
1349         ISatelliteProvisionStateCallback callback =
1350                 new ISatelliteProvisionStateCallback.Stub() {
1351                     @Override
1352                     public void onSatelliteProvisionStateChanged(boolean provisioned) {
1353                         logd("onSatelliteProvisionStateChanged: provisioned=" + provisioned);
1354                         try {
1355                             semaphore.release();
1356                         } catch (Exception ex) {
1357                             loge("onSatelliteProvisionStateChanged: Got exception in releasing "
1358                                     + "semaphore, ex=" + ex);
1359                         }
1360                     }
1361                 };
1362         int errorCode = mSatelliteControllerUT.registerForSatelliteProvisionStateChanged(
1363                 SUB_ID, callback);
1364         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE, errorCode);
1365 
1366         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1367         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1368         errorCode = mSatelliteControllerUT.registerForSatelliteProvisionStateChanged(
1369                 SUB_ID, callback);
1370         assertEquals(SATELLITE_RESULT_NOT_SUPPORTED, errorCode);
1371 
1372         resetSatelliteControllerUT();
1373         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1374         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1375         errorCode = mSatelliteControllerUT.registerForSatelliteProvisionStateChanged(
1376                 SUB_ID, callback);
1377         assertEquals(SATELLITE_RESULT_SUCCESS, errorCode);
1378 
1379         sendProvisionedStateChangedEvent(true, null);
1380         processAllMessages();
1381         assertTrue(waitForForEvents(
1382                 semaphore, 1, "testRegisterForSatelliteProvisionStateChanged"));
1383 
1384         mSatelliteControllerUT.unregisterForSatelliteProvisionStateChanged(SUB_ID, callback);
1385         sendProvisionedStateChangedEvent(true, null);
1386         processAllMessages();
1387         assertFalse(waitForForEvents(
1388                 semaphore, 1, "testRegisterForSatelliteProvisionStateChanged"));
1389     }
1390 
1391     @Test
testRegisterForSatelliteDatagram()1392     public void testRegisterForSatelliteDatagram() {
1393         ISatelliteDatagramCallback callback =
1394                 new ISatelliteDatagramCallback.Stub() {
1395                     @Override
1396                     public void onSatelliteDatagramReceived(long datagramId,
1397                             @NonNull SatelliteDatagram datagram, int pendingCount,
1398                             @NonNull IVoidConsumer internalAck) {
1399                         logd("onSatelliteDatagramReceived");
1400                     }
1401                 };
1402         when(mMockDatagramController.registerForSatelliteDatagram(eq(SUB_ID), eq(callback)))
1403                 .thenReturn(SATELLITE_RESULT_SUCCESS);
1404         int errorCode = mSatelliteControllerUT.registerForIncomingDatagram(SUB_ID, callback);
1405         assertEquals(SATELLITE_RESULT_SUCCESS, errorCode);
1406         verify(mMockDatagramController).registerForSatelliteDatagram(eq(SUB_ID), eq(callback));
1407     }
1408 
1409     @Test
testUnregisterForSatelliteDatagram()1410     public void testUnregisterForSatelliteDatagram() {
1411         ISatelliteDatagramCallback callback =
1412                 new ISatelliteDatagramCallback.Stub() {
1413                     @Override
1414                     public void onSatelliteDatagramReceived(long datagramId,
1415                             @NonNull SatelliteDatagram datagram, int pendingCount,
1416                             @NonNull IVoidConsumer internalAck) {
1417                         logd("onSatelliteDatagramReceived");
1418                     }
1419                 };
1420         doNothing().when(mMockDatagramController)
1421                 .unregisterForSatelliteDatagram(eq(SUB_ID), eq(callback));
1422         mSatelliteControllerUT.unregisterForIncomingDatagram(SUB_ID, callback);
1423         verify(mMockDatagramController).unregisterForSatelliteDatagram(eq(SUB_ID), eq(callback));
1424     }
1425 
1426     @Test
testSendSatelliteDatagram()1427     public void testSendSatelliteDatagram() {
1428         String mText = "This is a test datagram message from user";
1429         SatelliteDatagram datagram = new SatelliteDatagram(mText.getBytes());
1430 
1431         int[] sosDatagramTypes = {SatelliteManager.DATAGRAM_TYPE_SOS_MESSAGE,
1432                 SatelliteManager.DATAGRAM_TYPE_LAST_SOS_MESSAGE_STILL_NEED_HELP,
1433                 SatelliteManager.DATAGRAM_TYPE_LAST_SOS_MESSAGE_NO_HELP_NEEDED};
1434         for (int datagramType : sosDatagramTypes) {
1435             mSatelliteControllerUT =
1436                     new TestSatelliteController(mContext, Looper.myLooper(), mFeatureFlags);
1437             mIIntegerConsumerSemaphore.drainPermits();
1438             mIIntegerConsumerResults.clear();
1439             clearInvocations(mMockDatagramController);
1440             clearInvocations(mMockPointingAppController);
1441 
1442             mSatelliteControllerUT.sendDatagram(SUB_ID, datagramType, datagram, true,
1443                     mIIntegerConsumer);
1444             processAllMessages();
1445             assertTrue(waitForIIntegerConsumerResult(1));
1446             assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1447                     (long) mIIntegerConsumerResults.get(0));
1448             verify(mMockDatagramController, never()).sendSatelliteDatagram(anyInt(),
1449                     eq(datagramType), eq(datagram), eq(true), any());
1450 
1451             mIIntegerConsumerResults.clear();
1452             setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1453             verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1454             sendProvisionedStateChangedEvent(false, null);
1455             processAllMessages();
1456             verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1457             mSatelliteControllerUT.sendDatagram(SUB_ID, datagramType, datagram, true,
1458                     mIIntegerConsumer);
1459             processAllMessages();
1460             assertTrue(waitForIIntegerConsumerResult(1));
1461             assertEquals(SATELLITE_RESULT_SERVICE_NOT_PROVISIONED,
1462                     (long) mIIntegerConsumerResults.get(0));
1463             verify(mMockDatagramController, never()).sendSatelliteDatagram(anyInt(),
1464                     eq(datagramType), eq(datagram), eq(true), any());
1465 
1466             mIIntegerConsumerResults.clear();
1467             sendProvisionedStateChangedEvent(true, null);
1468             processAllMessages();
1469             verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
1470             mSatelliteControllerUT.sendDatagram(SUB_ID, datagramType, datagram, true,
1471                     mIIntegerConsumer);
1472             processAllMessages();
1473             assertFalse(waitForIIntegerConsumerResult(1));
1474             verify(mMockDatagramController, times(1)).sendSatelliteDatagram(anyInt(),
1475                     eq(datagramType), eq(datagram), eq(true), any());
1476             verify(mMockPointingAppController, times(1)).startPointingUI(eq(true), anyBoolean(),
1477                     anyBoolean());
1478         }
1479     }
1480 
1481     @Test
testPollPendingSatelliteDatagrams()1482     public void testPollPendingSatelliteDatagrams() {
1483         mIIntegerConsumerResults.clear();
1484         mSatelliteControllerUT.pollPendingDatagrams(SUB_ID, mIIntegerConsumer);
1485         processAllMessages();
1486         assertTrue(waitForIIntegerConsumerResult(1));
1487         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1488                 (long) mIIntegerConsumerResults.get(0));
1489         verify(mMockDatagramController, never()).pollPendingSatelliteDatagrams(anyInt(), any());
1490 
1491         mIIntegerConsumerResults.clear();
1492         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1493         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1494         sendProvisionedStateChangedEvent(false, null);
1495         processAllMessages();
1496         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1497         mSatelliteControllerUT.pollPendingDatagrams(SUB_ID, mIIntegerConsumer);
1498         processAllMessages();
1499         assertTrue(waitForIIntegerConsumerResult(1));
1500         assertEquals(SATELLITE_RESULT_SERVICE_NOT_PROVISIONED,
1501                 (long) mIIntegerConsumerResults.get(0));
1502         verify(mMockDatagramController, never()).pollPendingSatelliteDatagrams(anyInt(), any());
1503 
1504         mIIntegerConsumerResults.clear();
1505         sendProvisionedStateChangedEvent(true, null);
1506         processAllMessages();
1507         verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
1508         mSatelliteControllerUT.pollPendingDatagrams(SUB_ID, mIIntegerConsumer);
1509         processAllMessages();
1510         assertFalse(waitForIIntegerConsumerResult(1));
1511         verify(mMockDatagramController, times(1)).pollPendingSatelliteDatagrams(anyInt(), any());
1512     }
1513 
1514     @Test
testProvisionSatelliteService()1515     public void testProvisionSatelliteService() {
1516         String mText = "This is test provision data.";
1517         byte[] testProvisionData = mText.getBytes();
1518         CancellationSignal cancellationSignal = new CancellationSignal();
1519         ICancellationSignal cancelRemote = null;
1520         mIIntegerConsumerResults.clear();
1521         cancelRemote = mSatelliteControllerUT.provisionSatelliteService(SUB_ID,
1522                 TEST_SATELLITE_TOKEN,
1523                 testProvisionData, mIIntegerConsumer);
1524         processAllMessages();
1525         assertTrue(waitForIIntegerConsumerResult(1));
1526         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1527                 (long) mIIntegerConsumerResults.get(0));
1528         assertNull(cancelRemote);
1529 
1530         resetSatelliteControllerUT();
1531         mIIntegerConsumerResults.clear();
1532         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1533         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1534         cancelRemote = mSatelliteControllerUT.provisionSatelliteService(SUB_ID,
1535                 TEST_SATELLITE_TOKEN,
1536                 testProvisionData, mIIntegerConsumer);
1537         processAllMessages();
1538         assertTrue(waitForIIntegerConsumerResult(1));
1539         assertEquals(SATELLITE_RESULT_NOT_SUPPORTED, (long) mIIntegerConsumerResults.get(0));
1540         assertNull(cancelRemote);
1541 
1542         resetSatelliteControllerUT();
1543         mIIntegerConsumerResults.clear();
1544         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1545         setUpResponseForRequestIsSatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1546         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1547         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1548         setUpResponseForProvisionSatelliteService(TEST_SATELLITE_TOKEN, testProvisionData,
1549                 SATELLITE_RESULT_SUCCESS);
1550         cancelRemote = mSatelliteControllerUT.provisionSatelliteService(SUB_ID,
1551                 TEST_SATELLITE_TOKEN,
1552                 testProvisionData, mIIntegerConsumer);
1553         processAllMessages();
1554         assertTrue(waitForIIntegerConsumerResult(1));
1555         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
1556         assertNotNull(cancelRemote);
1557         verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
1558 
1559         // Send provision request again after the device is successfully provisioned
1560         cancelRemote = mSatelliteControllerUT.provisionSatelliteService(SUB_ID,
1561                 TEST_SATELLITE_TOKEN,
1562                 testProvisionData, mIIntegerConsumer);
1563         processAllMessages();
1564         assertTrue(waitForIIntegerConsumerResult(1));
1565         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
1566         assertNull(cancelRemote);
1567 
1568         // Vendor service does not support the request requestIsSatelliteProvisioned. Telephony will
1569         // make decision itself
1570         resetSatelliteControllerUT();
1571         mIIntegerConsumerResults.clear();
1572         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1573         setUpResponseForRequestIsSatelliteProvisioned(
1574                 false, SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
1575         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1576         verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
1577 
1578         // Vendor service does not support the requests requestIsSatelliteProvisioned and
1579         // provisionSatelliteService. Telephony will make decision itself
1580         deprovisionSatelliteService();
1581         resetSatelliteControllerUT();
1582         mIIntegerConsumerResults.clear();
1583         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1584         setUpResponseForRequestIsSatelliteProvisioned(
1585                 false, SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
1586         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1587         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1588         setUpResponseForProvisionSatelliteService(TEST_SATELLITE_TOKEN, testProvisionData,
1589                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
1590         cancelRemote = mSatelliteControllerUT.provisionSatelliteService(SUB_ID,
1591                 TEST_SATELLITE_TOKEN,
1592                 testProvisionData, mIIntegerConsumer);
1593         processAllMessages();
1594         assertTrue(waitForIIntegerConsumerResult(1));
1595         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
1596         assertNotNull(cancelRemote);
1597         verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
1598 
1599         resetSatelliteControllerUT();
1600         mIIntegerConsumerResults.clear();
1601         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1602         setUpResponseForRequestIsSatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1603         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1604         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1605         setUpResponseForProvisionSatelliteService(TEST_SATELLITE_TOKEN, testProvisionData,
1606                 SATELLITE_RESULT_NOT_AUTHORIZED);
1607         cancelRemote = mSatelliteControllerUT.provisionSatelliteService(SUB_ID,
1608                 TEST_SATELLITE_TOKEN,
1609                 testProvisionData, mIIntegerConsumer);
1610         processAllMessages();
1611         assertTrue(waitForIIntegerConsumerResult(1));
1612         assertEquals(SATELLITE_RESULT_NOT_AUTHORIZED, (long) mIIntegerConsumerResults.get(0));
1613         assertNotNull(cancelRemote);
1614 
1615         resetSatelliteControllerUT();
1616         mIIntegerConsumerResults.clear();
1617         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1618         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1619         setUpResponseForRequestIsSatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1620         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1621         setUpResponseForProvisionSatelliteService(TEST_NEXT_SATELLITE_TOKEN, testProvisionData,
1622                 SATELLITE_RESULT_SUCCESS);
1623         cancelRemote = mSatelliteControllerUT.provisionSatelliteService(SUB_ID,
1624                 TEST_NEXT_SATELLITE_TOKEN, testProvisionData, mIIntegerConsumer);
1625         cancellationSignal.setRemote(cancelRemote);
1626         cancellationSignal.cancel();
1627         processAllMessages();
1628         assertTrue(waitForIIntegerConsumerResult(1));
1629         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
1630         verify(mMockSatelliteModemInterface).deprovisionSatelliteService(
1631                 eq(TEST_NEXT_SATELLITE_TOKEN), any(Message.class));
1632 
1633         resetSatelliteControllerUT();
1634         mIIntegerConsumerResults.clear();
1635         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1636         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1637         setUpResponseForRequestIsSatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1638         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1639         setUpNoResponseForProvisionSatelliteService(TEST_SATELLITE_TOKEN);
1640         setUpResponseForProvisionSatelliteService(TEST_NEXT_SATELLITE_TOKEN, testProvisionData,
1641                 SATELLITE_RESULT_SUCCESS);
1642         cancelRemote = mSatelliteControllerUT.provisionSatelliteService(SUB_ID,
1643                 TEST_SATELLITE_TOKEN,
1644                 testProvisionData, mIIntegerConsumer);
1645         cancelRemote = mSatelliteControllerUT.provisionSatelliteService(SUB_ID,
1646                 TEST_NEXT_SATELLITE_TOKEN,
1647                 testProvisionData, mIIntegerConsumer);
1648         processAllMessages();
1649         assertTrue(waitForIIntegerConsumerResult(1));
1650         assertEquals(SATELLITE_RESULT_SERVICE_PROVISION_IN_PROGRESS,
1651                 (long) mIIntegerConsumerResults.get(0));
1652     }
1653 
1654     @Test
testDeprovisionSatelliteService()1655     public void testDeprovisionSatelliteService() {
1656         mIIntegerConsumerSemaphore.drainPermits();
1657         mIIntegerConsumerResults.clear();
1658         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1659         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
1660         mSatelliteControllerUT.deprovisionSatelliteService(SUB_ID,
1661                 TEST_SATELLITE_TOKEN, mIIntegerConsumer);
1662         processAllMessages();
1663         assertTrue(waitForIIntegerConsumerResult(1));
1664         assertEquals(SATELLITE_RESULT_NOT_SUPPORTED, (long) mIIntegerConsumerResults.get(0));
1665 
1666         resetSatelliteControllerUT();
1667         mIIntegerConsumerResults.clear();
1668         mSatelliteControllerUT.deprovisionSatelliteService(SUB_ID,
1669                 TEST_SATELLITE_TOKEN, mIIntegerConsumer);
1670         processAllMessages();
1671         assertTrue(waitForIIntegerConsumerResult(1));
1672         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1673                 (long) mIIntegerConsumerResults.get(0));
1674 
1675         resetSatelliteControllerUT();
1676         mIIntegerConsumerResults.clear();
1677         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1678         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1679         setUpResponseForDeprovisionSatelliteService(TEST_SATELLITE_TOKEN, SATELLITE_RESULT_SUCCESS);
1680         mSatelliteControllerUT.deprovisionSatelliteService(SUB_ID,
1681                 TEST_SATELLITE_TOKEN, mIIntegerConsumer);
1682         processAllMessages();
1683         assertTrue(waitForIIntegerConsumerResult(1));
1684         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE,
1685                 (long) mIIntegerConsumerResults.get(0));
1686 
1687         resetSatelliteControllerUT();
1688         mIIntegerConsumerResults.clear();
1689         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1690         setUpResponseForRequestIsSatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1691         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
1692         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1693         setUpResponseForDeprovisionSatelliteService(TEST_SATELLITE_TOKEN, SATELLITE_RESULT_SUCCESS);
1694         mSatelliteControllerUT.deprovisionSatelliteService(SUB_ID,
1695                 TEST_SATELLITE_TOKEN, mIIntegerConsumer);
1696         processAllMessages();
1697         assertTrue(waitForIIntegerConsumerResult(1));
1698         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
1699 
1700         resetSatelliteControllerUT();
1701         provisionSatelliteService();
1702         mIIntegerConsumerResults.clear();
1703         setUpResponseForDeprovisionSatelliteService(TEST_SATELLITE_TOKEN, SATELLITE_RESULT_SUCCESS);
1704         mSatelliteControllerUT.deprovisionSatelliteService(SUB_ID,
1705                 TEST_SATELLITE_TOKEN, mIIntegerConsumer);
1706         processAllMessages();
1707         assertTrue(waitForIIntegerConsumerResult(1));
1708         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
1709         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1710 
1711         // Vendor service does not support deprovisionSatelliteService
1712         resetSatelliteControllerUT();
1713         provisionSatelliteService();
1714         mIIntegerConsumerResults.clear();
1715         setUpResponseForDeprovisionSatelliteService(
1716                 TEST_SATELLITE_TOKEN, SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
1717         mSatelliteControllerUT.deprovisionSatelliteService(SUB_ID,
1718                 TEST_SATELLITE_TOKEN, mIIntegerConsumer);
1719         processAllMessages();
1720         assertTrue(waitForIIntegerConsumerResult(1));
1721         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
1722         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
1723 
1724         resetSatelliteControllerUT();
1725         provisionSatelliteService();
1726         mIIntegerConsumerResults.clear();
1727         setUpResponseForDeprovisionSatelliteService(TEST_SATELLITE_TOKEN,
1728                 SATELLITE_RESULT_INVALID_MODEM_STATE);
1729         mSatelliteControllerUT.deprovisionSatelliteService(SUB_ID,
1730                 TEST_SATELLITE_TOKEN, mIIntegerConsumer);
1731         processAllMessages();
1732         assertTrue(waitForIIntegerConsumerResult(1));
1733         assertEquals(SATELLITE_RESULT_INVALID_MODEM_STATE, (long) mIIntegerConsumerResults.get(0));
1734         verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
1735     }
1736 
1737     @Test
testSupportedSatelliteServices()1738     public void testSupportedSatelliteServices() throws Exception {
1739         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(false);
1740         List<String> satellitePlmnList = mSatelliteControllerUT.getSatellitePlmnsForCarrier(
1741                 SUB_ID);
1742         assertEquals(EMPTY_STRING_ARRAY.length, satellitePlmnList.size());
1743         List<Integer> supportedSatelliteServices =
1744                 mSatelliteControllerUT.getSupportedSatelliteServices(SUB_ID, "00101");
1745         assertTrue(supportedSatelliteServices.isEmpty());
1746 
1747         String[] satelliteProviderStrArray = {"00101", "00102"};
1748         mContextFixture.putStringArrayResource(
1749                 R.array.config_satellite_providers, satelliteProviderStrArray);
1750         int[] expectedSupportedServices2 = {2};
1751         int[] expectedSupportedServices3 = {1, 3};
1752         int[] defaultSupportedServices = {5, 6};
1753         PersistableBundle carrierSupportedSatelliteServicesPerProvider = new PersistableBundle();
1754         carrierSupportedSatelliteServicesPerProvider.putIntArray(
1755                 "00102", expectedSupportedServices2);
1756         carrierSupportedSatelliteServicesPerProvider.putIntArray(
1757                 "00103", expectedSupportedServices3);
1758         String[] expectedSupportedSatellitePlmns = {"00102", "00103"};
1759         mCarrierConfigBundle.putPersistableBundle(CarrierConfigManager
1760                         .KEY_CARRIER_SUPPORTED_SATELLITE_SERVICES_PER_PROVIDER_BUNDLE,
1761                 carrierSupportedSatelliteServicesPerProvider);
1762         mCarrierConfigBundle.putIntArray(
1763                 CarrierConfigManager.KEY_CARRIER_ROAMING_SATELLITE_DEFAULT_SERVICES_INT_ARRAY,
1764                 defaultSupportedServices);
1765         TestSatelliteController testSatelliteController =
1766                 new TestSatelliteController(mContext, Looper.myLooper(), mFeatureFlags);
1767 
1768         satellitePlmnList = testSatelliteController.getSatellitePlmnsForCarrier(SUB_ID);
1769         assertTrue(satellitePlmnList.isEmpty());
1770         supportedSatelliteServices =
1771                 testSatelliteController.getSupportedSatelliteServices(SUB_ID, "00101");
1772         assertTrue(supportedSatelliteServices.isEmpty());
1773 
1774         // Add entitlement provided PLMNs.
1775         setEntitlementPlmnList(testSatelliteController, SUB_ID,
1776                 Arrays.asList("00102", "00104", "00105"));
1777         // Carrier config changed with carrierEnabledSatelliteFlag disabled
1778         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
1779                 : mCarrierConfigChangedListenerList) {
1780             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
1781                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
1782             );
1783         }
1784         processAllMessages();
1785 
1786         supportedSatelliteServices =
1787                 testSatelliteController.getSupportedSatelliteServices(SUB_ID, "00102");
1788         assertTrue(supportedSatelliteServices.isEmpty());
1789         supportedSatelliteServices =
1790                 testSatelliteController.getSupportedSatelliteServices(SUB_ID, "00103");
1791         assertTrue(supportedSatelliteServices.isEmpty());
1792         supportedSatelliteServices =
1793                 testSatelliteController.getSupportedSatelliteServices(SUB_ID, "00104");
1794         assertTrue(supportedSatelliteServices.isEmpty());
1795         supportedSatelliteServices =
1796                 testSatelliteController.getSupportedSatelliteServices(SUB_ID, "00105");
1797         assertTrue(supportedSatelliteServices.isEmpty());
1798 
1799         // Trigger carrier config changed with carrierEnabledSatelliteFlag enabled
1800         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
1801         mCarrierConfigBundle.putBoolean(CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL,
1802                 true);
1803         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
1804                 : mCarrierConfigChangedListenerList) {
1805             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
1806                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
1807             );
1808         }
1809         processAllMessages();
1810 
1811         satellitePlmnList = testSatelliteController.getSatellitePlmnsForCarrier(SUB_ID);
1812         assertTrue(Arrays.equals(
1813                 expectedSupportedSatellitePlmns, satellitePlmnList.stream().toArray()));
1814         supportedSatelliteServices =
1815                 mSatelliteControllerUT.getSupportedSatelliteServices(SUB_ID, "00102");
1816         // "00101" should return carrier config assigned value, though it is in allowed list.
1817         assertTrue(Arrays.equals(expectedSupportedServices2,
1818                 supportedSatelliteServices.stream()
1819                         .mapToInt(Integer::intValue)
1820                         .toArray()));
1821         supportedSatelliteServices =
1822                 mSatelliteControllerUT.getSupportedSatelliteServices(SUB_ID, "00103");
1823         assertTrue(Arrays.equals(expectedSupportedServices3,
1824                 supportedSatelliteServices.stream()
1825                         .mapToInt(Integer::intValue)
1826                         .toArray()));
1827         // "00104", and "00105" should return default supported service.
1828         supportedSatelliteServices =
1829                 testSatelliteController.getSupportedSatelliteServices(SUB_ID, "00104");
1830         assertTrue(Arrays.equals(defaultSupportedServices,
1831                 supportedSatelliteServices.stream()
1832                         .mapToInt(Integer::intValue)
1833                         .toArray()));
1834         supportedSatelliteServices =
1835                 testSatelliteController.getSupportedSatelliteServices(SUB_ID, "00105");
1836         assertTrue(Arrays.equals(defaultSupportedServices,
1837                 supportedSatelliteServices.stream()
1838                         .mapToInt(Integer::intValue)
1839                         .toArray()));
1840 
1841         // Subscriptions changed
1842         int[] newActiveSubIds = {SUB_ID1};
1843         doReturn(newActiveSubIds).when(mMockSubscriptionManagerService).getActiveSubIdList(true);
1844         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
1845                 : mCarrierConfigChangedListenerList) {
1846             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
1847                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
1848             );
1849         }
1850         processAllMessages();
1851 
1852         satellitePlmnList = testSatelliteController.getSatellitePlmnsForCarrier(SUB_ID);
1853         assertTrue(satellitePlmnList.isEmpty());
1854         // "00102" and "00103" should return default supported service for SUB_ID.
1855         supportedSatelliteServices =
1856                 testSatelliteController.getSupportedSatelliteServices(SUB_ID, "00102");
1857         assertTrue(Arrays.equals(defaultSupportedServices,
1858                 supportedSatelliteServices.stream()
1859                         .mapToInt(Integer::intValue)
1860                         .toArray()));
1861         supportedSatelliteServices =
1862                 testSatelliteController.getSupportedSatelliteServices(SUB_ID, "00103");
1863         assertTrue(Arrays.equals(defaultSupportedServices,
1864                 supportedSatelliteServices.stream()
1865                         .mapToInt(Integer::intValue)
1866                         .toArray()));
1867         // "00104", and "00105" should return default supported service for SUB_ID.
1868         supportedSatelliteServices =
1869                 testSatelliteController.getSupportedSatelliteServices(SUB_ID, "00104");
1870         assertTrue(Arrays.equals(defaultSupportedServices,
1871                 supportedSatelliteServices.stream()
1872                         .mapToInt(Integer::intValue)
1873                         .toArray()));
1874         supportedSatelliteServices =
1875                 testSatelliteController.getSupportedSatelliteServices(SUB_ID, "00105");
1876         assertTrue(Arrays.equals(defaultSupportedServices,
1877                 supportedSatelliteServices.stream()
1878                         .mapToInt(Integer::intValue)
1879                         .toArray()));
1880 
1881         supportedSatelliteServices =
1882                 testSatelliteController.getSupportedSatelliteServices(SUB_ID1, "00102");
1883         assertNotNull(supportedSatelliteServices);
1884         assertTrue(Arrays.equals(expectedSupportedServices2,
1885                 supportedSatelliteServices.stream()
1886                         .mapToInt(Integer::intValue)
1887                         .toArray()));
1888 
1889         supportedSatelliteServices =
1890                 testSatelliteController.getSupportedSatelliteServices(SUB_ID1, "00103");
1891         assertTrue(Arrays.equals(expectedSupportedServices3,
1892                 supportedSatelliteServices.stream()
1893                         .mapToInt(Integer::intValue)
1894                         .toArray()));
1895         /* "00104", and "00105" should return default supported service. */
1896         supportedSatelliteServices =
1897                 testSatelliteController.getSupportedSatelliteServices(SUB_ID1, "00104");
1898         assertTrue(Arrays.equals(defaultSupportedServices,
1899                 supportedSatelliteServices.stream()
1900                         .mapToInt(Integer::intValue)
1901                         .toArray()));
1902         supportedSatelliteServices =
1903                 testSatelliteController.getSupportedSatelliteServices(SUB_ID1, "00105");
1904         assertTrue(Arrays.equals(defaultSupportedServices,
1905                 supportedSatelliteServices.stream()
1906                         .mapToInt(Integer::intValue)
1907                         .toArray()));
1908     }
1909 
1910     @Test
testConfigureSatellitePlmnOnCarrierConfigChanged()1911     public void testConfigureSatellitePlmnOnCarrierConfigChanged() {
1912         logd("testConfigureSatellitePlmnOnCarrierConfigChanged");
1913 
1914         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(false);
1915         String[] satelliteProviderStrArray =
1916                 {"00101", "00102", "00103", "00104", "00105"};
1917         List<String> satellitePlmnListFromOverlayConfig =
1918                 Arrays.stream(satelliteProviderStrArray).toList();
1919         mContextFixture.putStringArrayResource(
1920                 R.array.config_satellite_providers, satelliteProviderStrArray);
1921 
1922         /* Initially, the radio state is ON. In the constructor, satelliteController registers for
1923          the radio state changed events and immediately gets the radio state changed event as ON. */
1924         doReturn(false).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
1925         mCarrierConfigChangedListenerList.clear();
1926         TestSatelliteController testSatelliteController =
1927                 new TestSatelliteController(mContext, Looper.myLooper(), mFeatureFlags);
1928         processAllMessages();
1929         List<String> carrierPlmnList = testSatelliteController.getSatellitePlmnsForCarrier(
1930                 SUB_ID);
1931         verify(mMockSatelliteModemInterface, never()).setSatellitePlmn(
1932                 anyInt(), anyList(), anyList(), any(Message.class));
1933         assertTrue(carrierPlmnList.isEmpty());
1934         reset(mMockSatelliteModemInterface);
1935 
1936         // Test setSatellitePlmn() when Carrier Config change event triggered.
1937         mCarrierConfigBundle.putBoolean(CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL,
1938                 true);
1939         int[] supportedServices2 = {2};
1940         int[] supportedServices3 = {1, 3};
1941         PersistableBundle carrierSupportedSatelliteServicesPerProvider = new PersistableBundle();
1942         carrierSupportedSatelliteServicesPerProvider.putIntArray(
1943                 "00102", supportedServices2);
1944         carrierSupportedSatelliteServicesPerProvider.putIntArray(
1945                 "00103", supportedServices3);
1946         List<String> expectedCarrierPlmnList = Arrays.asList("00102", "00103");
1947         mCarrierConfigBundle.putPersistableBundle(CarrierConfigManager
1948                         .KEY_CARRIER_SUPPORTED_SATELLITE_SERVICES_PER_PROVIDER_BUNDLE,
1949                 carrierSupportedSatelliteServicesPerProvider);
1950         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
1951                 : mCarrierConfigChangedListenerList) {
1952             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
1953                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
1954             );
1955         }
1956         processAllMessages();
1957         carrierPlmnList = testSatelliteController.getSatellitePlmnsForCarrier(SUB_ID);
1958         verify(mMockSatelliteModemInterface, never()).setSatellitePlmn(
1959                 anyInt(), anyList(), anyList(), any(Message.class));
1960         assertTrue(carrierPlmnList.isEmpty());
1961         reset(mMockSatelliteModemInterface);
1962 
1963         // Reset TestSatelliteController so that device satellite PLMNs is loaded when
1964         // carrierEnabledSatelliteFlag is enabled.
1965         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
1966         mCarrierConfigChangedListenerList.clear();
1967         testSatelliteController =
1968                 new TestSatelliteController(mContext, Looper.myLooper(), mFeatureFlags);
1969 
1970         // Trigger carrier config changed with carrierEnabledSatelliteFlag enabled and empty
1971         // carrier supported satellite services.
1972         mCarrierConfigBundle.putPersistableBundle(CarrierConfigManager
1973                         .KEY_CARRIER_SUPPORTED_SATELLITE_SERVICES_PER_PROVIDER_BUNDLE,
1974                 new PersistableBundle());
1975         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
1976                 : mCarrierConfigChangedListenerList) {
1977             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
1978                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
1979             );
1980         }
1981         processAllMessages();
1982 
1983         carrierPlmnList = testSatelliteController.getSatellitePlmnsForCarrier(SUB_ID);
1984         assertTrue(carrierPlmnList.isEmpty());
1985         List<String> allSatellitePlmnList = SatelliteServiceUtils.mergeStrLists(
1986                 carrierPlmnList, satellitePlmnListFromOverlayConfig);
1987         verify(mMockSatelliteModemInterface, times(1)).setSatellitePlmn(anyInt(),
1988                 eq(EMPTY_STRING_LIST), eq(allSatellitePlmnList), any(Message.class));
1989         reset(mMockSatelliteModemInterface);
1990 
1991         // Trigger carrier config changed with carrierEnabledSatelliteFlag enabled and non-empty
1992         // carrier supported satellite services.
1993         mCarrierConfigBundle.putPersistableBundle(CarrierConfigManager
1994                         .KEY_CARRIER_SUPPORTED_SATELLITE_SERVICES_PER_PROVIDER_BUNDLE,
1995                 carrierSupportedSatelliteServicesPerProvider);
1996         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
1997                 : mCarrierConfigChangedListenerList) {
1998             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
1999                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
2000             );
2001         }
2002         processAllMessages();
2003         carrierPlmnList = testSatelliteController.getSatellitePlmnsForCarrier(SUB_ID);
2004         allSatellitePlmnList = SatelliteServiceUtils.mergeStrLists(
2005                 carrierPlmnList, satellitePlmnListFromOverlayConfig);
2006         assertEquals(expectedCarrierPlmnList, carrierPlmnList);
2007         verify(mMockSatelliteModemInterface, times(1)).setSatellitePlmn(anyInt(),
2008                 eq(carrierPlmnList), eq(allSatellitePlmnList), any(Message.class));
2009         reset(mMockSatelliteModemInterface);
2010 
2011         /* setSatellitePlmn() is called regardless whether satellite attach for carrier is
2012            supported. */
2013         mCarrierConfigBundle.putBoolean(CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL,
2014                 false);
2015         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
2016                 : mCarrierConfigChangedListenerList) {
2017             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
2018                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
2019             );
2020         }
2021         processAllMessages();
2022         verify(mMockSatelliteModemInterface, times(1)).setSatellitePlmn(anyInt(),
2023                 eq(carrierPlmnList), eq(allSatellitePlmnList), any(Message.class));
2024         reset(mMockSatelliteModemInterface);
2025 
2026         // Test empty config_satellite_providers and empty carrier PLMN list
2027         mCarrierConfigChangedListenerList.clear();
2028         mContextFixture.putStringArrayResource(
2029                 R.array.config_satellite_providers, EMPTY_STRING_ARRAY);
2030         testSatelliteController =
2031                 new TestSatelliteController(mContext, Looper.myLooper(), mFeatureFlags);
2032         mCarrierConfigBundle.putPersistableBundle(CarrierConfigManager
2033                         .KEY_CARRIER_SUPPORTED_SATELLITE_SERVICES_PER_PROVIDER_BUNDLE,
2034                 new PersistableBundle());
2035         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
2036                 : mCarrierConfigChangedListenerList) {
2037             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
2038                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
2039             );
2040         }
2041         processAllMessages();
2042         carrierPlmnList = testSatelliteController.getSatellitePlmnsForCarrier(SUB_ID);
2043         assertTrue(carrierPlmnList.isEmpty());
2044         verify(mMockSatelliteModemInterface, times(1)).setSatellitePlmn(anyInt(),
2045                 eq(EMPTY_STRING_LIST), eq(EMPTY_STRING_LIST), any(Message.class));
2046         reset(mMockSatelliteModemInterface);
2047     }
2048 
2049     @Test
testSatelliteCommunicationRestriction()2050     public void testSatelliteCommunicationRestriction() {
2051         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
2052         mCarrierConfigBundle.putBoolean(
2053                 CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL, true);
2054         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
2055                 : mCarrierConfigChangedListenerList) {
2056             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
2057                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
2058             );
2059         }
2060         processAllMessages();
2061 
2062         // Remove restriction reason if exist
2063         mIIntegerConsumerResults.clear();
2064         reset(mMockSatelliteModemInterface);
2065         setUpResponseForRequestSetSatelliteEnabledForCarrier(true, SATELLITE_RESULT_SUCCESS);
2066         setUpResponseForRequestSetSatelliteEnabledForCarrier(false, SATELLITE_RESULT_SUCCESS);
2067         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2068         mSatelliteControllerUT.removeAttachRestrictionForCarrier(SUB_ID,
2069                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER, mIIntegerConsumer);
2070         mSatelliteControllerUT.removeAttachRestrictionForCarrier(SUB_ID,
2071                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_GEOLOCATION, mIIntegerConsumer);
2072         processAllMessages();
2073         assertTrue(waitForIIntegerConsumerResult(2));
2074 
2075         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
2076         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(1));
2077 
2078         Set<Integer> restrictionSet =
2079                 mSatelliteControllerUT.getAttachRestrictionReasonsForCarrier(SUB_ID);
2080         assertTrue(!restrictionSet.contains(SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER));
2081         assertTrue(!restrictionSet.contains(
2082                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_GEOLOCATION));
2083 
2084         // Add satellite attach restriction reason by user
2085         mIIntegerConsumerResults.clear();
2086         reset(mMockSatelliteModemInterface);
2087         setUpResponseForRequestSetSatelliteEnabledForCarrier(false, SATELLITE_RESULT_SUCCESS);
2088         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2089         mSatelliteControllerUT.addAttachRestrictionForCarrier(SUB_ID,
2090                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER, mIIntegerConsumer);
2091         processAllMessages();
2092         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
2093         verify(mMockSatelliteModemInterface, never())
2094                 .requestSetSatelliteEnabledForCarrier(anyInt(), anyBoolean(), any(Message.class));
2095         assertTrue(waitForIIntegerConsumerResult(1));
2096         restrictionSet =
2097                 mSatelliteControllerUT.getAttachRestrictionReasonsForCarrier(SUB_ID);
2098         assertTrue(restrictionSet.contains(SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER));
2099 
2100         // remove satellite restriction reason by user
2101         mIIntegerConsumerResults.clear();
2102         reset(mMockSatelliteModemInterface);
2103         setUpResponseForRequestSetSatelliteEnabledForCarrier(true, SATELLITE_RESULT_SUCCESS);
2104         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2105         mSatelliteControllerUT.removeAttachRestrictionForCarrier(SUB_ID,
2106                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER, mIIntegerConsumer);
2107         processAllMessages();
2108         assertTrue(waitForIIntegerConsumerResult(1));
2109         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
2110         restrictionSet =
2111                 mSatelliteControllerUT.getAttachRestrictionReasonsForCarrier(SUB_ID);
2112         assertTrue(!restrictionSet.contains(SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER));
2113         verify(mMockSatelliteModemInterface, times(1))
2114                 .requestSetSatelliteEnabledForCarrier(anyInt(), anyBoolean(), any(Message.class));
2115 
2116         // Add satellite attach restriction reason by user
2117         mIIntegerConsumerResults.clear();
2118         reset(mMockSatelliteModemInterface);
2119         setUpResponseForRequestSetSatelliteEnabledForCarrier(false, SATELLITE_RESULT_SUCCESS);
2120         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2121         mSatelliteControllerUT.addAttachRestrictionForCarrier(SUB_ID,
2122                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER, mIIntegerConsumer);
2123         processAllMessages();
2124         assertTrue(waitForIIntegerConsumerResult(1));
2125         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
2126         restrictionSet =
2127                 mSatelliteControllerUT.getAttachRestrictionReasonsForCarrier(SUB_ID);
2128         assertTrue(restrictionSet.contains(SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER));
2129         verify(mMockSatelliteModemInterface, times(1))
2130                 .requestSetSatelliteEnabledForCarrier(anyInt(), eq(false), any(Message.class));
2131 
2132         // add satellite attach restriction reason by geolocation
2133         mIIntegerConsumerResults.clear();
2134         reset(mMockSatelliteModemInterface);
2135         setUpResponseForRequestSetSatelliteEnabledForCarrier(false, SATELLITE_RESULT_SUCCESS);
2136         mSatelliteControllerUT.addAttachRestrictionForCarrier(SUB_ID,
2137                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_GEOLOCATION, mIIntegerConsumer);
2138         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2139         processAllMessages();
2140         assertTrue(waitForIIntegerConsumerResult(1));
2141         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
2142         restrictionSet =
2143                 mSatelliteControllerUT.getAttachRestrictionReasonsForCarrier(SUB_ID);
2144         assertTrue(restrictionSet.contains(SATELLITE_COMMUNICATION_RESTRICTION_REASON_GEOLOCATION));
2145         verify(mMockSatelliteModemInterface, never())
2146                 .requestSetSatelliteEnabledForCarrier(anyInt(), anyBoolean(), any(Message.class));
2147 
2148         // remove satellite attach restriction reason by geolocation
2149         mIIntegerConsumerResults.clear();
2150         reset(mMockSatelliteModemInterface);
2151         setUpResponseForRequestSetSatelliteEnabledForCarrier(true, SATELLITE_RESULT_SUCCESS);
2152         mSatelliteControllerUT.removeAttachRestrictionForCarrier(SUB_ID,
2153                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_GEOLOCATION, mIIntegerConsumer);
2154         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2155         processAllMessages();
2156         assertTrue(waitForIIntegerConsumerResult(1));
2157         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
2158         restrictionSet =
2159                 mSatelliteControllerUT.getAttachRestrictionReasonsForCarrier(SUB_ID);
2160         assertTrue(!restrictionSet.contains(
2161                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_GEOLOCATION));
2162         verify(mMockSatelliteModemInterface, never())
2163                 .requestSetSatelliteEnabledForCarrier(anyInt(), anyBoolean(), any(Message.class));
2164 
2165         // remove satellite restriction reason by user
2166         mIIntegerConsumerResults.clear();
2167         reset(mMockSatelliteModemInterface);
2168         setUpResponseForRequestSetSatelliteEnabledForCarrier(true, SATELLITE_RESULT_SUCCESS);
2169         mSatelliteControllerUT.removeAttachRestrictionForCarrier(SUB_ID,
2170                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER, mIIntegerConsumer);
2171         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2172         processAllMessages();
2173         assertTrue(waitForIIntegerConsumerResult(1));
2174         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
2175         restrictionSet =
2176                 mSatelliteControllerUT.getAttachRestrictionReasonsForCarrier(SUB_ID);
2177         assertTrue(!restrictionSet.contains(SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER));
2178         verify(mMockSatelliteModemInterface, times(1))
2179                 .requestSetSatelliteEnabledForCarrier(anyInt(), eq(true), any(Message.class));
2180         reset(mMockSatelliteModemInterface);
2181 
2182         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(false);
2183 
2184         mIIntegerConsumerResults.clear();
2185         mSatelliteControllerUT.removeAttachRestrictionForCarrier(SUB_ID,
2186                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER, mIIntegerConsumer);
2187         processAllMessages();
2188         assertTrue(waitForIIntegerConsumerResult(1));
2189         assertEquals(
2190                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED, (long) mIIntegerConsumerResults.get(0));
2191         verifyZeroInteractions(mMockSatelliteModemInterface);
2192 
2193         mIIntegerConsumerResults.clear();
2194         mSatelliteControllerUT.addAttachRestrictionForCarrier(SUB_ID,
2195                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER, mIIntegerConsumer);
2196         processAllMessages();
2197         assertTrue(waitForIIntegerConsumerResult(1));
2198         assertEquals(
2199                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED, (long) mIIntegerConsumerResults.get(0));
2200         verifyZeroInteractions(mMockSatelliteModemInterface);
2201 
2202         Set<Integer> satelliteRestrictionReasons =
2203                 mSatelliteControllerUT.getAttachRestrictionReasonsForCarrier(SUB_ID);
2204         assertTrue(satelliteRestrictionReasons.isEmpty());
2205     }
2206 
2207     @Test
testIsSatelliteAttachRequired()2208     public void testIsSatelliteAttachRequired() {
2209         TestSatelliteController satelliteController =
2210                 new TestSatelliteController(mContext, Looper.myLooper(), mFeatureFlags);
2211         mSatelliteCapabilitiesSemaphore.drainPermits();
2212         satelliteController.requestSatelliteCapabilities(SUB_ID, mSatelliteCapabilitiesReceiver);
2213         processAllMessages();
2214         assertTrue(waitForRequestSatelliteCapabilitiesResult(1));
2215         assertEquals(
2216                 SATELLITE_RESULT_INVALID_TELEPHONY_STATE, mQueriedSatelliteCapabilitiesResultCode);
2217         assertFalse(satelliteController.isSatelliteAttachRequired());
2218 
2219         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
2220         setUpResponseForRequestSatelliteCapabilities(
2221                 mEmptySatelliteCapabilities, SATELLITE_RESULT_SUCCESS);
2222         satelliteController =
2223                 new TestSatelliteController(mContext, Looper.myLooper(), mFeatureFlags);
2224         verifySatelliteSupported(satelliteController, true, SATELLITE_RESULT_SUCCESS);
2225         mSatelliteCapabilitiesSemaphore.drainPermits();
2226         satelliteController.requestSatelliteCapabilities(SUB_ID, mSatelliteCapabilitiesReceiver);
2227         processAllMessages();
2228         assertTrue(waitForRequestSatelliteCapabilitiesResult(1));
2229         assertEquals(SATELLITE_RESULT_SUCCESS, mQueriedSatelliteCapabilitiesResultCode);
2230         assertEquals(mEmptySatelliteCapabilities, mQueriedSatelliteCapabilities);
2231         assertEquals(SatelliteManager.NT_RADIO_TECHNOLOGY_UNKNOWN,
2232                 mSatelliteControllerUT.getSupportedNtnRadioTechnology());
2233 
2234         assertFalse(satelliteController.isSatelliteAttachRequired());
2235 
2236         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
2237         setUpResponseForRequestSatelliteCapabilities(
2238                 mSatelliteCapabilities, SATELLITE_RESULT_SUCCESS);
2239         satelliteController =
2240                 new TestSatelliteController(mContext, Looper.myLooper(), mFeatureFlags);
2241         verifySatelliteSupported(satelliteController, true, SATELLITE_RESULT_SUCCESS);
2242         mSatelliteCapabilitiesSemaphore.drainPermits();
2243         satelliteController.requestSatelliteCapabilities(SUB_ID, mSatelliteCapabilitiesReceiver);
2244         processAllMessages();
2245         assertTrue(waitForRequestSatelliteCapabilitiesResult(1));
2246         assertEquals(SATELLITE_RESULT_SUCCESS, mQueriedSatelliteCapabilitiesResultCode);
2247         assertEquals(mSatelliteCapabilities, mQueriedSatelliteCapabilities);
2248         assertTrue(
2249                 mQueriedSatelliteCapabilities.getSupportedRadioTechnologies().contains(
2250                         satelliteController.getSupportedNtnRadioTechnology()));
2251         assertTrue(satelliteController.isSatelliteAttachRequired());
2252 
2253         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(false);
2254         assertFalse(satelliteController.isSatelliteAttachRequired());
2255     }
2256 
2257     @Test
testSatelliteModemStateChanged()2258     public void testSatelliteModemStateChanged() {
2259         clearInvocations(mMockSatelliteSessionController);
2260         clearInvocations(mMockDatagramController);
2261         sendSatelliteModemStateChangedEvent(SATELLITE_MODEM_STATE_CONNECTED, null);
2262         processAllMessages();
2263         verify(mMockSatelliteSessionController, times(0)).onSatelliteModemStateChanged(
2264                 SATELLITE_MODEM_STATE_CONNECTED);
2265 
2266         resetSatelliteControllerUTToSupportedAndProvisionedState();
2267         mSatelliteControllerUT.setSatelliteSessionController(mMockSatelliteSessionController);
2268         clearInvocations(mMockSatelliteSessionController);
2269         clearInvocations(mMockDatagramController);
2270         sendSatelliteModemStateChangedEvent(SATELLITE_MODEM_STATE_UNAVAILABLE, null);
2271         processAllMessages();
2272         verify(mMockSatelliteSessionController, times(1)).onSatelliteEnabledStateChanged(eq(false));
2273         verify(mMockSatelliteSessionController, times(1)).setDemoMode(eq(false));
2274         verify(mMockDatagramController, times(1)).setDemoMode(eq(false));
2275 
2276         clearInvocations(mMockSatelliteSessionController);
2277         clearInvocations(mMockDatagramController);
2278         sendSatelliteModemStateChangedEvent(SATELLITE_MODEM_STATE_CONNECTED, null);
2279         processAllMessages();
2280         verify(mMockSatelliteSessionController, times(1)).onSatelliteModemStateChanged(
2281                 SATELLITE_MODEM_STATE_CONNECTED);
2282     }
2283 
2284     @Test
testRequestNtnSignalStrengthWithFeatureFlagEnabled()2285     public void testRequestNtnSignalStrengthWithFeatureFlagEnabled() {
2286         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(true);
2287 
2288         resetSatelliteControllerUT();
2289 
2290         mRequestNtnSignalStrengthSemaphore.drainPermits();
2291         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
2292         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
2293 
2294         @NtnSignalStrength.NtnSignalStrengthLevel int expectedLevel = NTN_SIGNAL_STRENGTH_GREAT;
2295         setUpResponseForRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
2296         /* In case request is not successful, result should be NTN_SIGNAL_STRENGTH_NONE */
2297         verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_NONE, SATELLITE_RESULT_NOT_SUPPORTED);
2298 
2299         resetSatelliteControllerUT();
2300         provisionSatelliteService();
2301 
2302         doReturn(false).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2303         setUpResponseForRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
2304         verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_NONE,
2305                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
2306 
2307         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2308         setUpResponseForRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
2309         verifyRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
2310 
2311         resetSatelliteControllerUT();
2312         provisionSatelliteService();
2313         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2314         // reset cache to NTN_SIGNAL_STRENGTH_NONE
2315         sendNtnSignalStrengthChangedEvent(NTN_SIGNAL_STRENGTH_NONE, null);
2316         processAllMessages();
2317         expectedLevel = NTN_SIGNAL_STRENGTH_POOR;
2318         setUpResponseForRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
2319         verifyRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
2320     }
2321 
2322     @Test
testRequestNtnSignalStrengthWithFeatureFlagDisabled()2323     public void testRequestNtnSignalStrengthWithFeatureFlagDisabled() {
2324         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(false);
2325 
2326         resetSatelliteControllerUT();
2327         mRequestNtnSignalStrengthSemaphore.drainPermits();
2328         doReturn(false).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2329 
2330         @NtnSignalStrength.NtnSignalStrengthLevel int expectedLevel = NTN_SIGNAL_STRENGTH_GREAT;
2331         setUpResponseForRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
2332         verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_NONE,
2333                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
2334 
2335         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2336         setUpResponseForRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
2337         verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_NONE,
2338                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
2339 
2340         expectedLevel = NTN_SIGNAL_STRENGTH_POOR;
2341         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2342         setUpResponseForRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
2343         verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_NONE,
2344                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
2345 
2346         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2347         setUpResponseForRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_MODEM_ERROR);
2348         verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_NONE,
2349                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
2350     }
2351 
2352     @Test
testRegisterForNtnSignalStrengthChangedWithFeatureFlagEnabled()2353     public void testRegisterForNtnSignalStrengthChangedWithFeatureFlagEnabled() {
2354         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(true);
2355 
2356         Semaphore semaphore = new Semaphore(0);
2357         final NtnSignalStrength[] signalStrength = new NtnSignalStrength[1];
2358         INtnSignalStrengthCallback callback =
2359                 new INtnSignalStrengthCallback.Stub() {
2360                     @Override
2361                     public void onNtnSignalStrengthChanged(NtnSignalStrength ntnSignalStrength) {
2362                         logd("onNtnSignalStrengthChanged: ntnSignalStrength="
2363                                 + ntnSignalStrength);
2364                         try {
2365                             signalStrength[0] = ntnSignalStrength;
2366                             semaphore.release();
2367                         } catch (Exception ex) {
2368                             loge("onNtnSignalStrengthChanged: Got exception in releasing "
2369                                     + "semaphore, ex=" + ex);
2370                         }
2371                     }
2372                 };
2373 
2374         verifyRegisterForNtnSignalStrengthChanged(SUB_ID, callback,
2375                 SATELLITE_RESULT_INVALID_TELEPHONY_STATE);
2376 
2377         setUpResponseForRequestIsSatelliteSupported(false,
2378                 SATELLITE_RESULT_SUCCESS);
2379         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
2380         verifyRegisterForNtnSignalStrengthChanged(SUB_ID, callback,
2381                 SATELLITE_RESULT_NOT_SUPPORTED);
2382 
2383         @NtnSignalStrength.NtnSignalStrengthLevel int expectedLevel = NTN_SIGNAL_STRENGTH_NONE;
2384         verifyRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_NOT_SUPPORTED);
2385 
2386         resetSatelliteControllerUT();
2387         setUpResponseForRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
2388         provisionSatelliteService();
2389         verifyRegisterForNtnSignalStrengthChanged(SUB_ID, callback,
2390                 SATELLITE_RESULT_SUCCESS);
2391         verifyRequestNtnSignalStrength(expectedLevel, SATELLITE_RESULT_SUCCESS);
2392         processAllMessages();
2393         assertTrue(waitForForEvents(
2394                 semaphore, 1, "testRegisterForNtnSignalStrengthChanged"));
2395         assertEquals(expectedLevel, signalStrength[0].getLevel());
2396 
2397         expectedLevel = NTN_SIGNAL_STRENGTH_GOOD;
2398         sendNtnSignalStrengthChangedEvent(expectedLevel, null);
2399         processAllMessages();
2400         assertTrue(waitForForEvents(
2401                 semaphore, 1, "testRegisterForNtnSignalStrengthChanged"));
2402         assertEquals(expectedLevel, signalStrength[0].getLevel());
2403         verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_GOOD, SATELLITE_RESULT_SUCCESS);
2404 
2405         expectedLevel = NTN_SIGNAL_STRENGTH_POOR;
2406         sendNtnSignalStrengthChangedEvent(expectedLevel, null);
2407         processAllMessages();
2408         assertTrue(waitForForEvents(
2409                 semaphore, 1, "testRegisterForNtnSignalStrengthChanged"));
2410         assertEquals(expectedLevel, signalStrength[0].getLevel());
2411         verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_POOR, SATELLITE_RESULT_SUCCESS);
2412 
2413         mSatelliteControllerUT.unregisterForNtnSignalStrengthChanged(SUB_ID, callback);
2414         sendNtnSignalStrengthChangedEvent(NTN_SIGNAL_STRENGTH_GREAT, null);
2415         processAllMessages();
2416         assertFalse(waitForForEvents(
2417                 semaphore, 1, "testRegisterForNtnSignalStrengthChanged"));
2418         /* Even if all listeners are unregistered, the cache is updated with the latest value when a
2419          new value event occurs. */
2420         verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_GREAT, SATELLITE_RESULT_SUCCESS);
2421     }
2422 
2423     @Test
testRegisterForNtnSignalStrengthChangedWithFeatureFlagDisabled()2424     public void testRegisterForNtnSignalStrengthChangedWithFeatureFlagDisabled() {
2425         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(false);
2426 
2427         Semaphore semaphore = new Semaphore(0);
2428         final NtnSignalStrength[] signalStrength = new NtnSignalStrength[1];
2429         INtnSignalStrengthCallback callback =
2430                 new INtnSignalStrengthCallback.Stub() {
2431                     @Override
2432                     public void onNtnSignalStrengthChanged(NtnSignalStrength ntnSignalStrength) {
2433                         logd("onNtnSignalStrengthChanged: ntnSignalStrength="
2434                                 + ntnSignalStrength);
2435                         try {
2436                             signalStrength[0] = ntnSignalStrength;
2437                             semaphore.release();
2438                         } catch (Exception ex) {
2439                             loge("onNtnSignalStrengthChanged: Got exception in releasing "
2440                                     + "semaphore, ex=" + ex);
2441                         }
2442                     }
2443                 };
2444 
2445         verifyRegisterForNtnSignalStrengthChanged(SUB_ID, callback,
2446                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
2447 
2448         setUpResponseForRequestIsSatelliteSupported(false,
2449                 SATELLITE_RESULT_SUCCESS);
2450         verifySatelliteSupported(false, SATELLITE_RESULT_NOT_SUPPORTED);
2451         verifyRegisterForNtnSignalStrengthChanged(SUB_ID, callback,
2452                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
2453         setUpResponseForRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_NONE,
2454                 SATELLITE_RESULT_SUCCESS);
2455         verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_NONE,
2456                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
2457 
2458         resetSatelliteControllerUT();
2459         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
2460         verifySatelliteSupported(false, SATELLITE_RESULT_NOT_SUPPORTED);
2461         verifyRegisterForNtnSignalStrengthChanged(SUB_ID, callback,
2462                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
2463         verifyRequestNtnSignalStrength(NTN_SIGNAL_STRENGTH_NONE,
2464                 SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
2465 
2466         @NtnSignalStrength.NtnSignalStrengthLevel int expectedNtnSignalStrengthLevel =
2467                 NTN_SIGNAL_STRENGTH_GOOD;
2468         sendNtnSignalStrengthChangedEvent(expectedNtnSignalStrengthLevel, null);
2469         processAllMessages();
2470         assertTrue(waitForForEvents(
2471                 semaphore, 0, "testRegisterForNtnSignalStrengthChanged"));
2472     }
2473 
2474     @Test
testSendingNtnSignalStrengthWithFeatureEnabled()2475     public void testSendingNtnSignalStrengthWithFeatureEnabled() {
2476         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(true);
2477 
2478         int expectedResult = SATELLITE_RESULT_SUCCESS;
2479         // startSendingNtnSignalStrength() is requested when screen on event comes.
2480         reset(mMockSatelliteModemInterface);
2481         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2482         provisionSatelliteService();
2483         setUpResponseForStartSendingNtnSignalStrength(expectedResult);
2484 
2485         // but it is ignored because satellite is disabled
2486         setUpResponseForRequestIsSatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
2487         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
2488         sendCmdStartSendingNtnSignalStrengthChangedEvent(true);
2489         processAllMessages();
2490         verify(mMockSatelliteModemInterface, never())
2491                 .startSendingNtnSignalStrength(any(Message.class));
2492 
2493         // after satellite is enabled, startSendingNtnSignalStrength() is requested normally
2494         resetSatelliteControllerUT();
2495         reset(mMockSatelliteModemInterface);
2496         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2497         provisionSatelliteService();
2498         setUpResponseForStartSendingNtnSignalStrength(expectedResult);
2499         setUpResponseForRequestIsSatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
2500         verifySatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
2501         processAllMessages();
2502         sendCmdStartSendingNtnSignalStrengthChangedEvent(true);
2503         processAllMessages();
2504         verify(mMockSatelliteModemInterface, times(1))
2505                 .startSendingNtnSignalStrength(any(Message.class));
2506 
2507         // requested again but ignored as expected and current state are matched.
2508         setUpResponseForStartSendingNtnSignalStrength(expectedResult);
2509         sendCmdStartSendingNtnSignalStrengthChangedEvent(true);
2510         processAllMessages();
2511         verify(mMockSatelliteModemInterface, times(1))
2512                 .startSendingNtnSignalStrength(any(Message.class));
2513 
2514         // stopSendingNtnSignalStrength() is requested when screen off event comes.
2515         reset(mMockSatelliteModemInterface);
2516         setUpResponseForRequestIsSatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
2517         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
2518         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2519         setUpResponseForStopSendingNtnSignalStrength(expectedResult);
2520         sendCmdStartSendingNtnSignalStrengthChangedEvent(false);
2521         processAllMessages();
2522         verify(mMockSatelliteModemInterface, times(1))
2523                 .stopSendingNtnSignalStrength(any(Message.class));
2524 
2525         // requested again but ignored as expected and current state are matched.
2526         setUpResponseForStopSendingNtnSignalStrength(expectedResult);
2527         sendCmdStartSendingNtnSignalStrengthChangedEvent(false);
2528         processAllMessages();
2529         verify(mMockSatelliteModemInterface, times(1))
2530                 .stopSendingNtnSignalStrength(any(Message.class));
2531 
2532         // startSendingNtnSignalStrength() is requested but received fail from the service.
2533         reset(mMockSatelliteModemInterface);
2534         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2535         setUpResponseForStartSendingNtnSignalStrength(SATELLITE_RESULT_INVALID_MODEM_STATE);
2536         sendCmdStartSendingNtnSignalStrengthChangedEvent(true);
2537         processAllMessages();
2538         verify(mMockSatelliteModemInterface, times(1))
2539                 .startSendingNtnSignalStrength(any(Message.class));
2540 
2541         /* stopSendingNtnSignalStrength() is ignored because startSendingNtnSignalStrength has
2542            failed thus current state is stopSendingNtnSignalStrength */
2543         reset(mMockSatelliteModemInterface);
2544         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2545         setUpResponseForStopSendingNtnSignalStrength(SATELLITE_RESULT_NO_RESOURCES);
2546         sendCmdStartSendingNtnSignalStrengthChangedEvent(false);
2547         processAllMessages();
2548         verify(mMockSatelliteModemInterface, never())
2549                 .stopSendingNtnSignalStrength(any(Message.class));
2550 
2551         // startSendingNtnSignalStrength() is requested and modem state is changed
2552         reset(mMockSatelliteModemInterface);
2553         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2554         setUpResponseForStartSendingNtnSignalStrength(SATELLITE_RESULT_SUCCESS);
2555         sendCmdStartSendingNtnSignalStrengthChangedEvent(true);
2556         processAllMessages();
2557         verify(mMockSatelliteModemInterface, times(1))
2558                 .startSendingNtnSignalStrength(any(Message.class));
2559 
2560         // stopSendingNtnSignalStrength() is failed as modem returns error
2561         reset(mMockSatelliteModemInterface);
2562         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2563         setUpResponseForStopSendingNtnSignalStrength(SATELLITE_RESULT_NO_RESOURCES);
2564         sendCmdStartSendingNtnSignalStrengthChangedEvent(false);
2565         processAllMessages();
2566         verify(mMockSatelliteModemInterface, times(1))
2567                 .stopSendingNtnSignalStrength(any(Message.class));
2568 
2569         // request stopSendingNtnSignalStrength() again and returns success
2570         reset(mMockSatelliteModemInterface);
2571         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2572         setUpResponseForStopSendingNtnSignalStrength(SATELLITE_RESULT_SUCCESS);
2573         sendCmdStartSendingNtnSignalStrengthChangedEvent(false);
2574         processAllMessages();
2575         verify(mMockSatelliteModemInterface, times(1))
2576                 .stopSendingNtnSignalStrength(any(Message.class));
2577     }
2578 
2579     @Test
testSendingNtnSignalStrengthWithFeatureDisabled()2580     public void testSendingNtnSignalStrengthWithFeatureDisabled() {
2581         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(false);
2582 
2583         int expectedResult = SATELLITE_RESULT_SUCCESS;
2584         // startSendingNtnSignalStrength() is requested when screen on event comes.
2585         reset(mMockSatelliteModemInterface);
2586         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2587         setUpResponseForRequestIsSatelliteSupported(true, expectedResult);
2588         setUpResponseForRequestIsSatelliteProvisioned(true, expectedResult);
2589         verifySatelliteSupported(false, SATELLITE_RESULT_NOT_SUPPORTED);
2590         verifySatelliteProvisioned(false, SATELLITE_RESULT_REQUEST_NOT_SUPPORTED);
2591         setUpResponseForStartSendingNtnSignalStrength(expectedResult);
2592         sendCmdStartSendingNtnSignalStrengthChangedEvent(true);
2593         processAllMessages();
2594         verify(mMockSatelliteModemInterface, never())
2595                 .startSendingNtnSignalStrength(any(Message.class));
2596 
2597         // stopSendingNtnSignalStrength() is requested when screen off event comes.
2598         reset(mMockSatelliteModemInterface);
2599         setUpResponseForRequestIsSatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
2600         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
2601         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2602         setUpResponseForStopSendingNtnSignalStrength(expectedResult);
2603         sendCmdStartSendingNtnSignalStrengthChangedEvent(false);
2604         processAllMessages();
2605         verify(mMockSatelliteModemInterface, never())
2606                 .stopSendingNtnSignalStrength(any(Message.class));
2607     }
2608 
2609     @Test
testIsSatelliteSupportedViaCarrier()2610     public void testIsSatelliteSupportedViaCarrier() {
2611         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(false);
2612         assertFalse(mSatelliteControllerUT.isSatelliteSupportedViaCarrier());
2613 
2614         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
2615         assertFalse(mSatelliteControllerUT.isSatelliteSupportedViaCarrier());
2616 
2617         mCarrierConfigBundle.putBoolean(KEY_SATELLITE_ATTACH_SUPPORTED_BOOL, true);
2618         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
2619                 : mCarrierConfigChangedListenerList) {
2620             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
2621                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
2622             );
2623         }
2624         processAllMessages();
2625         assertTrue(mSatelliteControllerUT.isSatelliteSupportedViaCarrier());
2626     }
2627 
2628     @Test
testCarrierEnabledSatelliteConnectionHysteresisTime()2629     public void testCarrierEnabledSatelliteConnectionHysteresisTime() throws Exception {
2630         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(false);
2631         assertFalse(mSatelliteControllerUT.isSatelliteConnectedViaCarrierWithinHysteresisTime());
2632 
2633         when(mServiceState.getState()).thenReturn(ServiceState.STATE_OUT_OF_SERVICE);
2634         when(mServiceState2.getState()).thenReturn(ServiceState.STATE_OUT_OF_SERVICE);
2635         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
2636         mCarrierConfigBundle.putInt(KEY_SATELLITE_CONNECTION_HYSTERESIS_SEC_INT, 1 * 60);
2637         mCarrierConfigBundle.putBoolean(KEY_SATELLITE_ATTACH_SUPPORTED_BOOL, true);
2638         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
2639                 : mCarrierConfigChangedListenerList) {
2640             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
2641                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
2642             );
2643         }
2644         doReturn(mSignalStrength).when(mPhone).getSignalStrength();
2645         doReturn(mSignalStrength).when(mPhone2).getSignalStrength();
2646         List<CellSignalStrength> cellSignalStrengthList = new ArrayList<>();
2647         cellSignalStrengthList.add(mCellSignalStrength);
2648         doReturn(cellSignalStrengthList).when(mSignalStrength).getCellSignalStrengths();
2649         processAllMessages();
2650         mSatelliteControllerUT.elapsedRealtime = 0;
2651         assertFalse(mSatelliteControllerUT.isSatelliteConnectedViaCarrierWithinHysteresisTime());
2652         assertFalse(mSatelliteControllerUT.isInSatelliteModeForCarrierRoaming(mPhone));
2653         assertFalse(mSatelliteControllerUT.isInSatelliteModeForCarrierRoaming(mPhone2));
2654 
2655         when(mServiceState.isUsingNonTerrestrialNetwork()).thenReturn(false);
2656         when(mServiceState2.isUsingNonTerrestrialNetwork()).thenReturn(false);
2657         sendServiceStateChangedEvent();
2658         processAllMessages();
2659         assertFalse(mSatelliteControllerUT.isSatelliteConnectedViaCarrierWithinHysteresisTime());
2660         assertFalse(mSatelliteControllerUT.isInSatelliteModeForCarrierRoaming(mPhone));
2661         assertFalse(mSatelliteControllerUT.isInSatelliteModeForCarrierRoaming(mPhone2));
2662         verify(mPhone, times(1)).notifyCarrierRoamingNtnModeChanged(eq(false));
2663         verify(mPhone2, times(1)).notifyCarrierRoamingNtnModeChanged(eq(false));
2664         clearInvocations(mPhone);
2665         clearInvocations(mPhone2);
2666 
2667         // Last satellite connected time of Phone2 should be 0
2668         when(mServiceState2.isUsingNonTerrestrialNetwork()).thenReturn(true);
2669         sendServiceStateChangedEvent();
2670         processAllMessages();
2671         // 2 minutes later and hysteresis timeout is 1 minute
2672         mSatelliteControllerUT.elapsedRealtime = 2 * 60 * 1000;
2673         // But Phone2 is connected to NTN right now
2674         assertTrue(mSatelliteControllerUT.isSatelliteConnectedViaCarrierWithinHysteresisTime());
2675         assertFalse(mSatelliteControllerUT.isInSatelliteModeForCarrierRoaming(mPhone));
2676         assertTrue(mSatelliteControllerUT.isInSatelliteModeForCarrierRoaming(mPhone2));
2677         verify(mPhone, times(0)).notifyCarrierRoamingNtnModeChanged(eq(false));
2678         verify(mPhone2, times(1)).notifyCarrierRoamingNtnModeChanged(eq(true));
2679         clearInvocations(mPhone);
2680         clearInvocations(mPhone2);
2681 
2682         // Last satellite disconnected time of Phone2 should be 2 * 60 * 1000
2683         when(mServiceState2.isUsingNonTerrestrialNetwork()).thenReturn(false);
2684         sendServiceStateChangedEvent();
2685         processAllMessages();
2686         // Current time (2) - last disconnected time (2) < hysteresis timeout (1)
2687         assertTrue(mSatelliteControllerUT.isSatelliteConnectedViaCarrierWithinHysteresisTime());
2688         assertFalse(mSatelliteControllerUT.isInSatelliteModeForCarrierRoaming(mPhone));
2689         assertTrue(mSatelliteControllerUT.isInSatelliteModeForCarrierRoaming(mPhone2));
2690         verify(mPhone, times(0)).notifyCarrierRoamingNtnModeChanged(eq(false));
2691         verify(mPhone2, times(0)).notifyCarrierRoamingNtnModeChanged(anyBoolean());
2692         clearInvocations(mPhone);
2693         clearInvocations(mPhone2);
2694 
2695         // Current time (4) - last disconnected time (2) > hysteresis timeout (1)
2696         mSatelliteControllerUT.elapsedRealtime = 4 * 60 * 1000;
2697         moveTimeForward(2 * 60 * 1000);
2698         processAllMessages();
2699         assertFalse(mSatelliteControllerUT.isSatelliteConnectedViaCarrierWithinHysteresisTime());
2700         assertFalse(mSatelliteControllerUT.isInSatelliteModeForCarrierRoaming(mPhone));
2701         assertFalse(mSatelliteControllerUT.isInSatelliteModeForCarrierRoaming(mPhone2));
2702         verify(mPhone, times(0)).notifyCarrierRoamingNtnModeChanged(eq(false));
2703         verify(mPhone2, times(1)).notifyCarrierRoamingNtnModeChanged(eq(false));
2704     }
2705 
2706     @Test
testRegisterForSatelliteCapabilitiesChangedWithFeatureFlagEnabled()2707     public void testRegisterForSatelliteCapabilitiesChangedWithFeatureFlagEnabled() {
2708         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(true);
2709 
2710         Semaphore semaphore = new Semaphore(0);
2711         final SatelliteCapabilities[] satelliteCapabilities = new SatelliteCapabilities[1];
2712         ISatelliteCapabilitiesCallback callback =
2713                 new ISatelliteCapabilitiesCallback.Stub() {
2714                     @Override
2715                     public void onSatelliteCapabilitiesChanged(SatelliteCapabilities capabilities) {
2716                         logd("onSatelliteCapabilitiesChanged: " + capabilities);
2717                         try {
2718                             satelliteCapabilities[0] = capabilities;
2719                             semaphore.release();
2720                         } catch (Exception ex) {
2721                             loge("onSatelliteCapabilitiesChanged: Got exception in releasing "
2722                                     + "semaphore, ex=" + ex);
2723                         }
2724                     }
2725                 };
2726 
2727         int errorCode = mSatelliteControllerUT.registerForCapabilitiesChanged(SUB_ID,
2728                 callback);
2729         assertEquals(SATELLITE_RESULT_INVALID_TELEPHONY_STATE, errorCode);
2730 
2731         setUpResponseForRequestIsSatelliteSupported(false,
2732                 SATELLITE_RESULT_SUCCESS);
2733         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
2734         errorCode = mSatelliteControllerUT.registerForCapabilitiesChanged(SUB_ID,
2735                 callback);
2736         assertEquals(SATELLITE_RESULT_NOT_SUPPORTED, errorCode);
2737 
2738         resetSatelliteControllerUT();
2739         provisionSatelliteService();
2740         errorCode = mSatelliteControllerUT.registerForCapabilitiesChanged(SUB_ID,
2741                 callback);
2742         assertEquals(SATELLITE_RESULT_SUCCESS, errorCode);
2743         SatelliteCapabilities expectedCapabilities = mSatelliteCapabilities;
2744         sendSatelliteCapabilitiesChangedEvent(expectedCapabilities, null);
2745         processAllMessages();
2746         assertTrue(waitForForEvents(
2747                 semaphore, 1, "testRegisterForSatelliteCapabilitiesChanged"));
2748         assertTrue(expectedCapabilities.equals(satelliteCapabilities[0]));
2749 
2750         expectedCapabilities = mEmptySatelliteCapabilities;
2751         sendSatelliteCapabilitiesChangedEvent(expectedCapabilities, null);
2752         processAllMessages();
2753         assertTrue(waitForForEvents(
2754                 semaphore, 1, "testRegisterForSatelliteCapabilitiesChanged"));
2755         assertTrue(expectedCapabilities.equals(satelliteCapabilities[0]));
2756 
2757         mSatelliteControllerUT.unregisterForCapabilitiesChanged(SUB_ID, callback);
2758         expectedCapabilities = mSatelliteCapabilities;
2759         sendSatelliteCapabilitiesChangedEvent(expectedCapabilities, null);
2760         processAllMessages();
2761         assertTrue(waitForForEvents(
2762                 semaphore, 0, "testRegisterForSatelliteCapabilitiesChanged"));
2763     }
2764 
2765     @Test
testRegisterForSatelliteCapabilitiesChangedWithFeatureFlagDisabled()2766     public void testRegisterForSatelliteCapabilitiesChangedWithFeatureFlagDisabled() {
2767         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(false);
2768 
2769         Semaphore semaphore = new Semaphore(0);
2770         final SatelliteCapabilities[] satelliteCapabilities = new SatelliteCapabilities[1];
2771         ISatelliteCapabilitiesCallback callback =
2772                 new ISatelliteCapabilitiesCallback.Stub() {
2773                     @Override
2774                     public void onSatelliteCapabilitiesChanged(SatelliteCapabilities capabilities) {
2775                         logd("onSatelliteCapabilitiesChanged: " + capabilities);
2776                         try {
2777                             satelliteCapabilities[0] = capabilities;
2778                             semaphore.release();
2779                         } catch (Exception ex) {
2780                             loge("onSatelliteCapabilitiesChanged: Got exception in releasing "
2781                                     + "semaphore, ex=" + ex);
2782                         }
2783                     }
2784                 };
2785 
2786         int errorCode = mSatelliteControllerUT.registerForCapabilitiesChanged(SUB_ID,
2787                 callback);
2788         assertEquals(SATELLITE_RESULT_REQUEST_NOT_SUPPORTED, errorCode);
2789 
2790         setUpResponseForRequestIsSatelliteSupported(false,
2791                 SATELLITE_RESULT_SUCCESS);
2792         verifySatelliteSupported(false, SATELLITE_RESULT_NOT_SUPPORTED);
2793         errorCode = mSatelliteControllerUT.registerForCapabilitiesChanged(SUB_ID,
2794                 callback);
2795         assertEquals(SATELLITE_RESULT_REQUEST_NOT_SUPPORTED, errorCode);
2796 
2797         resetSatelliteControllerUT();
2798         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
2799         verifySatelliteSupported(false, SATELLITE_RESULT_NOT_SUPPORTED);
2800         errorCode = mSatelliteControllerUT.registerForCapabilitiesChanged(SUB_ID,
2801                 callback);
2802         assertEquals(SATELLITE_RESULT_REQUEST_NOT_SUPPORTED, errorCode);
2803 
2804         SatelliteCapabilities expectedCapabilities = mSatelliteCapabilities;
2805         sendSatelliteCapabilitiesChangedEvent(expectedCapabilities, null);
2806         processAllMessages();
2807         assertTrue(waitForForEvents(
2808                 semaphore, 0, "testRegisterForSatelliteCapabilitiesChanged"));
2809     }
2810 
2811     @Test
testSatelliteCommunicationRestrictionForEntitlement()2812     public void testSatelliteCommunicationRestrictionForEntitlement() throws Exception {
2813         logd("testSatelliteCommunicationRestrictionForEntitlement");
2814         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
2815 
2816         mCarrierConfigBundle.putBoolean(CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL,
2817                 true);
2818         SparseBooleanArray satelliteEnabledPerCarrier = new SparseBooleanArray();
2819         replaceInstance(SatelliteController.class, "mSatelliteEntitlementStatusPerCarrier",
2820                 mSatelliteControllerUT, satelliteEnabledPerCarrier);
2821 
2822         mIIntegerConsumerResults.clear();
2823         reset(mMockSatelliteModemInterface);
2824         setUpResponseForRequestSetSatelliteEnabledForCarrier(true, SATELLITE_RESULT_SUCCESS);
2825         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2826         Map<Integer, Set<Integer>> satelliteAttachRestrictionForCarrierArray = new HashMap<>();
2827         satelliteAttachRestrictionForCarrierArray.put(SUB_ID, new HashSet<>());
2828         satelliteAttachRestrictionForCarrierArray.get(SUB_ID).add(
2829                 SATELLITE_COMMUNICATION_RESTRICTION_REASON_ENTITLEMENT);
2830         replaceInstance(SatelliteController.class, "mSatelliteAttachRestrictionForCarrierArray",
2831                 mSatelliteControllerUT, satelliteAttachRestrictionForCarrierArray);
2832 
2833         // Verify call the requestSetSatelliteEnabledForCarrier to enable the satellite when
2834         // satellite service is enabled by entitlement server.
2835         mSatelliteControllerUT.onSatelliteEntitlementStatusUpdated(SUB_ID, true, new ArrayList<>(),
2836                 new ArrayList<>(), mIIntegerConsumer);
2837         processAllMessages();
2838 
2839         assertTrue(waitForIIntegerConsumerResult(1));
2840         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
2841         verify(mMockSatelliteModemInterface, times(1))
2842                 .requestSetSatelliteEnabledForCarrier(anyInt(), eq(true), any(Message.class));
2843 
2844         // Verify call the requestSetSatelliteEnabledForCarrier to disable the satellite when
2845         // satellite service is disabled by entitlement server.
2846         mIIntegerConsumerResults.clear();
2847         reset(mMockSatelliteModemInterface);
2848         Map<Integer, Boolean> enabledForCarrierArrayPerSub = new HashMap<>();
2849         enabledForCarrierArrayPerSub.put(SUB_ID, true);
2850         replaceInstance(SatelliteController.class, "mIsSatelliteAttachEnabledForCarrierArrayPerSub",
2851                 mSatelliteControllerUT, enabledForCarrierArrayPerSub);
2852         doReturn(mIsSatelliteServiceSupported)
2853                 .when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
2854         setUpResponseForRequestSetSatelliteEnabledForCarrier(false, SATELLITE_RESULT_SUCCESS);
2855         mSatelliteControllerUT.onSatelliteEntitlementStatusUpdated(SUB_ID, false, new ArrayList<>(),
2856                 new ArrayList<>(), mIIntegerConsumer);
2857         processAllMessages();
2858 
2859         assertTrue(waitForIIntegerConsumerResult(1));
2860         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
2861         verify(mMockSatelliteModemInterface, times(1))
2862                 .requestSetSatelliteEnabledForCarrier(anyInt(), eq(false), any(Message.class));
2863     }
2864 
2865     @Test
testPassSatellitePlmnToModemAfterUpdateSatelliteEntitlementStatus()2866     public void testPassSatellitePlmnToModemAfterUpdateSatelliteEntitlementStatus()
2867             throws Exception {
2868         logd("testPassSatellitePlmnToModemAfterUpdateSatelliteEntitlementStatus");
2869         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
2870 
2871         replaceInstance(SatelliteController.class, "mMergedPlmnListPerCarrier",
2872                 mSatelliteControllerUT, new SparseArray<>());
2873         List<String> overlayConfigPlmnList = new ArrayList<>();
2874         replaceInstance(SatelliteController.class, "mSatellitePlmnListFromOverlayConfig",
2875                 mSatelliteControllerUT, overlayConfigPlmnList);
2876         mCarrierConfigBundle.putBoolean(
2877                 CarrierConfigManager.KEY_SATELLITE_ENTITLEMENT_SUPPORTED_BOOL, true);
2878         mCarrierConfigBundle.putBoolean(CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL,
2879                 true);
2880 
2881         // If the entitlement plmn list, the carrier plmn list, the overlay config plmn list and
2882         // the barred plmn list are empty, verify not passing to the modem.
2883         reset(mMockSatelliteModemInterface);
2884         List<String> entitlementPlmnList = new ArrayList<>();
2885         List<String> barredPlmnList = new ArrayList<>();
2886         mSatelliteControllerUT.onSatelliteEntitlementStatusUpdated(SUB_ID, false,
2887                 entitlementPlmnList, barredPlmnList, mIIntegerConsumer);
2888         verify(mMockSatelliteModemInterface, never()).requestSatelliteEnabled(anyBoolean(),
2889                 anyBoolean(), anyBoolean(), any(Message.class));
2890 
2891         // If the entitlement plmn list and the overlay config plmn list are available and the
2892         // carrier plmn list and the barred plmn list are empty, verify passing to the modem.
2893         reset(mMockSatelliteModemInterface);
2894         entitlementPlmnList = Arrays.stream(new String[]{"00101", "00102", "00103"}).toList();
2895         List<String> mergedPlmnList = entitlementPlmnList;
2896         overlayConfigPlmnList =
2897                 Arrays.stream(new String[]{"00101", "00102", "00104"}).toList();
2898         replaceInstance(SatelliteController.class, "mSatellitePlmnListFromOverlayConfig",
2899                 mSatelliteControllerUT, overlayConfigPlmnList);
2900         verifyPassingToModemAfterQueryCompleted(entitlementPlmnList, mergedPlmnList,
2901                 overlayConfigPlmnList, barredPlmnList);
2902 
2903         // If the entitlement plmn list, the overlay config plmn list and the carrier plmn list
2904         // are available and the barred plmn list is empty, verify passing to the modem.
2905         reset(mMockSatelliteModemInterface);
2906         Map<Integer, Map<String, Set<Integer>>>
2907                 satelliteServicesSupportedByCarriers = new HashMap<>();
2908         List<String> carrierConfigPlmnList = Arrays.stream(new String[]{"00105", "00106"}).toList();
2909         Map<String, Set<Integer>> plmnAndService = new HashMap<>();
2910         plmnAndService.put(carrierConfigPlmnList.get(0), new HashSet<>(Arrays.asList(3, 5)));
2911         plmnAndService.put(carrierConfigPlmnList.get(1), new HashSet<>(Arrays.asList(3)));
2912         satelliteServicesSupportedByCarriers.put(SUB_ID, plmnAndService);
2913         replaceInstance(SatelliteController.class, "mSatelliteServicesSupportedByCarriers",
2914                 mSatelliteControllerUT, satelliteServicesSupportedByCarriers);
2915         verifyPassingToModemAfterQueryCompleted(entitlementPlmnList, mergedPlmnList,
2916                 overlayConfigPlmnList, barredPlmnList);
2917 
2918         // If the entitlement plmn list is empty and the overlay config plmn list and the carrier
2919         // plmn list are available, verify passing to the modem.
2920         reset(mMockSatelliteModemInterface);
2921         entitlementPlmnList = new ArrayList<>();
2922         mergedPlmnList = carrierConfigPlmnList;
2923         verifyPassingToModemAfterQueryCompleted(entitlementPlmnList, mergedPlmnList,
2924                 overlayConfigPlmnList, barredPlmnList);
2925 
2926         // If the entitlement plmn list is empty and the overlay config plmn list, the carrier
2927         // plmn list and the barred plmn list are available, verify passing to the modem.
2928         reset(mMockSatelliteModemInterface);
2929         barredPlmnList = Arrays.stream(new String[]{"00105", "00107"}).toList();
2930         verifyPassingToModemAfterQueryCompleted(entitlementPlmnList, mergedPlmnList,
2931                 overlayConfigPlmnList, barredPlmnList);
2932 
2933         // If the entitlement plmn list is null and the overlay config plmn list and the carrier
2934         // plmn list are available, verify passing to the modem.
2935         reset(mMockSatelliteModemInterface);
2936         entitlementPlmnList = null;
2937         mergedPlmnList = carrierConfigPlmnList;
2938         verifyPassingToModemAfterQueryCompleted(entitlementPlmnList, mergedPlmnList,
2939                 overlayConfigPlmnList, barredPlmnList);
2940 
2941         // If the entitlement plmn list is invalid, verify not passing to the modem.
2942         reset(mMockSatelliteModemInterface);
2943         entitlementPlmnList = Arrays.stream(new String[]{"00101", "00102", ""}).toList();
2944         mSatelliteControllerUT.onSatelliteEntitlementStatusUpdated(SUB_ID, false,
2945                 entitlementPlmnList, barredPlmnList, mIIntegerConsumer);
2946         verify(mMockSatelliteModemInterface, never()).requestSatelliteEnabled(anyBoolean(),
2947                 anyBoolean(), anyBoolean(), any(Message.class));
2948 
2949         // If the entitlement plmn list is invalid, verify not passing to the modem.
2950         reset(mMockSatelliteModemInterface);
2951         entitlementPlmnList = Arrays.stream(new String[]{"00101", "00102", "123456789"}).toList();
2952         mSatelliteControllerUT.onSatelliteEntitlementStatusUpdated(SUB_ID, false,
2953                 entitlementPlmnList, barredPlmnList, mIIntegerConsumer);
2954         verify(mMockSatelliteModemInterface, never()).requestSatelliteEnabled(anyBoolean(),
2955                 anyBoolean(), anyBoolean(), any(Message.class));
2956 
2957         // If the entitlement plmn list is invalid, verify not passing to the modem.
2958         reset(mMockSatelliteModemInterface);
2959         entitlementPlmnList = Arrays.stream(new String[]{"00101", "00102", "12"}).toList();
2960         mSatelliteControllerUT.onSatelliteEntitlementStatusUpdated(SUB_ID, false,
2961                 entitlementPlmnList, barredPlmnList, mIIntegerConsumer);
2962         verify(mMockSatelliteModemInterface, never()).requestSatelliteEnabled(anyBoolean(),
2963                 anyBoolean(), anyBoolean(), any(Message.class));
2964 
2965         // If the entitlement plmn list is invalid, verify not passing to the modem.
2966         reset(mMockSatelliteModemInterface);
2967         entitlementPlmnList = Arrays.stream(new String[]{"00101", "00102", "1234"}).toList();
2968         mSatelliteControllerUT.onSatelliteEntitlementStatusUpdated(SUB_ID, false,
2969                 entitlementPlmnList, barredPlmnList, mIIntegerConsumer);
2970         verify(mMockSatelliteModemInterface, never()).requestSatelliteEnabled(anyBoolean(),
2971                 anyBoolean(), anyBoolean(), any(Message.class));
2972     }
2973 
verifyPassingToModemAfterQueryCompleted(List<String> entitlementPlmnList, List<String> mergedPlmnList, List<String> overlayConfigPlmnList, List<String> barredPlmnList)2974     private void verifyPassingToModemAfterQueryCompleted(List<String> entitlementPlmnList,
2975             List<String> mergedPlmnList, List<String> overlayConfigPlmnList,
2976             List<String> barredPlmnList) {
2977         mSatelliteControllerUT.onSatelliteEntitlementStatusUpdated(SUB_ID, false,
2978                 entitlementPlmnList, barredPlmnList, mIIntegerConsumer);
2979 
2980         List<String> plmnListPerCarrier = mSatelliteControllerUT.getSatellitePlmnsForCarrier(
2981                 SUB_ID);
2982         List<String> allSatellitePlmnList = SatelliteServiceUtils.mergeStrLists(
2983                 plmnListPerCarrier, overlayConfigPlmnList, barredPlmnList);
2984 
2985         assertEquals(mergedPlmnList, plmnListPerCarrier);
2986         if (overlayConfigPlmnList.isEmpty()) {
2987             assertEquals(plmnListPerCarrier, allSatellitePlmnList);
2988         }
2989         verify(mMockSatelliteModemInterface, times(1)).setSatellitePlmn(anyInt(),
2990                 eq(plmnListPerCarrier), eq(allSatellitePlmnList), any(Message.class));
2991     }
2992 
setConfigData(List<String> plmnList)2993     private void setConfigData(List<String> plmnList) {
2994         doReturn(plmnList).when(mMockConfig).getAllSatellitePlmnsForCarrier(anyInt());
2995         doReturn(mMockConfig).when(mMockConfigParser).getConfig();
2996 
2997         Map<String, List<Integer>> servicePerPlmn = new HashMap<>();
2998         List<List<Integer>> serviceLists = Arrays.asList(
2999                 Arrays.asList(1),
3000                 Arrays.asList(3),
3001                 Arrays.asList(5)
3002         );
3003         for (int i = 0; i < plmnList.size(); i++) {
3004             servicePerPlmn.put(plmnList.get(i), serviceLists.get(i));
3005         }
3006         doReturn(servicePerPlmn).when(mMockConfig).getSupportedSatelliteServices(anyInt());
3007         doReturn(mMockConfig).when(mMockConfigParser).getConfig();
3008     }
3009 
3010     @Test
testUpdateSupportedSatelliteServices()3011     public void testUpdateSupportedSatelliteServices() throws Exception {
3012         logd("testUpdateSupportedSatelliteServices");
3013         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
3014         replaceInstance(SatelliteController.class, "mMergedPlmnListPerCarrier",
3015                 mSatelliteControllerUT, new SparseArray<>());
3016         replaceInstance(SatelliteController.class, "mSatelliteServicesSupportedByCarriers",
3017                 mSatelliteControllerUT, new HashMap<>());
3018         List<Integer> servicesPerPlmn;
3019 
3020         // verify whether an empty list is returned with conditions below
3021         // the config data plmn list : empty
3022         // the carrier config plmn list : empty
3023         setConfigData(new ArrayList<>());
3024         setCarrierConfigDataPlmnList(new ArrayList<>());
3025         invokeCarrierConfigChanged();
3026         servicesPerPlmn = mSatelliteControllerUT.getSupportedSatelliteServices(SUB_ID, "31016");
3027         assertEquals(new ArrayList<>(), servicesPerPlmn);
3028 
3029         // Verify whether the carrier config plmn list is returned with conditions below
3030         // the config data plmn list : empty
3031         // the carrier config plmn list : exist with services {{2}, {1, 3}, {2}}
3032         setConfigData(new ArrayList<>());
3033         setCarrierConfigDataPlmnList(Arrays.asList("00101", "00102", "00104"));
3034         invokeCarrierConfigChanged();
3035         servicesPerPlmn = mSatelliteControllerUT.getSupportedSatelliteServices(SUB_ID, "00101");
3036         assertEquals(Arrays.asList(2).stream().sorted().toList(),
3037                 servicesPerPlmn.stream().sorted().toList());
3038         servicesPerPlmn = mSatelliteControllerUT.getSupportedSatelliteServices(SUB_ID, "00102");
3039         assertEquals(Arrays.asList(1, 3).stream().sorted().toList(),
3040                 servicesPerPlmn.stream().sorted().toList());
3041         servicesPerPlmn = mSatelliteControllerUT.getSupportedSatelliteServices(SUB_ID, "00104");
3042         assertEquals(Arrays.asList(2).stream().sorted().toList(),
3043                 servicesPerPlmn.stream().sorted().toList());
3044 
3045         // Verify whether the carrier config plmn list is returned with conditions below
3046         // the config data plmn list : exist with services {{1}, {3}, {5}}
3047         // the carrier config plmn list : exist with services {{2}, {1, 3}, {2}}
3048         setConfigData(Arrays.asList("00101", "00102", "31024"));
3049         setCarrierConfigDataPlmnList(Arrays.asList("00101", "00102", "00104"));
3050         invokeCarrierConfigChanged();
3051         servicesPerPlmn = mSatelliteControllerUT.getSupportedSatelliteServices(SUB_ID, "00101");
3052         assertEquals(Arrays.asList(1).stream().sorted().toList(),
3053                 servicesPerPlmn.stream().sorted().toList());
3054         servicesPerPlmn = mSatelliteControllerUT.getSupportedSatelliteServices(SUB_ID, "00102");
3055         assertEquals(Arrays.asList(3).stream().sorted().toList(),
3056                 servicesPerPlmn.stream().sorted().toList());
3057         servicesPerPlmn = mSatelliteControllerUT.getSupportedSatelliteServices(SUB_ID, "00104");
3058         assertEquals(new ArrayList<>(), servicesPerPlmn.stream().sorted().toList());
3059         servicesPerPlmn = mSatelliteControllerUT.getSupportedSatelliteServices(SUB_ID, "31024");
3060         assertEquals(Arrays.asList(5).stream().sorted().toList(),
3061                 servicesPerPlmn.stream().sorted().toList());
3062     }
setEntitlementPlmnList(List<String> plmnList)3063     private void setEntitlementPlmnList(List<String> plmnList) throws Exception {
3064         SparseArray<List<String>> entitlementPlmnListPerCarrier = new SparseArray<>();
3065         if (!plmnList.isEmpty()) {
3066             entitlementPlmnListPerCarrier.clear();
3067             entitlementPlmnListPerCarrier.put(SUB_ID, plmnList);
3068         }
3069         replaceInstance(SatelliteController.class, "mEntitlementPlmnListPerCarrier",
3070                 mSatelliteControllerUT, entitlementPlmnListPerCarrier);
3071     }
3072 
setEntitlementPlmnList(SatelliteController targetClass, int subId, List<String> plmnList)3073     private void setEntitlementPlmnList(SatelliteController targetClass, int subId,
3074             List<String> plmnList) throws Exception {
3075         SparseArray<List<String>> entitlementPlmnListPerCarrier = new SparseArray<>();
3076         if (!plmnList.isEmpty()) {
3077             entitlementPlmnListPerCarrier.clear();
3078             entitlementPlmnListPerCarrier.put(subId, plmnList);
3079         }
3080         replaceInstance(SatelliteController.class, "mEntitlementPlmnListPerCarrier",
3081                 targetClass, entitlementPlmnListPerCarrier);
3082     }
3083 
setConfigDataPlmnList(List<String> plmnList)3084     private void setConfigDataPlmnList(List<String> plmnList) {
3085         doReturn(plmnList).when(mMockConfig).getAllSatellitePlmnsForCarrier(anyInt());
3086         doReturn(mMockConfig).when(mMockConfigParser).getConfig();
3087     }
3088 
setCarrierConfigDataPlmnList(List<String> plmnList)3089     private void setCarrierConfigDataPlmnList(List<String> plmnList) {
3090         if (!plmnList.isEmpty()) {
3091             mCarrierConfigBundle.putBoolean(
3092                     CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL,
3093                     true);
3094             PersistableBundle carrierSupportedSatelliteServicesPerProvider =
3095                     new PersistableBundle();
3096             List<String> carrierConfigPlmnList = plmnList;
3097             carrierSupportedSatelliteServicesPerProvider.putIntArray(
3098                     carrierConfigPlmnList.get(0), new int[]{2});
3099             carrierSupportedSatelliteServicesPerProvider.putIntArray(
3100                     carrierConfigPlmnList.get(1), new int[]{1, 3});
3101             carrierSupportedSatelliteServicesPerProvider.putIntArray(
3102                     carrierConfigPlmnList.get(2), new int[]{2});
3103             mCarrierConfigBundle.putPersistableBundle(CarrierConfigManager
3104                             .KEY_CARRIER_SUPPORTED_SATELLITE_SERVICES_PER_PROVIDER_BUNDLE,
3105                     carrierSupportedSatelliteServicesPerProvider);
3106         } else {
3107             mCarrierConfigBundle.putPersistableBundle(CarrierConfigManager
3108                             .KEY_CARRIER_SUPPORTED_SATELLITE_SERVICES_PER_PROVIDER_BUNDLE,
3109                     new PersistableBundle());
3110         }
3111     }
3112 
invokeCarrierConfigChanged()3113     private void invokeCarrierConfigChanged() {
3114         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
3115                 : mCarrierConfigChangedListenerList) {
3116             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
3117                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
3118             );
3119         }
3120         processAllMessages();
3121     }
3122 
3123     @Test
testUpdatePlmnListPerCarrier()3124     public void testUpdatePlmnListPerCarrier() throws Exception {
3125         logd("testUpdatePlmnListPerCarrier");
3126         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
3127 
3128         replaceInstance(SatelliteController.class, "mMergedPlmnListPerCarrier",
3129                 mSatelliteControllerUT, new SparseArray<>());
3130         mCarrierConfigBundle.putBoolean(
3131                 CarrierConfigManager.KEY_SATELLITE_ENTITLEMENT_SUPPORTED_BOOL, true);
3132         List<String> plmnListPerCarrier;
3133 
3134         // verify whether an empty list is returned with conditions below
3135         // the entitlement plmn list : empty
3136         // the config data plmn list : empty
3137         // the carrier config plmn list : empty
3138         setEntitlementPlmnList(new ArrayList<>());
3139         setConfigDataPlmnList(new ArrayList<>());
3140         setCarrierConfigDataPlmnList(new ArrayList<>());
3141         invokeCarrierConfigChanged();
3142         plmnListPerCarrier = mSatelliteControllerUT.getSatellitePlmnsForCarrier(SUB_ID);
3143         assertEquals(new ArrayList<>(), plmnListPerCarrier.stream().sorted().toList());
3144 
3145         // Verify whether the carrier config plmn list is returned with conditions below
3146         // the entitlement plmn list : empty
3147         // the config data plmn list : empty
3148         // the carrier config plmn list : exist
3149         setEntitlementPlmnList(new ArrayList<>());
3150         setConfigDataPlmnList(new ArrayList<>());
3151         setCarrierConfigDataPlmnList(Arrays.asList("00101", "00102", "00104"));
3152         invokeCarrierConfigChanged();
3153         plmnListPerCarrier = mSatelliteControllerUT.getSatellitePlmnsForCarrier(SUB_ID);
3154         assertEquals(Arrays.asList("00101", "00102", "00104").stream().sorted().toList(),
3155                 plmnListPerCarrier.stream().sorted().toList());
3156 
3157         // Verify whether config data plmn list is returned with conditions below
3158         // the entitlement plmn list : empty
3159         // the config data plmn list : exist
3160         // the carrier config plmn list : exist
3161         setEntitlementPlmnList(new ArrayList<>());
3162         setConfigDataPlmnList(Arrays.asList("11111", "22222", "33333"));
3163         setCarrierConfigDataPlmnList(Arrays.asList("00101", "00102", "00104"));
3164         invokeCarrierConfigChanged();
3165         plmnListPerCarrier = mSatelliteControllerUT.getSatellitePlmnsForCarrier(SUB_ID);
3166         assertEquals(Arrays.asList("11111", "22222", "33333").stream().sorted().toList(),
3167                 plmnListPerCarrier.stream().sorted().toList());
3168 
3169         // Verify whether the entitlement plmn list is returned with conditions below
3170         // the entitlement plmn list : exist
3171         // the config data plmn list : exist
3172         // the carrier config plmn list : exist
3173         setEntitlementPlmnList(Arrays.asList("99090", "88080", "77070"));
3174         setConfigDataPlmnList(Arrays.asList("11111", "22222", "33333"));
3175         setCarrierConfigDataPlmnList(Arrays.asList("00101", "00102", "00104"));
3176         invokeCarrierConfigChanged();
3177         plmnListPerCarrier = mSatelliteControllerUT.getSatellitePlmnsForCarrier(SUB_ID);
3178         assertEquals(Arrays.asList("99090", "88080", "77070").stream().sorted().toList(),
3179                 plmnListPerCarrier.stream().sorted().toList());
3180     }
3181 
3182     @Test
testEntitlementStatus()3183     public void testEntitlementStatus() throws Exception {
3184         logd("testEntitlementStatus");
3185         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
3186         SparseBooleanArray satelliteEnabledPerCarrier = new SparseBooleanArray();
3187         replaceInstance(SatelliteController.class, "mSatelliteEntitlementStatusPerCarrier",
3188                 mSatelliteControllerUT, satelliteEnabledPerCarrier);
3189 
3190         // Change SUB_ID's EntitlementStatus to true
3191         mSatelliteControllerUT.onSatelliteEntitlementStatusUpdated(SUB_ID, true, new ArrayList<>(),
3192                 new ArrayList<>(), mIIntegerConsumer);
3193 
3194         assertEquals(true, satelliteEnabledPerCarrier.get(SUB_ID));
3195         assertEquals(false, satelliteEnabledPerCarrier.get(SUB_ID1));
3196 
3197         // Change SUB_ID1's EntitlementStatus to true
3198         mSatelliteControllerUT.onSatelliteEntitlementStatusUpdated(SUB_ID1, true, new ArrayList<>(),
3199                 new ArrayList<>(), mIIntegerConsumer);
3200 
3201         assertEquals(true, satelliteEnabledPerCarrier.get(SUB_ID));
3202         assertEquals(true, satelliteEnabledPerCarrier.get(SUB_ID1));
3203 
3204         // Change SUB_ID's EntitlementStatus to false
3205         mSatelliteControllerUT.onSatelliteEntitlementStatusUpdated(SUB_ID, false, new ArrayList<>(),
3206                 new ArrayList<>(), mIIntegerConsumer);
3207 
3208         assertEquals(false, satelliteEnabledPerCarrier.get(SUB_ID));
3209         assertEquals(true, satelliteEnabledPerCarrier.get(SUB_ID1));
3210     }
3211 
3212     @Test
testUpdateRestrictReasonForEntitlementPerCarrier()3213     public void testUpdateRestrictReasonForEntitlementPerCarrier() throws Exception {
3214         logd("testUpdateRestrictReasonForEntitlementPerCarrier");
3215         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
3216 
3217         // Verify that the entitlement restriction reason is added before the entitlement query,
3218         // When the Satellite entitlement status value read from DB is disabled.
3219         doReturn("").when(mContext).getOpPackageName();
3220         doReturn("").when(mContext).getAttributionTag();
3221         doReturn("0").when(mMockSubscriptionManagerService).getSubscriptionProperty(anyInt(),
3222                 eq(SATELLITE_ENTITLEMENT_STATUS), anyString(), anyString());
3223         doReturn(new ArrayList<>()).when(
3224                 mMockSubscriptionManagerService).getSatelliteEntitlementPlmnList(anyInt());
3225         mCarrierConfigBundle.putBoolean(CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL,
3226                 true);
3227         mCarrierConfigBundle.putBoolean(
3228                 CarrierConfigManager.KEY_SATELLITE_ENTITLEMENT_SUPPORTED_BOOL, true);
3229         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
3230                 : mCarrierConfigChangedListenerList) {
3231             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
3232                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
3233             );
3234         }
3235         processAllMessages();
3236         Set<Integer> restrictionSet =
3237                 mSatelliteControllerUT.getAttachRestrictionReasonsForCarrier(SUB_ID);
3238         assertEquals(1, restrictionSet.size());
3239         assertTrue(restrictionSet.contains(SATELLITE_COMMUNICATION_RESTRICTION_REASON_ENTITLEMENT));
3240     }
3241 
3242     @Test
testUpdateEntitlementPlmnListPerCarrier()3243     public void testUpdateEntitlementPlmnListPerCarrier() throws Exception {
3244         logd("testUpdateEntitlementPlmnListPerCarrier");
3245         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
3246 
3247         // If the Satellite entitlement plmn list read from the DB is empty list and carrier
3248         // config plmn list also is empty , check whether an empty list is returned when calling
3249         // getSatellitePlmnsForCarrier before the entitlement query.
3250         doReturn(new ArrayList<>()).when(
3251                 mMockSubscriptionManagerService).getSatelliteEntitlementPlmnList(anyInt());
3252         replaceInstance(SatelliteController.class, "mEntitlementPlmnListPerCarrier",
3253                 mSatelliteControllerUT, new SparseArray<>());
3254         replaceInstance(SatelliteController.class, "mSatelliteServicesSupportedByCarriers",
3255                 mSatelliteControllerUT, new HashMap<>());
3256         mCarrierConfigBundle.putBoolean(CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL,
3257                 true);
3258         mCarrierConfigBundle.putBoolean(
3259                 CarrierConfigManager.KEY_SATELLITE_ENTITLEMENT_SUPPORTED_BOOL, true);
3260         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
3261                 : mCarrierConfigChangedListenerList) {
3262             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
3263                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
3264             );
3265         }
3266         processAllMessages();
3267 
3268         assertEquals(new ArrayList<>(), mSatelliteControllerUT.getSatellitePlmnsForCarrier(SUB_ID));
3269 
3270         // If the Satellite entitlement plmn list read from the DB is valid and carrier config
3271         // plmn list is empty, check whether valid entitlement plmn list is returned
3272         // when calling getSatellitePlmnsForCarrier before the entitlement query.
3273         replaceInstance(SatelliteController.class, "mEntitlementPlmnListPerCarrier",
3274                 mSatelliteControllerUT, new SparseArray<>());
3275         List<String> expectedSatelliteEntitlementPlmnList = Arrays.asList("123456,12560");
3276         doReturn(expectedSatelliteEntitlementPlmnList).when(
3277                 mMockSubscriptionManagerService).getSatelliteEntitlementPlmnList(anyInt());
3278         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
3279                 : mCarrierConfigChangedListenerList) {
3280             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
3281                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
3282             );
3283         }
3284         processAllMessages();
3285 
3286         assertEquals(expectedSatelliteEntitlementPlmnList,
3287                 mSatelliteControllerUT.getSatellitePlmnsForCarrier(SUB_ID));
3288 
3289         // If the Satellite entitlement plmn list read from the DB is valid and carrier config
3290         // plmn list is valid, check whether valid entitlement plmn list is returned when
3291         // calling getSatellitePlmnsForCarrier before the entitlement query.
3292         replaceInstance(SatelliteController.class, "mEntitlementPlmnListPerCarrier",
3293                 mSatelliteControllerUT, new SparseArray<>());
3294         PersistableBundle carrierSupportedSatelliteServicesPerProvider = new PersistableBundle();
3295         List<String> carrierConfigPlmnList = Arrays.asList("00102", "00103", "00105");
3296         carrierSupportedSatelliteServicesPerProvider.putIntArray(
3297                 carrierConfigPlmnList.get(0), new int[]{2});
3298         carrierSupportedSatelliteServicesPerProvider.putIntArray(
3299                 carrierConfigPlmnList.get(1), new int[]{1, 3});
3300         carrierSupportedSatelliteServicesPerProvider.putIntArray(
3301                 carrierConfigPlmnList.get(2), new int[]{2});
3302         mCarrierConfigBundle.putPersistableBundle(CarrierConfigManager
3303                         .KEY_CARRIER_SUPPORTED_SATELLITE_SERVICES_PER_PROVIDER_BUNDLE,
3304                 carrierSupportedSatelliteServicesPerProvider);
3305         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
3306                 : mCarrierConfigChangedListenerList) {
3307             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
3308                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
3309             );
3310         }
3311         processAllMessages();
3312 
3313         assertEquals(expectedSatelliteEntitlementPlmnList,
3314                 mSatelliteControllerUT.getSatellitePlmnsForCarrier(SUB_ID));
3315 
3316         // If the Satellite entitlement plmn list read from the DB is empty and carrier config
3317         // plmn list is valid, check whether valid carrier config plmn list is returned when
3318         // calling getSatellitePlmnsForCarrier before the entitlement query.
3319         replaceInstance(SatelliteController.class, "mEntitlementPlmnListPerCarrier",
3320                 mSatelliteControllerUT, new SparseArray<>());
3321         doReturn(new ArrayList<>()).when(
3322                 mMockSubscriptionManagerService).getSatelliteEntitlementPlmnList(anyInt());
3323         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
3324                 : mCarrierConfigChangedListenerList) {
3325             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
3326                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
3327             );
3328         }
3329         processAllMessages();
3330 
3331         assertEquals(carrierConfigPlmnList.stream().sorted().toList(),
3332                 mSatelliteControllerUT.getSatellitePlmnsForCarrier(
3333                         SUB_ID).stream().sorted().toList());
3334     }
3335 
3336     @Test
testHandleEventServiceStateChanged()3337     public void testHandleEventServiceStateChanged() throws Exception {
3338         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
3339         // Do nothing when the satellite is not connected
3340         doReturn(false).when(mServiceState).isUsingNonTerrestrialNetwork();
3341         sendServiceStateChangedEvent();
3342         processAllMessages();
3343         assertEquals(false,
3344                 mSharedPreferences.getBoolean(SATELLITE_SYSTEM_NOTIFICATION_DONE_KEY, false));
3345         verify(mMockNotificationManager, never()).notifyAsUser(anyString(), anyInt(), any(), any());
3346 
3347         // Check sending a system notification when the satellite is connected
3348         doReturn(true).when(mServiceState).isUsingNonTerrestrialNetwork();
3349         sendServiceStateChangedEvent();
3350         processAllMessages();
3351         verify(mMockNotificationManager, times(1)).notifyAsUser(anyString(), anyInt(), any(),
3352                 any());
3353         assertEquals(true,
3354                 mSharedPreferences.getBoolean(SATELLITE_SYSTEM_NOTIFICATION_DONE_KEY, false));
3355 
3356         // Check don't display again after displayed already a system notification.
3357         sendServiceStateChangedEvent();
3358         processAllMessages();
3359         verify(mMockNotificationManager, times(1)).notifyAsUser(anyString(), anyInt(), any(),
3360                 any());
3361     }
3362 
3363     @Test
testRequestSatelliteEnabled_timeout()3364     public void testRequestSatelliteEnabled_timeout() {
3365         mIsSatelliteEnabledSemaphore.drainPermits();
3366         mIIntegerConsumerResults.clear();
3367         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
3368         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
3369         sendProvisionedStateChangedEvent(true, null);
3370         processAllMessages();
3371         verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
3372 
3373         // Successfully disable satellite
3374         mIIntegerConsumerResults.clear();
3375         setUpResponseForRequestSatelliteEnabled(false, false, false, SATELLITE_RESULT_SUCCESS);
3376         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, false, false, false,
3377                 mIIntegerConsumer);
3378         processAllMessages();
3379         assertTrue(waitForIIntegerConsumerResult(1));
3380         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
3381         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
3382 
3383         // Time out to enable satellite
3384         ArgumentCaptor<Message> enableSatelliteResponse = ArgumentCaptor.forClass(Message.class);
3385         mIIntegerConsumerResults.clear();
3386         setUpNoResponseForRequestSatelliteEnabled(true, false, false);
3387         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
3388                 mIIntegerConsumer);
3389         processAllMessages();
3390         assertFalse(waitForIIntegerConsumerResult(1));
3391         verify(mMockSatelliteModemInterface).requestSatelliteEnabled(eq(true), eq(false), eq(false),
3392                 enableSatelliteResponse.capture());
3393 
3394         clearInvocations(mMockSatelliteModemInterface);
3395         moveTimeForward(TEST_WAIT_FOR_SATELLITE_ENABLING_RESPONSE_TIMEOUT_MILLIS);
3396         processAllMessages();
3397         assertTrue(waitForIIntegerConsumerResult(1));
3398         assertEquals(SATELLITE_RESULT_MODEM_TIMEOUT, (long) mIIntegerConsumerResults.get(0));
3399         verify(mMockSatelliteModemInterface).requestSatelliteEnabled(eq(false), eq(false),
3400                 eq(false), any(Message.class));
3401         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
3402 
3403         // Send the response for the above request to enable satellite. SatelliteController should
3404         // ignore the event
3405         Message response = enableSatelliteResponse.getValue();
3406         AsyncResult.forMessage(response, null, null);
3407         response.sendToTarget();
3408         processAllMessages();
3409         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
3410 
3411         // Successfully enable satellite
3412         mIIntegerConsumerResults.clear();
3413         setUpResponseForRequestSatelliteEnabled(true, false, false, SATELLITE_RESULT_SUCCESS);
3414         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
3415                 mIIntegerConsumer);
3416         processAllMessages();
3417         assertTrue(waitForIIntegerConsumerResult(1));
3418         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
3419         verifySatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
3420 
3421         // Time out to disable satellite
3422         ArgumentCaptor<Message> disableSatelliteResponse = ArgumentCaptor.forClass(Message.class);
3423         mIIntegerConsumerResults.clear();
3424         clearInvocations(mMockSatelliteModemInterface);
3425         setUpNoResponseForRequestSatelliteEnabled(false, false, false);
3426         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, false, false, false,
3427                 mIIntegerConsumer);
3428         processAllMessages();
3429         assertFalse(waitForIIntegerConsumerResult(1));
3430         verify(mMockSatelliteModemInterface).requestSatelliteEnabled(eq(false), eq(false),
3431                 eq(false),
3432                 disableSatelliteResponse.capture());
3433 
3434         clearInvocations(mMockSatelliteModemInterface);
3435         moveTimeForward(TEST_WAIT_FOR_SATELLITE_ENABLING_RESPONSE_TIMEOUT_MILLIS);
3436         processAllMessages();
3437         assertTrue(waitForIIntegerConsumerResult(1));
3438         assertEquals(SATELLITE_RESULT_MODEM_TIMEOUT, (long) mIIntegerConsumerResults.get(0));
3439         verify(mMockSatelliteModemInterface, never()).requestSatelliteEnabled(anyBoolean(),
3440                 anyBoolean(), anyBoolean(), any(Message.class));
3441         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
3442 
3443         // Send the response for the above request to disable satellite. SatelliteController should
3444         // ignore the event
3445         response = disableSatelliteResponse.getValue();
3446         AsyncResult.forMessage(response, null, null);
3447         response.sendToTarget();
3448         processAllMessages();
3449         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
3450     }
3451 
3452     @Test
testUpdateNtnSignalStrentghReportWithFeatureFlagEnabled()3453     public void testUpdateNtnSignalStrentghReportWithFeatureFlagEnabled() {
3454         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(true);
3455 
3456         mIsSatelliteEnabledSemaphore.drainPermits();
3457         mIIntegerConsumerResults.clear();
3458         resetSatelliteControllerUT();
3459 
3460         // Successfully provisioned
3461         reset(mMockSatelliteModemInterface);
3462         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
3463         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
3464         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
3465         sendProvisionedStateChangedEvent(true, null);
3466         setUpResponseForRequestIsSatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
3467         sendProvisionedStateChangedEvent(true, null);
3468         processAllMessages();
3469         verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
3470 
3471         // startSendingNtnSignalStrength should be invoked when satellite is enabled
3472         mSatelliteControllerUT.setSettingsKeyForSatelliteModeCalled = false;
3473         mSatelliteControllerUT.setSettingsKeyToAllowDeviceRotationCalled = false;
3474         setUpResponseForRequestSatelliteEnabled(true, false, false, SATELLITE_RESULT_SUCCESS);
3475         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
3476                 mIIntegerConsumer);
3477         processAllMessages();
3478         assertTrue(waitForIIntegerConsumerResult(1));
3479         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
3480         verifySatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
3481         assertTrue(mSatelliteControllerUT.setSettingsKeyForSatelliteModeCalled);
3482         assertTrue(mSatelliteControllerUT.setSettingsKeyToAllowDeviceRotationCalled);
3483         assertEquals(
3484                 SATELLITE_MODE_ENABLED_TRUE, mSatelliteControllerUT.satelliteModeSettingValue);
3485         verify(mMockSatelliteModemInterface, times(1)).startSendingNtnSignalStrength(
3486                 any(Message.class));
3487 
3488         // Ignore request ntn signal strength for redundant enable request
3489         reset(mMockSatelliteModemInterface);
3490         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
3491         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
3492                 mIIntegerConsumer);
3493         processAllMessages();
3494         assertTrue(waitForIIntegerConsumerResult(1));
3495         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
3496         verifySatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
3497         verify(mMockSatelliteModemInterface, never()).startSendingNtnSignalStrength(
3498                 any(Message.class));
3499 
3500         // stopSendingNtnSignalStrength should be invoked when satellite is successfully off.
3501         mIIntegerConsumerResults.clear();
3502         reset(mMockSatelliteModemInterface);
3503         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
3504         setUpResponseForRequestSatelliteEnabled(false, false, false, SATELLITE_RESULT_SUCCESS);
3505         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, false, false, false,
3506                 mIIntegerConsumer);
3507         processAllMessages();
3508         assertTrue(waitForIIntegerConsumerResult(1));
3509         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
3510         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
3511         verify(mMockSatelliteModemInterface, times(1)).stopSendingNtnSignalStrength(
3512                 any(Message.class));
3513 
3514         // Ignore redundant request for stop reporting ntn signal strength.
3515         mIIntegerConsumerResults.clear();
3516         reset(mMockSatelliteModemInterface);
3517         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
3518         mIIntegerConsumerResults.clear();
3519         setUpResponseForRequestSatelliteEnabled(false, false, false, SATELLITE_RESULT_SUCCESS);
3520         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, false, false, false,
3521                 mIIntegerConsumer);
3522         processAllMessages();
3523         assertTrue(waitForIIntegerConsumerResult(1));
3524         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
3525         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
3526         verify(mMockSatelliteModemInterface, never()).stopSendingNtnSignalStrength(
3527                 any(Message.class));
3528 
3529         // startSendingNtnSignalStrength is invoked when satellite is enabled again.
3530         mIIntegerConsumerResults.clear();
3531         reset(mMockSatelliteModemInterface);
3532         doReturn(true).when(mMockSatelliteModemInterface).isSatelliteServiceSupported();
3533         mSatelliteControllerUT.setSettingsKeyForSatelliteModeCalled = false;
3534         mSatelliteControllerUT.setSettingsKeyToAllowDeviceRotationCalled = false;
3535         setUpResponseForRequestSatelliteEnabled(true, false, false, SATELLITE_RESULT_SUCCESS);
3536         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
3537                 mIIntegerConsumer);
3538         processAllMessages();
3539         assertTrue(waitForIIntegerConsumerResult(1));
3540         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
3541         verifySatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
3542         assertTrue(mSatelliteControllerUT.setSettingsKeyForSatelliteModeCalled);
3543         assertTrue(mSatelliteControllerUT.setSettingsKeyToAllowDeviceRotationCalled);
3544         assertEquals(
3545                 SATELLITE_MODE_ENABLED_TRUE, mSatelliteControllerUT.satelliteModeSettingValue);
3546         verify(mMockSatelliteModemInterface, times(1)).startSendingNtnSignalStrength(
3547                 any(Message.class));
3548     }
3549 
3550     @Test
testRegisterForSatelliteSupportedStateChanged_WithFeatureFlagEnabled()3551     public void testRegisterForSatelliteSupportedStateChanged_WithFeatureFlagEnabled() {
3552         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(true);
3553 
3554         Semaphore semaphore = new Semaphore(0);
3555         final boolean[] isSupported  = new boolean[1];
3556         ISatelliteSupportedStateCallback callback =
3557                 new ISatelliteSupportedStateCallback.Stub() {
3558                     @Override
3559                     public void onSatelliteSupportedStateChanged(boolean supported) {
3560                         logd("onSatelliteSupportedStateChanged: supported=" + supported);
3561                         isSupported[0] = supported;
3562                         try {
3563                             semaphore.release();
3564                         } catch (Exception ex) {
3565                             loge("onSatelliteSupportedStateChanged: Got exception in releasing "
3566                                     + "semaphore, ex=" + ex);
3567                         }
3568                     }
3569                 };
3570 
3571         resetSatelliteControllerUT();
3572         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
3573         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
3574         int errorCode = mSatelliteControllerUT.registerForSatelliteSupportedStateChanged(
3575                 SUB_ID, callback);
3576         assertEquals(SATELLITE_RESULT_SUCCESS, errorCode);
3577 
3578         sendSatelliteSupportedStateChangedEvent(true, null);
3579         processAllMessages();
3580         // Verify redundant report is ignored
3581         assertFalse(waitForForEvents(
3582                 semaphore, 1, "testRegisterForSatelliteSupportedStateChanged"));
3583         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
3584 
3585         // Verify updated state is reported
3586         sendSatelliteSupportedStateChangedEvent(false, null);
3587         processAllMessages();
3588         assertTrue(waitForForEvents(
3589                 semaphore, 1, "testRegisterForSatelliteSupportedStateChanged"));
3590         assertEquals(false, isSupported[0]);
3591         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
3592 
3593         // Verify redundant report is ignored
3594         sendSatelliteSupportedStateChangedEvent(false, null);
3595         processAllMessages();
3596         assertFalse(waitForForEvents(
3597                 semaphore, 1, "testRegisterForSatelliteSupportedStateChanged"));
3598         verifySatelliteSupported(false, SATELLITE_RESULT_SUCCESS);
3599 
3600         // Verify updated state is reported
3601         sendSatelliteSupportedStateChangedEvent(true, null);
3602         processAllMessages();
3603         assertTrue(waitForForEvents(
3604                 semaphore, 1, "testRegisterForSatelliteSupportedStateChanged"));
3605         assertEquals(true, isSupported[0]);
3606         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
3607 
3608         // Successfully enable satellite
3609         sendProvisionedStateChangedEvent(true, null);
3610         processAllMessages();
3611         verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
3612         mIIntegerConsumerResults.clear();
3613         setUpResponseForRequestSatelliteEnabled(true, false, false, SATELLITE_RESULT_SUCCESS);
3614         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
3615                 mIIntegerConsumer);
3616         processAllMessages();
3617         assertTrue(waitForIIntegerConsumerResult(1));
3618         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
3619         verifySatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
3620 
3621         // Send satellite is not supported state from modem to disable satellite
3622         setUpResponseForRequestSatelliteEnabled(false, false, false, SATELLITE_RESULT_SUCCESS);
3623         sendSatelliteSupportedStateChangedEvent(false, null);
3624         processAllMessages();
3625         assertTrue(waitForForEvents(
3626                 semaphore, 1, "testRegisterForSatelliteSupportedStateChanged"));
3627         assertEquals(false, isSupported[0]);
3628 
3629         // It is needed to set satellite as support to check whether satellite is enabled or not
3630         sendSatelliteSupportedStateChangedEvent(true, null);
3631         processAllMessages();
3632         assertTrue(waitForForEvents(
3633                 semaphore, 1, "testRegisterForSatelliteSupportedStateChanged"));
3634         assertEquals(true, isSupported[0]);
3635         // Verify satellite was disabled
3636         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
3637 
3638         mSatelliteControllerUT.unregisterForSatelliteSupportedStateChanged(SUB_ID, callback);
3639         sendSatelliteSupportedStateChangedEvent(true, null);
3640         processAllMessages();
3641         assertFalse(waitForForEvents(
3642                 semaphore, 1, "testRegisterForSatelliteSupportedStateChanged"));
3643     }
3644 
3645     @Test
testRegisterForSatelliteSupportedStateChanged_WithFeatureFlagDisabled()3646     public void testRegisterForSatelliteSupportedStateChanged_WithFeatureFlagDisabled() {
3647         when(mFeatureFlags.oemEnabledSatelliteFlag()).thenReturn(false);
3648 
3649         Semaphore semaphore = new Semaphore(0);
3650         ISatelliteSupportedStateCallback callback =
3651                 new ISatelliteSupportedStateCallback.Stub() {
3652                     @Override
3653                     public void onSatelliteSupportedStateChanged(boolean supported) {
3654                         logd("onSatelliteSupportedStateChanged: supported=" + supported);
3655                         try {
3656                             semaphore.release();
3657                         } catch (Exception ex) {
3658                             loge("onSatelliteSupportedStateChanged: Got exception in releasing "
3659                                     + "semaphore, ex=" + ex);
3660                         }
3661                     }
3662                 };
3663         int errorCode = mSatelliteControllerUT.registerForSatelliteSupportedStateChanged(
3664                 SUB_ID, callback);
3665         assertEquals(SATELLITE_RESULT_REQUEST_NOT_SUPPORTED, errorCode);
3666     }
3667 
3668     @Test
testIsSatelliteEmergencyMessagingSupportedViaCarrier()3669     public void testIsSatelliteEmergencyMessagingSupportedViaCarrier() {
3670         // Carrier-enabled flag is off
3671         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(false);
3672         assertFalse(mSatelliteControllerUT.isSatelliteEmergencyMessagingSupportedViaCarrier());
3673 
3674         // Carrier-enabled flag is on and satellite attach is not supported
3675         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
3676         assertFalse(mSatelliteControllerUT.isSatelliteEmergencyMessagingSupportedViaCarrier());
3677 
3678         // Trigger carrier config changed to enable satellite attach
3679         mCarrierConfigBundle.putBoolean(
3680                 CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL, true);
3681         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
3682                 : mCarrierConfigChangedListenerList) {
3683             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
3684                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
3685             );
3686         }
3687         processAllMessages();
3688         assertFalse(mSatelliteControllerUT.isSatelliteEmergencyMessagingSupportedViaCarrier());
3689 
3690         // Trigger carrier config changed to enable satellite attach & emergency messaging
3691         mCarrierConfigBundle.putBoolean(
3692                 CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL, true);
3693         mCarrierConfigBundle.putBoolean(
3694                 CarrierConfigManager.KEY_EMERGENCY_MESSAGING_SUPPORTED_BOOL, true);
3695         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
3696                 : mCarrierConfigChangedListenerList) {
3697             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
3698                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
3699             );
3700         }
3701         processAllMessages();
3702         assertTrue(mSatelliteControllerUT.isSatelliteEmergencyMessagingSupportedViaCarrier());
3703     }
3704 
3705     @Test
testGetCarrierEmergencyCallWaitForConnectionTimeoutMillis()3706     public void testGetCarrierEmergencyCallWaitForConnectionTimeoutMillis() {
3707         // Carrier-enabled flag is off
3708         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(false);
3709         assertEquals(DEFAULT_CARRIER_EMERGENCY_CALL_WAIT_FOR_CONNECTION_TIMEOUT_MILLIS,
3710                 mSatelliteControllerUT.getCarrierEmergencyCallWaitForConnectionTimeoutMillis());
3711 
3712         // Carrier-enabled flag is on
3713         when(mFeatureFlags.carrierEnabledSatelliteFlag()).thenReturn(true);
3714         assertEquals(DEFAULT_CARRIER_EMERGENCY_CALL_WAIT_FOR_CONNECTION_TIMEOUT_MILLIS,
3715                 mSatelliteControllerUT.getCarrierEmergencyCallWaitForConnectionTimeoutMillis());
3716 
3717         // Trigger carrier config changed to enable satellite attach
3718         int timeoutMillisForCarrier1 = 1000;
3719         PersistableBundle carrierConfigBundle1 = new PersistableBundle();
3720         carrierConfigBundle1.putBoolean(
3721                 CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL, true);
3722         carrierConfigBundle1.putBoolean(
3723                 CarrierConfigManager.KEY_EMERGENCY_MESSAGING_SUPPORTED_BOOL, true);
3724         carrierConfigBundle1.putInt(
3725                 KEY_EMERGENCY_CALL_TO_SATELLITE_T911_HANDOVER_TIMEOUT_MILLIS_INT,
3726                 timeoutMillisForCarrier1);
3727         doReturn(carrierConfigBundle1)
3728                 .when(mCarrierConfigManager).getConfigForSubId(eq(SUB_ID), anyVararg());
3729 
3730         int timeoutMillisForCarrier2 = 2000;
3731         PersistableBundle carrierConfigBundle2 = new PersistableBundle();
3732         carrierConfigBundle2.putBoolean(
3733                 CarrierConfigManager.KEY_SATELLITE_ATTACH_SUPPORTED_BOOL, true);
3734         carrierConfigBundle2.putBoolean(
3735                 CarrierConfigManager.KEY_EMERGENCY_MESSAGING_SUPPORTED_BOOL, true);
3736         carrierConfigBundle2.putInt(
3737                 KEY_EMERGENCY_CALL_TO_SATELLITE_T911_HANDOVER_TIMEOUT_MILLIS_INT,
3738                 timeoutMillisForCarrier2);
3739         doReturn(carrierConfigBundle2)
3740                 .when(mCarrierConfigManager).getConfigForSubId(eq(SUB_ID1), anyVararg());
3741 
3742         for (Pair<Executor, CarrierConfigManager.CarrierConfigChangeListener> pair
3743                 : mCarrierConfigChangedListenerList) {
3744             pair.first.execute(() -> pair.second.onCarrierConfigChanged(
3745                     /*slotIndex*/ 0, /*subId*/ SUB_ID, /*carrierId*/ 0, /*specificCarrierId*/ 0)
3746             );
3747         }
3748         processAllMessages();
3749 
3750         // Both phones are not in satellite mode for carrier roaming, and thus the max timeout
3751         // duration - timeoutMillisForCarrier2 - is used
3752         assertEquals(timeoutMillisForCarrier2,
3753                 mSatelliteControllerUT.getCarrierEmergencyCallWaitForConnectionTimeoutMillis());
3754 
3755         // Phone 1 is in satellite mode for carrier roaming
3756         when(mServiceState.isUsingNonTerrestrialNetwork()).thenReturn(true);
3757         assertEquals(timeoutMillisForCarrier1,
3758                 mSatelliteControllerUT.getCarrierEmergencyCallWaitForConnectionTimeoutMillis());
3759 
3760         // Both phones are in satellite mode for carrier roaming. The timeout duration of the first
3761         // phone will be selected
3762         when(mServiceState2.isUsingNonTerrestrialNetwork()).thenReturn(true);
3763         assertEquals(timeoutMillisForCarrier1,
3764                 mSatelliteControllerUT.getCarrierEmergencyCallWaitForConnectionTimeoutMillis());
3765     }
3766 
resetSatelliteControllerUTEnabledState()3767     private void resetSatelliteControllerUTEnabledState() {
3768         logd("resetSatelliteControllerUTEnabledState");
3769         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_RADIO_NOT_AVAILABLE);
3770         doNothing().when(mMockSatelliteModemInterface)
3771                 .setSatelliteServicePackageName(anyString());
3772         mSatelliteControllerUT.setSatelliteServicePackageName("TestSatelliteService");
3773         processAllMessages();
3774 
3775         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
3776         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
3777         sendProvisionedStateChangedEvent(true, null);
3778         processAllMessages();
3779         verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
3780     }
3781 
resetSatelliteControllerUT()3782     private void resetSatelliteControllerUT() {
3783         logd("resetSatelliteControllerUT");
3784         // Trigger cleanUpResources
3785         sendSatelliteModemStateChangedEvent(SATELLITE_MODEM_STATE_UNAVAILABLE, null);
3786         processAllMessages();
3787 
3788         // Reset all cached states
3789         setUpResponseForRequestIsSatelliteSupported(false, SATELLITE_RESULT_RADIO_NOT_AVAILABLE);
3790         doNothing().when(mMockSatelliteModemInterface)
3791                 .setSatelliteServicePackageName(anyString());
3792         mSatelliteControllerUT.setSatelliteServicePackageName("TestSatelliteService");
3793         processAllMessages();
3794     }
3795 
resetSatelliteControllerUTToSupportedAndProvisionedState()3796     private void resetSatelliteControllerUTToSupportedAndProvisionedState() {
3797         resetSatelliteControllerUT();
3798         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
3799         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
3800         sendProvisionedStateChangedEvent(true, null);
3801         processAllMessages();
3802         verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
3803     }
3804 
resetSatelliteControllerUTToOffAndProvisionedState()3805     private void resetSatelliteControllerUTToOffAndProvisionedState() {
3806         resetSatelliteControllerUTToSupportedAndProvisionedState();
3807         // Clean up pending resources and move satellite controller to OFF state.
3808         sendSatelliteModemStateChangedEvent(SATELLITE_MODEM_STATE_UNAVAILABLE, null);
3809         processAllMessages();
3810         verifySatelliteEnabled(false, SATELLITE_RESULT_SUCCESS);
3811     }
3812 
resetSatelliteControllerUTToOnAndProvisionedState()3813     private void resetSatelliteControllerUTToOnAndProvisionedState() {
3814         resetSatelliteControllerUTToOffAndProvisionedState();
3815         setRadioPower(true);
3816         processAllMessages();
3817 
3818         setUpResponseForRequestSatelliteEnabled(true, false, false, SATELLITE_RESULT_SUCCESS);
3819         mSatelliteControllerUT.requestSatelliteEnabled(SUB_ID, true, false, false,
3820                 mIIntegerConsumer);
3821         processAllMessages();
3822         assertTrue(waitForIIntegerConsumerResult(1));
3823         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
3824         verifySatelliteEnabled(true, SATELLITE_RESULT_SUCCESS);
3825     }
3826 
setUpResponseForRequestIsSatelliteEnabled(boolean isSatelliteEnabled, @SatelliteManager.SatelliteResult int error)3827     private void setUpResponseForRequestIsSatelliteEnabled(boolean isSatelliteEnabled,
3828             @SatelliteManager.SatelliteResult int error) {
3829         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
3830                 ? null : new SatelliteException(error);
3831         doAnswer(invocation -> {
3832             Message message = (Message) invocation.getArguments()[0];
3833             int[] enabled = new int[] {isSatelliteEnabled ? 1 : 0};
3834             AsyncResult.forMessage(message, enabled, exception);
3835             message.sendToTarget();
3836             return null;
3837         }).when(mMockSatelliteModemInterface).requestIsSatelliteEnabled(any(Message.class));
3838     }
3839 
setUpResponseForRequestIsSatelliteSupported( boolean isSatelliteSupported, @SatelliteManager.SatelliteResult int error)3840     private void setUpResponseForRequestIsSatelliteSupported(
3841             boolean isSatelliteSupported, @SatelliteManager.SatelliteResult int error) {
3842         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
3843                 ? null : new SatelliteException(error);
3844         doAnswer(invocation -> {
3845             Message message = (Message) invocation.getArguments()[0];
3846             AsyncResult.forMessage(message, isSatelliteSupported, exception);
3847             message.sendToTarget();
3848             return null;
3849         }).when(mMockSatelliteModemInterface).requestIsSatelliteSupported(any(Message.class));
3850     }
3851 
setUpResponseForRequestTimeForNextSatelliteVisibility( int satelliteVisibilityTime, @SatelliteManager.SatelliteResult int error)3852     private void setUpResponseForRequestTimeForNextSatelliteVisibility(
3853             int satelliteVisibilityTime, @SatelliteManager.SatelliteResult int error) {
3854         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
3855                 ? null : new SatelliteException(error);
3856         int[] visibilityTime = new int[]{satelliteVisibilityTime};
3857         doAnswer(invocation -> {
3858             Message message = (Message) invocation.getArguments()[0];
3859             AsyncResult.forMessage(message, visibilityTime, exception);
3860             message.sendToTarget();
3861             return null;
3862         }).when(mMockSatelliteModemInterface)
3863                 .requestTimeForNextSatelliteVisibility(any(Message.class));
3864     }
3865 
setUpNullResponseForRequestTimeForNextSatelliteVisibility( @atelliteManager.SatelliteResult int error)3866     private void setUpNullResponseForRequestTimeForNextSatelliteVisibility(
3867             @SatelliteManager.SatelliteResult int error) {
3868         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
3869                 ? null : new SatelliteException(error);
3870         doAnswer(invocation -> {
3871             Message message = (Message) invocation.getArguments()[0];
3872             AsyncResult.forMessage(message, null, exception);
3873             message.sendToTarget();
3874             return null;
3875         }).when(mMockSatelliteModemInterface)
3876                 .requestTimeForNextSatelliteVisibility(any(Message.class));
3877     }
3878 
setUpResponseForRequestIsSatelliteProvisioned( boolean isSatelliteProvisioned, @SatelliteManager.SatelliteResult int error)3879     private void setUpResponseForRequestIsSatelliteProvisioned(
3880             boolean isSatelliteProvisioned, @SatelliteManager.SatelliteResult int error) {
3881         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
3882                 ? null : new SatelliteException(error);
3883         int[] provisioned = new int[]{isSatelliteProvisioned ? 1 : 0};
3884         doAnswer(invocation -> {
3885             Message message = (Message) invocation.getArguments()[0];
3886             AsyncResult.forMessage(message, provisioned, exception);
3887             message.sendToTarget();
3888             return null;
3889         }).when(mMockSatelliteModemInterface).requestIsSatelliteProvisioned(any(Message.class));
3890     }
3891 
setUpResponseForRequestSatelliteEnabled( boolean enabled, boolean demoMode, boolean emergency, @SatelliteManager.SatelliteResult int error)3892     private void setUpResponseForRequestSatelliteEnabled(
3893             boolean enabled, boolean demoMode, boolean emergency,
3894             @SatelliteManager.SatelliteResult int error) {
3895         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
3896                 ? null : new SatelliteException(error);
3897         doAnswer(invocation -> {
3898             if (exception == null && !enabled) {
3899                 sendSatelliteModemStateChangedEvent(SATELLITE_MODEM_STATE_OFF, null);
3900             }
3901             Message message = (Message) invocation.getArguments()[3];
3902             AsyncResult.forMessage(message, null, exception);
3903             message.sendToTarget();
3904             return null;
3905         }).when(mMockSatelliteModemInterface)
3906                 .requestSatelliteEnabled(eq(enabled), eq(demoMode), eq(emergency),
3907                         any(Message.class));
3908     }
3909 
setUpResponseForRequestSetSatelliteEnabledForCarrier( boolean enabled, @SatelliteManager.SatelliteResult int error)3910     private void setUpResponseForRequestSetSatelliteEnabledForCarrier(
3911             boolean enabled, @SatelliteManager.SatelliteResult int error) {
3912         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
3913                 ? null : new SatelliteException(error);
3914         doAnswer(invocation -> {
3915             Message message = (Message) invocation.getArguments()[2];
3916             AsyncResult.forMessage(message, null, exception);
3917             message.sendToTarget();
3918             return null;
3919         }).when(mMockSatelliteModemInterface)
3920                 .requestSetSatelliteEnabledForCarrier(anyInt(), eq(enabled), any(Message.class));
3921     }
3922 
setUpNoResponseForRequestSatelliteEnabled(boolean enabled, boolean demoMode, boolean emergency)3923     private void setUpNoResponseForRequestSatelliteEnabled(boolean enabled, boolean demoMode,
3924             boolean emergency) {
3925         doNothing().when(mMockSatelliteModemInterface)
3926                 .requestSatelliteEnabled(eq(enabled), eq(demoMode), eq(emergency),
3927                         any(Message.class));
3928     }
3929 
setUpResponseForProvisionSatelliteService( String token, byte[] provisionData, @SatelliteManager.SatelliteResult int error)3930     private void setUpResponseForProvisionSatelliteService(
3931             String token, byte[] provisionData, @SatelliteManager.SatelliteResult int error) {
3932         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
3933                 ? null : new SatelliteException(error);
3934         doAnswer(invocation -> {
3935             Message message = (Message) invocation.getArguments()[2];
3936             AsyncResult.forMessage(message, null, exception);
3937             message.sendToTarget();
3938             return null;
3939         }).when(mMockSatelliteModemInterface)
3940                 .provisionSatelliteService(eq(token), any(byte[].class), any(Message.class));
3941     }
3942 
setUpNoResponseForProvisionSatelliteService(String token)3943     private void setUpNoResponseForProvisionSatelliteService(String token) {
3944         doNothing().when(mMockSatelliteModemInterface)
3945                 .provisionSatelliteService(eq(token), any(), any(Message.class));
3946     }
3947 
setUpResponseForDeprovisionSatelliteService(String token, @SatelliteManager.SatelliteResult int error)3948     private void setUpResponseForDeprovisionSatelliteService(String token,
3949             @SatelliteManager.SatelliteResult int error) {
3950         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
3951                 ? null : new SatelliteException(error);
3952         doAnswer(invocation -> {
3953             Message message = (Message) invocation.getArguments()[1];
3954             AsyncResult.forMessage(message, null, exception);
3955             message.sendToTarget();
3956             return null;
3957         }).when(mMockSatelliteModemInterface)
3958                 .deprovisionSatelliteService(eq(token), any(Message.class));
3959     }
3960 
setUpResponseForRequestSatelliteCapabilities( SatelliteCapabilities satelliteCapabilities, @SatelliteManager.SatelliteResult int error)3961     private void setUpResponseForRequestSatelliteCapabilities(
3962             SatelliteCapabilities satelliteCapabilities,
3963             @SatelliteManager.SatelliteResult int error) {
3964         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
3965                 ? null : new SatelliteException(error);
3966         doAnswer(invocation -> {
3967             Message message = (Message) invocation.getArguments()[0];
3968             AsyncResult.forMessage(message, satelliteCapabilities, exception);
3969             message.sendToTarget();
3970             return null;
3971         }).when(mMockSatelliteModemInterface).requestSatelliteCapabilities(any(Message.class));
3972     }
3973 
setUpResponseForRequestNtnSignalStrength( @tnSignalStrength.NtnSignalStrengthLevel int ntnSignalStrengthLevel, @SatelliteManager.SatelliteResult int error)3974     private void setUpResponseForRequestNtnSignalStrength(
3975             @NtnSignalStrength.NtnSignalStrengthLevel int ntnSignalStrengthLevel,
3976             @SatelliteManager.SatelliteResult int error) {
3977         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
3978                 ? null : new SatelliteException(error);
3979         doAnswer(invocation -> {
3980             Message message = (Message) invocation.getArguments()[0];
3981             AsyncResult.forMessage(message, new NtnSignalStrength(ntnSignalStrengthLevel),
3982                     exception);
3983             message.sendToTarget();
3984             return null;
3985         }).when(mMockSatelliteModemInterface).requestNtnSignalStrength(any(Message.class));
3986     }
3987 
waitForForEvents( Semaphore semaphore, int expectedNumberOfEvents, String caller)3988     private boolean waitForForEvents(
3989             Semaphore semaphore, int expectedNumberOfEvents, String caller) {
3990         for (int i = 0; i < expectedNumberOfEvents; i++) {
3991             try {
3992                 if (!semaphore.tryAcquire(TIMEOUT, TimeUnit.MILLISECONDS)) {
3993                     loge(caller + ": Timeout to receive the expected event");
3994                     return false;
3995                 }
3996             } catch (Exception ex) {
3997                 loge(caller + ": Got exception=" + ex);
3998                 return false;
3999             }
4000         }
4001         return true;
4002     }
4003 
setUpNullResponseForRequestSatelliteCapabilities( @atelliteManager.SatelliteResult int error)4004     private void setUpNullResponseForRequestSatelliteCapabilities(
4005             @SatelliteManager.SatelliteResult int error) {
4006         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
4007                 ? null : new SatelliteException(error);
4008         doAnswer(invocation -> {
4009             Message message = (Message) invocation.getArguments()[0];
4010             AsyncResult.forMessage(message, null, exception);
4011             message.sendToTarget();
4012             return null;
4013         }).when(mMockSatelliteModemInterface).requestSatelliteCapabilities(any(Message.class));
4014     }
4015 
setUpResponseForStartSatelliteTransmissionUpdates( @atelliteManager.SatelliteResult int error)4016     private void setUpResponseForStartSatelliteTransmissionUpdates(
4017             @SatelliteManager.SatelliteResult int error) {
4018         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
4019                 ? null : new SatelliteException(error);
4020         doAnswer(invocation -> {
4021             Message message = (Message) invocation.getArguments()[0];
4022             AsyncResult.forMessage(message, null, exception);
4023             message.sendToTarget();
4024             return null;
4025         }).when(mMockPointingAppController).startSatelliteTransmissionUpdates(any(Message.class));
4026     }
4027 
setUpResponseForStopSatelliteTransmissionUpdates( @atelliteManager.SatelliteResult int error)4028     private void setUpResponseForStopSatelliteTransmissionUpdates(
4029             @SatelliteManager.SatelliteResult int error) {
4030         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
4031                 ? null : new SatelliteException(error);
4032         doAnswer(invocation -> {
4033             Message message = (Message) invocation.getArguments()[0];
4034             AsyncResult.forMessage(message, null, exception);
4035             message.sendToTarget();
4036             return null;
4037         }).when(mMockPointingAppController).stopSatelliteTransmissionUpdates(any(Message.class));
4038     }
4039 
setUpResponseForStartSendingNtnSignalStrength( @atelliteManager.SatelliteResult int error)4040     private void setUpResponseForStartSendingNtnSignalStrength(
4041             @SatelliteManager.SatelliteResult int error) {
4042         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
4043                 ? null : new SatelliteException(error);
4044         doAnswer(invocation -> {
4045             Message message = (Message) invocation.getArguments()[0];
4046             AsyncResult.forMessage(message, null, exception);
4047             message.sendToTarget();
4048             return null;
4049         }).when(mMockSatelliteModemInterface).startSendingNtnSignalStrength(any(Message.class));
4050     }
4051 
setUpResponseForStopSendingNtnSignalStrength( @atelliteManager.SatelliteResult int error)4052     private void setUpResponseForStopSendingNtnSignalStrength(
4053             @SatelliteManager.SatelliteResult int error) {
4054         SatelliteException exception = (error == SATELLITE_RESULT_SUCCESS)
4055                 ? null : new SatelliteException(error);
4056         doAnswer(invocation -> {
4057             Message message = (Message) invocation.getArguments()[0];
4058             AsyncResult.forMessage(message, null, exception);
4059             message.sendToTarget();
4060             return null;
4061         }).when(mMockSatelliteModemInterface).stopSendingNtnSignalStrength(any(Message.class));
4062     }
4063 
waitForRequestIsSatelliteSupportedResult(int expectedNumberOfEvents)4064     private boolean waitForRequestIsSatelliteSupportedResult(int expectedNumberOfEvents) {
4065         for (int i = 0; i < expectedNumberOfEvents; i++) {
4066             try {
4067                 if (!mSatelliteSupportSemaphore.tryAcquire(TIMEOUT, TimeUnit.MILLISECONDS)) {
4068                     loge("Timeout to receive requestIsSatelliteSupported() callback");
4069                     return false;
4070                 }
4071             } catch (Exception ex) {
4072                 loge("waitForRequestIsSatelliteSupportedResult: Got exception=" + ex);
4073                 return false;
4074             }
4075         }
4076         return true;
4077     }
4078 
waitForRequestTimeForNextSatelliteVisibilityResult( int expectedNumberOfEvents)4079     private boolean waitForRequestTimeForNextSatelliteVisibilityResult(
4080             int expectedNumberOfEvents) {
4081         for (int i = 0; i < expectedNumberOfEvents; i++) {
4082             try {
4083                 if (!mSatelliteVisibilityTimeSemaphore.tryAcquire(TIMEOUT, TimeUnit.MILLISECONDS)) {
4084                     loge("Timeout to receive "
4085                             + "requestTimeForNextSatelliteVisibility() callback");
4086                     return false;
4087                 }
4088             } catch (Exception ex) {
4089                 loge("waitForRequestTimeForNextSatelliteVisibilityResult: Got exception=" + ex);
4090                 return false;
4091             }
4092         }
4093         return true;
4094     }
4095 
waitForRequestIsSatelliteEnabledResult(int expectedNumberOfEvents)4096     private boolean waitForRequestIsSatelliteEnabledResult(int expectedNumberOfEvents) {
4097         for (int i = 0; i < expectedNumberOfEvents; i++) {
4098             try {
4099                 if (!mIsSatelliteEnabledSemaphore.tryAcquire(TIMEOUT, TimeUnit.MILLISECONDS)) {
4100                     loge("Timeout to receive requestIsSatelliteEnabled() callback");
4101                     return false;
4102                 }
4103             } catch (Exception ex) {
4104                 loge("waitForRequestIsSatelliteEnabledResult: Got exception=" + ex);
4105                 return false;
4106             }
4107         }
4108         return true;
4109     }
4110 
waitForRequestIsSatelliteProvisionedResult(int expectedNumberOfEvents)4111     private boolean waitForRequestIsSatelliteProvisionedResult(int expectedNumberOfEvents) {
4112         for (int i = 0; i < expectedNumberOfEvents; i++) {
4113             try {
4114                 if (!mIsSatelliteProvisionedSemaphore.tryAcquire(TIMEOUT, TimeUnit.MILLISECONDS)) {
4115                     loge("Timeout to receive requestIsSatelliteProvisioned() callback");
4116                     return false;
4117                 }
4118             } catch (Exception ex) {
4119                 loge("waitForRequestIsSatelliteProvisionedResult: Got exception=" + ex);
4120                 return false;
4121             }
4122         }
4123         return true;
4124     }
4125 
waitForRequestSatelliteCapabilitiesResult(int expectedNumberOfEvents)4126     private boolean waitForRequestSatelliteCapabilitiesResult(int expectedNumberOfEvents) {
4127         for (int i = 0; i < expectedNumberOfEvents; i++) {
4128             try {
4129                 if (!mSatelliteCapabilitiesSemaphore.tryAcquire(TIMEOUT, TimeUnit.MILLISECONDS)) {
4130                     loge("Timeout to receive requestSatelliteCapabilities() callback");
4131                     return false;
4132                 }
4133             } catch (Exception ex) {
4134                 loge("waitForRequestSatelliteCapabilitiesResult: Got exception=" + ex);
4135                 return false;
4136             }
4137         }
4138         return true;
4139     }
4140 
waitForRequestIsDemoModeEnabledResult(int expectedNumberOfEvents)4141     private boolean waitForRequestIsDemoModeEnabledResult(int expectedNumberOfEvents) {
4142         for (int i = 0; i < expectedNumberOfEvents; i++) {
4143             try {
4144                 if (!mIsDemoModeEnabledSemaphore.tryAcquire(TIMEOUT, TimeUnit.MILLISECONDS)) {
4145                     loge("Timeout to receive requestIsDemoModeEnabled() callback");
4146                     return false;
4147                 }
4148             } catch (Exception ex) {
4149                 loge("waitForRequestIsDemoModeEnabled: Got exception=" + ex);
4150                 return false;
4151             }
4152         }
4153         return true;
4154     }
4155 
waitForRequestNtnSignalStrengthResult(int expectedNumberOfEvents)4156     private boolean waitForRequestNtnSignalStrengthResult(int expectedNumberOfEvents) {
4157         for (int i = 0; i < expectedNumberOfEvents; i++) {
4158             try {
4159                 if (!mRequestNtnSignalStrengthSemaphore.tryAcquire(TIMEOUT,
4160                         TimeUnit.MILLISECONDS)) {
4161                     loge("Timeout to receive requestNtnSignalStrength() callback");
4162                     return false;
4163                 }
4164             } catch (Exception ex) {
4165                 loge("requestNtnSignalStrength: Got exception=" + ex);
4166                 return false;
4167             }
4168         }
4169         return true;
4170     }
4171 
waitForIIntegerConsumerResult(int expectedNumberOfEvents)4172     private boolean waitForIIntegerConsumerResult(int expectedNumberOfEvents) {
4173         for (int i = 0; i < expectedNumberOfEvents; i++) {
4174             try {
4175                 if (!mIIntegerConsumerSemaphore.tryAcquire(TIMEOUT, TimeUnit.MILLISECONDS)) {
4176                     loge("Timeout to receive IIntegerConsumer() callback");
4177                     return false;
4178                 }
4179             } catch (Exception ex) {
4180                 loge("waitForIIntegerConsumerResult: Got exception=" + ex);
4181                 return false;
4182             }
4183         }
4184         return true;
4185     }
4186 
verifySatelliteSupported(boolean supported, int expectedErrorCode)4187     private void verifySatelliteSupported(boolean supported, int expectedErrorCode) {
4188         mSatelliteSupportSemaphore.drainPermits();
4189         mSatelliteControllerUT.requestIsSatelliteSupported(SUB_ID, mSatelliteSupportReceiver);
4190         processAllMessages();
4191         assertTrue(waitForRequestIsSatelliteSupportedResult(1));
4192         assertEquals(expectedErrorCode, mQueriedSatelliteSupportedResultCode);
4193         assertEquals(supported, mQueriedSatelliteSupported);
4194     }
4195 
verifySatelliteSupported(TestSatelliteController satelliteController, boolean supported, int expectedErrorCode)4196     private void verifySatelliteSupported(TestSatelliteController satelliteController,
4197             boolean supported, int expectedErrorCode) {
4198         mSatelliteSupportSemaphore.drainPermits();
4199         satelliteController.requestIsSatelliteSupported(SUB_ID, mSatelliteSupportReceiver);
4200         processAllMessages();
4201         assertTrue(waitForRequestIsSatelliteSupportedResult(1));
4202         assertEquals(expectedErrorCode, mQueriedSatelliteSupportedResultCode);
4203         assertEquals(supported, mQueriedSatelliteSupported);
4204     }
4205 
verifySatelliteEnabled(boolean enabled, int expectedErrorCode)4206     private void verifySatelliteEnabled(boolean enabled, int expectedErrorCode) {
4207         mIsSatelliteEnabledSemaphore.drainPermits();
4208         mSatelliteControllerUT.requestIsSatelliteEnabled(SUB_ID, mIsSatelliteEnabledReceiver);
4209         processAllMessages();
4210         assertTrue(waitForRequestIsSatelliteEnabledResult(1));
4211         assertEquals(expectedErrorCode, mQueriedIsSatelliteEnabledResultCode);
4212         assertEquals(enabled, mQueriedIsSatelliteEnabled);
4213     }
4214 
verifySatelliteProvisioned(boolean provisioned, int expectedErrorCode)4215     private void verifySatelliteProvisioned(boolean provisioned, int expectedErrorCode) {
4216         mIsSatelliteProvisionedSemaphore.drainPermits();
4217         mSatelliteControllerUT.requestIsSatelliteProvisioned(
4218                 SUB_ID, mIsSatelliteProvisionedReceiver);
4219         processAllMessages();
4220         assertTrue(waitForRequestIsSatelliteProvisionedResult(1));
4221         assertEquals(expectedErrorCode, mQueriedIsSatelliteProvisionedResultCode);
4222         assertEquals(provisioned, mQueriedIsSatelliteProvisioned);
4223     }
4224 
verifyRequestNtnSignalStrength( @tnSignalStrength.NtnSignalStrengthLevel int signalStrengthLevel, int expectedErrorCode)4225     private void verifyRequestNtnSignalStrength(
4226             @NtnSignalStrength.NtnSignalStrengthLevel int signalStrengthLevel,
4227             int expectedErrorCode) {
4228         mRequestNtnSignalStrengthSemaphore.drainPermits();
4229         mSatelliteControllerUT.requestNtnSignalStrength(SUB_ID, mRequestNtnSignalStrengthReceiver);
4230         processAllMessages();
4231         assertTrue(waitForRequestNtnSignalStrengthResult(1));
4232         assertEquals(expectedErrorCode, mQueriedNtnSignalStrengthResultCode);
4233         assertEquals(signalStrengthLevel, mQueriedNtnSignalStrengthLevel);
4234     }
4235 
sendProvisionedStateChangedEvent(boolean provisioned, Throwable exception)4236     private void sendProvisionedStateChangedEvent(boolean provisioned, Throwable exception) {
4237         Message msg = mSatelliteControllerUT.obtainMessage(
4238                 26 /* EVENT_SATELLITE_PROVISION_STATE_CHANGED */);
4239         msg.obj = new AsyncResult(null, provisioned, exception);
4240         msg.sendToTarget();
4241     }
4242 
sendSatelliteModemStateChangedEvent(int state, Throwable exception)4243     private void sendSatelliteModemStateChangedEvent(int state, Throwable exception) {
4244         Message msg = mSatelliteControllerUT.obtainMessage(
4245                 28 /* EVENT_SATELLITE_MODEM_STATE_CHANGED */);
4246         msg.obj = new AsyncResult(null, state, exception);
4247         msg.sendToTarget();
4248     }
4249 
sendNtnSignalStrengthChangedEvent( @tnSignalStrength.NtnSignalStrengthLevel int ntnSignalStrengthLevel, Throwable exception)4250     private void sendNtnSignalStrengthChangedEvent(
4251             @NtnSignalStrength.NtnSignalStrengthLevel int ntnSignalStrengthLevel,
4252             Throwable exception) {
4253         Message msg = mSatelliteControllerUT.obtainMessage(
4254                 34 /* EVENT_NTN_SIGNAL_STRENGTH_CHANGED */);
4255         msg.obj = new AsyncResult(null, new NtnSignalStrength(ntnSignalStrengthLevel),
4256                 exception);
4257         msg.sendToTarget();
4258     }
4259 
sendCmdStartSendingNtnSignalStrengthChangedEvent(boolean shouldReport)4260     private void sendCmdStartSendingNtnSignalStrengthChangedEvent(boolean shouldReport) {
4261         Message msg = mSatelliteControllerUT.obtainMessage(
4262                 35 /* CMD_UPDATE_NTN_SIGNAL_STRENGTH_REPORTING */);
4263         msg.obj = new AsyncResult(null, shouldReport, null);
4264         msg.sendToTarget();
4265     }
4266 
sendStartSendingNtnSignalStrengthChangedEvent( @tnSignalStrength.NtnSignalStrengthLevel int ntnSignalStrengthLevel, Throwable exception)4267     private void sendStartSendingNtnSignalStrengthChangedEvent(
4268             @NtnSignalStrength.NtnSignalStrengthLevel int ntnSignalStrengthLevel,
4269             Throwable exception) {
4270         Message msg = mSatelliteControllerUT.obtainMessage(
4271                 36 /* EVENT_UPDATE_NTN_SIGNAL_STRENGTH_REPORTING_DONE */);
4272         msg.obj = new AsyncResult(null, new NtnSignalStrength(ntnSignalStrengthLevel),
4273                 exception);
4274         msg.sendToTarget();
4275     }
4276 
sendServiceStateChangedEvent()4277     private void sendServiceStateChangedEvent() {
4278         mSatelliteControllerUT.obtainMessage(37 /* EVENT_SERVICE_STATE_CHANGED */).sendToTarget();
4279     }
4280 
sendSatelliteCapabilitiesChangedEvent(SatelliteCapabilities capabilities, Throwable exception)4281     private void sendSatelliteCapabilitiesChangedEvent(SatelliteCapabilities capabilities,
4282             Throwable exception) {
4283         Message msg = mSatelliteControllerUT.obtainMessage(
4284                 38 /* EVENT_SATELLITE_CAPABILITIES_CHANGED */);
4285         msg.obj = new AsyncResult(null, capabilities, exception);
4286         msg.sendToTarget();
4287     }
4288 
sendSatelliteSupportedStateChangedEvent(boolean supported, Throwable exception)4289     private void sendSatelliteSupportedStateChangedEvent(boolean supported, Throwable exception) {
4290         Message msg = mSatelliteControllerUT.obtainMessage(
4291                 41 /* EVENT_SATELLITE_SUPPORTED_STATE_CHANGED */);
4292         msg.obj = new AsyncResult(null, supported, exception);
4293         msg.sendToTarget();
4294     }
4295 
setRadioPower(boolean on)4296     private void setRadioPower(boolean on) {
4297         mSimulatedCommands.setRadioPower(on, false, false, null);
4298     }
4299 
verifyRegisterForNtnSignalStrengthChanged(int subId, INtnSignalStrengthCallback callback, int expectedError)4300     private void verifyRegisterForNtnSignalStrengthChanged(int subId,
4301             INtnSignalStrengthCallback callback, int expectedError) {
4302         if (expectedError == SATELLITE_RESULT_SUCCESS) {
4303             try {
4304                 mSatelliteControllerUT.registerForNtnSignalStrengthChanged(subId, callback);
4305             } catch (RemoteException ex) {
4306                 throw new AssertionError();
4307             }
4308         } else {
4309             RemoteException ex = assertThrows(RemoteException.class,
4310                     () -> mSatelliteControllerUT.registerForNtnSignalStrengthChanged(subId,
4311                             callback));
4312             assertTrue("The cause is not IllegalStateException",
4313                     ex.getCause() instanceof IllegalStateException);
4314         }
4315     }
4316 
provisionSatelliteService()4317     private void provisionSatelliteService() {
4318         String mText = "This is test provision data.";
4319         byte[] testProvisionData = mText.getBytes();
4320         ICancellationSignal cancelRemote;
4321         mIIntegerConsumerResults.clear();
4322         setUpResponseForRequestIsSatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
4323         setUpResponseForRequestIsSatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
4324         verifySatelliteSupported(true, SATELLITE_RESULT_SUCCESS);
4325         verifySatelliteProvisioned(false, SATELLITE_RESULT_SUCCESS);
4326         setUpResponseForProvisionSatelliteService(TEST_SATELLITE_TOKEN, testProvisionData,
4327                 SATELLITE_RESULT_SUCCESS);
4328         cancelRemote = mSatelliteControllerUT.provisionSatelliteService(SUB_ID,
4329                 TEST_SATELLITE_TOKEN,
4330                 testProvisionData, mIIntegerConsumer);
4331         processAllMessages();
4332         assertTrue(waitForIIntegerConsumerResult(1));
4333         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
4334         assertNotNull(cancelRemote);
4335         verifySatelliteProvisioned(true, SATELLITE_RESULT_SUCCESS);
4336     }
4337 
deprovisionSatelliteService()4338     private void deprovisionSatelliteService() {
4339         mIIntegerConsumerResults.clear();
4340         setUpResponseForDeprovisionSatelliteService(TEST_SATELLITE_TOKEN, SATELLITE_RESULT_SUCCESS);
4341         mSatelliteControllerUT.deprovisionSatelliteService(SUB_ID,
4342                 TEST_SATELLITE_TOKEN, mIIntegerConsumer);
4343         processAllMessages();
4344         assertTrue(waitForIIntegerConsumerResult(1));
4345         assertEquals(SATELLITE_RESULT_SUCCESS, (long) mIIntegerConsumerResults.get(0));
4346     }
4347 
loge(String message)4348     private static void loge(String message) {
4349         Rlog.e(TAG, message);
4350     }
4351 
4352     private static class TestSharedPreferences
4353             implements SharedPreferences, SharedPreferences.Editor {
4354         private HashMap<String, Object> mValues = new HashMap<String, Object>();
4355 
getValueCount()4356         public int getValueCount() {
4357             return mValues.size();
4358         }
4359 
4360         @Override
edit()4361         public Editor edit() {
4362             return this;
4363         }
4364 
4365         @Override
contains(String key)4366         public boolean contains(String key) {
4367             return mValues.containsKey(key);
4368         }
4369 
4370         @Override
getAll()4371         public Map<String, ?> getAll() {
4372             return new HashMap<String, Object>(mValues);
4373         }
4374 
4375         @Override
getBoolean(String key, boolean defValue)4376         public boolean getBoolean(String key, boolean defValue) {
4377             if (mValues.containsKey(key)) {
4378                 return ((Boolean) mValues.get(key)).booleanValue();
4379             }
4380             return defValue;
4381         }
4382 
4383         @Override
getFloat(String key, float defValue)4384         public float getFloat(String key, float defValue) {
4385             if (mValues.containsKey(key)) {
4386                 return ((Float) mValues.get(key)).floatValue();
4387             }
4388             return defValue;
4389         }
4390 
4391         @Override
getInt(String key, int defValue)4392         public int getInt(String key, int defValue) {
4393             if (mValues.containsKey(key)) {
4394                 return ((Integer) mValues.get(key)).intValue();
4395             }
4396             return defValue;
4397         }
4398 
4399         @Override
getLong(String key, long defValue)4400         public long getLong(String key, long defValue) {
4401             if (mValues.containsKey(key)) {
4402                 return ((Long) mValues.get(key)).longValue();
4403             }
4404             return defValue;
4405         }
4406 
4407         @Override
getString(String key, String defValue)4408         public String getString(String key, String defValue) {
4409             if (mValues.containsKey(key)) return (String) mValues.get(key);
4410             else return defValue;
4411         }
4412 
4413         @SuppressWarnings("unchecked")
4414         @Override
getStringSet(String key, Set<String> defValues)4415         public Set<String> getStringSet(String key, Set<String> defValues) {
4416             if (mValues.containsKey(key)) {
4417                 return (Set<String>) mValues.get(key);
4418             }
4419             return defValues;
4420         }
4421 
4422         @Override
registerOnSharedPreferenceChangeListener( OnSharedPreferenceChangeListener listener)4423         public void registerOnSharedPreferenceChangeListener(
4424                 OnSharedPreferenceChangeListener listener) {
4425             throw new UnsupportedOperationException();
4426         }
4427 
4428         @Override
unregisterOnSharedPreferenceChangeListener( OnSharedPreferenceChangeListener listener)4429         public void unregisterOnSharedPreferenceChangeListener(
4430                 OnSharedPreferenceChangeListener listener) {
4431             throw new UnsupportedOperationException();
4432         }
4433 
4434         @Override
putBoolean(String key, boolean value)4435         public Editor putBoolean(String key, boolean value) {
4436             mValues.put(key, Boolean.valueOf(value));
4437             return this;
4438         }
4439 
4440         @Override
putFloat(String key, float value)4441         public Editor putFloat(String key, float value) {
4442             mValues.put(key, value);
4443             return this;
4444         }
4445 
4446         @Override
putInt(String key, int value)4447         public Editor putInt(String key, int value) {
4448             mValues.put(key, value);
4449             return this;
4450         }
4451 
4452         @Override
putLong(String key, long value)4453         public Editor putLong(String key, long value) {
4454             mValues.put(key, value);
4455             return this;
4456         }
4457 
4458         @Override
putString(String key, String value)4459         public Editor putString(String key, String value) {
4460             mValues.put(key, value);
4461             return this;
4462         }
4463 
4464         @Override
putStringSet(String key, Set<String> values)4465         public Editor putStringSet(String key, Set<String> values) {
4466             mValues.put(key, values);
4467             return this;
4468         }
4469 
4470         @Override
remove(String key)4471         public Editor remove(String key) {
4472             mValues.remove(key);
4473             return this;
4474         }
4475 
4476         @Override
clear()4477         public Editor clear() {
4478             mValues.clear();
4479             return this;
4480         }
4481 
4482         @Override
commit()4483         public boolean commit() {
4484             return true;
4485         }
4486 
4487         @Override
apply()4488         public void apply() {
4489             commit();
4490         }
4491     }
4492 
4493     private static class TestSatelliteController extends SatelliteController {
4494         public boolean setSettingsKeyForSatelliteModeCalled = false;
4495         public boolean allRadiosDisabled = true;
4496         public long elapsedRealtime = 0;
4497         public int satelliteModeSettingValue = SATELLITE_MODE_ENABLED_FALSE;
4498         public boolean setSettingsKeyToAllowDeviceRotationCalled = false;
4499 
TestSatelliteController( Context context, Looper looper, @NonNull FeatureFlags featureFlags)4500         TestSatelliteController(
4501                 Context context, Looper looper, @NonNull FeatureFlags featureFlags) {
4502             super(context, looper, featureFlags);
4503             logd("Constructing TestSatelliteController");
4504         }
4505 
4506         @Override
initializeSatelliteModeRadios()4507         protected void initializeSatelliteModeRadios() {
4508             logd("initializeSatelliteModeRadios");
4509         }
4510 
4511         @Override
setSettingsKeyForSatelliteMode(int val)4512         protected void setSettingsKeyForSatelliteMode(int val) {
4513             logd("setSettingsKeyForSatelliteMode: val=" + val);
4514             satelliteModeSettingValue = val;
4515             setSettingsKeyForSatelliteModeCalled = true;
4516         }
4517 
4518         @Override
setSettingsKeyToAllowDeviceRotation(int val)4519         protected void setSettingsKeyToAllowDeviceRotation(int val) {
4520             logd("setSettingsKeyToAllowDeviceRotation: val=" + val);
4521             setSettingsKeyToAllowDeviceRotationCalled = true;
4522         }
4523 
4524         @Override
areAllRadiosDisabled()4525         protected boolean areAllRadiosDisabled() {
4526             return allRadiosDisabled;
4527         }
4528 
4529         @Override
getSupportedNtnRadioTechnology()4530         protected int getSupportedNtnRadioTechnology() {
4531             int ntRadioTechnology = super.getSupportedNtnRadioTechnology();
4532             logd("getCurrentNtnRadioTechnology: val=" + ntRadioTechnology);
4533             return ntRadioTechnology;
4534         }
4535 
4536         @Override
getElapsedRealtime()4537         protected long getElapsedRealtime() {
4538             return elapsedRealtime;
4539         }
4540 
setSatelliteSessionController(SatelliteSessionController satelliteSessionController)4541         void setSatelliteSessionController(SatelliteSessionController satelliteSessionController) {
4542             mSatelliteSessionController = satelliteSessionController;
4543         }
4544     }
4545 }
4546