API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 2nd, 2018
188
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 175.18 KB | None | 0 0
raw download clone embed print report
  1. package com.android.internal.telephony;
  2.  
  3. import android.content.Context;
  4. import android.content.pm.ApplicationInfo;
  5. import android.content.res.Resources;
  6. import android.hardware.radio.V1_0.Carrier;
  7. import android.hardware.radio.V1_0.CarrierRestrictions;
  8. import android.hardware.radio.V1_0.CdmaBroadcastSmsConfigInfo;
  9. import android.hardware.radio.V1_0.CdmaSignalStrength;
  10. import android.hardware.radio.V1_0.CdmaSmsAck;
  11. import android.hardware.radio.V1_0.CdmaSmsAddress;
  12. import android.hardware.radio.V1_0.CdmaSmsMessage;
  13. import android.hardware.radio.V1_0.CdmaSmsSubaddress;
  14. import android.hardware.radio.V1_0.CdmaSmsWriteArgs;
  15. import android.hardware.radio.V1_0.CellIdentityCdma;
  16. import android.hardware.radio.V1_0.CellIdentityGsm;
  17. import android.hardware.radio.V1_0.CellIdentityLte;
  18. import android.hardware.radio.V1_0.CellIdentityWcdma;
  19. import android.hardware.radio.V1_0.CellInfoCdma;
  20. import android.hardware.radio.V1_0.CellInfoGsm;
  21. import android.hardware.radio.V1_0.CellInfoLte;
  22. import android.hardware.radio.V1_0.CellInfoWcdma;
  23. import android.hardware.radio.V1_0.DataProfileInfo;
  24. import android.hardware.radio.V1_0.Dial;
  25. import android.hardware.radio.V1_0.EvdoSignalStrength;
  26. import android.hardware.radio.V1_0.GsmBroadcastSmsConfigInfo;
  27. import android.hardware.radio.V1_0.GsmSignalStrength;
  28. import android.hardware.radio.V1_0.GsmSmsMessage;
  29. import android.hardware.radio.V1_0.HardwareConfigModem;
  30. import android.hardware.radio.V1_0.HardwareConfigSim;
  31. import android.hardware.radio.V1_0.IRadio;
  32. import android.hardware.radio.V1_0.IccIo;
  33. import android.hardware.radio.V1_0.ImsSmsMessage;
  34. import android.hardware.radio.V1_0.LceDataInfo;
  35. import android.hardware.radio.V1_0.LteSignalStrength;
  36. import android.hardware.radio.V1_0.NvWriteItem;
  37. import android.hardware.radio.V1_0.RadioResponseInfo;
  38. import android.hardware.radio.V1_0.SelectUiccSub;
  39. import android.hardware.radio.V1_0.SetupDataCallResult;
  40. import android.hardware.radio.V1_0.SimApdu;
  41. import android.hardware.radio.V1_0.SmsWriteArgs;
  42. import android.hardware.radio.V1_0.TdScdmaSignalStrength;
  43. import android.hardware.radio.V1_0.UusInfo;
  44. import android.hardware.radio.V1_0.WcdmaSignalStrength;
  45. import android.hardware.radio.deprecated.V1_0.IOemHook;
  46. import android.net.ConnectivityManager;
  47. import android.os.AsyncResult;
  48. import android.os.Handler;
  49. import android.os.IHwBinder.DeathRecipient;
  50. import android.os.Message;
  51. import android.os.Parcel;
  52. import android.os.Parcelable.Creator;
  53. import android.os.PowerManager;
  54. import android.os.PowerManager.WakeLock;
  55. import android.os.Registrant;
  56. import android.os.RegistrantList;
  57. import android.os.RemoteException;
  58. import android.os.SystemClock;
  59. import android.os.SystemProperties;
  60. import android.os.WorkSource;
  61. import android.service.carrier.CarrierIdentifier;
  62. import android.telephony.ClientRequestStats;
  63. import android.telephony.ModemActivityInfo;
  64. import android.telephony.NeighboringCellInfo;
  65. import android.telephony.PhoneNumberUtils;
  66. import android.telephony.RadioAccessFamily;
  67. import android.telephony.Rlog;
  68. import android.telephony.TelephonyHistogram;
  69. import android.text.TextUtils;
  70. import android.util.SparseArray;
  71. import com.android.internal.telephony.cdma.CdmaInformationRecords;
  72. import com.android.internal.telephony.cdma.CdmaInformationRecords.CdmaDisplayInfoRec;
  73. import com.android.internal.telephony.cdma.CdmaInformationRecords.CdmaLineControlInfoRec;
  74. import com.android.internal.telephony.cdma.CdmaInformationRecords.CdmaNumberInfoRec;
  75. import com.android.internal.telephony.cdma.CdmaInformationRecords.CdmaRedirectingNumberInfoRec;
  76. import com.android.internal.telephony.cdma.CdmaInformationRecords.CdmaSignalInfoRec;
  77. import com.android.internal.telephony.cdma.CdmaInformationRecords.CdmaT53AudioControlInfoRec;
  78. import com.android.internal.telephony.cdma.CdmaInformationRecords.CdmaT53ClirInfoRec;
  79. import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;
  80. import com.android.internal.telephony.dataconnection.DataCallResponse;
  81. import com.android.internal.telephony.dataconnection.DataProfile;
  82. import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo;
  83. import com.android.internal.telephony.metrics.TelephonyMetrics;
  84. import com.android.internal.telephony.uicc.IccUtils;
  85. import com.android.internal.util.Preconditions;
  86. import java.io.ByteArrayInputStream;
  87. import java.io.DataInputStream;
  88. import java.io.IOException;
  89. import java.util.ArrayList;
  90. import java.util.Arrays;
  91. import java.util.Iterator;
  92. import java.util.List;
  93. import java.util.concurrent.atomic.AtomicBoolean;
  94. import java.util.concurrent.atomic.AtomicLong;
  95.  
  96. public class RIL
  97. extends BaseCommands
  98. implements CommandsInterface
  99. {
  100. private static final int DEFAULT_ACK_WAKE_LOCK_TIMEOUT_MS = 200;
  101. private static final int DEFAULT_BLOCKING_MESSAGE_RESPONSE_TIMEOUT_MS = 2000;
  102. private static final int DEFAULT_WAKE_LOCK_TIMEOUT_MS = 60000;
  103. static final int EVENT_ACK_WAKE_LOCK_TIMEOUT = 4;
  104. static final int EVENT_BLOCKING_RESPONSE_TIMEOUT = 5;
  105. static final int EVENT_RADIO_PROXY_DEAD = 6;
  106. static final int EVENT_WAKE_LOCK_TIMEOUT = 2;
  107. public static final int FOR_ACK_WAKELOCK = 1;
  108. public static final int FOR_WAKELOCK = 0;
  109. static final String[] HIDL_SERVICE_NAME = { "slot1", "slot2", "slot3" };
  110. public static final int INVALID_WAKELOCK = -1;
  111. static final int IRADIO_GET_SERVICE_DELAY_MILLIS = 4000;
  112. static final String RILJ_ACK_WAKELOCK_NAME = "RILJ_ACK_WL";
  113. static final boolean RILJ_LOGD = true;
  114. static final boolean RILJ_LOGV = false;
  115. static final String RILJ_LOG_TAG = "RILJ";
  116. static final int RIL_HISTOGRAM_BUCKET_COUNT = 5;
  117. static SparseArray<TelephonyHistogram> mRilTimeHistograms = new SparseArray();
  118. final PowerManager.WakeLock mAckWakeLock;
  119. final int mAckWakeLockTimeout;
  120. volatile int mAckWlSequenceNum = 0;
  121. private WorkSource mActiveWakelockWorkSource;
  122. private final ClientWakelockTracker mClientWakelockTracker = new ClientWakelockTracker();
  123. protected boolean mIsMobileNetworkSupported;
  124. Object[] mLastNITZTimeInfo;
  125. private TelephonyMetrics mMetrics = TelephonyMetrics.getInstance();
  126. OemHookIndication mOemHookIndication;
  127. volatile IOemHook mOemHookProxy = null;
  128. OemHookResponse mOemHookResponse;
  129. final Integer mPhoneId;
  130. protected WorkSource mRILDefaultWorkSource;
  131. RadioIndication mRadioIndication;
  132. volatile IRadio mRadioProxy = null;
  133. final AtomicLong mRadioProxyCookie = new AtomicLong(0L);
  134. final RadioProxyDeathRecipient mRadioProxyDeathRecipient;
  135. RadioResponse mRadioResponse;
  136. SparseArray<RILRequest> mRequestList = new SparseArray();
  137. final RilHandler mRilHandler;
  138. AtomicBoolean mTestingEmergencyCall = new AtomicBoolean(false);
  139. final PowerManager.WakeLock mWakeLock;
  140. int mWakeLockCount;
  141. final int mWakeLockTimeout;
  142. volatile int mWlSequenceNum = 0;
  143.  
  144. public RIL(Context paramContext, int paramInt1, int paramInt2)
  145. {
  146. this(paramContext, paramInt1, paramInt2, null);
  147. }
  148.  
  149. public RIL(Context paramContext, int paramInt1, int paramInt2, Integer paramInteger)
  150. {
  151. super(paramContext);
  152. riljLog("RIL: init preferredNetworkType=" + paramInt1 + " cdmaSubscription=" + paramInt2 + ")");
  153. mContext = paramContext;
  154. mCdmaSubscription = paramInt2;
  155. mPreferredNetworkType = paramInt1;
  156. mPhoneType = 0;
  157. mPhoneId = paramInteger;
  158. mIsMobileNetworkSupported = ((ConnectivityManager)paramContext.getSystemService("connectivity")).isNetworkSupported(0);
  159. mRadioResponse = new RadioResponse(this);
  160. mRadioIndication = new RadioIndication(this);
  161. mOemHookResponse = new OemHookResponse(this);
  162. mOemHookIndication = new OemHookIndication(this);
  163. mRilHandler = new RilHandler();
  164. mRadioProxyDeathRecipient = new RadioProxyDeathRecipient();
  165. paramInteger = (PowerManager)paramContext.getSystemService("power");
  166. mWakeLock = paramInteger.newWakeLock(1, "RILJ");
  167. mWakeLock.setReferenceCounted(false);
  168. mAckWakeLock = paramInteger.newWakeLock(1, "RILJ_ACK_WL");
  169. mAckWakeLock.setReferenceCounted(false);
  170. mWakeLockTimeout = SystemProperties.getInt("ro.ril.wake_lock_timeout", 60000);
  171. mAckWakeLockTimeout = SystemProperties.getInt("ro.ril.wake_lock_timeout", 200);
  172. mWakeLockCount = 0;
  173. mRILDefaultWorkSource = new WorkSource(getApplicationInfouid, paramContext.getPackageName());
  174. TelephonyDevController.getInstance();
  175. TelephonyDevController.registerRIL(this);
  176. getRadioProxy(null);
  177. getOemHookProxy(null);
  178. }
  179.  
  180. private void acquireWakeLock(RILRequest paramRILRequest, int paramInt)
  181. {
  182. for (;;)
  183. {
  184. Object localObject3;
  185. try
  186. {
  187. if (mWakeLockType != -1)
  188. {
  189. ??? = new java/lang/StringBuilder;
  190. ((StringBuilder)???).<init>();
  191. Rlog.d("RILJ", "Failed to aquire wakelock for " + paramRILRequest.serialString());
  192. return;
  193. }
  194. switch (paramInt)
  195. {
  196. default:
  197. ??? = new java/lang/StringBuilder;
  198. ((StringBuilder)???).<init>();
  199. Rlog.w("RILJ", "Acquiring Invalid Wakelock type " + paramInt);
  200. return;
  201. }
  202. }
  203. finally {}
  204. synchronized (mWakeLock)
  205. {
  206. mWakeLock.acquire();
  207. mWakeLockCount += 1;
  208. mWlSequenceNum += 1;
  209. localObject3 = getWorkSourceClientId(mWorkSource);
  210. if (!mClientWakelockTracker.isClientActive((String)localObject3))
  211. {
  212. if (mActiveWakelockWorkSource != null)
  213. {
  214. mActiveWakelockWorkSource.add(mWorkSource);
  215. mWakeLock.setWorkSource(mActiveWakelockWorkSource);
  216. }
  217. }
  218. else
  219. {
  220. mClientWakelockTracker.startTracking(mClientId, mRequest, mSerial, mWakeLockCount);
  221. localObject3 = mRilHandler.obtainMessage(2);
  222. arg1 = mWlSequenceNum;
  223. mRilHandler.sendMessageDelayed((Message)localObject3, mWakeLockTimeout);
  224. mWakeLockType = paramInt;
  225. return;
  226. }
  227. mActiveWakelockWorkSource = mWorkSource;
  228. }
  229. synchronized (mAckWakeLock)
  230. {
  231. mAckWakeLock.acquire();
  232. mAckWlSequenceNum += 1;
  233. Message localMessage = mRilHandler.obtainMessage(4);
  234. arg1 = mAckWlSequenceNum;
  235. mRilHandler.sendMessageDelayed(localMessage, mAckWakeLockTimeout);
  236. }
  237. }
  238. }
  239.  
  240. private void addRequest(RILRequest paramRILRequest)
  241. {
  242. acquireWakeLock(paramRILRequest, 0);
  243. synchronized (mRequestList)
  244. {
  245. mStartTimeMs = SystemClock.elapsedRealtime();
  246. mRequestList.append(mSerial, paramRILRequest);
  247. return;
  248. }
  249. }
  250.  
  251. private void addToRilHistogram(RILRequest paramRILRequest)
  252. {
  253. int i = (int)(SystemClock.elapsedRealtime() - mStartTimeMs);
  254. synchronized (mRilTimeHistograms)
  255. {
  256. TelephonyHistogram localTelephonyHistogram1 = (TelephonyHistogram)mRilTimeHistograms.get(mRequest);
  257. TelephonyHistogram localTelephonyHistogram2 = localTelephonyHistogram1;
  258. if (localTelephonyHistogram1 == null)
  259. {
  260. localTelephonyHistogram2 = new android/telephony/TelephonyHistogram;
  261. localTelephonyHistogram2.<init>(1, mRequest, 5);
  262. mRilTimeHistograms.put(mRequest, localTelephonyHistogram2);
  263. }
  264. localTelephonyHistogram2.addTimeTaken(i);
  265. return;
  266. }
  267. }
  268.  
  269. public static byte[] arrayListToPrimitiveArray(ArrayList<Byte> paramArrayList)
  270. {
  271. byte[] arrayOfByte = new byte[paramArrayList.size()];
  272. for (int i = 0; i < arrayOfByte.length; i++) {
  273. arrayOfByte[i] = ((Byte)paramArrayList.get(i)).byteValue();
  274. }
  275. return arrayOfByte;
  276. }
  277.  
  278. private void clearRequestList(int paramInt, boolean paramBoolean)
  279. {
  280. synchronized (mRequestList)
  281. {
  282. int i = mRequestList.size();
  283. StringBuilder localStringBuilder;
  284. if (paramBoolean)
  285. {
  286. localStringBuilder = new java/lang/StringBuilder;
  287. localStringBuilder.<init>();
  288. Rlog.d("RILJ", "clearRequestList mWakeLockCount=" + mWakeLockCount + " mRequestList=" + i);
  289. }
  290. for (int j = 0; j < i; j++)
  291. {
  292. RILRequest localRILRequest = (RILRequest)mRequestList.valueAt(j);
  293. if (paramBoolean)
  294. {
  295. localStringBuilder = new java/lang/StringBuilder;
  296. localStringBuilder.<init>();
  297. Rlog.d("RILJ", j + ": [" + mSerial + "] " + requestToString(mRequest));
  298. }
  299. localRILRequest.onError(paramInt, null);
  300. decrementWakeLock(localRILRequest);
  301. localRILRequest.release();
  302. }
  303. mRequestList.clear();
  304. return;
  305. }
  306. }
  307.  
  308. private boolean clearWakeLock(int paramInt)
  309. {
  310. boolean bool;
  311. if (paramInt == 0) {
  312. synchronized (mWakeLock)
  313. {
  314. if (mWakeLockCount == 0)
  315. {
  316. bool = mWakeLock.isHeld();
  317. if ((bool ^ true)) {
  318. return false;
  319. }
  320. }
  321. StringBuilder localStringBuilder = new java/lang/StringBuilder;
  322. localStringBuilder.<init>();
  323. Rlog.d("RILJ", "NOTE: mWakeLockCount is " + mWakeLockCount + "at time of clearing");
  324. mWakeLockCount = 0;
  325. mWakeLock.release();
  326. mClientWakelockTracker.stopTrackingAll();
  327. mActiveWakelockWorkSource = null;
  328. return true;
  329. }
  330. }
  331. synchronized (mAckWakeLock)
  332. {
  333. bool = mAckWakeLock.isHeld();
  334. if (!bool) {
  335. return false;
  336. }
  337. mAckWakeLock.release();
  338. return true;
  339. }
  340. }
  341.  
  342. private void constructCdmaSendSmsRilRequest(CdmaSmsMessage paramCdmaSmsMessage, byte[] paramArrayOfByte)
  343. {
  344. boolean bool1 = true;
  345. DataInputStream localDataInputStream = new DataInputStream(new ByteArrayInputStream(paramArrayOfByte));
  346. try
  347. {
  348. teleserviceId = localDataInputStream.readInt();
  349. if ((byte)localDataInputStream.readInt() == 1) {}
  350. for (boolean bool2 = true;; bool2 = false)
  351. {
  352. isServicePresent = bool2;
  353. serviceCategory = localDataInputStream.readInt();
  354. address.digitMode = localDataInputStream.read();
  355. address.numberMode = localDataInputStream.read();
  356. address.numberType = localDataInputStream.read();
  357. address.numberPlan = localDataInputStream.read();
  358. i = (byte)localDataInputStream.read();
  359. for (j = 0; j < i; j++) {
  360. address.digits.add(Byte.valueOf(localDataInputStream.readByte()));
  361. }
  362. }
  363. subAddress.subaddressType = localDataInputStream.read();
  364. paramArrayOfByte = subAddress;
  365. if ((byte)localDataInputStream.read() == 1) {}
  366. for (bool2 = bool1;; bool2 = false)
  367. {
  368. odd = bool2;
  369. i = (byte)localDataInputStream.read();
  370. for (j = 0; j < i; j++) {
  371. subAddress.digits.add(Byte.valueOf(localDataInputStream.readByte()));
  372. }
  373. }
  374. int i = localDataInputStream.read();
  375. for (int j = 0; j < i; j++) {
  376. bearerData.add(Byte.valueOf(localDataInputStream.readByte()));
  377. }
  378. return;
  379. }
  380. catch (IOException paramCdmaSmsMessage)
  381. {
  382. riljLog("sendSmsCdma: conversion from input stream to object failed: " + paramCdmaSmsMessage);
  383. }
  384. }
  385.  
  386. private GsmSmsMessage constructGsmSendSmsRilRequest(String paramString1, String paramString2)
  387. {
  388. GsmSmsMessage localGsmSmsMessage = new GsmSmsMessage();
  389. String str = paramString1;
  390. if (paramString1 == null) {
  391. str = "";
  392. }
  393. smscPdu = str;
  394. paramString1 = paramString2;
  395. if (paramString2 == null) {
  396. paramString1 = "";
  397. }
  398. pdu = paramString1;
  399. return localGsmSmsMessage;
  400. }
  401.  
  402. static DataCallResponse convertDataCallResult(SetupDataCallResult paramSetupDataCallResult)
  403. {
  404. return new DataCallResponse(status, suggestedRetryTime, cid, active, type, ifname, addresses, dnses, gateways, pcscf, mtu);
  405. }
  406.  
  407. static ArrayList<android.telephony.CellInfo> convertHalCellInfoList(ArrayList<android.hardware.radio.V1_0.CellInfo> paramArrayList)
  408. {
  409. ArrayList localArrayList = new ArrayList(paramArrayList.size());
  410. paramArrayList = paramArrayList.iterator();
  411. if (paramArrayList.hasNext())
  412. {
  413. Object localObject = (android.hardware.radio.V1_0.CellInfo)paramArrayList.next();
  414. Parcel localParcel = Parcel.obtain();
  415. localParcel.writeInt(cellInfoType);
  416. if (registered) {}
  417. for (int i = 1;; i = 0)
  418. {
  419. localParcel.writeInt(i);
  420. localParcel.writeInt(timeStampType);
  421. localParcel.writeLong(timeStamp);
  422. switch (cellInfoType)
  423. {
  424. default:
  425. throw new RuntimeException("unexpected cellinfotype: " + cellInfoType);
  426. }
  427. }
  428. localObject = (CellInfoGsm)gsm.get(0);
  429. localParcel.writeInt(Integer.parseInt(cellIdentityGsm.mcc));
  430. localParcel.writeInt(Integer.parseInt(cellIdentityGsm.mnc));
  431. localParcel.writeInt(cellIdentityGsm.lac);
  432. localParcel.writeInt(cellIdentityGsm.cid);
  433. localParcel.writeInt(cellIdentityGsm.arfcn);
  434. localParcel.writeInt(Byte.toUnsignedInt(cellIdentityGsm.bsic));
  435. localParcel.writeInt(signalStrengthGsm.signalStrength);
  436. localParcel.writeInt(signalStrengthGsm.bitErrorRate);
  437. localParcel.writeInt(signalStrengthGsm.timingAdvance);
  438. for (;;)
  439. {
  440. localParcel.setDataPosition(0);
  441. localObject = (android.telephony.CellInfo)android.telephony.CellInfo.CREATOR.createFromParcel(localParcel);
  442. localParcel.recycle();
  443. localArrayList.add(localObject);
  444. break;
  445. localObject = (CellInfoCdma)cdma.get(0);
  446. localParcel.writeInt(cellIdentityCdma.networkId);
  447. localParcel.writeInt(cellIdentityCdma.systemId);
  448. localParcel.writeInt(cellIdentityCdma.baseStationId);
  449. localParcel.writeInt(cellIdentityCdma.longitude);
  450. localParcel.writeInt(cellIdentityCdma.latitude);
  451. localParcel.writeInt(signalStrengthCdma.dbm);
  452. localParcel.writeInt(signalStrengthCdma.ecio);
  453. localParcel.writeInt(signalStrengthEvdo.dbm);
  454. localParcel.writeInt(signalStrengthEvdo.ecio);
  455. localParcel.writeInt(signalStrengthEvdo.signalNoiseRatio);
  456. continue;
  457. localObject = (CellInfoLte)lte.get(0);
  458. localParcel.writeInt(Integer.parseInt(cellIdentityLte.mcc));
  459. localParcel.writeInt(Integer.parseInt(cellIdentityLte.mnc));
  460. localParcel.writeInt(cellIdentityLte.ci);
  461. localParcel.writeInt(cellIdentityLte.pci);
  462. localParcel.writeInt(cellIdentityLte.tac);
  463. localParcel.writeInt(cellIdentityLte.earfcn);
  464. localParcel.writeInt(signalStrengthLte.signalStrength);
  465. localParcel.writeInt(signalStrengthLte.rsrp);
  466. localParcel.writeInt(signalStrengthLte.rsrq);
  467. localParcel.writeInt(signalStrengthLte.rssnr);
  468. localParcel.writeInt(signalStrengthLte.cqi);
  469. localParcel.writeInt(signalStrengthLte.timingAdvance);
  470. continue;
  471. localObject = (CellInfoWcdma)wcdma.get(0);
  472. localParcel.writeInt(Integer.parseInt(cellIdentityWcdma.mcc));
  473. localParcel.writeInt(Integer.parseInt(cellIdentityWcdma.mnc));
  474. localParcel.writeInt(cellIdentityWcdma.lac);
  475. localParcel.writeInt(cellIdentityWcdma.cid);
  476. localParcel.writeInt(cellIdentityWcdma.psc);
  477. localParcel.writeInt(cellIdentityWcdma.uarfcn);
  478. localParcel.writeInt(signalStrengthWcdma.signalStrength);
  479. localParcel.writeInt(signalStrengthWcdma.bitErrorRate);
  480. }
  481. }
  482. return localArrayList;
  483. }
  484.  
  485. static ArrayList<HardwareConfig> convertHalHwConfigList(ArrayList<android.hardware.radio.V1_0.HardwareConfig> paramArrayList, RIL paramRIL)
  486. {
  487. paramRIL = new ArrayList(paramArrayList.size());
  488. Iterator localIterator = paramArrayList.iterator();
  489. if (localIterator.hasNext())
  490. {
  491. android.hardware.radio.V1_0.HardwareConfig localHardwareConfig = (android.hardware.radio.V1_0.HardwareConfig)localIterator.next();
  492. int i = type;
  493. switch (i)
  494. {
  495. default:
  496. throw new RuntimeException("RIL_REQUEST_GET_HARDWARE_CONFIG invalid hardward type:" + i);
  497. case 0:
  498. paramArrayList = new HardwareConfig(i);
  499. HardwareConfigModem localHardwareConfigModem = (HardwareConfigModem)modem.get(0);
  500. paramArrayList.assignModem(uuid, state, rilModel, rat, maxVoice, maxData, maxStandby);
  501. }
  502. for (;;)
  503. {
  504. paramRIL.add(paramArrayList);
  505. break;
  506. paramArrayList = new HardwareConfig(i);
  507. paramArrayList.assignSim(uuid, state, sim.get(0)).modemUuid);
  508. }
  509. }
  510. return paramRIL;
  511. }
  512.  
  513. static ArrayList<Integer> convertHalLceData(LceDataInfo paramLceDataInfo, RIL paramRIL)
  514. {
  515. ArrayList localArrayList = new ArrayList();
  516. int i = lastHopCapacityKbps;
  517. int j = Byte.toUnsignedInt(confidenceLevel);
  518. if (lceSuspended) {}
  519. for (int k = 1;; k = 0)
  520. {
  521. paramRIL.riljLog("LCE capacity information received: capacity=" + i + " confidence=" + j + " lceSuspended=" + k);
  522. localArrayList.add(Integer.valueOf(i));
  523. localArrayList.add(Integer.valueOf(j));
  524. localArrayList.add(Integer.valueOf(k));
  525. return localArrayList;
  526. }
  527. }
  528.  
  529. static RadioCapability convertHalRadioCapability(android.hardware.radio.V1_0.RadioCapability paramRadioCapability, RIL paramRIL)
  530. {
  531. int i = session;
  532. int j = phase;
  533. int k = raf;
  534. String str = logicalModemUuid;
  535. int m = status;
  536. paramRIL.riljLog("convertHalRadioCapability: session=" + i + ", phase=" + j + ", rat=" + k + ", logicModemUuid=" + str + ", status=" + m);
  537. return new RadioCapability(mPhoneId.intValue(), i, j, k, str, m);
  538. }
  539.  
  540. static android.telephony.SignalStrength convertHalSignalStrength(android.hardware.radio.V1_0.SignalStrength paramSignalStrength)
  541. {
  542. return new android.telephony.SignalStrength(gw.signalStrength, gw.bitErrorRate, cdma.dbm, cdma.ecio, evdo.dbm, evdo.ecio, evdo.signalNoiseRatio, lte.signalStrength, lte.rsrp, lte.rsrq, lte.rssnr, lte.cqi, tdScdma.rscp, false);
  543. }
  544.  
  545. private String convertNullToEmptyString(String paramString)
  546. {
  547. if (paramString != null) {}
  548. for (;;)
  549. {
  550. return paramString;
  551. paramString = "";
  552. }
  553. }
  554.  
  555. private static DataProfileInfo convertToHalDataProfile(DataProfile paramDataProfile)
  556. {
  557. DataProfileInfo localDataProfileInfo = new DataProfileInfo();
  558. profileId = profileId;
  559. apn = apn;
  560. protocol = protocol;
  561. roamingProtocol = roamingProtocol;
  562. authType = authType;
  563. user = user;
  564. password = password;
  565. type = type;
  566. maxConnsTime = maxConnsTime;
  567. maxConns = maxConns;
  568. waitTime = waitTime;
  569. enabled = enabled;
  570. supportedApnTypesBitmap = supportedApnTypesBitmap;
  571. bearerBitmap = bearerBitmap;
  572. mtu = mtu;
  573. mvnoType = convertToHalMvnoType(mvnoType);
  574. mvnoMatchData = mvnoMatchData;
  575. return localDataProfileInfo;
  576. }
  577.  
  578. private static int convertToHalMvnoType(String paramString)
  579. {
  580. if (paramString.equals("imsi")) {
  581. return 1;
  582. }
  583. if (paramString.equals("gid")) {
  584. return 2;
  585. }
  586. if (paramString.equals("spn")) {
  587. return 3;
  588. }
  589. return 0;
  590. }
  591.  
  592. private static int convertToHalResetNvType(int paramInt)
  593. {
  594. switch (paramInt)
  595. {
  596. default:
  597. return -1;
  598. case 1:
  599. return 0;
  600. case 2:
  601. return 1;
  602. }
  603. return 2;
  604. }
  605.  
  606. private SimApdu createSimApdu(int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5, int paramInt6, String paramString)
  607. {
  608. SimApdu localSimApdu = new SimApdu();
  609. sessionId = paramInt1;
  610. cla = paramInt2;
  611. instruction = paramInt3;
  612. p1 = paramInt4;
  613. p2 = paramInt5;
  614. p3 = paramInt6;
  615. data = convertNullToEmptyString(paramString);
  616. return localSimApdu;
  617. }
  618.  
  619. /* Error */
  620. private void decrementWakeLock(RILRequest paramRILRequest)
  621. {
  622. // Byte code:
  623. // 0: iconst_0
  624. // 1: istore_2
  625. // 2: aload_1
  626. // 3: monitorenter
  627. // 4: aload_1
  628. // 5: getfield 342 com/android/internal/telephony/RILRequest:mWakeLockType I
  629. // 8: tableswitch default:+28->36, -1:+59->67, 0:+67->75, 1:+59->67
  630. // 36: new 196 java/lang/StringBuilder
  631. // 39: astore_3
  632. // 40: aload_3
  633. // 41: invokespecial 197 java/lang/StringBuilder:<init> ()V
  634. // 44: ldc 47
  635. // 46: aload_3
  636. // 47: ldc_w 1141
  637. // 50: invokevirtual 203 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
  638. // 53: aload_1
  639. // 54: getfield 342 com/android/internal/telephony/RILRequest:mWakeLockType I
  640. // 57: invokevirtual 206 java/lang/StringBuilder:append (I)Ljava/lang/StringBuilder;
  641. // 60: invokevirtual 214 java/lang/StringBuilder:toString ()Ljava/lang/String;
  642. // 63: invokestatic 358 android/telephony/Rlog:w (Ljava/lang/String;Ljava/lang/String;)I
  643. // 66: pop
  644. // 67: aload_1
  645. // 68: iconst_m1
  646. // 69: putfield 342 com/android/internal/telephony/RILRequest:mWakeLockType I
  647. // 72: aload_1
  648. // 73: monitorexit
  649. // 74: return
  650. // 75: aload_0
  651. // 76: getfield 286 com/android/internal/telephony/RIL:mWakeLock Landroid/os/PowerManager$WakeLock;
  652. // 79: astore_3
  653. // 80: aload_3
  654. // 81: monitorenter
  655. // 82: aload_0
  656. // 83: getfield 164 com/android/internal/telephony/RIL:mClientWakelockTracker Lcom/android/internal/telephony/ClientWakelockTracker;
  657. // 86: astore 4
  658. // 88: aload_1
  659. // 89: getfield 385 com/android/internal/telephony/RILRequest:mClientId Ljava/lang/String;
  660. // 92: astore 5
  661. // 94: aload_1
  662. // 95: getfield 388 com/android/internal/telephony/RILRequest:mRequest I
  663. // 98: istore 6
  664. // 100: aload_1
  665. // 101: getfield 391 com/android/internal/telephony/RILRequest:mSerial I
  666. // 104: istore 7
  667. // 106: aload_0
  668. // 107: getfield 307 com/android/internal/telephony/RIL:mWakeLockCount I
  669. // 110: iconst_1
  670. // 111: if_icmple +10 -> 121
  671. // 114: aload_0
  672. // 115: getfield 307 com/android/internal/telephony/RIL:mWakeLockCount I
  673. // 118: iconst_1
  674. // 119: isub
  675. // 120: istore_2
  676. // 121: aload 4
  677. // 123: aload 5
  678. // 125: iload 6
  679. // 127: iload 7
  680. // 129: iload_2
  681. // 130: invokevirtual 1144 com/android/internal/telephony/ClientWakelockTracker:stopTracking (Ljava/lang/String;III)V
  682. // 133: aload_0
  683. // 134: aload_1
  684. // 135: getfield 364 com/android/internal/telephony/RILRequest:mWorkSource Landroid/os/WorkSource;
  685. // 138: invokespecial 368 com/android/internal/telephony/RIL:getWorkSourceClientId (Landroid/os/WorkSource;)Ljava/lang/String;
  686. // 141: astore 4
  687. // 143: aload_0
  688. // 144: getfield 164 com/android/internal/telephony/RIL:mClientWakelockTracker Lcom/android/internal/telephony/ClientWakelockTracker;
  689. // 147: aload 4
  690. // 149: invokevirtual 372 com/android/internal/telephony/ClientWakelockTracker:isClientActive (Ljava/lang/String;)Z
  691. // 152: ifne +48 -> 200
  692. // 155: aload_0
  693. // 156: getfield 374 com/android/internal/telephony/RIL:mActiveWakelockWorkSource Landroid/os/WorkSource;
  694. // 159: ifnull +41 -> 200
  695. // 162: aload_0
  696. // 163: getfield 374 com/android/internal/telephony/RIL:mActiveWakelockWorkSource Landroid/os/WorkSource;
  697. // 166: aload_1
  698. // 167: getfield 364 com/android/internal/telephony/RILRequest:mWorkSource Landroid/os/WorkSource;
  699. // 170: invokevirtual 1147 android/os/WorkSource:remove (Landroid/os/WorkSource;)Z
  700. // 173: pop
  701. // 174: aload_0
  702. // 175: getfield 374 com/android/internal/telephony/RIL:mActiveWakelockWorkSource Landroid/os/WorkSource;
  703. // 178: invokevirtual 1148 android/os/WorkSource:size ()I
  704. // 181: ifne +8 -> 189
  705. // 184: aload_0
  706. // 185: aconst_null
  707. // 186: putfield 374 com/android/internal/telephony/RIL:mActiveWakelockWorkSource Landroid/os/WorkSource;
  708. // 189: aload_0
  709. // 190: getfield 286 com/android/internal/telephony/RIL:mWakeLock Landroid/os/PowerManager$WakeLock;
  710. // 193: aload_0
  711. // 194: getfield 374 com/android/internal/telephony/RIL:mActiveWakelockWorkSource Landroid/os/WorkSource;
  712. // 197: invokevirtual 382 android/os/PowerManager$WakeLock:setWorkSource (Landroid/os/WorkSource;)V
  713. // 200: aload_0
  714. // 201: getfield 307 com/android/internal/telephony/RIL:mWakeLockCount I
  715. // 204: iconst_1
  716. // 205: if_icmple +23 -> 228
  717. // 208: aload_0
  718. // 209: aload_0
  719. // 210: getfield 307 com/android/internal/telephony/RIL:mWakeLockCount I
  720. // 213: iconst_1
  721. // 214: isub
  722. // 215: putfield 307 com/android/internal/telephony/RIL:mWakeLockCount I
  723. // 218: aload_3
  724. // 219: monitorexit
  725. // 220: goto -153 -> 67
  726. // 223: astore_3
  727. // 224: aload_1
  728. // 225: monitorexit
  729. // 226: aload_3
  730. // 227: athrow
  731. // 228: aload_0
  732. // 229: iconst_0
  733. // 230: putfield 307 com/android/internal/telephony/RIL:mWakeLockCount I
  734. // 233: aload_0
  735. // 234: getfield 286 com/android/internal/telephony/RIL:mWakeLock Landroid/os/PowerManager$WakeLock;
  736. // 237: invokevirtual 494 android/os/PowerManager$WakeLock:release ()V
  737. // 240: goto -22 -> 218
  738. // 243: astore 4
  739. // 245: aload_3
  740. // 246: monitorexit
  741. // 247: aload 4
  742. // 249: athrow
  743. // Local variable table:
  744. // start length slot name signature
  745. // 0 250 0 this RIL
  746. // 0 250 1 paramRILRequest RILRequest
  747. // 1 129 2 i int
  748. // 223 23 3 localObject2 Object
  749. // 86 62 4 localObject3 Object
  750. // 243 5 4 localObject4 Object
  751. // 92 32 5 str String
  752. // 98 28 6 j int
  753. // 104 24 7 k int
  754. // Exception table:
  755. // from to target type
  756. // 4 36 223 finally
  757. // 36 67 223 finally
  758. // 67 72 223 finally
  759. // 75 82 223 finally
  760. // 218 220 223 finally
  761. // 245 250 223 finally
  762. // 82 106 243 finally
  763. // 106 121 243 finally
  764. // 121 189 243 finally
  765. // 189 200 243 finally
  766. // 200 218 243 finally
  767. // 228 240 243 finally
  768. }
  769.  
  770. private RILRequest findAndRemoveRequestFromList(int paramInt)
  771. {
  772. synchronized (mRequestList)
  773. {
  774. RILRequest localRILRequest = (RILRequest)mRequestList.get(paramInt);
  775. if (localRILRequest != null) {
  776. mRequestList.remove(paramInt);
  777. }
  778. return localRILRequest;
  779. }
  780. }
  781.  
  782. private WorkSource getDeafultWorkSourceIfInvalid(WorkSource paramWorkSource)
  783. {
  784. WorkSource localWorkSource = paramWorkSource;
  785. if (paramWorkSource == null) {
  786. localWorkSource = mRILDefaultWorkSource;
  787. }
  788. return localWorkSource;
  789. }
  790.  
  791. private IOemHook getOemHookProxy(Message paramMessage)
  792. {
  793. if (!mIsMobileNetworkSupported)
  794. {
  795. if (paramMessage != null)
  796. {
  797. AsyncResult.forMessage(paramMessage, null, CommandException.fromRilErrno(1));
  798. paramMessage.sendToTarget();
  799. }
  800. return null;
  801. }
  802. if (mOemHookProxy != null) {
  803. return mOemHookProxy;
  804. }
  805. for (;;)
  806. {
  807. try
  808. {
  809. String[] arrayOfString = HIDL_SERVICE_NAME;
  810. if (mPhoneId != null) {
  811. continue;
  812. }
  813. i = 0;
  814. mOemHookProxy = IOemHook.getService(arrayOfString[i]);
  815. if (mOemHookProxy == null) {
  816. continue;
  817. }
  818. mOemHookProxy.setResponseFunctions(mOemHookResponse, mOemHookIndication);
  819. }
  820. catch (RemoteException|RuntimeException localRemoteException)
  821. {
  822. int i;
  823. mOemHookProxy = null;
  824. riljLoge("OemHookProxy getService/setResponseFunctions: " + localRemoteException);
  825. continue;
  826. }
  827. if (mOemHookProxy == null)
  828. {
  829. if (paramMessage != null)
  830. {
  831. AsyncResult.forMessage(paramMessage, null, CommandException.fromRilErrno(1));
  832. paramMessage.sendToTarget();
  833. }
  834. mRilHandler.sendMessageDelayed(mRilHandler.obtainMessage(6, Long.valueOf(mRadioProxyCookie.incrementAndGet())), 4000L);
  835. }
  836. return mOemHookProxy;
  837. i = mPhoneId.intValue();
  838. continue;
  839. riljLoge("getOemHookProxy: mOemHookProxy == null");
  840. }
  841. }
  842.  
  843. private IRadio getRadioProxy(Message paramMessage)
  844. {
  845. if (!mIsMobileNetworkSupported)
  846. {
  847. if (paramMessage != null)
  848. {
  849. AsyncResult.forMessage(paramMessage, null, CommandException.fromRilErrno(1));
  850. paramMessage.sendToTarget();
  851. }
  852. return null;
  853. }
  854. if (mRadioProxy != null) {
  855. return mRadioProxy;
  856. }
  857. for (;;)
  858. {
  859. try
  860. {
  861. String[] arrayOfString = HIDL_SERVICE_NAME;
  862. if (mPhoneId != null) {
  863. continue;
  864. }
  865. i = 0;
  866. mRadioProxy = IRadio.getService(arrayOfString[i]);
  867. if (mRadioProxy == null) {
  868. continue;
  869. }
  870. mRadioProxy.linkToDeath(mRadioProxyDeathRecipient, mRadioProxyCookie.incrementAndGet());
  871. mRadioProxy.setResponseFunctions(mRadioResponse, mRadioIndication);
  872. }
  873. catch (RemoteException|RuntimeException localRemoteException)
  874. {
  875. int i;
  876. mRadioProxy = null;
  877. riljLoge("RadioProxy getService/setResponseFunctions: " + localRemoteException);
  878. continue;
  879. }
  880. if (mRadioProxy == null)
  881. {
  882. if (paramMessage != null)
  883. {
  884. AsyncResult.forMessage(paramMessage, null, CommandException.fromRilErrno(1));
  885. paramMessage.sendToTarget();
  886. }
  887. mRilHandler.sendMessageDelayed(mRilHandler.obtainMessage(6, Long.valueOf(mRadioProxyCookie.incrementAndGet())), 4000L);
  888. }
  889. return mRadioProxy;
  890. i = mPhoneId.intValue();
  891. continue;
  892. riljLoge("getRadioProxy: mRadioProxy == null");
  893. }
  894. }
  895.  
  896. private static Object getResponseForTimedOutRILRequest(RILRequest paramRILRequest)
  897. {
  898. if (paramRILRequest == null) {
  899. return null;
  900. }
  901. Object localObject = null;
  902. switch (mRequest)
  903. {
  904. }
  905. for (paramRILRequest = localObject;; paramRILRequest = new ModemActivityInfo(0L, 0, 0, new int[5], 0, 0)) {
  906. return paramRILRequest;
  907. }
  908. }
  909.  
  910. public static List<TelephonyHistogram> getTelephonyRILTimingHistograms()
  911. {
  912. synchronized (mRilTimeHistograms)
  913. {
  914. ArrayList localArrayList = new java/util/ArrayList;
  915. localArrayList.<init>(mRilTimeHistograms.size());
  916. for (int i = 0; i < mRilTimeHistograms.size(); i++)
  917. {
  918. TelephonyHistogram localTelephonyHistogram = new android/telephony/TelephonyHistogram;
  919. localTelephonyHistogram.<init>((TelephonyHistogram)mRilTimeHistograms.valueAt(i));
  920. localArrayList.add(localTelephonyHistogram);
  921. }
  922. return localArrayList;
  923. }
  924. }
  925.  
  926. private String getWorkSourceClientId(WorkSource paramWorkSource)
  927. {
  928. if (paramWorkSource != null) {
  929. return String.valueOf(paramWorkSource.get(0)) + ":" + paramWorkSource.getName(0);
  930. }
  931. return null;
  932. }
  933.  
  934. private void handleRadioProxyExceptionForRR(RILRequest paramRILRequest, String paramString, Exception paramException)
  935. {
  936. riljLoge(paramString + ": " + paramException);
  937. resetProxyAndRequestList();
  938. mRilHandler.sendMessageDelayed(mRilHandler.obtainMessage(6, Long.valueOf(mRadioProxyCookie.incrementAndGet())), 4000L);
  939. }
  940.  
  941. private RILRequest obtainRequest(int paramInt, Message paramMessage, WorkSource paramWorkSource)
  942. {
  943. paramMessage = RILRequest.obtain(paramInt, paramMessage, paramWorkSource);
  944. addRequest(paramMessage);
  945. return paramMessage;
  946. }
  947.  
  948. public static ArrayList<Byte> primitiveArrayToArrayList(byte[] paramArrayOfByte)
  949. {
  950. ArrayList localArrayList = new ArrayList(paramArrayOfByte.length);
  951. int i = 0;
  952. int j = paramArrayOfByte.length;
  953. while (i < j)
  954. {
  955. localArrayList.add(Byte.valueOf(paramArrayOfByte[i]));
  956. i++;
  957. }
  958. return localArrayList;
  959. }
  960.  
  961. static String requestToString(int paramInt)
  962. {
  963. switch (paramInt)
  964. {
  965. default:
  966. return "<unknown request>";
  967. case 1:
  968. return "GET_SIM_STATUS";
  969. case 2:
  970. return "ENTER_SIM_PIN";
  971. case 3:
  972. return "ENTER_SIM_PUK";
  973. case 4:
  974. return "ENTER_SIM_PIN2";
  975. case 5:
  976. return "ENTER_SIM_PUK2";
  977. case 6:
  978. return "CHANGE_SIM_PIN";
  979. case 7:
  980. return "CHANGE_SIM_PIN2";
  981. case 8:
  982. return "ENTER_NETWORK_DEPERSONALIZATION";
  983. case 9:
  984. return "GET_CURRENT_CALLS";
  985. case 10:
  986. return "DIAL";
  987. case 11:
  988. return "GET_IMSI";
  989. case 12:
  990. return "HANGUP";
  991. case 13:
  992. return "HANGUP_WAITING_OR_BACKGROUND";
  993. case 14:
  994. return "HANGUP_FOREGROUND_RESUME_BACKGROUND";
  995. case 15:
  996. return "REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE";
  997. case 16:
  998. return "CONFERENCE";
  999. case 17:
  1000. return "UDUB";
  1001. case 18:
  1002. return "LAST_CALL_FAIL_CAUSE";
  1003. case 19:
  1004. return "SIGNAL_STRENGTH";
  1005. case 20:
  1006. return "VOICE_REGISTRATION_STATE";
  1007. case 21:
  1008. return "DATA_REGISTRATION_STATE";
  1009. case 22:
  1010. return "OPERATOR";
  1011. case 23:
  1012. return "RADIO_POWER";
  1013. case 24:
  1014. return "DTMF";
  1015. case 25:
  1016. return "SEND_SMS";
  1017. case 26:
  1018. return "SEND_SMS_EXPECT_MORE";
  1019. case 27:
  1020. return "SETUP_DATA_CALL";
  1021. case 28:
  1022. return "SIM_IO";
  1023. case 29:
  1024. return "SEND_USSD";
  1025. case 30:
  1026. return "CANCEL_USSD";
  1027. case 31:
  1028. return "GET_CLIR";
  1029. case 32:
  1030. return "SET_CLIR";
  1031. case 33:
  1032. return "QUERY_CALL_FORWARD_STATUS";
  1033. case 34:
  1034. return "SET_CALL_FORWARD";
  1035. case 35:
  1036. return "QUERY_CALL_WAITING";
  1037. case 36:
  1038. return "SET_CALL_WAITING";
  1039. case 37:
  1040. return "SMS_ACKNOWLEDGE";
  1041. case 38:
  1042. return "GET_IMEI";
  1043. case 39:
  1044. return "GET_IMEISV";
  1045. case 40:
  1046. return "ANSWER";
  1047. case 41:
  1048. return "DEACTIVATE_DATA_CALL";
  1049. case 42:
  1050. return "QUERY_FACILITY_LOCK";
  1051. case 43:
  1052. return "SET_FACILITY_LOCK";
  1053. case 44:
  1054. return "CHANGE_BARRING_PASSWORD";
  1055. case 45:
  1056. return "QUERY_NETWORK_SELECTION_MODE";
  1057. case 46:
  1058. return "SET_NETWORK_SELECTION_AUTOMATIC";
  1059. case 47:
  1060. return "SET_NETWORK_SELECTION_MANUAL";
  1061. case 48:
  1062. return "QUERY_AVAILABLE_NETWORKS ";
  1063. case 49:
  1064. return "DTMF_START";
  1065. case 50:
  1066. return "DTMF_STOP";
  1067. case 51:
  1068. return "BASEBAND_VERSION";
  1069. case 52:
  1070. return "SEPARATE_CONNECTION";
  1071. case 53:
  1072. return "SET_MUTE";
  1073. case 54:
  1074. return "GET_MUTE";
  1075. case 55:
  1076. return "QUERY_CLIP";
  1077. case 56:
  1078. return "LAST_DATA_CALL_FAIL_CAUSE";
  1079. case 57:
  1080. return "DATA_CALL_LIST";
  1081. case 58:
  1082. return "RESET_RADIO";
  1083. case 59:
  1084. return "OEM_HOOK_RAW";
  1085. case 60:
  1086. return "OEM_HOOK_STRINGS";
  1087. case 61:
  1088. return "SCREEN_STATE";
  1089. case 62:
  1090. return "SET_SUPP_SVC_NOTIFICATION";
  1091. case 63:
  1092. return "WRITE_SMS_TO_SIM";
  1093. case 64:
  1094. return "DELETE_SMS_ON_SIM";
  1095. case 65:
  1096. return "SET_BAND_MODE";
  1097. case 66:
  1098. return "QUERY_AVAILABLE_BAND_MODE";
  1099. case 67:
  1100. return "REQUEST_STK_GET_PROFILE";
  1101. case 68:
  1102. return "REQUEST_STK_SET_PROFILE";
  1103. case 69:
  1104. return "REQUEST_STK_SEND_ENVELOPE_COMMAND";
  1105. case 70:
  1106. return "REQUEST_STK_SEND_TERMINAL_RESPONSE";
  1107. case 71:
  1108. return "REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
  1109. case 72:
  1110. return "REQUEST_EXPLICIT_CALL_TRANSFER";
  1111. case 73:
  1112. return "REQUEST_SET_PREFERRED_NETWORK_TYPE";
  1113. case 74:
  1114. return "REQUEST_GET_PREFERRED_NETWORK_TYPE";
  1115. case 75:
  1116. return "REQUEST_GET_NEIGHBORING_CELL_IDS";
  1117. case 76:
  1118. return "REQUEST_SET_LOCATION_UPDATES";
  1119. case 77:
  1120. return "RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE";
  1121. case 78:
  1122. return "RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE";
  1123. case 79:
  1124. return "RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE";
  1125. case 80:
  1126. return "RIL_REQUEST_SET_TTY_MODE";
  1127. case 81:
  1128. return "RIL_REQUEST_QUERY_TTY_MODE";
  1129. case 82:
  1130. return "RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE";
  1131. case 83:
  1132. return "RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE";
  1133. case 84:
  1134. return "RIL_REQUEST_CDMA_FLASH";
  1135. case 85:
  1136. return "RIL_REQUEST_CDMA_BURST_DTMF";
  1137. case 87:
  1138. return "RIL_REQUEST_CDMA_SEND_SMS";
  1139. case 88:
  1140. return "RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE";
  1141. case 89:
  1142. return "RIL_REQUEST_GSM_GET_BROADCAST_CONFIG";
  1143. case 90:
  1144. return "RIL_REQUEST_GSM_SET_BROADCAST_CONFIG";
  1145. case 92:
  1146. return "RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG";
  1147. case 93:
  1148. return "RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG";
  1149. case 91:
  1150. return "RIL_REQUEST_GSM_BROADCAST_ACTIVATION";
  1151. case 86:
  1152. return "RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY";
  1153. case 94:
  1154. return "RIL_REQUEST_CDMA_BROADCAST_ACTIVATION";
  1155. case 95:
  1156. return "RIL_REQUEST_CDMA_SUBSCRIPTION";
  1157. case 96:
  1158. return "RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM";
  1159. case 97:
  1160. return "RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM";
  1161. case 98:
  1162. return "RIL_REQUEST_DEVICE_IDENTITY";
  1163. case 100:
  1164. return "RIL_REQUEST_GET_SMSC_ADDRESS";
  1165. case 101:
  1166. return "RIL_REQUEST_SET_SMSC_ADDRESS";
  1167. case 99:
  1168. return "REQUEST_EXIT_EMERGENCY_CALLBACK_MODE";
  1169. case 102:
  1170. return "RIL_REQUEST_REPORT_SMS_MEMORY_STATUS";
  1171. case 103:
  1172. return "RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING";
  1173. case 104:
  1174. return "RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE";
  1175. case 105:
  1176. return "RIL_REQUEST_ISIM_AUTHENTICATION";
  1177. case 106:
  1178. return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU";
  1179. case 107:
  1180. return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS";
  1181. case 108:
  1182. return "RIL_REQUEST_VOICE_RADIO_TECH";
  1183. case 109:
  1184. return "RIL_REQUEST_GET_CELL_INFO_LIST";
  1185. case 110:
  1186. return "RIL_REQUEST_SET_CELL_INFO_LIST_RATE";
  1187. case 111:
  1188. return "RIL_REQUEST_SET_INITIAL_ATTACH_APN";
  1189. case 128:
  1190. return "RIL_REQUEST_SET_DATA_PROFILE";
  1191. case 112:
  1192. return "RIL_REQUEST_IMS_REGISTRATION_STATE";
  1193. case 113:
  1194. return "RIL_REQUEST_IMS_SEND_SMS";
  1195. case 114:
  1196. return "RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC";
  1197. case 115:
  1198. return "RIL_REQUEST_SIM_OPEN_CHANNEL";
  1199. case 116:
  1200. return "RIL_REQUEST_SIM_CLOSE_CHANNEL";
  1201. case 117:
  1202. return "RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL";
  1203. case 118:
  1204. return "RIL_REQUEST_NV_READ_ITEM";
  1205. case 119:
  1206. return "RIL_REQUEST_NV_WRITE_ITEM";
  1207. case 120:
  1208. return "RIL_REQUEST_NV_WRITE_CDMA_PRL";
  1209. case 121:
  1210. return "RIL_REQUEST_NV_RESET_CONFIG";
  1211. case 122:
  1212. return "RIL_REQUEST_SET_UICC_SUBSCRIPTION";
  1213. case 123:
  1214. return "RIL_REQUEST_ALLOW_DATA";
  1215. case 124:
  1216. return "GET_HARDWARE_CONFIG";
  1217. case 125:
  1218. return "RIL_REQUEST_SIM_AUTHENTICATION";
  1219. case 129:
  1220. return "RIL_REQUEST_SHUTDOWN";
  1221. case 131:
  1222. return "RIL_REQUEST_SET_RADIO_CAPABILITY";
  1223. case 130:
  1224. return "RIL_REQUEST_GET_RADIO_CAPABILITY";
  1225. case 132:
  1226. return "RIL_REQUEST_START_LCE";
  1227. case 133:
  1228. return "RIL_REQUEST_STOP_LCE";
  1229. case 134:
  1230. return "RIL_REQUEST_PULL_LCEDATA";
  1231. case 135:
  1232. return "RIL_REQUEST_GET_ACTIVITY_INFO";
  1233. case 136:
  1234. return "RIL_REQUEST_SET_ALLOWED_CARRIERS";
  1235. case 137:
  1236. return "RIL_REQUEST_GET_ALLOWED_CARRIERS";
  1237. case 140:
  1238. return "RIL_REQUEST_SET_SIM_CARD_POWER";
  1239. case 138:
  1240. return "RIL_REQUEST_SEND_DEVICE_STATE";
  1241. case 139:
  1242. return "RIL_REQUEST_SET_UNSOLICITED_RESPONSE_FILTER";
  1243. case 800:
  1244. return "RIL_RESPONSE_ACKNOWLEDGEMENT";
  1245. }
  1246. return "RIL_REQUEST_SIM_QUERY_ATR";
  1247. }
  1248.  
  1249. static String responseToString(int paramInt)
  1250. {
  1251. switch (paramInt)
  1252. {
  1253. case 1041:
  1254. default:
  1255. return "<unknown response>";
  1256. case 1000:
  1257. return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
  1258. case 1001:
  1259. return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
  1260. case 1002:
  1261. return "UNSOL_RESPONSE_NETWORK_STATE_CHANGED";
  1262. case 1003:
  1263. return "UNSOL_RESPONSE_NEW_SMS";
  1264. case 1004:
  1265. return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
  1266. case 1005:
  1267. return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
  1268. case 1006:
  1269. return "UNSOL_ON_USSD";
  1270. case 1007:
  1271. return "UNSOL_ON_USSD_REQUEST";
  1272. case 1008:
  1273. return "UNSOL_NITZ_TIME_RECEIVED";
  1274. case 1009:
  1275. return "UNSOL_SIGNAL_STRENGTH";
  1276. case 1010:
  1277. return "UNSOL_DATA_CALL_LIST_CHANGED";
  1278. case 1011:
  1279. return "UNSOL_SUPP_SVC_NOTIFICATION";
  1280. case 1012:
  1281. return "UNSOL_STK_SESSION_END";
  1282. case 1013:
  1283. return "UNSOL_STK_PROACTIVE_COMMAND";
  1284. case 1014:
  1285. return "UNSOL_STK_EVENT_NOTIFY";
  1286. case 1015:
  1287. return "UNSOL_STK_CALL_SETUP";
  1288. case 1016:
  1289. return "UNSOL_SIM_SMS_STORAGE_FULL";
  1290. case 1017:
  1291. return "UNSOL_SIM_REFRESH";
  1292. case 1018:
  1293. return "UNSOL_CALL_RING";
  1294. case 1019:
  1295. return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
  1296. case 1020:
  1297. return "UNSOL_RESPONSE_CDMA_NEW_SMS";
  1298. case 1021:
  1299. return "UNSOL_RESPONSE_NEW_BROADCAST_SMS";
  1300. case 1022:
  1301. return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL";
  1302. case 1023:
  1303. return "UNSOL_RESTRICTED_STATE_CHANGED";
  1304. case 1024:
  1305. return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE";
  1306. case 1025:
  1307. return "UNSOL_CDMA_CALL_WAITING";
  1308. case 1026:
  1309. return "UNSOL_CDMA_OTA_PROVISION_STATUS";
  1310. case 1027:
  1311. return "UNSOL_CDMA_INFO_REC";
  1312. case 1028:
  1313. return "UNSOL_OEM_HOOK_RAW";
  1314. case 1029:
  1315. return "UNSOL_RINGBACK_TONE";
  1316. case 1030:
  1317. return "UNSOL_RESEND_INCALL_MUTE";
  1318. case 1031:
  1319. return "CDMA_SUBSCRIPTION_SOURCE_CHANGED";
  1320. case 1032:
  1321. return "UNSOL_CDMA_PRL_CHANGED";
  1322. case 1033:
  1323. return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE";
  1324. case 1034:
  1325. return "UNSOL_RIL_CONNECTED";
  1326. case 1035:
  1327. return "UNSOL_VOICE_RADIO_TECH_CHANGED";
  1328. case 1036:
  1329. return "UNSOL_CELL_INFO_LIST";
  1330. case 1037:
  1331. return "UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED";
  1332. case 1038:
  1333. return "RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED";
  1334. case 1039:
  1335. return "UNSOL_SRVCC_STATE_NOTIFY";
  1336. case 1040:
  1337. return "RIL_UNSOL_HARDWARE_CONFIG_CHANGED";
  1338. case 1042:
  1339. return "RIL_UNSOL_RADIO_CAPABILITY";
  1340. case 1043:
  1341. return "UNSOL_ON_SS";
  1342. case 1044:
  1343. return "UNSOL_STK_CC_ALPHA_NOTIFY";
  1344. case 1045:
  1345. return "UNSOL_LCE_INFO_RECV";
  1346. case 1046:
  1347. return "UNSOL_PCO_DATA";
  1348. }
  1349. return "UNSOL_MODEM_RESTART";
  1350. }
  1351.  
  1352. static String retToString(int paramInt, Object paramObject)
  1353. {
  1354. if (paramObject == null) {
  1355. return "";
  1356. }
  1357. int i;
  1358. Object localObject1;
  1359. switch (paramInt)
  1360. {
  1361. default:
  1362. if (!(paramObject instanceof int[])) {
  1363. break label144;
  1364. }
  1365. paramObject = (int[])paramObject;
  1366. i = paramObject.length;
  1367. localObject1 = new StringBuilder("{");
  1368. if (i > 0)
  1369. {
  1370. ((StringBuilder)localObject1).append(paramObject[0]);
  1371. paramInt = 1;
  1372. }
  1373. break;
  1374. case 11:
  1375. case 38:
  1376. case 39:
  1377. case 115:
  1378. case 117:
  1379. while (paramInt < i)
  1380. {
  1381. ((StringBuilder)localObject1).append(", ").append(paramObject[paramInt]);
  1382. paramInt++;
  1383. continue;
  1384. return "";
  1385. }
  1386. }
  1387. ((StringBuilder)localObject1).append("}");
  1388. paramObject = ((StringBuilder)localObject1).toString();
  1389. for (;;)
  1390. {
  1391. return paramObject;
  1392. label144:
  1393. if ((paramObject instanceof String[]))
  1394. {
  1395. localObject1 = (String[])paramObject;
  1396. i = localObject1.length;
  1397. paramObject = new StringBuilder("{");
  1398. if (i > 0)
  1399. {
  1400. paramObject.append(localObject1[0]);
  1401. for (paramInt = 1; paramInt < i; paramInt++) {
  1402. paramObject.append(", ").append(localObject1[paramInt]);
  1403. }
  1404. }
  1405. paramObject.append("}");
  1406. paramObject = paramObject.toString();
  1407. }
  1408. else
  1409. {
  1410. Object localObject2;
  1411. if (paramInt == 9)
  1412. {
  1413. localObject1 = (ArrayList)paramObject;
  1414. paramObject = new StringBuilder("{");
  1415. localObject1 = ((Iterable)localObject1).iterator();
  1416. while (((Iterator)localObject1).hasNext())
  1417. {
  1418. localObject2 = (DriverCall)((Iterator)localObject1).next();
  1419. paramObject.append("[").append(localObject2).append("] ");
  1420. }
  1421. paramObject.append("}");
  1422. paramObject = paramObject.toString();
  1423. }
  1424. else if (paramInt == 75)
  1425. {
  1426. localObject1 = (ArrayList)paramObject;
  1427. paramObject = new StringBuilder("{");
  1428. localObject1 = ((Iterable)localObject1).iterator();
  1429. while (((Iterator)localObject1).hasNext())
  1430. {
  1431. localObject2 = (NeighboringCellInfo)((Iterator)localObject1).next();
  1432. paramObject.append("[").append(localObject2).append("] ");
  1433. }
  1434. paramObject.append("}");
  1435. paramObject = paramObject.toString();
  1436. }
  1437. else if (paramInt == 33)
  1438. {
  1439. localObject1 = (CallForwardInfo[])paramObject;
  1440. i = localObject1.length;
  1441. paramObject = new StringBuilder("{");
  1442. for (paramInt = 0; paramInt < i; paramInt++) {
  1443. paramObject.append("[").append(localObject1[paramInt]).append("] ");
  1444. }
  1445. paramObject.append("}");
  1446. paramObject = paramObject.toString();
  1447. }
  1448. else if (paramInt == 124)
  1449. {
  1450. localObject1 = (ArrayList)paramObject;
  1451. paramObject = new StringBuilder(" ");
  1452. localObject1 = ((Iterable)localObject1).iterator();
  1453. while (((Iterator)localObject1).hasNext())
  1454. {
  1455. localObject2 = (HardwareConfig)((Iterator)localObject1).next();
  1456. paramObject.append("[").append(localObject2).append("] ");
  1457. }
  1458. paramObject = paramObject.toString();
  1459. }
  1460. else
  1461. {
  1462. paramObject = paramObject.toString();
  1463. }
  1464. }
  1465. }
  1466. }
  1467.  
  1468. private void sendAck()
  1469. {
  1470. RILRequest localRILRequest = RILRequest.obtain(800, null, mRILDefaultWorkSource);
  1471. acquireWakeLock(localRILRequest, 1);
  1472. IRadio localIRadio = getRadioProxy(null);
  1473. if (localIRadio != null) {}
  1474. for (;;)
  1475. {
  1476. try
  1477. {
  1478. localIRadio.responseAcknowledgement();
  1479. localRILRequest.release();
  1480. return;
  1481. }
  1482. catch (RemoteException|RuntimeException localRemoteException)
  1483. {
  1484. handleRadioProxyExceptionForRR(localRILRequest, "sendAck", localRemoteException);
  1485. riljLoge("sendAck: " + localRemoteException);
  1486. continue;
  1487. }
  1488. Rlog.e("RILJ", "Error trying to send ack, radioProxy = null");
  1489. }
  1490. }
  1491.  
  1492. private int translateStatus(int paramInt)
  1493. {
  1494. switch (paramInt & 0x7)
  1495. {
  1496. case 2:
  1497. case 4:
  1498. case 6:
  1499. default:
  1500. return 1;
  1501. case 1:
  1502. return 1;
  1503. case 3:
  1504. return 0;
  1505. case 5:
  1506. return 3;
  1507. }
  1508. return 2;
  1509. }
  1510.  
  1511. public void acceptCall(Message paramMessage)
  1512. {
  1513. IRadio localIRadio = getRadioProxy(paramMessage);
  1514. if (localIRadio != null)
  1515. {
  1516. paramMessage = obtainRequest(40, paramMessage, mRILDefaultWorkSource);
  1517. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  1518. }
  1519. try
  1520. {
  1521. localIRadio.acceptCall(mSerial);
  1522. mMetrics.writeRilAnswer(mPhoneId.intValue(), mSerial);
  1523. return;
  1524. }
  1525. catch (RemoteException|RuntimeException localRemoteException)
  1526. {
  1527. for (;;)
  1528. {
  1529. handleRadioProxyExceptionForRR(paramMessage, "acceptCall", localRemoteException);
  1530. }
  1531. }
  1532. }
  1533.  
  1534. public void acknowledgeIncomingGsmSmsWithPdu(boolean paramBoolean, String paramString, Message paramMessage)
  1535. {
  1536. IRadio localIRadio = getRadioProxy(paramMessage);
  1537. if (localIRadio != null)
  1538. {
  1539. paramMessage = obtainRequest(106, paramMessage, mRILDefaultWorkSource);
  1540. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " success = " + paramBoolean);
  1541. }
  1542. try
  1543. {
  1544. localIRadio.acknowledgeIncomingGsmSmsWithPdu(mSerial, paramBoolean, convertNullToEmptyString(paramString));
  1545. return;
  1546. }
  1547. catch (RemoteException|RuntimeException paramString)
  1548. {
  1549. for (;;)
  1550. {
  1551. handleRadioProxyExceptionForRR(paramMessage, "acknowledgeIncomingGsmSmsWithPdu", paramString);
  1552. }
  1553. }
  1554. }
  1555.  
  1556. public void acknowledgeLastIncomingCdmaSms(boolean paramBoolean, int paramInt, Message paramMessage)
  1557. {
  1558. IRadio localIRadio = getRadioProxy(paramMessage);
  1559. CdmaSmsAck localCdmaSmsAck;
  1560. int i;
  1561. if (localIRadio != null)
  1562. {
  1563. paramMessage = obtainRequest(88, paramMessage, mRILDefaultWorkSource);
  1564. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " success = " + paramBoolean + " cause = " + paramInt);
  1565. localCdmaSmsAck = new CdmaSmsAck();
  1566. if (!paramBoolean) {
  1567. break label124;
  1568. }
  1569. i = 0;
  1570. }
  1571. for (;;)
  1572. {
  1573. errorClass = i;
  1574. smsCauseCode = paramInt;
  1575. try
  1576. {
  1577. localIRadio.acknowledgeLastIncomingCdmaSms(mSerial, localCdmaSmsAck);
  1578. return;
  1579. label124:
  1580. i = 1;
  1581. }
  1582. catch (RemoteException|RuntimeException localRemoteException)
  1583. {
  1584. for (;;)
  1585. {
  1586. handleRadioProxyExceptionForRR(paramMessage, "acknowledgeLastIncomingCdmaSms", localRemoteException);
  1587. }
  1588. }
  1589. }
  1590. }
  1591.  
  1592. public void acknowledgeLastIncomingGsmSms(boolean paramBoolean, int paramInt, Message paramMessage)
  1593. {
  1594. IRadio localIRadio = getRadioProxy(paramMessage);
  1595. if (localIRadio != null)
  1596. {
  1597. paramMessage = obtainRequest(37, paramMessage, mRILDefaultWorkSource);
  1598. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " success = " + paramBoolean + " cause = " + paramInt);
  1599. }
  1600. try
  1601. {
  1602. localIRadio.acknowledgeLastIncomingGsmSms(mSerial, paramBoolean, paramInt);
  1603. return;
  1604. }
  1605. catch (RemoteException|RuntimeException localRemoteException)
  1606. {
  1607. for (;;)
  1608. {
  1609. handleRadioProxyExceptionForRR(paramMessage, "acknowledgeLastIncomingGsmSms", localRemoteException);
  1610. }
  1611. }
  1612. }
  1613.  
  1614. public void cancelPendingUssd(Message paramMessage)
  1615. {
  1616. IRadio localIRadio = getRadioProxy(paramMessage);
  1617. if (localIRadio != null)
  1618. {
  1619. paramMessage = obtainRequest(30, paramMessage, mRILDefaultWorkSource);
  1620. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  1621. }
  1622. try
  1623. {
  1624. localIRadio.cancelPendingUssd(mSerial);
  1625. return;
  1626. }
  1627. catch (RemoteException|RuntimeException localRemoteException)
  1628. {
  1629. for (;;)
  1630. {
  1631. handleRadioProxyExceptionForRR(paramMessage, "cancelPendingUssd", localRemoteException);
  1632. }
  1633. }
  1634. }
  1635.  
  1636. public void changeBarringPassword(String paramString1, String paramString2, String paramString3, Message paramMessage)
  1637. {
  1638. IRadio localIRadio = getRadioProxy(paramMessage);
  1639. if (localIRadio != null)
  1640. {
  1641. paramMessage = obtainRequest(44, paramMessage, mRILDefaultWorkSource);
  1642. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + "facility = " + paramString1);
  1643. }
  1644. try
  1645. {
  1646. localIRadio.setBarringPassword(mSerial, convertNullToEmptyString(paramString1), convertNullToEmptyString(paramString2), convertNullToEmptyString(paramString3));
  1647. return;
  1648. }
  1649. catch (RemoteException|RuntimeException paramString1)
  1650. {
  1651. for (;;)
  1652. {
  1653. handleRadioProxyExceptionForRR(paramMessage, "changeBarringPassword", paramString1);
  1654. }
  1655. }
  1656. }
  1657.  
  1658. public void changeIccPin(String paramString1, String paramString2, Message paramMessage)
  1659. {
  1660. changeIccPinForApp(paramString1, paramString2, null, paramMessage);
  1661. }
  1662.  
  1663. public void changeIccPin2(String paramString1, String paramString2, Message paramMessage)
  1664. {
  1665. changeIccPin2ForApp(paramString1, paramString2, null, paramMessage);
  1666. }
  1667.  
  1668. public void changeIccPin2ForApp(String paramString1, String paramString2, String paramString3, Message paramMessage)
  1669. {
  1670. IRadio localIRadio = getRadioProxy(paramMessage);
  1671. if (localIRadio != null)
  1672. {
  1673. paramMessage = obtainRequest(7, paramMessage, mRILDefaultWorkSource);
  1674. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " oldPin = " + paramString1 + " newPin = " + paramString2 + " aid = " + paramString3);
  1675. }
  1676. try
  1677. {
  1678. localIRadio.changeIccPin2ForApp(mSerial, convertNullToEmptyString(paramString1), convertNullToEmptyString(paramString2), convertNullToEmptyString(paramString3));
  1679. return;
  1680. }
  1681. catch (RemoteException|RuntimeException paramString1)
  1682. {
  1683. for (;;)
  1684. {
  1685. handleRadioProxyExceptionForRR(paramMessage, "changeIccPin2ForApp", paramString1);
  1686. }
  1687. }
  1688. }
  1689.  
  1690. public void changeIccPinForApp(String paramString1, String paramString2, String paramString3, Message paramMessage)
  1691. {
  1692. IRadio localIRadio = getRadioProxy(paramMessage);
  1693. if (localIRadio != null)
  1694. {
  1695. paramMessage = obtainRequest(6, paramMessage, mRILDefaultWorkSource);
  1696. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " oldPin = " + paramString1 + " newPin = " + paramString2 + " aid = " + paramString3);
  1697. }
  1698. try
  1699. {
  1700. localIRadio.changeIccPinForApp(mSerial, convertNullToEmptyString(paramString1), convertNullToEmptyString(paramString2), convertNullToEmptyString(paramString3));
  1701. return;
  1702. }
  1703. catch (RemoteException|RuntimeException paramString1)
  1704. {
  1705. for (;;)
  1706. {
  1707. handleRadioProxyExceptionForRR(paramMessage, "changeIccPinForApp", paramString1);
  1708. }
  1709. }
  1710. }
  1711.  
  1712. public void conference(Message paramMessage)
  1713. {
  1714. IRadio localIRadio = getRadioProxy(paramMessage);
  1715. if (localIRadio != null)
  1716. {
  1717. paramMessage = obtainRequest(16, paramMessage, mRILDefaultWorkSource);
  1718. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  1719. }
  1720. try
  1721. {
  1722. localIRadio.conference(mSerial);
  1723. return;
  1724. }
  1725. catch (RemoteException|RuntimeException localRemoteException)
  1726. {
  1727. for (;;)
  1728. {
  1729. handleRadioProxyExceptionForRR(paramMessage, "conference", localRemoteException);
  1730. }
  1731. }
  1732. }
  1733.  
  1734. public void deactivateDataCall(int paramInt1, int paramInt2, Message paramMessage)
  1735. {
  1736. boolean bool = false;
  1737. IRadio localIRadio = getRadioProxy(paramMessage);
  1738. if (localIRadio != null)
  1739. {
  1740. paramMessage = obtainRequest(41, paramMessage, mRILDefaultWorkSource);
  1741. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " cid = " + paramInt1 + " reason = " + paramInt2);
  1742. }
  1743. for (;;)
  1744. {
  1745. try
  1746. {
  1747. int i = mSerial;
  1748. if (paramInt2 == 0)
  1749. {
  1750. localIRadio.deactivateDataCall(i, paramInt1, bool);
  1751. mMetrics.writeRilDeactivateDataCall(mPhoneId.intValue(), mSerial, paramInt1, paramInt2);
  1752. return;
  1753. }
  1754. }
  1755. catch (RemoteException|RuntimeException localRemoteException)
  1756. {
  1757. handleRadioProxyExceptionForRR(paramMessage, "deactivateDataCall", localRemoteException);
  1758. continue;
  1759. }
  1760. bool = true;
  1761. }
  1762. }
  1763.  
  1764. public void deleteSmsOnRuim(int paramInt, Message paramMessage)
  1765. {
  1766. IRadio localIRadio = getRadioProxy(paramMessage);
  1767. if (localIRadio != null) {
  1768. paramMessage = obtainRequest(97, paramMessage, mRILDefaultWorkSource);
  1769. }
  1770. try
  1771. {
  1772. localIRadio.deleteSmsOnRuim(mSerial, paramInt);
  1773. return;
  1774. }
  1775. catch (RemoteException|RuntimeException localRemoteException)
  1776. {
  1777. for (;;)
  1778. {
  1779. handleRadioProxyExceptionForRR(paramMessage, "deleteSmsOnRuim", localRemoteException);
  1780. }
  1781. }
  1782. }
  1783.  
  1784. public void deleteSmsOnSim(int paramInt, Message paramMessage)
  1785. {
  1786. IRadio localIRadio = getRadioProxy(paramMessage);
  1787. if (localIRadio != null) {
  1788. paramMessage = obtainRequest(64, paramMessage, mRILDefaultWorkSource);
  1789. }
  1790. try
  1791. {
  1792. localIRadio.deleteSmsOnSim(mSerial, paramInt);
  1793. return;
  1794. }
  1795. catch (RemoteException|RuntimeException localRemoteException)
  1796. {
  1797. for (;;)
  1798. {
  1799. handleRadioProxyExceptionForRR(paramMessage, "deleteSmsOnSim", localRemoteException);
  1800. }
  1801. }
  1802. }
  1803.  
  1804. public void dial(String paramString, int paramInt, Message paramMessage)
  1805. {
  1806. dial(paramString, paramInt, null, paramMessage);
  1807. }
  1808.  
  1809. public void dial(String paramString, int paramInt, UUSInfo paramUUSInfo, Message paramMessage)
  1810. {
  1811. IRadio localIRadio = getRadioProxy(paramMessage);
  1812. Dial localDial;
  1813. if (localIRadio != null)
  1814. {
  1815. paramMessage = obtainRequest(10, paramMessage, mRILDefaultWorkSource);
  1816. localDial = new Dial();
  1817. address = convertNullToEmptyString(paramString);
  1818. clir = paramInt;
  1819. if (paramUUSInfo != null)
  1820. {
  1821. paramString = new UusInfo();
  1822. uusType = paramUUSInfo.getType();
  1823. uusDcs = paramUUSInfo.getDcs();
  1824. uusData = new String(paramUUSInfo.getUserData());
  1825. uusInfo.add(paramString);
  1826. }
  1827. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  1828. }
  1829. try
  1830. {
  1831. localIRadio.dial(mSerial, localDial);
  1832. return;
  1833. }
  1834. catch (RemoteException|RuntimeException paramString)
  1835. {
  1836. for (;;)
  1837. {
  1838. handleRadioProxyExceptionForRR(paramMessage, "dial", paramString);
  1839. }
  1840. }
  1841. }
  1842.  
  1843. /* Error */
  1844. public void dump(java.io.FileDescriptor paramFileDescriptor, java.io.PrintWriter paramPrintWriter, String[] arg3)
  1845. {
  1846. // Byte code:
  1847. // 0: aload_2
  1848. // 1: new 196 java/lang/StringBuilder
  1849. // 4: dup
  1850. // 5: invokespecial 197 java/lang/StringBuilder:<init> ()V
  1851. // 8: ldc_w 1829
  1852. // 11: invokevirtual 203 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
  1853. // 14: aload_0
  1854. // 15: invokevirtual 581 java/lang/StringBuilder:append (Ljava/lang/Object;)Ljava/lang/StringBuilder;
  1855. // 18: invokevirtual 214 java/lang/StringBuilder:toString ()Ljava/lang/String;
  1856. // 21: invokevirtual 1834 java/io/PrintWriter:println (Ljava/lang/String;)V
  1857. // 24: aload_2
  1858. // 25: new 196 java/lang/StringBuilder
  1859. // 28: dup
  1860. // 29: invokespecial 197 java/lang/StringBuilder:<init> ()V
  1861. // 32: ldc_w 1836
  1862. // 35: invokevirtual 203 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
  1863. // 38: aload_0
  1864. // 39: getfield 286 com/android/internal/telephony/RIL:mWakeLock Landroid/os/PowerManager$WakeLock;
  1865. // 42: invokevirtual 581 java/lang/StringBuilder:append (Ljava/lang/Object;)Ljava/lang/StringBuilder;
  1866. // 45: invokevirtual 214 java/lang/StringBuilder:toString ()Ljava/lang/String;
  1867. // 48: invokevirtual 1834 java/io/PrintWriter:println (Ljava/lang/String;)V
  1868. // 51: aload_2
  1869. // 52: new 196 java/lang/StringBuilder
  1870. // 55: dup
  1871. // 56: invokespecial 197 java/lang/StringBuilder:<init> ()V
  1872. // 59: ldc_w 1838
  1873. // 62: invokevirtual 203 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
  1874. // 65: aload_0
  1875. // 66: getfield 303 com/android/internal/telephony/RIL:mWakeLockTimeout I
  1876. // 69: invokevirtual 206 java/lang/StringBuilder:append (I)Ljava/lang/StringBuilder;
  1877. // 72: invokevirtual 214 java/lang/StringBuilder:toString ()Ljava/lang/String;
  1878. // 75: invokevirtual 1834 java/io/PrintWriter:println (Ljava/lang/String;)V
  1879. // 78: aload_0
  1880. // 79: getfield 170 com/android/internal/telephony/RIL:mRequestList Landroid/util/SparseArray;
  1881. // 82: astore_1
  1882. // 83: aload_1
  1883. // 84: monitorenter
  1884. // 85: aload_0
  1885. // 86: getfield 286 com/android/internal/telephony/RIL:mWakeLock Landroid/os/PowerManager$WakeLock;
  1886. // 89: astore_3
  1887. // 90: aload_3
  1888. // 91: monitorenter
  1889. // 92: new 196 java/lang/StringBuilder
  1890. // 95: astore 4
  1891. // 97: aload 4
  1892. // 99: invokespecial 197 java/lang/StringBuilder:<init> ()V
  1893. // 102: aload_2
  1894. // 103: aload 4
  1895. // 105: ldc_w 1840
  1896. // 108: invokevirtual 203 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
  1897. // 111: aload_0
  1898. // 112: getfield 307 com/android/internal/telephony/RIL:mWakeLockCount I
  1899. // 115: invokevirtual 206 java/lang/StringBuilder:append (I)Ljava/lang/StringBuilder;
  1900. // 118: invokevirtual 214 java/lang/StringBuilder:toString ()Ljava/lang/String;
  1901. // 121: invokevirtual 1834 java/io/PrintWriter:println (Ljava/lang/String;)V
  1902. // 124: aload_3
  1903. // 125: monitorexit
  1904. // 126: aload_0
  1905. // 127: getfield 170 com/android/internal/telephony/RIL:mRequestList Landroid/util/SparseArray;
  1906. // 130: invokevirtual 461 android/util/SparseArray:size ()I
  1907. // 133: istore 5
  1908. // 135: new 196 java/lang/StringBuilder
  1909. // 138: astore_3
  1910. // 139: aload_3
  1911. // 140: invokespecial 197 java/lang/StringBuilder:<init> ()V
  1912. // 143: aload_2
  1913. // 144: aload_3
  1914. // 145: ldc_w 1842
  1915. // 148: invokevirtual 203 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
  1916. // 151: iload 5
  1917. // 153: invokevirtual 206 java/lang/StringBuilder:append (I)Ljava/lang/StringBuilder;
  1918. // 156: invokevirtual 214 java/lang/StringBuilder:toString ()Ljava/lang/String;
  1919. // 159: invokevirtual 1834 java/io/PrintWriter:println (Ljava/lang/String;)V
  1920. // 162: iconst_0
  1921. // 163: istore 6
  1922. // 165: iload 6
  1923. // 167: iload 5
  1924. // 169: if_icmpge +80 -> 249
  1925. // 172: aload_0
  1926. // 173: getfield 170 com/android/internal/telephony/RIL:mRequestList Landroid/util/SparseArray;
  1927. // 176: iload 6
  1928. // 178: invokevirtual 468 android/util/SparseArray:valueAt (I)Ljava/lang/Object;
  1929. // 181: checkcast 339 com/android/internal/telephony/RILRequest
  1930. // 184: astore 4
  1931. // 186: new 196 java/lang/StringBuilder
  1932. // 189: astore_3
  1933. // 190: aload_3
  1934. // 191: invokespecial 197 java/lang/StringBuilder:<init> ()V
  1935. // 194: aload_2
  1936. // 195: aload_3
  1937. // 196: ldc_w 1844
  1938. // 199: invokevirtual 203 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
  1939. // 202: aload 4
  1940. // 204: getfield 391 com/android/internal/telephony/RILRequest:mSerial I
  1941. // 207: invokevirtual 206 java/lang/StringBuilder:append (I)Ljava/lang/StringBuilder;
  1942. // 210: ldc_w 472
  1943. // 213: invokevirtual 203 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
  1944. // 216: aload 4
  1945. // 218: getfield 388 com/android/internal/telephony/RILRequest:mRequest I
  1946. // 221: invokestatic 476 com/android/internal/telephony/RIL:requestToString (I)Ljava/lang/String;
  1947. // 224: invokevirtual 203 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
  1948. // 227: invokevirtual 214 java/lang/StringBuilder:toString ()Ljava/lang/String;
  1949. // 230: invokevirtual 1834 java/io/PrintWriter:println (Ljava/lang/String;)V
  1950. // 233: iinc 6 1
  1951. // 236: goto -71 -> 165
  1952. // 239: astore_2
  1953. // 240: aload_3
  1954. // 241: monitorexit
  1955. // 242: aload_2
  1956. // 243: athrow
  1957. // 244: astore_2
  1958. // 245: aload_1
  1959. // 246: monitorexit
  1960. // 247: aload_2
  1961. // 248: athrow
  1962. // 249: aload_1
  1963. // 250: monitorexit
  1964. // 251: aload_2
  1965. // 252: new 196 java/lang/StringBuilder
  1966. // 255: dup
  1967. // 256: invokespecial 197 java/lang/StringBuilder:<init> ()V
  1968. // 259: ldc_w 1846
  1969. // 262: invokevirtual 203 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
  1970. // 265: aload_0
  1971. // 266: getfield 1848 com/android/internal/telephony/RIL:mLastNITZTimeInfo [Ljava/lang/Object;
  1972. // 269: invokestatic 1853 java/util/Arrays:toString ([Ljava/lang/Object;)Ljava/lang/String;
  1973. // 272: invokevirtual 203 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
  1974. // 275: invokevirtual 214 java/lang/StringBuilder:toString ()Ljava/lang/String;
  1975. // 278: invokevirtual 1834 java/io/PrintWriter:println (Ljava/lang/String;)V
  1976. // 281: aload_2
  1977. // 282: new 196 java/lang/StringBuilder
  1978. // 285: dup
  1979. // 286: invokespecial 197 java/lang/StringBuilder:<init> ()V
  1980. // 289: ldc_w 1855
  1981. // 292: invokevirtual 203 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
  1982. // 295: aload_0
  1983. // 296: getfield 177 com/android/internal/telephony/RIL:mTestingEmergencyCall Ljava/util/concurrent/atomic/AtomicBoolean;
  1984. // 299: invokevirtual 1857 java/util/concurrent/atomic/AtomicBoolean:get ()Z
  1985. // 302: invokevirtual 1693 java/lang/StringBuilder:append (Z)Ljava/lang/StringBuilder;
  1986. // 305: invokevirtual 214 java/lang/StringBuilder:toString ()Ljava/lang/String;
  1987. // 308: invokevirtual 1834 java/io/PrintWriter:println (Ljava/lang/String;)V
  1988. // 311: aload_0
  1989. // 312: getfield 164 com/android/internal/telephony/RIL:mClientWakelockTracker Lcom/android/internal/telephony/ClientWakelockTracker;
  1990. // 315: invokevirtual 1860 com/android/internal/telephony/ClientWakelockTracker:dumpClientRequestTracker ()V
  1991. // 318: return
  1992. // Local variable table:
  1993. // start length slot name signature
  1994. // 0 319 0 this RIL
  1995. // 0 319 1 paramFileDescriptor java.io.FileDescriptor
  1996. // 0 319 2 paramPrintWriter java.io.PrintWriter
  1997. // 95 122 4 localObject Object
  1998. // 133 37 5 i int
  1999. // 163 71 6 j int
  2000. // Exception table:
  2001. // from to target type
  2002. // 92 124 239 finally
  2003. // 85 92 244 finally
  2004. // 124 162 244 finally
  2005. // 172 233 244 finally
  2006. // 240 244 244 finally
  2007. }
  2008.  
  2009. public void exitEmergencyCallbackMode(Message paramMessage)
  2010. {
  2011. IRadio localIRadio = getRadioProxy(paramMessage);
  2012. if (localIRadio != null)
  2013. {
  2014. paramMessage = obtainRequest(99, paramMessage, mRILDefaultWorkSource);
  2015. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2016. }
  2017. try
  2018. {
  2019. localIRadio.exitEmergencyCallbackMode(mSerial);
  2020. return;
  2021. }
  2022. catch (RemoteException|RuntimeException localRemoteException)
  2023. {
  2024. for (;;)
  2025. {
  2026. handleRadioProxyExceptionForRR(paramMessage, "exitEmergencyCallbackMode", localRemoteException);
  2027. }
  2028. }
  2029. }
  2030.  
  2031. public void explicitCallTransfer(Message paramMessage)
  2032. {
  2033. IRadio localIRadio = getRadioProxy(paramMessage);
  2034. if (localIRadio != null)
  2035. {
  2036. paramMessage = obtainRequest(72, paramMessage, mRILDefaultWorkSource);
  2037. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2038. }
  2039. try
  2040. {
  2041. localIRadio.explicitCallTransfer(mSerial);
  2042. return;
  2043. }
  2044. catch (RemoteException|RuntimeException localRemoteException)
  2045. {
  2046. for (;;)
  2047. {
  2048. handleRadioProxyExceptionForRR(paramMessage, "explicitCallTransfer", localRemoteException);
  2049. }
  2050. }
  2051. }
  2052.  
  2053. public void getAllowedCarriers(Message paramMessage)
  2054. {
  2055. IRadio localIRadio = getRadioProxy(paramMessage);
  2056. if (localIRadio != null)
  2057. {
  2058. paramMessage = obtainRequest(137, paramMessage, mRILDefaultWorkSource);
  2059. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2060. }
  2061. try
  2062. {
  2063. localIRadio.getAllowedCarriers(mSerial);
  2064. return;
  2065. }
  2066. catch (RemoteException|RuntimeException localRemoteException)
  2067. {
  2068. for (;;)
  2069. {
  2070. handleRadioProxyExceptionForRR(paramMessage, "getAllowedCarriers", localRemoteException);
  2071. }
  2072. }
  2073. }
  2074.  
  2075. public void getAtr(Message paramMessage) {}
  2076.  
  2077. public void getAvailableNetworks(Message paramMessage)
  2078. {
  2079. IRadio localIRadio = getRadioProxy(paramMessage);
  2080. if (localIRadio != null)
  2081. {
  2082. paramMessage = obtainRequest(48, paramMessage, mRILDefaultWorkSource);
  2083. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2084. }
  2085. try
  2086. {
  2087. localIRadio.getAvailableNetworks(mSerial);
  2088. return;
  2089. }
  2090. catch (RemoteException|RuntimeException localRemoteException)
  2091. {
  2092. for (;;)
  2093. {
  2094. handleRadioProxyExceptionForRR(paramMessage, "getAvailableNetworks", localRemoteException);
  2095. }
  2096. }
  2097. }
  2098.  
  2099. public void getBasebandVersion(Message paramMessage)
  2100. {
  2101. IRadio localIRadio = getRadioProxy(paramMessage);
  2102. if (localIRadio != null)
  2103. {
  2104. paramMessage = obtainRequest(51, paramMessage, mRILDefaultWorkSource);
  2105. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2106. }
  2107. try
  2108. {
  2109. localIRadio.getBasebandVersion(mSerial);
  2110. return;
  2111. }
  2112. catch (RemoteException|RuntimeException localRemoteException)
  2113. {
  2114. for (;;)
  2115. {
  2116. handleRadioProxyExceptionForRR(paramMessage, "getBasebandVersion", localRemoteException);
  2117. }
  2118. }
  2119. }
  2120.  
  2121. public void getCDMASubscription(Message paramMessage)
  2122. {
  2123. IRadio localIRadio = getRadioProxy(paramMessage);
  2124. if (localIRadio != null)
  2125. {
  2126. paramMessage = obtainRequest(95, paramMessage, mRILDefaultWorkSource);
  2127. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2128. }
  2129. try
  2130. {
  2131. localIRadio.getCDMASubscription(mSerial);
  2132. return;
  2133. }
  2134. catch (RemoteException|RuntimeException localRemoteException)
  2135. {
  2136. for (;;)
  2137. {
  2138. handleRadioProxyExceptionForRR(paramMessage, "getCDMASubscription", localRemoteException);
  2139. }
  2140. }
  2141. }
  2142.  
  2143. public void getCLIR(Message paramMessage)
  2144. {
  2145. IRadio localIRadio = getRadioProxy(paramMessage);
  2146. if (localIRadio != null)
  2147. {
  2148. paramMessage = obtainRequest(31, paramMessage, mRILDefaultWorkSource);
  2149. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2150. }
  2151. try
  2152. {
  2153. localIRadio.getClir(mSerial);
  2154. return;
  2155. }
  2156. catch (RemoteException|RuntimeException localRemoteException)
  2157. {
  2158. for (;;)
  2159. {
  2160. handleRadioProxyExceptionForRR(paramMessage, "getCLIR", localRemoteException);
  2161. }
  2162. }
  2163. }
  2164.  
  2165. public void getCdmaBroadcastConfig(Message paramMessage)
  2166. {
  2167. IRadio localIRadio = getRadioProxy(paramMessage);
  2168. if (localIRadio != null)
  2169. {
  2170. paramMessage = obtainRequest(92, paramMessage, mRILDefaultWorkSource);
  2171. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2172. }
  2173. try
  2174. {
  2175. localIRadio.getCdmaBroadcastConfig(mSerial);
  2176. return;
  2177. }
  2178. catch (RemoteException|RuntimeException localRemoteException)
  2179. {
  2180. for (;;)
  2181. {
  2182. handleRadioProxyExceptionForRR(paramMessage, "getCdmaBroadcastConfig", localRemoteException);
  2183. }
  2184. }
  2185. }
  2186.  
  2187. public void getCdmaSubscriptionSource(Message paramMessage)
  2188. {
  2189. IRadio localIRadio = getRadioProxy(paramMessage);
  2190. if (localIRadio != null)
  2191. {
  2192. paramMessage = obtainRequest(104, paramMessage, mRILDefaultWorkSource);
  2193. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2194. }
  2195. try
  2196. {
  2197. localIRadio.getCdmaSubscriptionSource(mSerial);
  2198. return;
  2199. }
  2200. catch (RemoteException|RuntimeException localRemoteException)
  2201. {
  2202. for (;;)
  2203. {
  2204. handleRadioProxyExceptionForRR(paramMessage, "getCdmaSubscriptionSource", localRemoteException);
  2205. }
  2206. }
  2207. }
  2208.  
  2209. public void getCellInfoList(Message paramMessage, WorkSource paramWorkSource)
  2210. {
  2211. WorkSource localWorkSource = getDeafultWorkSourceIfInvalid(paramWorkSource);
  2212. paramWorkSource = getRadioProxy(paramMessage);
  2213. if (paramWorkSource != null)
  2214. {
  2215. paramMessage = obtainRequest(109, paramMessage, localWorkSource);
  2216. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2217. }
  2218. try
  2219. {
  2220. paramWorkSource.getCellInfoList(mSerial);
  2221. return;
  2222. }
  2223. catch (RemoteException|RuntimeException paramWorkSource)
  2224. {
  2225. for (;;)
  2226. {
  2227. handleRadioProxyExceptionForRR(paramMessage, "getCellInfoList", paramWorkSource);
  2228. }
  2229. }
  2230. }
  2231.  
  2232. public List<ClientRequestStats> getClientRequestStats()
  2233. {
  2234. return mClientWakelockTracker.getClientRequestStats();
  2235. }
  2236.  
  2237. public void getCurrentCalls(Message paramMessage)
  2238. {
  2239. IRadio localIRadio = getRadioProxy(paramMessage);
  2240. if (localIRadio != null)
  2241. {
  2242. paramMessage = obtainRequest(9, paramMessage, mRILDefaultWorkSource);
  2243. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2244. }
  2245. try
  2246. {
  2247. localIRadio.getCurrentCalls(mSerial);
  2248. return;
  2249. }
  2250. catch (RemoteException|RuntimeException localRemoteException)
  2251. {
  2252. for (;;)
  2253. {
  2254. handleRadioProxyExceptionForRR(paramMessage, "getCurrentCalls", localRemoteException);
  2255. }
  2256. }
  2257. }
  2258.  
  2259. public void getDataCallList(Message paramMessage)
  2260. {
  2261. IRadio localIRadio = getRadioProxy(paramMessage);
  2262. if (localIRadio != null)
  2263. {
  2264. paramMessage = obtainRequest(57, paramMessage, mRILDefaultWorkSource);
  2265. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2266. }
  2267. try
  2268. {
  2269. localIRadio.getDataCallList(mSerial);
  2270. return;
  2271. }
  2272. catch (RemoteException|RuntimeException localRemoteException)
  2273. {
  2274. for (;;)
  2275. {
  2276. handleRadioProxyExceptionForRR(paramMessage, "getDataCallList", localRemoteException);
  2277. }
  2278. }
  2279. }
  2280.  
  2281. public void getDataRegistrationState(Message paramMessage)
  2282. {
  2283. IRadio localIRadio = getRadioProxy(paramMessage);
  2284. if (localIRadio != null)
  2285. {
  2286. paramMessage = obtainRequest(21, paramMessage, mRILDefaultWorkSource);
  2287. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2288. }
  2289. try
  2290. {
  2291. localIRadio.getDataRegistrationState(mSerial);
  2292. return;
  2293. }
  2294. catch (RemoteException|RuntimeException localRemoteException)
  2295. {
  2296. for (;;)
  2297. {
  2298. handleRadioProxyExceptionForRR(paramMessage, "getDataRegistrationState", localRemoteException);
  2299. }
  2300. }
  2301. }
  2302.  
  2303. public void getDeviceIdentity(Message paramMessage)
  2304. {
  2305. IRadio localIRadio = getRadioProxy(paramMessage);
  2306. if (localIRadio != null)
  2307. {
  2308. paramMessage = obtainRequest(98, paramMessage, mRILDefaultWorkSource);
  2309. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2310. }
  2311. try
  2312. {
  2313. localIRadio.getDeviceIdentity(mSerial);
  2314. return;
  2315. }
  2316. catch (RemoteException|RuntimeException localRemoteException)
  2317. {
  2318. for (;;)
  2319. {
  2320. handleRadioProxyExceptionForRR(paramMessage, "getDeviceIdentity", localRemoteException);
  2321. }
  2322. }
  2323. }
  2324.  
  2325. public void getGsmBroadcastConfig(Message paramMessage)
  2326. {
  2327. IRadio localIRadio = getRadioProxy(paramMessage);
  2328. if (localIRadio != null)
  2329. {
  2330. paramMessage = obtainRequest(89, paramMessage, mRILDefaultWorkSource);
  2331. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2332. }
  2333. try
  2334. {
  2335. localIRadio.getGsmBroadcastConfig(mSerial);
  2336. return;
  2337. }
  2338. catch (RemoteException|RuntimeException localRemoteException)
  2339. {
  2340. for (;;)
  2341. {
  2342. handleRadioProxyExceptionForRR(paramMessage, "getGsmBroadcastConfig", localRemoteException);
  2343. }
  2344. }
  2345. }
  2346.  
  2347. public void getHardwareConfig(Message paramMessage)
  2348. {
  2349. IRadio localIRadio = getRadioProxy(paramMessage);
  2350. if (localIRadio != null)
  2351. {
  2352. paramMessage = obtainRequest(124, paramMessage, mRILDefaultWorkSource);
  2353. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2354. }
  2355. try
  2356. {
  2357. localIRadio.getHardwareConfig(mSerial);
  2358. return;
  2359. }
  2360. catch (RemoteException|RuntimeException localRemoteException)
  2361. {
  2362. for (;;)
  2363. {
  2364. handleRadioProxyExceptionForRR(paramMessage, "getHardwareConfig", localRemoteException);
  2365. }
  2366. }
  2367. }
  2368.  
  2369. public void getIMEI(Message paramMessage)
  2370. {
  2371. throw new RuntimeException("getIMEI not expected to be called");
  2372. }
  2373.  
  2374. public void getIMEISV(Message paramMessage)
  2375. {
  2376. throw new RuntimeException("getIMEISV not expected to be called");
  2377. }
  2378.  
  2379. public void getIMSI(Message paramMessage)
  2380. {
  2381. getIMSIForApp(null, paramMessage);
  2382. }
  2383.  
  2384. public void getIMSIForApp(String paramString, Message paramMessage)
  2385. {
  2386. IRadio localIRadio = getRadioProxy(paramMessage);
  2387. if (localIRadio != null)
  2388. {
  2389. paramMessage = obtainRequest(11, paramMessage, mRILDefaultWorkSource);
  2390. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " aid = " + paramString);
  2391. }
  2392. try
  2393. {
  2394. localIRadio.getImsiForApp(mSerial, convertNullToEmptyString(paramString));
  2395. return;
  2396. }
  2397. catch (RemoteException|RuntimeException paramString)
  2398. {
  2399. for (;;)
  2400. {
  2401. handleRadioProxyExceptionForRR(paramMessage, "getIMSIForApp", paramString);
  2402. }
  2403. }
  2404. }
  2405.  
  2406. public void getIccCardStatus(Message paramMessage)
  2407. {
  2408. IRadio localIRadio = getRadioProxy(paramMessage);
  2409. if (localIRadio != null)
  2410. {
  2411. paramMessage = obtainRequest(1, paramMessage, mRILDefaultWorkSource);
  2412. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2413. }
  2414. try
  2415. {
  2416. localIRadio.getIccCardStatus(mSerial);
  2417. return;
  2418. }
  2419. catch (RemoteException|RuntimeException localRemoteException)
  2420. {
  2421. for (;;)
  2422. {
  2423. handleRadioProxyExceptionForRR(paramMessage, "getIccCardStatus", localRemoteException);
  2424. }
  2425. }
  2426. }
  2427.  
  2428. public void getImsRegistrationState(Message paramMessage)
  2429. {
  2430. IRadio localIRadio = getRadioProxy(paramMessage);
  2431. if (localIRadio != null)
  2432. {
  2433. paramMessage = obtainRequest(112, paramMessage, mRILDefaultWorkSource);
  2434. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2435. }
  2436. try
  2437. {
  2438. localIRadio.getImsRegistrationState(mSerial);
  2439. return;
  2440. }
  2441. catch (RemoteException|RuntimeException localRemoteException)
  2442. {
  2443. for (;;)
  2444. {
  2445. handleRadioProxyExceptionForRR(paramMessage, "getImsRegistrationState", localRemoteException);
  2446. }
  2447. }
  2448. }
  2449.  
  2450. public void getLastCallFailCause(Message paramMessage)
  2451. {
  2452. IRadio localIRadio = getRadioProxy(paramMessage);
  2453. if (localIRadio != null)
  2454. {
  2455. paramMessage = obtainRequest(18, paramMessage, mRILDefaultWorkSource);
  2456. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2457. }
  2458. try
  2459. {
  2460. localIRadio.getLastCallFailCause(mSerial);
  2461. return;
  2462. }
  2463. catch (RemoteException|RuntimeException localRemoteException)
  2464. {
  2465. for (;;)
  2466. {
  2467. handleRadioProxyExceptionForRR(paramMessage, "getLastCallFailCause", localRemoteException);
  2468. }
  2469. }
  2470. }
  2471.  
  2472. public void getLastDataCallFailCause(Message paramMessage)
  2473. {
  2474. throw new RuntimeException("getLastDataCallFailCause not expected to be called");
  2475. }
  2476.  
  2477. @Deprecated
  2478. public void getLastPdpFailCause(Message paramMessage)
  2479. {
  2480. throw new RuntimeException("getLastPdpFailCause not expected to be called");
  2481. }
  2482.  
  2483. protected Message getMessageFromRequest(Object paramObject)
  2484. {
  2485. RILRequest localRILRequest = (RILRequest)paramObject;
  2486. paramObject = null;
  2487. if (localRILRequest != null) {
  2488. paramObject = mResult;
  2489. }
  2490. return paramObject;
  2491. }
  2492.  
  2493. public void getModemActivityInfo(Message paramMessage)
  2494. {
  2495. Object localObject = getRadioProxy(paramMessage);
  2496. if (localObject != null)
  2497. {
  2498. paramMessage = obtainRequest(135, paramMessage, mRILDefaultWorkSource);
  2499. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2500. }
  2501. try
  2502. {
  2503. ((IRadio)localObject).getModemActivityInfo(mSerial);
  2504. localObject = mRilHandler.obtainMessage(5);
  2505. obj = null;
  2506. arg1 = mSerial;
  2507. mRilHandler.sendMessageDelayed((Message)localObject, 2000L);
  2508. return;
  2509. }
  2510. catch (RemoteException|RuntimeException localRemoteException)
  2511. {
  2512. for (;;)
  2513. {
  2514. handleRadioProxyExceptionForRR(paramMessage, "getModemActivityInfo", localRemoteException);
  2515. }
  2516. }
  2517. }
  2518.  
  2519. public void getMute(Message paramMessage)
  2520. {
  2521. IRadio localIRadio = getRadioProxy(paramMessage);
  2522. if (localIRadio != null)
  2523. {
  2524. paramMessage = obtainRequest(54, paramMessage, mRILDefaultWorkSource);
  2525. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2526. }
  2527. try
  2528. {
  2529. localIRadio.getMute(mSerial);
  2530. return;
  2531. }
  2532. catch (RemoteException|RuntimeException localRemoteException)
  2533. {
  2534. for (;;)
  2535. {
  2536. handleRadioProxyExceptionForRR(paramMessage, "getMute", localRemoteException);
  2537. }
  2538. }
  2539. }
  2540.  
  2541. public void getNeighboringCids(Message paramMessage, WorkSource paramWorkSource)
  2542. {
  2543. WorkSource localWorkSource = getDeafultWorkSourceIfInvalid(paramWorkSource);
  2544. paramWorkSource = getRadioProxy(paramMessage);
  2545. if (paramWorkSource != null)
  2546. {
  2547. paramMessage = obtainRequest(75, paramMessage, localWorkSource);
  2548. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2549. }
  2550. try
  2551. {
  2552. paramWorkSource.getNeighboringCids(mSerial);
  2553. return;
  2554. }
  2555. catch (RemoteException|RuntimeException paramWorkSource)
  2556. {
  2557. for (;;)
  2558. {
  2559. handleRadioProxyExceptionForRR(paramMessage, "getNeighboringCids", paramWorkSource);
  2560. }
  2561. }
  2562. }
  2563.  
  2564. public void getNetworkSelectionMode(Message paramMessage)
  2565. {
  2566. IRadio localIRadio = getRadioProxy(paramMessage);
  2567. if (localIRadio != null)
  2568. {
  2569. paramMessage = obtainRequest(45, paramMessage, mRILDefaultWorkSource);
  2570. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2571. }
  2572. try
  2573. {
  2574. localIRadio.getNetworkSelectionMode(mSerial);
  2575. return;
  2576. }
  2577. catch (RemoteException|RuntimeException localRemoteException)
  2578. {
  2579. for (;;)
  2580. {
  2581. handleRadioProxyExceptionForRR(paramMessage, "getNetworkSelectionMode", localRemoteException);
  2582. }
  2583. }
  2584. }
  2585.  
  2586. public void getOperator(Message paramMessage)
  2587. {
  2588. IRadio localIRadio = getRadioProxy(paramMessage);
  2589. if (localIRadio != null)
  2590. {
  2591. paramMessage = obtainRequest(22, paramMessage, mRILDefaultWorkSource);
  2592. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2593. }
  2594. try
  2595. {
  2596. localIRadio.getOperator(mSerial);
  2597. return;
  2598. }
  2599. catch (RemoteException|RuntimeException localRemoteException)
  2600. {
  2601. for (;;)
  2602. {
  2603. handleRadioProxyExceptionForRR(paramMessage, "getOperator", localRemoteException);
  2604. }
  2605. }
  2606. }
  2607.  
  2608. @Deprecated
  2609. public void getPDPContextList(Message paramMessage)
  2610. {
  2611. getDataCallList(paramMessage);
  2612. }
  2613.  
  2614. public void getPreferredNetworkType(Message paramMessage)
  2615. {
  2616. IRadio localIRadio = getRadioProxy(paramMessage);
  2617. if (localIRadio != null)
  2618. {
  2619. paramMessage = obtainRequest(74, paramMessage, mRILDefaultWorkSource);
  2620. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2621. }
  2622. try
  2623. {
  2624. localIRadio.getPreferredNetworkType(mSerial);
  2625. return;
  2626. }
  2627. catch (RemoteException|RuntimeException localRemoteException)
  2628. {
  2629. for (;;)
  2630. {
  2631. handleRadioProxyExceptionForRR(paramMessage, "getPreferredNetworkType", localRemoteException);
  2632. }
  2633. }
  2634. }
  2635.  
  2636. public void getPreferredVoicePrivacy(Message paramMessage)
  2637. {
  2638. IRadio localIRadio = getRadioProxy(paramMessage);
  2639. if (localIRadio != null)
  2640. {
  2641. paramMessage = obtainRequest(83, paramMessage, mRILDefaultWorkSource);
  2642. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2643. }
  2644. try
  2645. {
  2646. localIRadio.getPreferredVoicePrivacy(mSerial);
  2647. return;
  2648. }
  2649. catch (RemoteException|RuntimeException localRemoteException)
  2650. {
  2651. for (;;)
  2652. {
  2653. handleRadioProxyExceptionForRR(paramMessage, "getPreferredVoicePrivacy", localRemoteException);
  2654. }
  2655. }
  2656. }
  2657.  
  2658. public void getRadioCapability(Message paramMessage)
  2659. {
  2660. IRadio localIRadio = getRadioProxy(paramMessage);
  2661. if (localIRadio != null)
  2662. {
  2663. paramMessage = obtainRequest(130, paramMessage, mRILDefaultWorkSource);
  2664. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2665. }
  2666. try
  2667. {
  2668. localIRadio.getRadioCapability(mSerial);
  2669. return;
  2670. }
  2671. catch (RemoteException|RuntimeException localRemoteException)
  2672. {
  2673. for (;;)
  2674. {
  2675. handleRadioProxyExceptionForRR(paramMessage, "getRadioCapability", localRemoteException);
  2676. }
  2677. }
  2678. }
  2679.  
  2680. public void getSignalStrength(Message paramMessage)
  2681. {
  2682. IRadio localIRadio = getRadioProxy(paramMessage);
  2683. if (localIRadio != null)
  2684. {
  2685. paramMessage = obtainRequest(19, paramMessage, mRILDefaultWorkSource);
  2686. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2687. }
  2688. try
  2689. {
  2690. localIRadio.getSignalStrength(mSerial);
  2691. return;
  2692. }
  2693. catch (RemoteException|RuntimeException localRemoteException)
  2694. {
  2695. for (;;)
  2696. {
  2697. handleRadioProxyExceptionForRR(paramMessage, "getSignalStrength", localRemoteException);
  2698. }
  2699. }
  2700. }
  2701.  
  2702. public void getSmscAddress(Message paramMessage)
  2703. {
  2704. IRadio localIRadio = getRadioProxy(paramMessage);
  2705. if (localIRadio != null)
  2706. {
  2707. paramMessage = obtainRequest(100, paramMessage, mRILDefaultWorkSource);
  2708. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2709. }
  2710. try
  2711. {
  2712. localIRadio.getSmscAddress(mSerial);
  2713. return;
  2714. }
  2715. catch (RemoteException|RuntimeException localRemoteException)
  2716. {
  2717. for (;;)
  2718. {
  2719. handleRadioProxyExceptionForRR(paramMessage, "getSmscAddress", localRemoteException);
  2720. }
  2721. }
  2722. }
  2723.  
  2724. public void getVoiceRadioTechnology(Message paramMessage)
  2725. {
  2726. IRadio localIRadio = getRadioProxy(paramMessage);
  2727. if (localIRadio != null)
  2728. {
  2729. paramMessage = obtainRequest(108, paramMessage, mRILDefaultWorkSource);
  2730. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2731. }
  2732. try
  2733. {
  2734. localIRadio.getVoiceRadioTechnology(mSerial);
  2735. return;
  2736. }
  2737. catch (RemoteException|RuntimeException localRemoteException)
  2738. {
  2739. for (;;)
  2740. {
  2741. handleRadioProxyExceptionForRR(paramMessage, "getVoiceRadioTechnology", localRemoteException);
  2742. }
  2743. }
  2744. }
  2745.  
  2746. public void getVoiceRegistrationState(Message paramMessage)
  2747. {
  2748. IRadio localIRadio = getRadioProxy(paramMessage);
  2749. if (localIRadio != null)
  2750. {
  2751. paramMessage = obtainRequest(20, paramMessage, mRILDefaultWorkSource);
  2752. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2753. }
  2754. try
  2755. {
  2756. localIRadio.getVoiceRegistrationState(mSerial);
  2757. return;
  2758. }
  2759. catch (RemoteException|RuntimeException localRemoteException)
  2760. {
  2761. for (;;)
  2762. {
  2763. handleRadioProxyExceptionForRR(paramMessage, "getVoiceRegistrationState", localRemoteException);
  2764. }
  2765. }
  2766. }
  2767.  
  2768. public void handleCallSetupRequestFromSim(boolean paramBoolean, Message paramMessage)
  2769. {
  2770. IRadio localIRadio = getRadioProxy(paramMessage);
  2771. if (localIRadio != null)
  2772. {
  2773. paramMessage = obtainRequest(71, paramMessage, mRILDefaultWorkSource);
  2774. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2775. }
  2776. try
  2777. {
  2778. localIRadio.handleStkCallSetupRequestFromSim(mSerial, paramBoolean);
  2779. return;
  2780. }
  2781. catch (RemoteException|RuntimeException localRemoteException)
  2782. {
  2783. for (;;)
  2784. {
  2785. handleRadioProxyExceptionForRR(paramMessage, "getAllowedCarriers", localRemoteException);
  2786. }
  2787. }
  2788. }
  2789.  
  2790. public void hangupConnection(int paramInt, Message paramMessage)
  2791. {
  2792. IRadio localIRadio = getRadioProxy(paramMessage);
  2793. if (localIRadio != null)
  2794. {
  2795. paramMessage = obtainRequest(12, paramMessage, mRILDefaultWorkSource);
  2796. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " gsmIndex = " + paramInt);
  2797. }
  2798. try
  2799. {
  2800. localIRadio.hangup(mSerial, paramInt);
  2801. return;
  2802. }
  2803. catch (RemoteException|RuntimeException localRemoteException)
  2804. {
  2805. for (;;)
  2806. {
  2807. handleRadioProxyExceptionForRR(paramMessage, "hangupConnection", localRemoteException);
  2808. }
  2809. }
  2810. }
  2811.  
  2812. public void hangupForegroundResumeBackground(Message paramMessage)
  2813. {
  2814. IRadio localIRadio = getRadioProxy(paramMessage);
  2815. if (localIRadio != null)
  2816. {
  2817. paramMessage = obtainRequest(14, paramMessage, mRILDefaultWorkSource);
  2818. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2819. }
  2820. try
  2821. {
  2822. localIRadio.hangupForegroundResumeBackground(mSerial);
  2823. return;
  2824. }
  2825. catch (RemoteException|RuntimeException localRemoteException)
  2826. {
  2827. for (;;)
  2828. {
  2829. handleRadioProxyExceptionForRR(paramMessage, "hangupForegroundResumeBackground", localRemoteException);
  2830. }
  2831. }
  2832. }
  2833.  
  2834. public void hangupWaitingOrBackground(Message paramMessage)
  2835. {
  2836. IRadio localIRadio = getRadioProxy(paramMessage);
  2837. if (localIRadio != null)
  2838. {
  2839. paramMessage = obtainRequest(13, paramMessage, mRILDefaultWorkSource);
  2840. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  2841. }
  2842. try
  2843. {
  2844. localIRadio.hangupWaitingOrBackground(mSerial);
  2845. return;
  2846. }
  2847. catch (RemoteException|RuntimeException localRemoteException)
  2848. {
  2849. for (;;)
  2850. {
  2851. handleRadioProxyExceptionForRR(paramMessage, "hangupWaitingOrBackground", localRemoteException);
  2852. }
  2853. }
  2854. }
  2855.  
  2856. public void iccCloseLogicalChannel(int paramInt, Message paramMessage)
  2857. {
  2858. IRadio localIRadio = getRadioProxy(paramMessage);
  2859. if (localIRadio != null)
  2860. {
  2861. paramMessage = obtainRequest(116, paramMessage, mRILDefaultWorkSource);
  2862. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " channel = " + paramInt);
  2863. }
  2864. try
  2865. {
  2866. localIRadio.iccCloseLogicalChannel(mSerial, paramInt);
  2867. return;
  2868. }
  2869. catch (RemoteException|RuntimeException localRemoteException)
  2870. {
  2871. for (;;)
  2872. {
  2873. handleRadioProxyExceptionForRR(paramMessage, "iccCloseLogicalChannel", localRemoteException);
  2874. }
  2875. }
  2876. }
  2877.  
  2878. public void iccIO(int paramInt1, int paramInt2, String paramString1, int paramInt3, int paramInt4, int paramInt5, String paramString2, String paramString3, Message paramMessage)
  2879. {
  2880. iccIOForApp(paramInt1, paramInt2, paramString1, paramInt3, paramInt4, paramInt5, paramString2, paramString3, null, paramMessage);
  2881. }
  2882.  
  2883. public void iccIOForApp(int paramInt1, int paramInt2, String paramString1, int paramInt3, int paramInt4, int paramInt5, String paramString2, String paramString3, String paramString4, Message paramMessage)
  2884. {
  2885. IRadio localIRadio = getRadioProxy(paramMessage);
  2886. IccIo localIccIo;
  2887. if (localIRadio != null)
  2888. {
  2889. paramMessage = obtainRequest(28, paramMessage, mRILDefaultWorkSource);
  2890. riljLog(paramMessage.serialString() + "> iccIO: " + requestToString(mRequest) + " command = 0x" + Integer.toHexString(paramInt1) + " fileId = 0x" + Integer.toHexString(paramInt2) + " path = " + paramString1 + " p1 = " + paramInt3 + " p2 = " + paramInt4 + " p3 = " + " data = " + paramString2 + " aid = " + paramString4);
  2891. localIccIo = new IccIo();
  2892. command = paramInt1;
  2893. fileId = paramInt2;
  2894. path = convertNullToEmptyString(paramString1);
  2895. p1 = paramInt3;
  2896. p2 = paramInt4;
  2897. p3 = paramInt5;
  2898. data = convertNullToEmptyString(paramString2);
  2899. pin2 = convertNullToEmptyString(paramString3);
  2900. aid = convertNullToEmptyString(paramString4);
  2901. }
  2902. try
  2903. {
  2904. localIRadio.iccIOForApp(mSerial, localIccIo);
  2905. return;
  2906. }
  2907. catch (RemoteException|RuntimeException paramString1)
  2908. {
  2909. for (;;)
  2910. {
  2911. handleRadioProxyExceptionForRR(paramMessage, "iccIOForApp", paramString1);
  2912. }
  2913. }
  2914. }
  2915.  
  2916. public void iccOpenLogicalChannel(String paramString, int paramInt, Message paramMessage)
  2917. {
  2918. IRadio localIRadio = getRadioProxy(paramMessage);
  2919. if (localIRadio != null)
  2920. {
  2921. paramMessage = obtainRequest(115, paramMessage, mRILDefaultWorkSource);
  2922. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " aid = " + paramString + " p2 = " + paramInt);
  2923. }
  2924. try
  2925. {
  2926. localIRadio.iccOpenLogicalChannel(mSerial, convertNullToEmptyString(paramString), paramInt);
  2927. return;
  2928. }
  2929. catch (RemoteException|RuntimeException paramString)
  2930. {
  2931. for (;;)
  2932. {
  2933. handleRadioProxyExceptionForRR(paramMessage, "iccOpenLogicalChannel", paramString);
  2934. }
  2935. }
  2936. }
  2937.  
  2938. public void iccTransmitApduBasicChannel(int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5, String paramString, Message paramMessage)
  2939. {
  2940. IRadio localIRadio = getRadioProxy(paramMessage);
  2941. if (localIRadio != null)
  2942. {
  2943. paramMessage = obtainRequest(114, paramMessage, mRILDefaultWorkSource);
  2944. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " cla = " + paramInt1 + " instruction = " + paramInt2 + " p1 = " + paramInt3 + " p2 = " + " p3 = " + paramInt5 + " data = " + paramString);
  2945. paramString = createSimApdu(0, paramInt1, paramInt2, paramInt3, paramInt4, paramInt5, paramString);
  2946. }
  2947. try
  2948. {
  2949. localIRadio.iccTransmitApduBasicChannel(mSerial, paramString);
  2950. return;
  2951. }
  2952. catch (RemoteException|RuntimeException paramString)
  2953. {
  2954. for (;;)
  2955. {
  2956. handleRadioProxyExceptionForRR(paramMessage, "iccTransmitApduBasicChannel", paramString);
  2957. }
  2958. }
  2959. }
  2960.  
  2961. public void iccTransmitApduLogicalChannel(int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5, int paramInt6, String paramString, Message paramMessage)
  2962. {
  2963. if (paramInt1 <= 0) {
  2964. throw new RuntimeException("Invalid channel in iccTransmitApduLogicalChannel: " + paramInt1);
  2965. }
  2966. IRadio localIRadio = getRadioProxy(paramMessage);
  2967. if (localIRadio != null)
  2968. {
  2969. paramMessage = obtainRequest(117, paramMessage, mRILDefaultWorkSource);
  2970. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " channel = " + paramInt1 + " cla = " + paramInt2 + " instruction = " + paramInt3 + " p1 = " + paramInt4 + " p2 = " + " p3 = " + paramInt6 + " data = " + paramString);
  2971. paramString = createSimApdu(paramInt1, paramInt2, paramInt3, paramInt4, paramInt5, paramInt6, paramString);
  2972. }
  2973. try
  2974. {
  2975. localIRadio.iccTransmitApduLogicalChannel(mSerial, paramString);
  2976. return;
  2977. }
  2978. catch (RemoteException|RuntimeException paramString)
  2979. {
  2980. for (;;)
  2981. {
  2982. handleRadioProxyExceptionForRR(paramMessage, "iccTransmitApduLogicalChannel", paramString);
  2983. }
  2984. }
  2985. }
  2986.  
  2987. public void invokeOemRilRequestRaw(byte[] paramArrayOfByte, Message paramMessage)
  2988. {
  2989. IOemHook localIOemHook = getOemHookProxy(paramMessage);
  2990. if (localIOemHook != null)
  2991. {
  2992. paramMessage = obtainRequest(59, paramMessage, mRILDefaultWorkSource);
  2993. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + "[" + IccUtils.bytesToHexString(paramArrayOfByte) + "]");
  2994. }
  2995. try
  2996. {
  2997. localIOemHook.sendRequestRaw(mSerial, primitiveArrayToArrayList(paramArrayOfByte));
  2998. return;
  2999. }
  3000. catch (RemoteException|RuntimeException paramArrayOfByte)
  3001. {
  3002. for (;;)
  3003. {
  3004. handleRadioProxyExceptionForRR(paramMessage, "invokeOemRilRequestStrings", paramArrayOfByte);
  3005. }
  3006. }
  3007. }
  3008.  
  3009. public void invokeOemRilRequestStrings(String[] paramArrayOfString, Message paramMessage)
  3010. {
  3011. IOemHook localIOemHook = getOemHookProxy(paramMessage);
  3012. RILRequest localRILRequest;
  3013. int i;
  3014. if (localIOemHook != null)
  3015. {
  3016. localRILRequest = obtainRequest(60, paramMessage, mRILDefaultWorkSource);
  3017. paramMessage = "";
  3018. for (i = 0; i < paramArrayOfString.length; i++) {
  3019. paramMessage = paramMessage + paramArrayOfString[i] + " ";
  3020. }
  3021. riljLog(localRILRequest.serialString() + "> " + requestToString(mRequest) + " strings = " + paramMessage);
  3022. }
  3023. try
  3024. {
  3025. i = mSerial;
  3026. paramMessage = new java/util/ArrayList;
  3027. paramMessage.<init>(Arrays.asList(paramArrayOfString));
  3028. localIOemHook.sendRequestStrings(i, paramMessage);
  3029. return;
  3030. }
  3031. catch (RemoteException|RuntimeException paramArrayOfString)
  3032. {
  3033. for (;;)
  3034. {
  3035. handleRadioProxyExceptionForRR(localRILRequest, "invokeOemRilRequestStrings", paramArrayOfString);
  3036. }
  3037. }
  3038. }
  3039.  
  3040. RadioCapability makeStaticRadioCapability()
  3041. {
  3042. int i = 1;
  3043. Object localObject = mContext.getResources().getString(17039683);
  3044. if (!TextUtils.isEmpty((CharSequence)localObject)) {
  3045. i = RadioAccessFamily.rafTypeFromString((String)localObject);
  3046. }
  3047. localObject = new RadioCapability(mPhoneId.intValue(), 0, 0, i, "", 1);
  3048. riljLog("Faking RIL_REQUEST_GET_RADIO_CAPABILITY response using " + i);
  3049. return localObject;
  3050. }
  3051.  
  3052. void notifyRegistrantsCdmaInfoRec(CdmaInformationRecords paramCdmaInformationRecords)
  3053. {
  3054. if ((record instanceof CdmaInformationRecords.CdmaDisplayInfoRec)) {
  3055. if (mDisplayInfoRegistrants != null)
  3056. {
  3057. unsljLogRet(1027, record);
  3058. mDisplayInfoRegistrants.notifyRegistrants(new AsyncResult(null, record, null));
  3059. }
  3060. }
  3061. for (;;)
  3062. {
  3063. return;
  3064. if ((record instanceof CdmaInformationRecords.CdmaSignalInfoRec))
  3065. {
  3066. if (mSignalInfoRegistrants != null)
  3067. {
  3068. unsljLogRet(1027, record);
  3069. mSignalInfoRegistrants.notifyRegistrants(new AsyncResult(null, record, null));
  3070. }
  3071. }
  3072. else if ((record instanceof CdmaInformationRecords.CdmaNumberInfoRec))
  3073. {
  3074. if (mNumberInfoRegistrants != null)
  3075. {
  3076. unsljLogRet(1027, record);
  3077. mNumberInfoRegistrants.notifyRegistrants(new AsyncResult(null, record, null));
  3078. }
  3079. }
  3080. else if ((record instanceof CdmaInformationRecords.CdmaRedirectingNumberInfoRec))
  3081. {
  3082. if (mRedirNumInfoRegistrants != null)
  3083. {
  3084. unsljLogRet(1027, record);
  3085. mRedirNumInfoRegistrants.notifyRegistrants(new AsyncResult(null, record, null));
  3086. }
  3087. }
  3088. else if ((record instanceof CdmaInformationRecords.CdmaLineControlInfoRec))
  3089. {
  3090. if (mLineControlInfoRegistrants != null)
  3091. {
  3092. unsljLogRet(1027, record);
  3093. mLineControlInfoRegistrants.notifyRegistrants(new AsyncResult(null, record, null));
  3094. }
  3095. }
  3096. else if ((record instanceof CdmaInformationRecords.CdmaT53ClirInfoRec))
  3097. {
  3098. if (mT53ClirInfoRegistrants != null)
  3099. {
  3100. unsljLogRet(1027, record);
  3101. mT53ClirInfoRegistrants.notifyRegistrants(new AsyncResult(null, record, null));
  3102. }
  3103. }
  3104. else if (((record instanceof CdmaInformationRecords.CdmaT53AudioControlInfoRec)) && (mT53AudCntrlInfoRegistrants != null))
  3105. {
  3106. unsljLogRet(1027, record);
  3107. mT53AudCntrlInfoRegistrants.notifyRegistrants(new AsyncResult(null, record, null));
  3108. }
  3109. }
  3110. }
  3111.  
  3112. void notifyRegistrantsRilConnectionChanged(int paramInt)
  3113. {
  3114. mRilVersion = paramInt;
  3115. if (mRilConnectedRegistrants != null) {
  3116. mRilConnectedRegistrants.notifyRegistrants(new AsyncResult(null, new Integer(paramInt), null));
  3117. }
  3118. }
  3119.  
  3120. public void nvReadItem(int paramInt, Message paramMessage)
  3121. {
  3122. IRadio localIRadio = getRadioProxy(paramMessage);
  3123. if (localIRadio != null)
  3124. {
  3125. paramMessage = obtainRequest(118, paramMessage, mRILDefaultWorkSource);
  3126. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " itemId = " + paramInt);
  3127. }
  3128. try
  3129. {
  3130. localIRadio.nvReadItem(mSerial, paramInt);
  3131. return;
  3132. }
  3133. catch (RemoteException|RuntimeException localRemoteException)
  3134. {
  3135. for (;;)
  3136. {
  3137. handleRadioProxyExceptionForRR(paramMessage, "nvReadItem", localRemoteException);
  3138. }
  3139. }
  3140. }
  3141.  
  3142. public void nvResetConfig(int paramInt, Message paramMessage)
  3143. {
  3144. IRadio localIRadio = getRadioProxy(paramMessage);
  3145. if (localIRadio != null)
  3146. {
  3147. paramMessage = obtainRequest(121, paramMessage, mRILDefaultWorkSource);
  3148. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " resetType = " + paramInt);
  3149. }
  3150. try
  3151. {
  3152. localIRadio.nvResetConfig(mSerial, convertToHalResetNvType(paramInt));
  3153. return;
  3154. }
  3155. catch (RemoteException|RuntimeException localRemoteException)
  3156. {
  3157. for (;;)
  3158. {
  3159. handleRadioProxyExceptionForRR(paramMessage, "nvResetConfig", localRemoteException);
  3160. }
  3161. }
  3162. }
  3163.  
  3164. public void nvWriteCdmaPrl(byte[] paramArrayOfByte, Message paramMessage)
  3165. {
  3166. IRadio localIRadio = getRadioProxy(paramMessage);
  3167. ArrayList localArrayList;
  3168. if (localIRadio != null)
  3169. {
  3170. paramMessage = obtainRequest(120, paramMessage, mRILDefaultWorkSource);
  3171. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " PreferredRoamingList = 0x" + IccUtils.bytesToHexString(paramArrayOfByte));
  3172. localArrayList = new ArrayList();
  3173. for (int i = 0; i < paramArrayOfByte.length; i++) {
  3174. localArrayList.add(Byte.valueOf(paramArrayOfByte[i]));
  3175. }
  3176. }
  3177. try
  3178. {
  3179. localIRadio.nvWriteCdmaPrl(mSerial, localArrayList);
  3180. return;
  3181. }
  3182. catch (RemoteException|RuntimeException paramArrayOfByte)
  3183. {
  3184. for (;;)
  3185. {
  3186. handleRadioProxyExceptionForRR(paramMessage, "nvWriteCdmaPrl", paramArrayOfByte);
  3187. }
  3188. }
  3189. }
  3190.  
  3191. public void nvWriteItem(int paramInt, String paramString, Message paramMessage)
  3192. {
  3193. IRadio localIRadio = getRadioProxy(paramMessage);
  3194. NvWriteItem localNvWriteItem;
  3195. if (localIRadio != null)
  3196. {
  3197. paramMessage = obtainRequest(119, paramMessage, mRILDefaultWorkSource);
  3198. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " itemId = " + paramInt + " itemValue = " + paramString);
  3199. localNvWriteItem = new NvWriteItem();
  3200. itemId = paramInt;
  3201. value = convertNullToEmptyString(paramString);
  3202. }
  3203. try
  3204. {
  3205. localIRadio.nvWriteItem(mSerial, localNvWriteItem);
  3206. return;
  3207. }
  3208. catch (RemoteException|RuntimeException paramString)
  3209. {
  3210. for (;;)
  3211. {
  3212. handleRadioProxyExceptionForRR(paramMessage, "nvWriteItem", paramString);
  3213. }
  3214. }
  3215. }
  3216.  
  3217. protected int obtainRequestSerial(int paramInt, Message paramMessage, WorkSource paramWorkSource)
  3218. {
  3219. paramMessage = RILRequest.obtain(paramInt, paramMessage, paramWorkSource);
  3220. addRequest(paramMessage);
  3221. return mSerial;
  3222. }
  3223.  
  3224. void processIndication(int paramInt)
  3225. {
  3226. if (paramInt == 1)
  3227. {
  3228. sendAck();
  3229. riljLog("Unsol response received; Sending ack to ril.cpp");
  3230. }
  3231. }
  3232.  
  3233. void processRequestAck(int paramInt)
  3234. {
  3235. for (;;)
  3236. {
  3237. synchronized (mRequestList)
  3238. {
  3239. RILRequest localRILRequest1 = (RILRequest)mRequestList.get(paramInt);
  3240. if (localRILRequest1 == null)
  3241. {
  3242. Rlog.w("RILJ", "processRequestAck: Unexpected solicited ack response! serial: " + paramInt);
  3243. return;
  3244. }
  3245. }
  3246. decrementWakeLock(localRILRequest2);
  3247. riljLog(localRILRequest2.serialString() + " Ack < " + requestToString(mRequest));
  3248. }
  3249. }
  3250.  
  3251. protected RILRequest processResponse(RadioResponseInfo arg1)
  3252. {
  3253. int i = serial;
  3254. int j = error;
  3255. int k = type;
  3256. if (k == 1) {
  3257. for (;;)
  3258. {
  3259. synchronized (mRequestList)
  3260. {
  3261. RILRequest localRILRequest1 = (RILRequest)mRequestList.get(i);
  3262. if (localRILRequest1 == null)
  3263. {
  3264. Rlog.w("RILJ", "Unexpected solicited ack response! sn: " + i);
  3265. return localRILRequest1;
  3266. }
  3267. }
  3268. decrementWakeLock(localRILRequest2);
  3269. riljLog(localRILRequest2.serialString() + " Ack < " + requestToString(mRequest));
  3270. }
  3271. }
  3272. ??? = findAndRemoveRequestFromList(i);
  3273. if (??? == null)
  3274. {
  3275. Rlog.e("RILJ", "processResponse: Unexpected response! serial: " + i + " error: " + j);
  3276. return null;
  3277. }
  3278. addToRilHistogram(???);
  3279. if (k == 2)
  3280. {
  3281. sendAck();
  3282. riljLog("Response received for " + ???.serialString() + " " + requestToString(mRequest) + " Sending ack to ril.cpp");
  3283. }
  3284. switch (mRequest)
  3285. {
  3286. default:
  3287. if (j != 0) {
  3288. switch (mRequest)
  3289. {
  3290. }
  3291. }
  3292. break;
  3293. }
  3294. for (;;)
  3295. {
  3296. return ???;
  3297. if (mIccStatusChangedRegistrants == null) {
  3298. break;
  3299. }
  3300. riljLog("ON enter sim puk fakeSimStatusChanged: reg count=" + mIccStatusChangedRegistrants.size());
  3301. mIccStatusChangedRegistrants.notifyRegistrants();
  3302. break;
  3303. setRadioState(CommandsInterface.RadioState.RADIO_UNAVAILABLE);
  3304. break;
  3305. if (mIccStatusChangedRegistrants != null)
  3306. {
  3307. riljLog("ON some errors fakeSimStatusChanged: reg count=" + mIccStatusChangedRegistrants.size());
  3308. mIccStatusChangedRegistrants.notifyRegistrants();
  3309. continue;
  3310. switch (mRequest)
  3311. {
  3312. default:
  3313. break;
  3314. case 14:
  3315. if ((mTestingEmergencyCall.getAndSet(false)) && (mEmergencyCallbackModeRegistrant != null))
  3316. {
  3317. riljLog("testing emergency call, notify ECM Registrants");
  3318. mEmergencyCallbackModeRegistrant.notifyRegistrant();
  3319. }
  3320. break;
  3321. }
  3322. }
  3323. }
  3324. }
  3325.  
  3326. void processResponseDone(RILRequest paramRILRequest, RadioResponseInfo paramRadioResponseInfo, Object paramObject)
  3327. {
  3328. if (error == 0) {
  3329. riljLog(paramRILRequest.serialString() + "< " + requestToString(mRequest) + " " + retToString(mRequest, paramObject));
  3330. }
  3331. for (;;)
  3332. {
  3333. mMetrics.writeOnRilSolicitedResponse(mPhoneId.intValue(), mSerial, error, mRequest, paramObject);
  3334. if (paramRILRequest != null)
  3335. {
  3336. if (type == 0) {
  3337. decrementWakeLock(paramRILRequest);
  3338. }
  3339. paramRILRequest.release();
  3340. }
  3341. return;
  3342. riljLog(paramRILRequest.serialString() + "< " + requestToString(mRequest) + " error " + error);
  3343. paramRILRequest.onError(error, paramObject);
  3344. }
  3345. }
  3346.  
  3347. protected void processResponseDone(Object paramObject1, RadioResponseInfo paramRadioResponseInfo, Object paramObject2)
  3348. {
  3349. processResponseDone((RILRequest)paramObject1, paramRadioResponseInfo, paramObject2);
  3350. }
  3351.  
  3352. public void pullLceData(Message paramMessage)
  3353. {
  3354. IRadio localIRadio = getRadioProxy(paramMessage);
  3355. if (localIRadio != null)
  3356. {
  3357. paramMessage = obtainRequest(134, paramMessage, mRILDefaultWorkSource);
  3358. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3359. }
  3360. try
  3361. {
  3362. localIRadio.pullLceData(mSerial);
  3363. return;
  3364. }
  3365. catch (RemoteException|RuntimeException localRemoteException)
  3366. {
  3367. for (;;)
  3368. {
  3369. handleRadioProxyExceptionForRR(paramMessage, "pullLceData", localRemoteException);
  3370. }
  3371. }
  3372. }
  3373.  
  3374. public void queryAvailableBandMode(Message paramMessage)
  3375. {
  3376. IRadio localIRadio = getRadioProxy(paramMessage);
  3377. if (localIRadio != null)
  3378. {
  3379. paramMessage = obtainRequest(66, paramMessage, mRILDefaultWorkSource);
  3380. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3381. }
  3382. try
  3383. {
  3384. localIRadio.getAvailableBandModes(mSerial);
  3385. return;
  3386. }
  3387. catch (RemoteException|RuntimeException localRemoteException)
  3388. {
  3389. for (;;)
  3390. {
  3391. handleRadioProxyExceptionForRR(paramMessage, "queryAvailableBandMode", localRemoteException);
  3392. }
  3393. }
  3394. }
  3395.  
  3396. public void queryCLIP(Message paramMessage)
  3397. {
  3398. IRadio localIRadio = getRadioProxy(paramMessage);
  3399. if (localIRadio != null)
  3400. {
  3401. paramMessage = obtainRequest(55, paramMessage, mRILDefaultWorkSource);
  3402. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3403. }
  3404. try
  3405. {
  3406. localIRadio.getClip(mSerial);
  3407. return;
  3408. }
  3409. catch (RemoteException|RuntimeException localRemoteException)
  3410. {
  3411. for (;;)
  3412. {
  3413. handleRadioProxyExceptionForRR(paramMessage, "queryCLIP", localRemoteException);
  3414. }
  3415. }
  3416. }
  3417.  
  3418. public void queryCallForwardStatus(int paramInt1, int paramInt2, String paramString, Message paramMessage)
  3419. {
  3420. IRadio localIRadio = getRadioProxy(paramMessage);
  3421. android.hardware.radio.V1_0.CallForwardInfo localCallForwardInfo;
  3422. if (localIRadio != null)
  3423. {
  3424. paramMessage = obtainRequest(33, paramMessage, mRILDefaultWorkSource);
  3425. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " cfreason = " + paramInt1 + " serviceClass = " + paramInt2);
  3426. localCallForwardInfo = new android.hardware.radio.V1_0.CallForwardInfo();
  3427. reason = paramInt1;
  3428. serviceClass = paramInt2;
  3429. toa = PhoneNumberUtils.toaFromString(paramString);
  3430. number = convertNullToEmptyString(paramString);
  3431. timeSeconds = 0;
  3432. }
  3433. try
  3434. {
  3435. localIRadio.getCallForwardStatus(mSerial, localCallForwardInfo);
  3436. return;
  3437. }
  3438. catch (RemoteException|RuntimeException paramString)
  3439. {
  3440. for (;;)
  3441. {
  3442. handleRadioProxyExceptionForRR(paramMessage, "queryCallForwardStatus", paramString);
  3443. }
  3444. }
  3445. }
  3446.  
  3447. public void queryCallWaiting(int paramInt, Message paramMessage)
  3448. {
  3449. IRadio localIRadio = getRadioProxy(paramMessage);
  3450. if (localIRadio != null)
  3451. {
  3452. paramMessage = obtainRequest(35, paramMessage, mRILDefaultWorkSource);
  3453. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " serviceClass = " + paramInt);
  3454. }
  3455. try
  3456. {
  3457. localIRadio.getCallWaiting(mSerial, paramInt);
  3458. return;
  3459. }
  3460. catch (RemoteException|RuntimeException localRemoteException)
  3461. {
  3462. for (;;)
  3463. {
  3464. handleRadioProxyExceptionForRR(paramMessage, "queryCallWaiting", localRemoteException);
  3465. }
  3466. }
  3467. }
  3468.  
  3469. public void queryCdmaRoamingPreference(Message paramMessage)
  3470. {
  3471. IRadio localIRadio = getRadioProxy(paramMessage);
  3472. if (localIRadio != null)
  3473. {
  3474. paramMessage = obtainRequest(79, paramMessage, mRILDefaultWorkSource);
  3475. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3476. }
  3477. try
  3478. {
  3479. localIRadio.getCdmaRoamingPreference(mSerial);
  3480. return;
  3481. }
  3482. catch (RemoteException|RuntimeException localRemoteException)
  3483. {
  3484. for (;;)
  3485. {
  3486. handleRadioProxyExceptionForRR(paramMessage, "queryCdmaRoamingPreference", localRemoteException);
  3487. }
  3488. }
  3489. }
  3490.  
  3491. public void queryFacilityLock(String paramString1, String paramString2, int paramInt, Message paramMessage)
  3492. {
  3493. queryFacilityLockForApp(paramString1, paramString2, paramInt, null, paramMessage);
  3494. }
  3495.  
  3496. public void queryFacilityLockForApp(String paramString1, String paramString2, int paramInt, String paramString3, Message paramMessage)
  3497. {
  3498. IRadio localIRadio = getRadioProxy(paramMessage);
  3499. if (localIRadio != null)
  3500. {
  3501. paramMessage = obtainRequest(42, paramMessage, mRILDefaultWorkSource);
  3502. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " facility = " + paramString1 + " serviceClass = " + paramInt + " appId = " + paramString3);
  3503. }
  3504. try
  3505. {
  3506. localIRadio.getFacilityLockForApp(mSerial, convertNullToEmptyString(paramString1), convertNullToEmptyString(paramString2), paramInt, convertNullToEmptyString(paramString3));
  3507. return;
  3508. }
  3509. catch (RemoteException|RuntimeException paramString1)
  3510. {
  3511. for (;;)
  3512. {
  3513. handleRadioProxyExceptionForRR(paramMessage, "getFacilityLockForApp", paramString1);
  3514. }
  3515. }
  3516. }
  3517.  
  3518. public void queryTTYMode(Message paramMessage)
  3519. {
  3520. IRadio localIRadio = getRadioProxy(paramMessage);
  3521. if (localIRadio != null)
  3522. {
  3523. paramMessage = obtainRequest(81, paramMessage, mRILDefaultWorkSource);
  3524. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3525. }
  3526. try
  3527. {
  3528. localIRadio.getTTYMode(mSerial);
  3529. return;
  3530. }
  3531. catch (RemoteException|RuntimeException localRemoteException)
  3532. {
  3533. for (;;)
  3534. {
  3535. handleRadioProxyExceptionForRR(paramMessage, "queryTTYMode", localRemoteException);
  3536. }
  3537. }
  3538. }
  3539.  
  3540. public void rejectCall(Message paramMessage)
  3541. {
  3542. IRadio localIRadio = getRadioProxy(paramMessage);
  3543. if (localIRadio != null)
  3544. {
  3545. paramMessage = obtainRequest(17, paramMessage, mRILDefaultWorkSource);
  3546. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3547. }
  3548. try
  3549. {
  3550. localIRadio.rejectCall(mSerial);
  3551. return;
  3552. }
  3553. catch (RemoteException|RuntimeException localRemoteException)
  3554. {
  3555. for (;;)
  3556. {
  3557. handleRadioProxyExceptionForRR(paramMessage, "rejectCall", localRemoteException);
  3558. }
  3559. }
  3560. }
  3561.  
  3562. public void reportSmsMemoryStatus(boolean paramBoolean, Message paramMessage)
  3563. {
  3564. IRadio localIRadio = getRadioProxy(paramMessage);
  3565. if (localIRadio != null)
  3566. {
  3567. paramMessage = obtainRequest(102, paramMessage, mRILDefaultWorkSource);
  3568. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " available = " + paramBoolean);
  3569. }
  3570. try
  3571. {
  3572. localIRadio.reportSmsMemoryStatus(mSerial, paramBoolean);
  3573. return;
  3574. }
  3575. catch (RemoteException|RuntimeException localRemoteException)
  3576. {
  3577. for (;;)
  3578. {
  3579. handleRadioProxyExceptionForRR(paramMessage, "reportSmsMemoryStatus", localRemoteException);
  3580. }
  3581. }
  3582. }
  3583.  
  3584. public void reportStkServiceIsRunning(Message paramMessage)
  3585. {
  3586. IRadio localIRadio = getRadioProxy(paramMessage);
  3587. if (localIRadio != null)
  3588. {
  3589. paramMessage = obtainRequest(103, paramMessage, mRILDefaultWorkSource);
  3590. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3591. }
  3592. try
  3593. {
  3594. localIRadio.reportStkServiceIsRunning(mSerial);
  3595. return;
  3596. }
  3597. catch (RemoteException|RuntimeException localRemoteException)
  3598. {
  3599. for (;;)
  3600. {
  3601. handleRadioProxyExceptionForRR(paramMessage, "reportStkServiceIsRunning", localRemoteException);
  3602. }
  3603. }
  3604. }
  3605.  
  3606. public void requestIccSimAuthentication(int paramInt, String paramString1, String paramString2, Message paramMessage)
  3607. {
  3608. IRadio localIRadio = getRadioProxy(paramMessage);
  3609. if (localIRadio != null)
  3610. {
  3611. paramMessage = obtainRequest(125, paramMessage, mRILDefaultWorkSource);
  3612. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3613. }
  3614. try
  3615. {
  3616. localIRadio.requestIccSimAuthentication(mSerial, paramInt, convertNullToEmptyString(paramString1), convertNullToEmptyString(paramString2));
  3617. return;
  3618. }
  3619. catch (RemoteException|RuntimeException paramString1)
  3620. {
  3621. for (;;)
  3622. {
  3623. handleRadioProxyExceptionForRR(paramMessage, "requestIccSimAuthentication", paramString1);
  3624. }
  3625. }
  3626. }
  3627.  
  3628. public void requestIsimAuthentication(String paramString, Message paramMessage)
  3629. {
  3630. IRadio localIRadio = getRadioProxy(paramMessage);
  3631. if (localIRadio != null)
  3632. {
  3633. paramMessage = obtainRequest(105, paramMessage, mRILDefaultWorkSource);
  3634. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " nonce = " + paramString);
  3635. }
  3636. try
  3637. {
  3638. localIRadio.requestIsimAuthentication(mSerial, convertNullToEmptyString(paramString));
  3639. return;
  3640. }
  3641. catch (RemoteException|RuntimeException paramString)
  3642. {
  3643. for (;;)
  3644. {
  3645. handleRadioProxyExceptionForRR(paramMessage, "requestIsimAuthentication", paramString);
  3646. }
  3647. }
  3648. }
  3649.  
  3650. public void requestShutdown(Message paramMessage)
  3651. {
  3652. IRadio localIRadio = getRadioProxy(paramMessage);
  3653. if (localIRadio != null)
  3654. {
  3655. paramMessage = obtainRequest(129, paramMessage, mRILDefaultWorkSource);
  3656. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3657. }
  3658. try
  3659. {
  3660. localIRadio.requestShutdown(mSerial);
  3661. return;
  3662. }
  3663. catch (RemoteException|RuntimeException localRemoteException)
  3664. {
  3665. for (;;)
  3666. {
  3667. handleRadioProxyExceptionForRR(paramMessage, "requestShutdown", localRemoteException);
  3668. }
  3669. }
  3670. }
  3671.  
  3672. protected void resetProxyAndRequestList()
  3673. {
  3674. mRadioProxy = null;
  3675. mOemHookProxy = null;
  3676. mRadioProxyCookie.incrementAndGet();
  3677. setRadioState(CommandsInterface.RadioState.RADIO_UNAVAILABLE);
  3678. RILRequest.resetSerial();
  3679. clearRequestList(1, false);
  3680. }
  3681.  
  3682. public void resetRadio(Message paramMessage)
  3683. {
  3684. throw new RuntimeException("resetRadio not expected to be called");
  3685. }
  3686.  
  3687. void riljLog(String paramString)
  3688. {
  3689. StringBuilder localStringBuilder;
  3690. if (PrivacyLog.PRIVACY_LOG)
  3691. {
  3692. localStringBuilder = new StringBuilder().append(paramString);
  3693. if (mPhoneId == null) {
  3694. break label70;
  3695. }
  3696. }
  3697. label70:
  3698. for (paramString = " [SUB" + mPhoneId + "]";; paramString = "")
  3699. {
  3700. Rlog.d("RILJ", paramString);
  3701. return;
  3702. }
  3703. }
  3704.  
  3705. void riljLoge(String paramString)
  3706. {
  3707. StringBuilder localStringBuilder;
  3708. if (PrivacyLog.PRIVACY_LOG)
  3709. {
  3710. localStringBuilder = new StringBuilder().append(paramString);
  3711. if (mPhoneId == null) {
  3712. break label70;
  3713. }
  3714. }
  3715. label70:
  3716. for (paramString = " [SUB" + mPhoneId + "]";; paramString = "")
  3717. {
  3718. Rlog.e("RILJ", paramString);
  3719. return;
  3720. }
  3721. }
  3722.  
  3723. void riljLoge(String paramString, Exception paramException)
  3724. {
  3725. StringBuilder localStringBuilder;
  3726. if (PrivacyLog.PRIVACY_LOG)
  3727. {
  3728. localStringBuilder = new StringBuilder().append(paramString);
  3729. if (mPhoneId == null) {
  3730. break label71;
  3731. }
  3732. }
  3733. label71:
  3734. for (paramString = " [SUB" + mPhoneId + "]";; paramString = "")
  3735. {
  3736. Rlog.e("RILJ", paramString, paramException);
  3737. return;
  3738. }
  3739. }
  3740.  
  3741. void riljLogv(String paramString)
  3742. {
  3743. StringBuilder localStringBuilder;
  3744. if (PrivacyLog.PRIVACY_LOG)
  3745. {
  3746. localStringBuilder = new StringBuilder().append(paramString);
  3747. if (mPhoneId == null) {
  3748. break label70;
  3749. }
  3750. }
  3751. label70:
  3752. for (paramString = " [SUB" + mPhoneId + "]";; paramString = "")
  3753. {
  3754. Rlog.v("RILJ", paramString);
  3755. return;
  3756. }
  3757. }
  3758.  
  3759. public void sendBurstDtmf(String paramString, int paramInt1, int paramInt2, Message paramMessage)
  3760. {
  3761. IRadio localIRadio = getRadioProxy(paramMessage);
  3762. if (localIRadio != null)
  3763. {
  3764. paramMessage = obtainRequest(85, paramMessage, mRILDefaultWorkSource);
  3765. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " dtmfString = " + paramString + " on = " + paramInt1 + " off = " + paramInt2);
  3766. }
  3767. try
  3768. {
  3769. localIRadio.sendBurstDtmf(mSerial, convertNullToEmptyString(paramString), paramInt1, paramInt2);
  3770. return;
  3771. }
  3772. catch (RemoteException|RuntimeException paramString)
  3773. {
  3774. for (;;)
  3775. {
  3776. handleRadioProxyExceptionForRR(paramMessage, "sendBurstDtmf", paramString);
  3777. }
  3778. }
  3779. }
  3780.  
  3781. public void sendCDMAFeatureCode(String paramString, Message paramMessage)
  3782. {
  3783. IRadio localIRadio = getRadioProxy(paramMessage);
  3784. if (localIRadio != null)
  3785. {
  3786. paramMessage = obtainRequest(84, paramMessage, mRILDefaultWorkSource);
  3787. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " featureCode = " + paramString);
  3788. }
  3789. try
  3790. {
  3791. localIRadio.sendCDMAFeatureCode(mSerial, convertNullToEmptyString(paramString));
  3792. return;
  3793. }
  3794. catch (RemoteException|RuntimeException paramString)
  3795. {
  3796. for (;;)
  3797. {
  3798. handleRadioProxyExceptionForRR(paramMessage, "sendCDMAFeatureCode", paramString);
  3799. }
  3800. }
  3801. }
  3802.  
  3803. public void sendCdmaSms(byte[] paramArrayOfByte, Message paramMessage)
  3804. {
  3805. IRadio localIRadio = getRadioProxy(paramMessage);
  3806. CdmaSmsMessage localCdmaSmsMessage;
  3807. if (localIRadio != null)
  3808. {
  3809. paramMessage = obtainRequest(87, paramMessage, mRILDefaultWorkSource);
  3810. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3811. localCdmaSmsMessage = new CdmaSmsMessage();
  3812. constructCdmaSendSmsRilRequest(localCdmaSmsMessage, paramArrayOfByte);
  3813. }
  3814. try
  3815. {
  3816. localIRadio.sendCdmaSms(mSerial, localCdmaSmsMessage);
  3817. mMetrics.writeRilSendSms(mPhoneId.intValue(), mSerial, 2, 2);
  3818. return;
  3819. }
  3820. catch (RemoteException|RuntimeException paramArrayOfByte)
  3821. {
  3822. for (;;)
  3823. {
  3824. handleRadioProxyExceptionForRR(paramMessage, "sendCdmaSms", paramArrayOfByte);
  3825. }
  3826. }
  3827. }
  3828.  
  3829. public void sendDeviceState(int paramInt, boolean paramBoolean, Message paramMessage)
  3830. {
  3831. IRadio localIRadio = getRadioProxy(paramMessage);
  3832. if (localIRadio != null)
  3833. {
  3834. paramMessage = obtainRequest(138, paramMessage, mRILDefaultWorkSource);
  3835. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " " + paramInt + ":" + paramBoolean);
  3836. }
  3837. try
  3838. {
  3839. localIRadio.sendDeviceState(mSerial, paramInt, paramBoolean);
  3840. return;
  3841. }
  3842. catch (RemoteException|RuntimeException localRemoteException)
  3843. {
  3844. for (;;)
  3845. {
  3846. handleRadioProxyExceptionForRR(paramMessage, "sendDeviceState", localRemoteException);
  3847. }
  3848. }
  3849. }
  3850.  
  3851. public void sendDtmf(char paramChar, Message paramMessage)
  3852. {
  3853. IRadio localIRadio = getRadioProxy(paramMessage);
  3854. if (localIRadio != null)
  3855. {
  3856. paramMessage = obtainRequest(24, paramMessage, mRILDefaultWorkSource);
  3857. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3858. }
  3859. try
  3860. {
  3861. int i = mSerial;
  3862. StringBuilder localStringBuilder = new java/lang/StringBuilder;
  3863. localStringBuilder.<init>();
  3864. localIRadio.sendDtmf(i, paramChar + "");
  3865. return;
  3866. }
  3867. catch (RemoteException|RuntimeException localRemoteException)
  3868. {
  3869. for (;;)
  3870. {
  3871. handleRadioProxyExceptionForRR(paramMessage, "sendDtmf", localRemoteException);
  3872. }
  3873. }
  3874. }
  3875.  
  3876. public void sendEnvelope(String paramString, Message paramMessage)
  3877. {
  3878. IRadio localIRadio = getRadioProxy(paramMessage);
  3879. if (localIRadio != null)
  3880. {
  3881. paramMessage = obtainRequest(69, paramMessage, mRILDefaultWorkSource);
  3882. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " contents = " + paramString);
  3883. }
  3884. try
  3885. {
  3886. localIRadio.sendEnvelope(mSerial, convertNullToEmptyString(paramString));
  3887. return;
  3888. }
  3889. catch (RemoteException|RuntimeException paramString)
  3890. {
  3891. for (;;)
  3892. {
  3893. handleRadioProxyExceptionForRR(paramMessage, "sendEnvelope", paramString);
  3894. }
  3895. }
  3896. }
  3897.  
  3898. public void sendEnvelopeWithStatus(String paramString, Message paramMessage)
  3899. {
  3900. IRadio localIRadio = getRadioProxy(paramMessage);
  3901. if (localIRadio != null)
  3902. {
  3903. paramMessage = obtainRequest(107, paramMessage, mRILDefaultWorkSource);
  3904. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " contents = " + paramString);
  3905. }
  3906. try
  3907. {
  3908. localIRadio.sendEnvelopeWithStatus(mSerial, convertNullToEmptyString(paramString));
  3909. return;
  3910. }
  3911. catch (RemoteException|RuntimeException paramString)
  3912. {
  3913. for (;;)
  3914. {
  3915. handleRadioProxyExceptionForRR(paramMessage, "sendEnvelopeWithStatus", paramString);
  3916. }
  3917. }
  3918. }
  3919.  
  3920. public void sendImsCdmaSms(byte[] paramArrayOfByte, int paramInt1, int paramInt2, Message paramMessage)
  3921. {
  3922. boolean bool = true;
  3923. IRadio localIRadio = getRadioProxy(paramMessage);
  3924. ImsSmsMessage localImsSmsMessage;
  3925. if (localIRadio != null)
  3926. {
  3927. paramMessage = obtainRequest(113, paramMessage, mRILDefaultWorkSource);
  3928. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3929. localImsSmsMessage = new ImsSmsMessage();
  3930. tech = 2;
  3931. if ((byte)paramInt1 != 1) {
  3932. break label166;
  3933. }
  3934. }
  3935. for (;;)
  3936. {
  3937. retry = bool;
  3938. messageRef = paramInt2;
  3939. CdmaSmsMessage localCdmaSmsMessage = new CdmaSmsMessage();
  3940. constructCdmaSendSmsRilRequest(localCdmaSmsMessage, paramArrayOfByte);
  3941. cdmaMessage.add(localCdmaSmsMessage);
  3942. try
  3943. {
  3944. localIRadio.sendImsSms(mSerial, localImsSmsMessage);
  3945. mMetrics.writeRilSendSms(mPhoneId.intValue(), mSerial, 3, 1);
  3946. return;
  3947. label166:
  3948. bool = false;
  3949. }
  3950. catch (RemoteException|RuntimeException paramArrayOfByte)
  3951. {
  3952. for (;;)
  3953. {
  3954. handleRadioProxyExceptionForRR(paramMessage, "sendImsCdmaSms", paramArrayOfByte);
  3955. }
  3956. }
  3957. }
  3958. }
  3959.  
  3960. public void sendImsGsmSms(String paramString1, String paramString2, int paramInt1, int paramInt2, Message paramMessage)
  3961. {
  3962. boolean bool = true;
  3963. IRadio localIRadio = getRadioProxy(paramMessage);
  3964. ImsSmsMessage localImsSmsMessage;
  3965. if (localIRadio != null)
  3966. {
  3967. paramMessage = obtainRequest(113, paramMessage, mRILDefaultWorkSource);
  3968. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  3969. localImsSmsMessage = new ImsSmsMessage();
  3970. tech = 1;
  3971. if ((byte)paramInt1 != 1) {
  3972. break label157;
  3973. }
  3974. }
  3975. for (;;)
  3976. {
  3977. retry = bool;
  3978. messageRef = paramInt2;
  3979. paramString1 = constructGsmSendSmsRilRequest(paramString1, paramString2);
  3980. gsmMessage.add(paramString1);
  3981. try
  3982. {
  3983. localIRadio.sendImsSms(mSerial, localImsSmsMessage);
  3984. mMetrics.writeRilSendSms(mPhoneId.intValue(), mSerial, 3, 1);
  3985. return;
  3986. label157:
  3987. bool = false;
  3988. }
  3989. catch (RemoteException|RuntimeException paramString1)
  3990. {
  3991. for (;;)
  3992. {
  3993. handleRadioProxyExceptionForRR(paramMessage, "sendImsGsmSms", paramString1);
  3994. }
  3995. }
  3996. }
  3997. }
  3998.  
  3999. public void sendSMS(String paramString1, String paramString2, Message paramMessage)
  4000. {
  4001. IRadio localIRadio = getRadioProxy(paramMessage);
  4002. if (localIRadio != null)
  4003. {
  4004. paramMessage = obtainRequest(25, paramMessage, mRILDefaultWorkSource);
  4005. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  4006. paramString1 = constructGsmSendSmsRilRequest(paramString1, paramString2);
  4007. }
  4008. try
  4009. {
  4010. localIRadio.sendSms(mSerial, paramString1);
  4011. mMetrics.writeRilSendSms(mPhoneId.intValue(), mSerial, 1, 1);
  4012. return;
  4013. }
  4014. catch (RemoteException|RuntimeException paramString1)
  4015. {
  4016. for (;;)
  4017. {
  4018. handleRadioProxyExceptionForRR(paramMessage, "sendSMS", paramString1);
  4019. }
  4020. }
  4021. }
  4022.  
  4023. public void sendSMSExpectMore(String paramString1, String paramString2, Message paramMessage)
  4024. {
  4025. IRadio localIRadio = getRadioProxy(paramMessage);
  4026. if (localIRadio != null)
  4027. {
  4028. paramMessage = obtainRequest(26, paramMessage, mRILDefaultWorkSource);
  4029. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  4030. paramString1 = constructGsmSendSmsRilRequest(paramString1, paramString2);
  4031. }
  4032. try
  4033. {
  4034. localIRadio.sendSMSExpectMore(mSerial, paramString1);
  4035. mMetrics.writeRilSendSms(mPhoneId.intValue(), mSerial, 1, 1);
  4036. return;
  4037. }
  4038. catch (RemoteException|RuntimeException paramString1)
  4039. {
  4040. for (;;)
  4041. {
  4042. handleRadioProxyExceptionForRR(paramMessage, "sendSMSExpectMore", paramString1);
  4043. }
  4044. }
  4045. }
  4046.  
  4047. public void sendTerminalResponse(String paramString, Message paramMessage)
  4048. {
  4049. IRadio localIRadio = getRadioProxy(paramMessage);
  4050. if (localIRadio != null)
  4051. {
  4052. paramMessage = obtainRequest(70, paramMessage, mRILDefaultWorkSource);
  4053. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " contents = " + paramString);
  4054. }
  4055. try
  4056. {
  4057. localIRadio.sendTerminalResponseToSim(mSerial, convertNullToEmptyString(paramString));
  4058. return;
  4059. }
  4060. catch (RemoteException|RuntimeException paramString)
  4061. {
  4062. for (;;)
  4063. {
  4064. handleRadioProxyExceptionForRR(paramMessage, "sendTerminalResponse", paramString);
  4065. }
  4066. }
  4067. }
  4068.  
  4069. public void sendUSSD(String paramString, Message paramMessage)
  4070. {
  4071. IRadio localIRadio = getRadioProxy(paramMessage);
  4072. if (localIRadio != null)
  4073. {
  4074. paramMessage = obtainRequest(29, paramMessage, mRILDefaultWorkSource);
  4075. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " ussd = " + "*******");
  4076. }
  4077. try
  4078. {
  4079. localIRadio.sendUssd(mSerial, convertNullToEmptyString(paramString));
  4080. return;
  4081. }
  4082. catch (RemoteException|RuntimeException paramString)
  4083. {
  4084. for (;;)
  4085. {
  4086. handleRadioProxyExceptionForRR(paramMessage, "sendUSSD", paramString);
  4087. }
  4088. }
  4089. }
  4090.  
  4091. public void separateConnection(int paramInt, Message paramMessage)
  4092. {
  4093. IRadio localIRadio = getRadioProxy(paramMessage);
  4094. if (localIRadio != null)
  4095. {
  4096. paramMessage = obtainRequest(52, paramMessage, mRILDefaultWorkSource);
  4097. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " gsmIndex = " + paramInt);
  4098. }
  4099. try
  4100. {
  4101. localIRadio.separateConnection(mSerial, paramInt);
  4102. return;
  4103. }
  4104. catch (RemoteException|RuntimeException localRemoteException)
  4105. {
  4106. for (;;)
  4107. {
  4108. handleRadioProxyExceptionForRR(paramMessage, "separateConnection", localRemoteException);
  4109. }
  4110. }
  4111. }
  4112.  
  4113. public void setAllowedCarriers(List<CarrierIdentifier> paramList, Message paramMessage)
  4114. {
  4115. Preconditions.checkNotNull(paramList, "Allowed carriers list cannot be null.");
  4116. IRadio localIRadio = getRadioProxy(paramMessage);
  4117. RILRequest localRILRequest;
  4118. boolean bool;
  4119. if (localIRadio != null)
  4120. {
  4121. localRILRequest = obtainRequest(136, paramMessage, mRILDefaultWorkSource);
  4122. paramMessage = "";
  4123. for (int i = 0; i < paramList.size(); i++) {
  4124. paramMessage = paramMessage + paramList.get(i) + " ";
  4125. }
  4126. riljLog(localRILRequest.serialString() + "> " + requestToString(mRequest) + "carriers = " + paramMessage);
  4127. label165:
  4128. CarrierIdentifier localCarrierIdentifier;
  4129. Carrier localCarrier;
  4130. if (paramList.size() == 0)
  4131. {
  4132. bool = true;
  4133. paramMessage = new CarrierRestrictions();
  4134. Iterator localIterator = paramList.iterator();
  4135. if (!localIterator.hasNext()) {
  4136. break label354;
  4137. }
  4138. localCarrierIdentifier = (CarrierIdentifier)localIterator.next();
  4139. localCarrier = new Carrier();
  4140. mcc = convertNullToEmptyString(localCarrierIdentifier.getMcc());
  4141. mnc = convertNullToEmptyString(localCarrierIdentifier.getMnc());
  4142. i = 0;
  4143. paramList = null;
  4144. if (TextUtils.isEmpty(localCarrierIdentifier.getSpn())) {
  4145. break label285;
  4146. }
  4147. i = 1;
  4148. paramList = localCarrierIdentifier.getSpn();
  4149. }
  4150. for (;;)
  4151. {
  4152. matchType = i;
  4153. matchData = convertNullToEmptyString(paramList);
  4154. allowedCarriers.add(localCarrier);
  4155. break label165;
  4156. bool = false;
  4157. break;
  4158. label285:
  4159. if (!TextUtils.isEmpty(localCarrierIdentifier.getImsi()))
  4160. {
  4161. i = 2;
  4162. paramList = localCarrierIdentifier.getImsi();
  4163. }
  4164. else if (!TextUtils.isEmpty(localCarrierIdentifier.getGid1()))
  4165. {
  4166. i = 3;
  4167. paramList = localCarrierIdentifier.getGid1();
  4168. }
  4169. else if (!TextUtils.isEmpty(localCarrierIdentifier.getGid2()))
  4170. {
  4171. i = 4;
  4172. paramList = localCarrierIdentifier.getGid2();
  4173. }
  4174. }
  4175. }
  4176. try
  4177. {
  4178. label354:
  4179. localIRadio.setAllowedCarriers(mSerial, bool, paramMessage);
  4180. return;
  4181. }
  4182. catch (RemoteException|RuntimeException paramList)
  4183. {
  4184. for (;;)
  4185. {
  4186. handleRadioProxyExceptionForRR(localRILRequest, "setAllowedCarriers", paramList);
  4187. }
  4188. }
  4189. }
  4190.  
  4191. public void setBandMode(int paramInt, Message paramMessage)
  4192. {
  4193. IRadio localIRadio = getRadioProxy(paramMessage);
  4194. if (localIRadio != null)
  4195. {
  4196. paramMessage = obtainRequest(65, paramMessage, mRILDefaultWorkSource);
  4197. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " bandMode = " + paramInt);
  4198. }
  4199. try
  4200. {
  4201. localIRadio.setBandMode(mSerial, paramInt);
  4202. return;
  4203. }
  4204. catch (RemoteException|RuntimeException localRemoteException)
  4205. {
  4206. for (;;)
  4207. {
  4208. handleRadioProxyExceptionForRR(paramMessage, "setBandMode", localRemoteException);
  4209. }
  4210. }
  4211. }
  4212.  
  4213. public void setCLIR(int paramInt, Message paramMessage)
  4214. {
  4215. IRadio localIRadio = getRadioProxy(paramMessage);
  4216. if (localIRadio != null)
  4217. {
  4218. paramMessage = obtainRequest(32, paramMessage, mRILDefaultWorkSource);
  4219. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " clirMode = " + paramInt);
  4220. }
  4221. try
  4222. {
  4223. localIRadio.setClir(mSerial, paramInt);
  4224. return;
  4225. }
  4226. catch (RemoteException|RuntimeException localRemoteException)
  4227. {
  4228. for (;;)
  4229. {
  4230. handleRadioProxyExceptionForRR(paramMessage, "setCLIR", localRemoteException);
  4231. }
  4232. }
  4233. }
  4234.  
  4235. public void setCallForward(int paramInt1, int paramInt2, int paramInt3, String paramString, int paramInt4, Message paramMessage)
  4236. {
  4237. IRadio localIRadio = getRadioProxy(paramMessage);
  4238. android.hardware.radio.V1_0.CallForwardInfo localCallForwardInfo;
  4239. if (localIRadio != null)
  4240. {
  4241. paramMessage = obtainRequest(34, paramMessage, mRILDefaultWorkSource);
  4242. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " action = " + paramInt1 + " cfReason = " + paramInt2 + " serviceClass = " + paramInt3 + " timeSeconds = " + paramInt4);
  4243. localCallForwardInfo = new android.hardware.radio.V1_0.CallForwardInfo();
  4244. status = paramInt1;
  4245. reason = paramInt2;
  4246. serviceClass = paramInt3;
  4247. toa = PhoneNumberUtils.toaFromString(paramString);
  4248. number = convertNullToEmptyString(paramString);
  4249. timeSeconds = paramInt4;
  4250. }
  4251. try
  4252. {
  4253. localIRadio.setCallForward(mSerial, localCallForwardInfo);
  4254. return;
  4255. }
  4256. catch (RemoteException|RuntimeException paramString)
  4257. {
  4258. for (;;)
  4259. {
  4260. handleRadioProxyExceptionForRR(paramMessage, "setCallForward", paramString);
  4261. }
  4262. }
  4263. }
  4264.  
  4265. public void setCallWaiting(boolean paramBoolean, int paramInt, Message paramMessage)
  4266. {
  4267. IRadio localIRadio = getRadioProxy(paramMessage);
  4268. if (localIRadio != null)
  4269. {
  4270. paramMessage = obtainRequest(36, paramMessage, mRILDefaultWorkSource);
  4271. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " enable = " + paramBoolean + " serviceClass = " + paramInt);
  4272. }
  4273. try
  4274. {
  4275. localIRadio.setCallWaiting(mSerial, paramBoolean, paramInt);
  4276. return;
  4277. }
  4278. catch (RemoteException|RuntimeException localRemoteException)
  4279. {
  4280. for (;;)
  4281. {
  4282. handleRadioProxyExceptionForRR(paramMessage, "setCallWaiting", localRemoteException);
  4283. }
  4284. }
  4285. }
  4286.  
  4287. public void setCdmaBroadcastActivation(boolean paramBoolean, Message paramMessage)
  4288. {
  4289. IRadio localIRadio = getRadioProxy(paramMessage);
  4290. if (localIRadio != null)
  4291. {
  4292. paramMessage = obtainRequest(94, paramMessage, mRILDefaultWorkSource);
  4293. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " activate = " + paramBoolean);
  4294. }
  4295. try
  4296. {
  4297. localIRadio.setCdmaBroadcastActivation(mSerial, paramBoolean);
  4298. return;
  4299. }
  4300. catch (RemoteException|RuntimeException localRemoteException)
  4301. {
  4302. for (;;)
  4303. {
  4304. handleRadioProxyExceptionForRR(paramMessage, "setCdmaBroadcastActivation", localRemoteException);
  4305. }
  4306. }
  4307. }
  4308.  
  4309. public void setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] paramArrayOfCdmaSmsBroadcastConfigInfo, Message paramMessage)
  4310. {
  4311. IRadio localIRadio = getRadioProxy(paramMessage);
  4312. ArrayList localArrayList;
  4313. if (localIRadio != null)
  4314. {
  4315. paramMessage = obtainRequest(93, paramMessage, mRILDefaultWorkSource);
  4316. localArrayList = new ArrayList();
  4317. int i = 0;
  4318. int j = paramArrayOfCdmaSmsBroadcastConfigInfo.length;
  4319. while (i < j)
  4320. {
  4321. CdmaSmsBroadcastConfigInfo localCdmaSmsBroadcastConfigInfo = paramArrayOfCdmaSmsBroadcastConfigInfo[i];
  4322. for (int k = localCdmaSmsBroadcastConfigInfo.getFromServiceCategory(); k <= localCdmaSmsBroadcastConfigInfo.getToServiceCategory(); k++)
  4323. {
  4324. CdmaBroadcastSmsConfigInfo localCdmaBroadcastSmsConfigInfo = new CdmaBroadcastSmsConfigInfo();
  4325. serviceCategory = k;
  4326. language = localCdmaSmsBroadcastConfigInfo.getLanguage();
  4327. selected = localCdmaSmsBroadcastConfigInfo.isSelected();
  4328. localArrayList.add(localCdmaBroadcastSmsConfigInfo);
  4329. }
  4330. i++;
  4331. }
  4332. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " with " + localArrayList.size() + " configs : ");
  4333. paramArrayOfCdmaSmsBroadcastConfigInfo = localArrayList.iterator();
  4334. while (paramArrayOfCdmaSmsBroadcastConfigInfo.hasNext()) {
  4335. riljLog(((CdmaBroadcastSmsConfigInfo)paramArrayOfCdmaSmsBroadcastConfigInfo.next()).toString());
  4336. }
  4337. }
  4338. try
  4339. {
  4340. localIRadio.setCdmaBroadcastConfig(mSerial, localArrayList);
  4341. return;
  4342. }
  4343. catch (RemoteException|RuntimeException paramArrayOfCdmaSmsBroadcastConfigInfo)
  4344. {
  4345. for (;;)
  4346. {
  4347. handleRadioProxyExceptionForRR(paramMessage, "setCdmaBroadcastConfig", paramArrayOfCdmaSmsBroadcastConfigInfo);
  4348. }
  4349. }
  4350. }
  4351.  
  4352. public void setCdmaRoamingPreference(int paramInt, Message paramMessage)
  4353. {
  4354. IRadio localIRadio = getRadioProxy(paramMessage);
  4355. if (localIRadio != null)
  4356. {
  4357. paramMessage = obtainRequest(78, paramMessage, mRILDefaultWorkSource);
  4358. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " cdmaRoamingType = " + paramInt);
  4359. }
  4360. try
  4361. {
  4362. localIRadio.setCdmaRoamingPreference(mSerial, paramInt);
  4363. return;
  4364. }
  4365. catch (RemoteException|RuntimeException localRemoteException)
  4366. {
  4367. for (;;)
  4368. {
  4369. handleRadioProxyExceptionForRR(paramMessage, "setCdmaRoamingPreference", localRemoteException);
  4370. }
  4371. }
  4372. }
  4373.  
  4374. public void setCdmaSubscriptionSource(int paramInt, Message paramMessage)
  4375. {
  4376. IRadio localIRadio = getRadioProxy(paramMessage);
  4377. if (localIRadio != null)
  4378. {
  4379. paramMessage = obtainRequest(77, paramMessage, mRILDefaultWorkSource);
  4380. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " cdmaSubscription = " + paramInt);
  4381. }
  4382. try
  4383. {
  4384. localIRadio.setCdmaSubscriptionSource(mSerial, paramInt);
  4385. return;
  4386. }
  4387. catch (RemoteException|RuntimeException localRemoteException)
  4388. {
  4389. for (;;)
  4390. {
  4391. handleRadioProxyExceptionForRR(paramMessage, "setCdmaSubscriptionSource", localRemoteException);
  4392. }
  4393. }
  4394. }
  4395.  
  4396. void setCellInfoListRate()
  4397. {
  4398. setCellInfoListRate(Integer.MAX_VALUE, null, mRILDefaultWorkSource);
  4399. }
  4400.  
  4401. public void setCellInfoListRate(int paramInt, Message paramMessage, WorkSource paramWorkSource)
  4402. {
  4403. WorkSource localWorkSource = getDeafultWorkSourceIfInvalid(paramWorkSource);
  4404. paramWorkSource = getRadioProxy(paramMessage);
  4405. if (paramWorkSource != null)
  4406. {
  4407. paramMessage = obtainRequest(110, paramMessage, localWorkSource);
  4408. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " rateInMillis = " + paramInt);
  4409. }
  4410. try
  4411. {
  4412. paramWorkSource.setCellInfoListRate(mSerial, paramInt);
  4413. return;
  4414. }
  4415. catch (RemoteException|RuntimeException paramWorkSource)
  4416. {
  4417. for (;;)
  4418. {
  4419. handleRadioProxyExceptionForRR(paramMessage, "setCellInfoListRate", paramWorkSource);
  4420. }
  4421. }
  4422. }
  4423.  
  4424. public void setDataAllowed(boolean paramBoolean, Message paramMessage)
  4425. {
  4426. IRadio localIRadio = getRadioProxy(paramMessage);
  4427. if (localIRadio != null)
  4428. {
  4429. paramMessage = obtainRequest(123, paramMessage, mRILDefaultWorkSource);
  4430. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " allowed = " + paramBoolean);
  4431. }
  4432. try
  4433. {
  4434. localIRadio.setDataAllowed(mSerial, paramBoolean);
  4435. return;
  4436. }
  4437. catch (RemoteException|RuntimeException localRemoteException)
  4438. {
  4439. for (;;)
  4440. {
  4441. handleRadioProxyExceptionForRR(paramMessage, "setDataAllowed", localRemoteException);
  4442. }
  4443. }
  4444. }
  4445.  
  4446. public void setDataProfile(DataProfile[] paramArrayOfDataProfile, boolean paramBoolean, Message paramMessage)
  4447. {
  4448. int i = 0;
  4449. IRadio localIRadio = getRadioProxy(paramMessage);
  4450. ArrayList localArrayList;
  4451. if (localIRadio != null)
  4452. {
  4453. paramMessage = obtainRequest(128, paramMessage, mRILDefaultWorkSource);
  4454. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " with data profiles : ");
  4455. int j = paramArrayOfDataProfile.length;
  4456. for (int k = 0; k < j; k++) {
  4457. riljLog(paramArrayOfDataProfile[k].toString());
  4458. }
  4459. localArrayList = new ArrayList();
  4460. j = paramArrayOfDataProfile.length;
  4461. for (k = i; k < j; k++) {
  4462. localArrayList.add(convertToHalDataProfile(paramArrayOfDataProfile[k]));
  4463. }
  4464. }
  4465. try
  4466. {
  4467. localIRadio.setDataProfile(mSerial, localArrayList, paramBoolean);
  4468. return;
  4469. }
  4470. catch (RemoteException|RuntimeException paramArrayOfDataProfile)
  4471. {
  4472. for (;;)
  4473. {
  4474. handleRadioProxyExceptionForRR(paramMessage, "setDataProfile", paramArrayOfDataProfile);
  4475. }
  4476. }
  4477. }
  4478.  
  4479. public void setFacilityLock(String paramString1, boolean paramBoolean, String paramString2, int paramInt, Message paramMessage)
  4480. {
  4481. setFacilityLockForApp(paramString1, paramBoolean, paramString2, paramInt, null, paramMessage);
  4482. }
  4483.  
  4484. public void setFacilityLockForApp(String paramString1, boolean paramBoolean, String paramString2, int paramInt, String paramString3, Message paramMessage)
  4485. {
  4486. IRadio localIRadio = getRadioProxy(paramMessage);
  4487. if (localIRadio != null)
  4488. {
  4489. paramMessage = obtainRequest(43, paramMessage, mRILDefaultWorkSource);
  4490. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " facility = " + paramString1 + " lockstate = " + paramBoolean + " serviceClass = " + paramInt + " appId = " + paramString3);
  4491. }
  4492. try
  4493. {
  4494. localIRadio.setFacilityLockForApp(mSerial, convertNullToEmptyString(paramString1), paramBoolean, convertNullToEmptyString(paramString2), paramInt, convertNullToEmptyString(paramString3));
  4495. return;
  4496. }
  4497. catch (RemoteException|RuntimeException paramString1)
  4498. {
  4499. for (;;)
  4500. {
  4501. handleRadioProxyExceptionForRR(paramMessage, "setFacilityLockForApp", paramString1);
  4502. }
  4503. }
  4504. }
  4505.  
  4506. public void setGsmBroadcastActivation(boolean paramBoolean, Message paramMessage)
  4507. {
  4508. IRadio localIRadio = getRadioProxy(paramMessage);
  4509. if (localIRadio != null)
  4510. {
  4511. paramMessage = obtainRequest(91, paramMessage, mRILDefaultWorkSource);
  4512. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " activate = " + paramBoolean);
  4513. }
  4514. try
  4515. {
  4516. localIRadio.setGsmBroadcastActivation(mSerial, paramBoolean);
  4517. return;
  4518. }
  4519. catch (RemoteException|RuntimeException localRemoteException)
  4520. {
  4521. for (;;)
  4522. {
  4523. handleRadioProxyExceptionForRR(paramMessage, "setGsmBroadcastActivation", localRemoteException);
  4524. }
  4525. }
  4526. }
  4527.  
  4528. public void setGsmBroadcastConfig(SmsBroadcastConfigInfo[] paramArrayOfSmsBroadcastConfigInfo, Message paramMessage)
  4529. {
  4530. IRadio localIRadio = getRadioProxy(paramMessage);
  4531. ArrayList localArrayList;
  4532. if (localIRadio != null)
  4533. {
  4534. paramMessage = obtainRequest(90, paramMessage, mRILDefaultWorkSource);
  4535. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " with " + paramArrayOfSmsBroadcastConfigInfo.length + " configs : ");
  4536. for (int i = 0; i < paramArrayOfSmsBroadcastConfigInfo.length; i++) {
  4537. riljLog(paramArrayOfSmsBroadcastConfigInfo[i].toString());
  4538. }
  4539. localArrayList = new ArrayList();
  4540. int j = paramArrayOfSmsBroadcastConfigInfo.length;
  4541. for (i = 0; i < j; i++)
  4542. {
  4543. GsmBroadcastSmsConfigInfo localGsmBroadcastSmsConfigInfo = new GsmBroadcastSmsConfigInfo();
  4544. fromServiceId = paramArrayOfSmsBroadcastConfigInfo[i].getFromServiceId();
  4545. toServiceId = paramArrayOfSmsBroadcastConfigInfo[i].getToServiceId();
  4546. fromCodeScheme = paramArrayOfSmsBroadcastConfigInfo[i].getFromCodeScheme();
  4547. toCodeScheme = paramArrayOfSmsBroadcastConfigInfo[i].getToCodeScheme();
  4548. selected = paramArrayOfSmsBroadcastConfigInfo[i].isSelected();
  4549. localArrayList.add(localGsmBroadcastSmsConfigInfo);
  4550. }
  4551. }
  4552. try
  4553. {
  4554. localIRadio.setGsmBroadcastConfig(mSerial, localArrayList);
  4555. return;
  4556. }
  4557. catch (RemoteException|RuntimeException paramArrayOfSmsBroadcastConfigInfo)
  4558. {
  4559. for (;;)
  4560. {
  4561. handleRadioProxyExceptionForRR(paramMessage, "setGsmBroadcastConfig", paramArrayOfSmsBroadcastConfigInfo);
  4562. }
  4563. }
  4564. }
  4565.  
  4566. public void setInitialAttachApn(DataProfile paramDataProfile, boolean paramBoolean, Message paramMessage)
  4567. {
  4568. IRadio localIRadio = getRadioProxy(paramMessage);
  4569. if (localIRadio != null)
  4570. {
  4571. paramMessage = obtainRequest(111, paramMessage, mRILDefaultWorkSource);
  4572. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + paramDataProfile);
  4573. }
  4574. try
  4575. {
  4576. localIRadio.setInitialAttachApn(mSerial, convertToHalDataProfile(paramDataProfile), modemCognitive, paramBoolean);
  4577. return;
  4578. }
  4579. catch (RemoteException|RuntimeException paramDataProfile)
  4580. {
  4581. for (;;)
  4582. {
  4583. handleRadioProxyExceptionForRR(paramMessage, "setInitialAttachApn", paramDataProfile);
  4584. }
  4585. }
  4586. }
  4587.  
  4588. public void setLocationUpdates(boolean paramBoolean, Message paramMessage)
  4589. {
  4590. IRadio localIRadio = getRadioProxy(paramMessage);
  4591. if (localIRadio != null)
  4592. {
  4593. paramMessage = obtainRequest(76, paramMessage, mRILDefaultWorkSource);
  4594. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " enable = " + paramBoolean);
  4595. }
  4596. try
  4597. {
  4598. localIRadio.setLocationUpdates(mSerial, paramBoolean);
  4599. return;
  4600. }
  4601. catch (RemoteException|RuntimeException localRemoteException)
  4602. {
  4603. for (;;)
  4604. {
  4605. handleRadioProxyExceptionForRR(paramMessage, "setLocationUpdates", localRemoteException);
  4606. }
  4607. }
  4608. }
  4609.  
  4610. public void setMute(boolean paramBoolean, Message paramMessage)
  4611. {
  4612. IRadio localIRadio = getRadioProxy(paramMessage);
  4613. if (localIRadio != null)
  4614. {
  4615. paramMessage = obtainRequest(53, paramMessage, mRILDefaultWorkSource);
  4616. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " enableMute = " + paramBoolean);
  4617. }
  4618. try
  4619. {
  4620. localIRadio.setMute(mSerial, paramBoolean);
  4621. return;
  4622. }
  4623. catch (RemoteException|RuntimeException localRemoteException)
  4624. {
  4625. for (;;)
  4626. {
  4627. handleRadioProxyExceptionForRR(paramMessage, "setMute", localRemoteException);
  4628. }
  4629. }
  4630. }
  4631.  
  4632. public void setNetworkSelectionModeAutomatic(Message paramMessage)
  4633. {
  4634. IRadio localIRadio = getRadioProxy(paramMessage);
  4635. if (localIRadio != null)
  4636. {
  4637. paramMessage = obtainRequest(46, paramMessage, mRILDefaultWorkSource);
  4638. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  4639. }
  4640. try
  4641. {
  4642. localIRadio.setNetworkSelectionModeAutomatic(mSerial);
  4643. return;
  4644. }
  4645. catch (RemoteException|RuntimeException localRemoteException)
  4646. {
  4647. for (;;)
  4648. {
  4649. handleRadioProxyExceptionForRR(paramMessage, "setNetworkSelectionModeAutomatic", localRemoteException);
  4650. }
  4651. }
  4652. }
  4653.  
  4654. public void setNetworkSelectionModeManual(String paramString, Message paramMessage)
  4655. {
  4656. IRadio localIRadio = getRadioProxy(paramMessage);
  4657. if (localIRadio != null)
  4658. {
  4659. paramMessage = obtainRequest(47, paramMessage, mRILDefaultWorkSource);
  4660. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " operatorNumeric = " + paramString);
  4661. }
  4662. try
  4663. {
  4664. localIRadio.setNetworkSelectionModeManual(mSerial, convertNullToEmptyString(paramString));
  4665. return;
  4666. }
  4667. catch (RemoteException|RuntimeException paramString)
  4668. {
  4669. for (;;)
  4670. {
  4671. handleRadioProxyExceptionForRR(paramMessage, "setNetworkSelectionModeManual", paramString);
  4672. }
  4673. }
  4674. }
  4675.  
  4676. public void setOnNITZTime(Handler paramHandler, int paramInt, Object paramObject)
  4677. {
  4678. super.setOnNITZTime(paramHandler, paramInt, paramObject);
  4679. if (mLastNITZTimeInfo != null) {
  4680. mNITZTimeRegistrant.notifyRegistrant(new AsyncResult(null, mLastNITZTimeInfo, null));
  4681. }
  4682. }
  4683.  
  4684. public void setPhoneType(int paramInt)
  4685. {
  4686. riljLog("setPhoneType=" + paramInt + " old value=" + mPhoneType);
  4687. mPhoneType = paramInt;
  4688. }
  4689.  
  4690. public void setPreferredNetworkType(int paramInt, Message paramMessage)
  4691. {
  4692. IRadio localIRadio = getRadioProxy(paramMessage);
  4693. if (localIRadio != null)
  4694. {
  4695. paramMessage = obtainRequest(73, paramMessage, mRILDefaultWorkSource);
  4696. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " networkType = " + paramInt);
  4697. mPreferredNetworkType = paramInt;
  4698. mMetrics.writeSetPreferredNetworkType(mPhoneId.intValue(), paramInt);
  4699. }
  4700. try
  4701. {
  4702. localIRadio.setPreferredNetworkType(mSerial, paramInt);
  4703. return;
  4704. }
  4705. catch (RemoteException|RuntimeException localRemoteException)
  4706. {
  4707. for (;;)
  4708. {
  4709. handleRadioProxyExceptionForRR(paramMessage, "setPreferredNetworkType", localRemoteException);
  4710. }
  4711. }
  4712. }
  4713.  
  4714. public void setPreferredVoicePrivacy(boolean paramBoolean, Message paramMessage)
  4715. {
  4716. IRadio localIRadio = getRadioProxy(paramMessage);
  4717. if (localIRadio != null)
  4718. {
  4719. paramMessage = obtainRequest(82, paramMessage, mRILDefaultWorkSource);
  4720. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " enable = " + paramBoolean);
  4721. }
  4722. try
  4723. {
  4724. localIRadio.setPreferredVoicePrivacy(mSerial, paramBoolean);
  4725. return;
  4726. }
  4727. catch (RemoteException|RuntimeException localRemoteException)
  4728. {
  4729. for (;;)
  4730. {
  4731. handleRadioProxyExceptionForRR(paramMessage, "setPreferredVoicePrivacy", localRemoteException);
  4732. }
  4733. }
  4734. }
  4735.  
  4736. public void setRadioCapability(RadioCapability paramRadioCapability, Message paramMessage)
  4737. {
  4738. IRadio localIRadio = getRadioProxy(paramMessage);
  4739. android.hardware.radio.V1_0.RadioCapability localRadioCapability;
  4740. if (localIRadio != null)
  4741. {
  4742. paramMessage = obtainRequest(131, paramMessage, mRILDefaultWorkSource);
  4743. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " RadioCapability = " + paramRadioCapability.toString());
  4744. localRadioCapability = new android.hardware.radio.V1_0.RadioCapability();
  4745. session = paramRadioCapability.getSession();
  4746. phase = paramRadioCapability.getPhase();
  4747. raf = paramRadioCapability.getRadioAccessFamily();
  4748. logicalModemUuid = convertNullToEmptyString(paramRadioCapability.getLogicalModemUuid());
  4749. status = paramRadioCapability.getStatus();
  4750. }
  4751. try
  4752. {
  4753. localIRadio.setRadioCapability(mSerial, localRadioCapability);
  4754. return;
  4755. }
  4756. catch (Exception paramRadioCapability)
  4757. {
  4758. for (;;)
  4759. {
  4760. handleRadioProxyExceptionForRR(paramMessage, "setRadioCapability", paramRadioCapability);
  4761. }
  4762. }
  4763. }
  4764.  
  4765. public void setRadioPower(boolean paramBoolean, Message paramMessage)
  4766. {
  4767. IRadio localIRadio = getRadioProxy(paramMessage);
  4768. if (localIRadio != null)
  4769. {
  4770. paramMessage = obtainRequest(23, paramMessage, mRILDefaultWorkSource);
  4771. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " on = " + paramBoolean);
  4772. }
  4773. try
  4774. {
  4775. localIRadio.setRadioPower(mSerial, paramBoolean);
  4776. return;
  4777. }
  4778. catch (RemoteException|RuntimeException localRemoteException)
  4779. {
  4780. for (;;)
  4781. {
  4782. handleRadioProxyExceptionForRR(paramMessage, "setRadioPower", localRemoteException);
  4783. }
  4784. }
  4785. }
  4786.  
  4787. public void setSimCardPower(boolean paramBoolean, Message paramMessage)
  4788. {
  4789. IRadio localIRadio = getRadioProxy(paramMessage);
  4790. if (localIRadio != null)
  4791. {
  4792. paramMessage = obtainRequest(140, paramMessage, mRILDefaultWorkSource);
  4793. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " " + paramBoolean);
  4794. }
  4795. try
  4796. {
  4797. localIRadio.setSimCardPower(mSerial, paramBoolean);
  4798. return;
  4799. }
  4800. catch (RemoteException|RuntimeException localRemoteException)
  4801. {
  4802. for (;;)
  4803. {
  4804. handleRadioProxyExceptionForRR(paramMessage, "setSimCardPower", localRemoteException);
  4805. }
  4806. }
  4807. }
  4808.  
  4809. public void setSmscAddress(String paramString, Message paramMessage)
  4810. {
  4811. IRadio localIRadio = getRadioProxy(paramMessage);
  4812. if (localIRadio != null)
  4813. {
  4814. paramMessage = obtainRequest(101, paramMessage, mRILDefaultWorkSource);
  4815. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " address = " + paramString);
  4816. }
  4817. try
  4818. {
  4819. localIRadio.setSmscAddress(mSerial, convertNullToEmptyString(paramString));
  4820. return;
  4821. }
  4822. catch (RemoteException|RuntimeException paramString)
  4823. {
  4824. for (;;)
  4825. {
  4826. handleRadioProxyExceptionForRR(paramMessage, "setSmscAddress", paramString);
  4827. }
  4828. }
  4829. }
  4830.  
  4831. public void setSuppServiceNotifications(boolean paramBoolean, Message paramMessage)
  4832. {
  4833. IRadio localIRadio = getRadioProxy(paramMessage);
  4834. if (localIRadio != null)
  4835. {
  4836. paramMessage = obtainRequest(62, paramMessage, mRILDefaultWorkSource);
  4837. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " enable = " + paramBoolean);
  4838. }
  4839. try
  4840. {
  4841. localIRadio.setSuppServiceNotifications(mSerial, paramBoolean);
  4842. return;
  4843. }
  4844. catch (RemoteException|RuntimeException localRemoteException)
  4845. {
  4846. for (;;)
  4847. {
  4848. handleRadioProxyExceptionForRR(paramMessage, "setSuppServiceNotifications", localRemoteException);
  4849. }
  4850. }
  4851. }
  4852.  
  4853. public void setTTYMode(int paramInt, Message paramMessage)
  4854. {
  4855. IRadio localIRadio = getRadioProxy(paramMessage);
  4856. if (localIRadio != null)
  4857. {
  4858. paramMessage = obtainRequest(80, paramMessage, mRILDefaultWorkSource);
  4859. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " ttyMode = " + paramInt);
  4860. }
  4861. try
  4862. {
  4863. localIRadio.setTTYMode(mSerial, paramInt);
  4864. return;
  4865. }
  4866. catch (RemoteException|RuntimeException localRemoteException)
  4867. {
  4868. for (;;)
  4869. {
  4870. handleRadioProxyExceptionForRR(paramMessage, "setTTYMode", localRemoteException);
  4871. }
  4872. }
  4873. }
  4874.  
  4875. public void setUiccSubscription(int paramInt1, int paramInt2, int paramInt3, int paramInt4, Message paramMessage)
  4876. {
  4877. IRadio localIRadio = getRadioProxy(paramMessage);
  4878. SelectUiccSub localSelectUiccSub;
  4879. if (localIRadio != null)
  4880. {
  4881. paramMessage = obtainRequest(122, paramMessage, mRILDefaultWorkSource);
  4882. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " slot = " + paramInt1 + " appIndex = " + paramInt2 + " subId = " + paramInt3 + " subStatus = " + paramInt4);
  4883. localSelectUiccSub = new SelectUiccSub();
  4884. slot = paramInt1;
  4885. appIndex = paramInt2;
  4886. subType = paramInt3;
  4887. actStatus = paramInt4;
  4888. }
  4889. try
  4890. {
  4891. localIRadio.setUiccSubscription(mSerial, localSelectUiccSub);
  4892. return;
  4893. }
  4894. catch (RemoteException|RuntimeException localRemoteException)
  4895. {
  4896. for (;;)
  4897. {
  4898. handleRadioProxyExceptionForRR(paramMessage, "setUiccSubscription", localRemoteException);
  4899. }
  4900. }
  4901. }
  4902.  
  4903. public void setUnsolResponseFilter(int paramInt, Message paramMessage)
  4904. {
  4905. IRadio localIRadio = getRadioProxy(paramMessage);
  4906. if (localIRadio != null)
  4907. {
  4908. paramMessage = obtainRequest(139, paramMessage, mRILDefaultWorkSource);
  4909. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " " + paramInt);
  4910. }
  4911. try
  4912. {
  4913. localIRadio.setIndicationFilter(mSerial, paramInt);
  4914. return;
  4915. }
  4916. catch (RemoteException|RuntimeException localRemoteException)
  4917. {
  4918. for (;;)
  4919. {
  4920. handleRadioProxyExceptionForRR(paramMessage, "setIndicationFilter", localRemoteException);
  4921. }
  4922. }
  4923. }
  4924.  
  4925. public void setupDataCall(int paramInt, DataProfile paramDataProfile, boolean paramBoolean1, boolean paramBoolean2, Message paramMessage)
  4926. {
  4927. IRadio localIRadio = getRadioProxy(paramMessage);
  4928. DataProfileInfo localDataProfileInfo;
  4929. if (localIRadio != null)
  4930. {
  4931. paramMessage = obtainRequest(27, paramMessage, mRILDefaultWorkSource);
  4932. localDataProfileInfo = convertToHalDataProfile(paramDataProfile);
  4933. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + ",radioTechnology=" + paramInt + ",isRoaming=" + paramBoolean1 + ",allowRoaming=" + paramBoolean2 + "," + paramDataProfile);
  4934. }
  4935. try
  4936. {
  4937. localIRadio.setupDataCall(mSerial, paramInt, localDataProfileInfo, modemCognitive, paramBoolean2, paramBoolean1);
  4938. mMetrics.writeRilSetupDataCall(mPhoneId.intValue(), mSerial, paramInt, profileId, apn, authType, protocol);
  4939. return;
  4940. }
  4941. catch (RemoteException|RuntimeException paramDataProfile)
  4942. {
  4943. for (;;)
  4944. {
  4945. handleRadioProxyExceptionForRR(paramMessage, "setupDataCall", paramDataProfile);
  4946. }
  4947. }
  4948. }
  4949.  
  4950. public void startDtmf(char paramChar, Message paramMessage)
  4951. {
  4952. IRadio localIRadio = getRadioProxy(paramMessage);
  4953. if (localIRadio != null)
  4954. {
  4955. paramMessage = obtainRequest(49, paramMessage, mRILDefaultWorkSource);
  4956. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  4957. }
  4958. try
  4959. {
  4960. int i = mSerial;
  4961. StringBuilder localStringBuilder = new java/lang/StringBuilder;
  4962. localStringBuilder.<init>();
  4963. localIRadio.startDtmf(i, paramChar + "");
  4964. return;
  4965. }
  4966. catch (RemoteException|RuntimeException localRemoteException)
  4967. {
  4968. for (;;)
  4969. {
  4970. handleRadioProxyExceptionForRR(paramMessage, "startDtmf", localRemoteException);
  4971. }
  4972. }
  4973. }
  4974.  
  4975. public void startLceService(int paramInt, boolean paramBoolean, Message paramMessage)
  4976. {
  4977. IRadio localIRadio = getRadioProxy(paramMessage);
  4978. if (localIRadio != null)
  4979. {
  4980. paramMessage = obtainRequest(132, paramMessage, mRILDefaultWorkSource);
  4981. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " reportIntervalMs = " + paramInt + " pullMode = " + paramBoolean);
  4982. }
  4983. try
  4984. {
  4985. localIRadio.startLceService(mSerial, paramInt, paramBoolean);
  4986. return;
  4987. }
  4988. catch (RemoteException|RuntimeException localRemoteException)
  4989. {
  4990. for (;;)
  4991. {
  4992. handleRadioProxyExceptionForRR(paramMessage, "startLceService", localRemoteException);
  4993. }
  4994. }
  4995. }
  4996.  
  4997. public void stopDtmf(Message paramMessage)
  4998. {
  4999. IRadio localIRadio = getRadioProxy(paramMessage);
  5000. if (localIRadio != null)
  5001. {
  5002. paramMessage = obtainRequest(50, paramMessage, mRILDefaultWorkSource);
  5003. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  5004. }
  5005. try
  5006. {
  5007. localIRadio.stopDtmf(mSerial);
  5008. return;
  5009. }
  5010. catch (RemoteException|RuntimeException localRemoteException)
  5011. {
  5012. for (;;)
  5013. {
  5014. handleRadioProxyExceptionForRR(paramMessage, "stopDtmf", localRemoteException);
  5015. }
  5016. }
  5017. }
  5018.  
  5019. public void stopLceService(Message paramMessage)
  5020. {
  5021. IRadio localIRadio = getRadioProxy(paramMessage);
  5022. if (localIRadio != null)
  5023. {
  5024. paramMessage = obtainRequest(133, paramMessage, mRILDefaultWorkSource);
  5025. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  5026. }
  5027. try
  5028. {
  5029. localIRadio.stopLceService(mSerial);
  5030. return;
  5031. }
  5032. catch (RemoteException|RuntimeException localRemoteException)
  5033. {
  5034. for (;;)
  5035. {
  5036. handleRadioProxyExceptionForRR(paramMessage, "stopLceService", localRemoteException);
  5037. }
  5038. }
  5039. }
  5040.  
  5041. public void supplyIccPin(String paramString, Message paramMessage)
  5042. {
  5043. supplyIccPinForApp(paramString, null, paramMessage);
  5044. }
  5045.  
  5046. public void supplyIccPin2(String paramString, Message paramMessage)
  5047. {
  5048. supplyIccPin2ForApp(paramString, null, paramMessage);
  5049. }
  5050.  
  5051. public void supplyIccPin2ForApp(String paramString1, String paramString2, Message paramMessage)
  5052. {
  5053. IRadio localIRadio = getRadioProxy(paramMessage);
  5054. if (localIRadio != null)
  5055. {
  5056. paramMessage = obtainRequest(4, paramMessage, mRILDefaultWorkSource);
  5057. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " aid = " + paramString2);
  5058. }
  5059. try
  5060. {
  5061. localIRadio.supplyIccPin2ForApp(mSerial, convertNullToEmptyString(paramString1), convertNullToEmptyString(paramString2));
  5062. return;
  5063. }
  5064. catch (RemoteException|RuntimeException paramString1)
  5065. {
  5066. for (;;)
  5067. {
  5068. handleRadioProxyExceptionForRR(paramMessage, "supplyIccPin2ForApp", paramString1);
  5069. }
  5070. }
  5071. }
  5072.  
  5073. public void supplyIccPinForApp(String paramString1, String paramString2, Message paramMessage)
  5074. {
  5075. IRadio localIRadio = getRadioProxy(paramMessage);
  5076. if (localIRadio != null)
  5077. {
  5078. paramMessage = obtainRequest(2, paramMessage, mRILDefaultWorkSource);
  5079. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " aid = " + paramString2);
  5080. }
  5081. try
  5082. {
  5083. localIRadio.supplyIccPinForApp(mSerial, convertNullToEmptyString(paramString1), convertNullToEmptyString(paramString2));
  5084. return;
  5085. }
  5086. catch (RemoteException|RuntimeException paramString1)
  5087. {
  5088. for (;;)
  5089. {
  5090. handleRadioProxyExceptionForRR(paramMessage, "supplyIccPinForApp", paramString1);
  5091. }
  5092. }
  5093. }
  5094.  
  5095. public void supplyIccPuk(String paramString1, String paramString2, Message paramMessage)
  5096. {
  5097. supplyIccPukForApp(paramString1, paramString2, null, paramMessage);
  5098. }
  5099.  
  5100. public void supplyIccPuk2(String paramString1, String paramString2, Message paramMessage)
  5101. {
  5102. supplyIccPuk2ForApp(paramString1, paramString2, null, paramMessage);
  5103. }
  5104.  
  5105. public void supplyIccPuk2ForApp(String paramString1, String paramString2, String paramString3, Message paramMessage)
  5106. {
  5107. IRadio localIRadio = getRadioProxy(paramMessage);
  5108. if (localIRadio != null)
  5109. {
  5110. paramMessage = obtainRequest(5, paramMessage, mRILDefaultWorkSource);
  5111. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " aid = " + paramString3);
  5112. }
  5113. try
  5114. {
  5115. localIRadio.supplyIccPuk2ForApp(mSerial, convertNullToEmptyString(paramString1), convertNullToEmptyString(paramString2), convertNullToEmptyString(paramString3));
  5116. return;
  5117. }
  5118. catch (RemoteException|RuntimeException paramString1)
  5119. {
  5120. for (;;)
  5121. {
  5122. handleRadioProxyExceptionForRR(paramMessage, "supplyIccPuk2ForApp", paramString1);
  5123. }
  5124. }
  5125. }
  5126.  
  5127. public void supplyIccPukForApp(String paramString1, String paramString2, String paramString3, Message paramMessage)
  5128. {
  5129. IRadio localIRadio = getRadioProxy(paramMessage);
  5130. if (localIRadio != null)
  5131. {
  5132. paramMessage = obtainRequest(3, paramMessage, mRILDefaultWorkSource);
  5133. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " aid = " + paramString3);
  5134. }
  5135. try
  5136. {
  5137. localIRadio.supplyIccPukForApp(mSerial, convertNullToEmptyString(paramString1), convertNullToEmptyString(paramString2), convertNullToEmptyString(paramString3));
  5138. return;
  5139. }
  5140. catch (RemoteException|RuntimeException paramString1)
  5141. {
  5142. for (;;)
  5143. {
  5144. handleRadioProxyExceptionForRR(paramMessage, "supplyIccPukForApp", paramString1);
  5145. }
  5146. }
  5147. }
  5148.  
  5149. public void supplyNetworkDepersonalization(String paramString, Message paramMessage)
  5150. {
  5151. IRadio localIRadio = getRadioProxy(paramMessage);
  5152. if (localIRadio != null)
  5153. {
  5154. paramMessage = obtainRequest(8, paramMessage, mRILDefaultWorkSource);
  5155. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest) + " netpin = " + paramString);
  5156. }
  5157. try
  5158. {
  5159. localIRadio.supplyNetworkDepersonalization(mSerial, convertNullToEmptyString(paramString));
  5160. return;
  5161. }
  5162. catch (RemoteException|RuntimeException paramString)
  5163. {
  5164. for (;;)
  5165. {
  5166. handleRadioProxyExceptionForRR(paramMessage, "supplyNetworkDepersonalization", paramString);
  5167. }
  5168. }
  5169. }
  5170.  
  5171. public void switchWaitingOrHoldingAndActive(Message paramMessage)
  5172. {
  5173. IRadio localIRadio = getRadioProxy(paramMessage);
  5174. if (localIRadio != null)
  5175. {
  5176. paramMessage = obtainRequest(15, paramMessage, mRILDefaultWorkSource);
  5177. riljLog(paramMessage.serialString() + "> " + requestToString(mRequest));
  5178. }
  5179. try
  5180. {
  5181. localIRadio.switchWaitingOrHoldingAndActive(mSerial);
  5182. return;
  5183. }
  5184. catch (RemoteException|RuntimeException localRemoteException)
  5185. {
  5186. for (;;)
  5187. {
  5188. handleRadioProxyExceptionForRR(paramMessage, "switchWaitingOrHoldingAndActive", localRemoteException);
  5189. }
  5190. }
  5191. }
  5192.  
  5193. public void testingEmergencyCall()
  5194. {
  5195. riljLog("testingEmergencyCall");
  5196. mTestingEmergencyCall.set(true);
  5197. }
  5198.  
  5199. void unsljLog(int paramInt)
  5200. {
  5201. riljLog("[UNSL]< " + responseToString(paramInt));
  5202. }
  5203.  
  5204. void unsljLogMore(int paramInt, String paramString)
  5205. {
  5206. riljLog("[UNSL]< " + responseToString(paramInt) + " " + paramString);
  5207. }
  5208.  
  5209. void unsljLogRet(int paramInt, Object paramObject)
  5210. {
  5211. riljLog("[UNSL]< " + responseToString(paramInt) + " " + retToString(paramInt, paramObject));
  5212. }
  5213.  
  5214. void unsljLogvRet(int paramInt, Object paramObject)
  5215. {
  5216. riljLogv("[UNSL]< " + responseToString(paramInt) + " " + retToString(paramInt, paramObject));
  5217. }
  5218.  
  5219. void writeMetricsCallRing(char[] paramArrayOfChar)
  5220. {
  5221. mMetrics.writeRilCallRing(mPhoneId.intValue(), paramArrayOfChar);
  5222. }
  5223.  
  5224. void writeMetricsModemRestartEvent(String paramString)
  5225. {
  5226. mMetrics.writeModemRestartEvent(mPhoneId.intValue(), paramString);
  5227. }
  5228.  
  5229. void writeMetricsNewSms(int paramInt1, int paramInt2)
  5230. {
  5231. mMetrics.writeRilNewSms(mPhoneId.intValue(), paramInt1, paramInt2);
  5232. }
  5233.  
  5234. void writeMetricsSrvcc(int paramInt)
  5235. {
  5236. mMetrics.writeRilSrvcc(mPhoneId.intValue(), paramInt);
  5237. }
  5238.  
  5239. public void writeSmsToRuim(int paramInt, String paramString, Message paramMessage)
  5240. {
  5241. paramInt = translateStatus(paramInt);
  5242. IRadio localIRadio = getRadioProxy(paramMessage);
  5243. CdmaSmsWriteArgs localCdmaSmsWriteArgs;
  5244. if (localIRadio != null)
  5245. {
  5246. paramMessage = obtainRequest(96, paramMessage, mRILDefaultWorkSource);
  5247. localCdmaSmsWriteArgs = new CdmaSmsWriteArgs();
  5248. status = paramInt;
  5249. constructCdmaSendSmsRilRequest(message, IccUtils.hexStringToBytes(paramString));
  5250. }
  5251. try
  5252. {
  5253. localIRadio.writeSmsToRuim(mSerial, localCdmaSmsWriteArgs);
  5254. return;
  5255. }
  5256. catch (RemoteException|RuntimeException paramString)
  5257. {
  5258. for (;;)
  5259. {
  5260. handleRadioProxyExceptionForRR(paramMessage, "writeSmsToRuim", paramString);
  5261. }
  5262. }
  5263. }
  5264.  
  5265. public void writeSmsToSim(int paramInt, String paramString1, String paramString2, Message paramMessage)
  5266. {
  5267. paramInt = translateStatus(paramInt);
  5268. IRadio localIRadio = getRadioProxy(paramMessage);
  5269. SmsWriteArgs localSmsWriteArgs;
  5270. if (localIRadio != null)
  5271. {
  5272. paramMessage = obtainRequest(63, paramMessage, mRILDefaultWorkSource);
  5273. localSmsWriteArgs = new SmsWriteArgs();
  5274. status = paramInt;
  5275. smsc = convertNullToEmptyString(paramString1);
  5276. pdu = convertNullToEmptyString(paramString2);
  5277. }
  5278. try
  5279. {
  5280. localIRadio.writeSmsToSim(mSerial, localSmsWriteArgs);
  5281. return;
  5282. }
  5283. catch (RemoteException|RuntimeException paramString1)
  5284. {
  5285. for (;;)
  5286. {
  5287. handleRadioProxyExceptionForRR(paramMessage, "writeSmsToSim", paramString1);
  5288. }
  5289. }
  5290. }
  5291.  
  5292. final class RadioProxyDeathRecipient
  5293. implements IHwBinder.DeathRecipient
  5294. {
  5295. RadioProxyDeathRecipient() {}
  5296.  
  5297. public void serviceDied(long paramLong)
  5298. {
  5299. riljLog("serviceDied");
  5300. mRilHandler.sendMessageDelayed(mRilHandler.obtainMessage(6, Long.valueOf(paramLong)), 4000L);
  5301. }
  5302. }
  5303.  
  5304. class RilHandler
  5305. extends Handler
  5306. {
  5307. RilHandler() {}
  5308.  
  5309. public void handleMessage(Message paramMessage)
  5310. {
  5311. switch (what)
  5312. {
  5313. }
  5314. for (;;)
  5315. {
  5316. return;
  5317. int j;
  5318. synchronized (mRequestList)
  5319. {
  5320. if ((arg1 == mWlSequenceNum) && (RIL.-wrap2(RIL.this, 0)))
  5321. {
  5322. int i = mRequestList.size();
  5323. paramMessage = new java/lang/StringBuilder;
  5324. paramMessage.<init>();
  5325. Rlog.d("RILJ", "WAKE_LOCK_TIMEOUT mRequestList=" + i);
  5326. for (j = 0; j < i; j++)
  5327. {
  5328. paramMessage = (RILRequest)mRequestList.valueAt(j);
  5329. StringBuilder localStringBuilder = new java/lang/StringBuilder;
  5330. localStringBuilder.<init>();
  5331. Rlog.d("RILJ", j + ": [" + mSerial + "] " + RIL.requestToString(mRequest));
  5332. }
  5333. }
  5334. }
  5335. if (arg1 == mAckWlSequenceNum)
  5336. {
  5337. RIL.-wrap2(RIL.this, 1);
  5338. continue;
  5339. j = arg1;
  5340. paramMessage = RIL.-wrap3(RIL.this, j);
  5341. if (paramMessage != null)
  5342. {
  5343. if (mResult != null)
  5344. {
  5345. ??? = RIL.-wrap4(paramMessage);
  5346. AsyncResult.forMessage(mResult, ???, null);
  5347. mResult.sendToTarget();
  5348. RIL.-get0(RIL.this).writeOnRilTimeoutResponse(mPhoneId.intValue(), mSerial, mRequest);
  5349. }
  5350. RIL.-wrap5(RIL.this, paramMessage);
  5351. paramMessage.release();
  5352. continue;
  5353. riljLog("handleMessage: EVENT_RADIO_PROXY_DEAD cookie = " + obj + " mRadioProxyCookie = " + mRadioProxyCookie.get());
  5354. if (((Long)obj).longValue() == mRadioProxyCookie.get())
  5355. {
  5356. resetProxyAndRequestList();
  5357. RIL.-wrap0(RIL.this, null);
  5358. RIL.-wrap1(RIL.this, null);
  5359. }
  5360. }
  5361. }
  5362. }
  5363. }
  5364. }
  5365. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!