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.phone.testapps.satellitetestapp;
18 
19 import android.annotation.NonNull;
20 import android.app.Activity;
21 import android.content.Intent;
22 import android.os.Bundle;
23 import android.os.OutcomeReceiver;
24 import android.telephony.SubscriptionInfo;
25 import android.telephony.SubscriptionManager;
26 import android.telephony.satellite.wrapper.CarrierRoamingNtnModeListenerWrapper;
27 import android.telephony.satellite.wrapper.NtnSignalStrengthCallbackWrapper;
28 import android.telephony.satellite.wrapper.NtnSignalStrengthWrapper;
29 import android.telephony.satellite.wrapper.SatelliteCapabilitiesCallbackWrapper;
30 import android.telephony.satellite.wrapper.SatelliteManagerWrapper;
31 import android.util.Log;
32 import android.view.View;
33 import android.view.View.OnClickListener;
34 import android.widget.ArrayAdapter;
35 import android.widget.ListView;
36 
37 import java.util.ArrayList;
38 import java.util.List;
39 import java.util.Map;
40 import java.util.Set;
41 import java.util.concurrent.ExecutorService;
42 import java.util.concurrent.Executors;
43 import java.util.function.Consumer;
44 import java.util.stream.Collectors;
45 
46 /**
47  * Activity related to SatelliteControl APIs for satellite.
48  */
49 public class TestSatelliteWrapper extends Activity {
50     private static final String TAG = "TestSatelliteWrapper";
51     ArrayList<String> mLogMessages = new ArrayList<>();
52     ArrayAdapter<String> mAdapter;
53 
54     private final ExecutorService mExecutor = Executors.newSingleThreadExecutor();
55     private SatelliteManagerWrapper mSatelliteManagerWrapper;
56     private NtnSignalStrengthCallback mNtnSignalStrengthCallback = null;
57     private CarrierRoamingNtnModeListener mCarrierRoamingNtnModeListener = null;
58     private SatelliteCapabilitiesCallbackWrapper mSatelliteCapabilitiesCallback;
59     private SubscriptionManager mSubscriptionManager;
60     private int mSubId;
61 
62     private ListView mLogListView;
63 
64     @Override
onCreate(Bundle savedInstanceState)65     public void onCreate(Bundle savedInstanceState) {
66         super.onCreate(savedInstanceState);
67         mSatelliteManagerWrapper = SatelliteManagerWrapper.getInstance(this);
68         mSubscriptionManager = getSystemService(SubscriptionManager.class);
69         mSubId = getActiveSubId();
70 
71         setContentView(R.layout.activity_TestSatelliteWrapper);
72         findViewById(R.id.requestNtnSignalStrength)
73                 .setOnClickListener(this::requestNtnSignalStrength);
74         findViewById(R.id.registerForNtnSignalStrengthChanged)
75                 .setOnClickListener(this::registerForNtnSignalStrengthChanged);
76         findViewById(R.id.unregisterForNtnSignalStrengthChanged)
77                 .setOnClickListener(this::unregisterForNtnSignalStrengthChanged);
78         findViewById(R.id.isOnlyNonTerrestrialNetworkSubscription)
79                 .setOnClickListener(this::isOnlyNonTerrestrialNetworkSubscription);
80         findViewById(R.id.registerForSatelliteCapabilitiesChanged)
81                 .setOnClickListener(this::registerForCapabilitiesChanged);
82         findViewById(R.id.unregisterForSatelliteCapabilitiesChanged)
83                 .setOnClickListener(this::unregisterForCapabilitiesChanged);
84         findViewById(R.id.isNonTerrestrialNetwork)
85                 .setOnClickListener(this::isNonTerrestrialNetwork);
86         findViewById(R.id.getAvailableServices)
87                 .setOnClickListener(this::getAvailableServices);
88         findViewById(R.id.isUsingNonTerrestrialNetwork)
89                 .setOnClickListener(this::isUsingNonTerrestrialNetwork);
90         findViewById(R.id.requestAttachEnabledForCarrier_enable)
91                 .setOnClickListener(this::requestAttachEnabledForCarrier_enable);
92         findViewById(R.id.requestAttachEnabledForCarrier_disable)
93                 .setOnClickListener(this::requestAttachEnabledForCarrier_disable);
94         findViewById(R.id.requestIsAttachEnabledForCarrier)
95                 .setOnClickListener(this::requestIsAttachEnabledForCarrier);
96         findViewById(R.id.addAttachRestrictionForCarrier)
97                 .setOnClickListener(this::addAttachRestrictionForCarrier);
98         findViewById(R.id.removeAttachRestrictionForCarrier)
99                 .setOnClickListener(this::removeAttachRestrictionForCarrier);
100         findViewById(R.id.getAttachRestrictionReasonsForCarrier)
101                 .setOnClickListener(this::getAttachRestrictionReasonsForCarrier);
102         findViewById(R.id.getSatellitePlmnsForCarrier)
103                 .setOnClickListener(this::getSatellitePlmnsForCarrier);
104         findViewById(R.id.registerForCarrierRoamingNtnModeChanged)
105                 .setOnClickListener(this::registerForCarrierRoamingNtnModeChanged);
106         findViewById(R.id.unregisterForCarrierRoamingNtnModeChanged)
107                 .setOnClickListener(this::unregisterForCarrierRoamingNtnModeChanged);
108         findViewById(R.id.Back).setOnClickListener(new OnClickListener() {
109             @Override
110             public void onClick(View view) {
111                 startActivity(new Intent(TestSatelliteWrapper.this, SatelliteTestApp.class));
112             }
113         });
114         findViewById(R.id.ClearLog).setOnClickListener(new OnClickListener() {
115             @Override
116             public void onClick(View v) {
117                 clearListView();
118             }
119         });
120 
121         mLogListView = findViewById(R.id.logListView);
122         mAdapter = new ArrayAdapter<>(this, R.layout.log_textview, mLogMessages);
123         mLogListView.setAdapter(mAdapter);
124 
125         addLogMessage("TestSatelliteWrapper.onCreate()");
126     }
127 
128 
clearListView()129     private void clearListView() {
130         mLogMessages.clear();
131         mAdapter.notifyDataSetChanged();
132     }
133 
134     @Override
onDestroy()135     protected void onDestroy() {
136         super.onDestroy();
137 
138         if (mSatelliteManagerWrapper != null) {
139             if (mNtnSignalStrengthCallback != null) {
140                 logd("unregisterForNtnSignalStrengthChanged()");
141                 mSatelliteManagerWrapper.unregisterForNtnSignalStrengthChanged(
142                         mNtnSignalStrengthCallback);
143             }
144             if (mSatelliteCapabilitiesCallback != null) {
145                 logd("unregisterForCapabilitiesChanged()");
146                 mSatelliteManagerWrapper.unregisterForCapabilitiesChanged(
147                         mSatelliteCapabilitiesCallback);
148             }
149         }
150         mSubscriptionManager = null;
151         mSatelliteManagerWrapper = null;
152         mExecutor.shutdown();
153     }
154 
requestNtnSignalStrength(View view)155     private void requestNtnSignalStrength(View view) {
156         addLogMessage("requestNtnSignalStrength");
157         logd("requestNtnSignalStrength");
158         OutcomeReceiver<NtnSignalStrengthWrapper,
159                 SatelliteManagerWrapper.SatelliteExceptionWrapper> receiver =
160                 new OutcomeReceiver<>() {
161                     @Override
162                     public void onResult(NtnSignalStrengthWrapper level) {
163                         if (level != null) {
164                             addLogMessage("requestNtnSignalStrength level is " + level.getLevel());
165                         }
166                     }
167 
168                     @Override
169                     public void onError(
170                             SatelliteManagerWrapper.SatelliteExceptionWrapper exception) {
171                         if (exception != null) {
172                             String onError = "requestNtnSignalStrength exception: "
173                                     + translateResultCodeToString(exception.getErrorCode());
174                             logd(onError);
175                             addLogMessage(onError);
176                         }
177                     }
178                 };
179 
180         try {
181             mSatelliteManagerWrapper.requestNtnSignalStrength(mExecutor, receiver);
182         } catch (SecurityException ex) {
183             String errorMessage = "requestNtnSignalStrength: " + ex.getMessage();
184             logd(errorMessage);
185             addLogMessage(errorMessage);
186         }
187     }
188 
registerForCarrierRoamingNtnModeChanged(View view)189     private void registerForCarrierRoamingNtnModeChanged(View view) {
190         addLogMessage("registerForCarrierRoamingNtnModeChanged");
191         logd("registerForCarrierRoamingNtnModeChanged()");
192         if (mCarrierRoamingNtnModeListener == null) {
193             logd("Creating new CarrierRoamingNtnModeListener instance.");
194             mCarrierRoamingNtnModeListener = new CarrierRoamingNtnModeListener();
195         }
196 
197         try {
198             mSatelliteManagerWrapper.registerForCarrierRoamingNtnModeChanged(mSubId, mExecutor,
199                     mCarrierRoamingNtnModeListener);
200         } catch (Exception ex) {
201             String errorMessage = "registerForCarrierRoamingNtnModeChanged: " + ex.getMessage();
202             logd(errorMessage);
203             addLogMessage(errorMessage);
204             mCarrierRoamingNtnModeListener = null;
205         }
206     }
207 
unregisterForCarrierRoamingNtnModeChanged(View view)208     private void unregisterForCarrierRoamingNtnModeChanged(View view) {
209         addLogMessage("unregisterForCarrierRoamingNtnModeChanged");
210         logd("unregisterForCarrierRoamingNtnModeChanged()");
211         if (mCarrierRoamingNtnModeListener != null) {
212             mSatelliteManagerWrapper.unregisterForCarrierRoamingNtnModeChanged(mSubId,
213                     mCarrierRoamingNtnModeListener);
214             mCarrierRoamingNtnModeListener = null;
215             addLogMessage("mCarrierRoamingNtnModeListener was unregistered");
216         } else {
217             addLogMessage("mCarrierRoamingNtnModeListener is null, ignored.");
218         }
219     }
220 
221 
registerForNtnSignalStrengthChanged(View view)222     private void registerForNtnSignalStrengthChanged(View view) {
223         addLogMessage("registerForNtnSignalStrengthChanged");
224         logd("registerForNtnSignalStrengthChanged()");
225         if (mNtnSignalStrengthCallback == null) {
226             logd("create new NtnSignalStrengthCallback instance.");
227             mNtnSignalStrengthCallback = new NtnSignalStrengthCallback();
228         }
229 
230         try {
231             mSatelliteManagerWrapper.registerForNtnSignalStrengthChanged(mExecutor,
232                     mNtnSignalStrengthCallback);
233         } catch (Exception ex) {
234             String errorMessage = "registerForNtnSignalStrengthChanged: " + ex.getMessage();
235             logd(errorMessage);
236             addLogMessage(errorMessage);
237             mNtnSignalStrengthCallback = null;
238         }
239     }
240 
unregisterForNtnSignalStrengthChanged(View view)241     private void unregisterForNtnSignalStrengthChanged(View view) {
242         addLogMessage("unregisterForNtnSignalStrengthChanged");
243         logd("unregisterForNtnSignalStrengthChanged()");
244         if (mNtnSignalStrengthCallback != null) {
245             mSatelliteManagerWrapper.unregisterForNtnSignalStrengthChanged(
246                     mNtnSignalStrengthCallback);
247             mNtnSignalStrengthCallback = null;
248             addLogMessage("mNtnSignalStrengthCallback was unregistered");
249         } else {
250             addLogMessage("mNtnSignalStrengthCallback is null, ignored.");
251         }
252     }
253 
isOnlyNonTerrestrialNetworkSubscription(View view)254     private void isOnlyNonTerrestrialNetworkSubscription(View view) {
255         addLogMessage("isOnlyNonTerrestrialNetworkSubscription");
256         logd("isOnlyNonTerrestrialNetworkSubscription()");
257         List<SubscriptionInfo> infoList = mSubscriptionManager.getAvailableSubscriptionInfoList();
258         List<Integer> subIdList = infoList.stream()
259                 .map(SubscriptionInfo::getSubscriptionId)
260                 .toList();
261 
262         Map<Integer, Boolean> resultMap = subIdList.stream().collect(
263                 Collectors.toMap(
264                         id -> id,
265                         id -> {
266                             boolean result = mSatelliteManagerWrapper
267                                     .isOnlyNonTerrestrialNetworkSubscription(id);
268                             addLogMessage("SatelliteManagerWrapper"
269                                     + ".isOnlyNonTerrestrialNetworkSubscription(" + id + ")");
270                             return result;
271                         }
272                 ));
273 
274         for (Map.Entry<Integer, Boolean> entry : resultMap.entrySet()) {
275             int subId = entry.getKey();
276             boolean result = entry.getValue();
277             addLogMessage("Subscription ID: " + subId + ", Result: " + result);
278         }
279     }
280 
registerForCapabilitiesChanged(View view)281     private void registerForCapabilitiesChanged(View view) {
282         addLogMessage("registerForCapabilitiesChanged");
283         logd("registerForCapabilitiesChanged()");
284         if (mSatelliteCapabilitiesCallback == null) {
285             mSatelliteCapabilitiesCallback =
286                     SatelliteCapabilities -> {
287                         String message = "Received SatelliteCapabillities : "
288                                 + SatelliteCapabilities;
289                         logd(message);
290                         addLogMessage(message);
291                     };
292         }
293 
294         int result = mSatelliteManagerWrapper.registerForCapabilitiesChanged(mExecutor,
295                 mSatelliteCapabilitiesCallback);
296         if (result != SatelliteManagerWrapper.SATELLITE_RESULT_SUCCESS) {
297             String onError = translateResultCodeToString(result);
298             logd(onError);
299             addLogMessage(onError);
300             mSatelliteCapabilitiesCallback = null;
301         }
302     }
303 
unregisterForCapabilitiesChanged(View view)304     private void unregisterForCapabilitiesChanged(View view) {
305         addLogMessage("unregisterForCapabilitiesChanged");
306         logd("unregisterForCapabilitiesChanged()");
307         if (mSatelliteCapabilitiesCallback != null) {
308             mSatelliteManagerWrapper.unregisterForCapabilitiesChanged(
309                     mSatelliteCapabilitiesCallback);
310             mSatelliteCapabilitiesCallback = null;
311             addLogMessage("mSatelliteCapabilitiesCallback was unregistered");
312         } else {
313             addLogMessage("mSatelliteCapabilitiesCallback is null, ignored.");
314         }
315     }
316 
317     public class NtnSignalStrengthCallback implements NtnSignalStrengthCallbackWrapper {
318         @Override
onNtnSignalStrengthChanged( @onNull NtnSignalStrengthWrapper ntnSignalStrength)319         public void onNtnSignalStrengthChanged(
320                 @NonNull NtnSignalStrengthWrapper ntnSignalStrength) {
321             String message = "Received NTN SignalStrength : " + ntnSignalStrength.getLevel();
322             logd(message);
323             addLogMessage(message);
324         }
325     }
326 
327     private class CarrierRoamingNtnModeListener implements CarrierRoamingNtnModeListenerWrapper {
328 
329         @Override
onCarrierRoamingNtnModeChanged(boolean active)330         public void onCarrierRoamingNtnModeChanged(boolean active) {
331             String message = "Received onCarrierRoamingNtnModeChanged active: " + active;
332             logd(message);
333             addLogMessage(message);
334         }
335     }
336 
isNonTerrestrialNetwork(View view)337     private void isNonTerrestrialNetwork(View view) {
338         boolean isNonTerrestrialNetwork = mSatelliteManagerWrapper.isNonTerrestrialNetwork(mSubId);
339         addLogMessage("isNonTerrestrialNetwork=" + isNonTerrestrialNetwork);
340         logd("isNonTerrestrialNetwork=" + isNonTerrestrialNetwork);
341     }
342 
getAvailableServices(View view)343     private void getAvailableServices(View view) {
344         List<Integer> as = mSatelliteManagerWrapper.getAvailableServices(mSubId);
345         String availableServices = as.stream().map(Object::toString).collect(
346                 Collectors.joining(", "));
347         addLogMessage("getAvailableServices=" + availableServices);
348         logd("getAvailableServices=" + availableServices);
349     }
350 
isUsingNonTerrestrialNetwork(View view)351     private void isUsingNonTerrestrialNetwork(View view) {
352         boolean isUsingNonTerrestrialNetwork =
353                 mSatelliteManagerWrapper.isUsingNonTerrestrialNetwork(mSubId);
354         addLogMessage("isUsingNonTerrestrialNetwork=" + isUsingNonTerrestrialNetwork);
355         logd("isUsingNonTerrestrialNetwork=" + isUsingNonTerrestrialNetwork);
356     }
357 
requestAttachEnabledForCarrier_enable(View view)358     private void requestAttachEnabledForCarrier_enable(View view) {
359         addLogMessage("requestAttachEnabledForCarrier");
360         logd("requestAttachEnabledForCarrier");
361 
362         if (mSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
363             addLogMessage("requestAttachEnabledForCarrier: Subscription ID is invalid");
364             logd("requestAttachEnabledForCarrier: Subscription ID is invalid");
365             return;
366         }
367 
368         Consumer<Integer> callback = result -> {
369             addLogMessage("requestAttachEnabledForCarrier result: " + result);
370             logd("requestAttachEnabledForCarrier result: " + result);
371         };
372 
373         try {
374             mSatelliteManagerWrapper.requestAttachEnabledForCarrier(mSubId, true, mExecutor,
375                     callback);
376         } catch (SecurityException | IllegalArgumentException ex) {
377             String errorMessage = "requestAttachEnabledForCarrier: " + ex.getMessage();
378             logd(errorMessage);
379             addLogMessage(errorMessage);
380         }
381     }
382 
requestAttachEnabledForCarrier_disable(View view)383     private void requestAttachEnabledForCarrier_disable(View view) {
384         addLogMessage("requestAttachEnabledForCarrier");
385         logd("requestAttachEnabledForCarrier");
386 
387         if (mSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
388             addLogMessage("requestAttachEnabledForCarrier: Subscription ID is invalid");
389             logd("requestAttachEnabledForCarrier: Subscription ID is invalid");
390             return;
391         }
392 
393         Consumer<Integer> callback = result -> {
394             addLogMessage("requestAttachEnabledForCarrier result: " + result);
395             logd("requestAttachEnabledForCarrier result: " + result);
396         };
397 
398         try {
399             mSatelliteManagerWrapper.requestAttachEnabledForCarrier(mSubId, false, mExecutor,
400                     callback);
401         } catch (SecurityException | IllegalArgumentException ex) {
402             String errorMessage = "requestAttachEnabledForCarrier: " + ex.getMessage();
403             logd(errorMessage);
404             addLogMessage(errorMessage);
405         }
406     }
407 
requestIsAttachEnabledForCarrier(View view)408     private void requestIsAttachEnabledForCarrier(View view) {
409         logd("requestIsAttachEnabledForCarrier");
410         addLogMessage("requestIsAttachEnabledForCarrier");
411 
412         if (mSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
413             addLogMessage("requestIsAttachEnabledForCarrier: Subscription ID is invalid");
414             logd("requestIsAttachEnabledForCarrier: Subscription ID is invalid");
415             return;
416         }
417 
418         OutcomeReceiver<Boolean,
419                 SatelliteManagerWrapper.SatelliteExceptionWrapper> receiver =
420                 new OutcomeReceiver<>() {
421                     @Override
422                     public void onResult(Boolean result) {
423                         logd("requestIsAttachEnabledForCarrier: onResult=" + result);
424                         addLogMessage("requestIsAttachEnabledForCarrier: onResult=" + result);
425                     }
426 
427                     @Override
428                     public void onError(
429                             SatelliteManagerWrapper.SatelliteExceptionWrapper exception) {
430                         if (exception != null) {
431                             String onError = "requestIsAttachEnabledForCarrier exception: "
432                                     + translateResultCodeToString(exception.getErrorCode());
433                             logd(onError);
434                             addLogMessage(onError);
435                         }
436                     }
437                 };
438 
439         try {
440             mSatelliteManagerWrapper.requestIsAttachEnabledForCarrier(mSubId, mExecutor, receiver);
441         } catch (SecurityException | IllegalStateException | IllegalArgumentException ex) {
442             String errorMessage = "requestIsAttachEnabledForCarrier: " + ex.getMessage();
443             logd(errorMessage);
444             addLogMessage(errorMessage);
445         }
446     }
447 
addAttachRestrictionForCarrier(View view)448     private void addAttachRestrictionForCarrier(View view) {
449         addLogMessage("addAttachRestrictionForCarrier");
450         logd("addAttachRestrictionForCarrier");
451 
452         if (mSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
453             addLogMessage("addAttachRestrictionForCarrier: Subscription ID is invalid");
454             logd("addAttachRestrictionForCarrier: Subscription ID is invalid");
455             return;
456         }
457 
458         int reason = SatelliteManagerWrapper.SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER;
459 
460         Consumer<Integer> callback = result -> {
461             addLogMessage("addAttachRestrictionForCarrier result: " + result);
462             logd("addAttachRestrictionForCarrier result: " + result);
463         };
464 
465         try {
466             mSatelliteManagerWrapper.addAttachRestrictionForCarrier(mSubId, reason, mExecutor,
467                     callback);
468         } catch (SecurityException | IllegalArgumentException ex) {
469             String errorMessage = "addAttachRestrictionForCarrier: " + ex.getMessage();
470             logd(errorMessage);
471             addLogMessage(errorMessage);
472         }
473     }
474 
removeAttachRestrictionForCarrier(View view)475     private void removeAttachRestrictionForCarrier(View view) {
476         addLogMessage("removeAttachRestrictionForCarrier");
477         logd("removeAttachRestrictionForCarrier");
478 
479         if (mSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
480             addLogMessage("removeAttachRestrictionForCarrier: Subscription ID is invalid");
481             logd("removeAttachRestrictionForCarrier: Subscription ID is invalid");
482             return;
483         }
484 
485         int reason = SatelliteManagerWrapper.SATELLITE_COMMUNICATION_RESTRICTION_REASON_USER;
486 
487         Consumer<Integer> callback = result -> {
488             addLogMessage("removeAttachRestrictionForCarrier result: " + result);
489             logd("removeAttachRestrictionForCarrier result: " + result);
490         };
491 
492         try {
493             mSatelliteManagerWrapper.removeAttachRestrictionForCarrier(mSubId, reason, mExecutor,
494                     callback);
495         } catch (SecurityException | IllegalArgumentException ex) {
496             String errorMessage = "removeAttachRestrictionForCarrier: " + ex.getMessage();
497             logd(errorMessage);
498             addLogMessage(errorMessage);
499         }
500     }
501 
getAttachRestrictionReasonsForCarrier(View view)502     private void getAttachRestrictionReasonsForCarrier(View view) {
503         addLogMessage("getAttachRestrictionReasonsForCarrier");
504         logd("getAttachRestrictionReasonsForCarrier");
505 
506         if (mSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
507             addLogMessage("getAttachRestrictionReasonsForCarrier: Subscription ID is invalid");
508             logd("getAttachRestrictionReasonsForCarrier: Subscription ID is invalid");
509             return;
510         }
511 
512         try {
513             Set<Integer> reasons = mSatelliteManagerWrapper.getAttachRestrictionReasonsForCarrier(
514                     mSubId);
515             String stringReasons = reasons.stream().map(Object::toString).collect(
516                     Collectors.joining(", "));
517             logd("getAttachRestrictionReasonsForCarrier=" + stringReasons);
518             addLogMessage("getAttachRestrictionReasonsForCarrier=" + stringReasons);
519         } catch (SecurityException | IllegalArgumentException ex) {
520             String errorMessage = "getAttachRestrictionReasonsForCarrier: " + ex.getMessage();
521             logd(errorMessage);
522             addLogMessage(errorMessage);
523         }
524     }
525 
getSatellitePlmnsForCarrier(View view)526     private void getSatellitePlmnsForCarrier(View view) {
527         addLogMessage("getSatellitePlmnsForCarrier");
528         logd("getSatellitePlmnsForCarrier");
529 
530         if (mSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
531             addLogMessage("getSatellitePlmnsForCarrier: Subscription ID is invalid");
532             logd("getSatellitePlmnsForCarrier: Subscription ID is invalid");
533             return;
534         }
535 
536         try {
537             List<String> reasons = mSatelliteManagerWrapper.getSatellitePlmnsForCarrier(
538                     mSubId);
539             String stringReasons = reasons.stream().collect(Collectors.joining(", "));
540             logd("getSatellitePlmnsForCarrier=" + stringReasons);
541             addLogMessage("getSatellitePlmnsForCarrier=" + stringReasons);
542         } catch (SecurityException | IllegalArgumentException ex) {
543             String errorMessage = "getSatellitePlmnsForCarrier: " + ex.getMessage();
544             logd(errorMessage);
545             addLogMessage(errorMessage);
546         }
547     }
548 
getActiveSubId()549     private int getActiveSubId() {
550         int subId;
551         List<SubscriptionInfo> subscriptionInfoList =
552                 mSubscriptionManager.getActiveSubscriptionInfoList();
553 
554         if (subscriptionInfoList != null && subscriptionInfoList.size() > 0) {
555             subId = subscriptionInfoList.get(0).getSubscriptionId();
556         } else {
557             subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
558         }
559         logd("getActiveSubId() returns " + subId);
560         return subId;
561     }
562 
translateResultCodeToString( @atelliteManagerWrapper.SatelliteResult int result)563     private String translateResultCodeToString(
564             @SatelliteManagerWrapper.SatelliteResult int result) {
565         switch (result) {
566             case SatelliteManagerWrapper.SATELLITE_RESULT_SUCCESS:
567                 return "SATELLITE_RESULT_SUCCESS";
568             case SatelliteManagerWrapper.SATELLITE_RESULT_ERROR:
569                 return "SATELLITE_RESULT_ERROR";
570             case SatelliteManagerWrapper.SATELLITE_RESULT_SERVER_ERROR:
571                 return "SATELLITE_RESULT_SERVER_ERROR";
572             case SatelliteManagerWrapper.SATELLITE_RESULT_SERVICE_ERROR:
573                 return "SATELLITE_RESULT_SERVICE_ERROR";
574             case SatelliteManagerWrapper.SATELLITE_RESULT_MODEM_ERROR:
575                 return "SATELLITE_RESULT_MODEM_ERROR";
576             case SatelliteManagerWrapper.SATELLITE_RESULT_NETWORK_ERROR:
577                 return "SATELLITE_RESULT_NETWORK_ERROR";
578             case SatelliteManagerWrapper.SATELLITE_RESULT_INVALID_TELEPHONY_STATE:
579                 return "SATELLITE_RESULT_INVALID_TELEPHONY_STATE";
580             case SatelliteManagerWrapper.SATELLITE_RESULT_INVALID_MODEM_STATE:
581                 return "SATELLITE_RESULT_INVALID_MODEM_STATE";
582             case SatelliteManagerWrapper.SATELLITE_RESULT_INVALID_ARGUMENTS:
583                 return "SATELLITE_RESULT_INVALID_ARGUMENTS";
584             case SatelliteManagerWrapper.SATELLITE_RESULT_REQUEST_FAILED:
585                 return "SATELLITE_RESULT_REQUEST_FAILED";
586             case SatelliteManagerWrapper.SATELLITE_RESULT_RADIO_NOT_AVAILABLE:
587                 return "SATELLITE_RESULT_RADIO_NOT_AVAILABLE";
588             case SatelliteManagerWrapper.SATELLITE_RESULT_REQUEST_NOT_SUPPORTED:
589                 return "SATELLITE_RESULT_REQUEST_NOT_SUPPORTED";
590             case SatelliteManagerWrapper.SATELLITE_RESULT_NO_RESOURCES:
591                 return "SATELLITE_RESULT_NO_RESOURCES";
592             case SatelliteManagerWrapper.SATELLITE_RESULT_SERVICE_NOT_PROVISIONED:
593                 return "SATELLITE_RESULT_SERVICE_NOT_PROVISIONED";
594             case SatelliteManagerWrapper.SATELLITE_RESULT_SERVICE_PROVISION_IN_PROGRESS:
595                 return "SATELLITE_RESULT_SERVICE_PROVISION_IN_PROGRESS";
596             case SatelliteManagerWrapper.SATELLITE_RESULT_REQUEST_ABORTED:
597                 return "SATELLITE_RESULT_REQUEST_ABORTED";
598             case SatelliteManagerWrapper.SATELLITE_RESULT_ACCESS_BARRED:
599                 return "SATELLITE_RESULT_ACCESS_BARRED";
600             case SatelliteManagerWrapper.SATELLITE_RESULT_NETWORK_TIMEOUT:
601                 return "SATELLITE_RESULT_NETWORK_TIMEOUT";
602             case SatelliteManagerWrapper.SATELLITE_RESULT_NOT_REACHABLE:
603                 return "SATELLITE_RESULT_NOT_REACHABLE";
604             case SatelliteManagerWrapper.SATELLITE_RESULT_NOT_AUTHORIZED:
605                 return "SATELLITE_RESULT_NOT_AUTHORIZED";
606             case SatelliteManagerWrapper.SATELLITE_RESULT_NOT_SUPPORTED:
607                 return "SATELLITE_RESULT_NOT_SUPPORTED";
608             case SatelliteManagerWrapper.SATELLITE_RESULT_REQUEST_IN_PROGRESS:
609                 return "SATELLITE_RESULT_REQUEST_IN_PROGRESS";
610             case SatelliteManagerWrapper.SATELLITE_RESULT_MODEM_BUSY:
611                 return "SATELLITE_RESULT_MODEM_BUSY";
612             case SatelliteManagerWrapper.SATELLITE_RESULT_ILLEGAL_STATE:
613                 return "SATELLITE_RESULT_ILLEGAL_STATE";
614             default:
615                 return "INVALID CODE: " + result;
616         }
617     }
618 
addLogMessage(String message)619     private void addLogMessage(String message) {
620         runOnUiThread(() -> {
621             mLogMessages.add(message);
622             mAdapter.notifyDataSetChanged();
623             mLogListView.setSelection(mAdapter.getCount() - 1);
624         });
625     }
626 
logd(String message)627     private static void logd(String message) {
628         if (message != null) {
629             Log.d(TAG, message);
630         }
631     }
632 }
633