• 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.hardware.radio.RadioError;
20 import android.hardware.radio.RadioIndicationType;
21 import android.hardware.radio.RadioResponseInfo;
22 import android.hardware.radio.network.IRadioNetwork;
23 import android.hardware.radio.network.IRadioNetworkIndication;
24 import android.hardware.radio.network.IRadioNetworkResponse;
25 import android.hardware.radio.network.NetworkScanRequest;
26 import android.hardware.radio.network.RadioAccessSpecifier;
27 import android.hardware.radio.network.RegState;
28 import android.hardware.radio.network.SignalThresholdInfo;
29 import android.hardware.radio.sim.CardStatus;
30 import android.os.AsyncResult;
31 import android.os.Handler;
32 import android.os.Message;
33 import android.os.RemoteException;
34 import android.util.Log;
35 
36 public class IRadioNetworkImpl extends IRadioNetwork.Stub {
37     private static final String TAG = "MRNW";
38 
39     private final MockModemService mService;
40     private IRadioNetworkResponse mRadioNetworkResponse;
41     private IRadioNetworkIndication mRadioNetworkIndication;
42     private static MockModemConfigInterface[] sMockModemConfigInterfaces;
43     private Object mCacheUpdateMutex;
44     private final Handler mHandler;
45     private int mSubId;
46 
47     // ***** Events
48     static final int EVENT_RADIO_STATE_CHANGED = 1;
49     static final int EVENT_SIM_STATUS_CHANGED = 2;
50     static final int EVENT_PREFERRED_MODE_CHANGED = 3;
51 
52     // ***** Cache of modem attributes/status
53     private int mNetworkTypeBitmap;
54     private int mReasonForDenial;
55     private boolean mNetworkSelectionMode;
56 
57     private int mRadioState;
58     private boolean mSimReady;
59 
60     private MockNetworkService mServiceState;
61 
IRadioNetworkImpl( MockModemService service, MockModemConfigInterface[] interfaces, int instanceId)62     public IRadioNetworkImpl(
63             MockModemService service, MockModemConfigInterface[] interfaces, int instanceId) {
64         Log.d(TAG, "Instantiated");
65 
66         this.mService = service;
67         sMockModemConfigInterfaces = interfaces;
68         mCacheUpdateMutex = new Object();
69         mHandler = new IRadioNetworkHandler();
70         mSubId = instanceId;
71         mServiceState = new MockNetworkService();
72 
73         // Default network type GPRS|EDGE|UMTS|HSDPA|HSUPA|HSPA|LTE|HSPA+|GSM|LTE_CA|NR
74         mNetworkTypeBitmap =
75                 MockNetworkService.GSM
76                         | MockNetworkService.WCDMA
77                         | MockNetworkService.LTE
78                         | MockNetworkService.NR;
79         mServiceState.updateHighestRegisteredRat(mNetworkTypeBitmap);
80 
81         sMockModemConfigInterfaces[mSubId].registerForRadioStateChanged(
82                 mHandler, EVENT_RADIO_STATE_CHANGED, null);
83         sMockModemConfigInterfaces[mSubId].registerForCardStatusChanged(
84                 mHandler, EVENT_SIM_STATUS_CHANGED, null);
85     }
86 
87     /** Handler class to handle callbacks */
88     private final class IRadioNetworkHandler extends Handler {
89         @Override
handleMessage(Message msg)90         public void handleMessage(Message msg) {
91             AsyncResult ar;
92             synchronized (mCacheUpdateMutex) {
93                 switch (msg.what) {
94                     case EVENT_SIM_STATUS_CHANGED:
95                         Log.d(TAG, "Received EVENT_SIM_STATUS_CHANGED");
96                         boolean oldSimReady = mSimReady;
97                         ar = (AsyncResult) msg.obj;
98                         if (ar != null && ar.exception == null) {
99                             mSimReady = updateSimReady(ar);
100                             if (oldSimReady != mSimReady) {
101                                 updateNetworkStatus();
102                             }
103                         } else {
104                             Log.e(TAG, msg.what + " failure. Exception: " + ar.exception);
105                         }
106                         break;
107 
108                     case EVENT_RADIO_STATE_CHANGED:
109                         Log.d(TAG, "Received EVENT_RADIO_STATE_CHANGED");
110                         int oldRadioState = mRadioState;
111                         ar = (AsyncResult) msg.obj;
112                         if (ar != null && ar.exception == null) {
113                             mRadioState = (int) ar.result;
114                             Log.i(TAG, "Radio state: " + mRadioState);
115                             if (oldRadioState != mRadioState) {
116                                 updateNetworkStatus();
117                             }
118                         } else {
119                             Log.e(TAG, msg.what + " failure. Exception: " + ar.exception);
120                         }
121                         break;
122 
123                     case EVENT_PREFERRED_MODE_CHANGED:
124                         Log.d(TAG, "Received EVENT_PREFERRED_MODE_CHANGED");
125                         mServiceState.updateNetworkStatus(
126                                 MockNetworkService.NETWORK_UPDATE_PREFERRED_MODE_CHANGE);
127                         updateNetworkStatus();
128                         break;
129                 }
130             }
131         }
132     }
133 
134     // Implementation of IRadioNetwork utility functions
135 
notifyServiceStateChange()136     private void notifyServiceStateChange() {
137         Log.d(TAG, "notifyServiceStateChange");
138 
139         Handler handler = sMockModemConfigInterfaces[mSubId].getMockModemConfigHandler();
140         Message msg =
141                 handler.obtainMessage(
142                         MockModemConfigBase.EVENT_SERVICE_STATE_CHANGE, mServiceState);
143         handler.sendMessage(msg);
144     }
145 
updateNetworkStatus()146     private void updateNetworkStatus() {
147 
148         if (mRadioState != MockModemConfigInterface.RADIO_STATE_ON) {
149             // Update to OOS state
150             mServiceState.updateServiceState(RegState.NOT_REG_MT_NOT_SEARCHING_OP);
151         } else if (!mSimReady) {
152             // Update to Searching state
153             mServiceState.updateServiceState(RegState.NOT_REG_MT_SEARCHING_OP);
154         } else if (mServiceState.isHomeCellExisted() && mServiceState.getIsHomeCamping()) {
155             // Update to Home state
156             mServiceState.updateServiceState(RegState.REG_HOME);
157         } else if (mServiceState.isRoamingCellExisted() && mServiceState.getIsRoamingCamping()) {
158             // Update to Roaming state
159             mServiceState.updateServiceState(RegState.REG_ROAMING);
160         } else {
161             // Update to Searching state
162             mServiceState.updateServiceState(RegState.NOT_REG_MT_SEARCHING_OP);
163         }
164 
165         unsolNetworkStateChanged();
166         unsolCurrentSignalStrength();
167         unsolCellInfoList();
168     }
169 
updateSimReady(AsyncResult ar)170     private boolean updateSimReady(AsyncResult ar) {
171         String simPlmn = "";
172         CardStatus cardStatus = new CardStatus();
173         cardStatus = (CardStatus) ar.result;
174 
175         if (cardStatus.cardState != CardStatus.STATE_PRESENT) {
176             return false;
177         }
178 
179         int numApplications = cardStatus.applications.length;
180         if (numApplications < 1) {
181             return false;
182         }
183 
184         for (int i = 0; i < numApplications; i++) {
185             android.hardware.radio.sim.AppStatus rilAppStatus = cardStatus.applications[i];
186             if (rilAppStatus.appState == android.hardware.radio.sim.AppStatus.APP_STATE_READY) {
187                 Log.i(TAG, "SIM is ready");
188                 simPlmn = "46692"; // TODO: Get SIM PLMN, maybe decode from IMSI
189                 mServiceState.updateSimPlmn(simPlmn);
190                 return true;
191             }
192         }
193 
194         mServiceState.updateSimPlmn(simPlmn);
195         return false;
196     }
197 
changeNetworkService(int carrierId, boolean registration)198     public boolean changeNetworkService(int carrierId, boolean registration) {
199         Log.d(TAG, "changeNetworkService: carrier id(" + carrierId + "): " + registration);
200 
201         synchronized (mCacheUpdateMutex) {
202             // TODO: compare carrierId and sim to decide home or roming
203             mServiceState.setServiceStatus(false, registration);
204             updateNetworkStatus();
205         }
206 
207         return true;
208     }
209 
210     // Implementation of IRadioNetwork functions
211     @Override
getAllowedNetworkTypesBitmap(int serial)212     public void getAllowedNetworkTypesBitmap(int serial) {
213         Log.d(TAG, "getAllowedNetworkTypesBitmap");
214         int networkTypeBitmap = mNetworkTypeBitmap;
215 
216         RadioResponseInfo rsp = mService.makeSolRsp(serial);
217         try {
218             mRadioNetworkResponse.getAllowedNetworkTypesBitmapResponse(rsp, networkTypeBitmap);
219         } catch (RemoteException ex) {
220             Log.e(TAG, "Failed to getAllowedNetworkTypesBitmap from AIDL. Exception" + ex);
221         }
222     }
223 
224     @Override
getAvailableBandModes(int serial)225     public void getAvailableBandModes(int serial) {
226         Log.d(TAG, "getAvailableBandModes");
227 
228         int[] bandModes = new int[0];
229         RadioResponseInfo rsp = mService.makeSolRsp(serial);
230         try {
231             mRadioNetworkResponse.getAvailableBandModesResponse(rsp, bandModes);
232         } catch (RemoteException ex) {
233             Log.e(TAG, "Failed to getAvailableBandModes from AIDL. Exception" + ex);
234         }
235     }
236 
237     @Override
getAvailableNetworks(int serial)238     public void getAvailableNetworks(int serial) {
239         Log.d(TAG, "getAvailableNetworks");
240 
241         android.hardware.radio.network.OperatorInfo[] networkInfos =
242                 new android.hardware.radio.network.OperatorInfo[0];
243         RadioResponseInfo rsp = mService.makeSolRsp(serial);
244         try {
245             mRadioNetworkResponse.getAvailableNetworksResponse(rsp, networkInfos);
246         } catch (RemoteException ex) {
247             Log.e(TAG, "Failed to getAvailableNetworks from AIDL. Exception" + ex);
248         }
249     }
250 
251     @Override
getBarringInfo(int serial)252     public void getBarringInfo(int serial) {
253         Log.d(TAG, "getBarringInfo");
254 
255         android.hardware.radio.network.CellIdentity cellIdentity =
256                 new android.hardware.radio.network.CellIdentity();
257         android.hardware.radio.network.BarringInfo[] barringInfos =
258                 new android.hardware.radio.network.BarringInfo[0];
259         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
260         try {
261             mRadioNetworkResponse.getBarringInfoResponse(rsp, cellIdentity, barringInfos);
262         } catch (RemoteException ex) {
263             Log.e(TAG, "Failed to getBarringInfo from AIDL. Exception" + ex);
264         }
265     }
266 
267     @Override
getCdmaRoamingPreference(int serial)268     public void getCdmaRoamingPreference(int serial) {
269         Log.d(TAG, "getCdmaRoamingPreference");
270         int type = 0;
271         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
272         try {
273             mRadioNetworkResponse.getCdmaRoamingPreferenceResponse(rsp, type);
274         } catch (RemoteException ex) {
275             Log.e(TAG, "Failed to getCdmaRoamingPreference from AIDL. Exception" + ex);
276         }
277     }
278 
279     @Override
getCellInfoList(int serial)280     public void getCellInfoList(int serial) {
281         Log.d(TAG, "getCellInfoList");
282         android.hardware.radio.network.CellInfo[] cells;
283 
284         synchronized (mCacheUpdateMutex) {
285             cells = mServiceState.getCells();
286         }
287 
288         RadioResponseInfo rsp = mService.makeSolRsp(serial);
289         try {
290             mRadioNetworkResponse.getCellInfoListResponse(rsp, cells);
291         } catch (RemoteException ex) {
292             Log.e(TAG, "Failed to getCellInfoList from AIDL. Exception" + ex);
293         }
294     }
295 
296     @Override
getDataRegistrationState(int serial)297     public void getDataRegistrationState(int serial) {
298         Log.d(TAG, "getDataRegistrationState");
299 
300         android.hardware.radio.network.RegStateResult dataRegResponse =
301                 new android.hardware.radio.network.RegStateResult();
302 
303         dataRegResponse.cellIdentity = new android.hardware.radio.network.CellIdentity();
304         dataRegResponse.reasonForDenial = mReasonForDenial;
305 
306         synchronized (mCacheUpdateMutex) {
307             dataRegResponse.regState =
308                     mServiceState.getRegistration(android.hardware.radio.network.Domain.PS);
309             dataRegResponse.rat = mServiceState.getRegistrationRat();
310             if (mServiceState.isInService()) {
311                 dataRegResponse.registeredPlmn =
312                         mServiceState.getPrimaryCellOperatorInfo().operatorNumeric;
313             }
314 
315             dataRegResponse.cellIdentity = mServiceState.getPrimaryCellIdentity();
316         }
317 
318         // TODO: support accessTechnologySpecificInfo
319         dataRegResponse.accessTechnologySpecificInfo =
320                 android.hardware.radio.network.AccessTechnologySpecificInfo.noinit(true);
321 
322         RadioResponseInfo rsp = mService.makeSolRsp(serial);
323         try {
324             mRadioNetworkResponse.getDataRegistrationStateResponse(rsp, dataRegResponse);
325         } catch (RemoteException ex) {
326             Log.e(TAG, "Failed to getRadioCapability from AIDL. Exception" + ex);
327         }
328     }
329 
330     @Override
getImsRegistrationState(int serial)331     public void getImsRegistrationState(int serial) {
332         Log.d(TAG, "getImsRegistrationState");
333         boolean isRegistered = false;
334         int ratFamily = 0;
335         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
336         try {
337             mRadioNetworkResponse.getImsRegistrationStateResponse(rsp, isRegistered, ratFamily);
338         } catch (RemoteException ex) {
339             Log.e(TAG, "Failed to getImsRegistrationState from AIDL. Exception" + ex);
340         }
341     }
342 
343     @Override
getNetworkSelectionMode(int serial)344     public void getNetworkSelectionMode(int serial) {
345         Log.d(TAG, "getNetworkSelectionMode");
346 
347         RadioResponseInfo rsp = mService.makeSolRsp(serial);
348         try {
349             mRadioNetworkResponse.getNetworkSelectionModeResponse(rsp, mNetworkSelectionMode);
350         } catch (RemoteException ex) {
351             Log.e(TAG, "Failed to getNetworkSelectionMode from AIDL. Exception" + ex);
352         }
353     }
354 
355     @Override
getOperator(int serial)356     public void getOperator(int serial) {
357         Log.d(TAG, "getOperator");
358 
359         String longName = "";
360         String shortName = "";
361         String numeric = "";
362 
363         synchronized (mCacheUpdateMutex) {
364             if (mServiceState.isInService()) {
365                 android.hardware.radio.network.OperatorInfo operatorInfo =
366                         mServiceState.getPrimaryCellOperatorInfo();
367                 longName = operatorInfo.alphaLong;
368                 shortName = operatorInfo.alphaShort;
369                 numeric = operatorInfo.operatorNumeric;
370             }
371         }
372         RadioResponseInfo rsp = mService.makeSolRsp(serial);
373         try {
374             mRadioNetworkResponse.getOperatorResponse(rsp, longName, shortName, numeric);
375         } catch (RemoteException ex) {
376             Log.e(TAG, "Failed to getOperator from AIDL. Exception" + ex);
377         }
378     }
379 
380     @Override
getSignalStrength(int serial)381     public void getSignalStrength(int serial) {
382         Log.d(TAG, "getSignalStrength");
383 
384         android.hardware.radio.network.SignalStrength signalStrength =
385                 new android.hardware.radio.network.SignalStrength();
386 
387         synchronized (mCacheUpdateMutex) {
388             if (mServiceState.getIsHomeCamping()
389                     && mRadioState == MockModemConfigInterface.RADIO_STATE_ON) {
390                 signalStrength = mServiceState.getSignalStrength();
391             }
392         }
393 
394         RadioResponseInfo rsp = mService.makeSolRsp(serial);
395         try {
396             mRadioNetworkResponse.getSignalStrengthResponse(rsp, signalStrength);
397         } catch (RemoteException ex) {
398             Log.e(TAG, "Failed to getSignalStrength from AIDL. Exception" + ex);
399         }
400     }
401 
402     @Override
getSystemSelectionChannels(int serial)403     public void getSystemSelectionChannels(int serial) {
404         Log.d(TAG, "getSystemSelectionChannels");
405 
406         android.hardware.radio.network.RadioAccessSpecifier[] specifiers =
407                 new android.hardware.radio.network.RadioAccessSpecifier[0];
408         RadioResponseInfo rsp = mService.makeSolRsp(serial);
409         try {
410             mRadioNetworkResponse.getSystemSelectionChannelsResponse(rsp, specifiers);
411         } catch (RemoteException ex) {
412             Log.e(TAG, "Failed to getSystemSelectionChannels from AIDL. Exception" + ex);
413         }
414     }
415 
416     @Override
getVoiceRadioTechnology(int serial)417     public void getVoiceRadioTechnology(int serial) {
418         Log.d(TAG, "getVoiceRadioTechnology");
419         int rat;
420 
421         synchronized (mCacheUpdateMutex) {
422             rat = mServiceState.getRegistrationRat();
423         }
424 
425         RadioResponseInfo rsp = mService.makeSolRsp(serial);
426         try {
427             mRadioNetworkResponse.getVoiceRadioTechnologyResponse(rsp, rat);
428         } catch (RemoteException ex) {
429             Log.e(TAG, "Failed to getVoiceRadioTechnology from AIDL. Exception" + ex);
430         }
431     }
432 
433     @Override
getVoiceRegistrationState(int serial)434     public void getVoiceRegistrationState(int serial) {
435         Log.d(TAG, "getVoiceRegistrationState");
436 
437         android.hardware.radio.network.RegStateResult voiceRegResponse =
438                 new android.hardware.radio.network.RegStateResult();
439 
440         voiceRegResponse.cellIdentity = new android.hardware.radio.network.CellIdentity();
441         voiceRegResponse.reasonForDenial = mReasonForDenial;
442 
443         synchronized (mCacheUpdateMutex) {
444             voiceRegResponse.regState =
445                     mServiceState.getRegistration(android.hardware.radio.network.Domain.CS);
446             voiceRegResponse.rat = mServiceState.getRegistrationRat();
447             if (mServiceState.isInService()) {
448                 voiceRegResponse.registeredPlmn =
449                         mServiceState.getPrimaryCellOperatorInfo().operatorNumeric;
450             }
451 
452             voiceRegResponse.cellIdentity = mServiceState.getPrimaryCellIdentity();
453         }
454 
455         // TODO: support accessTechnologySpecificInfo
456         voiceRegResponse.accessTechnologySpecificInfo =
457                 android.hardware.radio.network.AccessTechnologySpecificInfo.noinit(true);
458 
459         RadioResponseInfo rsp = mService.makeSolRsp(serial);
460         try {
461             mRadioNetworkResponse.getVoiceRegistrationStateResponse(rsp, voiceRegResponse);
462         } catch (RemoteException ex) {
463             Log.e(TAG, "Failed to getVoiceRegistrationState from AIDL. Exception" + ex);
464         }
465     }
466 
467     @Override
isNrDualConnectivityEnabled(int serial)468     public void isNrDualConnectivityEnabled(int serial) {
469         Log.d(TAG, "isNrDualConnectivityEnabled");
470         boolean isEnabled = false;
471         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
472         try {
473             mRadioNetworkResponse.isNrDualConnectivityEnabledResponse(rsp, isEnabled);
474         } catch (RemoteException ex) {
475             Log.e(TAG, "Failed to isNrDualConnectivityEnabled from AIDL. Exception" + ex);
476         }
477     }
478 
479     @Override
responseAcknowledgement()480     public void responseAcknowledgement() {
481         Log.d(TAG, "responseAcknowledgement");
482     }
483 
484     @Override
setAllowedNetworkTypesBitmap(int serial, int networkTypeBitmap)485     public void setAllowedNetworkTypesBitmap(int serial, int networkTypeBitmap) {
486         Log.d(TAG, "setAllowedNetworkTypesBitmap");
487         boolean isModeChange = false;
488 
489         if (mNetworkTypeBitmap != networkTypeBitmap) {
490             mNetworkTypeBitmap = networkTypeBitmap;
491             synchronized (mCacheUpdateMutex) {
492                 isModeChange = mServiceState.updateHighestRegisteredRat(mNetworkTypeBitmap);
493             }
494             if (isModeChange) {
495                 mHandler.obtainMessage(EVENT_PREFERRED_MODE_CHANGED).sendToTarget();
496             }
497         }
498 
499         RadioResponseInfo rsp = mService.makeSolRsp(serial);
500         try {
501             mRadioNetworkResponse.setAllowedNetworkTypesBitmapResponse(rsp);
502         } catch (RemoteException ex) {
503             Log.e(TAG, "Failed to setAllowedNetworkTypesBitmap from AIDL. Exception" + ex);
504         }
505     }
506 
507     @Override
setBandMode(int serial, int mode)508     public void setBandMode(int serial, int mode) {
509         Log.d(TAG, "setBandMode");
510 
511         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
512         try {
513             mRadioNetworkResponse.setBandModeResponse(rsp);
514         } catch (RemoteException ex) {
515             Log.e(TAG, "Failed to setBandMode from AIDL. Exception" + ex);
516         }
517     }
518 
519     @Override
setBarringPassword( int serial, String facility, String oldPassword, String newPassword)520     public void setBarringPassword(
521             int serial, String facility, String oldPassword, String newPassword) {
522         Log.d(TAG, "setBarringPassword");
523 
524         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
525         try {
526             mRadioNetworkResponse.setBarringPasswordResponse(rsp);
527         } catch (RemoteException ex) {
528             Log.e(TAG, "Failed to setBarringPassword from AIDL. Exception" + ex);
529         }
530     }
531 
532     @Override
setCdmaRoamingPreference(int serial, int type)533     public void setCdmaRoamingPreference(int serial, int type) {
534         Log.d(TAG, "setCdmaRoamingPreference");
535 
536         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
537         try {
538             mRadioNetworkResponse.setCdmaRoamingPreferenceResponse(rsp);
539         } catch (RemoteException ex) {
540             Log.e(TAG, "Failed to setCdmaRoamingPreference from AIDL. Exception" + ex);
541         }
542     }
543 
544     @Override
setCellInfoListRate(int serial, int rate)545     public void setCellInfoListRate(int serial, int rate) {
546         Log.d(TAG, "setCellInfoListRate");
547 
548         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
549         try {
550             mRadioNetworkResponse.setCellInfoListRateResponse(rsp);
551         } catch (RemoteException ex) {
552             Log.e(TAG, "Failed to setCellInfoListRate from AIDL. Exception" + ex);
553         }
554     }
555 
556     @Override
setIndicationFilter(int serial, int indicationFilter)557     public void setIndicationFilter(int serial, int indicationFilter) {
558         Log.d(TAG, "setIndicationFilter");
559 
560         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
561         try {
562             mRadioNetworkResponse.setIndicationFilterResponse(rsp);
563         } catch (RemoteException ex) {
564             Log.e(TAG, "Failed to setIndicationFilter from AIDL. Exception" + ex);
565         }
566     }
567 
568     @Override
setLinkCapacityReportingCriteria( int serial, int hysteresisMs, int hysteresisDlKbps, int hysteresisUlKbps, int[] thresholdsDownlinkKbps, int[] thresholdsUplinkKbps, int accessNetwork)569     public void setLinkCapacityReportingCriteria(
570             int serial,
571             int hysteresisMs,
572             int hysteresisDlKbps,
573             int hysteresisUlKbps,
574             int[] thresholdsDownlinkKbps,
575             int[] thresholdsUplinkKbps,
576             int accessNetwork) {
577         Log.d(TAG, "setLinkCapacityReportingCriteria");
578 
579         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
580         try {
581             mRadioNetworkResponse.setLinkCapacityReportingCriteriaResponse(rsp);
582         } catch (RemoteException ex) {
583             Log.e(TAG, "Failed to setLinkCapacityReportingCriteria from AIDL. Exception" + ex);
584         }
585     }
586 
587     @Override
setLocationUpdates(int serial, boolean enable)588     public void setLocationUpdates(int serial, boolean enable) {
589         Log.d(TAG, "setLocationUpdates");
590 
591         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
592         try {
593             mRadioNetworkResponse.setLocationUpdatesResponse(rsp);
594         } catch (RemoteException ex) {
595             Log.e(TAG, "Failed to setLocationUpdates from AIDL. Exception" + ex);
596         }
597     }
598 
599     @Override
setNetworkSelectionModeAutomatic(int serial)600     public void setNetworkSelectionModeAutomatic(int serial) {
601         Log.d(TAG, "setNetworkSelectionModeAutomatic");
602 
603         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
604         try {
605             mRadioNetworkResponse.setNetworkSelectionModeAutomaticResponse(rsp);
606         } catch (RemoteException ex) {
607             Log.e(TAG, "Failed to setNetworkSelectionModeAutomatic from AIDL. Exception" + ex);
608         }
609     }
610 
611     @Override
setNetworkSelectionModeManual(int serial, String operatorNumeric, int ran)612     public void setNetworkSelectionModeManual(int serial, String operatorNumeric, int ran) {
613         Log.d(TAG, "setNetworkSelectionModeManual");
614 
615         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
616         try {
617             mRadioNetworkResponse.setNetworkSelectionModeManualResponse(rsp);
618         } catch (RemoteException ex) {
619             Log.e(TAG, "Failed to setNetworkSelectionModeManual from AIDL. Exception" + ex);
620         }
621     }
622 
623     @Override
setNrDualConnectivityState(int serial, byte nrDualConnectivityState)624     public void setNrDualConnectivityState(int serial, byte nrDualConnectivityState) {
625         Log.d(TAG, "setNrDualConnectivityState");
626 
627         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
628         try {
629             mRadioNetworkResponse.setNrDualConnectivityStateResponse(rsp);
630         } catch (RemoteException ex) {
631             Log.e(TAG, "Failed to setNrDualConnectivityState from AIDL. Exception" + ex);
632         }
633     }
634 
635     @Override
setResponseFunctions( IRadioNetworkResponse radioNetworkResponse, IRadioNetworkIndication radioNetworkIndication)636     public void setResponseFunctions(
637             IRadioNetworkResponse radioNetworkResponse,
638             IRadioNetworkIndication radioNetworkIndication) {
639         Log.d(TAG, "setResponseFunctions");
640         mRadioNetworkResponse = radioNetworkResponse;
641         mRadioNetworkIndication = radioNetworkIndication;
642         mService.countDownLatch(MockModemService.LATCH_RADIO_INTERFACES_READY);
643     }
644 
645     @Override
setSignalStrengthReportingCriteria( int serial, SignalThresholdInfo[] signalThresholdInfos)646     public void setSignalStrengthReportingCriteria(
647             int serial, SignalThresholdInfo[] signalThresholdInfos) {
648         Log.d(TAG, "setSignalStrengthReportingCriteria");
649 
650         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
651         try {
652             mRadioNetworkResponse.setSignalStrengthReportingCriteriaResponse(rsp);
653         } catch (RemoteException ex) {
654             Log.e(TAG, "Failed to setSignalStrengthReportingCriteria from AIDL. Exception" + ex);
655         }
656     }
657 
658     @Override
setSuppServiceNotifications(int serial, boolean enable)659     public void setSuppServiceNotifications(int serial, boolean enable) {
660         Log.d(TAG, "setSuppServiceNotifications");
661 
662         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
663         try {
664             mRadioNetworkResponse.setSuppServiceNotificationsResponse(rsp);
665         } catch (RemoteException ex) {
666             Log.e(TAG, "Failed to setSuppServiceNotifications from AIDL. Exception" + ex);
667         }
668     }
669 
670     @Override
setSystemSelectionChannels( int serial, boolean specifyChannels, RadioAccessSpecifier[] specifiers)671     public void setSystemSelectionChannels(
672             int serial, boolean specifyChannels, RadioAccessSpecifier[] specifiers) {
673         Log.d(TAG, "setSystemSelectionChannels");
674 
675         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
676         try {
677             mRadioNetworkResponse.setSystemSelectionChannelsResponse(rsp);
678         } catch (RemoteException ex) {
679             Log.e(TAG, "Failed to setSystemSelectionChannels from AIDL. Exception" + ex);
680         }
681     }
682 
683     @Override
startNetworkScan(int serial, NetworkScanRequest request)684     public void startNetworkScan(int serial, NetworkScanRequest request) {
685         Log.d(TAG, "startNetworkScan");
686 
687         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
688         try {
689             mRadioNetworkResponse.startNetworkScanResponse(rsp);
690         } catch (RemoteException ex) {
691             Log.e(TAG, "Failed to startNetworkScan from AIDL. Exception" + ex);
692         }
693     }
694 
695     @Override
stopNetworkScan(int serial)696     public void stopNetworkScan(int serial) {
697         Log.d(TAG, "stopNetworkScan");
698 
699         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
700         try {
701             mRadioNetworkResponse.stopNetworkScanResponse(rsp);
702         } catch (RemoteException ex) {
703             Log.e(TAG, "Failed to stopNetworkScan from AIDL. Exception" + ex);
704         }
705     }
706 
707     @Override
supplyNetworkDepersonalization(int serial, String netPin)708     public void supplyNetworkDepersonalization(int serial, String netPin) {
709         Log.d(TAG, "supplyNetworkDepersonalization");
710         int remainingRetries = 0;
711 
712         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
713         try {
714             mRadioNetworkResponse.supplyNetworkDepersonalizationResponse(rsp, remainingRetries);
715         } catch (RemoteException ex) {
716             Log.e(TAG, "Failed to supplyNetworkDepersonalization from AIDL. Exception" + ex);
717         }
718     }
719 
720     @Override
setUsageSetting(int serial, int usageSetting)721     public void setUsageSetting(int serial, int usageSetting) {
722         Log.d(TAG, "setUsageSetting");
723         int remainingRetries = 0;
724 
725         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
726         try {
727             mRadioNetworkResponse.setUsageSettingResponse(rsp);
728         } catch (RemoteException ex) {
729             Log.e(TAG, "Failed to setUsageSetting from AIDL. Exception" + ex);
730         }
731     }
732 
733     @Override
getUsageSetting(int serial)734     public void getUsageSetting(int serial) {
735         Log.d(TAG, "getUsageSetting");
736 
737         RadioResponseInfo rsp = mService.makeSolRsp(serial, RadioError.REQUEST_NOT_SUPPORTED);
738         try {
739             mRadioNetworkResponse.getUsageSettingResponse(rsp, -1 /* Invalid value */);
740         } catch (RemoteException ex) {
741             Log.e(TAG, "Failed to getUsageSetting from AIDL. Exception" + ex);
742         }
743     }
744 
745     @Override
getInterfaceHash()746     public String getInterfaceHash() {
747         return IRadioNetwork.HASH;
748     }
749 
750     @Override
getInterfaceVersion()751     public int getInterfaceVersion() {
752         return IRadioNetwork.VERSION;
753     }
754 
unsolNetworkStateChanged()755     public void unsolNetworkStateChanged() {
756         Log.d(TAG, "unsolNetworkStateChanged");
757 
758         // Notify other module
759         notifyServiceStateChange();
760 
761         if (mRadioNetworkIndication != null) {
762             try {
763                 mRadioNetworkIndication.networkStateChanged(RadioIndicationType.UNSOLICITED);
764             } catch (RemoteException ex) {
765                 Log.e(TAG, "Failed to invoke networkStateChanged from AIDL. Exception" + ex);
766             }
767         } else {
768             Log.e(TAG, "null mRadioNetworkIndication");
769         }
770     }
771 
unsolCurrentSignalStrength()772     public void unsolCurrentSignalStrength() {
773         Log.d(TAG, "unsolCurrentSignalStrength");
774         if (mRadioState != MockModemConfigInterface.RADIO_STATE_ON) {
775             return;
776         }
777 
778         if (mRadioNetworkIndication != null) {
779             android.hardware.radio.network.SignalStrength signalStrength =
780                     new android.hardware.radio.network.SignalStrength();
781 
782             synchronized (mCacheUpdateMutex) {
783                 signalStrength = mServiceState.getSignalStrength();
784             }
785 
786             try {
787                 mRadioNetworkIndication.currentSignalStrength(
788                         RadioIndicationType.UNSOLICITED, signalStrength);
789             } catch (RemoteException ex) {
790                 Log.e(
791                         TAG,
792                         "Failed to invoke currentSignalStrength change from AIDL. Exception" + ex);
793             }
794         } else {
795             Log.e(TAG, "null mRadioNetworkIndication");
796         }
797     }
798 
unsolCellInfoList()799     public void unsolCellInfoList() {
800         Log.d(TAG, "unsolCellInfoList");
801 
802         if (mRadioState != MockModemConfigInterface.RADIO_STATE_ON) {
803             return;
804         }
805 
806         if (mRadioNetworkIndication != null) {
807             android.hardware.radio.network.CellInfo[] cells;
808 
809             synchronized (mCacheUpdateMutex) {
810                 cells = mServiceState.getCells();
811             }
812             try {
813                 mRadioNetworkIndication.cellInfoList(RadioIndicationType.UNSOLICITED, cells);
814             } catch (RemoteException ex) {
815                 Log.e(TAG, "Failed to invoke cellInfoList change from AIDL. Exception" + ex);
816             }
817         } else {
818             Log.e(TAG, "null mRadioNetworkIndication");
819         }
820     }
821 }
822