1 /* 2 * Copyright (C) 2022 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.network.BarringInfo; 21 import android.hardware.radio.network.CellConnectionStatus; 22 import android.hardware.radio.network.CellInfo; 23 import android.hardware.radio.network.CellInfoRatSpecificInfo; 24 import android.hardware.radio.network.Domain; 25 import android.hardware.radio.network.EmergencyRegResult; 26 import android.hardware.radio.network.RegState; 27 import android.telephony.RadioAccessFamily; 28 import android.telephony.ServiceState; 29 import android.util.Log; 30 31 import com.android.internal.telephony.RILConstants; 32 33 import java.util.ArrayList; 34 import java.util.concurrent.CountDownLatch; 35 import java.util.concurrent.TimeUnit; 36 37 public class MockNetworkService { 38 private static final String TAG = "MockNetworkService"; 39 40 // Grouping of RAFs 41 // 2G 42 public static final int GSM = 43 RadioAccessFamily.RAF_GSM | RadioAccessFamily.RAF_GPRS | RadioAccessFamily.RAF_EDGE; 44 public static final int CDMA = 45 RadioAccessFamily.RAF_IS95A | RadioAccessFamily.RAF_IS95B | RadioAccessFamily.RAF_1xRTT; 46 // 3G 47 public static final int EVDO = 48 RadioAccessFamily.RAF_EVDO_0 49 | RadioAccessFamily.RAF_EVDO_A 50 | RadioAccessFamily.RAF_EVDO_B 51 | RadioAccessFamily.RAF_EHRPD; 52 public static final int HS = 53 RadioAccessFamily.RAF_HSUPA 54 | RadioAccessFamily.RAF_HSDPA 55 | RadioAccessFamily.RAF_HSPA 56 | RadioAccessFamily.RAF_HSPAP; 57 public static final int WCDMA = HS | RadioAccessFamily.RAF_UMTS; 58 // 4G 59 public static final int LTE = RadioAccessFamily.RAF_LTE | RadioAccessFamily.RAF_LTE_CA; 60 // 5G 61 public static final int NR = RadioAccessFamily.RAF_NR; 62 63 static final int MOCK_CARRIER_NO_SERVICE = 0; 64 65 // Network status update reason 66 static final int NETWORK_UPDATE_PREFERRED_MODE_CHANGE = 1; 67 68 public static final int LATCH_TRIGGER_EMERGENCY_SCAN = 0; 69 public static final int LATCH_CANCEL_EMERGENCY_SCAN = 1; 70 private static final int LATCH_MAX = 2; 71 72 private int mCsRegState = RegState.NOT_REG_MT_NOT_SEARCHING_OP; 73 private int mPsRegState = RegState.NOT_REG_MT_NOT_SEARCHING_OP; 74 75 private Context mContext; 76 77 private String mSimPlmn; 78 private boolean mIsHomeCamping; 79 private boolean mIsRoamingCamping; 80 private int mHomeCarrierId; 81 private int mRoamingCarrierId; 82 private int mInServiceCarrierId; 83 private int mHighRat; 84 85 private ArrayList<MockModemCell> mCellList = new ArrayList<MockModemCell>(); 86 87 private BarringInfo[] mBarringInfos = new BarringInfo[0]; 88 private EmergencyRegResult mEmergencyRegResult = new EmergencyRegResult(); 89 private boolean mEmergencyNetworkScanTriggered = false; 90 private boolean mEmergencyNetworkScanCanceled = false; 91 private int[] mEmergencyNetworkScanAccessNetwork = null; 92 private int mEmergencyNetworkScanType = -1; 93 private int mEmergencyMode = 0; 94 95 private final CountDownLatch[] mLatches = new CountDownLatch[LATCH_MAX]; 96 97 private class MockModemCell { 98 private int mCarrierId; 99 100 // Non-AOSP 101 public String[] mEHPlmnList; 102 public String[] mAllowRoamingList; 103 104 // AOSP 105 private CellInfo[] mCells; 106 MockModemCell(Context context, String file)107 MockModemCell(Context context, String file) { 108 MockNetworkConfig config; 109 110 config = new MockNetworkConfig(context); 111 config.getConfigFromAssets(file); 112 mCarrierId = config.getCarrierId(); 113 updateHomeRoamingList(config); 114 updateCellList(config); 115 } 116 getCarrierId()117 public int getCarrierId() { 118 return mCarrierId; 119 } 120 getCells()121 public CellInfo[] getCells() { 122 return mCells; 123 } 124 updateHomeRoamingList(MockNetworkConfig config)125 private void updateHomeRoamingList(MockNetworkConfig config) { 126 mEHPlmnList = config.getEHPlmnList(); 127 mAllowRoamingList = config.getAllowRoamingList(); 128 } 129 updateCellList(MockNetworkConfig config)130 private void updateCellList(MockNetworkConfig config) { 131 int cellNum; 132 133 cellNum = config.getCellNum(); 134 mCells = new CellInfo[cellNum]; 135 for (int i = 0; i < cellNum; i++) { 136 mCells[i] = config.getCellInfo(i); 137 } 138 } 139 getPrimaryCellOperatorInfo()140 public android.hardware.radio.network.OperatorInfo getPrimaryCellOperatorInfo() { 141 android.hardware.radio.network.OperatorInfo operatorInfo = 142 new android.hardware.radio.network.OperatorInfo(); 143 for (CellInfo cellInfo : getCells()) { 144 if (cellInfo.connectionStatus == CellConnectionStatus.PRIMARY_SERVING) { 145 switch (cellInfo.ratSpecificInfo.getTag()) { 146 case CellInfoRatSpecificInfo.wcdma: 147 operatorInfo = 148 cellInfo.ratSpecificInfo.getWcdma() 149 .cellIdentityWcdma 150 .operatorNames; 151 break; 152 case CellInfoRatSpecificInfo.lte: 153 operatorInfo = 154 cellInfo.ratSpecificInfo.getLte().cellIdentityLte.operatorNames; 155 break; 156 default: 157 break; 158 } 159 } 160 } 161 162 return operatorInfo; 163 } 164 getPrimaryCellSignalStrength()165 public android.hardware.radio.network.SignalStrength getPrimaryCellSignalStrength() { 166 android.hardware.radio.network.SignalStrength signalStrength = 167 new android.hardware.radio.network.SignalStrength(); 168 169 signalStrength.gsm = new android.hardware.radio.network.GsmSignalStrength(); 170 signalStrength.cdma = new android.hardware.radio.network.CdmaSignalStrength(); 171 signalStrength.evdo = new android.hardware.radio.network.EvdoSignalStrength(); 172 signalStrength.lte = new android.hardware.radio.network.LteSignalStrength(); 173 signalStrength.tdscdma = new android.hardware.radio.network.TdscdmaSignalStrength(); 174 signalStrength.wcdma = new android.hardware.radio.network.WcdmaSignalStrength(); 175 signalStrength.nr = new android.hardware.radio.network.NrSignalStrength(); 176 signalStrength.nr.csiCqiReport = new byte[0]; 177 178 for (CellInfo cellInfo : getCells()) { 179 if (cellInfo.connectionStatus == CellConnectionStatus.PRIMARY_SERVING) { 180 switch (cellInfo.ratSpecificInfo.getTag()) { 181 case CellInfoRatSpecificInfo.wcdma: 182 signalStrength.wcdma = 183 cellInfo.ratSpecificInfo.getWcdma().signalStrengthWcdma; 184 break; 185 case CellInfoRatSpecificInfo.lte: 186 signalStrength.lte = 187 cellInfo.ratSpecificInfo.getLte().signalStrengthLte; 188 break; 189 default: 190 break; 191 } 192 } 193 } 194 195 return signalStrength; 196 } 197 getPrimaryCellRat()198 public int getPrimaryCellRat() { 199 int rat = android.hardware.radio.RadioTechnology.UNKNOWN; 200 201 for (CellInfo cellInfo : getCells()) { 202 if (cellInfo.connectionStatus == CellConnectionStatus.PRIMARY_SERVING) { 203 switch (cellInfo.ratSpecificInfo.getTag()) { 204 case CellInfoRatSpecificInfo.wcdma: 205 // TODO: Need find an element to assign the rat WCDMA, HSUPA, HSDPA, or 206 // HSPA 207 rat = android.hardware.radio.RadioTechnology.HSPA; 208 break; 209 case CellInfoRatSpecificInfo.lte: 210 rat = android.hardware.radio.RadioTechnology.LTE; 211 break; 212 default: 213 break; 214 } 215 } 216 } 217 218 return rat; 219 } 220 getPrimaryCellIdentity()221 public android.hardware.radio.network.CellIdentity getPrimaryCellIdentity() { 222 android.hardware.radio.network.CellIdentity cellIdentity = 223 android.hardware.radio.network.CellIdentity.noinit(true); 224 225 for (CellInfo cellInfo : getCells()) { 226 if (cellInfo.connectionStatus == CellConnectionStatus.PRIMARY_SERVING) { 227 switch (cellInfo.ratSpecificInfo.getTag()) { 228 case CellInfoRatSpecificInfo.wcdma: 229 cellIdentity.setWcdma( 230 cellInfo.ratSpecificInfo.getWcdma().cellIdentityWcdma); 231 break; 232 case CellInfoRatSpecificInfo.lte: 233 cellIdentity.setLte(cellInfo.ratSpecificInfo.getLte().cellIdentityLte); 234 break; 235 default: 236 break; 237 } 238 } 239 } 240 241 return cellIdentity; 242 } 243 } 244 MockNetworkService(Context context)245 public MockNetworkService(Context context) { 246 mContext = context; 247 loadMockModemCell("mock_network_tw_cht.xml"); 248 loadMockModemCell("mock_network_tw_fet.xml"); 249 for (int i = 0; i < LATCH_MAX; i++) { 250 mLatches[i] = new CountDownLatch(1); 251 } 252 } 253 loadMockModemCell(String config)254 public void loadMockModemCell(String config) { 255 MockModemCell tmp = new MockModemCell(mContext, config); 256 int cid = tmp.getCarrierId(); 257 if (!mCellList.isEmpty()) { 258 for (MockModemCell mmc : mCellList) { 259 if (mmc.getCarrierId() == cid) { 260 Log.d(TAG, "Carrier ID " + cid + " had been loaded."); 261 return; 262 } 263 } 264 } 265 266 Log.d(TAG, "Load carrier(" + cid + ") " + config); 267 mCellList.add(tmp); 268 } 269 getHighestRatFromNetworkType(int raf)270 private int getHighestRatFromNetworkType(int raf) { 271 int rat; 272 int networkMode = RadioAccessFamily.getNetworkTypeFromRaf(raf); 273 274 switch (networkMode) { 275 case RILConstants.NETWORK_MODE_WCDMA_PREF: 276 rat = ServiceState.RIL_RADIO_TECHNOLOGY_HSPA; 277 break; 278 case RILConstants.NETWORK_MODE_GSM_ONLY: 279 rat = ServiceState.RIL_RADIO_TECHNOLOGY_GSM; 280 break; 281 case RILConstants.NETWORK_MODE_WCDMA_ONLY: 282 rat = ServiceState.RIL_RADIO_TECHNOLOGY_HSPA; 283 break; 284 case RILConstants.NETWORK_MODE_GSM_UMTS: 285 rat = ServiceState.RIL_RADIO_TECHNOLOGY_HSPA; 286 break; 287 case RILConstants.NETWORK_MODE_CDMA: 288 rat = ServiceState.RIL_RADIO_TECHNOLOGY_IS95A; 289 break; 290 case RILConstants.NETWORK_MODE_LTE_CDMA_EVDO: 291 rat = ServiceState.RIL_RADIO_TECHNOLOGY_LTE; 292 break; 293 case RILConstants.NETWORK_MODE_LTE_GSM_WCDMA: 294 rat = ServiceState.RIL_RADIO_TECHNOLOGY_LTE; 295 break; 296 case RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: 297 rat = ServiceState.RIL_RADIO_TECHNOLOGY_LTE; 298 break; 299 case RILConstants.NETWORK_MODE_LTE_ONLY: 300 rat = ServiceState.RIL_RADIO_TECHNOLOGY_LTE; 301 break; 302 case RILConstants.NETWORK_MODE_LTE_WCDMA: 303 rat = ServiceState.RIL_RADIO_TECHNOLOGY_LTE; 304 break; 305 case RILConstants.NETWORK_MODE_CDMA_NO_EVDO: 306 rat = ServiceState.RIL_RADIO_TECHNOLOGY_IS95A; 307 break; 308 case RILConstants.NETWORK_MODE_EVDO_NO_CDMA: 309 rat = ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_0; 310 break; 311 case RILConstants.NETWORK_MODE_GLOBAL: 312 // GSM | WCDMA | CDMA | EVDO; 313 rat = ServiceState.RIL_RADIO_TECHNOLOGY_HSPA; 314 break; 315 case RILConstants.NETWORK_MODE_TDSCDMA_ONLY: 316 rat = ServiceState.RIL_RADIO_TECHNOLOGY_TD_SCDMA; 317 break; 318 case RILConstants.NETWORK_MODE_TDSCDMA_WCDMA: 319 rat = ServiceState.RIL_RADIO_TECHNOLOGY_HSPA; 320 break; 321 case RILConstants.NETWORK_MODE_LTE_TDSCDMA: 322 rat = ServiceState.RIL_RADIO_TECHNOLOGY_LTE; 323 break; 324 case RILConstants.NETWORK_MODE_TDSCDMA_GSM: 325 rat = ServiceState.RIL_RADIO_TECHNOLOGY_TD_SCDMA; 326 break; 327 case RILConstants.NETWORK_MODE_LTE_TDSCDMA_GSM: 328 rat = ServiceState.RIL_RADIO_TECHNOLOGY_LTE; 329 break; 330 case RILConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA: 331 rat = ServiceState.RIL_RADIO_TECHNOLOGY_HSPA; 332 break; 333 case RILConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA: 334 rat = ServiceState.RIL_RADIO_TECHNOLOGY_LTE; 335 break; 336 case RILConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: 337 rat = ServiceState.RIL_RADIO_TECHNOLOGY_LTE; 338 break; 339 case RILConstants.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 340 rat = ServiceState.RIL_RADIO_TECHNOLOGY_HSPA; 341 break; 342 case RILConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 343 rat = ServiceState.RIL_RADIO_TECHNOLOGY_LTE; 344 break; 345 case RILConstants.NETWORK_MODE_NR_ONLY: 346 rat = ServiceState.RIL_RADIO_TECHNOLOGY_NR; 347 break; 348 case RILConstants.NETWORK_MODE_NR_LTE: 349 rat = ServiceState.RIL_RADIO_TECHNOLOGY_NR; 350 break; 351 case RILConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO: 352 rat = ServiceState.RIL_RADIO_TECHNOLOGY_NR; 353 break; 354 case RILConstants.NETWORK_MODE_NR_LTE_GSM_WCDMA: 355 rat = ServiceState.RIL_RADIO_TECHNOLOGY_NR; 356 break; 357 case RILConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA: 358 rat = ServiceState.RIL_RADIO_TECHNOLOGY_NR; 359 break; 360 case RILConstants.NETWORK_MODE_NR_LTE_WCDMA: 361 rat = ServiceState.RIL_RADIO_TECHNOLOGY_NR; 362 break; 363 case RILConstants.NETWORK_MODE_NR_LTE_TDSCDMA: 364 rat = ServiceState.RIL_RADIO_TECHNOLOGY_NR; 365 break; 366 case RILConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM: 367 rat = ServiceState.RIL_RADIO_TECHNOLOGY_NR; 368 break; 369 case RILConstants.NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA: 370 rat = ServiceState.RIL_RADIO_TECHNOLOGY_NR; 371 break; 372 case RILConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA: 373 rat = ServiceState.RIL_RADIO_TECHNOLOGY_NR; 374 break; 375 case RILConstants.NETWORK_MODE_NR_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 376 rat = ServiceState.RIL_RADIO_TECHNOLOGY_NR; 377 break; 378 default: 379 rat = ServiceState.RIL_RADIO_TECHNOLOGY_UNKNOWN; 380 break; 381 } 382 return rat; 383 } 384 getPrimaryCellOperatorInfo()385 public android.hardware.radio.network.OperatorInfo getPrimaryCellOperatorInfo() { 386 android.hardware.radio.network.OperatorInfo operatorInfo = 387 new android.hardware.radio.network.OperatorInfo(); 388 389 if (mCsRegState == RegState.REG_HOME || mPsRegState == RegState.REG_HOME) { 390 operatorInfo = getCarrierStatus(mHomeCarrierId).getPrimaryCellOperatorInfo(); 391 } else if (mCsRegState == RegState.REG_ROAMING || mPsRegState == RegState.REG_ROAMING) { 392 operatorInfo = getCarrierStatus(mRoamingCarrierId).getPrimaryCellOperatorInfo(); 393 } 394 395 return operatorInfo; 396 } 397 getPrimaryCellIdentity()398 public android.hardware.radio.network.CellIdentity getPrimaryCellIdentity() { 399 android.hardware.radio.network.CellIdentity cellIdentity = 400 android.hardware.radio.network.CellIdentity.noinit(true); 401 402 if (mCsRegState == RegState.REG_HOME || mPsRegState == RegState.REG_HOME) { 403 cellIdentity = getCarrierStatus(mHomeCarrierId).getPrimaryCellIdentity(); 404 } else if (mCsRegState == RegState.REG_ROAMING || mPsRegState == RegState.REG_ROAMING) { 405 cellIdentity = getCarrierStatus(mRoamingCarrierId).getPrimaryCellIdentity(); 406 } 407 408 return cellIdentity; 409 } 410 getCells()411 public android.hardware.radio.network.CellInfo[] getCells() { 412 ArrayList<android.hardware.radio.network.CellInfo> cellInfos = new ArrayList<>(); 413 414 for (MockModemCell mmc : mCellList) { 415 CellInfo[] cells = mmc.getCells(); 416 if (cells != null) { 417 for (CellInfo cellInfo : cells) { 418 cellInfos.add(cellInfo); 419 } 420 } 421 } 422 423 return cellInfos.stream().toArray(android.hardware.radio.network.CellInfo[]::new); 424 } 425 updateHighestRegisteredRat(int raf)426 public boolean updateHighestRegisteredRat(int raf) { 427 428 int rat = mHighRat; 429 mHighRat = getHighestRatFromNetworkType(raf); 430 431 return (rat == mHighRat); 432 } 433 updateNetworkStatus(int reason)434 public void updateNetworkStatus(int reason) { 435 if (reason == NETWORK_UPDATE_PREFERRED_MODE_CHANGE) { 436 Log.d(TAG, "updateNetworkStatus: NETWORK_UPDATE_PREFERRED_MODE_CHANGE"); 437 // TODO 438 } 439 } 440 getRegistrationRat()441 public int getRegistrationRat() { 442 int rat = android.hardware.radio.RadioTechnology.UNKNOWN; 443 444 if (mCsRegState == RegState.REG_HOME || mPsRegState == RegState.REG_HOME) { 445 rat = getCarrierStatus(mHomeCarrierId).getPrimaryCellRat(); 446 } else if (mCsRegState == RegState.REG_ROAMING || mPsRegState == RegState.REG_ROAMING) { 447 rat = getCarrierStatus(mRoamingCarrierId).getPrimaryCellRat(); 448 } 449 450 return rat; 451 } 452 getSignalStrength()453 public android.hardware.radio.network.SignalStrength getSignalStrength() { 454 android.hardware.radio.network.SignalStrength signalStrength = 455 new android.hardware.radio.network.SignalStrength(); 456 457 if (mCsRegState == RegState.REG_HOME || mPsRegState == RegState.REG_HOME) { 458 signalStrength = getCarrierStatus(mHomeCarrierId).getPrimaryCellSignalStrength(); 459 } else if (mCsRegState == RegState.REG_ROAMING || mPsRegState == RegState.REG_ROAMING) { 460 signalStrength = getCarrierStatus(mRoamingCarrierId).getPrimaryCellSignalStrength(); 461 } else { 462 // TODO 463 } 464 465 return signalStrength; 466 } 467 getRegistration(int domain)468 public int getRegistration(int domain) { 469 if (domain == android.hardware.radio.network.Domain.CS) { 470 return mCsRegState; 471 } else { 472 return mPsRegState; 473 } 474 } 475 isInService()476 public boolean isInService() { 477 return ((mCsRegState == RegState.REG_HOME) 478 || (mPsRegState == RegState.REG_HOME) 479 || (mCsRegState == RegState.REG_ROAMING) 480 || (mPsRegState == RegState.REG_ROAMING)); 481 } 482 isPsInService()483 public boolean isPsInService() { 484 return ((mPsRegState == RegState.REG_HOME) || (mPsRegState == RegState.REG_ROAMING)); 485 } 486 updateSimPlmn(String simPlmn)487 public void updateSimPlmn(String simPlmn) { 488 mSimPlmn = simPlmn; 489 490 // Reset mHomeCarrierId and mRoamingCarrierId 491 mHomeCarrierId = MOCK_CARRIER_NO_SERVICE; 492 mRoamingCarrierId = MOCK_CARRIER_NO_SERVICE; 493 494 if (mSimPlmn == null || mSimPlmn.isEmpty()) return; 495 496 if (mCellList.isEmpty()) return; 497 498 for (MockModemCell mmc : mCellList) { 499 500 if (isHomeCellExisted() && isRoamingCellExisted()) break; 501 502 // Find out which cell is Home cell 503 for (String plmn : mmc.mEHPlmnList) { 504 if (!isHomeCellExisted() && mSimPlmn.equals(plmn)) { 505 mHomeCarrierId = mmc.getCarrierId(); 506 Log.d(TAG, "Cell ID: Home Cell " + mHomeCarrierId); 507 } 508 } 509 510 // Find out which cell is Home cell 511 for (String plmn : mmc.mAllowRoamingList) { 512 if (!isRoamingCellExisted() && mSimPlmn.equals(plmn)) { 513 mRoamingCarrierId = mmc.getCarrierId(); 514 Log.d(TAG, "Cell ID: Roaming Cell " + mRoamingCarrierId); 515 } 516 } 517 } 518 } 519 520 /** 521 * Set the device enters IN SERVICE 522 * 523 * @param isRoaming boolean true if the camping network is Roaming service, otherwise Home 524 * service 525 * @param inService boolean true if the deviec enters carrier coverge, otherwise the device 526 * leaves the carrier coverage. 527 */ setServiceStatus(boolean isRoaming, boolean inService)528 public void setServiceStatus(boolean isRoaming, boolean inService) { 529 if (isRoaming) { 530 mIsRoamingCamping = inService; 531 } else { 532 mIsHomeCamping = inService; 533 } 534 } 535 getIsHomeCamping()536 public boolean getIsHomeCamping() { 537 return mIsHomeCamping; 538 } 539 getIsRoamingCamping()540 public boolean getIsRoamingCamping() { 541 return mIsRoamingCamping; 542 } 543 isHomeCellExisted()544 public boolean isHomeCellExisted() { 545 return (mHomeCarrierId != MOCK_CARRIER_NO_SERVICE); 546 } 547 isRoamingCellExisted()548 public boolean isRoamingCellExisted() { 549 return (mRoamingCarrierId != MOCK_CARRIER_NO_SERVICE); 550 } 551 updateServiceState(int reg)552 public void updateServiceState(int reg) { 553 Log.d(TAG, "Cell ID: updateServiceState " + reg); 554 switch (reg) { 555 case RegState.NOT_REG_MT_SEARCHING_OP: 556 mCsRegState = RegState.NOT_REG_MT_SEARCHING_OP; 557 mPsRegState = RegState.NOT_REG_MT_SEARCHING_OP; 558 break; 559 case RegState.REG_HOME: 560 mCsRegState = RegState.REG_HOME; 561 mPsRegState = RegState.REG_HOME; 562 break; 563 case RegState.REG_ROAMING: 564 mCsRegState = RegState.REG_ROAMING; 565 mPsRegState = RegState.REG_ROAMING; 566 break; 567 case RegState.NOT_REG_MT_NOT_SEARCHING_OP: 568 default: 569 mCsRegState = RegState.NOT_REG_MT_NOT_SEARCHING_OP; 570 mPsRegState = RegState.NOT_REG_MT_NOT_SEARCHING_OP; 571 break; 572 } 573 574 // TODO: mCsRegState and mPsReState may be changed by the registration denied reason set by 575 // TestCase 576 577 updateCellRegistration(); 578 } 579 updateServiceState(int reg, int domainBitmask)580 public void updateServiceState(int reg, int domainBitmask) { 581 Log.d(TAG, "Cell ID: updateServiceState " + reg + " with domainBitmask = " + domainBitmask); 582 switch (reg) { 583 case RegState.NOT_REG_MT_SEARCHING_OP: 584 if ((domainBitmask & Domain.CS) != 0) { 585 mCsRegState = RegState.NOT_REG_MT_SEARCHING_OP; 586 } 587 if ((domainBitmask & Domain.PS) != 0) { 588 mPsRegState = RegState.NOT_REG_MT_SEARCHING_OP; 589 } 590 break; 591 case RegState.REG_HOME: 592 if ((domainBitmask & Domain.CS) != 0) { 593 mCsRegState = RegState.REG_HOME; 594 } 595 if ((domainBitmask & Domain.PS) != 0) { 596 mPsRegState = RegState.REG_HOME; 597 } 598 break; 599 case RegState.REG_ROAMING: 600 if ((domainBitmask & Domain.CS) != 0) { 601 mCsRegState = RegState.REG_ROAMING; 602 } 603 if ((domainBitmask & Domain.PS) != 0) { 604 mPsRegState = RegState.REG_ROAMING; 605 } 606 break; 607 case RegState.NOT_REG_MT_NOT_SEARCHING_OP: 608 default: 609 if ((domainBitmask & Domain.CS) != 0) { 610 mCsRegState = RegState.NOT_REG_MT_NOT_SEARCHING_OP; 611 } 612 if ((domainBitmask & Domain.PS) != 0) { 613 mPsRegState = RegState.NOT_REG_MT_NOT_SEARCHING_OP; 614 } 615 break; 616 } 617 618 updateCellRegistration(); 619 } 620 updateCellRegistration()621 void updateCellRegistration() { 622 for (MockModemCell mmc : mCellList) { 623 boolean registered; 624 if ((mCsRegState == RegState.REG_HOME || mPsRegState == RegState.REG_HOME) 625 && mHomeCarrierId == mmc.getCarrierId()) { 626 registered = true; 627 } else if ((mCsRegState == RegState.REG_ROAMING || mPsRegState == RegState.REG_ROAMING) 628 && mRoamingCarrierId == mmc.getCarrierId()) { 629 registered = true; 630 } else { 631 registered = false; 632 } 633 634 CellInfo[] cells = mmc.getCells(); 635 if (cells != null) { 636 for (CellInfo cellInfo : cells) { 637 cellInfo.registered = registered; 638 } 639 } 640 } 641 } 642 getCarrierStatus(int carrierId)643 public MockModemCell getCarrierStatus(int carrierId) { 644 for (MockModemCell mmc : mCellList) { 645 if (mmc.getCarrierId() == carrierId) return mmc; 646 } 647 648 return null; 649 } 650 651 /** 652 * @return The barring status. 653 */ getBarringInfo()654 public BarringInfo[] getBarringInfo() { 655 return mBarringInfos; 656 } 657 658 /** 659 * Updates the barring status. 660 * @param barringInfos the barring status. 661 */ updateBarringInfos(BarringInfo[] barringInfos)662 public void updateBarringInfos(BarringInfo[] barringInfos) { 663 mBarringInfos = barringInfos; 664 } 665 666 /** 667 * Updates the emergency registration state. 668 * @param regResult the emergency registration state. 669 */ setEmergencyRegResult(EmergencyRegResult regResult)670 public void setEmergencyRegResult(EmergencyRegResult regResult) { 671 mEmergencyRegResult = regResult; 672 } 673 674 /** 675 * @return the emergency registration state. 676 */ getEmergencyRegResult()677 public EmergencyRegResult getEmergencyRegResult() { 678 return mEmergencyRegResult; 679 } 680 681 /** 682 * Updates the current emergency mode. 683 * @param mode the emergency mode 684 */ setEmergencyMode(int mode)685 public void setEmergencyMode(int mode) { 686 mEmergencyMode = mode; 687 } 688 689 /** 690 * @return the current emergency mode. 691 */ getEmergencyMode()692 public int getEmergencyMode() { 693 return mEmergencyMode; 694 } 695 696 /** 697 * Updates whether triggerEmergencyNetworkScan is requested and the attributes. 698 * 699 * @param state {@code true} if the scan is trigerred. 700 * @param accessNetwork the list of preferred network type. 701 * @param scanType indicates the preferred scan type. 702 */ setEmergencyNetworkScanTriggered(boolean state, int[] accessNetwork, int scanType)703 public void setEmergencyNetworkScanTriggered(boolean state, 704 int[] accessNetwork, int scanType) { 705 mEmergencyNetworkScanTriggered = state; 706 if (state) { 707 mEmergencyNetworkScanAccessNetwork = accessNetwork; 708 mEmergencyNetworkScanType = scanType; 709 countDownLatch(LATCH_TRIGGER_EMERGENCY_SCAN); 710 } 711 } 712 713 /** 714 * Updates whether cancelEmergencyNetworkScan is requested. 715 */ setEmergencyNetworkScanCanceled(boolean state)716 public void setEmergencyNetworkScanCanceled(boolean state) { 717 mEmergencyNetworkScanCanceled = state; 718 if (state) { 719 mEmergencyNetworkScanAccessNetwork = null; 720 mEmergencyNetworkScanType = -1; 721 countDownLatch(LATCH_CANCEL_EMERGENCY_SCAN); 722 } 723 } 724 725 /** 726 * @return whether emergency network scan is triggered. 727 */ isEmergencyNetworkScanTriggered()728 public boolean isEmergencyNetworkScanTriggered() { 729 return mEmergencyNetworkScanTriggered; 730 } 731 732 /** 733 * @return whether emergency network scan is canceled. 734 */ isEmergencyNetworkScanCanceled()735 public boolean isEmergencyNetworkScanCanceled() { 736 return mEmergencyNetworkScanCanceled; 737 } 738 739 /** 740 * @return the list of preferred network type. 741 */ getEmergencyNetworkScanAccessNetwork()742 public int[] getEmergencyNetworkScanAccessNetwork() { 743 return mEmergencyNetworkScanAccessNetwork; 744 } 745 746 /** 747 * @return the preferred scan type. 748 */ getEmergencyNetworkScanType()749 public int getEmergencyNetworkScanType() { 750 return mEmergencyNetworkScanType; 751 } 752 753 /** 754 * Resets the emergency network scan attributes. 755 */ resetEmergencyNetworkScan()756 public void resetEmergencyNetworkScan() { 757 mEmergencyRegResult = new EmergencyRegResult(); 758 mEmergencyNetworkScanTriggered = false; 759 mEmergencyNetworkScanCanceled = false; 760 mEmergencyNetworkScanAccessNetwork = null; 761 mEmergencyNetworkScanType = -1; 762 mEmergencyMode = 0; 763 } 764 countDownLatch(int latchIndex)765 private void countDownLatch(int latchIndex) { 766 synchronized (mLatches) { 767 mLatches[latchIndex].countDown(); 768 } 769 } 770 771 /** 772 * Waits for the event of network service. 773 * 774 * @param latchIndex The index of the event. 775 * @param waitMs The timeout in milliseconds. 776 * @return {@code true} if the event happens. 777 */ waitForLatchCountdown(int latchIndex, long waitMs)778 public boolean waitForLatchCountdown(int latchIndex, long waitMs) { 779 boolean complete = false; 780 try { 781 CountDownLatch latch; 782 synchronized (mLatches) { 783 latch = mLatches[latchIndex]; 784 } 785 long startTime = System.currentTimeMillis(); 786 complete = latch.await(waitMs, TimeUnit.MILLISECONDS); 787 Log.i(TAG, "Latch " + latchIndex + " took " 788 + (System.currentTimeMillis() - startTime) + " ms to count down."); 789 } catch (InterruptedException e) { 790 Log.e(TAG, "Waiting latch " + latchIndex + " interrupted, e=" + e); 791 } 792 synchronized (mLatches) { 793 mLatches[latchIndex] = new CountDownLatch(1); 794 } 795 return complete; 796 } 797 798 /** 799 * Resets the CountDownLatches 800 */ resetAllLatchCountdown()801 public void resetAllLatchCountdown() { 802 synchronized (mLatches) { 803 for (int i = 0; i < LATCH_MAX; i++) { 804 mLatches[i] = new CountDownLatch(1); 805 } 806 } 807 } 808 809 @Override toString()810 public String toString() { 811 return "isInService():" + isInService() + " Rat:" + getRegistrationRat() + ""; 812 } 813 } 814