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