• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2021 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.telephony.mockmodem;
18 
19 import android.content.Context;
20 import android.hardware.radio.RadioError;
21 import android.hardware.radio.RadioIndicationType;
22 import android.hardware.radio.RadioResponseInfo;
23 import android.hardware.radio.network.BarringInfo;
24 import android.hardware.radio.network.BarringTypeSpecificInfo;
25 import android.hardware.radio.network.CellIdentity;
26 import android.hardware.radio.network.EmergencyRegResult;
27 import android.hardware.radio.network.IRadioNetwork;
28 import android.hardware.radio.network.IRadioNetworkIndication;
29 import android.hardware.radio.network.IRadioNetworkResponse;
30 import android.hardware.radio.network.NetworkScanRequest;
31 import android.hardware.radio.network.RadioAccessSpecifier;
32 import android.hardware.radio.network.RegState;
33 import android.hardware.radio.network.SignalThresholdInfo;
34 import android.hardware.radio.sim.CardStatus;
35 import android.os.AsyncResult;
36 import android.os.Handler;
37 import android.os.Message;
38 import android.os.RemoteException;
39 import android.telephony.NetworkRegistrationInfo;
40 import android.telephony.mockmodem.MockModemConfigBase.SimInfoChangedResult;
41 import android.util.Log;
42 import android.util.SparseArray;
43 
44 import java.util.ArrayList;
45 
46 public class IRadioNetworkImpl extends IRadioNetwork.Stub {
47     private static final String TAG = "MRNW";
48 
49     private final MockModemService mService;
50     private IRadioNetworkResponse mRadioNetworkResponse;
51     private IRadioNetworkIndication mRadioNetworkIndication;
52     private MockModemConfigInterface mMockModemConfigInterface;
53     private final Object mCacheUpdateMutex;
54     private final Handler mHandler;
55     private int mSubId;
56     private String mTag;
57 
58     // ***** Events
59     static final int EVENT_RADIO_STATE_CHANGED = 1;
60     static final int EVENT_SIM_STATUS_CHANGED = 2;
61     static final int EVENT_PREFERRED_MODE_CHANGED = 3;
62 
63     // ***** Cache of modem attributes/status
64     private int mNetworkTypeBitmap;
65     private int mReasonForDenial;
66     private boolean mNetworkSelectionMode;
67     private boolean mNullCipherAndIntegrityEnabled;
68 
69     private int mRadioState;
70     private boolean mSimReady;
71 
72     private MockNetworkService mServiceState;
73 
IRadioNetworkImpl( MockModemService service, Context context, MockModemConfigInterface configInterface, int instanceId)74     public IRadioNetworkImpl(
75             MockModemService service,
76             Context context,
77             MockModemConfigInterface configInterface,
78             int instanceId) {
79         mTag = TAG + "-" + instanceId;
80         Log.d(mTag, "Instantiated");
81 
82         this.mService = service;
83         mMockModemConfigInterface = configInterface;
84         mCacheUpdateMutex = new Object();
85         mHandler = new IRadioNetworkHandler();
86         mSubId = instanceId;
87         mServiceState = new MockNetworkService(context);
88 
89         // Default network type GPRS|EDGE|UMTS|HSDPA|HSUPA|HSPA|LTE|HSPA+|GSM|LTE_CA|NR
90         mNetworkTypeBitmap =
91                 MockNetworkService.GSM
92                         | MockNetworkService.WCDMA
93                         | MockNetworkService.LTE
94                         | MockNetworkService.NR;
95         mServiceState.updateHighestRegisteredRat(mNetworkTypeBitmap);
96 
97         // Null security algorithms are allowed by default
98         mNullCipherAndIntegrityEnabled = true;
99 
100         mMockModemConfigInterface.registerForRadioStateChanged(
101                 mSubId, mHandler, EVENT_RADIO_STATE_CHANGED, null);
102         mMockModemConfigInterface.registerForCardStatusChanged(
103                 mSubId, mHandler, EVENT_SIM_STATUS_CHANGED, null);
104     }
105 
106     /** Handler class to handle callbacks */
107     private final class IRadioNetworkHandler extends Handler {
108         @Override
handleMessage(Message msg)109         public void handleMessage(Message msg) {
110             AsyncResult ar;
111             synchronized (mCacheUpdateMutex) {
112                 switch (msg.what) {
113                     case EVENT_SIM_STATUS_CHANGED:
114                         Log.d(mTag, "Received EVENT_SIM_STATUS_CHANGED");
115                         boolean oldSimReady = mSimReady;
116                         ar = (AsyncResult) msg.obj;
117                         if (ar != null && ar.exception == null) {
118                             mSimReady = updateSimReady(ar);
119                             if (oldSimReady != mSimReady) {
120                                 updateNetworkStatus();
121                             }
122                         } else {
123                             Log.e(mTag, msg.what + " failure. Exception: " + ar.exception);
124                         }
125                         break;
126 
127                     case EVENT_RADIO_STATE_CHANGED:
128                         Log.d(mTag, "Received EVENT_RADIO_STATE_CHANGED");
129                         int oldRadioState = mRadioState;
130                         ar = (AsyncResult) msg.obj;
131                         if (ar != null && ar.exception == null) {
132                             mRadioState = (int) ar.result;
133                             Log.i(mTag, "Radio state: " + mRadioState);
134                             if (oldRadioState != mRadioState) {
135                                 updateNetworkStatus();
136                             }
137                         } else {
138                             Log.e(mTag, msg.what + " failure. Exception: " + ar.exception);
139                         }
140                         break;
141 
142                     case EVENT_PREFERRED_MODE_CHANGED:
143                         Log.d(mTag, "Received EVENT_PREFERRED_MODE_CHANGED");
144                         mServiceState.updateNetworkStatus(
145                                 MockNetworkService.NETWORK_UPDATE_PREFERRED_MODE_CHANGE);
146                         updateNetworkStatus();
147                         break;
148                 }
149             }
150         }
151     }
152 
153     // Implementation of IRadioNetwork utility functions
154 
notifyServiceStateChange()155     private void notifyServiceStateChange() {
156         Log.d(mTag, "notifyServiceStateChange");
157 
158         Handler handler = mMockModemConfigInterface.getMockModemConfigHandler(mSubId);
159         Message msg =
160                 handler.obtainMessage(
161                         MockModemConfigBase.EVENT_SERVICE_STATE_CHANGE, mServiceState);
162         handler.sendMessage(msg);
163     }
164 
updateNetworkStatus()165     private void updateNetworkStatus() {
166 
167         if (mRadioState != MockModemConfigInterface.RADIO_STATE_ON) {
168             // Update to OOS state
169             mServiceState.updateServiceState(RegState.NOT_REG_MT_NOT_SEARCHING_OP);
170         } else if (!mSimReady) {
171             // Update to Searching state
172             mServiceState.updateServiceState(RegState.NOT_REG_MT_SEARCHING_OP);
173         } else if (mServiceState.isHomeCellExisted() && mServiceState.getIsHomeCamping()) {
174             // Update to Home state
175             mServiceState.updateServiceState(RegState.REG_HOME);
176         } else if (mServiceState.isRoamingCellExisted() && mServiceState.getIsRoamingCamping()) {
177             // Update to Roaming state
178             mServiceState.updateServiceState(RegState.REG_ROAMING);
179         } else {
180             // Update to Searching state
181             mServiceState.updateServiceState(RegState.NOT_REG_MT_SEARCHING_OP);
182         }
183 
184         unsolNetworkStateChanged();
185         unsolCurrentSignalStrength();
186         unsolCellInfoList();
187     }
188 
updateNetworkStatus(int domainBitmask)189     private void updateNetworkStatus(int domainBitmask) {
190         if (mRadioState != MockModemConfigInterface.RADIO_STATE_ON) {
191             // Update to OOS state
192             mServiceState.updateServiceState(RegState.NOT_REG_MT_NOT_SEARCHING_OP, domainBitmask);
193         } else if (!mSimReady) {
194             // Update to Searching state
195             mServiceState.updateServiceState(RegState.NOT_REG_MT_SEARCHING_OP, domainBitmask);
196         } else if (mServiceState.isHomeCellExisted() && mServiceState.getIsHomeCamping()) {
197             // Update to Home state
198             mServiceState.updateServiceState(RegState.REG_HOME, domainBitmask);
199         } else if (mServiceState.isRoamingCellExisted() && mServiceState.getIsRoamingCamping()) {
200             // Update to Roaming state
201             mServiceState.updateServiceState(RegState.REG_ROAMING, domainBitmask);
202         } else {
203             // Update to Searching state
204             mServiceState.updateServiceState(RegState.NOT_REG_MT_SEARCHING_OP, domainBitmask);
205         }
206 
207         unsolNetworkStateChanged();
208         unsolCurrentSignalStrength();
209         unsolCellInfoList();
210     }
211 
updateSimReady(AsyncResult ar)212     private boolean updateSimReady(AsyncResult ar) {
213         String simPlmn = "";
214         CardStatus cardStatus = new CardStatus();
215         cardStatus = (CardStatus) ar.result;
216 
217         if (cardStatus.cardState != CardStatus.STATE_PRESENT) {
218             return false;
219         }
220 
221         int numApplications = cardStatus.applications.length;
222         if (numApplications < 1) {
223             return false;
224         }
225 
226         for (int i = 0; i < numApplications; i++) {
227             android.hardware.radio.sim.AppStatus rilAppStatus = cardStatus.applications[i];
228             if (rilAppStatus.appState == android.hardware.radio.sim.AppStatus.APP_STATE_READY) {
229                 Log.i(mTag, "SIM is ready");
230                 simPlmn = mMockModemConfigInterface.getSimInfo(mSubId,
231                         SimInfoChangedResult.SIM_INFO_TYPE_MCC_MNC, mTag);
232                 mServiceState.updateSimPlmn(simPlmn);
233                 return true;
234             }
235         }
236 
237         mServiceState.updateSimPlmn(simPlmn);
238         return false;
239     }
240 
changeNetworkService(int carrierId, boolean registration)241     public boolean changeNetworkService(int carrierId, boolean registration) {
242         Log.d(mTag, "changeNetworkService: carrier id(" + carrierId + "): " + registration);
243 
244         synchronized (mCacheUpdateMutex) {
245             // TODO: compare carrierId and sim to decide home or roming
246             mServiceState.setServiceStatus(false, registration);
247             updateNetworkStatus();
248         }
249 
250         return true;
251     }
252 
changeNetworkService(int carrierId, boolean registration, int domainBitmask)253     public boolean changeNetworkService(int carrierId, boolean registration, int domainBitmask) {
254         Log.d(
255                 mTag,
256                 "changeNetworkService: carrier id("
257                         + carrierId
258                         + "): "
259                         + registration
260                         + " with domainBitmask = "
261                         + domainBitmask);
262 
263         synchronized (mCacheUpdateMutex) {
264             // TODO: compare carrierId and sim to decide home or roming
265             mServiceState.setServiceStatus(false, registration);
266             updateNetworkStatus(domainBitmask);
267         }
268 
269         return true;
270     }
271 
272     /**
273      * Updates the emergency registration state.
274      * @param regResult the emergency registration state.
275      */
setEmergencyRegResult(MockEmergencyRegResult regResult)276     public void setEmergencyRegResult(MockEmergencyRegResult regResult) {
277         Log.d(mTag, "setEmergencyRegResult");
278 
279         synchronized (mCacheUpdateMutex) {
280             mServiceState.setEmergencyRegResult(convertEmergencyRegResult(regResult));
281         }
282     }
283 
284     /**
285      * Resets the current emergency mode.
286      */
resetEmergencyMode()287     public void resetEmergencyMode() {
288         synchronized (mCacheUpdateMutex) {
289             mServiceState.setEmergencyMode(0);
290         }
291     }
292 
293     /**
294      * Returns the current emergency mode.
295      */
getEmergencyMode()296     public int getEmergencyMode() {
297         Log.d(mTag, "getEmergencyMode");
298 
299         synchronized (mCacheUpdateMutex) {
300             return mServiceState.getEmergencyMode();
301         }
302     }
303 
304     /**
305      * @return whether emergency network scan is triggered.
306      */
isEmergencyNetworkScanTriggered()307     public boolean isEmergencyNetworkScanTriggered() {
308         synchronized (mCacheUpdateMutex) {
309             return mServiceState.isEmergencyNetworkScanTriggered();
310         }
311     }
312 
313     /**
314      * @return whether emergency network scan is canceled.
315      */
isEmergencyNetworkScanCanceled()316     public boolean isEmergencyNetworkScanCanceled() {
317         synchronized (mCacheUpdateMutex) {
318             return mServiceState.isEmergencyNetworkScanCanceled();
319         }
320     }
321 
322     /**
323      * @return the list of preferred network type.
324      */
getEmergencyNetworkScanAccessNetwork()325     public int[] getEmergencyNetworkScanAccessNetwork() {
326         synchronized (mCacheUpdateMutex) {
327             return mServiceState.getEmergencyNetworkScanAccessNetwork();
328         }
329     }
330 
331     /**
332      * @return the preferred scan type.
333      */
getEmergencyNetworkScanType()334     public int getEmergencyNetworkScanType() {
335         synchronized (mCacheUpdateMutex) {
336             return mServiceState.getEmergencyNetworkScanType();
337         }
338     }
339 
340     /**
341      * Resets the emergency network scan attributes.
342      */
resetEmergencyNetworkScan()343     public void resetEmergencyNetworkScan() {
344         synchronized (mCacheUpdateMutex) {
345             mServiceState.resetEmergencyNetworkScan();
346         }
347     }
348 
349     // Implementation of IRadioNetwork functions
350     @Override
getAllowedNetworkTypesBitmap(int serial)351     public void getAllowedNetworkTypesBitmap(int serial) {
352         Log.d(mTag, "getAllowedNetworkTypesBitmap");
353         int networkTypeBitmap = mNetworkTypeBitmap;
354 
355         RadioResponseInfo rsp = mService.makeSolRsp(serial);
356         try {
357             mRadioNetworkResponse.getAllowedNetworkTypesBitmapResponse(rsp, networkTypeBitmap);
358         } catch (RemoteException ex) {
359             Log.e(mTag, "Failed to getAllowedNetworkTypesBitmap from AIDL. Exception" + ex);
360         }
361     }
362 
363     @Override
getAvailableBandModes(int serial)364     public void getAvailableBandModes(int serial) {
365         Log.d(mTag, "getAvailableBandModes");
366 
367         int[] bandModes = new int[0];
368         RadioResponseInfo rsp = mService.makeSolRsp(serial);
369         try {
370             mRadioNetworkResponse.getAvailableBandModesResponse(rsp, bandModes);
371         } catch (RemoteException ex) {
372             Log.e(mTag, "Failed to getAvailableBandModes from AIDL. Exception" + ex);
373         }
374     }
375 
376     @Override
getAvailableNetworks(int serial)377     public void getAvailableNetworks(int serial) {
378         Log.d(mTag, "getAvailableNetworks");
379 
380         android.hardware.radio.network.OperatorInfo[] networkInfos =
381                 new android.hardware.radio.network.OperatorInfo[0];
382         RadioResponseInfo rsp = mService.makeSolRsp(serial);
383         try {
384             mRadioNetworkResponse.getAvailableNetworksResponse(rsp, networkInfos);
385         } catch (RemoteException ex) {
386             Log.e(mTag, "Failed to getAvailableNetworks from AIDL. Exception" + ex);
387         }
388     }
389 
390     @Override
getBarringInfo(int serial)391     public void getBarringInfo(int serial) {
392         Log.d(mTag, "getBarringInfo");
393 
394         CellIdentity cellIdentity;
395         BarringInfo[] barringInfos;
396         synchronized (mCacheUpdateMutex) {
397             cellIdentity = mServiceState.getPrimaryCellIdentity();
398             barringInfos = mServiceState.getBarringInfo();
399         }
400 
401         RadioResponseInfo rsp = mService.makeSolRsp(serial);
402         try {
403             mRadioNetworkResponse.getBarringInfoResponse(rsp, cellIdentity, barringInfos);
404         } catch (RemoteException ex) {
405             Log.e(mTag, "Failed to getBarringInfo from AIDL. Exception" + ex);
406         }
407     }
408 
409     @Override
getCdmaRoamingPreference(int serial)410     public void getCdmaRoamingPreference(int serial) {
411         Log.d(mTag, "getCdmaRoamingPreference");
412         int type = 0;
413         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
414         try {
415             mRadioNetworkResponse.getCdmaRoamingPreferenceResponse(rsp, type);
416         } catch (RemoteException ex) {
417             Log.e(mTag, "Failed to getCdmaRoamingPreference from AIDL. Exception" + ex);
418         }
419     }
420 
421     @Override
getCellInfoList(int serial)422     public void getCellInfoList(int serial) {
423         Log.d(mTag, "getCellInfoList");
424         android.hardware.radio.network.CellInfo[] cells;
425 
426         synchronized (mCacheUpdateMutex) {
427             cells = mServiceState.getCells();
428         }
429 
430         RadioResponseInfo rsp = mService.makeSolRsp(serial);
431         try {
432             mRadioNetworkResponse.getCellInfoListResponse(rsp, cells);
433         } catch (RemoteException ex) {
434             Log.e(mTag, "Failed to getCellInfoList from AIDL. Exception" + ex);
435         }
436     }
437 
438     @Override
getDataRegistrationState(int serial)439     public void getDataRegistrationState(int serial) {
440         Log.d(mTag, "getDataRegistrationState");
441 
442         android.hardware.radio.network.RegStateResult dataRegResponse =
443                 new android.hardware.radio.network.RegStateResult();
444 
445         dataRegResponse.cellIdentity = new android.hardware.radio.network.CellIdentity();
446         dataRegResponse.reasonForDenial = mReasonForDenial;
447 
448         synchronized (mCacheUpdateMutex) {
449             dataRegResponse.regState =
450                     mServiceState.getRegistration(android.hardware.radio.network.Domain.PS);
451             dataRegResponse.rat = mServiceState.getRegistrationRat();
452             if (mServiceState.isInService()) {
453                 dataRegResponse.registeredPlmn =
454                         mServiceState.getPrimaryCellOperatorInfo().operatorNumeric;
455             }
456 
457             dataRegResponse.cellIdentity = mServiceState.getPrimaryCellIdentity();
458         }
459 
460         // TODO: support accessTechnologySpecificInfo
461         dataRegResponse.accessTechnologySpecificInfo =
462                 android.hardware.radio.network.AccessTechnologySpecificInfo.noinit(true);
463 
464         RadioResponseInfo rsp = mService.makeSolRsp(serial);
465         try {
466             mRadioNetworkResponse.getDataRegistrationStateResponse(rsp, dataRegResponse);
467         } catch (RemoteException ex) {
468             Log.e(mTag, "Failed to getRadioCapability from AIDL. Exception" + ex);
469         }
470     }
471 
472     @Override
getImsRegistrationState(int serial)473     public void getImsRegistrationState(int serial) {
474         Log.d(mTag, "getImsRegistrationState");
475         boolean isRegistered = false;
476         int ratFamily = 0;
477         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
478         try {
479             mRadioNetworkResponse.getImsRegistrationStateResponse(rsp, isRegistered, ratFamily);
480         } catch (RemoteException ex) {
481             Log.e(mTag, "Failed to getImsRegistrationState from AIDL. Exception" + ex);
482         }
483     }
484 
485     @Override
getNetworkSelectionMode(int serial)486     public void getNetworkSelectionMode(int serial) {
487         Log.d(mTag, "getNetworkSelectionMode");
488 
489         RadioResponseInfo rsp = mService.makeSolRsp(serial);
490         try {
491             mRadioNetworkResponse.getNetworkSelectionModeResponse(rsp, mNetworkSelectionMode);
492         } catch (RemoteException ex) {
493             Log.e(mTag, "Failed to getNetworkSelectionMode from AIDL. Exception" + ex);
494         }
495     }
496 
497     @Override
getOperator(int serial)498     public void getOperator(int serial) {
499         Log.d(mTag, "getOperator");
500 
501         String longName = "";
502         String shortName = "";
503         String numeric = "";
504 
505         synchronized (mCacheUpdateMutex) {
506             if (mServiceState.isInService()) {
507                 android.hardware.radio.network.OperatorInfo operatorInfo =
508                         mServiceState.getPrimaryCellOperatorInfo();
509                 longName = operatorInfo.alphaLong;
510                 shortName = operatorInfo.alphaShort;
511                 numeric = operatorInfo.operatorNumeric;
512             }
513         }
514         RadioResponseInfo rsp = mService.makeSolRsp(serial);
515         try {
516             mRadioNetworkResponse.getOperatorResponse(rsp, longName, shortName, numeric);
517         } catch (RemoteException ex) {
518             Log.e(mTag, "Failed to getOperator from AIDL. Exception" + ex);
519         }
520     }
521 
522     @Override
getSignalStrength(int serial)523     public void getSignalStrength(int serial) {
524         Log.d(mTag, "getSignalStrength");
525 
526         android.hardware.radio.network.SignalStrength signalStrength =
527                 new android.hardware.radio.network.SignalStrength();
528 
529         synchronized (mCacheUpdateMutex) {
530             if (mServiceState.getIsHomeCamping()
531                     && mRadioState == MockModemConfigInterface.RADIO_STATE_ON) {
532                 signalStrength = mServiceState.getSignalStrength();
533             }
534         }
535 
536         RadioResponseInfo rsp = mService.makeSolRsp(serial);
537         try {
538             mRadioNetworkResponse.getSignalStrengthResponse(rsp, signalStrength);
539         } catch (RemoteException ex) {
540             Log.e(mTag, "Failed to getSignalStrength from AIDL. Exception" + ex);
541         }
542     }
543 
544     @Override
getSystemSelectionChannels(int serial)545     public void getSystemSelectionChannels(int serial) {
546         Log.d(mTag, "getSystemSelectionChannels");
547 
548         android.hardware.radio.network.RadioAccessSpecifier[] specifiers =
549                 new android.hardware.radio.network.RadioAccessSpecifier[0];
550         RadioResponseInfo rsp = mService.makeSolRsp(serial);
551         try {
552             mRadioNetworkResponse.getSystemSelectionChannelsResponse(rsp, specifiers);
553         } catch (RemoteException ex) {
554             Log.e(mTag, "Failed to getSystemSelectionChannels from AIDL. Exception" + ex);
555         }
556     }
557 
558     @Override
getVoiceRadioTechnology(int serial)559     public void getVoiceRadioTechnology(int serial) {
560         Log.d(mTag, "getVoiceRadioTechnology");
561         int rat;
562 
563         synchronized (mCacheUpdateMutex) {
564             rat = mServiceState.getRegistrationRat();
565         }
566 
567         RadioResponseInfo rsp = mService.makeSolRsp(serial);
568         try {
569             mRadioNetworkResponse.getVoiceRadioTechnologyResponse(rsp, rat);
570         } catch (RemoteException ex) {
571             Log.e(mTag, "Failed to getVoiceRadioTechnology from AIDL. Exception" + ex);
572         }
573     }
574 
575     @Override
getVoiceRegistrationState(int serial)576     public void getVoiceRegistrationState(int serial) {
577         Log.d(mTag, "getVoiceRegistrationState");
578 
579         android.hardware.radio.network.RegStateResult voiceRegResponse =
580                 new android.hardware.radio.network.RegStateResult();
581 
582         voiceRegResponse.cellIdentity = new android.hardware.radio.network.CellIdentity();
583         voiceRegResponse.reasonForDenial = mReasonForDenial;
584 
585         synchronized (mCacheUpdateMutex) {
586             voiceRegResponse.regState =
587                     mServiceState.getRegistration(android.hardware.radio.network.Domain.CS);
588             voiceRegResponse.rat = mServiceState.getRegistrationRat();
589             if (mServiceState.isInService()) {
590                 voiceRegResponse.registeredPlmn =
591                         mServiceState.getPrimaryCellOperatorInfo().operatorNumeric;
592             }
593 
594             voiceRegResponse.cellIdentity = mServiceState.getPrimaryCellIdentity();
595         }
596 
597         // TODO: support accessTechnologySpecificInfo
598         voiceRegResponse.accessTechnologySpecificInfo =
599                 android.hardware.radio.network.AccessTechnologySpecificInfo.noinit(true);
600 
601         RadioResponseInfo rsp = mService.makeSolRsp(serial);
602         try {
603             mRadioNetworkResponse.getVoiceRegistrationStateResponse(rsp, voiceRegResponse);
604         } catch (RemoteException ex) {
605             Log.e(mTag, "Failed to getVoiceRegistrationState from AIDL. Exception" + ex);
606         }
607     }
608 
609     @Override
isNrDualConnectivityEnabled(int serial)610     public void isNrDualConnectivityEnabled(int serial) {
611         Log.d(mTag, "isNrDualConnectivityEnabled");
612         boolean isEnabled = false;
613         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
614         try {
615             mRadioNetworkResponse.isNrDualConnectivityEnabledResponse(rsp, isEnabled);
616         } catch (RemoteException ex) {
617             Log.e(mTag, "Failed to isNrDualConnectivityEnabled from AIDL. Exception" + ex);
618         }
619     }
620 
621     @Override
responseAcknowledgement()622     public void responseAcknowledgement() {
623         Log.d(mTag, "responseAcknowledgement");
624     }
625 
626     @Override
setAllowedNetworkTypesBitmap(int serial, int networkTypeBitmap)627     public void setAllowedNetworkTypesBitmap(int serial, int networkTypeBitmap) {
628         Log.d(mTag, "setAllowedNetworkTypesBitmap");
629         boolean isModeChange = false;
630 
631         if (mNetworkTypeBitmap != networkTypeBitmap) {
632             mNetworkTypeBitmap = networkTypeBitmap;
633             synchronized (mCacheUpdateMutex) {
634                 isModeChange = mServiceState.updateHighestRegisteredRat(mNetworkTypeBitmap);
635             }
636             if (isModeChange) {
637                 mHandler.obtainMessage(EVENT_PREFERRED_MODE_CHANGED).sendToTarget();
638             }
639         }
640 
641         RadioResponseInfo rsp = mService.makeSolRsp(serial);
642         try {
643             mRadioNetworkResponse.setAllowedNetworkTypesBitmapResponse(rsp);
644         } catch (RemoteException ex) {
645             Log.e(mTag, "Failed to setAllowedNetworkTypesBitmap from AIDL. Exception" + ex);
646         }
647     }
648 
649     @Override
setBandMode(int serial, int mode)650     public void setBandMode(int serial, int mode) {
651         Log.d(mTag, "setBandMode");
652 
653         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
654         try {
655             mRadioNetworkResponse.setBandModeResponse(rsp);
656         } catch (RemoteException ex) {
657             Log.e(mTag, "Failed to setBandMode from AIDL. Exception" + ex);
658         }
659     }
660 
661     @Override
setBarringPassword( int serial, String facility, String oldPassword, String newPassword)662     public void setBarringPassword(
663             int serial, String facility, String oldPassword, String newPassword) {
664         Log.d(mTag, "setBarringPassword");
665 
666         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
667         try {
668             mRadioNetworkResponse.setBarringPasswordResponse(rsp);
669         } catch (RemoteException ex) {
670             Log.e(mTag, "Failed to setBarringPassword from AIDL. Exception" + ex);
671         }
672     }
673 
674     @Override
setCdmaRoamingPreference(int serial, int type)675     public void setCdmaRoamingPreference(int serial, int type) {
676         Log.d(mTag, "setCdmaRoamingPreference");
677 
678         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
679         try {
680             mRadioNetworkResponse.setCdmaRoamingPreferenceResponse(rsp);
681         } catch (RemoteException ex) {
682             Log.e(mTag, "Failed to setCdmaRoamingPreference from AIDL. Exception" + ex);
683         }
684     }
685 
686     @Override
setCellInfoListRate(int serial, int rate)687     public void setCellInfoListRate(int serial, int rate) {
688         Log.d(mTag, "setCellInfoListRate");
689 
690         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
691         try {
692             mRadioNetworkResponse.setCellInfoListRateResponse(rsp);
693         } catch (RemoteException ex) {
694             Log.e(mTag, "Failed to setCellInfoListRate from AIDL. Exception" + ex);
695         }
696     }
697 
698     @Override
setIndicationFilter(int serial, int indicationFilter)699     public void setIndicationFilter(int serial, int indicationFilter) {
700         Log.d(mTag, "setIndicationFilter");
701 
702         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
703         try {
704             mRadioNetworkResponse.setIndicationFilterResponse(rsp);
705         } catch (RemoteException ex) {
706             Log.e(mTag, "Failed to setIndicationFilter from AIDL. Exception" + ex);
707         }
708     }
709 
710     @Override
setLinkCapacityReportingCriteria( int serial, int hysteresisMs, int hysteresisDlKbps, int hysteresisUlKbps, int[] thresholdsDownlinkKbps, int[] thresholdsUplinkKbps, int accessNetwork)711     public void setLinkCapacityReportingCriteria(
712             int serial,
713             int hysteresisMs,
714             int hysteresisDlKbps,
715             int hysteresisUlKbps,
716             int[] thresholdsDownlinkKbps,
717             int[] thresholdsUplinkKbps,
718             int accessNetwork) {
719         Log.d(mTag, "setLinkCapacityReportingCriteria");
720 
721         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
722         try {
723             mRadioNetworkResponse.setLinkCapacityReportingCriteriaResponse(rsp);
724         } catch (RemoteException ex) {
725             Log.e(mTag, "Failed to setLinkCapacityReportingCriteria from AIDL. Exception" + ex);
726         }
727     }
728 
729     @Override
setLocationUpdates(int serial, boolean enable)730     public void setLocationUpdates(int serial, boolean enable) {
731         Log.d(mTag, "setLocationUpdates");
732 
733         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
734         try {
735             mRadioNetworkResponse.setLocationUpdatesResponse(rsp);
736         } catch (RemoteException ex) {
737             Log.e(mTag, "Failed to setLocationUpdates from AIDL. Exception" + ex);
738         }
739     }
740 
741     @Override
setNetworkSelectionModeAutomatic(int serial)742     public void setNetworkSelectionModeAutomatic(int serial) {
743         Log.d(mTag, "setNetworkSelectionModeAutomatic");
744 
745         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
746         try {
747             mRadioNetworkResponse.setNetworkSelectionModeAutomaticResponse(rsp);
748         } catch (RemoteException ex) {
749             Log.e(mTag, "Failed to setNetworkSelectionModeAutomatic from AIDL. Exception" + ex);
750         }
751     }
752 
753     @Override
setNetworkSelectionModeManual(int serial, String operatorNumeric, int ran)754     public void setNetworkSelectionModeManual(int serial, String operatorNumeric, int ran) {
755         Log.d(mTag, "setNetworkSelectionModeManual");
756 
757         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
758         try {
759             mRadioNetworkResponse.setNetworkSelectionModeManualResponse(rsp);
760         } catch (RemoteException ex) {
761             Log.e(mTag, "Failed to setNetworkSelectionModeManual from AIDL. Exception" + ex);
762         }
763     }
764 
765     @Override
setNrDualConnectivityState(int serial, byte nrDualConnectivityState)766     public void setNrDualConnectivityState(int serial, byte nrDualConnectivityState) {
767         Log.d(mTag, "setNrDualConnectivityState");
768 
769         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
770         try {
771             mRadioNetworkResponse.setNrDualConnectivityStateResponse(rsp);
772         } catch (RemoteException ex) {
773             Log.e(mTag, "Failed to setNrDualConnectivityState from AIDL. Exception" + ex);
774         }
775     }
776 
777     @Override
setResponseFunctions( IRadioNetworkResponse radioNetworkResponse, IRadioNetworkIndication radioNetworkIndication)778     public void setResponseFunctions(
779             IRadioNetworkResponse radioNetworkResponse,
780             IRadioNetworkIndication radioNetworkIndication) {
781         Log.d(mTag, "setResponseFunctions");
782         mRadioNetworkResponse = radioNetworkResponse;
783         mRadioNetworkIndication = radioNetworkIndication;
784         mService.countDownLatch(MockModemService.LATCH_RADIO_INTERFACES_READY);
785     }
786 
787     @Override
setSignalStrengthReportingCriteria( int serial, SignalThresholdInfo[] signalThresholdInfos)788     public void setSignalStrengthReportingCriteria(
789             int serial, SignalThresholdInfo[] signalThresholdInfos) {
790         Log.d(mTag, "setSignalStrengthReportingCriteria");
791 
792         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
793         try {
794             mRadioNetworkResponse.setSignalStrengthReportingCriteriaResponse(rsp);
795         } catch (RemoteException ex) {
796             Log.e(mTag, "Failed to setSignalStrengthReportingCriteria from AIDL. Exception" + ex);
797         }
798     }
799 
800     @Override
setSuppServiceNotifications(int serial, boolean enable)801     public void setSuppServiceNotifications(int serial, boolean enable) {
802         Log.d(mTag, "setSuppServiceNotifications");
803 
804         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
805         try {
806             mRadioNetworkResponse.setSuppServiceNotificationsResponse(rsp);
807         } catch (RemoteException ex) {
808             Log.e(mTag, "Failed to setSuppServiceNotifications from AIDL. Exception" + ex);
809         }
810     }
811 
812     @Override
setSystemSelectionChannels( int serial, boolean specifyChannels, RadioAccessSpecifier[] specifiers)813     public void setSystemSelectionChannels(
814             int serial, boolean specifyChannels, RadioAccessSpecifier[] specifiers) {
815         Log.d(mTag, "setSystemSelectionChannels");
816 
817         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
818         try {
819             mRadioNetworkResponse.setSystemSelectionChannelsResponse(rsp);
820         } catch (RemoteException ex) {
821             Log.e(mTag, "Failed to setSystemSelectionChannels from AIDL. Exception" + ex);
822         }
823     }
824 
825     @Override
startNetworkScan(int serial, NetworkScanRequest request)826     public void startNetworkScan(int serial, NetworkScanRequest request) {
827         Log.d(mTag, "startNetworkScan");
828 
829         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
830         try {
831             mRadioNetworkResponse.startNetworkScanResponse(rsp);
832         } catch (RemoteException ex) {
833             Log.e(mTag, "Failed to startNetworkScan from AIDL. Exception" + ex);
834         }
835     }
836 
837     @Override
stopNetworkScan(int serial)838     public void stopNetworkScan(int serial) {
839         Log.d(mTag, "stopNetworkScan");
840 
841         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
842         try {
843             mRadioNetworkResponse.stopNetworkScanResponse(rsp);
844         } catch (RemoteException ex) {
845             Log.e(mTag, "Failed to stopNetworkScan from AIDL. Exception" + ex);
846         }
847     }
848 
849     @Override
supplyNetworkDepersonalization(int serial, String netPin)850     public void supplyNetworkDepersonalization(int serial, String netPin) {
851         Log.d(mTag, "supplyNetworkDepersonalization");
852         int remainingRetries = 0;
853 
854         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
855         try {
856             mRadioNetworkResponse.supplyNetworkDepersonalizationResponse(rsp, remainingRetries);
857         } catch (RemoteException ex) {
858             Log.e(mTag, "Failed to supplyNetworkDepersonalization from AIDL. Exception" + ex);
859         }
860     }
861 
862     @Override
setUsageSetting(int serial, int usageSetting)863     public void setUsageSetting(int serial, int usageSetting) {
864         Log.d(mTag, "setUsageSetting");
865         int remainingRetries = 0;
866 
867         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
868         try {
869             mRadioNetworkResponse.setUsageSettingResponse(rsp);
870         } catch (RemoteException ex) {
871             Log.e(mTag, "Failed to setUsageSetting from AIDL. Exception" + ex);
872         }
873     }
874 
875     @Override
getUsageSetting(int serial)876     public void getUsageSetting(int serial) {
877         Log.d(mTag, "getUsageSetting");
878 
879         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
880         try {
881             mRadioNetworkResponse.getUsageSettingResponse(rsp, -1 /* Invalid value */);
882         } catch (RemoteException ex) {
883             Log.e(mTag, "Failed to getUsageSetting from AIDL. Exception" + ex);
884         }
885     }
886 
887     @Override
setEmergencyMode(int serial, int emcModeType)888     public void setEmergencyMode(int serial, int emcModeType) {
889         Log.d(TAG, "setEmergencyMode");
890 
891         EmergencyRegResult result;
892         synchronized (mCacheUpdateMutex) {
893             mServiceState.setEmergencyMode(emcModeType);
894             result = mServiceState.getEmergencyRegResult();
895         }
896 
897         RadioResponseInfo rsp = mService.makeSolRsp(serial);
898         try {
899             mRadioNetworkResponse.setEmergencyModeResponse(rsp, result);
900         } catch (RemoteException ex) {
901             Log.e(TAG, "Failed to setEmergencyMode from AIDL. Exception" + ex);
902         }
903     }
904 
905     @Override
triggerEmergencyNetworkScan(int serial, android.hardware.radio.network.EmergencyNetworkScanTrigger request)906     public void triggerEmergencyNetworkScan(int serial,
907             android.hardware.radio.network.EmergencyNetworkScanTrigger request) {
908         Log.d(TAG, "triggerEmergencyNetworkScan");
909 
910         synchronized (mCacheUpdateMutex) {
911             mServiceState.setEmergencyNetworkScanTriggered(true,
912                     request.accessNetwork, request.scanType);
913         }
914 
915         RadioResponseInfo rsp = mService.makeSolRsp(serial);
916         try {
917             mRadioNetworkResponse.triggerEmergencyNetworkScanResponse(rsp);
918         } catch (RemoteException ex) {
919             Log.e(TAG, "Failed to triggerEmergencyNetworkScan from AIDL. Exception" + ex);
920         }
921     }
922 
923     @Override
cancelEmergencyNetworkScan(int serial, boolean resetScan)924     public void cancelEmergencyNetworkScan(int serial, boolean resetScan) {
925         Log.d(TAG, "cancelEmergencyNetworkScan");
926 
927         synchronized (mCacheUpdateMutex) {
928             mServiceState.setEmergencyNetworkScanCanceled(true);
929         }
930 
931         RadioResponseInfo rsp = mService.makeSolRsp(serial);
932         try {
933             mRadioNetworkResponse.cancelEmergencyNetworkScanResponse(rsp);
934         } catch (RemoteException ex) {
935             Log.e(TAG, "Failed to cancelEmergencyNetworkScan from AIDL. Exception" + ex);
936         }
937     }
938 
939     @Override
exitEmergencyMode(int serial)940     public void exitEmergencyMode(int serial) {
941         Log.d(TAG, "exitEmergencyMode");
942 
943         synchronized (mCacheUpdateMutex) {
944             mServiceState.setEmergencyMode(0);
945         }
946 
947         RadioResponseInfo rsp = mService.makeSolRsp(serial);
948         try {
949             mRadioNetworkResponse.exitEmergencyModeResponse(rsp);
950         } catch (RemoteException ex) {
951             Log.e(TAG, "Failed to exitEmergencyMode from AIDL. Exception" + ex);
952         }
953     }
954 
955     @Override
setNullCipherAndIntegrityEnabled(int serial, boolean isEnabled)956     public void setNullCipherAndIntegrityEnabled(int serial, boolean isEnabled) {
957         Log.d(TAG, "setNullCipherAndIntegrityEnabled");
958 
959         mNullCipherAndIntegrityEnabled = isEnabled;
960 
961         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.NONE);
962         try {
963             mRadioNetworkResponse.setNullCipherAndIntegrityEnabledResponse(rsp);
964         } catch (RemoteException ex) {
965             Log.e(TAG, "Failed to setNullCipherAndIntegrityEnabled from AIDL. Exception " + ex);
966         }
967     }
968 
969     @Override
isNullCipherAndIntegrityEnabled(int serial)970     public void isNullCipherAndIntegrityEnabled(int serial) {
971         Log.d(TAG, "isNullCipherAndIntegrityEnabled");
972 
973         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.NONE);
974         try {
975             mRadioNetworkResponse.isNullCipherAndIntegrityEnabledResponse(rsp,
976                     mNullCipherAndIntegrityEnabled);
977         } catch (RemoteException ex) {
978             Log.e(TAG, "Failed to call isNullCipherAndIntegrityEnabled from AIDL. Exception " + ex);
979         }
980     }
981 
982     @Override
isN1ModeEnabled(int serial)983     public void isN1ModeEnabled(int serial) {
984         Log.d(TAG, "isN1ModeEnabled");
985 
986         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
987         try {
988             mRadioNetworkResponse.isN1ModeEnabledResponse(rsp, false);
989         } catch (RemoteException ex) {
990             Log.e(TAG, "Failed to isN1ModeEnabled from AIDL. Exception " + ex);
991         }
992     }
993 
994     @Override
setN1ModeEnabled(int serial, boolean enable)995     public void setN1ModeEnabled(int serial, boolean enable) {
996         Log.d(TAG, "setN1ModeEnabled");
997 
998         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
999         try {
1000             mRadioNetworkResponse.setN1ModeEnabledResponse(rsp);
1001         } catch (RemoteException ex) {
1002             Log.e(TAG, "Failed to setN1ModeEnabled from AIDL. Exception " + ex);
1003         }
1004     }
1005 
1006     @Override
getInterfaceHash()1007     public String getInterfaceHash() {
1008         return IRadioNetwork.HASH;
1009     }
1010 
1011     @Override
getInterfaceVersion()1012     public int getInterfaceVersion() {
1013         return IRadioNetwork.VERSION;
1014     }
1015 
unsolNetworkStateChanged()1016     public void unsolNetworkStateChanged() {
1017         Log.d(mTag, "unsolNetworkStateChanged");
1018 
1019         // Notify other module
1020         notifyServiceStateChange();
1021 
1022         if (mRadioNetworkIndication != null) {
1023             try {
1024                 mRadioNetworkIndication.networkStateChanged(RadioIndicationType.UNSOLICITED);
1025             } catch (RemoteException ex) {
1026                 Log.e(mTag, "Failed to invoke networkStateChanged from AIDL. Exception" + ex);
1027             }
1028         } else {
1029             Log.e(mTag, "null mRadioNetworkIndication");
1030         }
1031     }
1032 
unsolCurrentSignalStrength()1033     public void unsolCurrentSignalStrength() {
1034         Log.d(mTag, "unsolCurrentSignalStrength");
1035         if (mRadioState != MockModemConfigInterface.RADIO_STATE_ON) {
1036             return;
1037         }
1038 
1039         if (mRadioNetworkIndication != null) {
1040             android.hardware.radio.network.SignalStrength signalStrength =
1041                     new android.hardware.radio.network.SignalStrength();
1042 
1043             synchronized (mCacheUpdateMutex) {
1044                 signalStrength = mServiceState.getSignalStrength();
1045             }
1046 
1047             try {
1048                 mRadioNetworkIndication.currentSignalStrength(
1049                         RadioIndicationType.UNSOLICITED, signalStrength);
1050             } catch (RemoteException ex) {
1051                 Log.e(
1052                         mTag,
1053                         "Failed to invoke currentSignalStrength change from AIDL. Exception" + ex);
1054             }
1055         } else {
1056             Log.e(mTag, "null mRadioNetworkIndication");
1057         }
1058     }
1059 
unsolCellInfoList()1060     public void unsolCellInfoList() {
1061         Log.d(mTag, "unsolCellInfoList");
1062 
1063         if (mRadioState != MockModemConfigInterface.RADIO_STATE_ON) {
1064             return;
1065         }
1066 
1067         if (mRadioNetworkIndication != null) {
1068             android.hardware.radio.network.CellInfo[] cells;
1069 
1070             synchronized (mCacheUpdateMutex) {
1071                 cells = mServiceState.getCells();
1072             }
1073             try {
1074                 mRadioNetworkIndication.cellInfoList(RadioIndicationType.UNSOLICITED, cells);
1075             } catch (RemoteException ex) {
1076                 Log.e(mTag, "Failed to invoke cellInfoList change from AIDL. Exception" + ex);
1077             }
1078         } else {
1079             Log.e(mTag, "null mRadioNetworkIndication");
1080         }
1081     }
1082 
unsolBarringInfoChanged( SparseArray<android.telephony.BarringInfo.BarringServiceInfo> barringServiceInfos)1083     public boolean unsolBarringInfoChanged(
1084             SparseArray<android.telephony.BarringInfo.BarringServiceInfo> barringServiceInfos) {
1085         Log.d(mTag, "unsolBarringInfoChanged");
1086 
1087         if (mRadioState != MockModemConfigInterface.RADIO_STATE_ON) {
1088             Log.d(mTag, "unsolBarringInfoChanged radio is off");
1089             return false;
1090         }
1091 
1092         if (mRadioNetworkIndication != null) {
1093             CellIdentity cellIdentity = new CellIdentity();
1094             BarringInfo[] halBarringInfos = convertBarringInfo(barringServiceInfos);
1095             synchronized (mCacheUpdateMutex) {
1096                 cellIdentity = mServiceState.getPrimaryCellIdentity();
1097                 mServiceState.updateBarringInfos(halBarringInfos);
1098             }
1099 
1100             try {
1101                 mRadioNetworkIndication.barringInfoChanged(RadioIndicationType.UNSOLICITED,
1102                         cellIdentity, halBarringInfos);
1103                 return true;
1104             } catch (RemoteException ex) {
1105                 Log.e(mTag, "Failed to invoke barringInfoChanged change from AIDL. Exception" + ex);
1106             }
1107         } else {
1108             Log.e(mTag, "null mRadioNetworkIndication");
1109         }
1110         return false;
1111     }
1112 
unsolEmergencyNetworkScanResult(MockEmergencyRegResult regResult)1113     public boolean unsolEmergencyNetworkScanResult(MockEmergencyRegResult regResult) {
1114         Log.d(TAG, "unsolEmergencyNetworkScanResult");
1115 
1116         if (mRadioState != MockModemConfigInterface.RADIO_STATE_ON) {
1117             return false;
1118         }
1119 
1120         if (mRadioNetworkIndication != null) {
1121             EmergencyRegResult result = convertEmergencyRegResult(regResult);
1122 
1123             synchronized (mCacheUpdateMutex) {
1124                 mServiceState.setEmergencyRegResult(result);
1125             }
1126 
1127             try {
1128                 mRadioNetworkIndication.emergencyNetworkScanResult(
1129                         RadioIndicationType.UNSOLICITED, result);
1130                 return true;
1131             } catch (RemoteException ex) {
1132                 Log.e(TAG,
1133                         "Failed to invoke emergencyNetworkScanResult change from AIDL. Exception"
1134                                 + ex);
1135             }
1136         } else {
1137             Log.e(TAG, "null mRadioNetworkIndication");
1138         }
1139         return false;
1140     }
1141 
convertEmergencyRegResult(MockEmergencyRegResult regResult)1142     private static EmergencyRegResult convertEmergencyRegResult(MockEmergencyRegResult regResult) {
1143 
1144         EmergencyRegResult result = new EmergencyRegResult();
1145 
1146         result.accessNetwork = regResult.getAccessNetwork();
1147         result.regState = convertRegState(regResult.getRegState());
1148         result.emcDomain = regResult.getDomain();
1149         result.isVopsSupported = regResult.isVopsSupported();
1150         result.isEmcBearerSupported = regResult.isEmcBearerSupported();
1151         result.nwProvidedEmc = (byte) regResult.getNwProvidedEmc();
1152         result.nwProvidedEmf = (byte) regResult.getNwProvidedEmf();
1153         result.mcc = regResult.getMcc();
1154         result.mnc = regResult.getMnc();
1155 
1156         return result;
1157     }
1158 
1159     /**
1160      * Convert RegistrationState to RegState
1161      * @param regState Registration state
1162      * @return Converted registration state.
1163      */
convertRegState(@etworkRegistrationInfo.RegistrationState int regState)1164     private static int convertRegState(@NetworkRegistrationInfo.RegistrationState int regState) {
1165         switch (regState) {
1166             case NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING:
1167                 return RegState.NOT_REG_MT_NOT_SEARCHING_OP_EM;
1168             case NetworkRegistrationInfo.REGISTRATION_STATE_HOME:
1169                 return RegState.REG_HOME;
1170             case NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_SEARCHING:
1171                 return RegState.NOT_REG_MT_SEARCHING_OP_EM;
1172             case NetworkRegistrationInfo.REGISTRATION_STATE_DENIED:
1173                 return RegState.REG_DENIED_EM;
1174             case NetworkRegistrationInfo.REGISTRATION_STATE_UNKNOWN:
1175                 return RegState.UNKNOWN_EM;
1176             case NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING:
1177                 return RegState.REG_ROAMING;
1178             default:
1179                 return RegState.NOT_REG_MT_NOT_SEARCHING_OP_EM;
1180         }
1181     }
1182 
convertBarringInfo( SparseArray<android.telephony.BarringInfo.BarringServiceInfo> barringServiceInfos)1183     private BarringInfo[] convertBarringInfo(
1184             SparseArray<android.telephony.BarringInfo.BarringServiceInfo> barringServiceInfos) {
1185         ArrayList<BarringInfo> halBarringInfo = new ArrayList<>();
1186 
1187         for (int i = BarringInfo.SERVICE_TYPE_CS_SERVICE; i <= BarringInfo.SERVICE_TYPE_SMS; i++) {
1188             android.telephony.BarringInfo.BarringServiceInfo serviceInfo =
1189                     barringServiceInfos.get(i);
1190             if (serviceInfo != null) {
1191                 BarringInfo barringInfo = new BarringInfo();
1192                 barringInfo.serviceType = i;
1193                 barringInfo.barringType = serviceInfo.getBarringType();
1194                 barringInfo.barringTypeSpecificInfo = new BarringTypeSpecificInfo();
1195                 barringInfo.barringTypeSpecificInfo.isBarred = serviceInfo.isConditionallyBarred();
1196                 barringInfo.barringTypeSpecificInfo.factor =
1197                         serviceInfo.getConditionalBarringFactor();
1198                 barringInfo.barringTypeSpecificInfo.timeSeconds =
1199                         serviceInfo.getConditionalBarringTimeSeconds();
1200                 halBarringInfo.add(barringInfo);
1201             }
1202         }
1203         return halBarringInfo.toArray(new BarringInfo[0]);
1204     }
1205 
1206     /**
1207      * Waits for the event of network service.
1208      *
1209      * @param latchIndex The index of the event.
1210      * @param waitMs The timeout in milliseconds.
1211      */
waitForLatchCountdown(int latchIndex, int waitMs)1212     public boolean waitForLatchCountdown(int latchIndex, int waitMs) {
1213         return mServiceState.waitForLatchCountdown(latchIndex, waitMs);
1214     }
1215 
1216     /**
1217      * Resets the CountDownLatches
1218      */
resetAllLatchCountdown()1219     public void resetAllLatchCountdown() {
1220         mServiceState.resetAllLatchCountdown();
1221     }
1222 }
1223