API tools faq
paste
goryn07

Untitled

goryn07
Oct 12th, 2016
549
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 429.10 KB | None | 0 0
raw download clone embed print report
  1. From 19044254448d50faed4427ae444ddc6c4717916f Mon Sep 17 00:00:00 2001
  2. From: olegsvs <oleg.texet@gmail.com>
  3. Date: Sun, 12 Jun 2016 13:19:03 -0400
  4. Subject: [PATCH] Patch for 6735 mtk
  5.  
  6. Change-Id: Ia7d89678193394b3f54aff3463d62b7909bb18fb
  7. ---
  8. .../android/internal/telephony/BaseCommands.java | 209 ++
  9. .../internal/telephony/CommandsInterface.java | 250 +++
  10. .../android/internal/telephony/HardwareConfig.java | 2 +
  11. .../com/android/internal/telephony/IccCard.java | 89 +
  12. .../android/internal/telephony/MediaTekRIL.java | 2259 ++++++++++++++++++++
  13. src/java/com/android/internal/telephony/Phone.java | 35 +
  14. .../com/android/internal/telephony/PhoneBase.java | 62 +-
  15. .../android/internal/telephony/PhoneFactory.java | 20 +
  16. .../com/android/internal/telephony/PhoneProxy.java | 23 +
  17. src/java/com/android/internal/telephony/RIL.java | 528 ++++-
  18. .../internal/telephony/ServiceStateTracker.java | 22 +
  19. .../telephony/SubscriptionInfoUpdater.java | 2 +-
  20. .../cdma/CdmaSubscriptionSourceManager.java | 2 +-
  21. .../telephony/dataconnection/ApnSetting.java | 30 +-
  22. .../telephony/dataconnection/DcTracker.java | 10 +
  23. .../telephony/dataconnection/DcTrackerBase.java | 6 +-
  24. .../android/internal/telephony/gsm/GSMPhone.java | 85 +-
  25. .../android/internal/telephony/gsm/GsmMmiCode.java | 102 +-
  26. .../telephony/gsm/GsmServiceStateTracker.java | 43 +-
  27. .../internal/telephony/imsphone/ImsPhone.java | 18 +
  28. .../imsphone/ImsPhoneCommandInterface.java | 47 +
  29. .../telephony/imsphone/ImsPhoneMmiCode.java | 21 +
  30. .../telephony/sip/SipCommandInterface.java | 47 +
  31. .../internal/telephony/test/SimulatedCommands.java | 33 +
  32. .../internal/telephony/uicc/IccCardProxy.java | 209 +-
  33. .../internal/telephony/uicc/IccConstants.java | 30 +
  34. .../internal/telephony/uicc/IccFileHandler.java | 219 +-
  35. .../internal/telephony/uicc/RuimRecords.java | 10 +-
  36. .../internal/telephony/uicc/SIMRecords.java | 10 +-
  37. .../android/internal/telephony/uicc/UiccCard.java | 107 +
  38. .../telephony/uicc/UiccCardApplication.java | 163 ++
  39. .../internal/telephony/uicc/UiccController.java | 421 +++-
  40. .../internal/telephony/uicc/UsimFileHandler.java | 7 +
  41. .../internal/telephony/EtwsNotification.java | 42 +
  42. .../com/mediatek/internal/telephony/EtwsUtils.java | 31 +
  43. .../mediatek/internal/telephony/FemtoCellInfo.aidl | 19 +
  44. .../mediatek/internal/telephony/FemtoCellInfo.java | 154 ++
  45. .../internal/telephony/ModemSwitchHandler.java | 244 +++
  46. .../internal/telephony/NetworkInfoWithAcT.aidl | 57 +
  47. .../internal/telephony/NetworkInfoWithAcT.java | 201 ++
  48. .../internal/telephony/NetworkManager.java | 101 +
  49. .../telephony/RadioCapabilitySwitchUtil.java | 310 +++
  50. .../telephony/dataconnection/FdManager.java | 421 ++++
  51. .../internal/telephony/uicc/IccCardProxyEx.java | 390 ++++
  52. .../internal/telephony/worldphone/IWorldPhone.java | 86 +
  53. .../telephony/worldphone/WorldPhoneOm.java | 912 ++++++++
  54. .../telephony/worldphone/WorldPhoneUtil.java | 246 +++
  55. .../telephony/worldphone/WorldPhoneWrapper.java | 86 +
  56. 48 files changed, 8360 insertions(+), 61 deletions(-)
  57. create mode 100644 src/java/com/android/internal/telephony/MediaTekRIL.java
  58. create mode 100644 src/java/com/mediatek/internal/telephony/EtwsNotification.java
  59. create mode 100644 src/java/com/mediatek/internal/telephony/EtwsUtils.java
  60. create mode 100755 src/java/com/mediatek/internal/telephony/FemtoCellInfo.aidl
  61. create mode 100755 src/java/com/mediatek/internal/telephony/FemtoCellInfo.java
  62. create mode 100755 src/java/com/mediatek/internal/telephony/ModemSwitchHandler.java
  63. create mode 100755 src/java/com/mediatek/internal/telephony/NetworkInfoWithAcT.aidl
  64. create mode 100755 src/java/com/mediatek/internal/telephony/NetworkInfoWithAcT.java
  65. create mode 100755 src/java/com/mediatek/internal/telephony/NetworkManager.java
  66. create mode 100755 src/java/com/mediatek/internal/telephony/RadioCapabilitySwitchUtil.java
  67. create mode 100755 src/java/com/mediatek/internal/telephony/dataconnection/FdManager.java
  68. create mode 100755 src/java/com/mediatek/internal/telephony/uicc/IccCardProxyEx.java
  69. create mode 100755 src/java/com/mediatek/internal/telephony/worldphone/IWorldPhone.java
  70. create mode 100755 src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneOm.java
  71. create mode 100755 src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneUtil.java
  72. create mode 100755 src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneWrapper.java
  73.  
  74. diff --git a/src/java/com/android/internal/telephony/BaseCommands.java b/src/java/com/android/internal/telephony/BaseCommands.java
  75. index 3b5cb4e..9d4bee8 100644
  76. --- a/src/java/com/android/internal/telephony/BaseCommands.java
  77. +++ b/src/java/com/android/internal/telephony/BaseCommands.java
  78. @@ -97,6 +97,25 @@ public abstract class BaseCommands implements CommandsInterface {
  79. protected Registrant mCatCcAlphaRegistrant;
  80. protected Registrant mSsRegistrant;
  81.  
  82. + // MTK registrants
  83. + protected RegistrantList mPhoneRatFamilyChangedRegistrants = new RegistrantList();
  84. + protected RegistrantList mSessionChangedRegistrants = new RegistrantList();
  85. + protected RegistrantList mSimMissing = new RegistrantList();
  86. + protected RegistrantList mSimRecovery = new RegistrantList();
  87. + protected RegistrantList mVirtualSimOn = new RegistrantList();
  88. + protected RegistrantList mVirtualSimOff = new RegistrantList();
  89. + protected RegistrantList mSimPlugOutRegistrants = new RegistrantList();
  90. + protected RegistrantList mSimPlugInRegistrants = new RegistrantList();
  91. + protected RegistrantList mCommonSlotNoChangedRegistrants = new RegistrantList();
  92. + protected RegistrantList mDataAllowedRegistrants = new RegistrantList();
  93. + protected RegistrantList mNeighboringInfoRegistrants = new RegistrantList();
  94. + protected RegistrantList mNetworkInfoRegistrants = new RegistrantList();
  95. + protected RegistrantList mPlmnChangeNotificationRegistrant = new RegistrantList();
  96. + protected RegistrantList mPsNetworkStateRegistrants = new RegistrantList();
  97. + protected Registrant mRegistrationSuspendedRegistrant;
  98. + // M: fast dormancy.
  99. + protected Registrant mScriResultRegistrant;
  100. +
  101. // Preferred network type received from PhoneFactory.
  102. // This is used when establishing a connection to the
  103. // vendor ril so it starts up in the correct mode.
  104. @@ -108,6 +127,12 @@ public abstract class BaseCommands implements CommandsInterface {
  105. // RIL Version
  106. protected int mRilVersion = -1;
  107.  
  108. + // MTK states
  109. + /* M: call control part start */
  110. + protected boolean mbWaitingForECFURegistrants = false;
  111. + protected Object mCfuReturnValue = null; ///* M: SS part */
  112. + /* M: call control part end */
  113. +
  114. public BaseCommands(Context context) {
  115. mContext = context; // May be null (if so we won't log statistics)
  116. }
  117. @@ -936,4 +961,188 @@ public abstract class BaseCommands implements CommandsInterface {
  118. return TelephonyManager.getLteOnGsmModeStatic();
  119. }
  120.  
  121. + // MTK additions
  122. +
  123. + //MTK-START Support Multi-Application
  124. + @Override
  125. + public void openIccApplication(int application, Message response) {
  126. + }
  127. +
  128. + @Override
  129. + public void getIccApplicationStatus(int sessionId, Message result) {
  130. + }
  131. +
  132. + @Override
  133. + public void iccIOForAppEx(int command, int fileid, String path, int p1, int p2, int p3,
  134. + String data, String pin2, String aid, int channel, Message response) {
  135. + }
  136. +
  137. + @Override
  138. + public void registerForSessionChanged(Handler h, int what, Object obj) {
  139. + Registrant r = new Registrant(h, what, obj);
  140. + mSessionChangedRegistrants.add(r);
  141. + }
  142. +
  143. + @Override
  144. + public void unregisterForSessionChanged(Handler h) {
  145. + mSessionChangedRegistrants.remove(h);
  146. + }
  147. + //MTK-END Support Multi-Application
  148. +
  149. + //MTK-START Support SIM ME lock
  150. + @Override
  151. + public void queryNetworkLock(int categrory, Message response){};
  152. +
  153. + @Override
  154. + public void setNetworkLock(int catagory, int lockop, String password,
  155. + String data_imsi, String gid1, String gid2, Message response){};
  156. + //MTK-END Support SIM ME lock
  157. +
  158. + @Override
  159. + public void doGeneralSimAuthentication(int sessionId, int mode , int tag, String param1,
  160. + String param2, Message response) {
  161. + }
  162. +
  163. + public void registerForSimMissing(Handler h, int what, Object obj) {
  164. + Registrant r = new Registrant(h, what, obj);
  165. + mSimMissing.add(r);
  166. + }
  167. + public void unregisterForSimMissing(Handler h) {
  168. + mSimMissing.remove(h);
  169. + }
  170. +
  171. + public void registerForSimRecovery(Handler h, int what, Object obj) {
  172. + Registrant r = new Registrant(h, what, obj);
  173. + mSimRecovery.add(r);
  174. + }
  175. +
  176. + public void unregisterForSimRecovery(Handler h) {
  177. + mSimRecovery.remove(h);
  178. + }
  179. +
  180. + public void registerForVirtualSimOn(Handler h, int what, Object obj) {
  181. + Registrant r = new Registrant(h, what, obj);
  182. + mVirtualSimOn.add(r);
  183. + }
  184. +
  185. + public void unregisterForVirtualSimOn(Handler h) {
  186. + mVirtualSimOn.remove(h);
  187. + }
  188. +
  189. + public void registerForVirtualSimOff(Handler h, int what, Object obj) {
  190. + Registrant r = new Registrant(h, what, obj);
  191. + mVirtualSimOff.add(r);
  192. + }
  193. +
  194. + public void unregisterForVirtualSimOff(Handler h) {
  195. + mVirtualSimOff.remove(h);
  196. + }
  197. +
  198. + public void registerForSimPlugOut(Handler h, int what, Object obj) {
  199. + Registrant r = new Registrant(h, what, obj);
  200. + mSimPlugOutRegistrants.add(r);
  201. + }
  202. +
  203. + public void unregisterForSimPlugOut(Handler h) {
  204. + mSimPlugOutRegistrants.remove(h);
  205. + }
  206. +
  207. + public void registerForSimPlugIn(Handler h, int what, Object obj) {
  208. + Registrant r = new Registrant(h, what, obj);
  209. + mSimPlugInRegistrants.add(r);
  210. + }
  211. +
  212. + public void unregisterForSimPlugIn(Handler h) {
  213. + mSimPlugInRegistrants.remove(h);
  214. + }
  215. +
  216. + public void registerForCommonSlotNoChanged(Handler h, int what, Object obj) {
  217. + Registrant r = new Registrant(h, what, obj);
  218. + mCommonSlotNoChangedRegistrants.add(r);
  219. + }
  220. +
  221. + public void unregisterForCommonSlotNoChanged(Handler h) {
  222. + mCommonSlotNoChangedRegistrants.remove(h);
  223. + }
  224. +
  225. + public void registerForPsNetworkStateChanged(Handler h, int what, Object obj) {
  226. + Registrant r = new Registrant(h, what, obj);
  227. +
  228. + mPsNetworkStateRegistrants.add(r);
  229. + }
  230. +
  231. + public void unregisterForPsNetworkStateChanged(Handler h) {
  232. + mPsNetworkStateRegistrants.remove(h);
  233. + }
  234. +
  235. + public void registerForNeighboringInfo(Handler h, int what, Object obj) {
  236. + Registrant r = new Registrant(h, what, obj);
  237. + mNeighboringInfoRegistrants.add(r);
  238. + }
  239. +
  240. + public void unregisterForNeighboringInfo(Handler h) {
  241. + mNeighboringInfoRegistrants.remove(h);
  242. + }
  243. +
  244. + public void registerForNetworkInfo(Handler h, int what, Object obj) {
  245. + Registrant r = new Registrant(h, what, obj);
  246. + mNetworkInfoRegistrants.add(r);
  247. + }
  248. +
  249. + public void unregisterForNetworkInfo(Handler h) {
  250. + mNetworkInfoRegistrants.remove(h);
  251. + }
  252. +
  253. + public void setTrm(int mode, Message result) {}
  254. +
  255. + public void setOnPlmnChangeNotification(Handler h, int what, Object obj) {
  256. + Registrant r = new Registrant(h, what, obj);
  257. + mPlmnChangeNotificationRegistrant.add(r);
  258. + }
  259. +
  260. + public void unSetOnPlmnChangeNotification(Handler h) {
  261. + mPlmnChangeNotificationRegistrant.remove(h);
  262. + }
  263. +
  264. + public void setOnRegistrationSuspended(Handler h, int what, Object obj) {
  265. + mRegistrationSuspendedRegistrant = new Registrant(h, what, obj);
  266. + }
  267. +
  268. + public void unSetOnRegistrationSuspended(Handler h) {
  269. + mRegistrationSuspendedRegistrant.clear();
  270. + }
  271. +
  272. + @Override
  273. + public void setPhoneRatFamily(int ratFamily, Message response) {
  274. + }
  275. +
  276. + @Override
  277. + public void getPhoneRatFamily(Message response) {
  278. + }
  279. +
  280. + @Override
  281. + public void registerForPhoneRatFamilyChanged(Handler h, int what, Object obj) {
  282. + Registrant r = new Registrant(h, what, obj);
  283. + mPhoneRatFamilyChangedRegistrants.add(r);
  284. + }
  285. +
  286. + @Override
  287. + public void unregisterForPhoneRatFamilyChanged(Handler h) {
  288. + mPhoneRatFamilyChangedRegistrants.remove(h);
  289. + }
  290. +
  291. + // M: fast dormancy
  292. + public void setScriResult(Handler h, int what, Object obj) {
  293. + mScriResultRegistrant = new Registrant(h, what, obj);
  294. + }
  295. +
  296. + public void unSetScriResult(Handler h) {
  297. + mScriResultRegistrant.clear();
  298. + }
  299. +
  300. + public void setScri(boolean forceRelease, Message response){
  301. + }
  302. +
  303. + public void setFDMode(int mode, int parameter1, int parameter2, Message response){
  304. + }
  305. }
  306. diff --git a/src/java/com/android/internal/telephony/CommandsInterface.java b/src/java/com/android/internal/telephony/CommandsInterface.java
  307. index 89e30ae..dfa968e 100644
  308. --- a/src/java/com/android/internal/telephony/CommandsInterface.java
  309. +++ b/src/java/com/android/internal/telephony/CommandsInterface.java
  310. @@ -102,6 +102,15 @@ public interface CommandsInterface {
  311. static final int USSD_MODE_NOT_SUPPORTED = 4;
  312. static final int USSD_MODE_NW_TIMEOUT = 5;
  313.  
  314. + /* M: SS part */
  315. + //MTK-START [mtk04070][111118][ALPS00093395]MTK added
  316. + static final int USSD_SESSION_END = 2;
  317. + static final int USSD_HANDLED_BY_STK = 3;
  318. + static final int USSD_OPERATION_NOT_SUPPORTED = 4;
  319. + static final int USSD_NETWORK_TIMEOUT = 5;
  320. + //MTK-END [mtk04070][111118][ALPS00093395]MTK added
  321. + /* M: SS part end */
  322. +
  323. // GSM SMS fail cause for acknowledgeLastIncomingSMS. From TS 23.040, 9.2.3.22.
  324. static final int GSM_SMS_FAIL_CAUSE_MEMORY_CAPACITY_EXCEEDED = 0xD3;
  325. static final int GSM_SMS_FAIL_CAUSE_USIM_APP_TOOLKIT_BUSY = 0xD4;
  326. @@ -114,6 +123,19 @@ public interface CommandsInterface {
  327. static final int CDMA_SMS_FAIL_CAUSE_OTHER_TERMINAL_PROBLEM = 39;
  328. static final int CDMA_SMS_FAIL_CAUSE_ENCODING_PROBLEM = 96;
  329.  
  330. + //MTK AT CMD +ESMLCK
  331. + static final int CAT_NETWOEK = 0;
  332. + static final int CAT_NETOWRK_SUBSET = 1;
  333. + static final int CAT_SERVICE_PROVIDER = 2;
  334. + static final int CAT_CORPORATE = 3;
  335. + static final int CAT_SIM = 4;
  336. +
  337. + static final int OP_UNLOCK = 0;
  338. + static final int OP_LOCK = 1;
  339. + static final int OP_ADD = 2;
  340. + static final int OP_REMOVE = 3;
  341. + static final int OP_PERMANENT_UNLOCK = 4;
  342. +
  343. //***** Methods
  344. RadioState getRadioState();
  345.  
  346. @@ -2018,4 +2040,232 @@ public interface CommandsInterface {
  347. */
  348. void setOnCatSendSmsResult(Handler h, int what, Object obj);
  349. void unSetOnCatSendSmsResult(Handler h);
  350. +
  351. + // MTK additions
  352. +
  353. + //MTK-START multiple application support
  354. + /**
  355. + * M: Open application in the UICC
  356. + *
  357. + * @param application: application ID
  358. + * @param response The message to send.
  359. + */
  360. + public void openIccApplication(int application, Message response);
  361. +
  362. + /**
  363. + * Query application status
  364. + *
  365. + * @param sessionId: The channel ID
  366. + * @param response The message to send.
  367. + */
  368. + public void getIccApplicationStatus(int sessionId, Message result);
  369. +
  370. + /**
  371. + * parameters equivalent to 27.007 AT+CRLA command
  372. + * channel is used to assign which application to get EF file.
  373. + * response.obj will be an AsyncResult
  374. + * response.obj.userObj will be a IccIoResult on success
  375. + */
  376. + void iccIOForAppEx(int command, int fileid, String path, int p1, int p2, int p3,
  377. + String data, String pin2, String aid, int channel, Message response);
  378. +
  379. + /**
  380. + * Register the handler for event notifications for sessionid of an application changed event.
  381. + *
  382. + * @param h Handler for notification message.
  383. + * @param what User-defined message code.
  384. + * @param obj User object.
  385. + */
  386. + void registerForSessionChanged(Handler h, int what, Object obj);
  387. +
  388. + /**
  389. + * Unregister the handler for event notifications for sessionid of an application changed event.
  390. + *
  391. + * @param h Handler for notification message.
  392. + */
  393. + void unregisterForSessionChanged(Handler h);
  394. + //MTK-END multiple application support
  395. +
  396. + /**
  397. + * Query network lock status according to indicated category.
  398. + *
  399. + * @param categrory network lock category
  400. + * 0 for Network personalisation category
  401. + * 1 for Network subset personalisation category
  402. + * 2 for Service provider personalisation category
  403. + * 3 for Corporate(GID) personalisation category
  404. + * 4 for SIM/USIM(IMSI) personalisation category
  405. + * @param response Callback message containing response structure.
  406. + */
  407. + void queryNetworkLock(int categrory, Message response);
  408. +
  409. + /**
  410. + * Query network lock status according to indicated category.
  411. + *
  412. + * @param categrory network lock category
  413. + * "0" for Network personalisation category
  414. + * "1" for Network subset personalisation category
  415. + * "2" for Service provider personalisation category
  416. + * "3" for Corporate(GID) personalisation category
  417. + * "4" for SIM/USIM(IMSI) personalisation category
  418. + * @param lockop lock operation
  419. + * "0" for unlock opreation
  420. + * "1" for lock opreation
  421. + * "2" for add lock opreation
  422. + * "3" for remove lock opreation
  423. + * "4" for disable lock category opreation
  424. + * @param password password of indicated network lock
  425. + * @param data_imsi IMSI value used to setup lock
  426. + * @param gid1 GID1 value used to setup lock
  427. + * @param gid2 GID2 value used to setup lock
  428. + * @param response Callback message containing response structure.
  429. + */
  430. + void setNetworkLock(int catagory, int lockop, String password,
  431. + String data_imsi, String gid1, String gid2, Message response);
  432. +
  433. +
  434. + /**
  435. + * Request security context authentication for SIM/USIM/ISIM
  436. + */
  437. + public void doGeneralSimAuthentication(int sessionId, int mode , int tag, String param1,
  438. + String param2, Message response);
  439. +
  440. + void iccGetATR(Message result);
  441. + void iccOpenChannelWithSw(String AID, Message result);
  442. +
  443. + void registerForSimMissing(Handler h, int what, Object obj);
  444. + void unregisterForSimMissing(Handler h);
  445. +
  446. + void registerForSimRecovery(Handler h, int what, Object obj);
  447. + void unregisterForSimRecovery(Handler h);
  448. +
  449. + public void registerForVirtualSimOn(Handler h, int what, Object obj);
  450. + public void unregisterForVirtualSimOn(Handler h);
  451. +
  452. + public void registerForVirtualSimOff(Handler h, int what, Object obj);
  453. + public void unregisterForVirtualSimOff(Handler h);
  454. +
  455. + /**
  456. + * Sets the handler for event notifications for SIM plug-out event.
  457. + *
  458. + * @param h Handler for notification message.
  459. + * @param what User-defined message code.
  460. + * @param obj User object.
  461. + */
  462. + void registerForSimPlugOut(Handler h, int what, Object obj);
  463. +
  464. + /**
  465. + * Unregister the handler for event notifications for SIM plug-out event.
  466. + *
  467. + * @param h Handler for notification message.
  468. + */
  469. + void unregisterForSimPlugOut(Handler h);
  470. +
  471. + /**
  472. + * Sets the handler for event notifications for SIM plug-in event.
  473. + *
  474. + * @param h Handler for notification message.
  475. + * @param what User-defined message code.
  476. + * @param obj User object.
  477. + */
  478. + void registerForSimPlugIn(Handler h, int what, Object obj);
  479. +
  480. + /**
  481. + * Unregister the handler for event notifications for SIM plug-in event.
  482. + *
  483. + * @param h Handler for notification message.
  484. + */
  485. + void unregisterForSimPlugIn(Handler h);
  486. +
  487. + /**
  488. + * Sets the handler for event notifications for SIM common slot no changed.
  489. + *
  490. + */
  491. + void registerForCommonSlotNoChanged(Handler h, int what, Object obj);
  492. +
  493. + /**
  494. + * Unregister the handler for event notifications for SIM common slot no changed.
  495. + *
  496. + */
  497. + void unregisterForCommonSlotNoChanged(Handler h);
  498. +
  499. + void registerForPsNetworkStateChanged(Handler h, int what, Object obj);
  500. + void unregisterForPsNetworkStateChanged(Handler h);
  501. +
  502. + /**
  503. + * unlike the register* methods, there's only one Neighboring cell info handler
  504. + *
  505. + * AsyncResult.result is an Object[]
  506. + * ((Object[])AsyncResult.result)[0] is a String containing the RAT
  507. + * ((Object[])AsyncResult.result)[1] is a String containing the neighboring cell info raw data
  508. + *
  509. + * Please note that the delivery of this message may be delayed several
  510. + * seconds on system startup
  511. + */
  512. + void registerForNeighboringInfo(Handler h, int what, Object obj);
  513. + void unregisterForNeighboringInfo(Handler h);
  514. +
  515. + /**
  516. + * unlike the register* methods, there's only one Network info handler
  517. + *
  518. + * AsyncResult.result is an Object[]
  519. + * ((Object[])AsyncResult.result)[0] is a String containing the type
  520. + * ((Object[])AsyncResult.result)[1] is a String contain the network info raw data
  521. + *
  522. + * Please note that the delivery of this message may be delayed several
  523. + * seconds on system startup
  524. + */
  525. + void registerForNetworkInfo(Handler h, int what, Object obj);
  526. + void unregisterForNetworkInfo(Handler h);
  527. +
  528. + void setTrm(int mode, Message result);
  529. +
  530. + void setOnPlmnChangeNotification(Handler h, int what, Object obj);
  531. + void unSetOnPlmnChangeNotification(Handler h);
  532. + void setOnRegistrationSuspended(Handler h, int what, Object obj);
  533. + void unSetOnRegistrationSuspended(Handler h);
  534. + void setResumeRegistration(int sessionId, Message response);
  535. + void storeModemType(int modemType, Message response);
  536. + void queryModemType(Message response);
  537. +
  538. + /**
  539. + * Set phone RAT family.
  540. + *
  541. + * @param ratFamily bit mask to identify PhoneRatFamily.PHONE_RAT_FAMILY_2G,
  542. + * PhoneRatFamily.PHONE_RAT_FAMILY_3G, PhoneRatFamily.PHONE_RAT_FAMILY_4G
  543. + * @param result Callback message.
  544. + */
  545. + public void setPhoneRatFamily(int ratFamily, Message result);
  546. +
  547. + /**
  548. + * Get phone RAT family.
  549. + *
  550. + * @param result Callback message.
  551. + */
  552. + public void getPhoneRatFamily(Message result);
  553. +
  554. + /**
  555. + * Registers the handler when phone RAT family is changed.
  556. + *
  557. + * @param h Handler for notification message.
  558. + * @param what User-defined message code.
  559. + * @param obj User object.
  560. + */
  561. + public void registerForPhoneRatFamilyChanged(Handler h, int what, Object obj);
  562. +
  563. + /**
  564. + * Unregister for notifications when phone RAT family is changed.
  565. + *
  566. + * @param h Handler to be removed from the registrant list.
  567. + */
  568. + public void unregisterForPhoneRatFamilyChanged(Handler h);
  569. +
  570. + public void setInitialAttachApn(String apn, String protocol, int authType, String username,
  571. + String password, String operatorNumeric, boolean canHandleIms, Message result);
  572. +
  573. + // Fast Dormancy
  574. + void setScri(boolean forceRelease, Message response);
  575. + void setFDMode(int mode, int parameter1, int parameter2, Message response);
  576. + public void setScriResult(Handler h, int what, Object obj);
  577. + public void unSetScriResult(Handler h);
  578. }
  579. diff --git a/src/java/com/android/internal/telephony/HardwareConfig.java b/src/java/com/android/internal/telephony/HardwareConfig.java
  580. index 0f855de..9a35a01 100644
  581. --- a/src/java/com/android/internal/telephony/HardwareConfig.java
  582. +++ b/src/java/com/android/internal/telephony/HardwareConfig.java
  583. @@ -161,6 +161,7 @@ public class HardwareConfig {
  584. maxActiveVoiceCall = maxV;
  585. maxActiveDataCall = maxD;
  586. maxStandby = maxS;
  587. + Rlog.d(LOG_TAG, "assignModem: result=" + this.toString());
  588. }
  589. }
  590.  
  591. @@ -169,6 +170,7 @@ public class HardwareConfig {
  592. uuid = id;
  593. modemUuid = link;
  594. state = state;
  595. + Rlog.d(LOG_TAG, "assignSim: result=" + this.toString());
  596. }
  597. }
  598.  
  599. diff --git a/src/java/com/android/internal/telephony/IccCard.java b/src/java/com/android/internal/telephony/IccCard.java
  600. index 7d182be..6e1d35b 100644
  601. --- a/src/java/com/android/internal/telephony/IccCard.java
  602. +++ b/src/java/com/android/internal/telephony/IccCard.java
  603. @@ -21,6 +21,7 @@ import android.os.Message;
  604.  
  605. import com.android.internal.telephony.IccCardConstants.State;
  606. import com.android.internal.telephony.uicc.IccCardApplicationStatus;
  607. +import com.android.internal.telephony.uicc.IccCardApplicationStatus.PersoSubState;
  608. import com.android.internal.telephony.uicc.IccFileHandler;
  609. import com.android.internal.telephony.uicc.IccRecords;
  610.  
  611. @@ -231,4 +232,92 @@ public interface IccCard {
  612. * @return true if ICC card is PUK2 blocked
  613. */
  614. public boolean getIccPuk2Blocked();
  615. +
  616. + // MTK additions
  617. +
  618. + // Added by M begin
  619. + /**
  620. + * Use to query the network lock type.
  621. + *
  622. + * @return the network lock type define in IccCardApplicationStatus.PersoSubState
  623. + *
  624. + * @internal
  625. + */
  626. + public PersoSubState getNetworkPersoType();
  627. +
  628. + /**
  629. + * Use to query indicated category's ME lock status
  630. + *
  631. + * @param category 0:Network, 1:Network subset, 2:Service Provider, 3: Corporate, 4:SIM
  632. + * @param onComplete
  633. + * onComplete.obj will be an AsyncResult
  634. + * ((AsyncResult)onComplete.obj).exception == null on success
  635. + * ((AsyncResult)onComplete.obj).exception != null on fail
  636. + *
  637. + * @return the network lock type define in IccCardApplicationStatus.PersoSubState
  638. + *
  639. + * @internal
  640. + */
  641. + public void queryIccNetworkLock(int category, Message onComplete);
  642. +
  643. + /**
  644. + * Use to set indicated category's ME lock status
  645. + *
  646. + * @param category 0:Network, 1:Network subset, 2:Service Provider, 3: Corporate, 4:SIM
  647. + * @param lockop 0: Unlock, 1: Lock, 2:Add, 3:Remove, 4:Permanently unlock
  648. + * @param password password of indicated category lock
  649. + * @param data_imsi IMSI
  650. + * @param gid1 GID1 value
  651. + * @param gid2 GID2 value
  652. + * @param onComplete
  653. + * onComplete.obj will be an AsyncResult
  654. + * ((AsyncResult)onComplete.obj).exception == null on success
  655. + * ((AsyncResult)onComplete.obj).exception != null on fail
  656. + *
  657. + * @return the network lock type define in IccCardApplicationStatus.PersoSubState
  658. + *
  659. + * @internal
  660. + */
  661. + public void setIccNetworkLockEnabled(int category,
  662. + int lockop, String password, String data_imsi, String gid1, String gid2, Message onComplete);
  663. +
  664. + /**
  665. + * Use to repolling icc card status (Used by SIM ME lock related enhancement feature)
  666. + *
  667. + * @param needIntent indicated need an Intent to notify needed to unlock another SIM or not.
  668. + * if yes, will broadcast TelephonyIntents.ACTION_UNLOCK_SIM_LOCK to notify.
  669. + * if no, will notify by original TelephonyIntents.ACTION_SIM_STATE_CHANGED.
  670. + */
  671. + public void repollIccStateForModemSmlChangeFeatrue(boolean needIntent);
  672. +
  673. + /**
  674. + * NFC API, use to exchange SIM IO.
  675. + *
  676. + * @internal
  677. + */
  678. + public void exchangeSimIo(int fileID, int command,
  679. + int p1, int p2, int p3, String pathID, String data, String pin2, Message onComplete);
  680. +
  681. + /**
  682. + * NFC API, use to get ATR.
  683. + *
  684. + * @internal
  685. + */
  686. + public void iccGetAtr(Message onComplete);
  687. +
  688. + public String getIccCardType();
  689. +
  690. + /**
  691. + * NFC API, use to open logical channel with sw.
  692. + *
  693. + * @internal
  694. + */
  695. + public void openLogicalChannelWithSw(String AID, Message onComplete);
  696. + /**
  697. + * Notifies handler in case of FDN changed
  698. + */
  699. + public void registerForFdnChanged(Handler h, int what, Object obj);
  700. + public void unregisterForFdnChanged(Handler h);
  701. +
  702. + // Added by M end
  703. }
  704. diff --git a/src/java/com/android/internal/telephony/MediaTekRIL.java b/src/java/com/android/internal/telephony/MediaTekRIL.java
  705. new file mode 100644
  706. index 0000000..947fc3f
  707. --- /dev/null
  708. +++ b/src/java/com/android/internal/telephony/MediaTekRIL.java
  709. @@ -0,0 +1,2259 @@
  710. +/*
  711. + * Copyright (C) 2014 The OmniROM Project <http://www.omnirom.org>
  712. + *
  713. + * Licensed under the Apache License, Version 2.0 (the "License");
  714. + * you may not use this file except in compliance with the License.
  715. + * You may obtain a copy of the License at
  716. + *
  717. + * http://www.apache.org/licenses/LICENSE-2.0
  718. + *
  719. + * Unless required by applicable law or agreed to in writing, software
  720. + * distributed under the License is distributed on an "AS IS" BASIS,
  721. + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  722. + * See the License for the specific language governing permissions and
  723. + * limitations under the License.
  724. + */
  725. +
  726. +package com.android.internal.telephony;
  727. +
  728. +import static com.android.internal.telephony.RILConstants.*;
  729. +
  730. +import android.content.Context;
  731. +import android.net.LocalSocket;
  732. +import android.net.LocalSocketAddress;
  733. +import android.os.AsyncResult;
  734. +import android.os.HandlerThread;
  735. +import android.os.Looper;
  736. +import android.os.Message;
  737. +import android.os.Parcel;
  738. +import android.os.SystemProperties;
  739. +import android.text.TextUtils;
  740. +import android.telephony.PhoneNumberUtils;
  741. +import android.telephony.PhoneRatFamily;
  742. +import android.telephony.Rlog;
  743. +import android.telephony.SignalStrength;
  744. +
  745. +import java.io.UnsupportedEncodingException;
  746. +import java.util.ArrayList;
  747. +import java.util.Vector;
  748. +
  749. +import java.io.IOException;
  750. +import java.io.InputStream;
  751. +
  752. +import com.android.internal.telephony.uicc.IccRecords;
  753. +import com.android.internal.telephony.uicc.UiccController;
  754. +
  755. +public class MediaTekRIL extends RIL implements CommandsInterface {
  756. +
  757. + // TODO: Support multiSIM
  758. + // Sim IDs are 0 / 1
  759. + int mSimId = 0;
  760. +
  761. + /* ALPS00799783: for restore previous preferred network type when set type fail */
  762. + private int mPreviousPreferredType = -1;
  763. +
  764. + /* M: call control part start */
  765. + /* DTMF request will be ignored when duplicated sending */
  766. + private class dtmfQueueHandler {
  767. +
  768. + public dtmfQueueHandler() {
  769. + mDtmfStatus = DTMF_STATUS_STOP;
  770. + }
  771. +
  772. + public void start() {
  773. + mDtmfStatus = DTMF_STATUS_START;
  774. + }
  775. +
  776. + public void stop() {
  777. + mDtmfStatus = DTMF_STATUS_STOP;
  778. + }
  779. +
  780. + public boolean isStart() {
  781. + return (mDtmfStatus == DTMF_STATUS_START);
  782. + }
  783. +
  784. + public void add(RILRequest o) {
  785. + mDtmfQueue.addElement(o);
  786. + }
  787. +
  788. + public void remove(RILRequest o) {
  789. + mDtmfQueue.remove(o);
  790. + }
  791. +
  792. + public void remove(int idx) {
  793. + mDtmfQueue.removeElementAt(idx);
  794. + }
  795. +
  796. + public RILRequest get() {
  797. + return (RILRequest) mDtmfQueue.get(0);
  798. + }
  799. +
  800. + public int size() {
  801. + return mDtmfQueue.size();
  802. + }
  803. +
  804. + public void setPendingRequest(RILRequest r) {
  805. + mPendingCHLDRequest = r;
  806. + }
  807. +
  808. + public RILRequest getPendingRequest() {
  809. + return mPendingCHLDRequest;
  810. + }
  811. +
  812. + public void setSendChldRequest() {
  813. + mIsSendChldRequest = true;
  814. + }
  815. +
  816. + public void resetSendChldRequest() {
  817. + mIsSendChldRequest = false;
  818. + }
  819. +
  820. + public boolean hasSendChldRequest() {
  821. + riljLog("mIsSendChldRequest = " + mIsSendChldRequest);
  822. + return mIsSendChldRequest;
  823. + }
  824. +
  825. + public final int MAXIMUM_DTMF_REQUEST = 32;
  826. + private final boolean DTMF_STATUS_START = true;
  827. + private final boolean DTMF_STATUS_STOP = false;
  828. +
  829. + private boolean mDtmfStatus = DTMF_STATUS_STOP;
  830. + private Vector mDtmfQueue = new Vector(MAXIMUM_DTMF_REQUEST);
  831. +
  832. + private RILRequest mPendingCHLDRequest = null;
  833. + private boolean mIsSendChldRequest = false;
  834. + }
  835. +
  836. + private dtmfQueueHandler mDtmfReqQueue = new dtmfQueueHandler();
  837. + /* M: call control part end */
  838. +
  839. + public MediaTekRIL(Context context, int networkMode, int cdmaSubscription) {
  840. + super(context, networkMode, cdmaSubscription, null);
  841. + }
  842. +
  843. + public MediaTekRIL(Context context, int networkMode, int cdmaSubscription, Integer instanceId) {
  844. + super(context, networkMode, cdmaSubscription, instanceId);
  845. + }
  846. +
  847. + public static byte[] hexStringToBytes(String s) {
  848. + byte[] ret;
  849. +
  850. + if (s == null) return null;
  851. +
  852. + int len = s.length();
  853. + ret = new byte[len/2];
  854. +
  855. + for (int i=0 ; i <len ; i+=2) {
  856. + ret[i/2] = (byte) ((hexCharToInt(s.charAt(i)) << 4)
  857. + | hexCharToInt(s.charAt(i+1)));
  858. + }
  859. +
  860. + return ret;
  861. + }
  862. +
  863. + static int hexCharToInt(char c) {
  864. + if (c >= '0' && c <= '9') return (c - '0');
  865. + if (c >= 'A' && c <= 'F') return (c - 'A' + 10);
  866. + if (c >= 'a' && c <= 'f') return (c - 'a' + 10);
  867. +
  868. + throw new RuntimeException ("invalid hex char '" + c + "'");
  869. + }
  870. +
  871. + protected Object
  872. + responseOperatorInfos(Parcel p) {
  873. + if (mInstanceId == null || mInstanceId == 0) {
  874. + mSimId = 0;
  875. + } else {
  876. + mSimId = mInstanceId;
  877. + }
  878. +
  879. + String strings[] = (String [])responseStrings(p);
  880. + ArrayList<OperatorInfo> ret;
  881. +
  882. + if (strings.length % 4 != 0) {
  883. + throw new RuntimeException(
  884. + "RIL_REQUEST_QUERY_AVAILABLE_NETWORKS: invalid response. Got "
  885. + + strings.length + " strings, expected multiples of 4");
  886. + }
  887. +
  888. + String lacStr = SystemProperties.get("gsm.cops.lac");
  889. + boolean lacValid = false;
  890. + int lacIndex=0;
  891. +
  892. + Rlog.d(RILJ_LOG_TAG, "lacStr = " + lacStr+" lacStr.length="+lacStr.length()+" strings.length="+strings.length);
  893. + if((lacStr.length() > 0) && (lacStr.length()%4 == 0) && ((lacStr.length()/4) == (strings.length/5 ))){
  894. + Rlog.d(RILJ_LOG_TAG, "lacValid set to true");
  895. + lacValid = true;
  896. + }
  897. +
  898. + SystemProperties.set("gsm.cops.lac","");
  899. +
  900. + ret = new ArrayList<OperatorInfo>(strings.length / 4);
  901. +
  902. + for (int i = 0 ; i < strings.length ; i += 4) {
  903. + if((strings[i+0] != null) && (strings[i+0].startsWith("uCs2") == true)) {
  904. + riljLog("responseOperatorInfos handling UCS2 format name");
  905. +
  906. + try {
  907. + strings[i+0] = new String(hexStringToBytes(strings[i+0].substring(4)), "UTF-16");
  908. + } catch(UnsupportedEncodingException ex) {
  909. + riljLog("responseOperatorInfos UnsupportedEncodingException");
  910. + }
  911. + }
  912. +
  913. + if ((lacValid == true) && (strings[i] != null)) {
  914. + UiccController uiccController = UiccController.getInstance();
  915. + IccRecords iccRecords = uiccController.getIccRecords(mSimId, UiccController.APP_FAM_3GPP);
  916. + int lacValue = -1;
  917. + String sEons = null;
  918. + String lac = lacStr.substring(lacIndex,lacIndex+4);
  919. + Rlog.d(RILJ_LOG_TAG, "lacIndex="+lacIndex+" lacValue="+lacValue+" lac="+lac+" plmn numeric="+strings[i+2]+" plmn name"+strings[i+0]);
  920. +
  921. + if(lac != "") {
  922. + lacValue = Integer.parseInt(lac, 16);
  923. + lacIndex += 4;
  924. + if(lacValue != 0xfffe) {
  925. + /*sEons = iccRecords.getEonsIfExist(strings[i+2],lacValue,true);
  926. + if(sEons != null) {
  927. + strings[i] = sEons;
  928. + Rlog.d(RILJ_LOG_TAG, "plmn name update to Eons: "+strings[i]);
  929. + }*/
  930. + } else {
  931. + Rlog.d(RILJ_LOG_TAG, "invalid lac ignored");
  932. + }
  933. + }
  934. + }
  935. +
  936. + if (strings[i] != null && (strings[i].equals("") || strings[i].equals(strings[i+2]))) {
  937. + Operators init = new Operators ();
  938. + String temp = init.unOptimizedOperatorReplace(strings[i+2]);
  939. + riljLog("lookup RIL responseOperatorInfos() " + strings[i+2] + " gave " + temp);
  940. + strings[i] = temp;
  941. + strings[i+1] = temp;
  942. + }
  943. +
  944. + // NOTE: We don't have the 5th element in MTK, and I don't know about
  945. + // the cases that make this processing necessary. Disable for now.
  946. + /*
  947. + // 1, 2 = 2G
  948. + // > 2 = 3G
  949. + String property_name = "gsm.baseband.capability";
  950. + if(mSimId > 0) {
  951. + property_name = property_name + (mSimId+1);
  952. + }
  953. +
  954. + int basebandCapability = SystemProperties.getInt(property_name, 3);
  955. + Rlog.d(RILJ_LOG_TAG, "property_name="+property_name+", basebandCapability=" + basebandCapability);
  956. + if (3 < basebandCapability) {
  957. + strings[i+0] = strings[i+0].concat(" " + strings[i+4]);
  958. + strings[i+1] = strings[i+1].concat(" " + strings[i+4]);
  959. + }
  960. + */
  961. +
  962. + ret.add(
  963. + new OperatorInfo(
  964. + strings[i+0],
  965. + strings[i+1],
  966. + strings[i+2],
  967. + strings[i+3]));
  968. + }
  969. +
  970. + return ret;
  971. + }
  972. +
  973. + private Object
  974. + responseCrssNotification(Parcel p) {
  975. + /*SuppCrssNotification notification = new SuppCrssNotification();
  976. +
  977. + notification.code = p.readInt();
  978. + notification.type = p.readInt();
  979. + notification.number = p.readString();
  980. + notification.alphaid = p.readString();
  981. + notification.cli_validity = p.readInt();
  982. +
  983. + return notification;*/
  984. +
  985. + Rlog.e(RILJ_LOG_TAG, "NOT PROCESSING CRSS NOTIFICATION");
  986. + return null;
  987. + }
  988. +
  989. + private Object responseEtwsNotification(Parcel p) {
  990. + /*EtwsNotification response = new EtwsNotification();
  991. +
  992. + response.warningType = p.readInt();
  993. + response.messageId = p.readInt();
  994. + response.serialNumber = p.readInt();
  995. + response.plmnId = p.readString();
  996. + response.securityInfo = p.readString();
  997. +
  998. + return response;*/
  999. + Rlog.e(RILJ_LOG_TAG, "NOT PROCESSING ETWS NOTIFICATION");
  1000. +
  1001. + return null;
  1002. + }
  1003. +
  1004. + private Object responseSetupDedicateDataCall(Parcel p) {
  1005. + int number = p.readInt();
  1006. + if (RILJ_LOGD) riljLog("responseSetupDedicateDataCall number=" + number);
  1007. + /*
  1008. + DedicateDataCallState[] dedicateDataCalls = new DedicateDataCallState[number];
  1009. + for (int i=0; i<number; i++) {
  1010. + DedicateDataCallState dedicateDataCall = new DedicateDataCallState();
  1011. + dedicateDataCall.readFrom(p);
  1012. + dedicateDataCalls[i] = dedicateDataCall;
  1013. +
  1014. + riljLog("[" + dedicateDataCall.interfaceId + ", " + dedicateDataCall.defaultCid + ", " + dedicateDataCall.cid + ", " + dedicateDataCall.active +
  1015. + ", " + dedicateDataCall.signalingFlag + ", " + dedicateDataCall.failCause + ", Qos" + dedicateDataCall.qosStatus +
  1016. + ", Tft" + dedicateDataCall.tftStatus + ", PCSCF" + dedicateDataCall.pcscfInfo);
  1017. + }
  1018. +
  1019. + if (number > 1)
  1020. + return dedicateDataCalls;
  1021. + else if (number > 0)
  1022. + return dedicateDataCalls[0];
  1023. + else
  1024. + return null;
  1025. + */
  1026. + Rlog.e(RILJ_LOG_TAG, "responseSetupDedicateDataCall: stub!");
  1027. +
  1028. + return null;
  1029. + }
  1030. +
  1031. + private Object
  1032. + responseSetPhoneRatChanged(Parcel p) {
  1033. + int num = p.readInt();
  1034. + int rat = p.readInt();
  1035. + PhoneRatFamily response = new PhoneRatFamily(mInstanceId, rat);
  1036. +
  1037. + return response;
  1038. + }
  1039. +
  1040. + private Object
  1041. + responseNetworkInfoWithActs(Parcel p) {
  1042. + Rlog.e(RILJ_LOG_TAG, "responseNetworkInfoWithActs: stub!");
  1043. +
  1044. + return null;
  1045. + }
  1046. +
  1047. + private Object
  1048. + responseOperatorInfosWithAct(Parcel p) {
  1049. + Rlog.e(RILJ_LOG_TAG, "responseOperatorInfosWithAct: stub!");
  1050. +
  1051. + return null;
  1052. + }
  1053. +
  1054. + private Object
  1055. + responseFemtoCellInfos(Parcel p) {
  1056. + Rlog.e(RILJ_LOG_TAG, "responseFemtoCellInfos: stub!");
  1057. +
  1058. + return null;
  1059. + }
  1060. +
  1061. + private Object
  1062. + responseSmsParams(Parcel p) {
  1063. + Rlog.e(RILJ_LOG_TAG, "responseSmsParams: stub!");
  1064. +
  1065. + return null;
  1066. + }
  1067. +
  1068. + private Object
  1069. + responseSimSmsMemoryStatus(Parcel p) {
  1070. + Rlog.e(RILJ_LOG_TAG, "responseSimSmsMemoryStatus: stub!");
  1071. +
  1072. + return null;
  1073. + }
  1074. +
  1075. + private Object
  1076. + responseCbConfig(Parcel p) {
  1077. + Rlog.e(RILJ_LOG_TAG, "responseCbConfig: stub!");
  1078. +
  1079. + return null;
  1080. + }
  1081. +
  1082. + private Object
  1083. + responseModifyDataCall(Parcel p) {
  1084. + Rlog.e(RILJ_LOG_TAG, "responseModifyDataCall: stub!");
  1085. +
  1086. + return null;
  1087. + }
  1088. +
  1089. + private Object
  1090. + responsePcscfDiscovery(Parcel p) {
  1091. + Rlog.e(RILJ_LOG_TAG, "responsePcscfDiscovery: stub!");
  1092. +
  1093. + return null;
  1094. + }
  1095. +
  1096. + private Object
  1097. + responseGetNitzTime(Parcel p) {
  1098. + Rlog.e(RILJ_LOG_TAG, "responseGetNitzTime: stub!");
  1099. +
  1100. + return null;
  1101. + }
  1102. +
  1103. + @Override
  1104. + public void setLocalCallHold(int lchStatus) {
  1105. + byte[] payload = new byte[]{(byte)(lchStatus & 0x7F)};
  1106. + Rlog.d(RILJ_LOG_TAG, "setLocalCallHold: lchStatus is " + lchStatus);
  1107. +
  1108. + // sendOemRilRequestRaw(OEMHOOK_EVT_HOOK_SET_LOCAL_CALL_HOLD, 1, payload, null);
  1109. + Rlog.e(RILJ_LOG_TAG, "setLocalCallHold: stub!");
  1110. + }
  1111. +
  1112. + @Override
  1113. + public void getModemCapability(Message response) {
  1114. + Rlog.d(RILJ_LOG_TAG, "GetModemCapability");
  1115. + // sendOemRilRequestRaw(OEMHOOK_EVT_HOOK_GET_MODEM_CAPABILITY, 0, null, response);
  1116. + Rlog.w(RILJ_LOG_TAG, "GetModemCapability: not really implemented!");
  1117. + AsyncResult.forMessage(response, null, CommandException.fromRilErrno(REQUEST_NOT_SUPPORTED));
  1118. + response.sendToTarget();
  1119. + }
  1120. +
  1121. + @Override
  1122. + public void updateStackBinding(int stack, int enable, Message response) {
  1123. + byte[] payload = new byte[]{(byte)stack,(byte)enable};
  1124. + Rlog.d(RILJ_LOG_TAG, "UpdateStackBinding: on Stack: " + stack +
  1125. + ", enable/disable: " + enable);
  1126. +
  1127. + // sendOemRilRequestRaw(OEMHOOK_EVT_HOOK_UPDATE_SUB_BINDING, 2, payload, response);
  1128. + Rlog.e(RILJ_LOG_TAG, "UpdateStackBinding: stub!");
  1129. + }
  1130. +
  1131. + @Override
  1132. + public void
  1133. + startDtmf(char c, Message result) {
  1134. + /* M: call control part start */
  1135. + /* DTMF request will be ignored when the count of requests reaches 32 */
  1136. + synchronized (mDtmfReqQueue) {
  1137. + if (!mDtmfReqQueue.hasSendChldRequest() && mDtmfReqQueue.size() < mDtmfReqQueue.MAXIMUM_DTMF_REQUEST) {
  1138. + if (!mDtmfReqQueue.isStart()) {
  1139. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_DTMF_START, result);
  1140. +
  1141. + rr.mParcel.writeString(Character.toString(c));
  1142. + mDtmfReqQueue.start();
  1143. + mDtmfReqQueue.add(rr);
  1144. + if (mDtmfReqQueue.size() == 1) {
  1145. + riljLog("send start dtmf");
  1146. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  1147. + send(rr);
  1148. + }
  1149. + } else {
  1150. + riljLog("DTMF status conflict, want to start DTMF when status is " + mDtmfReqQueue.isStart());
  1151. + }
  1152. + }
  1153. + }
  1154. + /* M: call control part end */
  1155. + }
  1156. + @Override
  1157. + public void
  1158. + stopDtmf(Message result) {
  1159. + /* M: call control part start */
  1160. + /* DTMF request will be ignored when the count of requests reaches 32 */
  1161. + synchronized (mDtmfReqQueue) {
  1162. + if (!mDtmfReqQueue.hasSendChldRequest() && mDtmfReqQueue.size() < mDtmfReqQueue.MAXIMUM_DTMF_REQUEST) {
  1163. + if (mDtmfReqQueue.isStart()) {
  1164. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_DTMF_STOP, result);
  1165. +
  1166. + mDtmfReqQueue.stop();
  1167. + mDtmfReqQueue.add(rr);
  1168. + if (mDtmfReqQueue.size() == 1) {
  1169. + riljLog("send stop dtmf");
  1170. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  1171. + send(rr);
  1172. + }
  1173. + } else {
  1174. + riljLog("DTMF status conflict, want to start DTMF when status is " + mDtmfReqQueue.isStart());
  1175. + }
  1176. + }
  1177. + }
  1178. + /* M: call control part end */
  1179. + }
  1180. +
  1181. + @Override
  1182. + public void
  1183. + switchWaitingOrHoldingAndActive (Message result) {
  1184. + RILRequest rr
  1185. + = RILRequest.obtain(
  1186. + RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE,
  1187. + result);
  1188. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  1189. +
  1190. + /* M: call control part start */
  1191. + handleChldRelatedRequest(rr);
  1192. + /* M: call control part end */
  1193. + }
  1194. +
  1195. + @Override
  1196. + public void
  1197. + conference (Message result) {
  1198. +
  1199. + /* M: call control part start */
  1200. + /*
  1201. + if (MobileManagerUtils.isSupported()) {
  1202. + if (!checkMoMSSubPermission(SubPermissions.MAKE_CONFERENCE_CALL)) {
  1203. + return;
  1204. + }
  1205. + }
  1206. + */
  1207. + /* M: call control part end */
  1208. +
  1209. + RILRequest rr
  1210. + = RILRequest.obtain(RIL_REQUEST_CONFERENCE, result);
  1211. +
  1212. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  1213. +
  1214. + /* M: call control part start */
  1215. + handleChldRelatedRequest(rr);
  1216. + /* M: call control part end */
  1217. + }
  1218. +
  1219. + @Override
  1220. + public void
  1221. + separateConnection (int gsmIndex, Message result) {
  1222. + RILRequest rr
  1223. + = RILRequest.obtain(RIL_REQUEST_SEPARATE_CONNECTION, result);
  1224. +
  1225. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
  1226. + + " " + gsmIndex);
  1227. +
  1228. + rr.mParcel.writeInt(1);
  1229. + rr.mParcel.writeInt(gsmIndex);
  1230. +
  1231. + /* M: call control part start */
  1232. + handleChldRelatedRequest(rr);
  1233. + /* M: call control part end */
  1234. + }
  1235. +
  1236. + @Override
  1237. + public void
  1238. + explicitCallTransfer (Message result) {
  1239. + RILRequest rr
  1240. + = RILRequest.obtain(RIL_REQUEST_EXPLICIT_CALL_TRANSFER, result);
  1241. +
  1242. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  1243. +
  1244. + /* M: call control part start */
  1245. + handleChldRelatedRequest(rr);
  1246. + /* M: call control part end */
  1247. + }
  1248. +
  1249. + // all that C&P just for responseOperator overriding?
  1250. + @Override
  1251. + protected RILRequest
  1252. + processSolicited (Parcel p) {
  1253. + int serial, error;
  1254. + boolean found = false;
  1255. +
  1256. + serial = p.readInt();
  1257. + error = p.readInt();
  1258. +
  1259. + RILRequest rr;
  1260. +
  1261. + rr = findAndRemoveRequestFromList(serial);
  1262. +
  1263. + if (rr == null) {
  1264. + Rlog.w(RILJ_LOG_TAG, "Unexpected solicited response! sn: "
  1265. + + serial + " error: " + error);
  1266. + return null;
  1267. + }
  1268. +
  1269. + /* M: call control part start */
  1270. + /* DTMF request will be ignored when the count of requests reaches 32 */
  1271. + if ((rr.mRequest == RIL_REQUEST_DTMF_START) ||
  1272. + (rr.mRequest == RIL_REQUEST_DTMF_STOP)) {
  1273. + synchronized (mDtmfReqQueue) {
  1274. + mDtmfReqQueue.remove(rr);
  1275. + riljLog("remove first item in dtmf queue done, size = " + mDtmfReqQueue.size());
  1276. + if (mDtmfReqQueue.size() > 0) {
  1277. + RILRequest rr2 = mDtmfReqQueue.get();
  1278. + if (RILJ_LOGD) riljLog(rr2.serialString() + "> " + requestToString(rr2.mRequest));
  1279. + send(rr2);
  1280. + } else {
  1281. + if (mDtmfReqQueue.getPendingRequest() != null) {
  1282. + riljLog("send pending switch request");
  1283. + send(mDtmfReqQueue.getPendingRequest());
  1284. + mDtmfReqQueue.setSendChldRequest();
  1285. + mDtmfReqQueue.setPendingRequest(null);
  1286. + }
  1287. + }
  1288. + }
  1289. + }
  1290. + /* M: call control part end */
  1291. + Object ret = null;
  1292. +
  1293. + if ((rr.mRequest == RIL_REQUEST_QUERY_AVAILABLE_NETWORKS) ||
  1294. + (rr.mRequest == RIL_REQUEST_QUERY_AVAILABLE_NETWORKS_WITH_ACT)) {
  1295. + // mGetAvailableNetworkDoneRegistrant.notifyRegistrants();
  1296. + Rlog.e(RILJ_LOG_TAG, "mGetAvailableNetworkDoneRegistrant.notifyRegistrants(); -- not implemented!");
  1297. + }
  1298. +
  1299. + /* ALPS00799783 START */
  1300. + if (rr.mRequest == RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE) {
  1301. + if ((error != 0) && (mPreviousPreferredType != -1)) {
  1302. + riljLog("restore mPreferredNetworkType from " + mPreferredNetworkType + " to " + mPreviousPreferredType);
  1303. + mPreferredNetworkType = mPreviousPreferredType;
  1304. + }
  1305. + mPreviousPreferredType = -1; //reset
  1306. + }
  1307. + /* ALPS00799783 END */
  1308. +
  1309. + /* M: call control part start */
  1310. + if (rr.mRequest == RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE ||
  1311. + rr.mRequest == RIL_REQUEST_CONFERENCE ||
  1312. + rr.mRequest == RIL_REQUEST_SEPARATE_CONNECTION ||
  1313. + rr.mRequest == RIL_REQUEST_EXPLICIT_CALL_TRANSFER) {
  1314. + riljLog("clear mIsSendChldRequest");
  1315. + mDtmfReqQueue.resetSendChldRequest();
  1316. + }
  1317. + /* M: call control part end */
  1318. +
  1319. + if (error == 0 || p.dataAvail() > 0) {
  1320. +
  1321. + /* Convert RIL_REQUEST_GET_MODEM_VERSION back */
  1322. + if (SystemProperties.get("ro.cm.device").indexOf("e73") == 0 &&
  1323. + rr.mRequest == 220) {
  1324. + rr.mRequest = RIL_REQUEST_BASEBAND_VERSION;
  1325. + }
  1326. +
  1327. + // either command succeeds or command fails but with data payload
  1328. + try {switch (rr.mRequest) {
  1329. + /*
  1330. + cat libs/telephony/ril_commands.h \
  1331. + | egrep "^ *{RIL_" \
  1332. + | sed -re 's/\{([^,]+),[^,]+,([^}]+).+/case \1: ret = \2(p); break;/'
  1333. + */
  1334. + case RIL_REQUEST_GET_SIM_STATUS: ret = responseIccCardStatus(p); break;
  1335. + case RIL_REQUEST_ENTER_SIM_PIN: ret = responseInts(p); break;
  1336. + case RIL_REQUEST_ENTER_SIM_PUK: ret = responseInts(p); break;
  1337. + case RIL_REQUEST_ENTER_SIM_PIN2: ret = responseInts(p); break;
  1338. + case RIL_REQUEST_ENTER_SIM_PUK2: ret = responseInts(p); break;
  1339. + case RIL_REQUEST_CHANGE_SIM_PIN: ret = responseInts(p); break;
  1340. + case RIL_REQUEST_CHANGE_SIM_PIN2: ret = responseInts(p); break;
  1341. + case RIL_REQUEST_ENTER_DEPERSONALIZATION_CODE: ret = responseInts(p); break;
  1342. + case RIL_REQUEST_GET_CURRENT_CALLS: ret = responseCallList(p); break;
  1343. + case RIL_REQUEST_DIAL: ret = responseVoid(p); break;
  1344. + case RIL_REQUEST_GET_IMSI: ret = responseString(p); break;
  1345. + case RIL_REQUEST_HANGUP: ret = responseVoid(p); break;
  1346. + case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: ret = responseVoid(p); break;
  1347. + case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: ret = responseVoid(p); break;
  1348. + case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: ret = responseVoid(p); break;
  1349. + case RIL_REQUEST_CONFERENCE: ret = responseVoid(p); break;
  1350. + case RIL_REQUEST_UDUB: ret = responseVoid(p); break;
  1351. + case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: ret = responseInts(p); break;
  1352. + case RIL_REQUEST_SIGNAL_STRENGTH: ret = responseSignalStrength(p); break;
  1353. + case RIL_REQUEST_VOICE_REGISTRATION_STATE: ret = responseStrings(p); break;
  1354. + case RIL_REQUEST_DATA_REGISTRATION_STATE: ret = responseStrings(p); break;
  1355. + case RIL_REQUEST_OPERATOR: ret = responseOperator(p); break;
  1356. + case RIL_REQUEST_RADIO_POWER: ret = responseVoid(p); break;
  1357. + case RIL_REQUEST_DTMF: ret = responseVoid(p); break;
  1358. + case RIL_REQUEST_SEND_SMS: ret = responseSMS(p); break;
  1359. + case RIL_REQUEST_SEND_SMS_EXPECT_MORE: ret = responseSMS(p); break;
  1360. + case RIL_REQUEST_SETUP_DATA_CALL: ret = responseSetupDataCall(p); break;
  1361. + case RIL_REQUEST_SIM_IO: ret = responseICC_IO(p); break;
  1362. + case RIL_REQUEST_SEND_USSD: ret = responseVoid(p); break;
  1363. + case RIL_REQUEST_CANCEL_USSD: ret = responseVoid(p); break;
  1364. + case RIL_REQUEST_GET_CLIR: ret = responseInts(p); break;
  1365. + case RIL_REQUEST_SET_CLIR: ret = responseVoid(p); break;
  1366. + case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: ret = responseCallForward(p); break;
  1367. + case RIL_REQUEST_SET_CALL_FORWARD: ret = responseVoid(p); break;
  1368. + case RIL_REQUEST_QUERY_CALL_WAITING: ret = responseInts(p); break;
  1369. + case RIL_REQUEST_SET_CALL_WAITING: ret = responseVoid(p); break;
  1370. + case RIL_REQUEST_SMS_ACKNOWLEDGE: ret = responseVoid(p); break;
  1371. + case RIL_REQUEST_GET_IMEI: ret = responseString(p); break;
  1372. + case RIL_REQUEST_GET_IMEISV: ret = responseString(p); break;
  1373. + case RIL_REQUEST_ANSWER: ret = responseVoid(p); break;
  1374. + case RIL_REQUEST_DEACTIVATE_DATA_CALL: ret = responseDeactivateDataCall(p); break; //VoLTE
  1375. + case RIL_REQUEST_QUERY_FACILITY_LOCK: ret = responseInts(p); break;
  1376. + case RIL_REQUEST_SET_FACILITY_LOCK: ret = responseInts(p); break;
  1377. + case RIL_REQUEST_CHANGE_BARRING_PASSWORD: ret = responseVoid(p); break;
  1378. + case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: ret = responseInts(p); break;
  1379. + case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: ret = responseVoid(p); break;
  1380. + case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: ret = responseVoid(p); break;
  1381. + case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : ret = responseOperatorInfos(p); break;
  1382. + case RIL_REQUEST_ABORT_QUERY_AVAILABLE_NETWORKS: ret = responseVoid(p); break;
  1383. + case RIL_REQUEST_DTMF_START: ret = responseVoid(p); break;
  1384. + case RIL_REQUEST_DTMF_STOP: ret = responseVoid(p); break;
  1385. + case RIL_REQUEST_BASEBAND_VERSION: ret = responseString(p); break;
  1386. + case RIL_REQUEST_SEPARATE_CONNECTION: ret = responseVoid(p); break;
  1387. + case RIL_REQUEST_SET_MUTE: ret = responseVoid(p); break;
  1388. + case RIL_REQUEST_GET_MUTE: ret = responseInts(p); break;
  1389. + case RIL_REQUEST_QUERY_CLIP: ret = responseInts(p); break;
  1390. + case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: ret = responseInts(p); break;
  1391. + case RIL_REQUEST_DATA_CALL_LIST: ret = responseDataCallList(p); break;
  1392. + case RIL_REQUEST_RESET_RADIO: ret = responseVoid(p); break;
  1393. + case RIL_REQUEST_OEM_HOOK_RAW: ret = responseRaw(p); break;
  1394. + case RIL_REQUEST_OEM_HOOK_STRINGS: ret = responseStrings(p); break;
  1395. + case RIL_REQUEST_SCREEN_STATE: ret = responseVoid(p); break;
  1396. + case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION: ret = responseVoid(p); break;
  1397. + case RIL_REQUEST_WRITE_SMS_TO_SIM: ret = responseInts(p); break;
  1398. + case RIL_REQUEST_DELETE_SMS_ON_SIM: ret = responseVoid(p); break;
  1399. + case RIL_REQUEST_SET_BAND_MODE: ret = responseVoid(p); break;
  1400. + case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: ret = responseInts(p); break;
  1401. + case RIL_REQUEST_STK_GET_PROFILE: ret = responseString(p); break;
  1402. + case RIL_REQUEST_STK_SET_PROFILE: ret = responseVoid(p); break;
  1403. + case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: ret = responseString(p); break;
  1404. + case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: ret = responseVoid(p); break;
  1405. + case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: ret = responseInts(p); break;
  1406. + case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: ret = responseVoid(p); break;
  1407. + case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: ret = responseVoid(p); break;
  1408. + case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: ret = responseGetPreferredNetworkType(p); break;
  1409. + case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: ret = responseCellList(p); break;
  1410. + case RIL_REQUEST_SET_LOCATION_UPDATES: ret = responseVoid(p); break;
  1411. + case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE: ret = responseVoid(p); break;
  1412. + case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE: ret = responseVoid(p); break;
  1413. + case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE: ret = responseInts(p); break;
  1414. + case RIL_REQUEST_SET_TTY_MODE: ret = responseVoid(p); break;
  1415. + case RIL_REQUEST_QUERY_TTY_MODE: ret = responseInts(p); break;
  1416. + case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE: ret = responseVoid(p); break;
  1417. + case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE: ret = responseInts(p); break;
  1418. + case RIL_REQUEST_CDMA_FLASH: ret = responseVoid(p); break;
  1419. + case RIL_REQUEST_CDMA_BURST_DTMF: ret = responseVoid(p); break;
  1420. + case RIL_REQUEST_CDMA_SEND_SMS: ret = responseSMS(p); break;
  1421. + case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE: ret = responseVoid(p); break;
  1422. + case RIL_REQUEST_GSM_GET_BROADCAST_CONFIG: ret = responseGmsBroadcastConfig(p); break;
  1423. + case RIL_REQUEST_GSM_SET_BROADCAST_CONFIG: ret = responseVoid(p); break;
  1424. + case RIL_REQUEST_GSM_BROADCAST_ACTIVATION: ret = responseVoid(p); break;
  1425. + case RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG: ret = responseCdmaBroadcastConfig(p); break;
  1426. + case RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG: ret = responseVoid(p); break;
  1427. + case RIL_REQUEST_CDMA_BROADCAST_ACTIVATION: ret = responseVoid(p); break;
  1428. + case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: ret = responseVoid(p); break;
  1429. + case RIL_REQUEST_CDMA_SUBSCRIPTION: ret = responseStrings(p); break;
  1430. + case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: ret = responseInts(p); break;
  1431. + case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: ret = responseVoid(p); break;
  1432. + case RIL_REQUEST_DEVICE_IDENTITY: ret = responseStrings(p); break;
  1433. + case RIL_REQUEST_GET_SMSC_ADDRESS: ret = responseString(p); break;
  1434. + case RIL_REQUEST_SET_SMSC_ADDRESS: ret = responseVoid(p); break;
  1435. + case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: ret = responseVoid(p); break;
  1436. + case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: ret = responseVoid(p); break;
  1437. + case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: ret = responseVoid(p); break;
  1438. + case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: ret = responseInts(p); break;
  1439. + case RIL_REQUEST_ISIM_AUTHENTICATION: ret = responseString(p); break;
  1440. + case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: ret = responseVoid(p); break;
  1441. + case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: ret = responseICC_IO(p); break;
  1442. + case RIL_REQUEST_VOICE_RADIO_TECH: ret = responseInts(p); break;
  1443. + case RIL_REQUEST_GET_CELL_INFO_LIST: ret = responseCellInfoList(p); break;
  1444. + case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: ret = responseVoid(p); break;
  1445. + case RIL_REQUEST_SET_INITIAL_ATTACH_APN: ret = responseVoid(p); break;
  1446. + case RIL_REQUEST_SET_DATA_PROFILE: ret = responseVoid(p); break;
  1447. + case RIL_REQUEST_IMS_REGISTRATION_STATE: ret = responseInts(p); break;
  1448. + case RIL_REQUEST_IMS_SEND_SMS: ret = responseSMS(p); break;
  1449. + case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: ret = responseICC_IO(p); break;
  1450. + case RIL_REQUEST_SIM_OPEN_CHANNEL: ret = responseInts(p); break;
  1451. + case RIL_REQUEST_SIM_CLOSE_CHANNEL: ret = responseVoid(p); break;
  1452. + case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: ret = responseICC_IO(p); break;
  1453. + case RIL_REQUEST_NV_READ_ITEM: ret = responseString(p); break;
  1454. + case RIL_REQUEST_NV_WRITE_ITEM: ret = responseVoid(p); break;
  1455. + case RIL_REQUEST_NV_WRITE_CDMA_PRL: ret = responseVoid(p); break;
  1456. + case RIL_REQUEST_NV_RESET_CONFIG: ret = responseVoid(p); break;
  1457. + case RIL_REQUEST_SET_UICC_SUBSCRIPTION: ret = responseVoid(p); break;
  1458. + case RIL_REQUEST_ALLOW_DATA: ret = responseVoid(p); break;
  1459. + case RIL_REQUEST_GET_HARDWARE_CONFIG: ret = responseHardwareConfig(p); break;
  1460. + case RIL_REQUEST_SIM_AUTHENTICATION: ret = responseICC_IOBase64(p); break;
  1461. + case RIL_REQUEST_SHUTDOWN: ret = responseVoid(p); break;
  1462. + case RIL_REQUEST_GET_PHONE_RAT_FAMILY: ret = responseInts(p); break;
  1463. + case RIL_REQUEST_SET_PHONE_RAT_FAMILY: ret = responsePhoneId(); break;
  1464. +
  1465. + /* M: call control part start */
  1466. + case RIL_REQUEST_HANGUP_ALL: ret = responseVoid(p); break;
  1467. + case RIL_REQUEST_FORCE_RELEASE_CALL: ret = responseVoid(p); break;
  1468. + case RIL_REQUEST_SET_CALL_INDICATION: ret = responseVoid(p); break;
  1469. + case RIL_REQUEST_EMERGENCY_DIAL: ret = responseVoid(p); break;
  1470. + case RIL_REQUEST_SET_ECC_SERVICE_CATEGORY: ret = responseVoid(p); break;
  1471. + case RIL_REQUEST_SET_ECC_LIST: ret = responseVoid(p); break;
  1472. + case RIL_REQUEST_SET_SPEECH_CODEC_INFO: ret = responseVoid(p); break;
  1473. + /* M: call control part end */
  1474. +
  1475. + /// M: IMS feature. @{
  1476. + case RIL_REQUEST_ADD_IMS_CONFERENCE_CALL_MEMBER: responseString(p); break;
  1477. + case RIL_REQUEST_REMOVE_IMS_CONFERENCE_CALL_MEMBER: responseString(p); break;
  1478. + case RIL_REQUEST_DIAL_WITH_SIP_URI: ret = responseVoid(p); break;
  1479. + case RIL_REQUEST_RETRIEVE_HELD_CALL: ret = responseVoid(p); break;
  1480. + /// @}
  1481. +
  1482. + //MTK-START SIM ME lock
  1483. + case RIL_REQUEST_QUERY_SIM_NETWORK_LOCK: ret = responseInts(p); break;
  1484. + case RIL_REQUEST_SET_SIM_NETWORK_LOCK: ret = responseInts(p); break;
  1485. + //MTK-END SIM ME lock
  1486. + //MTK-START multiple application support
  1487. + case RIL_REQUEST_GENERAL_SIM_AUTH: ret = responseICC_IO(p); break;
  1488. + case RIL_REQUEST_OPEN_ICC_APPLICATION: ret = responseInts(p); break;
  1489. + case RIL_REQUEST_GET_ICC_APPLICATION_STATUS: ret = responseIccCardStatus(p); break;
  1490. + //MTK-END multiple application support
  1491. + case RIL_REQUEST_SIM_IO_EX: ret = responseICC_IO(p); break;
  1492. + // PHB Start
  1493. + case RIL_REQUEST_QUERY_PHB_STORAGE_INFO: ret = responseInts(p); break;
  1494. + case RIL_REQUEST_WRITE_PHB_ENTRY: ret = responseVoid(p); break;
  1495. + case RIL_REQUEST_READ_PHB_ENTRY: {
  1496. + // ret = responsePhbEntries(p); break;
  1497. + Rlog.e(RILJ_LOG_TAG, "RIL_REQUEST_READ_PHB_ENTRY: stub!");
  1498. + ret = responseVoid(p); break;
  1499. + }
  1500. + case RIL_REQUEST_QUERY_UPB_CAPABILITY: ret = responseInts(p); break;
  1501. + case RIL_REQUEST_READ_UPB_GRP: ret = responseInts(p); break;
  1502. + case RIL_REQUEST_WRITE_UPB_GRP: ret = responseVoid(p); break;
  1503. + case RIL_REQUEST_EDIT_UPB_ENTRY: ret = responseVoid(p); break;
  1504. + case RIL_REQUEST_DELETE_UPB_ENTRY: ret = responseVoid(p); break;
  1505. + case RIL_REQUEST_READ_UPB_GAS_LIST: ret = responseStrings(p); break;
  1506. + case RIL_REQUEST_GET_PHB_STRING_LENGTH: ret = responseInts(p); break;
  1507. + case RIL_REQUEST_GET_PHB_MEM_STORAGE: {
  1508. + // ret = responseGetPhbMemStorage(p); break;
  1509. + Rlog.e(RILJ_LOG_TAG, "RIL_REQUEST_GET_PHB_MEM_STORAGE: stub!");
  1510. + ret = responseVoid(p); break;
  1511. + }
  1512. + case RIL_REQUEST_SET_PHB_MEM_STORAGE: ret = responseVoid(p); break;
  1513. + case RIL_REQUEST_READ_PHB_ENTRY_EXT: {
  1514. + // ret = responseReadPhbEntryExt(p); break;
  1515. + Rlog.e(RILJ_LOG_TAG, "RIL_REQUEST_READ_PHB_ENTRY_EXT: stub!");
  1516. + ret = responseVoid(p); break;
  1517. + }
  1518. + case RIL_REQUEST_WRITE_PHB_ENTRY_EXT: ret = responseVoid(p); break;
  1519. + // PHB End
  1520. +
  1521. +
  1522. + /* M: network part start */
  1523. + case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL_WITH_ACT: ret = responseVoid(p); break;
  1524. + case RIL_REQUEST_GET_POL_CAPABILITY: ret = responseInts(p); break;
  1525. + case RIL_REQUEST_GET_POL_LIST: ret = responseNetworkInfoWithActs(p); break;
  1526. + case RIL_REQUEST_SET_POL_ENTRY: ret = responseVoid(p); break;
  1527. + case RIL_REQUEST_SET_TRM: ret = responseInts(p); break;
  1528. + case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS_WITH_ACT : ret = responseOperatorInfosWithAct(p); break;
  1529. + case RIL_REQUEST_STK_EVDL_CALL_BY_AP: ret = responseVoid(p); break;
  1530. +
  1531. + //Femtocell (CSG) feature START
  1532. + case RIL_REQUEST_GET_FEMTOCELL_LIST: ret = responseFemtoCellInfos(p); break;
  1533. + case RIL_REQUEST_ABORT_FEMTOCELL_LIST: ret = responseVoid(p); break;
  1534. + case RIL_REQUEST_SELECT_FEMTOCELL: ret = responseVoid(p); break;
  1535. + //Femtocell (CSG) feature END
  1536. + /* M: network part end */
  1537. +
  1538. + case RIL_REQUEST_QUERY_MODEM_TYPE: ret = responseInts(p); break;
  1539. + case RIL_REQUEST_STORE_MODEM_TYPE: ret = responseVoid(p); break;
  1540. +
  1541. + // IMS
  1542. + case RIL_REQUEST_SET_IMS_ENABLE: ret = responseVoid(p); break;
  1543. + case RIL_REQUEST_SIM_GET_ATR: ret = responseString(p); break;
  1544. + // M: Fast Dormancy
  1545. + case RIL_REQUEST_SET_SCRI: ret = responseVoid(p); break;
  1546. + case RIL_REQUEST_SET_FD_MODE: ret = responseInts(p); break;
  1547. +
  1548. + // MTK-START, SMS part
  1549. + case RIL_REQUEST_GET_SMS_PARAMS: ret = responseSmsParams(p); break;
  1550. + case RIL_REQUEST_SET_SMS_PARAMS: ret = responseVoid(p); break;
  1551. + case RIL_REQUEST_GET_SMS_SIM_MEM_STATUS: ret = responseSimSmsMemoryStatus(p); break;
  1552. + case RIL_REQUEST_SET_ETWS: ret = responseVoid(p); break;
  1553. + case RIL_REQUEST_SET_CB_CHANNEL_CONFIG_INFO: ret = responseVoid(p); break;
  1554. + case RIL_REQUEST_SET_CB_LANGUAGE_CONFIG_INFO: ret = responseVoid(p); break;
  1555. + case RIL_REQUEST_GET_CB_CONFIG_INFO: ret = responseCbConfig(p); break;
  1556. + case RIL_REQUEST_REMOVE_CB_MESSAGE: ret = responseVoid(p); break;
  1557. + // MTK-END, SMS part
  1558. + case RIL_REQUEST_SET_DATA_CENTRIC: ret = responseVoid(p); break;
  1559. +
  1560. + //VoLTE
  1561. + case RIL_REQUEST_SETUP_DEDICATE_DATA_CALL: ret = responseSetupDedicateDataCall(p); break;
  1562. + case RIL_REQUEST_DEACTIVATE_DEDICATE_DATA_CALL: ret = responseVoid(p); break;
  1563. + case RIL_REQUEST_MODIFY_DATA_CALL: ret = responseModifyDataCall(p); break;
  1564. + case RIL_REQUEST_ABORT_SETUP_DATA_CALL: ret = responseVoid(p); break;
  1565. + case RIL_REQUEST_PCSCF_DISCOVERY_PCO: ret=responsePcscfDiscovery(p); break;
  1566. + case RIL_REQUEST_CLEAR_DATA_BEARER: ret=responseVoid(p); break;
  1567. + // M: CC33 LTE.
  1568. + case RIL_REQUEST_SET_DATA_ON_TO_MD: ret = responseVoid(p); break;
  1569. + case RIL_REQUEST_SET_REMOVE_RESTRICT_EUTRAN_MODE: ret = responseVoid(p); break;
  1570. +
  1571. + case RIL_REQUEST_BTSIM_CONNECT: ret = responseString(p); break;
  1572. + case RIL_REQUEST_BTSIM_DISCONNECT_OR_POWEROFF: ret = responseVoid(p); break;
  1573. + case RIL_REQUEST_BTSIM_POWERON_OR_RESETSIM: ret = responseString(p); break;
  1574. + case RIL_REQUEST_BTSIM_TRANSFERAPDU: ret = responseString(p); break;
  1575. +
  1576. + /* M: call control part start */
  1577. + case RIL_REQUEST_SET_IMS_CALL_STATUS: ret = responseVoid(p); break;
  1578. + /* M: call control part end */
  1579. +
  1580. + /* M: C2K part start */
  1581. + case RIL_REQUEST_GET_NITZ_TIME: ret = responseGetNitzTime(p); break;
  1582. + case RIL_REQUEST_QUERY_UIM_INSERTED: ret = responseInts(p); break;
  1583. + case RIL_REQUEST_SWITCH_HPF: ret = responseVoid(p); break;
  1584. + case RIL_REQUEST_SET_AVOID_SYS: ret = responseVoid(p); break;
  1585. + case RIL_REQUEST_QUERY_AVOID_SYS: ret = responseInts(p); break;
  1586. + case RIL_REQUEST_QUERY_CDMA_NETWORK_INFO: ret = responseStrings(p); break;
  1587. + case RIL_REQUEST_GET_LOCAL_INFO: ret = responseInts(p); break;
  1588. + case RIL_REQUEST_UTK_REFRESH: ret = responseVoid(p); break;
  1589. + case RIL_REQUEST_QUERY_SMS_AND_PHONEBOOK_STATUS: ret = responseInts(p); break;
  1590. + case RIL_REQUEST_QUERY_NETWORK_REGISTRATION: ret = responseInts(p); break;
  1591. + case RIL_REQUEST_AGPS_TCP_CONNIND: ret = responseVoid(p); break;
  1592. + case RIL_REQUEST_AGPS_SET_MPC_IPPORT: ret = responseVoid(p); break;
  1593. + case RIL_REQUEST_AGPS_GET_MPC_IPPORT: ret = responseStrings(p); break;
  1594. + case RIL_REQUEST_SET_MEID: ret = responseVoid(p); break;
  1595. + case RIL_REQUEST_SET_REG_RESUME: ret = responseVoid(p); break;
  1596. + case RIL_REQUEST_ENABLE_REG_PAUSE: ret = responseVoid(p); break;
  1597. + case RIL_REQUEST_SET_ETS_DEV: ret = responseVoid(p); break;
  1598. + case RIL_REQUEST_WRITE_MDN: ret = responseVoid(p); break;
  1599. + case RIL_REQUEST_SET_VIA_TRM: ret = responseVoid(p); break;
  1600. + case RIL_REQUEST_SET_ARSI_THRESHOLD: ret = responseVoid(p); break;
  1601. + /* M: C2K part end */
  1602. + default:
  1603. + throw new RuntimeException("Unrecognized solicited response: " + rr.mRequest);
  1604. + //break;
  1605. + }} catch (Throwable tr) {
  1606. + // Exceptions here usually mean invalid RIL responses
  1607. +
  1608. + Rlog.w(RILJ_LOG_TAG, rr.serialString() + "< "
  1609. + + requestToString(rr.mRequest)
  1610. + + " exception, possible invalid RIL response", tr);
  1611. +
  1612. + if (rr.mResult != null) {
  1613. + AsyncResult.forMessage(rr.mResult, null, tr);
  1614. + rr.mResult.sendToTarget();
  1615. + }
  1616. + return rr;
  1617. + }
  1618. + }
  1619. +
  1620. + if (rr.mRequest == RIL_REQUEST_SHUTDOWN) {
  1621. + // Set RADIO_STATE to RADIO_UNAVAILABLE to continue shutdown process
  1622. + // regardless of error code to continue shutdown procedure.
  1623. + riljLog("Response to RIL_REQUEST_SHUTDOWN received. Error is " +
  1624. + error + " Setting Radio State to Unavailable regardless of error.");
  1625. + setRadioState(RadioState.RADIO_UNAVAILABLE);
  1626. + }
  1627. +
  1628. + // Here and below fake RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, see b/7255789.
  1629. + // This is needed otherwise we don't automatically transition to the main lock
  1630. + // screen when the pin or puk is entered incorrectly.
  1631. + switch (rr.mRequest) {
  1632. + case RIL_REQUEST_ENTER_SIM_PUK:
  1633. + case RIL_REQUEST_ENTER_SIM_PUK2:
  1634. + if (mIccStatusChangedRegistrants != null) {
  1635. + if (RILJ_LOGD) {
  1636. + riljLog("ON enter sim puk fakeSimStatusChanged: reg count="
  1637. + + mIccStatusChangedRegistrants.size());
  1638. + }
  1639. + mIccStatusChangedRegistrants.notifyRegistrants();
  1640. + }
  1641. + break;
  1642. + }
  1643. +
  1644. + if (error != 0) {
  1645. + switch (rr.mRequest) {
  1646. + case RIL_REQUEST_ENTER_SIM_PIN:
  1647. + case RIL_REQUEST_ENTER_SIM_PIN2:
  1648. + case RIL_REQUEST_CHANGE_SIM_PIN:
  1649. + case RIL_REQUEST_CHANGE_SIM_PIN2:
  1650. + case RIL_REQUEST_SET_FACILITY_LOCK:
  1651. + if (mIccStatusChangedRegistrants != null) {
  1652. + if (RILJ_LOGD) {
  1653. + riljLog("ON some errors fakeSimStatusChanged: reg count="
  1654. + + mIccStatusChangedRegistrants.size());
  1655. + }
  1656. + mIccStatusChangedRegistrants.notifyRegistrants();
  1657. + }
  1658. + break;
  1659. +
  1660. + case RIL_REQUEST_SET_PHONE_RAT_FAMILY:
  1661. + if (RILJ_LOGD) {
  1662. + riljLog("Set phone RAT failed, send response with phone ID");
  1663. + }
  1664. + ret = responsePhoneId();
  1665. + break;
  1666. + }
  1667. +
  1668. + rr.onError(error, ret);
  1669. + return rr;
  1670. + }
  1671. +
  1672. + if (RILJ_LOGD) riljLog(rr.serialString() + "< " + requestToString(rr.mRequest)
  1673. + + " " + retToString(rr.mRequest, ret));
  1674. +
  1675. + if (rr.mResult != null) {
  1676. + AsyncResult.forMessage(rr.mResult, ret, null);
  1677. + rr.mResult.sendToTarget();
  1678. + }
  1679. +
  1680. + return rr;
  1681. + }
  1682. +
  1683. + @Override
  1684. + protected void
  1685. + processUnsolicited (Parcel p) {
  1686. + Object ret;
  1687. + int dataPosition = p.dataPosition(); // save off position within the Parcel
  1688. + int response = p.readInt();
  1689. +
  1690. + switch(response) {
  1691. + case RIL_UNSOL_NEIGHBORING_CELL_INFO: ret = responseStrings(p); break;
  1692. + case RIL_UNSOL_NETWORK_INFO: ret = responseStrings(p); break;
  1693. + case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED: ret = responseVoid(p); break;
  1694. + case RIL_UNSOL_INVALID_SIM: ret = responseStrings(p); break;
  1695. + case RIL_UNSOL_RESPONSE_ACMT: ret = responseInts(p); break;
  1696. + case RIL_UNSOL_IMEI_LOCK: ret = responseVoid(p); break;
  1697. + case RIL_UNSOL_RESPONSE_MMRR_STATUS_CHANGED: ret = responseInts(p); break;
  1698. + case RIL_UNSOL_STK_EVDL_CALL: ret = responseInts(p); break;
  1699. + case RIL_UNSOL_STK_CALL_CTRL: ret = responseStrings(p); break;
  1700. +
  1701. + case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: ret = responseInts(p); break;
  1702. + case RIL_UNSOL_SRVCC_STATE_NOTIFY: ret = responseInts(p); break;
  1703. + case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: ret = responseHardwareConfig(p); break;
  1704. + // fxxk this conflicts with RIL_UNSOL_RADIO_CAPABILITY...
  1705. + case RIL_UNSOL_SET_PHONE_RAT_FAMILY_COMPLETE:
  1706. + ret = responseSetPhoneRatChanged(p); break;
  1707. + /* M: call control part start */
  1708. + case RIL_UNSOL_CALL_FORWARDING: ret = responseInts(p); break;
  1709. + case RIL_UNSOL_CRSS_NOTIFICATION: ret = responseCrssNotification(p); break;
  1710. + case RIL_UNSOL_INCOMING_CALL_INDICATION: ret = responseStrings(p); break;
  1711. + case RIL_UNSOL_CIPHER_INDICATION: ret = responseStrings(p); break;
  1712. + case RIL_UNSOL_CNAP: ret = responseStrings(p); break;
  1713. + case RIL_UNSOL_SPEECH_CODEC_INFO: ret = responseInts(p); break;
  1714. + /* M: call control part end */
  1715. + //MTK-START multiple application support
  1716. + case RIL_UNSOL_APPLICATION_SESSION_ID_CHANGED: ret = responseInts(p); break;
  1717. + //MTK-END multiple application support
  1718. + case RIL_UNSOL_SIM_MISSING: ret = responseInts(p); break;
  1719. + case RIL_UNSOL_SIM_RECOVERY: ret = responseInts(p); break;
  1720. + case RIL_UNSOL_VIRTUAL_SIM_ON: ret = responseInts(p); break;
  1721. + case RIL_UNSOL_VIRTUAL_SIM_OFF: ret = responseInts(p); break;
  1722. + case RIL_UNSOL_SIM_PLUG_OUT: ret = responseVoid(p); break;
  1723. + case RIL_UNSOL_SIM_PLUG_IN: ret = responseVoid(p); break;
  1724. + case RIL_UNSOL_SIM_COMMON_SLOT_NO_CHANGED: ret = responseVoid(p); break;
  1725. + case RIL_UNSOL_DATA_ALLOWED: ret = responseVoid(p); break;
  1726. + case RIL_UNSOL_PHB_READY_NOTIFICATION: ret = responseInts(p); break;
  1727. + case RIL_UNSOL_STK_SETUP_MENU_RESET: ret = responseVoid(p); break;
  1728. + // IMS
  1729. + case RIL_UNSOL_IMS_ENABLE_DONE: ret = responseVoid(p); break;
  1730. + case RIL_UNSOL_IMS_DISABLE_DONE: ret = responseVoid(p); break;
  1731. + case RIL_UNSOL_IMS_REGISTRATION_INFO: ret = responseInts(p); break;
  1732. + //VoLTE
  1733. + case RIL_UNSOL_DEDICATE_BEARER_ACTIVATED: ret = responseSetupDedicateDataCall(p);break;
  1734. + case RIL_UNSOL_DEDICATE_BEARER_MODIFIED: ret = responseSetupDedicateDataCall(p);break;
  1735. + case RIL_UNSOL_DEDICATE_BEARER_DEACTIVATED: ret = responseInts(p);break;
  1736. + // M: Fast Dormancy
  1737. + case RIL_UNSOL_SCRI_RESULT: ret = responseInts(p); break;
  1738. +
  1739. + case RIL_UNSOL_RESPONSE_PLMN_CHANGED: ret = responseStrings(p); break;
  1740. + case RIL_UNSOL_RESPONSE_REGISTRATION_SUSPENDED: ret = responseInts(p); break;
  1741. + //Remote SIM ME lock related APIs [Start]
  1742. + case RIL_UNSOL_MELOCK_NOTIFICATION: ret = responseInts(p); break;
  1743. + //Remote SIM ME lock related APIs [End]
  1744. + case RIL_UNSOL_VOLTE_EPS_NETWORK_FEATURE_SUPPORT: ret = responseInts(p); break;
  1745. +
  1746. + /// M: IMS feature. @{
  1747. + //For updating call ids for conference call after SRVCC is done.
  1748. + case RIL_UNSOL_ECONF_SRVCC_INDICATION: ret = responseInts(p); break;
  1749. + //For updating conference call merged/added result.
  1750. + case RIL_UNSOL_ECONF_RESULT_INDICATION: ret = responseStrings(p); break;
  1751. + //For updating call mode and pau information.
  1752. + case RIL_UNSOL_CALL_INFO_INDICATION : ret = responseStrings(p); break;
  1753. + /// @}
  1754. +
  1755. + case RIL_UNSOL_VOLTE_EPS_NETWORK_FEATURE_INFO: ret = responseInts(p); break;
  1756. + case RIL_UNSOL_SRVCC_HANDOVER_INFO_INDICATION:ret = responseInts(p); break;
  1757. + // M: CC33 LTE.
  1758. + case RIL_UNSOL_RAC_UPDATE: ret = responseVoid(p); break;
  1759. + case RIL_UNSOL_REMOVE_RESTRICT_EUTRAN: ret = responseVoid(p); break;
  1760. +
  1761. + //MTK-START for MD state change
  1762. + case RIL_UNSOL_MD_STATE_CHANGE: ret = responseInts(p); break;
  1763. + //MTK-END for MD state change
  1764. +
  1765. + case RIL_UNSOL_MO_DATA_BARRING_INFO: ret = responseInts(p); break;
  1766. + case RIL_UNSOL_SSAC_BARRING_INFO: ret = responseInts(p); break;
  1767. +//MTK_TC1_FEATURE for LGE CSMCC_MO_CALL_MODIFIED {
  1768. + case RIL_UNSOL_RESPONSE_MO_CALL_STATE_CHANGED: ret = responseStrings(p); break;
  1769. +//}
  1770. + /* M: C2K part start*/
  1771. + case RIL_UNSOL_CDMA_CALL_ACCEPTED: ret = responseVoid(p); break;
  1772. + case RIL_UNSOL_UTK_SESSION_END: ret = responseVoid(p); break;
  1773. + case RIL_UNSOL_UTK_PROACTIVE_COMMAND: ret = responseString(p); break;
  1774. + case RIL_UNSOL_UTK_EVENT_NOTIFY: ret = responseString(p); break;
  1775. + case RIL_UNSOL_VIA_GPS_EVENT: ret = responseInts(p); break;
  1776. + case RIL_UNSOL_VIA_NETWORK_TYPE_CHANGE: ret = responseInts(p); break;
  1777. + case RIL_UNSOL_VIA_PLMN_CHANGE_REG_PAUSE: ret = responseStrings(p); break;
  1778. + case RIL_UNSOL_VIA_INVALID_SIM_DETECTED: ret = responseVoid(p); break;
  1779. + /* M: C2K part end*/
  1780. + default:
  1781. + // Rewind the Parcel
  1782. + p.setDataPosition(dataPosition);
  1783. +
  1784. + // Forward responses that we are not overriding to the super class
  1785. + super.processUnsolicited(p);
  1786. + return;
  1787. + }
  1788. +
  1789. + // To avoid duplicating code from RIL.java, we rewrite some response codes to fit
  1790. + // AOSP's one (when they do the same effect)
  1791. + boolean rewindAndReplace = false;
  1792. + int newResponseCode = 0;
  1793. +
  1794. + switch (response) {
  1795. + case RIL_UNSOL_NEIGHBORING_CELL_INFO:
  1796. + if (RILJ_LOGD) unsljLogvRet(response, ret);
  1797. + if (mNeighboringInfoRegistrants != null) {
  1798. + mNeighboringInfoRegistrants.notifyRegistrants(
  1799. + new AsyncResult(null, ret, null));
  1800. + }
  1801. + break;
  1802. +
  1803. + case RIL_UNSOL_NETWORK_INFO:
  1804. + if (RILJ_LOGD) unsljLogvRet(response, ret);
  1805. + if (mNetworkInfoRegistrants != null) {
  1806. + mNetworkInfoRegistrants.notifyRegistrants(
  1807. + new AsyncResult(null, ret, null));
  1808. + }
  1809. + break;
  1810. +
  1811. + case RIL_UNSOL_SET_PHONE_RAT_FAMILY_COMPLETE:
  1812. + if (RILJ_LOGD) unsljLogRet(response, ret);
  1813. + riljLog("mPhoneRatFamilyreg size :" + mPhoneRatFamilyChangedRegistrants.size());
  1814. + if (mPhoneRatFamilyChangedRegistrants != null) {
  1815. + mPhoneRatFamilyChangedRegistrants.notifyRegistrants(
  1816. + new AsyncResult(null, ret, null));
  1817. + }
  1818. + break;
  1819. +
  1820. + case RIL_UNSOL_PHB_READY_NOTIFICATION:
  1821. + if (RILJ_LOGD) unsljLogRet(response, ret);
  1822. + Rlog.e(RILJ_LOG_TAG, "RIL_UNSOL_PHB_READY_NOTIFICATION: stub!");
  1823. + /*
  1824. + if (mPhbReadyRegistrants != null) {
  1825. + mPhbReadyRegistrants.notifyRegistrants(
  1826. + new AsyncResult(null, ret, null));
  1827. + }
  1828. + */
  1829. + break;
  1830. +
  1831. + case RIL_UNSOL_STK_EVDL_CALL:
  1832. + Rlog.e(RILJ_LOG_TAG, "RIL_UNSOL_STK_EVDL_CALL: stub!");
  1833. + /*
  1834. + if (false == SystemProperties.get("ro.mtk_bsp_package").equals("1")) {
  1835. + if (RILJ_LOGD) unsljLogvRet(response, ret);
  1836. + if (mStkEvdlCallRegistrant != null) {
  1837. + mStkEvdlCallRegistrant.notifyRegistrant(new AsyncResult(null, ret, null));
  1838. + }
  1839. + }
  1840. + */
  1841. + break;
  1842. +
  1843. + case RIL_UNSOL_STK_CALL_CTRL:
  1844. + if (RILJ_LOGD) {
  1845. + unsljLogvRet(response, ret);
  1846. + }
  1847. + Rlog.e(RILJ_LOG_TAG, "RIL_UNSOL_STK_CALL_CTRL: stub!");
  1848. + /*
  1849. + if (mStkCallCtrlRegistrant != null) {
  1850. + mStkCallCtrlRegistrant.notifyRegistrant(new AsyncResult(null, ret, null));
  1851. + }
  1852. + */
  1853. + break;
  1854. +
  1855. + case RIL_UNSOL_STK_SETUP_MENU_RESET:
  1856. + if (RILJ_LOGD) unsljLogRet(response, ret);
  1857. + Rlog.e(RILJ_LOG_TAG, "RIL_UNSOL_STK_SETUP_MENU_RESET: stub!");
  1858. + /*
  1859. + if (mStkSetupMenuResetRegistrant != null) {
  1860. + mStkSetupMenuResetRegistrant.notifyRegistrant(new AsyncResult(null, ret, null));
  1861. + }
  1862. + */
  1863. + break;
  1864. +
  1865. + //MTK-START multiple application support
  1866. + case RIL_UNSOL_APPLICATION_SESSION_ID_CHANGED: {
  1867. + if (RILJ_LOGD) unsljLog(response);
  1868. + if (mSessionChangedRegistrants != null) {
  1869. + mSessionChangedRegistrants.notifyRegistrants(new AsyncResult(null, ret, null));
  1870. + }
  1871. + break;
  1872. + }
  1873. + //MTK-END multiple application support
  1874. +
  1875. + case RIL_UNSOL_SIM_MISSING:
  1876. + if (RILJ_LOGD) unsljLogRet(response, ret);
  1877. + if (mSimMissing != null) {
  1878. + mSimMissing.notifyRegistrants(
  1879. + new AsyncResult(null, ret, null));
  1880. + }
  1881. + break;
  1882. +
  1883. + case RIL_UNSOL_SIM_RECOVERY:
  1884. + if (RILJ_LOGD) unsljLogRet(response, ret);
  1885. + if (mSimRecovery != null) {
  1886. + mSimRecovery.notifyRegistrants(
  1887. + new AsyncResult(null, ret, null));
  1888. + }
  1889. + break;
  1890. +
  1891. + case RIL_UNSOL_VIRTUAL_SIM_ON:
  1892. + if (RILJ_LOGD) unsljLogRet(response, ret);
  1893. + if (mVirtualSimOn != null) {
  1894. + mVirtualSimOn.notifyRegistrants(
  1895. + new AsyncResult(null, ret, null));
  1896. + }
  1897. + break;
  1898. +
  1899. + case RIL_UNSOL_VIRTUAL_SIM_OFF:
  1900. + if (RILJ_LOGD) unsljLogRet(response, ret);
  1901. + if (mVirtualSimOff != null) {
  1902. + mVirtualSimOff.notifyRegistrants(
  1903. + new AsyncResult(null, ret, null));
  1904. + }
  1905. + break;
  1906. +
  1907. + case RIL_UNSOL_SIM_PLUG_OUT:
  1908. + if (RILJ_LOGD) unsljLogRet(response, ret);
  1909. + if (mSimPlugOutRegistrants != null) {
  1910. + mSimPlugOutRegistrants.notifyRegistrants(
  1911. + new AsyncResult(null, ret, null));
  1912. + }
  1913. + mCfuReturnValue = null;
  1914. + break;
  1915. +
  1916. + case RIL_UNSOL_SIM_PLUG_IN:
  1917. + if (RILJ_LOGD) unsljLogRet(response, ret);
  1918. + if (mSimPlugInRegistrants != null) {
  1919. + mSimPlugInRegistrants.notifyRegistrants(
  1920. + new AsyncResult(null, ret, null));
  1921. + }
  1922. + break;
  1923. +
  1924. + case RIL_UNSOL_SIM_COMMON_SLOT_NO_CHANGED:
  1925. + if (RILJ_LOGD) unsljLog(response);
  1926. + if (mCommonSlotNoChangedRegistrants != null) {
  1927. + mCommonSlotNoChangedRegistrants.notifyRegistrants(new AsyncResult(null, null, null));
  1928. + }
  1929. + break;
  1930. +
  1931. + case RIL_UNSOL_RESPONSE_PLMN_CHANGED:
  1932. + if (RILJ_LOGD) unsljLogvRet(response, ret);
  1933. + if (mPlmnChangeNotificationRegistrant != null) {
  1934. + mPlmnChangeNotificationRegistrant.notifyRegistrants(new AsyncResult(null, ret, null));
  1935. + }
  1936. + break;
  1937. +
  1938. + case RIL_UNSOL_RESPONSE_REGISTRATION_SUSPENDED:
  1939. + if (RILJ_LOGD) unsljLogvRet(response, ret);
  1940. + if (mRegistrationSuspendedRegistrant != null) {
  1941. + mRegistrationSuspendedRegistrant.notifyRegistrant(new AsyncResult(null, ret, null));
  1942. + }
  1943. + break;
  1944. +
  1945. + // M: Fast Dormancy
  1946. + case RIL_UNSOL_SCRI_RESULT:
  1947. + Integer scriResult = (((int[]) ret)[0]);
  1948. + riljLog("s:" + scriResult + ":" + (((int[]) ret)[0]));
  1949. + if (RILJ_LOGD) unsljLogRet(response, ret);
  1950. +
  1951. + if (mScriResultRegistrant != null) {
  1952. + mScriResultRegistrant.notifyRegistrant(new AsyncResult(null, scriResult, null));
  1953. + }
  1954. + break;
  1955. +
  1956. + /*
  1957. + case RIL_UNSOL_CALL_PROGRESS_INFO:
  1958. + rewindAndReplace = true;
  1959. + newResponseCode = RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED;
  1960. + break;
  1961. + */
  1962. +
  1963. + case RIL_UNSOL_INCOMING_CALL_INDICATION:
  1964. + setCallIndication((String[])ret);
  1965. + rewindAndReplace = true;
  1966. + newResponseCode = RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED;
  1967. + break;
  1968. +
  1969. + case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED:
  1970. + if (RILJ_LOGD) unsljLog(response);
  1971. +
  1972. + mPsNetworkStateRegistrants
  1973. + .notifyRegistrants(new AsyncResult(null, null, null));
  1974. + break;
  1975. +
  1976. + case RIL_UNSOL_SMS_READY_NOTIFICATION:
  1977. + Rlog.e(RILJ_LOG_TAG, "RIL_UNSOL_SMS_READY_NOTIFICATION: stub!");
  1978. + /*if (mGsmSmsRegistrant != null) {
  1979. + mGsmSmsRegistrant
  1980. + .notifyRegistrant();
  1981. + }*/
  1982. + break;
  1983. +
  1984. + default:
  1985. + Rlog.i(RILJ_LOG_TAG, "Unprocessed unsolicited known MTK response: " + response);
  1986. + }
  1987. +
  1988. + if (rewindAndReplace) {
  1989. + Rlog.w(RILJ_LOG_TAG, "Rewriting MTK unsolicited response " + response + " to " + newResponseCode);
  1990. +
  1991. + // Rewrite
  1992. + p.setDataPosition(dataPosition);
  1993. + p.writeInt(newResponseCode);
  1994. +
  1995. + // And rewind again in front
  1996. + p.setDataPosition(dataPosition);
  1997. +
  1998. + super.processUnsolicited(p);
  1999. + }
  2000. + }
  2001. +
  2002. + static String
  2003. + requestToString(int request) {
  2004. +/*
  2005. + cat libs/telephony/ril_commands.h \
  2006. + | egrep "^ *{RIL_" \
  2007. + | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/'
  2008. +*/
  2009. + switch(request) {
  2010. + case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS";
  2011. + case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN";
  2012. + case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK";
  2013. + case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2";
  2014. + case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2";
  2015. + case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN";
  2016. + case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2";
  2017. + case RIL_REQUEST_ENTER_DEPERSONALIZATION_CODE: return "ENTER_DEPERSONALIZATION_CODE";
  2018. + case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS";
  2019. + case RIL_REQUEST_DIAL: return "DIAL";
  2020. + case RIL_REQUEST_GET_IMSI: return "GET_IMSI";
  2021. + case RIL_REQUEST_HANGUP: return "HANGUP";
  2022. + case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND";
  2023. + case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND";
  2024. + case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE";
  2025. + case RIL_REQUEST_CONFERENCE: return "CONFERENCE";
  2026. + case RIL_REQUEST_UDUB: return "UDUB";
  2027. + case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE";
  2028. + case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH";
  2029. + case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE";
  2030. + case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE";
  2031. + case RIL_REQUEST_OPERATOR: return "OPERATOR";
  2032. + case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER";
  2033. + case RIL_REQUEST_DTMF: return "DTMF";
  2034. + case RIL_REQUEST_SEND_SMS: return "SEND_SMS";
  2035. + case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE";
  2036. + case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL";
  2037. + case RIL_REQUEST_SIM_IO: return "SIM_IO";
  2038. + case RIL_REQUEST_SEND_USSD: return "SEND_USSD";
  2039. + /* M: SS part */
  2040. + ///M: For query CNAP
  2041. + case RIL_REQUEST_SEND_CNAP: return "SEND_CNAP";
  2042. + /* M: SS part end */
  2043. + case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD";
  2044. + case RIL_REQUEST_GET_CLIR: return "GET_CLIR";
  2045. + case RIL_REQUEST_SET_CLIR: return "SET_CLIR";
  2046. + case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS";
  2047. + case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD";
  2048. + case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING";
  2049. + case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING";
  2050. + case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE";
  2051. + case RIL_REQUEST_GET_IMEI: return "GET_IMEI";
  2052. + case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV";
  2053. + case RIL_REQUEST_ANSWER: return "ANSWER";
  2054. + case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL";
  2055. + case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK";
  2056. + case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK";
  2057. + case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD";
  2058. + case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE";
  2059. + case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC";
  2060. + case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL";
  2061. + case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS ";
  2062. + case RIL_REQUEST_ABORT_QUERY_AVAILABLE_NETWORKS : return "ABORT_QUERY_AVAILABLE_NETWORKS";
  2063. + case RIL_REQUEST_DTMF_START: return "DTMF_START";
  2064. + case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP";
  2065. + case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION";
  2066. + case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION";
  2067. + case RIL_REQUEST_SET_MUTE: return "SET_MUTE";
  2068. + case RIL_REQUEST_GET_MUTE: return "GET_MUTE";
  2069. + case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP";
  2070. + case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE";
  2071. + case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST";
  2072. + case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO";
  2073. + case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW";
  2074. + case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS";
  2075. + case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE";
  2076. + case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION: return "SET_SUPP_SVC_NOTIFICATION";
  2077. + case RIL_REQUEST_WRITE_SMS_TO_SIM: return "WRITE_SMS_TO_SIM";
  2078. + case RIL_REQUEST_DELETE_SMS_ON_SIM: return "DELETE_SMS_ON_SIM";
  2079. + case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE";
  2080. + case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE";
  2081. + case RIL_REQUEST_STK_GET_PROFILE: return "REQUEST_STK_GET_PROFILE";
  2082. + case RIL_REQUEST_STK_SET_PROFILE: return "REQUEST_STK_SET_PROFILE";
  2083. + case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "REQUEST_STK_SEND_ENVELOPE_COMMAND";
  2084. + case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "REQUEST_STK_SEND_TERMINAL_RESPONSE";
  2085. + case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
  2086. + case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "REQUEST_EXPLICIT_CALL_TRANSFER";
  2087. + case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "REQUEST_SET_PREFERRED_NETWORK_TYPE";
  2088. + case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "REQUEST_GET_PREFERRED_NETWORK_TYPE";
  2089. + case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "REQUEST_GET_NEIGHBORING_CELL_IDS";
  2090. + case RIL_REQUEST_SET_LOCATION_UPDATES: return "REQUEST_SET_LOCATION_UPDATES";
  2091. + case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE: return "RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE";
  2092. + case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE: return "RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE";
  2093. + case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE: return "RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE";
  2094. + case RIL_REQUEST_SET_TTY_MODE: return "RIL_REQUEST_SET_TTY_MODE";
  2095. + case RIL_REQUEST_QUERY_TTY_MODE: return "RIL_REQUEST_QUERY_TTY_MODE";
  2096. + case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE: return "RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE";
  2097. + case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE: return "RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE";
  2098. + case RIL_REQUEST_CDMA_FLASH: return "RIL_REQUEST_CDMA_FLASH";
  2099. + case RIL_REQUEST_CDMA_BURST_DTMF: return "RIL_REQUEST_CDMA_BURST_DTMF";
  2100. + case RIL_REQUEST_CDMA_SEND_SMS: return "RIL_REQUEST_CDMA_SEND_SMS";
  2101. + case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE: return "RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE";
  2102. + case RIL_REQUEST_GSM_GET_BROADCAST_CONFIG: return "RIL_REQUEST_GSM_GET_BROADCAST_CONFIG";
  2103. + case RIL_REQUEST_GSM_SET_BROADCAST_CONFIG: return "RIL_REQUEST_GSM_SET_BROADCAST_CONFIG";
  2104. + case RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG: return "RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG";
  2105. + case RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG: return "RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG";
  2106. + case RIL_REQUEST_GSM_BROADCAST_ACTIVATION: return "RIL_REQUEST_GSM_BROADCAST_ACTIVATION";
  2107. + case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return "RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY";
  2108. + case RIL_REQUEST_CDMA_BROADCAST_ACTIVATION: return "RIL_REQUEST_CDMA_BROADCAST_ACTIVATION";
  2109. + case RIL_REQUEST_CDMA_SUBSCRIPTION: return "RIL_REQUEST_CDMA_SUBSCRIPTION";
  2110. + case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM";
  2111. + case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM";
  2112. + case RIL_REQUEST_DEVICE_IDENTITY: return "RIL_REQUEST_DEVICE_IDENTITY";
  2113. + case RIL_REQUEST_GET_SMSC_ADDRESS: return "RIL_REQUEST_GET_SMSC_ADDRESS";
  2114. + case RIL_REQUEST_SET_SMSC_ADDRESS: return "RIL_REQUEST_SET_SMSC_ADDRESS";
  2115. + case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "REQUEST_EXIT_EMERGENCY_CALLBACK_MODE";
  2116. + case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "RIL_REQUEST_REPORT_SMS_MEMORY_STATUS";
  2117. + case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING";
  2118. + case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE";
  2119. + case RIL_REQUEST_ISIM_AUTHENTICATION: return "RIL_REQUEST_ISIM_AUTHENTICATION";
  2120. + case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU";
  2121. + case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS";
  2122. + case RIL_REQUEST_VOICE_RADIO_TECH: return "RIL_REQUEST_VOICE_RADIO_TECH";
  2123. + case RIL_REQUEST_GET_CELL_INFO_LIST: return "RIL_REQUEST_GET_CELL_INFO_LIST";
  2124. + case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: return "RIL_REQUEST_SET_CELL_INFO_LIST_RATE";
  2125. + case RIL_REQUEST_SET_INITIAL_ATTACH_APN: return "RIL_REQUEST_SET_INITIAL_ATTACH_APN";
  2126. + case RIL_REQUEST_SET_DATA_PROFILE: return "RIL_REQUEST_SET_DATA_PROFILE";
  2127. + case RIL_REQUEST_IMS_REGISTRATION_STATE: return "RIL_REQUEST_IMS_REGISTRATION_STATE";
  2128. + case RIL_REQUEST_IMS_SEND_SMS: return "RIL_REQUEST_IMS_SEND_SMS";
  2129. + case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: return "RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC";
  2130. + case RIL_REQUEST_SIM_OPEN_CHANNEL: return "RIL_REQUEST_SIM_OPEN_CHANNEL";
  2131. + case RIL_REQUEST_SIM_CLOSE_CHANNEL: return "RIL_REQUEST_SIM_CLOSE_CHANNEL";
  2132. + case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: return "RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL";
  2133. + case RIL_REQUEST_NV_READ_ITEM: return "RIL_REQUEST_NV_READ_ITEM";
  2134. + case RIL_REQUEST_NV_WRITE_ITEM: return "RIL_REQUEST_NV_WRITE_ITEM";
  2135. + case RIL_REQUEST_NV_WRITE_CDMA_PRL: return "RIL_REQUEST_NV_WRITE_CDMA_PRL";
  2136. + case RIL_REQUEST_NV_RESET_CONFIG: return "RIL_REQUEST_NV_RESET_CONFIG";
  2137. + case RIL_REQUEST_SET_UICC_SUBSCRIPTION: return "RIL_REQUEST_SET_UICC_SUBSCRIPTION";
  2138. + case RIL_REQUEST_ALLOW_DATA: return "RIL_REQUEST_ALLOW_DATA";
  2139. + case RIL_REQUEST_GET_HARDWARE_CONFIG: return "GET_HARDWARE_CONFIG";
  2140. + case RIL_REQUEST_SIM_AUTHENTICATION: return "RIL_REQUEST_SIM_AUTHENTICATION";
  2141. + case RIL_REQUEST_SHUTDOWN: return "RIL_REQUEST_SHUTDOWN";
  2142. + case RIL_REQUEST_SET_PHONE_RAT_FAMILY: return "RIL_REQUEST_SET_PHONE_RAT_FAMILY";
  2143. + case RIL_REQUEST_GET_PHONE_RAT_FAMILY: return "RIL_REQUEST_GET_PHONE_RAT_FAMILY";
  2144. +
  2145. + /* M: call control part start */
  2146. + case RIL_REQUEST_HANGUP_ALL: return "HANGUP_ALL";
  2147. + case RIL_REQUEST_FORCE_RELEASE_CALL: return "FORCE_RELEASE_CALL";
  2148. + case RIL_REQUEST_SET_CALL_INDICATION: return "SET_CALL_INDICATION";
  2149. + case RIL_REQUEST_EMERGENCY_DIAL: return "EMERGENCY_DIAL";
  2150. + case RIL_REQUEST_SET_ECC_SERVICE_CATEGORY: return "SET_ECC_SERVICE_CATEGORY";
  2151. + case RIL_REQUEST_SET_ECC_LIST: return "SET_ECC_LIST";
  2152. + case RIL_REQUEST_SET_SPEECH_CODEC_INFO: return "SET_SPEECH_CODEC_INFO";
  2153. + /* M: call control part end */
  2154. +
  2155. + /// M: IMS feature. @{
  2156. + case RIL_REQUEST_ADD_IMS_CONFERENCE_CALL_MEMBER: return "RIL_REQUEST_ADD_IMS_CONFERENCE_CALL_MEMBER";
  2157. + case RIL_REQUEST_REMOVE_IMS_CONFERENCE_CALL_MEMBER: return "RIL_REQUEST_REMOVE_IMS_CONFERENCE_CALL_MEMBER";
  2158. + case RIL_REQUEST_DIAL_WITH_SIP_URI: return "RIL_REQUEST_DIAL_WITH_SIP_URI";
  2159. + case RIL_REQUEST_RETRIEVE_HELD_CALL: return "RIL_REQUEST_RETRIEVE_HELD_CALL";
  2160. + /// @}
  2161. +
  2162. + //MTK-START SIM ME lock
  2163. + case RIL_REQUEST_QUERY_SIM_NETWORK_LOCK: return "QUERY_SIM_NETWORK_LOCK";
  2164. + case RIL_REQUEST_SET_SIM_NETWORK_LOCK: return "SET_SIM_NETWORK_LOCK";
  2165. + //MTK-END SIM ME lock
  2166. + //ISIM
  2167. + case RIL_REQUEST_GENERAL_SIM_AUTH: return "RIL_REQUEST_GENERAL_SIM_AUTH";
  2168. + case RIL_REQUEST_OPEN_ICC_APPLICATION: return "RIL_REQUEST_OPEN_ICC_APPLICATION";
  2169. + case RIL_REQUEST_GET_ICC_APPLICATION_STATUS: return "RIL_REQUEST_GET_ICC_APPLICATION_STATUS";
  2170. + case RIL_REQUEST_SIM_IO_EX: return "SIM_IO_EX";
  2171. +
  2172. + // PHB Start
  2173. + case RIL_REQUEST_QUERY_PHB_STORAGE_INFO: return "RIL_REQUEST_QUERY_PHB_STORAGE_INFO";
  2174. + case RIL_REQUEST_WRITE_PHB_ENTRY: return "RIL_REQUEST_WRITE_PHB_ENTRY";
  2175. + case RIL_REQUEST_READ_PHB_ENTRY: return "RIL_REQUEST_READ_PHB_ENTRY";
  2176. + case RIL_REQUEST_QUERY_UPB_CAPABILITY: return "RIL_REQUEST_QUERY_UPB_CAPABILITY";
  2177. + case RIL_REQUEST_EDIT_UPB_ENTRY: return "RIL_REQUEST_EDIT_UPB_ENTRY";
  2178. + case RIL_REQUEST_DELETE_UPB_ENTRY: return "RIL_REQUEST_DELETE_UPB_ENTRY";
  2179. + case RIL_REQUEST_READ_UPB_GAS_LIST: return "RIL_REQUEST_READ_UPB_GAS_LIST";
  2180. + case RIL_REQUEST_READ_UPB_GRP: return "RIL_REQUEST_READ_UPB_GRP";
  2181. + case RIL_REQUEST_WRITE_UPB_GRP: return "RIL_REQUEST_WRITE_UPB_GRP";
  2182. + case RIL_REQUEST_GET_PHB_STRING_LENGTH: return "RIL_REQUEST_GET_PHB_STRING_LENGTH";
  2183. + case RIL_REQUEST_GET_PHB_MEM_STORAGE: return "RIL_REQUEST_GET_PHB_MEM_STORAGE";
  2184. + case RIL_REQUEST_SET_PHB_MEM_STORAGE: return "RIL_REQUEST_SET_PHB_MEM_STORAGE";
  2185. + case RIL_REQUEST_READ_PHB_ENTRY_EXT: return "RIL_REQUEST_READ_PHB_ENTRY_EXT";
  2186. + case RIL_REQUEST_WRITE_PHB_ENTRY_EXT: return "RIL_REQUEST_WRITE_PHB_ENTRY_EXT";
  2187. + // PHB End
  2188. +
  2189. + /* M: network part start */
  2190. + case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL_WITH_ACT: return "SET_NETWORK_SELECTION_MANUAL_WITH_ACT";
  2191. + case RIL_REQUEST_GET_POL_CAPABILITY: return "RIL_REQUEST_GET_POL_CAPABILITY";
  2192. + case RIL_REQUEST_GET_POL_LIST: return "RIL_REQUEST_GET_POL_LIST";
  2193. + case RIL_REQUEST_SET_POL_ENTRY: return "RIL_REQUEST_SET_POL_ENTRY";
  2194. + case RIL_REQUEST_SET_TRM: return "RIL_REQUEST_SET_TRM";
  2195. + case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS_WITH_ACT : return "QUERY_AVAILABLE_NETWORKS_WITH_ACT";
  2196. + //Femtocell (CSG) feature START
  2197. + case RIL_REQUEST_GET_FEMTOCELL_LIST: return "RIL_REQUEST_GET_FEMTOCELL_LIST";
  2198. + case RIL_REQUEST_ABORT_FEMTOCELL_LIST: return "RIL_REQUEST_ABORT_FEMTOCELL_LIST";
  2199. + case RIL_REQUEST_SELECT_FEMTOCELL: return "RIL_REQUEST_SELECT_FEMTOCELL";
  2200. + //Femtocell (CSG) feature END
  2201. + /* M: network part end */
  2202. + case RIL_REQUEST_STK_EVDL_CALL_BY_AP: return "RIL_REQUEST_STK_EVDL_CALL_BY_AP";
  2203. + case RIL_REQUEST_QUERY_MODEM_TYPE: return "RIL_REQUEST_QUERY_MODEM_TYPE";
  2204. + case RIL_REQUEST_STORE_MODEM_TYPE: return "RIL_REQUEST_STORE_MODEM_TYPE";
  2205. + case RIL_REQUEST_SIM_GET_ATR: return "SIM_GET_ATR";
  2206. + case RIL_REQUEST_SIM_OPEN_CHANNEL_WITH_SW: return "SIM_OPEN_CHANNEL_WITH_SW";
  2207. + //VoLTE
  2208. + case RIL_REQUEST_SETUP_DEDICATE_DATA_CALL: return "RIL_REQUEST_SETUP_DEDICATE_DATA_CALL";
  2209. + case RIL_REQUEST_DEACTIVATE_DEDICATE_DATA_CALL: return "RIL_REQUEST_DEACTIVATE_DEDICATE_DATA_CALL";
  2210. + case RIL_REQUEST_MODIFY_DATA_CALL: return "RIL_REQUEST_MODIFY_DATA_CALL";
  2211. + case RIL_REQUEST_ABORT_SETUP_DATA_CALL: return "RIL_REQUEST_ABORT_SETUP_DATA_CALL";
  2212. + case RIL_REQUEST_PCSCF_DISCOVERY_PCO: return "RIL_REQUEST_PCSCF_DISCOVERY_PCO";
  2213. + case RIL_REQUEST_CLEAR_DATA_BEARER: return "RIL_REQUEST_CLEAR_DATA_BEARER";
  2214. +
  2215. + // IMS
  2216. + case RIL_REQUEST_SET_IMS_ENABLE: return "RIL_REQUEST_SET_IMS_ENABLE";
  2217. +
  2218. + // M: Fast Dormancy
  2219. + case RIL_REQUEST_SET_SCRI: return "RIL_REQUEST_SET_SCRI";
  2220. + case RIL_REQUEST_SET_FD_MODE: return "RIL_REQUEST_SET_FD_MODE";
  2221. + // MTK-START, SMS part
  2222. + case RIL_REQUEST_GET_SMS_PARAMS: return "RIL_REQUEST_GET_SMS_PARAMS";
  2223. + case RIL_REQUEST_SET_SMS_PARAMS: return "RIL_REQUEST_SET_SMS_PARAMS";
  2224. + case RIL_REQUEST_GET_SMS_SIM_MEM_STATUS: return "RIL_REQUEST_GET_SMS_SIM_MEM_STATUS";
  2225. + case RIL_REQUEST_SET_ETWS: return "RIL_REQUEST_SET_ETWS";
  2226. + case RIL_REQUEST_SET_CB_CHANNEL_CONFIG_INFO:
  2227. + return "RIL_REQUEST_SET_CB_CHANNEL_CONFIG_INFO";
  2228. + case RIL_REQUEST_SET_CB_LANGUAGE_CONFIG_INFO:
  2229. + return "RIL_REQUEST_SET_CB_LANGUAGE_CONFIG_INFO";
  2230. + case RIL_REQUEST_GET_CB_CONFIG_INFO: return "RIL_REQUEST_GET_CB_CONFIG_INFO";
  2231. + case RIL_REQUEST_REMOVE_CB_MESSAGE: return "RIL_REQUEST_REMOVE_CB_MESSAGE";
  2232. + // MTK-END, SMS part
  2233. + case RIL_REQUEST_SET_DATA_CENTRIC: return "RIL_REQUEST_SET_DATA_CENTRIC";
  2234. +
  2235. + case RIL_REQUEST_MODEM_POWEROFF: return "MODEM_POWEROFF";
  2236. + case RIL_REQUEST_MODEM_POWERON: return "MODEM_POWERON";
  2237. + // M: CC33 LTE.
  2238. + case RIL_REQUEST_SET_DATA_ON_TO_MD: return "RIL_REQUEST_SET_DATA_ON_TO_MD";
  2239. + case RIL_REQUEST_SET_REMOVE_RESTRICT_EUTRAN_MODE: return "RIL_REQUEST_SET_REMOVE_RESTRICT_EUTRAN_MODE";
  2240. + case RIL_REQUEST_BTSIM_CONNECT: return "RIL_REQUEST_BTSIM_CONNECT";
  2241. + case RIL_REQUEST_BTSIM_DISCONNECT_OR_POWEROFF: return "RIL_REQUEST_BTSIM_DISCONNECT_OR_POWEROFF";
  2242. + case RIL_REQUEST_BTSIM_POWERON_OR_RESETSIM: return "RIL_REQUEST_BTSIM_POWERON_OR_RESETSIM";
  2243. + case RIL_REQUEST_BTSIM_TRANSFERAPDU: return "RIL_REQUEST_SEND_BTSIM_TRANSFERAPDU";
  2244. +
  2245. + /* M: call control part start */
  2246. + case RIL_REQUEST_SET_IMS_CALL_STATUS: return "RIL_REQUEST_SET_IMS_CALL_STATUS";
  2247. + /* M: call control part end */
  2248. +
  2249. + /* M: C2K part start */
  2250. + case RIL_REQUEST_GET_NITZ_TIME: return "RIL_REQUEST_GET_NITZ_TIME";
  2251. + case RIL_REQUEST_QUERY_UIM_INSERTED: return "RIL_REQUEST_QUERY_UIM_INSERTED";
  2252. + case RIL_REQUEST_SWITCH_HPF: return "RIL_REQUEST_SWITCH_HPF";
  2253. + case RIL_REQUEST_SET_AVOID_SYS: return "RIL_REQUEST_SET_AVOID_SYS";
  2254. + case RIL_REQUEST_QUERY_AVOID_SYS: return "RIL_REQUEST_QUERY_AVOID_SYS";
  2255. + case RIL_REQUEST_QUERY_CDMA_NETWORK_INFO: return "RIL_REQUEST_QUERY_CDMA_NETWORK_INFO";
  2256. + case RIL_REQUEST_GET_LOCAL_INFO: return "RIL_REQUEST_GET_LOCAL_INFO";
  2257. + case RIL_REQUEST_UTK_REFRESH: return "RIL_REQUEST_UTK_REFRESH";
  2258. + case RIL_REQUEST_QUERY_SMS_AND_PHONEBOOK_STATUS:
  2259. + return "RIL_REQUEST_QUERY_SMS_AND_PHONEBOOK_STATUS";
  2260. + case RIL_REQUEST_QUERY_NETWORK_REGISTRATION:
  2261. + return "RIL_REQUEST_QUERY_NETWORK_REGISTRATION";
  2262. + case RIL_REQUEST_AGPS_TCP_CONNIND: return "RIL_REQUEST_AGPS_TCP_CONNIND";
  2263. + case RIL_REQUEST_AGPS_SET_MPC_IPPORT: return "RIL_REQUEST_AGPS_SET_MPC_IPPORT";
  2264. + case RIL_REQUEST_AGPS_GET_MPC_IPPORT: return "RIL_REQUEST_AGPS_GET_MPC_IPPORT";
  2265. + case RIL_REQUEST_SET_MEID: return "RIL_REQUEST_SET_MEID";
  2266. + case RIL_REQUEST_SET_REG_RESUME: return "RIL_REQUEST_SET_REG_RESUME";
  2267. + case RIL_REQUEST_ENABLE_REG_PAUSE: return "RIL_REQUEST_ENABLE_REG_PAUSE";
  2268. + case RIL_REQUEST_SET_ETS_DEV: return "RIL_REQUEST_SET_ETS_DEV";
  2269. + case RIL_REQUEST_WRITE_MDN: return "RIL_REQUEST_WRITE_MDN";
  2270. + case RIL_REQUEST_SET_VIA_TRM: return "RIL_REQUEST_SET_VIA_TRM";
  2271. + case RIL_REQUEST_SET_ARSI_THRESHOLD: return "RIL_REQUEST_SET_ARSI_THRESHOLD";
  2272. + /* M: C2K part end */
  2273. + default: return "<unknown request> (" + request + ")";
  2274. + }
  2275. + }
  2276. +
  2277. + // VoLTE
  2278. + private Object
  2279. + responseDeactivateDataCall(Parcel p) {
  2280. + int [] cidArray = null;
  2281. + if (p.dataSize() > 0 ) { //checking Parcel data value
  2282. + cidArray = (int []) responseInts(p);
  2283. + }
  2284. +
  2285. + return cidArray;
  2286. + }
  2287. +
  2288. + private Object
  2289. + responseOperator(Parcel p) {
  2290. + int num;
  2291. + String response[] = null;
  2292. +
  2293. + response = p.readStringArray();
  2294. +
  2295. + if (false) {
  2296. + num = p.readInt();
  2297. +
  2298. + response = new String[num];
  2299. + for (int i = 0; i < num; i++) {
  2300. + response[i] = p.readString();
  2301. + }
  2302. + }
  2303. +
  2304. + for (int i = 0; i < response.length; i++) {
  2305. + if((response[i] != null) && (response[i].startsWith("uCs2") == true))
  2306. + {
  2307. + riljLog("responseOperator handling UCS2 format name: response[" + i + "]");
  2308. + try{
  2309. + response[i] = new String(hexStringToBytes(response[i].substring(4)),"UTF-16");
  2310. + }catch(UnsupportedEncodingException ex){
  2311. + riljLog("responseOperatorInfos UnsupportedEncodingException");
  2312. + }
  2313. + }
  2314. + }
  2315. +
  2316. + // NOTE: the original code seemingly has some nontrivial SpnOverride
  2317. + // modifications, so I'm not going to port that.
  2318. + if (response.length > 2 && response[2] != null) {
  2319. + if (response[0] != null && (response[0].equals("") || response[0].equals(response[2]))) {
  2320. + Operators init = new Operators ();
  2321. + String temp = init.unOptimizedOperatorReplace(response[2]);
  2322. + riljLog("lookup RIL responseOperator() " + response[2] + " gave " + temp + " was " + response[0] + "/" + response[1] + " before.");
  2323. + response[0] = temp;
  2324. + response[1] = temp;
  2325. + }
  2326. + }
  2327. +
  2328. + return response;
  2329. + }
  2330. +
  2331. + private Object
  2332. + responsePhoneId() {
  2333. + return mInstanceId;
  2334. + }
  2335. +
  2336. + static String
  2337. + responseToString(int request)
  2338. + {
  2339. +/*
  2340. + cat libs/telephony/ril_unsol_commands.h \
  2341. + | egrep "^ *{RIL_" \
  2342. + | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/'
  2343. +*/
  2344. + switch(request) {
  2345. + case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
  2346. + case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
  2347. + case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
  2348. + case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS";
  2349. + case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
  2350. + case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
  2351. + case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD";
  2352. + case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST";
  2353. + case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
  2354. + case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
  2355. + case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
  2356. + case RIL_UNSOL_SUPP_SVC_NOTIFICATION: return "UNSOL_SUPP_SVC_NOTIFICATION";
  2357. + case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
  2358. + case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
  2359. + case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
  2360. + case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
  2361. + case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FULL";
  2362. + case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
  2363. + case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
  2364. + case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
  2365. + case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_RESPONSE_CDMA_NEW_SMS";
  2366. + case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_RESPONSE_NEW_BROADCAST_SMS";
  2367. + case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL";
  2368. + case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED";
  2369. + case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE";
  2370. + case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING";
  2371. + case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS";
  2372. + case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC";
  2373. + case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW";
  2374. + case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE";
  2375. + case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE";
  2376. + case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "CDMA_SUBSCRIPTION_SOURCE_CHANGED";
  2377. + case RIL_UNSOl_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED";
  2378. + case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE";
  2379. + case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED";
  2380. + case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED";
  2381. + case RIL_UNSOL_CELL_INFO_LIST: return "UNSOL_CELL_INFO_LIST";
  2382. + case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED:
  2383. + return "UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED";
  2384. + case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED:
  2385. + return "RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED";
  2386. + case RIL_UNSOL_SRVCC_STATE_NOTIFY:
  2387. + return "UNSOL_SRVCC_STATE_NOTIFY";
  2388. + case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "RIL_UNSOL_HARDWARE_CONFIG_CHANGED";
  2389. + case RIL_UNSOL_ON_SS: return "UNSOL_ON_SS";
  2390. + case RIL_UNSOL_STK_CC_ALPHA_NOTIFY: return "UNSOL_STK_CC_ALPHA_NOTIFY";
  2391. + case RIL_UNSOL_STK_SEND_SMS_RESULT: return "RIL_UNSOL_STK_SEND_SMS_RESULT";
  2392. + case RIL_UNSOL_SET_PHONE_RAT_FAMILY_COMPLETE:
  2393. + return "RIL_UNSOL_SET_PHONE_RAT_FAMILY_COMPLETE";
  2394. + /* M: call control part start */
  2395. + case RIL_UNSOL_CALL_FORWARDING: return "UNSOL_CALL_FORWARDING";
  2396. + case RIL_UNSOL_CRSS_NOTIFICATION: return "UNSOL_CRSS_NOTIFICATION";
  2397. + case RIL_UNSOL_INCOMING_CALL_INDICATION: return "UNSOL_INCOMING_CALL_INDICATION";
  2398. + case RIL_UNSOL_CIPHER_INDICATION: return "UNSOL_CIPHER_INDICATION";
  2399. + case RIL_UNSOL_CNAP: return "UNSOL_CNAP";
  2400. + case RIL_UNSOL_SPEECH_CODEC_INFO: return "UNSOL_SPEECH_CODEC_INFO";
  2401. + /* M: call control part end */
  2402. + //MTK-START multiple application support
  2403. + case RIL_UNSOL_APPLICATION_SESSION_ID_CHANGED: return "RIL_UNSOL_APPLICATION_SESSION_ID_CHANGED";
  2404. + //MTK-END multiple application support
  2405. + case RIL_UNSOL_SIM_MISSING: return "UNSOL_SIM_MISSING";
  2406. + case RIL_UNSOL_VIRTUAL_SIM_ON: return "UNSOL_VIRTUAL_SIM_ON";
  2407. + case RIL_UNSOL_VIRTUAL_SIM_OFF: return "UNSOL_VIRTUAL_SIM_ON_OFF";
  2408. + case RIL_UNSOL_SIM_RECOVERY: return "UNSOL_SIM_RECOVERY";
  2409. + case RIL_UNSOL_SIM_PLUG_OUT: return "UNSOL_SIM_PLUG_OUT";
  2410. + case RIL_UNSOL_SIM_PLUG_IN: return "UNSOL_SIM_PLUG_IN";
  2411. + case RIL_UNSOL_SIM_COMMON_SLOT_NO_CHANGED: return "RIL_UNSOL_SIM_COMMON_SLOT_NO_CHANGED";
  2412. + case RIL_UNSOL_DATA_ALLOWED: return "RIL_UNSOL_DATA_ALLOWED";
  2413. + case RIL_UNSOL_PHB_READY_NOTIFICATION: return "UNSOL_PHB_READY_NOTIFICATION";
  2414. + case RIL_UNSOL_IMEI_LOCK: return "UNSOL_IMEI_LOCK";
  2415. + case RIL_UNSOL_RESPONSE_ACMT: return "UNSOL_ACMT_INFO";
  2416. + case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED";
  2417. + case RIL_UNSOL_RESPONSE_MMRR_STATUS_CHANGED: return "UNSOL_RESPONSE_MMRR_STATUS_CHANGED";
  2418. + case RIL_UNSOL_NEIGHBORING_CELL_INFO: return "UNSOL_NEIGHBORING_CELL_INFO";
  2419. + case RIL_UNSOL_NETWORK_INFO: return "UNSOL_NETWORK_INFO";
  2420. + case RIL_UNSOL_INVALID_SIM: return "RIL_UNSOL_INVALID_SIM";
  2421. + case RIL_UNSOL_IMS_ENABLE_DONE: return "RIL_UNSOL_IMS_ENABLE_DONE";
  2422. + case RIL_UNSOL_IMS_DISABLE_DONE: return "RIL_UNSOL_IMS_DISABLE_DONE";
  2423. + case RIL_UNSOL_IMS_REGISTRATION_INFO: return "RIL_UNSOL_IMS_REGISTRATION_INFO";
  2424. + case RIL_UNSOL_STK_SETUP_MENU_RESET: return "RIL_UNSOL_STK_SETUP_MENU_RESET";
  2425. + case RIL_UNSOL_RESPONSE_PLMN_CHANGED: return "RIL_UNSOL_RESPONSE_PLMN_CHANGED";
  2426. + case RIL_UNSOL_RESPONSE_REGISTRATION_SUSPENDED: return "RIL_UNSOL_RESPONSE_REGISTRATION_SUSPENDED";
  2427. + //VoLTE
  2428. + case RIL_UNSOL_DEDICATE_BEARER_ACTIVATED: return "RIL_UNSOL_DEDICATE_BEARER_ACTIVATED";
  2429. + case RIL_UNSOL_DEDICATE_BEARER_MODIFIED: return "RIL_UNSOL_DEDICATE_BEARER_MODIFIED";
  2430. + //Remote SIM ME lock related APIs [Start]
  2431. + case RIL_UNSOL_MELOCK_NOTIFICATION: return "RIL_UNSOL_MELOCK_NOTIFICATION";
  2432. + //Remote SIM ME lock related APIs [End]
  2433. + // M: Fast Dormancy
  2434. + case RIL_UNSOL_SCRI_RESULT: return "RIL_UNSOL_SCRI_RESULT";
  2435. + case RIL_UNSOL_STK_EVDL_CALL: return "RIL_UNSOL_STK_EVDL_CALL";
  2436. + case RIL_UNSOL_STK_CALL_CTRL: return "RIL_UNSOL_STK_CALL_CTRL";
  2437. +
  2438. + /// M: IMS feature. @{
  2439. + case RIL_UNSOL_ECONF_SRVCC_INDICATION: return "RIL_UNSOL_ECONF_SRVCC_INDICATION";
  2440. + //For updating conference call merged/added result.
  2441. + case RIL_UNSOL_ECONF_RESULT_INDICATION: return "RIL_UNSOL_ECONF_RESULT_INDICATION";
  2442. + //For updating call mode and pau information.
  2443. + case RIL_UNSOL_CALL_INFO_INDICATION : return "RIL_UNSOL_CALL_INFO_INDICATION";
  2444. + /// @}
  2445. +
  2446. + case RIL_UNSOL_VOLTE_EPS_NETWORK_FEATURE_INFO: return "RIL_UNSOL_VOLTE_EPS_NETWORK_FEATURE_INFO";
  2447. + case RIL_UNSOL_SRVCC_HANDOVER_INFO_INDICATION: return "RIL_UNSOL_SRVCC_HANDOVER_INFO_INDICATION";
  2448. + // M: CC33 LTE.
  2449. + case RIL_UNSOL_RAC_UPDATE: return "RIL_UNSOL_RAC_UPDATE";
  2450. + case RIL_UNSOL_REMOVE_RESTRICT_EUTRAN: return "RIL_UNSOL_REMOVE_RESTRICT_EUTRAN";
  2451. +
  2452. + //MTK-START for MD state change
  2453. + case RIL_UNSOL_MD_STATE_CHANGE: return "RIL_UNSOL_MD_STATE_CHANGE";
  2454. + //MTK-END for MD state change
  2455. +
  2456. + case RIL_UNSOL_MO_DATA_BARRING_INFO: return "RIL_UNSOL_MO_DATA_BARRING_INFO";
  2457. + case RIL_UNSOL_SSAC_BARRING_INFO: return "RIL_UNSOL_SSAC_BARRING_INFO";
  2458. +//MTK_TC1_FEATURE for LGE CSMCC_MO_CALL_MODIFIED {
  2459. + case RIL_UNSOL_RESPONSE_MO_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_MO_CALL_STATE_CHANGED";
  2460. +//}
  2461. + /* M: C2K part start */
  2462. + case RIL_UNSOL_CDMA_CALL_ACCEPTED: return "RIL_UNSOL_CDMA_CALL_ACCEPTED";
  2463. + case RIL_UNSOL_UTK_SESSION_END: return "RIL_UNSOL_UTK_SESSION_END";
  2464. + case RIL_UNSOL_UTK_PROACTIVE_COMMAND: return "RIL_UNSOL_UTK_PROACTIVE_COMMAND";
  2465. + case RIL_UNSOL_UTK_EVENT_NOTIFY: return "RIL_UNSOL_UTK_EVENT_NOTIFY";
  2466. + case RIL_UNSOL_VIA_GPS_EVENT: return "RIL_UNSOL_VIA_GPS_EVENT";
  2467. + case RIL_UNSOL_VIA_NETWORK_TYPE_CHANGE: return "RIL_UNSOL_VIA_NETWORK_TYPE_CHANGE";
  2468. + case RIL_UNSOL_VIA_PLMN_CHANGE_REG_PAUSE: return "RIL_UNSOL_VIA_PLMN_CHANGE_REG_PAUSE";
  2469. + case RIL_UNSOL_VIA_INVALID_SIM_DETECTED: return "RIL_UNSOL_VIA_INVALID_SIM_DETECTED";
  2470. + /* M: C2K part end */
  2471. + default: return "<unknown response> (" + request + ")";
  2472. + }
  2473. + }
  2474. +
  2475. + /*
  2476. + * to protect modem status we need to avoid two case :
  2477. + * 1. DTMF start -> CHLD request -> DTMF stop
  2478. + * 2. CHLD request -> DTMF request
  2479. + */
  2480. + private void handleChldRelatedRequest(RILRequest rr) {
  2481. + synchronized (mDtmfReqQueue) {
  2482. + int queueSize = mDtmfReqQueue.size();
  2483. + int i, j;
  2484. + if (queueSize > 0) {
  2485. + RILRequest rr2 = mDtmfReqQueue.get();
  2486. + if (rr2.mRequest == RIL_REQUEST_DTMF_START) {
  2487. + // need to send the STOP command
  2488. + if (RILJ_LOGD) riljLog("DTMF queue isn't 0, first request is START, send stop dtmf and pending switch");
  2489. + if (queueSize > 1) {
  2490. + j = 2;
  2491. + } else {
  2492. + // need to create a new STOP command
  2493. + j = 1;
  2494. + }
  2495. + if (RILJ_LOGD) riljLog("queue size " + mDtmfReqQueue.size());
  2496. +
  2497. + for (i = queueSize - 1; i >= j; i--) {
  2498. + mDtmfReqQueue.remove(i);
  2499. + }
  2500. + if (RILJ_LOGD) riljLog("queue size after " + mDtmfReqQueue.size());
  2501. + if (mDtmfReqQueue.size() == 1) { // only start command, we need to add stop command
  2502. + RILRequest rr3 = RILRequest.obtain(RIL_REQUEST_DTMF_STOP, null);
  2503. + if (RILJ_LOGD) riljLog("add dummy stop dtmf request");
  2504. + mDtmfReqQueue.stop();
  2505. + mDtmfReqQueue.add(rr3);
  2506. + }
  2507. + }
  2508. + else {
  2509. + // first request is STOP, just remove it and send switch
  2510. + if (RILJ_LOGD) riljLog("DTMF queue isn't 0, first request is STOP, penging switch");
  2511. + j = 1;
  2512. + for (i = queueSize - 1; i >= j; i--) {
  2513. + mDtmfReqQueue.remove(i);
  2514. + }
  2515. + }
  2516. + mDtmfReqQueue.setPendingRequest(rr);
  2517. + } else {
  2518. + if (RILJ_LOGD) riljLog("DTMF queue is 0, send switch Immediately");
  2519. + mDtmfReqQueue.setSendChldRequest();
  2520. + send(rr);
  2521. + }
  2522. + }
  2523. + }
  2524. +
  2525. + private
  2526. + void setCallIndication(String[] incomingCallInfo) {
  2527. + RILRequest rr
  2528. + = RILRequest.obtain(RIL_REQUEST_SET_CALL_INDICATION, null);
  2529. +
  2530. + int callId = Integer.parseInt(incomingCallInfo[0]);
  2531. + int callMode = Integer.parseInt(incomingCallInfo[3]);
  2532. + int seqNumber = Integer.parseInt(incomingCallInfo[4]);
  2533. +
  2534. + // some guess work is needed here, for now, just 0
  2535. + callMode = 0;
  2536. +
  2537. + rr.mParcel.writeInt(3);
  2538. +
  2539. + rr.mParcel.writeInt(callMode);
  2540. + rr.mParcel.writeInt(callId);
  2541. + rr.mParcel.writeInt(seqNumber);
  2542. +
  2543. + if (RILJ_LOGD) riljLog(rr.serialString() + "> "
  2544. + + requestToString(rr.mRequest) + " " + callMode + " " + callId + " " + seqNumber);
  2545. +
  2546. + send(rr);
  2547. + }
  2548. +
  2549. + // Override setupDataCall as the MTK RIL needs 8th param CID (hardwired to 1?)
  2550. + @Override
  2551. + public void
  2552. + setupDataCall(String radioTechnology, String profile, String apn,
  2553. + String user, String password, String authType, String protocol,
  2554. + Message result) {
  2555. + RILRequest rr
  2556. + = RILRequest.obtain(RIL_REQUEST_SETUP_DATA_CALL, result);
  2557. +
  2558. + rr.mParcel.writeInt(8);
  2559. +
  2560. + rr.mParcel.writeString(radioTechnology);
  2561. + rr.mParcel.writeString(profile);
  2562. + rr.mParcel.writeString(apn);
  2563. + rr.mParcel.writeString(user);
  2564. + rr.mParcel.writeString(password);
  2565. + rr.mParcel.writeString(authType);
  2566. + rr.mParcel.writeString(protocol);
  2567. + rr.mParcel.writeString("1");
  2568. +
  2569. + if (RILJ_LOGD) riljLog(rr.serialString() + "> "
  2570. + + requestToString(rr.mRequest) + " " + radioTechnology + " "
  2571. + + profile + " " + apn + " " + user + " "
  2572. + + password + " " + authType + " " + protocol + "1");
  2573. +
  2574. + send(rr);
  2575. + }
  2576. +
  2577. + protected Object
  2578. + responseSignalStrength(Parcel p) {
  2579. + SignalStrength s = SignalStrength.makeSignalStrengthFromRilParcel(p);
  2580. + return new SignalStrength(s.getGsmSignalStrength(),
  2581. + s.getGsmBitErrorRate(),
  2582. + s.getCdmaDbm(),
  2583. + s.getCdmaEcio(),
  2584. + s.getEvdoDbm(),
  2585. + s.getEvdoEcio(),
  2586. + s.getEvdoSnr(),
  2587. + true);
  2588. + }
  2589. +
  2590. + private void setRadioStateFromRILInt (int stateCode) {
  2591. + switch (stateCode) {
  2592. + case 0: case 1: break; // radio off
  2593. + default:
  2594. + {
  2595. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_GPRS_TRANSFER_TYPE, null);
  2596. +
  2597. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  2598. +
  2599. + rr.mParcel.writeInt(1);
  2600. + rr.mParcel.writeInt(1);
  2601. +
  2602. + send(rr);
  2603. + }
  2604. + {
  2605. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_GPRS_CONNECT_TYPE, null);
  2606. +
  2607. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  2608. +
  2609. + rr.mParcel.writeInt(1);
  2610. + rr.mParcel.writeInt(1);
  2611. +
  2612. + send(rr);
  2613. + }
  2614. + }
  2615. + }
  2616. +
  2617. + /* Oh well... this broke non-dual-SIM phones including MX4 :-/
  2618. + @Override
  2619. + public void
  2620. + setRadioPower(boolean on, Message result) {
  2621. + if ((mInstanceId != null && mInstanceId == 1)) {
  2622. + riljLog("SetRadioPower: on/off ignored on SIM2");
  2623. + return;
  2624. + }
  2625. +
  2626. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_DUAL_SIM_MODE_SWITCH, result);
  2627. +
  2628. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  2629. +
  2630. + rr.mParcel.writeInt(1);
  2631. + rr.mParcel.writeInt(on ? 3 : -1); // SIM1 | SIM2 ?
  2632. + send(rr);
  2633. + }
  2634. + */
  2635. +
  2636. + @Override
  2637. + public void setUiccSubscription(int slotId, int appIndex, int subId,
  2638. + int subStatus, Message result) {
  2639. + if (RILJ_LOGD) riljLog("setUiccSubscription" + slotId + " " + appIndex + " " + subId + " " + subStatus);
  2640. +
  2641. + // Fake response (note: should be sent before mSubscriptionStatusRegistrants or
  2642. + // SubscriptionManager might not set the readiness correctly)
  2643. + AsyncResult.forMessage(result, 0, null);
  2644. + result.sendToTarget();
  2645. +
  2646. + // TODO: Actually turn off/on the radio (and don't fight with the ServiceStateTracker)
  2647. + if (subStatus == 1 /* ACTIVATE */) {
  2648. + // Subscription changed: enabled
  2649. + if (mSubscriptionStatusRegistrants != null) {
  2650. + mSubscriptionStatusRegistrants.notifyRegistrants(
  2651. + new AsyncResult (null, new int[] {1}, null));
  2652. + }
  2653. + } else if (subStatus == 0 /* DEACTIVATE */) {
  2654. + // Subscription changed: disabled
  2655. + if (mSubscriptionStatusRegistrants != null) {
  2656. + mSubscriptionStatusRegistrants.notifyRegistrants(
  2657. + new AsyncResult (null, new int[] {0}, null));
  2658. + }
  2659. + }
  2660. + }
  2661. +
  2662. + /**
  2663. + * {@inheritDoc}
  2664. + */
  2665. + @Override
  2666. + public void setPreferredNetworkType(int networkType , Message response) {
  2667. + RILRequest rr = RILRequest.obtain(
  2668. + RILConstants.RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE, response);
  2669. +
  2670. + rr.mParcel.writeInt(1);
  2671. + rr.mParcel.writeInt(networkType);
  2672. +
  2673. + mPreviousPreferredType = mPreferredNetworkType; //ALPS00799783
  2674. + mPreferredNetworkType = networkType;
  2675. +
  2676. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
  2677. + + " : " + networkType);
  2678. +
  2679. + send(rr);
  2680. + }
  2681. +
  2682. + /** M: add extra parameter */
  2683. + @Override
  2684. + public void setInitialAttachApn(String apn, String protocol, int authType, String username,
  2685. + String password, Message result) {
  2686. + Rlog.e(RILJ_LOG_TAG, "setInitialAttachApn: operatorNumeric is required on MTK!");
  2687. + setInitialAttachApn(apn, protocol, authType, username, password, "", false, result);
  2688. + }
  2689. +
  2690. + @Override
  2691. + public void setInitialAttachApn(String apn, String protocol, int authType, String username,
  2692. + String password, String operatorNumeric, boolean canHandleIms, Message result) {
  2693. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_INITIAL_ATTACH_APN, null);
  2694. +
  2695. + if (RILJ_LOGD) riljLog("Set RIL_REQUEST_SET_INITIAL_ATTACH_APN");
  2696. +
  2697. + rr.mParcel.writeString(apn);
  2698. + rr.mParcel.writeString(protocol);
  2699. + rr.mParcel.writeInt(authType);
  2700. + rr.mParcel.writeString(username);
  2701. + rr.mParcel.writeString(password);
  2702. +
  2703. + /** M: start */
  2704. + rr.mParcel.writeString(operatorNumeric);
  2705. + rr.mParcel.writeInt(canHandleIms ? 1 : 0);
  2706. + /* M: end */
  2707. +
  2708. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
  2709. + + ", apn:" + apn + ", protocol:" + protocol + ", authType:" + authType
  2710. + + ", username:" + username + ", password:" + password
  2711. + + ", operatorNumeric:" + operatorNumeric + ", canHandleIms:" + canHandleIms);
  2712. +
  2713. + send(rr);
  2714. + }
  2715. +
  2716. + private static int readRilMessage(InputStream is, byte[] buffer)
  2717. + throws IOException {
  2718. + int countRead;
  2719. + int offset;
  2720. + int remaining;
  2721. + int messageLength;
  2722. +
  2723. + // First, read in the length of the message
  2724. + offset = 0;
  2725. + remaining = 4;
  2726. + do {
  2727. + countRead = is.read(buffer, offset, remaining);
  2728. +
  2729. + if (countRead < 0 ) {
  2730. + Rlog.e(RILJ_LOG_TAG, "Hit EOS reading message length");
  2731. + return -1;
  2732. + }
  2733. +
  2734. + offset += countRead;
  2735. + remaining -= countRead;
  2736. + } while (remaining > 0);
  2737. +
  2738. + messageLength = ((buffer[0] & 0xff) << 24)
  2739. + | ((buffer[1] & 0xff) << 16)
  2740. + | ((buffer[2] & 0xff) << 8)
  2741. + | (buffer[3] & 0xff);
  2742. +
  2743. + // Then, re-use the buffer and read in the message itself
  2744. + offset = 0;
  2745. + remaining = messageLength;
  2746. + do {
  2747. + countRead = is.read(buffer, offset, remaining);
  2748. +
  2749. + if (countRead < 0 ) {
  2750. + Rlog.e(RILJ_LOG_TAG, "Hit EOS reading message. messageLength=" + messageLength
  2751. + + " remaining=" + remaining);
  2752. + return -1;
  2753. + }
  2754. +
  2755. + offset += countRead;
  2756. + remaining -= countRead;
  2757. + } while (remaining > 0);
  2758. +
  2759. + return messageLength;
  2760. + }
  2761. +
  2762. + protected RILReceiver createRILReceiver() {
  2763. + return new MTKRILReceiver();
  2764. + }
  2765. +
  2766. + protected class MTKRILReceiver extends RILReceiver {
  2767. + byte[] buffer;
  2768. +
  2769. + protected MTKRILReceiver() {
  2770. + buffer = new byte[RIL_MAX_COMMAND_BYTES];
  2771. + }
  2772. +
  2773. + @Override
  2774. + public void
  2775. + run() {
  2776. + int retryCount = 0;
  2777. + String rilSocket = "rild";
  2778. +
  2779. + try {for (;;) {
  2780. + LocalSocket s = null;
  2781. + LocalSocketAddress l;
  2782. +
  2783. + if (mInstanceId == null || mInstanceId == 0 ) {
  2784. + rilSocket = SOCKET_NAME_RIL[0];
  2785. + } else {
  2786. + rilSocket = SOCKET_NAME_RIL[mInstanceId];
  2787. + }
  2788. +
  2789. + int currentSim;
  2790. + if (mInstanceId == null || mInstanceId ==0) {
  2791. + currentSim = 0;
  2792. + } else {
  2793. + currentSim = mInstanceId;
  2794. + }
  2795. +
  2796. + int m3GsimId = 0;
  2797. + m3GsimId = SystemProperties.getInt("gsm.3gswitch", 0);
  2798. + if((m3GsimId > 0) && (m3GsimId <= 2)) {
  2799. + --m3GsimId;
  2800. + } else {
  2801. + m3GsimId = 0;
  2802. + }
  2803. +
  2804. + if (m3GsimId >= 1) {
  2805. + if (currentSim == 0) {
  2806. + rilSocket = SOCKET_NAME_RIL[m3GsimId];
  2807. + }
  2808. + else if(currentSim == m3GsimId) {
  2809. + rilSocket = SOCKET_NAME_RIL[0];
  2810. + }
  2811. + if (RILJ_LOGD) riljLog("Capability switched, swap sockets [" + currentSim + ", " + rilSocket + "]");
  2812. + }
  2813. +
  2814. + try {
  2815. + s = new LocalSocket();
  2816. + l = new LocalSocketAddress(rilSocket,
  2817. + LocalSocketAddress.Namespace.RESERVED);
  2818. + s.connect(l);
  2819. + } catch (IOException ex){
  2820. + try {
  2821. + if (s != null) {
  2822. + s.close();
  2823. + }
  2824. + } catch (IOException ex2) {
  2825. + //ignore failure to close after failure to connect
  2826. + }
  2827. +
  2828. + // don't print an error message after the the first time
  2829. + // or after the 8th time
  2830. +
  2831. + if (retryCount == 8) {
  2832. + Rlog.e (RILJ_LOG_TAG,
  2833. + "Couldn't find '" + rilSocket
  2834. + + "' socket after " + retryCount
  2835. + + " times, continuing to retry silently");
  2836. + } else if (retryCount >= 0 && retryCount < 8) {
  2837. + Rlog.i (RILJ_LOG_TAG,
  2838. + "Couldn't find '" + rilSocket
  2839. + + "' socket; retrying after timeout");
  2840. + }
  2841. +
  2842. + try {
  2843. + Thread.sleep(SOCKET_OPEN_RETRY_MILLIS);
  2844. + } catch (InterruptedException er) {
  2845. + }
  2846. +
  2847. + retryCount++;
  2848. + continue;
  2849. + }
  2850. +
  2851. + retryCount = 0;
  2852. +
  2853. + mSocket = s;
  2854. + Rlog.i(RILJ_LOG_TAG, "(" + mInstanceId + ") Connected to '"
  2855. + + rilSocket + "' socket");
  2856. +
  2857. + /* Compatibility with qcom's DSDS (Dual SIM) stack */
  2858. + if (needsOldRilFeature("qcomdsds")) {
  2859. + String str = "SUB1";
  2860. + byte[] data = str.getBytes();
  2861. + try {
  2862. + mSocket.getOutputStream().write(data);
  2863. + Rlog.i(RILJ_LOG_TAG, "Data sent!!");
  2864. + } catch (IOException ex) {
  2865. + Rlog.e(RILJ_LOG_TAG, "IOException", ex);
  2866. + } catch (RuntimeException exc) {
  2867. + Rlog.e(RILJ_LOG_TAG, "Uncaught exception ", exc);
  2868. + }
  2869. + }
  2870. +
  2871. + int length = 0;
  2872. + try {
  2873. + InputStream is = mSocket.getInputStream();
  2874. +
  2875. + for (;;) {
  2876. + Parcel p;
  2877. +
  2878. + length = readRilMessage(is, buffer);
  2879. +
  2880. + if (length < 0) {
  2881. + // End-of-stream reached
  2882. + break;
  2883. + }
  2884. +
  2885. + p = Parcel.obtain();
  2886. + p.unmarshall(buffer, 0, length);
  2887. + p.setDataPosition(0);
  2888. +
  2889. + //Rlog.v(RILJ_LOG_TAG, "Read packet: " + length + " bytes");
  2890. +
  2891. + processResponse(p);
  2892. + p.recycle();
  2893. + }
  2894. + } catch (java.io.IOException ex) {
  2895. + Rlog.i(RILJ_LOG_TAG, "'" + rilSocket + "' socket closed",
  2896. + ex);
  2897. + } catch (Throwable tr) {
  2898. + Rlog.e(RILJ_LOG_TAG, "Uncaught exception read length=" + length +
  2899. + "Exception:" + tr.toString());
  2900. + }
  2901. +
  2902. + Rlog.i(RILJ_LOG_TAG, "(" + mInstanceId + ") Disconnected from '" + rilSocket
  2903. + + "' socket");
  2904. +
  2905. + setRadioState (RadioState.RADIO_UNAVAILABLE);
  2906. +
  2907. + try {
  2908. + mSocket.close();
  2909. + } catch (IOException ex) {
  2910. + }
  2911. +
  2912. + mSocket = null;
  2913. + RILRequest.resetSerial();
  2914. +
  2915. + // Clear request list on close
  2916. + clearRequestList(RADIO_NOT_AVAILABLE, false);
  2917. + }} catch (Throwable tr) {
  2918. + Rlog.e(RILJ_LOG_TAG,"Uncaught exception", tr);
  2919. + }
  2920. +
  2921. + /* We're disconnected so we don't know the ril version */
  2922. + notifyRegistrantsRilConnectionChanged(-1);
  2923. + }
  2924. + }
  2925. +
  2926. + /* broken by new version of MTK RIL, disable for now */
  2927. + /*
  2928. + public void handle3GSwitch() {
  2929. + int simId = mInstanceId == null ? 0 : mInstanceId;
  2930. + int newsim = SystemProperties.getInt("gsm.3gswitch", 0);
  2931. + newsim = newsim - 1;
  2932. + if(!(simId==newsim)) {
  2933. + int prop = SystemProperties.getInt("gsm.3gswitch", 0);
  2934. + if (RILJ_LOGD) riljLog("Setting data subscription on SIM" + (simId + 1) + " mInstanceid=" + mInstanceId + " gsm.3gswitch=" + prop);
  2935. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_3G_CAPABILITY, null);
  2936. + rr.mParcel.writeInt(1);
  2937. + int realsim = simId + 1;
  2938. + rr.mParcel.writeInt(realsim);
  2939. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  2940. + send(rr);
  2941. + try {
  2942. + Thread.sleep(1000);
  2943. + } catch (InterruptedException er) {
  2944. + }
  2945. + resetRadio(null);
  2946. + try {
  2947. + Thread.sleep(4*1000);
  2948. + } catch (InterruptedException er) {
  2949. + }
  2950. + }
  2951. + else {
  2952. + if (RILJ_LOGD) riljLog("Not setting data subscription on same SIM");
  2953. + }
  2954. + }
  2955. +
  2956. + public void setDataAllowed(boolean allowed, Message result) {
  2957. + handle3GSwitch();
  2958. +
  2959. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_ALLOW_DATA, result);
  2960. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
  2961. + + " " + allowed);
  2962. +
  2963. + rr.mParcel.writeInt(1);
  2964. + rr.mParcel.writeInt(allowed ? 1 : 0);
  2965. + send(rr);
  2966. + }
  2967. + */
  2968. +}
  2969. diff --git a/src/java/com/android/internal/telephony/Phone.java b/src/java/com/android/internal/telephony/Phone.java
  2970. index b412f2b..6b8ba87 100644
  2971. --- a/src/java/com/android/internal/telephony/Phone.java
  2972. +++ b/src/java/com/android/internal/telephony/Phone.java
  2973. @@ -2064,4 +2064,39 @@ public interface Phone {
  2974. * @return true if IMS is Registered
  2975. */
  2976. public boolean isImsRegistered();
  2977. +
  2978. + // MTK addditions
  2979. +
  2980. + /**
  2981. + * Set phone RAT family.
  2982. + *
  2983. + * @param ratFamily bit mask to identify PhoneRatFamily.PHONE_RAT_FAMILY_2G,
  2984. + * PhoneRatFamily.PHONE_RAT_FAMILY_3G, PhoneRatFamily.PHONE_RAT_FAMILY_4G
  2985. + * @param response Callback message.
  2986. + */
  2987. + public void setPhoneRatFamily(int ratFamily, Message response);
  2988. +
  2989. + /**
  2990. + * Get phone RAT family.
  2991. + *
  2992. + * @return a bit mask to identify PhoneRatFamily.PHONE_RAT_FAMILY_2G,
  2993. + * PhoneRatFamily.PHONE_RAT_FAMILY_3G, PhoneRatFamily.PHONE_RAT_FAMILY_4G
  2994. + */
  2995. + public int getPhoneRatFamily();
  2996. +
  2997. + /**
  2998. + * Registers the handler when phone RAT family is changed.
  2999. + *
  3000. + * @param h Handler for notification message.
  3001. + * @param what User-defined message code.
  3002. + * @param obj User object.
  3003. + */
  3004. + public void registerForPhoneRatFamilyChanged(Handler h, int what, Object obj);
  3005. +
  3006. + /**
  3007. + * Unregister for notifications when phone RAT family is changed.
  3008. + *
  3009. + * @param h Handler to be removed from the registrant list.
  3010. + */
  3011. + public void unregisterForPhoneRatFamilyChanged(Handler h);
  3012. }
  3013. diff --git a/src/java/com/android/internal/telephony/PhoneBase.java b/src/java/com/android/internal/telephony/PhoneBase.java
  3014. index 5ef81eb..dfbe0c2 100644
  3015. --- a/src/java/com/android/internal/telephony/PhoneBase.java
  3016. +++ b/src/java/com/android/internal/telephony/PhoneBase.java
  3017. @@ -42,6 +42,7 @@ import android.telephony.CellIdentityCdma;
  3018. import android.telephony.CellInfo;
  3019. import android.telephony.CellInfoCdma;
  3020. import android.telephony.DataConnectionRealTimeInfo;
  3021. +import android.telephony.PhoneRatFamily;
  3022. import android.telephony.VoLteServiceState;
  3023. import android.telephony.Rlog;
  3024. import android.telephony.ServiceState;
  3025. @@ -179,7 +180,21 @@ public abstract class PhoneBase extends Handler implements Phone {
  3026. protected static final int EVENT_SET_CALL_FORWARD_TIMER_DONE = 37;
  3027. protected static final int EVENT_GET_CALL_FORWARD_TIMER_DONE = 38;
  3028. protected static final int EVENT_GET_CALLFORWARDING_STATUS = 39;
  3029. - protected static final int EVENT_LAST = EVENT_GET_CALLFORWARDING_STATUS;
  3030. + // MTK
  3031. + protected static final int EVENT_GET_PHONE_RAT_FAMILY = 41;
  3032. + protected static final int EVENT_PHONE_RAT_FAMILY_CHANGED_NOTIFY = 42;
  3033. + protected static final int EVENT_LAST = EVENT_PHONE_RAT_FAMILY_CHANGED_NOTIFY;
  3034. +
  3035. + // MTK again - wtf
  3036. + /// M: c2k modify, event constants. @{
  3037. + protected static final int EVENT_SET_MEID_DONE = 101;
  3038. + protected static final int EVENT_RUIM_READY = 102;
  3039. + /// @}
  3040. +
  3041. + /** M: for suspend data during plmn list */
  3042. + protected static final int EVENT_GET_AVAILABLE_NETWORK_DONE = 500520;
  3043. + protected static final int EVENT_DC_SWITCH_STATE_CHANGE = 500521;
  3044. + protected static final int EVENT_GET_AVAILABLE_NETWORK = 500522;
  3045.  
  3046. // For shared prefs.
  3047. private static final String GSM_ROAMING_LIST_OVERRIDE_PREFIX = "gsm_roaming_list_";
  3048. @@ -252,6 +267,9 @@ public abstract class PhoneBase extends Handler implements Phone {
  3049. private boolean mImsServiceReady = false;
  3050. protected static ImsPhone mImsPhone = null;
  3051.  
  3052. + // give the empty phone RAT family at initial, we will update it when radio available
  3053. + protected int mPhoneRatFamily = PhoneRatFamily.PHONE_RAT_FAMILY_NONE;
  3054. +
  3055. @Override
  3056. public String getPhoneName() {
  3057. return mName;
  3058. @@ -349,6 +367,9 @@ public abstract class PhoneBase extends Handler implements Phone {
  3059. protected final RegistrantList mVideoCapabilityChangedRegistrants
  3060. = new RegistrantList();
  3061.  
  3062. + // MTK
  3063. + protected final RegistrantList mPhoneRatFamilyChangedRegistrants
  3064. + = new RegistrantList();
  3065.  
  3066. protected Looper mLooper; /* to insure registrants are in correct thread*/
  3067.  
  3068. @@ -608,6 +629,19 @@ public abstract class PhoneBase extends Handler implements Phone {
  3069. }
  3070. break;
  3071.  
  3072. + case EVENT_PHONE_RAT_FAMILY_CHANGED_NOTIFY:
  3073. + ar = (AsyncResult) msg.obj;
  3074. + Rlog.d(LOG_TAG, "Event EVENT_PHONE_RAT_FAMILY_CHANGED_NOTIFY "
  3075. + + mPhoneRatFamilyChangedRegistrants.size());
  3076. + if (ar.exception == null) {
  3077. + PhoneRatFamily rat = (PhoneRatFamily)(ar.result);
  3078. + Rlog.d(LOG_TAG, "update mPhoneRatFamily, "
  3079. + + mPhoneRatFamilyChangedRegistrants.size() + ", " + rat);
  3080. + mPhoneRatFamily = rat.getRatFamily();
  3081. + }
  3082. + mPhoneRatFamilyChangedRegistrants.notifyRegistrants((AsyncResult) msg.obj);
  3083. + break;
  3084. +
  3085. default:
  3086. throw new RuntimeException("unexpected event not handled");
  3087. }
  3088. @@ -2338,6 +2372,32 @@ public abstract class PhoneBase extends Handler implements Phone {
  3089. + this);
  3090. }
  3091.  
  3092. + // MTK additions
  3093. +
  3094. + @Override
  3095. + public void setPhoneRatFamily(int ratFamily, Message response) {
  3096. + mCi.setPhoneRatFamily(ratFamily, response);
  3097. + }
  3098. +
  3099. + @Override
  3100. + public int getPhoneRatFamily() {
  3101. + Rlog.d(LOG_TAG, "getPhoneRatFamily:ID:" + mPhoneId + ", RAT:" + mPhoneRatFamily);
  3102. + return mPhoneRatFamily;
  3103. + }
  3104. +
  3105. + @Override
  3106. + public void registerForPhoneRatFamilyChanged(Handler h, int what, Object obj) {
  3107. + Registrant r = new Registrant(h, what, obj);
  3108. + mPhoneRatFamilyChangedRegistrants.add(r);
  3109. + mCi.registerForPhoneRatFamilyChanged(this, EVENT_PHONE_RAT_FAMILY_CHANGED_NOTIFY, null);
  3110. + }
  3111. +
  3112. + @Override
  3113. + public void unregisterForPhoneRatFamilyChanged(Handler h) {
  3114. + mPhoneRatFamilyChangedRegistrants.remove(h);
  3115. + mCi.unregisterForPhoneRatFamilyChanged(this);
  3116. + }
  3117. +
  3118. public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
  3119. pw.println("PhoneBase: subId=" + getSubId());
  3120. pw.println(" mPhoneId=" + mPhoneId);
  3121. diff --git a/src/java/com/android/internal/telephony/PhoneFactory.java b/src/java/com/android/internal/telephony/PhoneFactory.java
  3122. index 08ea27c..9440e36 100644
  3123. --- a/src/java/com/android/internal/telephony/PhoneFactory.java
  3124. +++ b/src/java/com/android/internal/telephony/PhoneFactory.java
  3125. @@ -42,6 +42,10 @@ import com.android.internal.telephony.sip.SipPhoneFactory;
  3126. import com.android.internal.telephony.uicc.IccCardProxy;
  3127. import com.android.internal.telephony.uicc.UiccController;
  3128.  
  3129. +import com.mediatek.internal.telephony.worldphone.IWorldPhone;
  3130. +import com.mediatek.internal.telephony.worldphone.WorldPhoneUtil;
  3131. +import com.mediatek.internal.telephony.worldphone.WorldPhoneWrapper;
  3132. +
  3133. import java.io.FileDescriptor;
  3134. import java.io.PrintWriter;
  3135. import java.lang.reflect.Constructor;
  3136. @@ -75,6 +79,9 @@ public class PhoneFactory {
  3137. static private PhoneNotifier sPhoneNotifier;
  3138. static private Context sContext;
  3139.  
  3140. + // MTK
  3141. + static private IWorldPhone sWorldPhone = null;
  3142. +
  3143. //***** Class Methods
  3144.  
  3145. public static void makeDefaultPhones(Context context) {
  3146. @@ -236,6 +243,11 @@ public class PhoneFactory {
  3147. sSubInfoRecordUpdater = new SubscriptionInfoUpdater(context,
  3148. sProxyPhones, sCommandsInterfaces);
  3149. SubscriptionController.getInstance().updatePhonesAvailability(sProxyPhones);
  3150. +
  3151. + // MTK
  3152. + if (WorldPhoneUtil.isWorldPhoneSupport()) {
  3153. + sWorldPhone = WorldPhoneWrapper.getWorldPhoneInstance();
  3154. + }
  3155. }
  3156. }
  3157. }
  3158. @@ -257,6 +269,14 @@ public class PhoneFactory {
  3159. }
  3160. }
  3161.  
  3162. + public static IWorldPhone getWorldPhone() {
  3163. + if (sWorldPhone == null) {
  3164. + Rlog.d(LOG_TAG, "sWorldPhone is null");
  3165. + }
  3166. +
  3167. + return sWorldPhone;
  3168. + }
  3169. +
  3170. private static <T> T instantiateCustomRIL(
  3171. String sRILClassname, Context context, int networkMode, int cdmaSubscription, Integer instanceId)
  3172. throws Exception {
  3173. diff --git a/src/java/com/android/internal/telephony/PhoneProxy.java b/src/java/com/android/internal/telephony/PhoneProxy.java
  3174. index 8246d23..18b6e15 100644
  3175. --- a/src/java/com/android/internal/telephony/PhoneProxy.java
  3176. +++ b/src/java/com/android/internal/telephony/PhoneProxy.java
  3177. @@ -1589,4 +1589,27 @@ public class PhoneProxy extends Handler implements Phone {
  3178. pw.flush();
  3179. pw.println("++++++++++++++++++++++++++++++++");
  3180. }
  3181. +
  3182. + // MTK additions
  3183. +
  3184. + @Override
  3185. + public void setPhoneRatFamily(int ratFamily, Message response) {
  3186. + mActivePhone.setPhoneRatFamily(ratFamily, response);
  3187. + }
  3188. +
  3189. + @Override
  3190. + public int getPhoneRatFamily() {
  3191. + return mActivePhone.getPhoneRatFamily();
  3192. + }
  3193. +
  3194. + @Override
  3195. + public void registerForPhoneRatFamilyChanged(Handler h, int what, Object obj) {
  3196. + mActivePhone.registerForPhoneRatFamilyChanged(h, what, obj);
  3197. + }
  3198. +
  3199. + @Override
  3200. + public void unregisterForPhoneRatFamilyChanged(Handler h) {
  3201. + mActivePhone.unregisterForPhoneRatFamilyChanged(h);
  3202. + }
  3203. +
  3204. }
  3205. diff --git a/src/java/com/android/internal/telephony/RIL.java b/src/java/com/android/internal/telephony/RIL.java
  3206. index 330679e..b84cb4d 100644
  3207. --- a/src/java/com/android/internal/telephony/RIL.java
  3208. +++ b/src/java/com/android/internal/telephony/RIL.java
  3209. @@ -55,6 +55,7 @@ import android.telephony.SignalStrength;
  3210. import android.telephony.SmsManager;
  3211. import android.telephony.SmsMessage;
  3212. import android.telephony.SubscriptionManager;
  3213. +import android.telephony.TelephonyManager;
  3214. import android.text.TextUtils;
  3215. import android.util.SparseArray;
  3216. import android.view.Display;
  3217. @@ -289,6 +290,10 @@ public class RIL extends BaseCommands implements CommandsInterface {
  3218. // divide the response array without prior knowledge of the number of elements.
  3219. protected int mQANElements = 4;
  3220.  
  3221. + // MTK
  3222. + // save the status of screen
  3223. + private boolean isScreenOn = true;
  3224. +
  3225. //***** Events
  3226.  
  3227. static final int EVENT_SEND = 1;
  3228. @@ -2483,6 +2488,9 @@ public class RIL extends BaseCommands implements CommandsInterface {
  3229. }
  3230.  
  3231. protected void sendScreenState(boolean on) {
  3232. + // MTK
  3233. + isScreenOn = on;
  3234. +
  3235. RILRequest rr = RILRequest.obtain(RIL_REQUEST_SCREEN_STATE, null);
  3236. rr.mParcel.writeInt(1);
  3237. rr.mParcel.writeInt(on ? 1 : 0);
  3238. @@ -3387,12 +3395,19 @@ public class RIL extends BaseCommands implements CommandsInterface {
  3239. case RIL_UNSOL_RIL_CONNECTED: {
  3240. if (RILJ_LOGD) unsljLogRet(response, ret);
  3241.  
  3242. + // Set ecc list before MO call
  3243. + if (TelephonyManager.getDefault().getMultiSimConfiguration() == TelephonyManager.MultiSimVariants.DSDA
  3244. + || mInstanceId == 0) {
  3245. + setEccList();
  3246. + }
  3247. +
  3248. // Initial conditions
  3249. - setRadioPower(false, null);
  3250. + // setRadioPower(false, null);
  3251. setPreferredNetworkType(mPreferredNetworkType, null);
  3252. setCdmaSubscriptionSource(mCdmaSubscription, null);
  3253. setCellInfoListRate(Integer.MAX_VALUE, null);
  3254. notifyRegistrantsRilConnectionChanged(((int[])ret)[0]);
  3255. + sendScreenState(isScreenOn);
  3256. break;
  3257. }
  3258. case RIL_UNSOL_CELL_INFO_LIST: {
  3259. @@ -3900,6 +3915,7 @@ public class RIL extends BaseCommands implements CommandsInterface {
  3260. dataCall.suggestedRetryTime = p.readInt();
  3261. dataCall.cid = p.readInt();
  3262. dataCall.active = p.readInt();
  3263. + dataCall.mtu = p.readInt(); // fix for mobile data on MT6753 SoC
  3264. dataCall.type = p.readString();
  3265. dataCall.ifname = p.readString();
  3266. if ((dataCall.status == DcFailCause.NONE.getErrorCode()) &&
  3267. @@ -4378,6 +4394,10 @@ public class RIL extends BaseCommands implements CommandsInterface {
  3268. case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL";
  3269. case RIL_REQUEST_SIM_IO: return "SIM_IO";
  3270. case RIL_REQUEST_SEND_USSD: return "SEND_USSD";
  3271. + /* M: SS part */
  3272. + ///M: For query CNAP
  3273. + case RIL_REQUEST_SEND_CNAP: return "SEND_CNAP";
  3274. + /* M: SS part end */
  3275. case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD";
  3276. case RIL_REQUEST_GET_CLIR: return "GET_CLIR";
  3277. case RIL_REQUEST_SET_CLIR: return "SET_CLIR";
  3278. @@ -4397,6 +4417,7 @@ public class RIL extends BaseCommands implements CommandsInterface {
  3279. case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC";
  3280. case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL";
  3281. case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS ";
  3282. + case RIL_REQUEST_ABORT_QUERY_AVAILABLE_NETWORKS : return "ABORT_QUERY_AVAILABLE_NETWORKS";
  3283. case RIL_REQUEST_DTMF_START: return "DTMF_START";
  3284. case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP";
  3285. case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION";
  3286. @@ -4477,6 +4498,135 @@ public class RIL extends BaseCommands implements CommandsInterface {
  3287. case RIL_REQUEST_GET_HARDWARE_CONFIG: return "GET_HARDWARE_CONFIG";
  3288. case RIL_REQUEST_SIM_AUTHENTICATION: return "RIL_REQUEST_SIM_AUTHENTICATION";
  3289. case RIL_REQUEST_SHUTDOWN: return "RIL_REQUEST_SHUTDOWN";
  3290. + case RIL_REQUEST_SET_PHONE_RAT_FAMILY: return "RIL_REQUEST_SET_PHONE_RAT_FAMILY";
  3291. + case RIL_REQUEST_GET_PHONE_RAT_FAMILY: return "RIL_REQUEST_GET_PHONE_RAT_FAMILY";
  3292. +
  3293. + /* M: call control part start */
  3294. + case RIL_REQUEST_HANGUP_ALL: return "HANGUP_ALL";
  3295. + case RIL_REQUEST_FORCE_RELEASE_CALL: return "FORCE_RELEASE_CALL";
  3296. + case RIL_REQUEST_SET_CALL_INDICATION: return "SET_CALL_INDICATION";
  3297. + case RIL_REQUEST_EMERGENCY_DIAL: return "EMERGENCY_DIAL";
  3298. + case RIL_REQUEST_SET_ECC_SERVICE_CATEGORY: return "SET_ECC_SERVICE_CATEGORY";
  3299. + case RIL_REQUEST_SET_ECC_LIST: return "SET_ECC_LIST";
  3300. + case RIL_REQUEST_SET_SPEECH_CODEC_INFO: return "SET_SPEECH_CODEC_INFO";
  3301. + /* M: call control part end */
  3302. +
  3303. + /// M: IMS feature. @{
  3304. + case RIL_REQUEST_ADD_IMS_CONFERENCE_CALL_MEMBER: return "RIL_REQUEST_ADD_IMS_CONFERENCE_CALL_MEMBER";
  3305. + case RIL_REQUEST_REMOVE_IMS_CONFERENCE_CALL_MEMBER: return "RIL_REQUEST_REMOVE_IMS_CONFERENCE_CALL_MEMBER";
  3306. + case RIL_REQUEST_DIAL_WITH_SIP_URI: return "RIL_REQUEST_DIAL_WITH_SIP_URI";
  3307. + case RIL_REQUEST_RETRIEVE_HELD_CALL: return "RIL_REQUEST_RETRIEVE_HELD_CALL";
  3308. + /// @}
  3309. +
  3310. + //MTK-START SIM ME lock
  3311. + case RIL_REQUEST_QUERY_SIM_NETWORK_LOCK: return "QUERY_SIM_NETWORK_LOCK";
  3312. + case RIL_REQUEST_SET_SIM_NETWORK_LOCK: return "SET_SIM_NETWORK_LOCK";
  3313. + //MTK-END SIM ME lock
  3314. + //ISIM
  3315. + case RIL_REQUEST_GENERAL_SIM_AUTH: return "RIL_REQUEST_GENERAL_SIM_AUTH";
  3316. + case RIL_REQUEST_OPEN_ICC_APPLICATION: return "RIL_REQUEST_OPEN_ICC_APPLICATION";
  3317. + case RIL_REQUEST_GET_ICC_APPLICATION_STATUS: return "RIL_REQUEST_GET_ICC_APPLICATION_STATUS";
  3318. + case RIL_REQUEST_SIM_IO_EX: return "SIM_IO_EX";
  3319. +
  3320. + // PHB Start
  3321. + case RIL_REQUEST_QUERY_PHB_STORAGE_INFO: return "RIL_REQUEST_QUERY_PHB_STORAGE_INFO";
  3322. + case RIL_REQUEST_WRITE_PHB_ENTRY: return "RIL_REQUEST_WRITE_PHB_ENTRY";
  3323. + case RIL_REQUEST_READ_PHB_ENTRY: return "RIL_REQUEST_READ_PHB_ENTRY";
  3324. + case RIL_REQUEST_QUERY_UPB_CAPABILITY: return "RIL_REQUEST_QUERY_UPB_CAPABILITY";
  3325. + case RIL_REQUEST_EDIT_UPB_ENTRY: return "RIL_REQUEST_EDIT_UPB_ENTRY";
  3326. + case RIL_REQUEST_DELETE_UPB_ENTRY: return "RIL_REQUEST_DELETE_UPB_ENTRY";
  3327. + case RIL_REQUEST_READ_UPB_GAS_LIST: return "RIL_REQUEST_READ_UPB_GAS_LIST";
  3328. + case RIL_REQUEST_READ_UPB_GRP: return "RIL_REQUEST_READ_UPB_GRP";
  3329. + case RIL_REQUEST_WRITE_UPB_GRP: return "RIL_REQUEST_WRITE_UPB_GRP";
  3330. + case RIL_REQUEST_GET_PHB_STRING_LENGTH: return "RIL_REQUEST_GET_PHB_STRING_LENGTH";
  3331. + case RIL_REQUEST_GET_PHB_MEM_STORAGE: return "RIL_REQUEST_GET_PHB_MEM_STORAGE";
  3332. + case RIL_REQUEST_SET_PHB_MEM_STORAGE: return "RIL_REQUEST_SET_PHB_MEM_STORAGE";
  3333. + case RIL_REQUEST_READ_PHB_ENTRY_EXT: return "RIL_REQUEST_READ_PHB_ENTRY_EXT";
  3334. + case RIL_REQUEST_WRITE_PHB_ENTRY_EXT: return "RIL_REQUEST_WRITE_PHB_ENTRY_EXT";
  3335. + // PHB End
  3336. +
  3337. + /* M: network part start */
  3338. + case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL_WITH_ACT: return "SET_NETWORK_SELECTION_MANUAL_WITH_ACT";
  3339. + case RIL_REQUEST_GET_POL_CAPABILITY: return "RIL_REQUEST_GET_POL_CAPABILITY";
  3340. + case RIL_REQUEST_GET_POL_LIST: return "RIL_REQUEST_GET_POL_LIST";
  3341. + case RIL_REQUEST_SET_POL_ENTRY: return "RIL_REQUEST_SET_POL_ENTRY";
  3342. + case RIL_REQUEST_SET_TRM: return "RIL_REQUEST_SET_TRM";
  3343. + case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS_WITH_ACT : return "QUERY_AVAILABLE_NETWORKS_WITH_ACT";
  3344. + //Femtocell (CSG) feature START
  3345. + case RIL_REQUEST_GET_FEMTOCELL_LIST: return "RIL_REQUEST_GET_FEMTOCELL_LIST";
  3346. + case RIL_REQUEST_ABORT_FEMTOCELL_LIST: return "RIL_REQUEST_ABORT_FEMTOCELL_LIST";
  3347. + case RIL_REQUEST_SELECT_FEMTOCELL: return "RIL_REQUEST_SELECT_FEMTOCELL";
  3348. + //Femtocell (CSG) feature END
  3349. + /* M: network part end */
  3350. + case RIL_REQUEST_STK_EVDL_CALL_BY_AP: return "RIL_REQUEST_STK_EVDL_CALL_BY_AP";
  3351. + case RIL_REQUEST_QUERY_MODEM_TYPE: return "RIL_REQUEST_QUERY_MODEM_TYPE";
  3352. + case RIL_REQUEST_STORE_MODEM_TYPE: return "RIL_REQUEST_STORE_MODEM_TYPE";
  3353. + case RIL_REQUEST_SIM_GET_ATR: return "SIM_GET_ATR";
  3354. + case RIL_REQUEST_SIM_OPEN_CHANNEL_WITH_SW: return "SIM_OPEN_CHANNEL_WITH_SW";
  3355. + //VoLTE
  3356. + case RIL_REQUEST_SETUP_DEDICATE_DATA_CALL: return "RIL_REQUEST_SETUP_DEDICATE_DATA_CALL";
  3357. + case RIL_REQUEST_DEACTIVATE_DEDICATE_DATA_CALL: return "RIL_REQUEST_DEACTIVATE_DEDICATE_DATA_CALL";
  3358. + case RIL_REQUEST_MODIFY_DATA_CALL: return "RIL_REQUEST_MODIFY_DATA_CALL";
  3359. + case RIL_REQUEST_ABORT_SETUP_DATA_CALL: return "RIL_REQUEST_ABORT_SETUP_DATA_CALL";
  3360. + case RIL_REQUEST_PCSCF_DISCOVERY_PCO: return "RIL_REQUEST_PCSCF_DISCOVERY_PCO";
  3361. + case RIL_REQUEST_CLEAR_DATA_BEARER: return "RIL_REQUEST_CLEAR_DATA_BEARER";
  3362. +
  3363. + // IMS
  3364. + case RIL_REQUEST_SET_IMS_ENABLE: return "RIL_REQUEST_SET_IMS_ENABLE";
  3365. +
  3366. + // M: Fast Dormancy
  3367. + case RIL_REQUEST_SET_SCRI: return "RIL_REQUEST_SET_SCRI";
  3368. + case RIL_REQUEST_SET_FD_MODE: return "RIL_REQUEST_SET_FD_MODE";
  3369. + // MTK-START, SMS part
  3370. + case RIL_REQUEST_GET_SMS_PARAMS: return "RIL_REQUEST_GET_SMS_PARAMS";
  3371. + case RIL_REQUEST_SET_SMS_PARAMS: return "RIL_REQUEST_SET_SMS_PARAMS";
  3372. + case RIL_REQUEST_GET_SMS_SIM_MEM_STATUS: return "RIL_REQUEST_GET_SMS_SIM_MEM_STATUS";
  3373. + case RIL_REQUEST_SET_ETWS: return "RIL_REQUEST_SET_ETWS";
  3374. + case RIL_REQUEST_SET_CB_CHANNEL_CONFIG_INFO:
  3375. + return "RIL_REQUEST_SET_CB_CHANNEL_CONFIG_INFO";
  3376. + case RIL_REQUEST_SET_CB_LANGUAGE_CONFIG_INFO:
  3377. + return "RIL_REQUEST_SET_CB_LANGUAGE_CONFIG_INFO";
  3378. + case RIL_REQUEST_GET_CB_CONFIG_INFO: return "RIL_REQUEST_GET_CB_CONFIG_INFO";
  3379. + case RIL_REQUEST_REMOVE_CB_MESSAGE: return "RIL_REQUEST_REMOVE_CB_MESSAGE";
  3380. + // MTK-END, SMS part
  3381. + case RIL_REQUEST_SET_DATA_CENTRIC: return "RIL_REQUEST_SET_DATA_CENTRIC";
  3382. +
  3383. + case RIL_REQUEST_MODEM_POWEROFF: return "MODEM_POWEROFF";
  3384. + case RIL_REQUEST_MODEM_POWERON: return "MODEM_POWERON";
  3385. + // M: CC33 LTE.
  3386. + case RIL_REQUEST_SET_DATA_ON_TO_MD: return "RIL_REQUEST_SET_DATA_ON_TO_MD";
  3387. + case RIL_REQUEST_SET_REMOVE_RESTRICT_EUTRAN_MODE: return "RIL_REQUEST_SET_REMOVE_RESTRICT_EUTRAN_MODE";
  3388. + case RIL_REQUEST_BTSIM_CONNECT: return "RIL_REQUEST_BTSIM_CONNECT";
  3389. + case RIL_REQUEST_BTSIM_DISCONNECT_OR_POWEROFF: return "RIL_REQUEST_BTSIM_DISCONNECT_OR_POWEROFF";
  3390. + case RIL_REQUEST_BTSIM_POWERON_OR_RESETSIM: return "RIL_REQUEST_BTSIM_POWERON_OR_RESETSIM";
  3391. + case RIL_REQUEST_BTSIM_TRANSFERAPDU: return "RIL_REQUEST_SEND_BTSIM_TRANSFERAPDU";
  3392. +
  3393. + /* M: call control part start */
  3394. + case RIL_REQUEST_SET_IMS_CALL_STATUS: return "RIL_REQUEST_SET_IMS_CALL_STATUS";
  3395. + /* M: call control part end */
  3396. +
  3397. + /* M: C2K part start */
  3398. + case RIL_REQUEST_GET_NITZ_TIME: return "RIL_REQUEST_GET_NITZ_TIME";
  3399. + case RIL_REQUEST_QUERY_UIM_INSERTED: return "RIL_REQUEST_QUERY_UIM_INSERTED";
  3400. + case RIL_REQUEST_SWITCH_HPF: return "RIL_REQUEST_SWITCH_HPF";
  3401. + case RIL_REQUEST_SET_AVOID_SYS: return "RIL_REQUEST_SET_AVOID_SYS";
  3402. + case RIL_REQUEST_QUERY_AVOID_SYS: return "RIL_REQUEST_QUERY_AVOID_SYS";
  3403. + case RIL_REQUEST_QUERY_CDMA_NETWORK_INFO: return "RIL_REQUEST_QUERY_CDMA_NETWORK_INFO";
  3404. + case RIL_REQUEST_GET_LOCAL_INFO: return "RIL_REQUEST_GET_LOCAL_INFO";
  3405. + case RIL_REQUEST_UTK_REFRESH: return "RIL_REQUEST_UTK_REFRESH";
  3406. + case RIL_REQUEST_QUERY_SMS_AND_PHONEBOOK_STATUS: return "RIL_REQUEST_QUERY_SMS_AND_PHONEBOOK_STATUS";
  3407. + case RIL_REQUEST_QUERY_NETWORK_REGISTRATION: return "RIL_REQUEST_QUERY_NETWORK_REGISTRATION";
  3408. + case RIL_REQUEST_AGPS_TCP_CONNIND: return "RIL_REQUEST_AGPS_TCP_CONNIND";
  3409. + case RIL_REQUEST_AGPS_SET_MPC_IPPORT: return "RIL_REQUEST_AGPS_SET_MPC_IPPORT";
  3410. + case RIL_REQUEST_AGPS_GET_MPC_IPPORT: return "RIL_REQUEST_AGPS_GET_MPC_IPPORT";
  3411. + case RIL_REQUEST_SET_MEID: return "RIL_REQUEST_SET_MEID";
  3412. + case RIL_REQUEST_SET_REG_RESUME: return "RIL_REQUEST_SET_REG_RESUME";
  3413. + case RIL_REQUEST_ENABLE_REG_PAUSE: return "RIL_REQUEST_ENABLE_REG_PAUSE";
  3414. + case RIL_REQUEST_SET_ETS_DEV: return "RIL_REQUEST_SET_ETS_DEV";
  3415. + case RIL_REQUEST_WRITE_MDN: return "RIL_REQUEST_WRITE_MDN";
  3416. + case RIL_REQUEST_SET_VIA_TRM: return "RIL_REQUEST_SET_VIA_TRM";
  3417. + case RIL_REQUEST_SET_ARSI_THRESHOLD: return "RIL_REQUEST_SET_ARSI_THRESHOLD";
  3418. + /* M: C2K part end */
  3419. default: return "<unknown request>";
  3420. }
  3421. }
  3422. @@ -4534,9 +4684,85 @@ public class RIL extends BaseCommands implements CommandsInterface {
  3423. case RIL_UNSOL_SRVCC_STATE_NOTIFY:
  3424. return "UNSOL_SRVCC_STATE_NOTIFY";
  3425. case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "RIL_UNSOL_HARDWARE_CONFIG_CHANGED";
  3426. - case RIL_UNSOL_ON_SS: return "UNSOL_ON_SS";
  3427. - case RIL_UNSOL_STK_CC_ALPHA_NOTIFY: return "UNSOL_STK_CC_ALPHA_NOTIFY";
  3428. - case RIL_UNSOL_STK_SEND_SMS_RESULT: return "RIL_UNSOL_STK_SEND_SMS_RESULT";
  3429. + case RIL_UNSOL_SET_PHONE_RAT_FAMILY_COMPLETE: return "RIL_UNSOL_SET_PHONE_RAT_FAMILY_COMPLETE";
  3430. + /* M: call control part start */
  3431. + case RIL_UNSOL_CALL_FORWARDING: return "UNSOL_CALL_FORWARDING";
  3432. + case RIL_UNSOL_CRSS_NOTIFICATION: return "UNSOL_CRSS_NOTIFICATION";
  3433. + case RIL_UNSOL_INCOMING_CALL_INDICATION: return "UNSOL_INCOMING_CALL_INDICATION";
  3434. + case RIL_UNSOL_CIPHER_INDICATION: return "UNSOL_CIPHER_INDICATION";
  3435. + case RIL_UNSOL_CNAP: return "UNSOL_CNAP";
  3436. + case RIL_UNSOL_SPEECH_CODEC_INFO: return "UNSOL_SPEECH_CODEC_INFO";
  3437. + /* M: call control part end */
  3438. + //MTK-START multiple application support
  3439. + case RIL_UNSOL_APPLICATION_SESSION_ID_CHANGED: return "RIL_UNSOL_APPLICATION_SESSION_ID_CHANGED";
  3440. + //MTK-END multiple application support
  3441. + case RIL_UNSOL_SIM_MISSING: return "UNSOL_SIM_MISSING";
  3442. + case RIL_UNSOL_VIRTUAL_SIM_ON: return "UNSOL_VIRTUAL_SIM_ON";
  3443. + case RIL_UNSOL_VIRTUAL_SIM_OFF: return "UNSOL_VIRTUAL_SIM_ON_OFF";
  3444. + case RIL_UNSOL_SIM_RECOVERY: return "UNSOL_SIM_RECOVERY";
  3445. + case RIL_UNSOL_SIM_PLUG_OUT: return "UNSOL_SIM_PLUG_OUT";
  3446. + case RIL_UNSOL_SIM_PLUG_IN: return "UNSOL_SIM_PLUG_IN";
  3447. + case RIL_UNSOL_SIM_COMMON_SLOT_NO_CHANGED: return "RIL_UNSOL_SIM_COMMON_SLOT_NO_CHANGED";
  3448. + case RIL_UNSOL_DATA_ALLOWED: return "RIL_UNSOL_DATA_ALLOWED";
  3449. + case RIL_UNSOL_PHB_READY_NOTIFICATION: return "UNSOL_PHB_READY_NOTIFICATION";
  3450. + case RIL_UNSOL_IMEI_LOCK: return "UNSOL_IMEI_LOCK";
  3451. + case RIL_UNSOL_RESPONSE_ACMT: return "UNSOL_ACMT_INFO";
  3452. + case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED";
  3453. + case RIL_UNSOL_RESPONSE_MMRR_STATUS_CHANGED: return "UNSOL_RESPONSE_MMRR_STATUS_CHANGED";
  3454. + case RIL_UNSOL_NEIGHBORING_CELL_INFO: return "UNSOL_NEIGHBORING_CELL_INFO";
  3455. + case RIL_UNSOL_NETWORK_INFO: return "UNSOL_NETWORK_INFO";
  3456. + case RIL_UNSOL_INVALID_SIM: return "RIL_UNSOL_INVALID_SIM";
  3457. + case RIL_UNSOL_IMS_ENABLE_DONE: return "RIL_UNSOL_IMS_ENABLE_DONE";
  3458. + case RIL_UNSOL_IMS_DISABLE_DONE: return "RIL_UNSOL_IMS_DISABLE_DONE";
  3459. + case RIL_UNSOL_IMS_REGISTRATION_INFO: return "RIL_UNSOL_IMS_REGISTRATION_INFO";
  3460. + case RIL_UNSOL_STK_SETUP_MENU_RESET: return "RIL_UNSOL_STK_SETUP_MENU_RESET";
  3461. + case RIL_UNSOL_RESPONSE_PLMN_CHANGED: return "RIL_UNSOL_RESPONSE_PLMN_CHANGED";
  3462. + case RIL_UNSOL_RESPONSE_REGISTRATION_SUSPENDED: return "RIL_UNSOL_RESPONSE_REGISTRATION_SUSPENDED";
  3463. + //VoLTE
  3464. + case RIL_UNSOL_DEDICATE_BEARER_ACTIVATED: return "RIL_UNSOL_DEDICATE_BEARER_ACTIVATED";
  3465. + case RIL_UNSOL_DEDICATE_BEARER_MODIFIED: return "RIL_UNSOL_DEDICATE_BEARER_MODIFIED";
  3466. + //Remote SIM ME lock related APIs [Start]
  3467. + case RIL_UNSOL_MELOCK_NOTIFICATION: return "RIL_UNSOL_MELOCK_NOTIFICATION";
  3468. + //Remote SIM ME lock related APIs [End]
  3469. + // M: Fast Dormancy
  3470. + case RIL_UNSOL_SCRI_RESULT: return "RIL_UNSOL_SCRI_RESULT";
  3471. + case RIL_UNSOL_STK_EVDL_CALL: return "RIL_UNSOL_STK_EVDL_CALL";
  3472. + case RIL_UNSOL_STK_CALL_CTRL: return "RIL_UNSOL_STK_CALL_CTRL";
  3473. +
  3474. + /// M: IMS feature. @{
  3475. + case RIL_UNSOL_ECONF_SRVCC_INDICATION: return "RIL_UNSOL_ECONF_SRVCC_INDICATION";
  3476. + //For updating conference call merged/added result.
  3477. + case RIL_UNSOL_ECONF_RESULT_INDICATION: return "RIL_UNSOL_ECONF_RESULT_INDICATION";
  3478. + //For updating call mode and pau information.
  3479. + case RIL_UNSOL_CALL_INFO_INDICATION : return "RIL_UNSOL_CALL_INFO_INDICATION";
  3480. + /// @}
  3481. +
  3482. + case RIL_UNSOL_VOLTE_EPS_NETWORK_FEATURE_INFO: return "RIL_UNSOL_VOLTE_EPS_NETWORK_FEATURE_INFO";
  3483. + case RIL_UNSOL_SRVCC_HANDOVER_INFO_INDICATION: return "RIL_UNSOL_SRVCC_HANDOVER_INFO_INDICATION";
  3484. + // M: CC33 LTE.
  3485. + case RIL_UNSOL_RAC_UPDATE: return "RIL_UNSOL_RAC_UPDATE";
  3486. + case RIL_UNSOL_REMOVE_RESTRICT_EUTRAN: return "RIL_UNSOL_REMOVE_RESTRICT_EUTRAN";
  3487. +
  3488. + //MTK-START for MD state change
  3489. + case RIL_UNSOL_MD_STATE_CHANGE: return "RIL_UNSOL_MD_STATE_CHANGE";
  3490. + //MTK-END for MD state change
  3491. +
  3492. + case RIL_UNSOL_MO_DATA_BARRING_INFO: return "RIL_UNSOL_MO_DATA_BARRING_INFO";
  3493. + case RIL_UNSOL_SSAC_BARRING_INFO: return "RIL_UNSOL_SSAC_BARRING_INFO";
  3494. + //MTK_TC1_FEATURE for LGE CSMCC_MO_CALL_MODIFIED {
  3495. + case RIL_UNSOL_RESPONSE_MO_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_MO_CALL_STATE_CHANGED";
  3496. + //}
  3497. +
  3498. + /* M: C2K part start */
  3499. + case RIL_UNSOL_CDMA_CALL_ACCEPTED: return "RIL_UNSOL_CDMA_CALL_ACCEPTED";
  3500. + case RIL_UNSOL_UTK_SESSION_END: return "RIL_UNSOL_UTK_SESSION_END";
  3501. + case RIL_UNSOL_UTK_PROACTIVE_COMMAND: return "RIL_UNSOL_UTK_PROACTIVE_COMMAND";
  3502. + case RIL_UNSOL_UTK_EVENT_NOTIFY: return "RIL_UNSOL_UTK_EVENT_NOTIFY";
  3503. + case RIL_UNSOL_VIA_GPS_EVENT: return "RIL_UNSOL_VIA_GPS_EVENT";
  3504. + case RIL_UNSOL_VIA_NETWORK_TYPE_CHANGE: return "RIL_UNSOL_VIA_NETWORK_TYPE_CHANGE";
  3505. + case RIL_UNSOL_VIA_PLMN_CHANGE_REG_PAUSE: return "RIL_UNSOL_VIA_PLMN_CHANGE_REG_PAUSE";
  3506. + case RIL_UNSOL_VIA_INVALID_SIM_DETECTED: return "RIL_UNSOL_VIA_INVALID_SIM_DETECTED";
  3507. + /* M: C2K part end */
  3508. default: return "<unknown response>";
  3509. }
  3510. }
  3511. @@ -4878,6 +5104,13 @@ public class RIL extends BaseCommands implements CommandsInterface {
  3512. send(rr);
  3513. }
  3514.  
  3515. + @Override
  3516. + public void setInitialAttachApn(String apn, String protocol, int authType, String username,
  3517. + String password, String operatorNumeric, boolean canHandleIms, Message result) {
  3518. + // On generic RIL implementation we just ignore the MTK-specific parameters
  3519. + setInitialAttachApn(apn, protocol, authType, username, password, result);
  3520. + }
  3521. +
  3522. public void setDataProfile(DataProfile[] dps, Message result) {
  3523. if (RILJ_LOGD) riljLog("Set RIL_REQUEST_SET_DATA_PROFILE");
  3524.  
  3525. @@ -5098,4 +5331,291 @@ public class RIL extends BaseCommands implements CommandsInterface {
  3526.  
  3527. send(rr);
  3528. }
  3529. +
  3530. + // MTK additions
  3531. + //MTK-START Support Multi-Application
  3532. + @Override
  3533. + public void openIccApplication(int application, Message response) {
  3534. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_OPEN_ICC_APPLICATION, response);
  3535. +
  3536. + rr.mParcel.writeInt(1);
  3537. + rr.mParcel.writeInt(application);
  3538. +
  3539. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
  3540. + + ", application = " + application);
  3541. + send(rr);
  3542. + }
  3543. +
  3544. + @Override
  3545. + public void getIccApplicationStatus(int sessionId, Message result) {
  3546. + //Note: This RIL request has not been renamed to ICC,
  3547. + // but this request is also valid for SIM and RUIM
  3548. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_ICC_APPLICATION_STATUS, result);
  3549. +
  3550. + rr.mParcel.writeInt(1);
  3551. + rr.mParcel.writeInt(sessionId);
  3552. +
  3553. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
  3554. + + ", session = " + sessionId);
  3555. + send(rr);
  3556. + }
  3557. +
  3558. + @Override
  3559. + public void iccIOForAppEx(int command, int fileid, String path, int p1, int p2, int p3,
  3560. + String data, String pin2, String aid, int channel , Message result) {
  3561. + //Note: This RIL request has not been renamed to ICC,
  3562. + // but this request is also valid for SIM and RUIM
  3563. + RILRequest rr
  3564. + = RILRequest.obtain(RIL_REQUEST_SIM_IO_EX, result);
  3565. +
  3566. + rr.mParcel.writeInt(command);
  3567. + rr.mParcel.writeInt(fileid);
  3568. + rr.mParcel.writeString(path);
  3569. + rr.mParcel.writeInt(p1);
  3570. + rr.mParcel.writeInt(p2);
  3571. + rr.mParcel.writeInt(p3);
  3572. + rr.mParcel.writeString(data);
  3573. + rr.mParcel.writeString(pin2);
  3574. + rr.mParcel.writeString(aid);
  3575. + rr.mParcel.writeInt(channel);
  3576. +
  3577. + if (RILJ_LOGD) riljLog(rr.serialString() + "> iccIO: "
  3578. + + requestToString(rr.mRequest)
  3579. + + " 0x" + Integer.toHexString(command)
  3580. + + " 0x" + Integer.toHexString(fileid) + " "
  3581. + + " path: " + path + ","
  3582. + + p1 + "," + p2 + "," + p3 + ",channel:" + channel
  3583. + + " aid: " + aid);
  3584. +
  3585. + send(rr);
  3586. + }
  3587. + //MTK-END Support Multi-Application
  3588. +
  3589. + @Override
  3590. + public void queryNetworkLock(int category, Message response) {
  3591. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_QUERY_SIM_NETWORK_LOCK, response);
  3592. +
  3593. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  3594. +
  3595. + riljLog("queryNetworkLock:" + category);
  3596. +
  3597. + rr.mParcel.writeInt(1);
  3598. + rr.mParcel.writeInt(category);
  3599. +
  3600. + send(rr);
  3601. + }
  3602. +
  3603. + @Override
  3604. + public void setNetworkLock(int catagory, int lockop, String password,
  3605. + String data_imsi, String gid1, String gid2, Message response) {
  3606. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_SIM_NETWORK_LOCK, response);
  3607. +
  3608. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  3609. +
  3610. + riljLog("setNetworkLock:" + catagory + ", " + lockop + ", " + password + ", " + data_imsi
  3611. + + ", " + gid1 + ", " + gid2);
  3612. +
  3613. + rr.mParcel.writeInt(6);
  3614. + rr.mParcel.writeString(Integer.toString(catagory));
  3615. + rr.mParcel.writeString(Integer.toString(lockop));
  3616. + if (null != password) {
  3617. + rr.mParcel.writeString(password);
  3618. + } else {
  3619. + rr.mParcel.writeString("");
  3620. + }
  3621. + rr.mParcel.writeString(data_imsi);
  3622. + rr.mParcel.writeString(gid1);
  3623. + rr.mParcel.writeString(gid2);
  3624. +
  3625. + send(rr);
  3626. + }
  3627. +
  3628. + @Override
  3629. + public void doGeneralSimAuthentication(int sessionId, int mode , int tag, String param1,
  3630. + String param2, Message response) {
  3631. +
  3632. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_GENERAL_SIM_AUTH, response);
  3633. +
  3634. + rr.mParcel.writeInt(sessionId);
  3635. + rr.mParcel.writeInt(mode);
  3636. +
  3637. + // Calcuate param1 length in byte length
  3638. + if (param1 != null && param1.length() > 0) {
  3639. + String length = Integer.toHexString(param1.length() / 2);
  3640. + length = (((length.length() % 2 == 1) ? "0" : "") + length);
  3641. + // Session id is equal to 0, for backward compability, we use old AT command
  3642. + // old AT command no need to include param's length
  3643. + rr.mParcel.writeString(((sessionId == 0) ? param1 : (length + param1)));
  3644. + } else {
  3645. + rr.mParcel.writeString(param1);
  3646. + }
  3647. +
  3648. + // Calcuate param2 length in byte length
  3649. + if (param2 != null && param2.length() > 0) {
  3650. + String length = Integer.toHexString(param2.length() / 2);
  3651. + length = (((length.length() % 2 == 1) ? "0" : "") + length);
  3652. + // Session id is equal to 0, for backward compability, we use old AT command
  3653. + // old AT command no need to include param's length
  3654. + rr.mParcel.writeString(((sessionId == 0) ? param2 : (length + param2)));
  3655. + } else {
  3656. + rr.mParcel.writeString(param2);
  3657. + }
  3658. +
  3659. + if (mode == 1) {
  3660. + rr.mParcel.writeInt(tag);
  3661. + }
  3662. +
  3663. +
  3664. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + ": " +
  3665. + "session = " + sessionId + ",mode = " + mode + ",tag = " + tag + ", " + param1 + ", " + param2);
  3666. +
  3667. + send(rr);
  3668. + }
  3669. +
  3670. + @Override
  3671. + public void iccGetATR(Message result) {
  3672. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SIM_GET_ATR, result);
  3673. +
  3674. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  3675. +
  3676. + send(rr);
  3677. + }
  3678. +
  3679. + @Override
  3680. + public void iccOpenChannelWithSw(String AID, Message result) {
  3681. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SIM_OPEN_CHANNEL_WITH_SW, result);
  3682. +
  3683. + rr.mParcel.writeString(AID);
  3684. +
  3685. + if (RILJ_LOGD) riljLog(rr.serialString() + "> iccOpenChannelWithSw: " + requestToString(rr.mRequest)
  3686. + + " " + AID);
  3687. +
  3688. + send(rr);
  3689. + }
  3690. +
  3691. + public void setTrm(int mode, Message result) {
  3692. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_TRM, null);
  3693. +
  3694. + rr.mParcel.writeInt(1);
  3695. + rr.mParcel.writeInt(mode);
  3696. +
  3697. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  3698. + send(rr);
  3699. + }
  3700. +
  3701. + public void setResumeRegistration(int sessionId, Message response) {
  3702. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_RESUME_REGISTRATION, response);
  3703. + rr.mParcel.writeInt(1);
  3704. + rr.mParcel.writeInt(sessionId);
  3705. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  3706. + send(rr);
  3707. + }
  3708. +
  3709. + public void queryModemType(Message response) {
  3710. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_QUERY_MODEM_TYPE, response);
  3711. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  3712. + send(rr);
  3713. + }
  3714. +
  3715. + public void storeModemType(int modemType, Message response) {
  3716. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_STORE_MODEM_TYPE, response);
  3717. + rr.mParcel.writeInt(1);
  3718. + rr.mParcel.writeInt(modemType);
  3719. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  3720. + send(rr);
  3721. + }
  3722. +
  3723. + /*
  3724. + public void
  3725. + emergencyDial(String address, int clirMode, UUSInfo uusInfo, Message result) {
  3726. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_EMERGENCY_DIAL, result);
  3727. +
  3728. + rr.mParcel.writeString(address);
  3729. + rr.mParcel.writeInt(clirMode);
  3730. + rr.mParcel.writeInt(0); // UUS information is absent
  3731. +
  3732. + if (uusInfo == null) {
  3733. + rr.mParcel.writeInt(0); // UUS information is absent
  3734. + } else {
  3735. + rr.mParcel.writeInt(1); // UUS information is present
  3736. + rr.mParcel.writeInt(uusInfo.getType());
  3737. + rr.mParcel.writeInt(uusInfo.getDcs());
  3738. + rr.mParcel.writeByteArray(uusInfo.getUserData());
  3739. + }
  3740. +
  3741. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  3742. +
  3743. + send(rr);
  3744. + }
  3745. + */
  3746. +
  3747. + public void setEccServiceCategory(int serviceCategory) {
  3748. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_ECC_SERVICE_CATEGORY, null);
  3749. +
  3750. + rr.mParcel.writeInt(1);
  3751. + rr.mParcel.writeInt(serviceCategory);
  3752. +
  3753. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
  3754. + + " " + serviceCategory);
  3755. +
  3756. + send(rr);
  3757. + }
  3758. +
  3759. + private void setEccList() {
  3760. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_ECC_LIST, null);
  3761. + ArrayList<PhoneNumberUtils.EccEntry> eccList = PhoneNumberUtils.getEccList();
  3762. +
  3763. + rr.mParcel.writeInt(eccList.size() * 3);
  3764. + for (PhoneNumberUtils.EccEntry entry : eccList) {
  3765. + rr.mParcel.writeString(entry.getEcc());
  3766. + rr.mParcel.writeString(entry.getCategory());
  3767. + String strCondition = entry.getCondition();
  3768. + if (strCondition.equals(PhoneNumberUtils.EccEntry.ECC_FOR_MMI))
  3769. + strCondition = PhoneNumberUtils.EccEntry.ECC_NO_SIM;
  3770. + rr.mParcel.writeString(strCondition);
  3771. + }
  3772. +
  3773. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  3774. +
  3775. + send(rr);
  3776. + }
  3777. +
  3778. + // M: Fast Dormancy
  3779. + public void setScri(boolean forceRelease, Message response) {
  3780. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_SCRI, response);
  3781. +
  3782. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  3783. +
  3784. + rr.mParcel.writeInt(1);
  3785. + rr.mParcel.writeInt(forceRelease ? 1 : 0);
  3786. +
  3787. + send(rr);
  3788. + }
  3789. +
  3790. + //[New R8 modem FD]
  3791. + public void setFDMode(int mode, int parameter1, int parameter2, Message response) {
  3792. + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_FD_MODE, response);
  3793. +
  3794. + //AT+EFD=<mode>[,<param1>[,<param2>]]
  3795. + //mode=0:disable modem Fast Dormancy; mode=1:enable modem Fast Dormancy
  3796. + //mode=3:inform modem the screen status; parameter1: screen on or off
  3797. + //mode=2:Fast Dormancy inactivity timer; parameter1:timer_id; parameter2:timer_value
  3798. + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  3799. +
  3800. + if (mode == 0 || mode == 1) {
  3801. + rr.mParcel.writeInt(1);
  3802. + rr.mParcel.writeInt(mode);
  3803. + } else if (mode == 3) {
  3804. + rr.mParcel.writeInt(2);
  3805. + rr.mParcel.writeInt(mode);
  3806. + rr.mParcel.writeInt(parameter1);
  3807. + } else if (mode == 2) {
  3808. + rr.mParcel.writeInt(3);
  3809. + rr.mParcel.writeInt(mode);
  3810. + rr.mParcel.writeInt(parameter1);
  3811. + rr.mParcel.writeInt(parameter2);
  3812. + }
  3813. +
  3814. + send(rr);
  3815. + }
  3816. }
  3817. diff --git a/src/java/com/android/internal/telephony/ServiceStateTracker.java b/src/java/com/android/internal/telephony/ServiceStateTracker.java
  3818. index 179d4a1..7630879 100644
  3819. --- a/src/java/com/android/internal/telephony/ServiceStateTracker.java
  3820. +++ b/src/java/com/android/internal/telephony/ServiceStateTracker.java
  3821. @@ -189,6 +189,28 @@ public abstract class ServiceStateTracker extends Handler {
  3822. protected static final int EVENT_IMS_STATE_CHANGED = 46;
  3823. protected static final int EVENT_IMS_STATE_DONE = 47;
  3824.  
  3825. + // MTK events
  3826. + protected static final int EVENT_DATA_CONNECTION_DETACHED = 100;
  3827. + protected static final int EVENT_INVALID_SIM_INFO = 101; //ALPS00248788
  3828. + protected static final int EVENT_PS_NETWORK_STATE_CHANGED = 102;
  3829. + protected static final int EVENT_IMEI_LOCK = 103; /* ALPS00296298 */
  3830. + protected static final int EVENT_DISABLE_EMMRRS_STATUS = 104;
  3831. + protected static final int EVENT_ENABLE_EMMRRS_STATUS = 105;
  3832. + protected static final int EVENT_ICC_REFRESH = 106;
  3833. + protected static final int EVENT_FEMTO_CELL_INFO = 107;
  3834. + protected static final int EVENT_GET_CELL_INFO_LIST_BY_RATE = 108;
  3835. + protected static final int EVENT_SET_IMS_ENABLED_DONE = 109;
  3836. + protected static final int EVENT_SET_IMS_DISABLE_DONE = 110;
  3837. + protected static final int EVENT_IMS_DISABLED_URC = 111;
  3838. + protected static final int EVENT_IMS_REGISTRATION_INFO = 112;
  3839. +
  3840. + // MTK CDMA events
  3841. + protected static final int EVENT_QUERY_NITZ_TIME = 200;
  3842. + protected static final int EVENT_GET_NITZ_TIME = 201;
  3843. + protected static final int EVENT_NETWORK_TYPE_CHANGED = 202;
  3844. + protected static final int EVENT_ETS_DEV_CHANGED = 203;
  3845. + protected static final int EVENT_SET_MDN_DONE = 204;
  3846. +
  3847. protected static final String TIMEZONE_PROPERTY = "persist.sys.timezone";
  3848.  
  3849. /**
  3850. diff --git a/src/java/com/android/internal/telephony/SubscriptionInfoUpdater.java b/src/java/com/android/internal/telephony/SubscriptionInfoUpdater.java
  3851. index 95f805e..a806374 100644
  3852. --- a/src/java/com/android/internal/telephony/SubscriptionInfoUpdater.java
  3853. +++ b/src/java/com/android/internal/telephony/SubscriptionInfoUpdater.java
  3854. @@ -225,7 +225,7 @@ public class SubscriptionInfoUpdater extends Handler {
  3855. mIccId[slotId] = ICCID_STRING_FOR_NO_SIM;
  3856. }
  3857. } else {
  3858. - mIccId[slotId] = ICCID_STRING_FOR_NO_SIM;
  3859. + mIccId[slotId] = mFh[slotId].needsFakeIccid() ? IccConstants.FAKE_ICCID : ICCID_STRING_FOR_NO_SIM;
  3860. logd("Query IccId fail: " + ar.exception);
  3861. }
  3862. logd("mIccId[" + slotId + "] = " + mIccId[slotId]);
  3863. diff --git a/src/java/com/android/internal/telephony/cdma/CdmaSubscriptionSourceManager.java b/src/java/com/android/internal/telephony/cdma/CdmaSubscriptionSourceManager.java
  3864. index f7b8936..059d24d 100644
  3865. --- a/src/java/com/android/internal/telephony/cdma/CdmaSubscriptionSourceManager.java
  3866. +++ b/src/java/com/android/internal/telephony/cdma/CdmaSubscriptionSourceManager.java
  3867. @@ -44,7 +44,7 @@ public class CdmaSubscriptionSourceManager extends Handler {
  3868. public static final int SUBSCRIPTION_SOURCE_UNKNOWN = -1;
  3869. public static final int SUBSCRIPTION_FROM_RUIM = 0; /* CDMA subscription from RUIM */
  3870. public static final int SUBSCRIPTION_FROM_NV = 1; /* CDMA subscription from NV */
  3871. - public static final int PREFERRED_CDMA_SUBSCRIPTION = SUBSCRIPTION_FROM_NV;
  3872. + public static final int PREFERRED_CDMA_SUBSCRIPTION = SUBSCRIPTION_FROM_RUIM;
  3873.  
  3874. private static CdmaSubscriptionSourceManager sInstance;
  3875. private static final Object sReferenceCountMonitor = new Object();
  3876. diff --git a/src/java/com/android/internal/telephony/dataconnection/ApnSetting.java b/src/java/com/android/internal/telephony/dataconnection/ApnSetting.java
  3877. index cf2c57c..c9963c7 100755
  3878. --- a/src/java/com/android/internal/telephony/dataconnection/ApnSetting.java
  3879. +++ b/src/java/com/android/internal/telephony/dataconnection/ApnSetting.java
  3880. @@ -111,23 +111,23 @@ public class ApnSetting {
  3881. int profileId, boolean modemCognitive, int maxConns, int waitTime, int maxConnsTime,
  3882. int mtu, String mvnoType, String mvnoMatchData) {
  3883. this.id = id;
  3884. - this.numeric = numeric;
  3885. - this.carrier = carrier;
  3886. - this.apn = apn;
  3887. - this.proxy = proxy;
  3888. - this.port = port;
  3889. - this.mmsc = mmsc;
  3890. - this.mmsProxy = mmsProxy;
  3891. - this.mmsPort = mmsPort;
  3892. - this.user = user;
  3893. - this.password = password;
  3894. + this.numeric = numeric == null ? "" : numeric;
  3895. + this.carrier = carrier == null ? "" : carrier;
  3896. + this.apn = apn == null ? "" : apn;
  3897. + this.proxy = proxy == null ? "" : proxy;
  3898. + this.port = port == null ? "" : port;
  3899. + this.mmsc = mmsc == null ? "" : mmsc;
  3900. + this.mmsProxy = mmsProxy == null ? "" : mmsProxy;
  3901. + this.mmsPort = mmsPort == null ? "" : mmsPort;
  3902. + this.user = user == null ? "" : user;
  3903. + this.password = password == null ? "" : password;
  3904. this.authType = authType;
  3905. this.types = new String[types.length];
  3906. for (int i = 0; i < types.length; i++) {
  3907. - this.types[i] = types[i].toLowerCase(Locale.ROOT);
  3908. + this.types[i] = types[i] == null ? "" : types[i].toLowerCase(Locale.ROOT);
  3909. }
  3910. - this.protocol = protocol;
  3911. - this.roamingProtocol = roamingProtocol;
  3912. + this.protocol = protocol == null ? "" : protocol;
  3913. + this.roamingProtocol = roamingProtocol == null ? "" : roamingProtocol;
  3914. this.carrierEnabled = carrierEnabled;
  3915. this.bearer = bearer;
  3916. this.profileId = profileId;
  3917. @@ -136,8 +136,8 @@ public class ApnSetting {
  3918. this.waitTime = waitTime;
  3919. this.maxConnsTime = maxConnsTime;
  3920. this.mtu = mtu;
  3921. - this.mvnoType = mvnoType;
  3922. - this.mvnoMatchData = mvnoMatchData;
  3923. + this.mvnoType = mvnoType == null ? "" : mvnoType;
  3924. + this.mvnoMatchData = mvnoMatchData == null ? "" : mvnoMatchData;
  3925.  
  3926. }
  3927.  
  3928. diff --git a/src/java/com/android/internal/telephony/dataconnection/DcTracker.java b/src/java/com/android/internal/telephony/dataconnection/DcTracker.java
  3929. index b9432f1..aa5c1e6 100755
  3930. --- a/src/java/com/android/internal/telephony/dataconnection/DcTracker.java
  3931. +++ b/src/java/com/android/internal/telephony/dataconnection/DcTracker.java
  3932. @@ -88,6 +88,9 @@ import com.android.internal.telephony.uicc.IccUtils;
  3933. import com.android.internal.util.AsyncChannel;
  3934. import com.android.internal.util.ArrayUtils;
  3935.  
  3936. +// MTK
  3937. +import com.mediatek.internal.telephony.dataconnection.FdManager;
  3938. +
  3939. import java.io.FileDescriptor;
  3940. import java.io.PrintWriter;
  3941. import java.nio.ByteBuffer;
  3942. @@ -185,6 +188,9 @@ public final class DcTracker extends DcTrackerBase {
  3943. private boolean mDeregistrationAlarmState = false;
  3944. private PendingIntent mImsDeregistrationDelayIntent = null;
  3945.  
  3946. + // MTK
  3947. + protected FdManager mFdMgr;
  3948. +
  3949. /* IWLAN and WWAN co-exist flag */
  3950. private boolean mWwanIwlanCoexistFlag = false;
  3951.  
  3952. @@ -254,6 +260,9 @@ public final class DcTracker extends DcTrackerBase {
  3953. mPhone.getContext().registerReceiver(mIntentReceiver, filter, null, mPhone);
  3954. }
  3955.  
  3956. + // MTK Fast Dormancy
  3957. + mFdMgr = FdManager.getInstance(p);
  3958. +
  3959. // Add Emergency APN to APN setting list by default to support EPDN in sim absent cases
  3960. initEmergencyApnSetting();
  3961. addEmergencyApnSetting();
  3962. @@ -869,6 +878,7 @@ public final class DcTracker extends DcTrackerBase {
  3963. IccRecords r = mIccRecords.get();
  3964. boolean recordsLoaded = false;
  3965. if (r != null) {
  3966. + log("isDataAllowed mIccRecords=IccRecords {" + r.toString() + "}");
  3967. recordsLoaded = r.getRecordsLoaded();
  3968. if (DBG) log("isDataAllowed getRecordsLoaded=" + recordsLoaded);
  3969. }
  3970. diff --git a/src/java/com/android/internal/telephony/dataconnection/DcTrackerBase.java b/src/java/com/android/internal/telephony/dataconnection/DcTrackerBase.java
  3971. index 850a33e..816aa81 100644
  3972. --- a/src/java/com/android/internal/telephony/dataconnection/DcTrackerBase.java
  3973. +++ b/src/java/com/android/internal/telephony/dataconnection/DcTrackerBase.java
  3974. @@ -1807,7 +1807,7 @@ public abstract class DcTrackerBase extends Handler {
  3975. ApnSetting firstApnSetting = null;
  3976. String operator = (r != null) ? r.getOperatorNumeric(): "";
  3977.  
  3978. - log("setInitialApn: E mPreferredApn=" + mPreferredApn);
  3979. + log("setInitialApn: E operator=" + operator + " mPreferredApn=" + mPreferredApn);
  3980.  
  3981. if (apnList != null && !apnList.isEmpty()) {
  3982. firstApnSetting = apnList.get(0);
  3983. @@ -1859,7 +1859,9 @@ public abstract class DcTrackerBase extends Handler {
  3984.  
  3985. mPhone.mCi.setInitialAttachApn(initialAttachApnSetting.apn,
  3986. initialAttachApnSetting.protocol, initialAttachApnSetting.authType,
  3987. - initialAttachApnSetting.user, initialAttachApnSetting.password, null);
  3988. + initialAttachApnSetting.user, initialAttachApnSetting.password,
  3989. + operator, initialAttachApnSetting.canHandleType(PhoneConstants.APN_TYPE_IMS),
  3990. + null);
  3991. }
  3992. }
  3993.  
  3994. diff --git a/src/java/com/android/internal/telephony/gsm/GSMPhone.java b/src/java/com/android/internal/telephony/gsm/GSMPhone.java
  3995. index 1b8ef2d..723c223 100644
  3996. --- a/src/java/com/android/internal/telephony/gsm/GSMPhone.java
  3997. +++ b/src/java/com/android/internal/telephony/gsm/GSMPhone.java
  3998. @@ -147,6 +147,8 @@ public class GSMPhone extends PhoneBase {
  3999. }
  4000. }
  4001.  
  4002. + public boolean mIsNetworkInitiatedUssd = false;
  4003. +
  4004. // Constructors
  4005.  
  4006. public
  4007. @@ -977,6 +979,9 @@ public class GSMPhone extends PhoneBase {
  4008. @Override
  4009. public void sendUssdResponse(String ussdMessge) {
  4010. GsmMmiCode mmi = GsmMmiCode.newFromUssdUserInput(ussdMessge, this, mUiccApplication.get());
  4011. + /* M: SS part */
  4012. + Rlog.d(LOG_TAG, "[sendUssdResponse]mPendingMMIs.add(mmi) + " + mmi);
  4013. + /* M: SS part end */
  4014. mPendingMMIs.add(mmi);
  4015. mMmiRegistrants.notifyRegistrants(new AsyncResult(null, mmi, null));
  4016. mmi.sendUssd(ussdMessge);
  4017. @@ -1470,6 +1475,10 @@ public class GSMPhone extends PhoneBase {
  4018. * The exception is cancellation of an incoming USSD-REQUEST, which is
  4019. * not on the list.
  4020. */
  4021. +
  4022. + /* M: SS part */
  4023. + Rlog.d(LOG_TAG, "mPendingMMIs.remove(mmi) - " + mmi);
  4024. + /* M: SS part end */
  4025. if (mPendingMMIs.remove(mmi) || mmi.isUssdRequest() || mmi.isSsInfo()) {
  4026. mMmiCompleteRegistrants.notifyRegistrants(
  4027. new AsyncResult(null, mmi, null));
  4028. @@ -1477,6 +1486,27 @@ public class GSMPhone extends PhoneBase {
  4029. }
  4030.  
  4031. /**
  4032. + * Removes the given MMI from the pending list and notifies
  4033. + * registrants that it is complete.
  4034. + * @param mmi MMI that is done
  4035. + * @param obj User object to deliver to application
  4036. + */
  4037. + public void onMMIDone(GsmMmiCode mmi, Object obj) {
  4038. + /* Only notify complete if it's on the pending list.
  4039. + * Otherwise, it's already been handled (eg, previously canceled).
  4040. + * The exception is cancellation of an incoming USSD-REQUEST, which is
  4041. + * not on the list.
  4042. + */
  4043. + /* M: SS part */
  4044. + Rlog.d(LOG_TAG, "mPendingMMIs.remove(mmi) - " + mmi);
  4045. + /* M: SS part end */
  4046. + if (mPendingMMIs.remove(mmi) || mmi.isUssdRequest() || mmi.isSsInfo()) {
  4047. + mMmiCompleteRegistrants.notifyRegistrants(
  4048. + new AsyncResult(obj, mmi, null));
  4049. + }
  4050. + }
  4051. +
  4052. + /**
  4053. * Used to check if Call Forwarding status is present on sim card. If not, a message is
  4054. * sent so we can check if the CF status is stored as a Shared Preference.
  4055. */
  4056. @@ -1506,34 +1536,55 @@ public class GSMPhone extends PhoneBase {
  4057. boolean isUssdError;
  4058. boolean isUssdRequest;
  4059. boolean isUssdRelease;
  4060. + boolean isUssdhandleByStk;
  4061. +
  4062. + Rlog.d(LOG_TAG, "onIncomingUSSD(): mIsNetworkInitiatedUssd = " + mIsNetworkInitiatedUssd);
  4063.  
  4064. isUssdRequest
  4065. = (ussdMode == CommandsInterface.USSD_MODE_REQUEST);
  4066. -
  4067. + /* M: SS part */
  4068. + //MTK-START [mtk04070][111118][ALPS00093395]MTK modified
  4069. isUssdError
  4070. - = (ussdMode != CommandsInterface.USSD_MODE_NOTIFY
  4071. - && ussdMode != CommandsInterface.USSD_MODE_REQUEST);
  4072. + = ((ussdMode == CommandsInterface.USSD_OPERATION_NOT_SUPPORTED)
  4073. + || (ussdMode == CommandsInterface.USSD_NETWORK_TIMEOUT));
  4074. + //MTK-END [mtk04070][111118][ALPS00093395]MTK modified
  4075. +
  4076. + isUssdhandleByStk
  4077. + = (ussdMode == CommandsInterface.USSD_HANDLED_BY_STK);
  4078. + /* M: SS part end */
  4079.  
  4080. isUssdRelease = (ussdMode == CommandsInterface.USSD_MODE_NW_RELEASE);
  4081. + Rlog.d(LOG_TAG, "ussdMode= " + ussdMode);
  4082. + Rlog.d(LOG_TAG, "isUssdRequest=" + isUssdRequest + " isUssdError= " + isUssdError);
  4083.  
  4084. // See comments in GsmMmiCode.java
  4085. // USSD requests aren't finished until one
  4086. // of these two events happen
  4087. GsmMmiCode found = null;
  4088. + Rlog.d(LOG_TAG, "USSD:mPendingMMIs= " + mPendingMMIs + " size=" + mPendingMMIs.size());
  4089. for (int i = 0, s = mPendingMMIs.size() ; i < s; i++) {
  4090. + Rlog.d(LOG_TAG, "i= " + i + " isPending=" + mPendingMMIs.get(i).isPendingUSSD());
  4091. if(mPendingMMIs.get(i).isPendingUSSD()) {
  4092. found = mPendingMMIs.get(i);
  4093. + Rlog.d(LOG_TAG, "found = " + found);
  4094. break;
  4095. }
  4096. }
  4097.  
  4098. if (found != null) {
  4099. // Complete pending USSD
  4100. -
  4101. - if (isUssdRelease) {
  4102. + /* M: SS part */
  4103. + //For ALPS01471897
  4104. + Rlog.d(LOG_TAG, "setUserInitiatedMMI TRUE");
  4105. + found.setUserInitiatedMMI(true);
  4106. + /* M: SS part end */
  4107. + if (isUssdRelease && mIsNetworkInitiatedUssd) {
  4108. + Rlog.d(LOG_TAG, "onIncomingUSSD(): USSD_MODE_NW_RELEASE.");
  4109. found.onUssdRelease();
  4110. } else if (isUssdError) {
  4111. found.onUssdFinishedError();
  4112. + } else if (isUssdhandleByStk) {
  4113. + found.onUssdStkHandling(ussdMessage, isUssdRequest);
  4114. } else {
  4115. found.onUssdFinished(ussdMessage, isUssdRequest);
  4116. }
  4117. @@ -1542,6 +1593,13 @@ public class GSMPhone extends PhoneBase {
  4118.  
  4119. // ignore everything that isnt a Notify or a Request
  4120. // also, discard if there is no message to present
  4121. +
  4122. + /* M: SS part */
  4123. + //For ALPS01471897
  4124. + Rlog.d(LOG_TAG, "The default value of UserInitiatedMMI is FALSE");
  4125. + mIsNetworkInitiatedUssd = true;
  4126. + Rlog.d(LOG_TAG, "onIncomingUSSD(): Network Initialized USSD");
  4127. +
  4128. if (!isUssdError && ussdMessage != null) {
  4129. GsmMmiCode mmi;
  4130. mmi = GsmMmiCode.newNetworkInitiatedUssd(ussdMessage,
  4131. @@ -1549,8 +1607,25 @@ public class GSMPhone extends PhoneBase {
  4132. GSMPhone.this,
  4133. mUiccApplication.get());
  4134. onNetworkInitiatedUssd(mmi);
  4135. +
  4136. + //MTK-START [mtk04070][111118][ALPS00093395]MTK added
  4137. + } else if (isUssdError) {
  4138. + GsmMmiCode mmi;
  4139. + mmi = GsmMmiCode.newNetworkInitiatedUssdError(ussdMessage,
  4140. + isUssdRequest,
  4141. + GSMPhone.this,
  4142. + mUiccApplication.get());
  4143. + onNetworkInitiatedUssd(mmi);
  4144. + //MTK-END [mtk04070][111118][ALPS00093395]MTK added
  4145. }
  4146. + /* M: SS part end */
  4147. + }
  4148. +
  4149. + /* M: SS part */
  4150. + if (isUssdRelease || isUssdError) {
  4151. + mIsNetworkInitiatedUssd = false;
  4152. }
  4153. + /* M: SS part end */
  4154. }
  4155.  
  4156. /**
  4157. diff --git a/src/java/com/android/internal/telephony/gsm/GsmMmiCode.java b/src/java/com/android/internal/telephony/gsm/GsmMmiCode.java
  4158. index e2b8782..2cc6d07 100644
  4159. --- a/src/java/com/android/internal/telephony/gsm/GsmMmiCode.java
  4160. +++ b/src/java/com/android/internal/telephony/gsm/GsmMmiCode.java
  4161. @@ -119,6 +119,12 @@ public final class GsmMmiCode extends Handler implements MmiCode {
  4162. static final int EVENT_SET_CFF_COMPLETE = 6;
  4163. static final int EVENT_USSD_CANCEL_COMPLETE = 7;
  4164.  
  4165. + /* M: SS part */
  4166. + /// M: [mtk04070][111125][ALPS00093395]MTK added. @{
  4167. + static final String USSD_HANDLED_BY_STK = "stk";
  4168. + /// @}
  4169. + /* M: SS part end */
  4170. +
  4171. //***** Instance Variables
  4172.  
  4173. GSMPhone mPhone;
  4174. @@ -143,6 +149,9 @@ public final class GsmMmiCode extends Handler implements MmiCode {
  4175. CharSequence mMessage;
  4176. private boolean mIsSsInfo = false;
  4177.  
  4178. + //For ALPS01471897
  4179. + private boolean mUserInitiatedMMI = false;
  4180. + //end
  4181.  
  4182. //***** Class Variables
  4183.  
  4184. @@ -576,10 +585,21 @@ public final class GsmMmiCode extends Handler implements MmiCode {
  4185. return ((Phone) mPhone);
  4186. }
  4187.  
  4188. + //For ALPS01471897
  4189. + public void setUserInitiatedMMI(boolean userinit)
  4190. + {
  4191. + mUserInitiatedMMI = userinit;
  4192. + }
  4193. +
  4194. + public boolean getUserInitiatedMMI() {
  4195. + return mUserInitiatedMMI;
  4196. + }
  4197. +
  4198. // inherited javadoc suffices
  4199. @Override
  4200. public void
  4201. cancel() {
  4202. + mPhone.mIsNetworkInitiatedUssd = false;
  4203. // Complete or failed cannot be cancelled
  4204. if (mState == State.COMPLETE || mState == State.FAILED) {
  4205. return;
  4206. @@ -782,6 +802,36 @@ public final class GsmMmiCode extends Handler implements MmiCode {
  4207. return mIsSsInfo;
  4208. }
  4209.  
  4210. + public static boolean isUssdNumber(String dialString, GSMPhone dialPhone, UiccCardApplication iccApp) {
  4211. + String newDialString = PhoneNumberUtils.stripSeparators(dialString);
  4212. + String networkPortion = PhoneNumberUtils.extractNetworkPortionAlt(newDialString);
  4213. +
  4214. + GsmMmiCode mmi = GsmMmiCode.newFromDialString(networkPortion, dialPhone, iccApp);
  4215. + if (mmi == null || mmi.isTemporaryModeCLIR()) {
  4216. + return false;
  4217. + }
  4218. + else {
  4219. + if (mmi.isShortCode()) {
  4220. + return true;
  4221. + } else if (mmi.mDialingNumber != null) {
  4222. + return true;
  4223. + } else if (mmi.mSc != null
  4224. + && (mmi.mSc.equals(SC_CLIP)
  4225. + || mmi.mSc.equals(SC_CLIR)
  4226. + || isServiceCodeCallForwarding(mmi.mSc)
  4227. + || isServiceCodeCallBarring(mmi.mSc)
  4228. + || mmi.mSc.equals(SC_PWD)
  4229. + || mmi.mSc.equals(SC_WAIT)
  4230. + || mmi.isPinPukCommand()
  4231. + )) {
  4232. + return false;
  4233. + } else if (mmi.mPoundString != null) {
  4234. + return true;
  4235. + }
  4236. + return false;
  4237. + }
  4238. + }
  4239. +
  4240. /** Process a MMI code or short code...anything that isn't a dialing number */
  4241. void
  4242. processCode () {
  4243. @@ -792,7 +842,13 @@ public final class GsmMmiCode extends Handler implements MmiCode {
  4244. sendUssd(mDialingNumber);
  4245. } else if (mDialingNumber != null) {
  4246. // We should have no dialing numbers here
  4247. - throw new RuntimeException ("Invalid or Unsupported MMI Code");
  4248. +
  4249. + /* M: SS part */
  4250. + /// M: [mtk04070][111125][ALPS00093395]MTK modified. @{
  4251. + Rlog.w(LOG_TAG, "Special USSD Support:" + mPoundString + mDialingNumber);
  4252. + sendUssd(mPoundString + mDialingNumber);
  4253. + //throw new RuntimeException ("Invalid or Unsupported MMI Code");
  4254. + /// @}
  4255. } else if (mSc != null && mSc.equals(SC_CLIP)) {
  4256. Rlog.d(LOG_TAG, "is CLIP");
  4257. if (isInterrogate()) {
  4258. @@ -1010,7 +1066,10 @@ public final class GsmMmiCode extends Handler implements MmiCode {
  4259. void
  4260. onUssdFinished(String ussdMessage, boolean isUssdRequest) {
  4261. if (mState == State.PENDING) {
  4262. - if (ussdMessage == null) {
  4263. + /* M: SS part */
  4264. + /// M: [mtk04070][111125][ALPS00093395]Check the length of ussdMessage.
  4265. + if (ussdMessage == null || ussdMessage.length() == 0) {
  4266. + /* M: SS part end */
  4267. mMessage = mContext.getText(com.android.internal.R.string.mmiComplete);
  4268. } else {
  4269. mMessage = ussdMessage;
  4270. @@ -1020,11 +1079,28 @@ public final class GsmMmiCode extends Handler implements MmiCode {
  4271. if (!isUssdRequest) {
  4272. mState = State.COMPLETE;
  4273. }
  4274. -
  4275. mPhone.onMMIDone(this);
  4276. }
  4277. }
  4278.  
  4279. + void
  4280. + onUssdStkHandling(String ussdMessage, boolean isUssdRequest) {
  4281. + if (mState == State.PENDING) {
  4282. + if (ussdMessage == null || ussdMessage.length() == 0) {
  4283. + mMessage = mContext.getText(com.android.internal.R.string.mmiComplete);
  4284. + } else {
  4285. + mMessage = ussdMessage;
  4286. + }
  4287. + mIsUssdRequest = isUssdRequest;
  4288. + // If it's a request, leave it PENDING so that it's cancelable.
  4289. + if (!isUssdRequest) {
  4290. + mState = State.COMPLETE;
  4291. + }
  4292. + String userObjStringStk = USSD_HANDLED_BY_STK;
  4293. + mPhone.onMMIDone(this, (Object) userObjStringStk);
  4294. + }
  4295. + }
  4296. +
  4297. /**
  4298. * Called from GSMPhone
  4299. *
  4300. @@ -1036,11 +1112,11 @@ public final class GsmMmiCode extends Handler implements MmiCode {
  4301. if (mState == State.PENDING) {
  4302. mState = State.FAILED;
  4303. mMessage = mContext.getText(com.android.internal.R.string.mmiError);
  4304. -
  4305. mPhone.onMMIDone(this);
  4306. }
  4307. }
  4308.  
  4309. +
  4310. /**
  4311. * Called from GSMPhone
  4312. *
  4313. @@ -1060,6 +1136,7 @@ public final class GsmMmiCode extends Handler implements MmiCode {
  4314. }
  4315. }
  4316.  
  4317. +
  4318. void sendUssd(String ussdMessage) {
  4319. // Treat this as a USSD string
  4320. mIsPendingUSSD = true;
  4321. @@ -1627,4 +1704,21 @@ public final class GsmMmiCode extends Handler implements MmiCode {
  4322. sb.append("}");
  4323. return sb.toString();
  4324. }
  4325. +
  4326. + /* M: SS part */
  4327. + /// M: [mtk04070][111125][ALPS00093395]MTK proprietary methods. @{
  4328. + static GsmMmiCode
  4329. + newNetworkInitiatedUssdError(String ussdMessage,
  4330. + boolean isUssdRequest, GSMPhone phone, UiccCardApplication app) {
  4331. + GsmMmiCode ret;
  4332. +
  4333. + ret = new GsmMmiCode(phone, app);
  4334. +
  4335. + ret.mMessage = ret.mContext.getText(com.android.internal.R.string.mmiError);
  4336. + ret.mIsUssdRequest = isUssdRequest;
  4337. +
  4338. + ret.mState = State.FAILED;
  4339. +
  4340. + return ret;
  4341. + }
  4342. }
  4343. diff --git a/src/java/com/android/internal/telephony/gsm/GsmServiceStateTracker.java b/src/java/com/android/internal/telephony/gsm/GsmServiceStateTracker.java
  4344. index 117d054..f2e3d18 100644
  4345. --- a/src/java/com/android/internal/telephony/gsm/GsmServiceStateTracker.java
  4346. +++ b/src/java/com/android/internal/telephony/gsm/GsmServiceStateTracker.java
  4347. @@ -224,6 +224,20 @@ final class GsmServiceStateTracker extends ServiceStateTracker {
  4348. mCi.setOnNITZTime(this, EVENT_NITZ_TIME, null);
  4349. mCi.setOnRestrictedStateChanged(this, EVENT_RESTRICTED_STATE_CHANGED, null);
  4350.  
  4351. + // MTK
  4352. + mCi.registerForPsNetworkStateChanged(this, EVENT_PS_NETWORK_STATE_CHANGED, null);
  4353. + // mCi.setInvalidSimInfo(this, EVENT_INVALID_SIM_INFO, null); //ALPS00248788
  4354. +
  4355. + // mCi.registerForIccRefresh(this, EVENT_ICC_REFRESH, null);
  4356. + /*
  4357. + if (SystemProperties.get("ro.mtk_ims_support").equals("1")) {
  4358. + mCi.registerForImsDisable(this, EVENT_IMS_DISABLED_URC, null);
  4359. + mCi.registerForImsRegistrationInfo(this, EVENT_IMS_REGISTRATION_INFO, null);
  4360. + }
  4361. + if (SystemProperties.get("ro.mtk_femto_cell_support").equals("1"))
  4362. + mCi.registerForFemtoCellInfo(this, EVENT_FEMTO_CELL_INFO, null);
  4363. + */
  4364. +
  4365. // system setting property AIRPLANE_MODE_ON is set in Settings.
  4366. int airplaneMode = Settings.Global.getInt(
  4367. phone.getContext().getContentResolver(),
  4368. @@ -267,6 +281,11 @@ final class GsmServiceStateTracker extends ServiceStateTracker {
  4369. mCr.unregisterContentObserver(mAutoTimeObserver);
  4370. mCr.unregisterContentObserver(mAutoTimeZoneObserver);
  4371. mPhone.getContext().unregisterReceiver(mIntentReceiver);
  4372. +
  4373. + // MTK
  4374. + // mCi.unregisterForIccRefresh(this);
  4375. + mCi.unregisterForPsNetworkStateChanged(this);
  4376. +
  4377. super.dispose();
  4378. }
  4379.  
  4380. @@ -327,6 +346,10 @@ final class GsmServiceStateTracker extends ServiceStateTracker {
  4381. pollState();
  4382. break;
  4383.  
  4384. + case EVENT_PS_NETWORK_STATE_CHANGED:
  4385. + pollState();
  4386. + break;
  4387. +
  4388. case EVENT_GET_SIGNAL_STRENGTH:
  4389. // This callback is called when signal strength is polled
  4390. // all by itself
  4391. @@ -720,6 +743,12 @@ final class GsmServiceStateTracker extends ServiceStateTracker {
  4392. psc = Integer.parseInt(states[14], 16);
  4393. }
  4394. }
  4395. +
  4396. + log("EVENT_POLL_STATE_REGISTRATION mSS getRilVoiceRadioTechnology:" + mSS.getRilVoiceRadioTechnology() +
  4397. + ", regState:" + regState +
  4398. + ", NewSS RilVoiceRadioTechnology:" + mNewSS.getRilVoiceRadioTechnology() +
  4399. + ", lac:" + lac +
  4400. + ", cid:" + cid);
  4401. } catch (NumberFormatException ex) {
  4402. loge("error parsing RegistrationState: " + ex);
  4403. }
  4404. @@ -783,12 +812,18 @@ final class GsmServiceStateTracker extends ServiceStateTracker {
  4405. if (states.length >= 4 && states[3] != null) {
  4406. type = Integer.parseInt(states[3]);
  4407. }
  4408. - if ((states.length >= 5 ) &&
  4409. + if (states.length >= 5 && states[4] != null) {
  4410. + log("<cell_data_speed_support> " + states[4]);
  4411. + }
  4412. + if (states.length >= 6 && states[5] != null) {
  4413. + log("<max_data_bearer_capability> " + states[5]);
  4414. + }
  4415. + if ((states.length >= 7) &&
  4416. (regState == ServiceState.RIL_REG_STATE_DENIED)) {
  4417. - mNewReasonDataDenied = Integer.parseInt(states[4]);
  4418. + mNewReasonDataDenied = Integer.parseInt(states[6]);
  4419. }
  4420. - if (states.length >= 6) {
  4421. - mNewMaxDataCalls = Integer.parseInt(states[5]);
  4422. + if (states.length >= 8) {
  4423. + mNewMaxDataCalls = Integer.parseInt(states[7]);
  4424. }
  4425. } catch (NumberFormatException ex) {
  4426. loge("error parsing GprsRegistrationState: " + ex);
  4427. diff --git a/src/java/com/android/internal/telephony/imsphone/ImsPhone.java b/src/java/com/android/internal/telephony/imsphone/ImsPhone.java
  4428. index b4c70d9..ac63ebf 100644
  4429. --- a/src/java/com/android/internal/telephony/imsphone/ImsPhone.java
  4430. +++ b/src/java/com/android/internal/telephony/imsphone/ImsPhone.java
  4431. @@ -104,6 +104,14 @@ public class ImsPhone extends ImsPhoneBase {
  4432.  
  4433. public static final String CS_FALLBACK = "cs_fallback";
  4434.  
  4435. + /// M: @{
  4436. + /**
  4437. + * Used as the message in CallStateException.
  4438. + * We don't support dialing a USSD number while there is an existing IMS call.
  4439. + */
  4440. + public static final String USSD_DURING_IMS_INCALL = "ussd_during_ims_incall";
  4441. + /// @}
  4442. +
  4443. static final int RESTART_ECM_TIMER = 0; // restart Ecm timer
  4444. static final int CANCEL_ECM_TIMER = 1; // cancel Ecm timer
  4445.  
  4446. @@ -532,6 +540,16 @@ public class ImsPhone extends ImsPhoneBase {
  4447. return result;
  4448. }
  4449.  
  4450. + /// M: for USSD over IMS workaround. @{
  4451. + private boolean isUssdDuringInCall(ImsPhoneMmiCode mmi) {
  4452. + if (mmi == null || !mmi.isUssdNumber()) {
  4453. + return false;
  4454. + }
  4455. +
  4456. + return isInCall();
  4457. + }
  4458. + /// @}
  4459. +
  4460. boolean isInCall() {
  4461. ImsPhoneCall.State foregroundCallState = getForegroundCall().getState();
  4462. ImsPhoneCall.State backgroundCallState = getBackgroundCall().getState();
  4463. diff --git a/src/java/com/android/internal/telephony/imsphone/ImsPhoneCommandInterface.java b/src/java/com/android/internal/telephony/imsphone/ImsPhoneCommandInterface.java
  4464. index 755e87c..9226a8b 100644
  4465. --- a/src/java/com/android/internal/telephony/imsphone/ImsPhoneCommandInterface.java
  4466. +++ b/src/java/com/android/internal/telephony/imsphone/ImsPhoneCommandInterface.java
  4467. @@ -586,5 +586,52 @@ class ImsPhoneCommandInterface extends BaseCommands implements CommandsInterface
  4468. public void requestShutdown(Message result) {
  4469. }
  4470.  
  4471. + // MTK
  4472. +
  4473. + @Override
  4474. + public void iccGetATR(Message response) {
  4475. + }
  4476. +
  4477. + @Override
  4478. + public void iccOpenChannelWithSw(String AID, Message result){
  4479. + }
  4480. +
  4481. + @Override
  4482. + public void setTrm(int mode, Message result) {
  4483. + }
  4484. +
  4485. + @Override
  4486. + public void setOnPlmnChangeNotification(Handler h, int what, Object obj) {
  4487. + }
  4488. +
  4489. + @Override
  4490. + public void unSetOnPlmnChangeNotification(Handler h) {
  4491. + }
  4492. +
  4493. + @Override
  4494. + public void setOnRegistrationSuspended(Handler h, int what, Object obj) {
  4495. + }
  4496. +
  4497. + @Override
  4498. + public void unSetOnRegistrationSuspended(Handler h) {
  4499. + }
  4500. +
  4501. + @Override
  4502. + public void setResumeRegistration(int sessionId, Message response) {
  4503. + }
  4504. +
  4505. + @Override
  4506. + public void queryModemType(Message response) {
  4507. + }
  4508. +
  4509. + @Override
  4510. + public void storeModemType(int modemType, Message response) {
  4511. + }
  4512. +
  4513. + @Override
  4514. + public void setInitialAttachApn(String apn, String protocol, int authType, String username,
  4515. + String password, String operatorNumeric, boolean canHandleIms, Message result) {
  4516. + }
  4517. +
  4518. public boolean needsOldRilFeature(String feature) { return false; }
  4519. }
  4520. diff --git a/src/java/com/android/internal/telephony/imsphone/ImsPhoneMmiCode.java b/src/java/com/android/internal/telephony/imsphone/ImsPhoneMmiCode.java
  4521. index 18d94ad..2a9191c 100644
  4522. --- a/src/java/com/android/internal/telephony/imsphone/ImsPhoneMmiCode.java
  4523. +++ b/src/java/com/android/internal/telephony/imsphone/ImsPhoneMmiCode.java
  4524. @@ -1797,4 +1797,25 @@ public final class ImsPhoneMmiCode extends Handler implements MmiCode {
  4525. sb.append("}");
  4526. return sb.toString();
  4527. }
  4528. +
  4529. + /// M: for SS part. @{
  4530. + /**
  4531. + Utility function to check if it is USSD number.
  4532. + @return boolean true if this an USSD number.
  4533. + */
  4534. + public boolean isUssdNumber() {
  4535. + if (isTemporaryModeCLIR()) {
  4536. + return false;
  4537. + } else {
  4538. + if (isShortCode()) {
  4539. + return true;
  4540. + } else if (mDialingNumber != null) {
  4541. + return true;
  4542. + } else if (mPoundString != null) {
  4543. + return true;
  4544. + }
  4545. + return false;
  4546. + }
  4547. + }
  4548. + /// @}
  4549. }
  4550. diff --git a/src/java/com/android/internal/telephony/sip/SipCommandInterface.java b/src/java/com/android/internal/telephony/sip/SipCommandInterface.java
  4551. index 65c37ba..f14bf69 100644
  4552. --- a/src/java/com/android/internal/telephony/sip/SipCommandInterface.java
  4553. +++ b/src/java/com/android/internal/telephony/sip/SipCommandInterface.java
  4554. @@ -589,5 +589,52 @@ class SipCommandInterface extends BaseCommands implements CommandsInterface {
  4555. public void requestShutdown(Message result) {
  4556. }
  4557.  
  4558. + // MTK
  4559. +
  4560. + @Override
  4561. + public void iccGetATR(Message response) {
  4562. + }
  4563. +
  4564. + @Override
  4565. + public void iccOpenChannelWithSw(String AID, Message result){
  4566. + }
  4567. +
  4568. + @Override
  4569. + public void setTrm(int mode, Message result) {
  4570. + }
  4571. +
  4572. + @Override
  4573. + public void setOnPlmnChangeNotification(Handler h, int what, Object obj) {
  4574. + }
  4575. +
  4576. + @Override
  4577. + public void unSetOnPlmnChangeNotification(Handler h) {
  4578. + }
  4579. +
  4580. + @Override
  4581. + public void setOnRegistrationSuspended(Handler h, int what, Object obj) {
  4582. + }
  4583. +
  4584. + @Override
  4585. + public void unSetOnRegistrationSuspended(Handler h) {
  4586. + }
  4587. +
  4588. + @Override
  4589. + public void setResumeRegistration(int sessionId, Message response) {
  4590. + }
  4591. +
  4592. + @Override
  4593. + public void queryModemType(Message response) {
  4594. + }
  4595. +
  4596. + @Override
  4597. + public void storeModemType(int modemType, Message response) {
  4598. + }
  4599. +
  4600. + @Override
  4601. + public void setInitialAttachApn(String apn, String protocol, int authType, String username,
  4602. + String password, String operatorNumeric, boolean canHandleIms, Message result) {
  4603. + }
  4604. +
  4605. public boolean needsOldRilFeature(String feature) { return false; }
  4606. }
  4607. diff --git a/src/java/com/android/internal/telephony/test/SimulatedCommands.java b/src/java/com/android/internal/telephony/test/SimulatedCommands.java
  4608. index 0181430..afddcdc 100644
  4609. --- a/src/java/com/android/internal/telephony/test/SimulatedCommands.java
  4610. +++ b/src/java/com/android/internal/telephony/test/SimulatedCommands.java
  4611. @@ -1776,5 +1776,38 @@ public final class SimulatedCommands extends BaseCommands
  4612. setRadioState(RadioState.RADIO_UNAVAILABLE);
  4613. }
  4614.  
  4615. + // MTK additions
  4616. +
  4617. + @Override
  4618. + public void iccGetATR(Message response) {
  4619. + unimplemented(response);
  4620. + }
  4621. +
  4622. + @Override
  4623. + public void iccOpenChannelWithSw(String AID, Message response) {
  4624. + unimplemented(response);
  4625. + }
  4626. +
  4627. + @Override
  4628. + public void setTrm(int mode, Message result) {
  4629. + }
  4630. +
  4631. + @Override
  4632. + public void setResumeRegistration(int sessionId, Message response) {
  4633. + }
  4634. +
  4635. + @Override
  4636. + public void queryModemType(Message response) {
  4637. + }
  4638. +
  4639. + @Override
  4640. + public void storeModemType(int modemType, Message response) {
  4641. + }
  4642. +
  4643. + @Override
  4644. + public void setInitialAttachApn(String apn, String protocol, int authType, String username,
  4645. + String password, String operatorNumeric, boolean canHandleIms, Message result) {
  4646. + }
  4647. +
  4648. public boolean needsOldRilFeature(String feature) { return false; }
  4649. }
  4650. diff --git a/src/java/com/android/internal/telephony/uicc/IccCardProxy.java b/src/java/com/android/internal/telephony/uicc/IccCardProxy.java
  4651. index c4c55c6..ed7bab6 100755
  4652. --- a/src/java/com/android/internal/telephony/uicc/IccCardProxy.java
  4653. +++ b/src/java/com/android/internal/telephony/uicc/IccCardProxy.java
  4654. @@ -54,6 +54,8 @@ import com.android.internal.telephony.uicc.IccCardStatus.PinState;
  4655. import com.android.internal.telephony.uicc.UiccController;
  4656. import com.android.internal.telephony.uicc.RuimRecords;
  4657.  
  4658. +import com.mediatek.internal.telephony.uicc.IccCardProxyEx;
  4659. +
  4660. import java.io.FileDescriptor;
  4661. import java.io.PrintWriter;
  4662.  
  4663. @@ -103,6 +105,21 @@ public class IccCardProxy extends Handler implements IccCard {
  4664. private static final int EVENT_SUBSCRIPTION_DEACTIVATED = 502;
  4665. private static final int EVENT_CARRIER_PRIVILIGES_LOADED = 503;
  4666.  
  4667. + // MTK
  4668. + private static final int EVENT_ICC_RECOVERY = 100;
  4669. + private static final int EVENT_ICC_FDN_CHANGED = 101;
  4670. + private static final int EVENT_NOT_AVAILABLE = 102;
  4671. +
  4672. + private static final String ICCID_STRING_FOR_NO_SIM = "N/A";
  4673. + private String[] PROPERTY_ICCID_SIM = {
  4674. + "ril.iccid.sim1",
  4675. + "ril.iccid.sim2",
  4676. + "ril.iccid.sim3",
  4677. + "ril.iccid.sim4",
  4678. + };
  4679. +
  4680. + private static final String COMMON_SLOT_PROPERTY = "";
  4681. +
  4682. private Integer mPhoneId = null;
  4683.  
  4684. private final Object mLock = new Object();
  4685. @@ -113,6 +130,10 @@ public class IccCardProxy extends Handler implements IccCard {
  4686. private RegistrantList mPinLockedRegistrants = new RegistrantList();
  4687. private RegistrantList mPersoLockedRegistrants = new RegistrantList();
  4688.  
  4689. + // MTK
  4690. + private RegistrantList mRecoveryRegistrants = new RegistrantList();
  4691. + private RegistrantList mFdnChangedRegistrants = new RegistrantList();
  4692. +
  4693. private int mCurrentAppType = UiccController.APP_FAM_3GPP; //default to 3gpp?
  4694. private UiccController mUiccController = null;
  4695. private UiccCard mUiccCard = null;
  4696. @@ -127,6 +148,9 @@ public class IccCardProxy extends Handler implements IccCard {
  4697. private boolean mIsCardStatusAvailable = false;
  4698. private PersoSubState mPersoSubState = PersoSubState.PERSOSUBSTATE_UNKNOWN;
  4699.  
  4700. + // MTK
  4701. + private IccCardProxyEx mIccCardProxyEx;
  4702. +
  4703. // Sim State events may be broadcasted before the siminfo table update has been
  4704. // completed. Due to this such events may be broadcasted with dummy subId for a
  4705. // particular slotId. Therefore, setExternalState once the siminfo table has been updated.
  4706. @@ -145,6 +169,7 @@ public class IccCardProxy extends Handler implements IccCard {
  4707. mContext = context;
  4708. mCi = ci;
  4709. mPhoneId = phoneId;
  4710. + mIccCardProxyEx = new IccCardProxyEx(context, ci);
  4711. mCdmaSSM = CdmaSubscriptionSourceManager.getInstance(context,
  4712. ci, this, EVENT_CDMA_SUBSCRIPTION_SOURCE_CHANGED, null);
  4713. mUiccController = UiccController.getInstance();
  4714. @@ -168,6 +193,7 @@ public class IccCardProxy extends Handler implements IccCard {
  4715. mCi.unregisterForOn(this);
  4716. mCi.unregisterForOffOrNotAvailable(this);
  4717. mCdmaSSM.dispose(this);
  4718. + mIccCardProxyEx.dispose();
  4719. }
  4720. }
  4721.  
  4722. @@ -288,6 +314,10 @@ public class IccCardProxy extends Handler implements IccCard {
  4723. setExternalState(State.NOT_READY);
  4724. }
  4725. break;
  4726. + case EVENT_NOT_AVAILABLE:
  4727. + log("handleMessage (EVENT_NOT_AVAILABLE)");
  4728. + setExternalState(State.NOT_READY);
  4729. + break;
  4730. case EVENT_RADIO_ON:
  4731. mRadioOn = true;
  4732. if (!mInitialized) {
  4733. @@ -302,9 +332,29 @@ public class IccCardProxy extends Handler implements IccCard {
  4734. case EVENT_ICC_CHANGED:
  4735. mIsCardStatusAvailable = true;
  4736. if (mInitialized) {
  4737. + AsyncResult ar = (AsyncResult) msg.obj;
  4738. + int index = mPhoneId;
  4739. +
  4740. + if (ar != null && ar.result instanceof Integer) {
  4741. + index = ((Integer) ar.result).intValue();
  4742. + log("handleMessage (EVENT_ICC_CHANGED), index=" + index + " mPhoneId=" + mPhoneId);
  4743. + } else {
  4744. + log("handleMessage (EVENT_ICC_CHANGED), come from myself, mPhoneId=" + mPhoneId);
  4745. + }
  4746. +
  4747. updateIccAvailability();
  4748. }
  4749. break;
  4750. + case EVENT_ICC_RECOVERY: {
  4751. + AsyncResult ar = (AsyncResult) msg.obj;
  4752. + Integer index = (Integer) ar.result;
  4753. + log("handleMessage (EVENT_ICC_RECOVERY) , index = " + index);
  4754. + // if (index == mSlotId) {
  4755. + if (DBG) log("mRecoveryRegistrants notify");
  4756. + mRecoveryRegistrants.notifyRegistrants();
  4757. + // }
  4758. + break;
  4759. + }
  4760. case EVENT_ICC_ABSENT:
  4761. mAbsentRegistrants.notifyRegistrants();
  4762. setExternalState(State.ABSENT);
  4763. @@ -386,6 +436,10 @@ public class IccCardProxy extends Handler implements IccCard {
  4764. }
  4765. break;
  4766.  
  4767. + case EVENT_ICC_FDN_CHANGED:
  4768. + mFdnChangedRegistrants.notifyRegistrants();
  4769. + break;
  4770. +
  4771. case EVENT_CARRIER_PRIVILIGES_LOADED:
  4772. log("EVENT_CARRIER_PRIVILEGES_LOADED");
  4773. if (mUiccCard != null) {
  4774. @@ -490,12 +544,19 @@ public class IccCardProxy extends Handler implements IccCard {
  4775. setExternalState(State.PUK_REQUIRED);
  4776. break;
  4777. case APPSTATE_SUBSCRIPTION_PERSO:
  4778. + /* [mtk02772][ALPS00437082]
  4779. + mediatek platform will set network locked for all of subState (5 type of network locked)
  4780. + */
  4781. + setExternalState(State.PERSO_LOCKED);
  4782. +
  4783. + /*
  4784. if (mUiccApplication.isPersoLocked()) {
  4785. mPersoSubState = mUiccApplication.getPersoSubState();
  4786. setExternalState(State.PERSO_LOCKED);
  4787. } else {
  4788. setExternalState(State.UNKNOWN);
  4789. }
  4790. + */
  4791. break;
  4792. case APPSTATE_READY:
  4793. setExternalState(State.READY);
  4794. @@ -655,7 +716,15 @@ public class IccCardProxy extends Handler implements IccCard {
  4795. switch (state) {
  4796. case PIN_REQUIRED: return IccCardConstants.INTENT_VALUE_LOCKED_ON_PIN;
  4797. case PUK_REQUIRED: return IccCardConstants.INTENT_VALUE_LOCKED_ON_PUK;
  4798. - case PERSO_LOCKED: return IccCardConstants.INTENT_VALUE_LOCKED_PERSO;
  4799. + case PERSO_LOCKED: // return IccCardConstants.INTENT_VALUE_LOCKED_PERSO;
  4800. + switch (mUiccApplication.getPersoSubState()) {
  4801. + case PERSOSUBSTATE_SIM_NETWORK: return IccCardConstants.INTENT_VALUE_LOCKED_NETWORK;
  4802. + case PERSOSUBSTATE_SIM_NETWORK_SUBSET: return IccCardConstants.INTENT_VALUE_LOCKED_NETWORK_SUBSET;
  4803. + case PERSOSUBSTATE_SIM_CORPORATE: return IccCardConstants.INTENT_VALUE_LOCKED_CORPORATE;
  4804. + case PERSOSUBSTATE_SIM_SERVICE_PROVIDER: return IccCardConstants.INTENT_VALUE_LOCKED_SERVICE_PROVIDER;
  4805. + case PERSOSUBSTATE_SIM_SIM: return IccCardConstants.INTENT_VALUE_LOCKED_SIM;
  4806. + default: return null;
  4807. + }
  4808. case PERM_DISABLED: return IccCardConstants.INTENT_VALUE_ABSENT_ON_PERM_DISABLED;
  4809. case CARD_IO_ERROR: return IccCardConstants.INTENT_VALUE_ICC_CARD_IO_ERROR;
  4810. default: return null;
  4811. @@ -990,4 +1059,142 @@ public class IccCardProxy extends Handler implements IccCard {
  4812.  
  4813. pw.flush();
  4814. }
  4815. +
  4816. + // MTK additions
  4817. +
  4818. + // Added by M begin
  4819. + /**
  4820. + * Query the SIM ME Lock type required to unlock.
  4821. + *
  4822. + * @return SIM ME Lock type
  4823. + */
  4824. + public PersoSubState getNetworkPersoType() {
  4825. + if (mUiccApplication != null) {
  4826. + return mUiccApplication.getPersoSubState();
  4827. + }
  4828. + return PersoSubState.PERSOSUBSTATE_UNKNOWN;
  4829. + }
  4830. +
  4831. + /**
  4832. + * Check whether ICC network lock is enabled
  4833. + * This is an async call which returns lock state to applications directly
  4834. + */
  4835. + @Override
  4836. + public void queryIccNetworkLock(int category, Message onComplete) {
  4837. + if (DBG) log("queryIccNetworkLock(): category = " + category);
  4838. + synchronized (mLock) {
  4839. + if (mUiccApplication != null) {
  4840. + mUiccApplication.queryIccNetworkLock(category, onComplete);
  4841. + } else if (onComplete != null) {
  4842. + Exception e = new RuntimeException("ICC card is absent.");
  4843. + AsyncResult.forMessage(onComplete).exception = e;
  4844. + onComplete.sendToTarget();
  4845. + return;
  4846. + }
  4847. + }
  4848. + }
  4849. +
  4850. + /**
  4851. + * Set the ICC network lock enabled or disabled
  4852. + * When the operation is complete, onComplete will be sent to its handler
  4853. + */
  4854. + @Override
  4855. + public void setIccNetworkLockEnabled(int category,
  4856. + int lockop, String password, String data_imsi, String gid1, String gid2, Message onComplete) {
  4857. + if (DBG) log("SetIccNetworkEnabled(): category = " + category
  4858. + + " lockop = " + lockop + " password = " + password
  4859. + + " data_imsi = " + data_imsi + " gid1 = " + gid1 + " gid2 = " + gid2);
  4860. + synchronized (mLock) {
  4861. + if (mUiccApplication != null) {
  4862. + mUiccApplication.setIccNetworkLockEnabled(category, lockop, password, data_imsi, gid1, gid2, onComplete);
  4863. + } else if (onComplete != null) {
  4864. + Exception e = new RuntimeException("ICC card is absent.");
  4865. + AsyncResult.forMessage(onComplete).exception = e;
  4866. + onComplete.sendToTarget();
  4867. + return;
  4868. + }
  4869. + }
  4870. + }
  4871. +
  4872. + /**
  4873. + * Used by SIM ME lock related enhancement feature(Modem SML change feature).
  4874. + */
  4875. + public void repollIccStateForModemSmlChangeFeatrue(boolean needIntent) {
  4876. + if (DBG) log("repollIccStateForModemSmlChangeFeatrue, needIntent = " + needIntent);
  4877. + synchronized (mLock) {
  4878. + mUiccController.repollIccStateForModemSmlChangeFeatrue(mPhoneId, needIntent);
  4879. + }
  4880. + }
  4881. +
  4882. + public void exchangeSimIo(int fileID, int command,
  4883. + int p1, int p2, int p3, String pathID, String data, String pin2, Message onComplete) {
  4884. + if (mUiccCard != null && mUiccCard.getCardState() != CardState.CARDSTATE_ABSENT) {
  4885. + mUiccCard.exchangeSimIo(fileID, command, p1, p2, p3, pathID, data, pin2, onComplete);
  4886. + }
  4887. + }
  4888. +
  4889. + public void iccGetAtr(Message onComplete) {
  4890. + if (mUiccCard != null && mUiccCard.getCardState() != CardState.CARDSTATE_ABSENT) {
  4891. + mUiccCard.iccGetAtr(onComplete);
  4892. + }
  4893. + }
  4894. +
  4895. + public void openLogicalChannelWithSw(String AID, Message onComplete) {
  4896. + if (mUiccCard != null && mUiccCard.getCardState() != CardState.CARDSTATE_ABSENT) {
  4897. + mUiccCard.iccOpenChannelWithSw(AID, onComplete);
  4898. + }
  4899. + }
  4900. +
  4901. + // retrun usim property or use uicccardapplication app type
  4902. + public String getIccCardType() {
  4903. + if (mUiccCard != null && mUiccCard.getCardState() != CardState.CARDSTATE_ABSENT) {
  4904. + return mUiccCard.getIccCardType();
  4905. + }
  4906. + return "";
  4907. + }
  4908. +
  4909. + public void registerForRecovery(Handler h, int what, Object obj) {
  4910. + synchronized (mLock) {
  4911. + Registrant r = new Registrant(h, what, obj);
  4912. +
  4913. + mRecoveryRegistrants.add(r);
  4914. +
  4915. + if (getState() == State.READY) {
  4916. + r.notifyRegistrant();
  4917. + }
  4918. + }
  4919. + }
  4920. +
  4921. + public void unregisterForRecovery(Handler h) {
  4922. + synchronized (mLock) {
  4923. + mRecoveryRegistrants.remove(h);
  4924. + }
  4925. + }
  4926. +
  4927. + /**
  4928. + * Notifies handler in case of FDN changed
  4929. + */
  4930. + @Override
  4931. + public void registerForFdnChanged(Handler h, int what, Object obj) {
  4932. + synchronized (mLock) {
  4933. + synchronized (mLock) {
  4934. + Registrant r = new Registrant(h, what, obj);
  4935. +
  4936. + mFdnChangedRegistrants.add(r);
  4937. +
  4938. + if (getIccFdnEnabled()) {
  4939. + r.notifyRegistrant();
  4940. + }
  4941. + }
  4942. + }
  4943. + }
  4944. +
  4945. + @Override
  4946. + public void unregisterForFdnChanged(Handler h) {
  4947. + synchronized (mLock) {
  4948. + mFdnChangedRegistrants.remove(h);
  4949. + }
  4950. + }
  4951. +
  4952. + // Added by M end
  4953. }
  4954. diff --git a/src/java/com/android/internal/telephony/uicc/IccConstants.java b/src/java/com/android/internal/telephony/uicc/IccConstants.java
  4955. index facc918..4b5b48f 100644
  4956. --- a/src/java/com/android/internal/telephony/uicc/IccConstants.java
  4957. +++ b/src/java/com/android/internal/telephony/uicc/IccConstants.java
  4958. @@ -112,4 +112,34 @@ public interface IccConstants {
  4959.  
  4960. //UICC access
  4961. static final String DF_ADF = "7FFF";
  4962. +
  4963. + //CM-Specific : Fake ICCID
  4964. + static final String FAKE_ICCID = "00000000000001";
  4965. +
  4966. + // MTK
  4967. + static final int EF_ECC = 0x6FB7;
  4968. +
  4969. + // USIM SIM file ids from TS 31.102
  4970. + static final int EF_PSISMSC = 0x6FE5;
  4971. + static final int EF_GBABP = 0x6fD6;
  4972. + // [ALPS01206315] Support EF_SMSP (EF ids from 11.11/31.102)
  4973. + static final int EF_SMSP = 0x6F42;
  4974. + static final int EF_ELP = 0x2F05;
  4975. + // ALPS00302702 RAT balancing
  4976. + static public final int EF_RAT = 0x4F36; // ADF(USIM)/7F66/5F30/4F36
  4977. + static final String DF_USIM = "7FFF";
  4978. + static final int EF_GID2 = 0x6F3F;
  4979. +
  4980. + // MTK-START [ALPS00092673] Orange feature merge back added by mtk80589 in 2011.11.15
  4981. + /*
  4982. + Detail description:
  4983. + This feature provides a interface to get menu title string from EF_SUME
  4984. + */
  4985. + // SET UP MENU ELEMENTS
  4986. + static final int EF_SUME = 0x6F54;
  4987. + // MTK-END [ALPS00092673] Orange feature merge back added by mtk80589 in 2011.11.15
  4988. +
  4989. + //ISIM access file ids from TS 31.103
  4990. + static final int EF_ISIM_GBABP = 0x6fd5;
  4991. + static final int EF_ISIM_GBANL = 0x6fd7;
  4992. }
  4993. diff --git a/src/java/com/android/internal/telephony/uicc/IccFileHandler.java b/src/java/com/android/internal/telephony/uicc/IccFileHandler.java
  4994. index 24d948c..e1f524b 100644
  4995. --- a/src/java/com/android/internal/telephony/uicc/IccFileHandler.java
  4996. +++ b/src/java/com/android/internal/telephony/uicc/IccFileHandler.java
  4997. @@ -18,6 +18,7 @@ package com.android.internal.telephony.uicc;
  4998.  
  4999. import android.os.*;
  5000. import com.android.internal.telephony.CommandsInterface;
  5001. +import com.android.internal.telephony.PhoneConstants;
  5002.  
  5003. import java.util.ArrayList;
  5004.  
  5005. @@ -92,6 +93,9 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5006. /** Finished retrieving size of record for EFimg now. */
  5007. static protected final int EVENT_GET_RECORD_SIZE_IMG_DONE = 11;
  5008.  
  5009. + // MTK
  5010. + static protected final int EVENT_SELECT_EF_FILE = 100;
  5011. +
  5012. // member variables
  5013. protected final CommandsInterface mCi;
  5014. protected final UiccCardApplication mParentApp;
  5015. @@ -104,6 +108,10 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5016. boolean mLoadAll;
  5017. String mPath;
  5018.  
  5019. + // MTK
  5020. + int mChannel;
  5021. + int mMode;
  5022. +
  5023. // Variables used to load part records
  5024. boolean mLoadPart;
  5025. ArrayList<Integer> mRecordNums;
  5026. @@ -120,6 +128,8 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5027. mLoadAll = false;
  5028. mLoadPart = false;
  5029. mPath = null;
  5030. + mChannel = 0;
  5031. + mMode = -1;
  5032. }
  5033.  
  5034. LoadLinearFixedContext(int efid, int recordNum, String path, Message onLoaded) {
  5035. @@ -129,6 +139,8 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5036. mLoadAll = false;
  5037. mLoadPart = false;
  5038. mPath = path;
  5039. + mChannel = 0;
  5040. + mMode = -1;
  5041. }
  5042.  
  5043. LoadLinearFixedContext(int efid, String path, Message onLoaded) {
  5044. @@ -138,6 +150,8 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5045. mLoadPart = false;
  5046. mOnLoaded = onLoaded;
  5047. mPath = path;
  5048. + mChannel = 0;
  5049. + mMode = -1;
  5050. }
  5051.  
  5052. LoadLinearFixedContext(int efid, Message onLoaded) {
  5053. @@ -147,6 +161,8 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5054. mLoadPart = false;
  5055. mOnLoaded = onLoaded;
  5056. mPath = null;
  5057. + mChannel = 0;
  5058. + mMode = -1;
  5059. }
  5060.  
  5061. LoadLinearFixedContext(int efid, ArrayList<Integer> recordNums, String path,
  5062. @@ -161,6 +177,31 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5063. mCountLoadrecords = recordNums.size();
  5064. mOnLoaded = onLoaded;
  5065. mPath = path;
  5066. + mChannel = 0;
  5067. + mMode = -1;
  5068. + }
  5069. +
  5070. + // MTK
  5071. + LoadLinearFixedContext(int efid, int recordNum, Message onLoaded, int channel) {
  5072. + mEfid = efid;
  5073. + mRecordNum = recordNum;
  5074. + mOnLoaded = onLoaded;
  5075. + mLoadAll = false;
  5076. + mLoadPart = false;
  5077. + mPath = null;
  5078. + mChannel = channel;
  5079. + mMode = -1;
  5080. + }
  5081. +
  5082. + LoadLinearFixedContext(int efid, Message onLoaded, int channel) {
  5083. + mEfid = efid;
  5084. + mRecordNum = 1;
  5085. + mOnLoaded = onLoaded;
  5086. + mLoadAll = true;
  5087. + mLoadPart = false;
  5088. + mPath = null;
  5089. + mChannel = channel;
  5090. + mMode = -1;
  5091. }
  5092.  
  5093. private void initLCResults(int size) {
  5094. @@ -496,6 +537,7 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5095. int fileid;
  5096. int recordSize[];
  5097. String path = null;
  5098. + int channel = 0;
  5099.  
  5100. try {
  5101. switch (msg.what) {
  5102. @@ -591,12 +633,22 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5103. if (path == null) {
  5104. path = getEFPath(lc.mEfid);
  5105. }
  5106. - mCi.iccIOForApp(COMMAND_READ_RECORD, lc.mEfid, path,
  5107. - lc.mRecordNum,
  5108. - READ_RECORD_MODE_ABSOLUTE,
  5109. - lc.mRecordSize, null, null, mAid,
  5110. - obtainMessage(EVENT_READ_RECORD_DONE, lc));
  5111. - break;
  5112. +
  5113. +
  5114. + if (lc.mMode != -1) {
  5115. + mCi.iccIOForAppEx(COMMAND_READ_RECORD, lc.mEfid, getSmsEFPath(lc.mMode),
  5116. + lc.mRecordNum,
  5117. + READ_RECORD_MODE_ABSOLUTE,
  5118. + lc.mRecordSize, null, null, mAid, lc.mChannel,
  5119. + obtainMessage(EVENT_READ_RECORD_DONE, lc));
  5120. + } else {
  5121. + mCi.iccIOForAppEx(COMMAND_READ_RECORD, lc.mEfid, path,
  5122. + lc.mRecordNum,
  5123. + READ_RECORD_MODE_ABSOLUTE,
  5124. + lc.mRecordSize, null, null, mAid, lc.mChannel,
  5125. + obtainMessage(EVENT_READ_RECORD_DONE, lc));
  5126. + }
  5127. + break;
  5128. case EVENT_GET_BINARY_SIZE_DONE:
  5129. ar = (AsyncResult)msg.obj;
  5130. response = (Message) ar.userObj;
  5131. @@ -609,6 +661,7 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5132. data = result.payload;
  5133.  
  5134. fileid = msg.arg1;
  5135. + channel = msg.arg2;
  5136.  
  5137. if (UiccTlvData.isUiccTlvData(data)) {
  5138.  
  5139. @@ -634,8 +687,8 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5140. throw new IccFileTypeMismatch();
  5141. }
  5142.  
  5143. - mCi.iccIOForApp(COMMAND_READ_BINARY, fileid, getEFPath(fileid),
  5144. - 0, 0, size, null, null, mAid,
  5145. + mCi.iccIOForAppEx(COMMAND_READ_BINARY, fileid, getEFPath(fileid),
  5146. + 0, 0, size, null, null, mAid, channel,
  5147. obtainMessage(EVENT_READ_BINARY_DONE,
  5148. fileid, 0, response));
  5149. break;
  5150. @@ -665,11 +718,20 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5151. path = getEFPath(lc.mEfid);
  5152. }
  5153.  
  5154. - mCi.iccIOForApp(COMMAND_READ_RECORD, lc.mEfid, path,
  5155. - lc.mRecordNum,
  5156. - READ_RECORD_MODE_ABSOLUTE,
  5157. - lc.mRecordSize, null, null, mAid,
  5158. - obtainMessage(EVENT_READ_RECORD_DONE, lc));
  5159. + if (lc.mMode != -1) {
  5160. + mCi.iccIOForAppEx(COMMAND_READ_RECORD, lc.mEfid,
  5161. + getSmsEFPath(lc.mMode),
  5162. + lc.mRecordNum,
  5163. + READ_RECORD_MODE_ABSOLUTE,
  5164. + lc.mRecordSize, null, null, mAid, lc.mChannel,
  5165. + obtainMessage(EVENT_READ_RECORD_DONE, lc));
  5166. + } else {
  5167. + mCi.iccIOForAppEx(COMMAND_READ_RECORD, lc.mEfid, path,
  5168. + lc.mRecordNum,
  5169. + READ_RECORD_MODE_ABSOLUTE,
  5170. + lc.mRecordSize, null, null, mAid, lc.mChannel,
  5171. + obtainMessage(EVENT_READ_RECORD_DONE, lc));
  5172. + }
  5173. }
  5174. } else if (lc.mLoadPart) {
  5175. lc.results.set(lc.mRecordNum - 1, result.payload);
  5176. @@ -680,9 +742,20 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5177. if (path == null) {
  5178. path = getEFPath(lc.mEfid);
  5179. }
  5180. - mCi.iccIOForApp(COMMAND_READ_RECORD, lc.mEfid, path, lc.mRecordNum,
  5181. - READ_RECORD_MODE_ABSOLUTE, lc.mRecordSize, null, null, mAid,
  5182. - obtainMessage(EVENT_READ_RECORD_DONE, lc));
  5183. + if (lc.mMode != -1) {
  5184. + mCi.iccIOForAppEx(COMMAND_READ_RECORD, lc.mEfid,
  5185. + getSmsEFPath(lc.mMode),
  5186. + lc.mRecordNum,
  5187. + READ_RECORD_MODE_ABSOLUTE,
  5188. + lc.mRecordSize, null, null, mAid, lc.mChannel,
  5189. + obtainMessage(EVENT_READ_RECORD_DONE, lc));
  5190. + } else {
  5191. + mCi.iccIOForAppEx(COMMAND_READ_RECORD, lc.mEfid, path,
  5192. + lc.mRecordNum,
  5193. + READ_RECORD_MODE_ABSOLUTE,
  5194. + lc.mRecordSize, null, null, mAid, lc.mChannel,
  5195. + obtainMessage(EVENT_READ_RECORD_DONE, lc));
  5196. + }
  5197. } else {
  5198. sendResult(response, lc.results, null);
  5199. }
  5200. @@ -752,9 +825,123 @@ public abstract class IccFileHandler extends Handler implements IccConstants {
  5201. return null;
  5202. }
  5203.  
  5204. + public boolean needsFakeIccid() {
  5205. + return mCi.needsOldRilFeature("fakeiccid");
  5206. + }
  5207. +
  5208. protected abstract String getEFPath(int efid);
  5209. protected abstract void logd(String s);
  5210.  
  5211. protected abstract void loge(String s);
  5212.  
  5213. + // MTK
  5214. + public void loadEFLinearFixedAll(int fileid, Message onLoaded, boolean is7FFF) {
  5215. + Message response = obtainMessage(EVENT_GET_RECORD_SIZE_DONE,
  5216. + new LoadLinearFixedContext(fileid, onLoaded));
  5217. +
  5218. + mCi.iccIOForApp(COMMAND_GET_RESPONSE, fileid, getEFPath(fileid, is7FFF),
  5219. + 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, mAid, response);
  5220. + }
  5221. +
  5222. + public void loadEFLinearFixedAll(int fileid, int mode , Message onLoaded) {
  5223. + LoadLinearFixedContext lc = new LoadLinearFixedContext(fileid, onLoaded);
  5224. + lc.mMode = mode;
  5225. + Message response = obtainMessage(EVENT_GET_RECORD_SIZE_DONE, lc);
  5226. +
  5227. + mCi.iccIOForApp(COMMAND_GET_RESPONSE, fileid, getSmsEFPath(mode),
  5228. + 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, mAid, response);
  5229. + }
  5230. +
  5231. + protected String getSmsEFPath(int mode)
  5232. + {
  5233. + String efpath = "";
  5234. +
  5235. + if (mode == PhoneConstants.PHONE_TYPE_GSM)
  5236. + efpath = IccConstants.MF_SIM + IccConstants.DF_TELECOM;
  5237. + else if (mode == PhoneConstants.PHONE_TYPE_CDMA)
  5238. + efpath = IccConstants.MF_SIM + IccConstants.DF_CDMA;
  5239. +
  5240. + return efpath;
  5241. + }
  5242. +
  5243. +
  5244. + /**
  5245. + * Load a SIM Transparent EF with path specified
  5246. + *
  5247. + * @param fileid EF id
  5248. + * @param efPath EF path
  5249. + * @param onLoaded
  5250. + *
  5251. + * ((AsyncResult)(onLoaded.obj)).result is the byte[]
  5252. + *
  5253. + */
  5254. +
  5255. + public void loadEFTransparent(int fileid, String efPath, Message onLoaded) {
  5256. + Message response = obtainMessage(EVENT_GET_BINARY_SIZE_DONE,
  5257. + fileid, 0, onLoaded);
  5258. +
  5259. + mCi.iccIOForApp(COMMAND_GET_RESPONSE, fileid, efPath,
  5260. + 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, mAid, response);
  5261. + }
  5262. +
  5263. +
  5264. + /**
  5265. + * select an EF file and get response
  5266. + *
  5267. + * @param fileid EF id
  5268. + * @param onLoaded (EFResponseData)efData
  5269. + *
  5270. + */
  5271. + public void selectEFFile(int fileid, Message onLoaded) {
  5272. + Message response
  5273. + = obtainMessage(EVENT_SELECT_EF_FILE, fileid, 0, onLoaded);
  5274. +
  5275. + mCi.iccIOForApp(COMMAND_GET_RESPONSE, fileid, getEFPath(fileid),
  5276. + 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, mAid, response);
  5277. + }
  5278. + //MTK-START Support Multi-Application
  5279. + /**
  5280. + * Load a SIM Transparent EF
  5281. + *
  5282. + * @param fileid EF id
  5283. + * @param channel application channel
  5284. + * @param onLoaded
  5285. + *
  5286. + * ((AsyncResult)(onLoaded.obj)).result is the byte[]
  5287. + *
  5288. + */
  5289. +
  5290. + public void loadEFTransparentEx(int fileid, int channel , Message onLoaded) {
  5291. + Message response = obtainMessage(EVENT_GET_BINARY_SIZE_DONE,
  5292. + fileid, channel, onLoaded);
  5293. +
  5294. + mCi.iccIOForAppEx(COMMAND_GET_RESPONSE, fileid, getEFPath(fileid),
  5295. + 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, mAid, channel, response);
  5296. + }
  5297. +
  5298. + public void loadEFLinearFixedEx(int fileid, int recordNum, int channel, Message onLoaded) {
  5299. + Message response
  5300. + = obtainMessage(EVENT_GET_RECORD_SIZE_DONE,
  5301. + new LoadLinearFixedContext(fileid, recordNum, onLoaded, channel));
  5302. +
  5303. + mCi.iccIOForAppEx(COMMAND_GET_RESPONSE, fileid, getEFPath(fileid),
  5304. + 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, mAid, channel, response);
  5305. + }
  5306. + public void loadEFLinearFixedAllEx(int fileid, int channel, Message onLoaded) {
  5307. + Message response = obtainMessage(EVENT_GET_RECORD_SIZE_DONE,
  5308. + new LoadLinearFixedContext(fileid, onLoaded, channel));
  5309. +
  5310. + mCi.iccIOForAppEx(COMMAND_GET_RESPONSE, fileid, getEFPath(fileid, false),
  5311. + 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, mAid, channel, response);
  5312. + }
  5313. +
  5314. + public void updateEFTransparentEx(int fileid, int channel, byte[ ] data, Message onComplete) {
  5315. + mCi.iccIOForAppEx(COMMAND_UPDATE_BINARY, fileid, getEFPath(fileid),
  5316. + 0, 0, data.length,
  5317. + IccUtils.bytesToHexString(data), null, mAid, channel, onComplete);
  5318. + }
  5319. +
  5320. + //MTK-END Support Multi-Application
  5321. +
  5322. + protected String getEFPath(int efid, boolean is7FFF) { return null; };
  5323. }
  5324. diff --git a/src/java/com/android/internal/telephony/uicc/RuimRecords.java b/src/java/com/android/internal/telephony/uicc/RuimRecords.java
  5325. index 4d16293..883642b 100644
  5326. --- a/src/java/com/android/internal/telephony/uicc/RuimRecords.java
  5327. +++ b/src/java/com/android/internal/telephony/uicc/RuimRecords.java
  5328. @@ -723,11 +723,15 @@ public final class RuimRecords extends IccRecords {
  5329. data = (byte[])ar.result;
  5330.  
  5331. if (ar.exception != null) {
  5332. - break;
  5333. + if(mFh.needsFakeIccid()) {
  5334. + mIccId = FAKE_ICCID;
  5335. + } else {
  5336. + break;
  5337. + }
  5338. + } else {
  5339. + mIccId = IccUtils.bcdToString(data, 0, data.length);
  5340. }
  5341.  
  5342. - mIccId = IccUtils.bcdToString(data, 0, data.length);
  5343. -
  5344. log("iccid: " + mIccId);
  5345.  
  5346. break;
  5347. diff --git a/src/java/com/android/internal/telephony/uicc/SIMRecords.java b/src/java/com/android/internal/telephony/uicc/SIMRecords.java
  5348. index cd65830..df24072 100644
  5349. --- a/src/java/com/android/internal/telephony/uicc/SIMRecords.java
  5350. +++ b/src/java/com/android/internal/telephony/uicc/SIMRecords.java
  5351. @@ -876,11 +876,15 @@ public class SIMRecords extends IccRecords {
  5352. data = (byte[])ar.result;
  5353.  
  5354. if (ar.exception != null) {
  5355. - break;
  5356. + if(mFh.needsFakeIccid()) {
  5357. + mIccId = FAKE_ICCID;
  5358. + } else {
  5359. + break;
  5360. + }
  5361. + } else {
  5362. + mIccId = IccUtils.bcdToString(data, 0, data.length);
  5363. }
  5364.  
  5365. - mIccId = IccUtils.bcdToString(data, 0, data.length);
  5366. -
  5367. log("iccid: " + mIccId);
  5368.  
  5369. break;
  5370. diff --git a/src/java/com/android/internal/telephony/uicc/UiccCard.java b/src/java/com/android/internal/telephony/uicc/UiccCard.java
  5371. index 1c27e44..2c6a474 100644
  5372. --- a/src/java/com/android/internal/telephony/uicc/UiccCard.java
  5373. +++ b/src/java/com/android/internal/telephony/uicc/UiccCard.java
  5374. @@ -98,8 +98,20 @@ public class UiccCard {
  5375. private static final int EVENT_CARRIER_PRIVILIGES_LOADED = 20;
  5376. private static final int EVENT_SIM_GET_ATR_DONE = 21;
  5377.  
  5378. + // MTK
  5379. + private static final int EVENT_GET_ATR_DONE = 100;
  5380. + private static final int EVENT_OPEN_CHANNEL_WITH_SW_DONE = 101;
  5381. +
  5382. private int mPhoneId;
  5383.  
  5384. + // MTK
  5385. + static final String[] UICCCARD_PROPERTY_RIL_UICC_TYPE = {
  5386. + "gsm.ril.uicctype",
  5387. + "gsm.ril.uicctype.2",
  5388. + "gsm.ril.uicctype.3",
  5389. + "gsm.ril.uicctype.4",
  5390. + };
  5391. +
  5392. public UiccCard(Context c, CommandsInterface ci, IccCardStatus ics, int phoneId) {
  5393. mCardState = ics.mCardState;
  5394. mPhoneId = phoneId;
  5395. @@ -371,6 +383,9 @@ public class UiccCard {
  5396. case EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE:
  5397. case EVENT_SIM_IO_DONE:
  5398. case EVENT_SIM_GET_ATR_DONE:
  5399. + // MTK
  5400. + case EVENT_GET_ATR_DONE:
  5401. + case EVENT_OPEN_CHANNEL_WITH_SW_DONE:
  5402. AsyncResult ar = (AsyncResult)msg.obj;
  5403. if (ar.exception != null) {
  5404. if (DBG)
  5405. @@ -706,4 +721,96 @@ public class UiccCard {
  5406. }
  5407. pw.flush();
  5408. }
  5409. +
  5410. + // MTK additions
  5411. +
  5412. + public int getSlotId() {
  5413. + return mPhoneId;
  5414. + }
  5415. +
  5416. + public UiccCard(Context c, CommandsInterface ci, IccCardStatus ics, int slotId, boolean isUpdateSiminfo) {
  5417. + if (DBG) log("Creating simId " + slotId + ",isUpdateSiminfo" + isUpdateSiminfo);
  5418. + mCardState = ics.mCardState;
  5419. + mPhoneId = slotId;
  5420. + update(c, ci, ics, isUpdateSiminfo);
  5421. + }
  5422. +
  5423. + public void exchangeSimIo(int fileID, int command,
  5424. + int p1, int p2, int p3, String pathID, String data, String pin2, Message onComplete) {
  5425. + mCi.iccIO(command, fileID, pathID, p1, p2, p3, data, pin2,
  5426. + mHandler.obtainMessage(EVENT_SIM_IO_DONE, onComplete));
  5427. + }
  5428. +
  5429. + public void iccGetAtr(Message onComplete) {
  5430. + mCi.iccGetATR(mHandler.obtainMessage(EVENT_GET_ATR_DONE, onComplete));
  5431. + }
  5432. +
  5433. + public String getIccCardType() {
  5434. + final String mIccType = SystemProperties.get(UICCCARD_PROPERTY_RIL_UICC_TYPE[mPhoneId]);
  5435. + if (DBG) log("getIccCardType(): iccType = " + mIccType);
  5436. + return mIccType;
  5437. + }
  5438. +
  5439. + public void iccOpenChannelWithSw(String AID, Message onComplete) {
  5440. + mCi.iccOpenChannelWithSw(AID,
  5441. + mHandler.obtainMessage(EVENT_OPEN_CHANNEL_WITH_SW_DONE, onComplete));
  5442. + }
  5443. +
  5444. + public void update(Context c, CommandsInterface ci, IccCardStatus ics, boolean isUpdateSimInfo) {
  5445. + synchronized (mLock) {
  5446. + if (mDestroyed) {
  5447. + loge("Updated after destroyed! Fix me!");
  5448. + return;
  5449. + }
  5450. + CardState oldState = mCardState;
  5451. + mCardState = ics.mCardState;
  5452. + mUniversalPinState = ics.mUniversalPinState;
  5453. + mGsmUmtsSubscriptionAppIndex = ics.mGsmUmtsSubscriptionAppIndex;
  5454. + mCdmaSubscriptionAppIndex = ics.mCdmaSubscriptionAppIndex;
  5455. + mImsSubscriptionAppIndex = ics.mImsSubscriptionAppIndex;
  5456. + mContext = c;
  5457. + mCi = ci;
  5458. + //update applications
  5459. + if (DBG) log(ics.mApplications.length + " applications");
  5460. + for (int i = 0; i < mUiccApplications.length; i++) {
  5461. + if (mUiccApplications[i] == null) {
  5462. + //Create newly added Applications
  5463. + if (i < ics.mApplications.length) {
  5464. + mUiccApplications[i] = new UiccCardApplication(this,
  5465. + ics.mApplications[i], mContext, mCi);
  5466. + }
  5467. + } else if (i >= ics.mApplications.length) {
  5468. + //Delete removed applications
  5469. + mUiccApplications[i].dispose();
  5470. + mUiccApplications[i] = null;
  5471. + } else {
  5472. + //Update the rest
  5473. + mUiccApplications[i].update(ics.mApplications[i], mContext, mCi);
  5474. + }
  5475. + }
  5476. +
  5477. + createAndUpdateCatService();
  5478. + sanitizeApplicationIndexes();
  5479. +
  5480. + RadioState radioState = mCi.getRadioState();
  5481. + if (DBG) log("update: radioState=" + radioState + " mLastRadioState="
  5482. + + mLastRadioState + "isUpdateSimInfo= " + isUpdateSimInfo);
  5483. + // No notifications while radio is off or we just powering up
  5484. + if (isUpdateSimInfo) {
  5485. + if (radioState == RadioState.RADIO_ON && mLastRadioState == RadioState.RADIO_ON) {
  5486. + if (oldState != CardState.CARDSTATE_ABSENT &&
  5487. + mCardState == CardState.CARDSTATE_ABSENT) {
  5488. + if (DBG) log("update: notify card removed");
  5489. + mAbsentRegistrants.notifyRegistrants();
  5490. + mHandler.sendMessage(mHandler.obtainMessage(EVENT_CARD_REMOVED, null));
  5491. + } else if (oldState == CardState.CARDSTATE_ABSENT &&
  5492. + mCardState != CardState.CARDSTATE_ABSENT) {
  5493. + if (DBG) log("update: notify card added");
  5494. + mHandler.sendMessage(mHandler.obtainMessage(EVENT_CARD_ADDED, null));
  5495. + }
  5496. + }
  5497. + }
  5498. + mLastRadioState = radioState;
  5499. + }
  5500. + }
  5501. }
  5502. diff --git a/src/java/com/android/internal/telephony/uicc/UiccCardApplication.java b/src/java/com/android/internal/telephony/uicc/UiccCardApplication.java
  5503. index cce75f1..c455256 100644
  5504. --- a/src/java/com/android/internal/telephony/uicc/UiccCardApplication.java
  5505. +++ b/src/java/com/android/internal/telephony/uicc/UiccCardApplication.java
  5506. @@ -22,6 +22,7 @@ import android.os.Handler;
  5507. import android.os.Message;
  5508. import android.os.Registrant;
  5509. import android.os.RegistrantList;
  5510. +import android.os.SystemProperties;
  5511. import android.telephony.Rlog;
  5512.  
  5513. import com.android.internal.telephony.CommandsInterface;
  5514. @@ -88,6 +89,37 @@ public class UiccCardApplication {
  5515. private RegistrantList mPinLockedRegistrants = new RegistrantList();
  5516. private RegistrantList mPersoLockedRegistrants = new RegistrantList();
  5517.  
  5518. + // MTK
  5519. + private int mSlotId;
  5520. +
  5521. + private static final int EVENT_QUERY_NETWORK_LOCK_DONE = 101;
  5522. + private static final int EVENT_CHANGE_NETWORK_LOCK_DONE = 102;
  5523. + private static final int EVENT_RADIO_NOTAVAILABLE = 103;
  5524. +
  5525. + // [02772] start
  5526. + static final String[] UICCCARDAPPLICATION_PROPERTY_RIL_UICC_TYPE = {
  5527. + "gsm.ril.uicctype",
  5528. + "gsm.ril.uicctype.2",
  5529. + "gsm.ril.uicctype.3",
  5530. + "gsm.ril.uicctype.4",
  5531. + };
  5532. + protected String mIccType = null; /* Add for USIM detect */
  5533. + // [02772] end
  5534. +
  5535. + private static final String PROPERTY_PIN1_RETRY[] = {
  5536. + "gsm.sim.retry.pin1",
  5537. + "gsm.sim.retry.pin1.2",
  5538. + "gsm.sim.retry.pin1.3",
  5539. + "gsm.sim.retry.pin1.4",
  5540. + };
  5541. +
  5542. + private static final String PROPERTY_PIN2_RETRY[] = {
  5543. + "gsm.sim.retry.pin2",
  5544. + "gsm.sim.retry.pin2.2",
  5545. + "gsm.sim.retry.pin2.3",
  5546. + "gsm.sim.retry.pin2.4",
  5547. + };
  5548. +
  5549. UiccCardApplication(UiccCard uiccCard,
  5550. IccCardApplicationStatus as,
  5551. Context c,
  5552. @@ -107,6 +139,8 @@ public class UiccCardApplication {
  5553. mContext = c;
  5554. mCi = ci;
  5555.  
  5556. + mSlotId = mUiccCard.getSlotId();
  5557. +
  5558. mIccFh = createIccFileHandler(as.app_type);
  5559. mIccRecords = createIccRecords(as.app_type, mContext, mCi);
  5560. if (mAppState == AppState.APPSTATE_READY) {
  5561. @@ -146,6 +180,8 @@ public class UiccCardApplication {
  5562. mIccRecords = createIccRecords(as.app_type, c, ci);
  5563. }
  5564.  
  5565. + // MTK log
  5566. + if (DBG) log("mPersoSubState: " + mPersoSubState + " oldPersoSubState: " + oldPersoSubState);
  5567. if (mPersoSubState != oldPersoSubState &&
  5568. isPersoLocked()) {
  5569. notifyPersoLockedRegistrantsIfNeeded(null);
  5570. @@ -409,6 +445,28 @@ public class UiccCardApplication {
  5571. ar = (AsyncResult)msg.obj;
  5572. onChangeFacilityLock(ar);
  5573. break;
  5574. + case EVENT_QUERY_NETWORK_LOCK_DONE:
  5575. + if (DBG) log("handleMessage (EVENT_QUERY_NETWORK_LOCK)");
  5576. + ar = (AsyncResult) msg.obj;
  5577. +
  5578. + if (ar.exception != null) {
  5579. + Rlog.e(LOG_TAG, "Error query network lock with exception "
  5580. + + ar.exception);
  5581. + }
  5582. + AsyncResult.forMessage((Message) ar.userObj, ar.result, ar.exception);
  5583. + ((Message) ar.userObj).sendToTarget();
  5584. + break;
  5585. + case EVENT_CHANGE_NETWORK_LOCK_DONE:
  5586. + if (DBG) log("handleMessage (EVENT_CHANGE_NETWORK_LOCK)");
  5587. + ar = (AsyncResult) msg.obj;
  5588. + if (ar.exception != null) {
  5589. + Rlog.e(LOG_TAG, "Error change network lock with exception "
  5590. + + ar.exception);
  5591. + }
  5592. + AsyncResult.forMessage(((Message) ar.userObj)).exception
  5593. + = ar.exception;
  5594. + ((Message) ar.userObj).sendToTarget();
  5595. + break;
  5596. case EVENT_RADIO_UNAVAILABLE:
  5597. if (DBG) log("handleMessage (EVENT_RADIO_UNAVAILABLE)");
  5598. mAppState = AppState.APPSTATE_UNKNOWN;
  5599. @@ -779,12 +837,34 @@ public class UiccCardApplication {
  5600. }
  5601. }
  5602.  
  5603. + // MTK implementation of getIccFdnAvailable
  5604. + public boolean getIccFdnAvailableMTK() {
  5605. + if (mIccRecords == null) {
  5606. + if (DBG) log("isFdnExist mIccRecords == null");
  5607. + return false;
  5608. + }
  5609. +
  5610. + UsimServiceTable ust = mIccRecords.getUsimServiceTable();
  5611. + if (ust != null && ust.isAvailable(UsimServiceTable.UsimService.FDN)) {
  5612. + if (DBG) log("isFdnExist return true");
  5613. + return true;
  5614. + } else {
  5615. + if (DBG) log("isFdnExist return false");
  5616. + return false;
  5617. + }
  5618. + }
  5619. +
  5620. /**
  5621. * Check whether fdn (fixed dialing number) service is available.
  5622. * @return true if ICC fdn service available
  5623. * false if ICC fdn service not available
  5624. */
  5625. public boolean getIccFdnAvailable() {
  5626. + final boolean mtkResult = getIccFdnAvailableMTK();
  5627. + if (mtkResult != mIccFdnAvailable) {
  5628. + if (DBG) log("getIccFdnAvailable: WARNING: mIccFdnAvailable="
  5629. + + mIccFdnAvailable + " disagrees with mtkResult!");
  5630. + }
  5631. return mIccFdnAvailable;
  5632. }
  5633.  
  5634. @@ -958,4 +1038,87 @@ public class UiccCardApplication {
  5635. }
  5636. pw.flush();
  5637. }
  5638. +
  5639. + // MTK
  5640. + private RegistrantList mFdnChangedRegistrants = new RegistrantList();
  5641. +
  5642. + public void registerForFdnChanged(Handler h, int what, Object obj) {
  5643. + synchronized (mLock) {
  5644. + Registrant r = new Registrant(h, what, obj);
  5645. + mFdnChangedRegistrants.add(r);
  5646. + }
  5647. + }
  5648. +
  5649. + public void unregisterForFdnChanged(Handler h) {
  5650. + synchronized (mLock) {
  5651. + mFdnChangedRegistrants.remove(h);
  5652. + }
  5653. + }
  5654. +
  5655. + public int getSlotId() {
  5656. + return mSlotId;
  5657. + }
  5658. +
  5659. + private void notifyFdnChangedRegistrants() {
  5660. + if (mDestroyed) {
  5661. + return;
  5662. + }
  5663. +
  5664. + mFdnChangedRegistrants.notifyRegistrants();
  5665. + }
  5666. +
  5667. + public String getIccCardType() {
  5668. + if (mIccType == null || mIccType.equals("")) {
  5669. + mIccType = SystemProperties.get(UICCCARDAPPLICATION_PROPERTY_RIL_UICC_TYPE[mSlotId]);
  5670. + }
  5671. +
  5672. + log("getIccCardType(): mIccType = " + mIccType);
  5673. + return mIccType;
  5674. + }
  5675. +
  5676. + //MTK-START [mtk80601][111215][ALPS00093395]
  5677. + /**
  5678. + * Check whether ICC network lock is enabled
  5679. + * This is an async call which returns lock state to applications directly
  5680. + */
  5681. + public void queryIccNetworkLock(int category, Message onComplete) {
  5682. + if (DBG) log("queryIccNetworkLock(): category = " + category);
  5683. +
  5684. + switch(category) {
  5685. + case CommandsInterface.CAT_NETWOEK:
  5686. + case CommandsInterface.CAT_NETOWRK_SUBSET:
  5687. + case CommandsInterface.CAT_CORPORATE:
  5688. + case CommandsInterface.CAT_SERVICE_PROVIDER:
  5689. + case CommandsInterface.CAT_SIM:
  5690. + mCi.queryNetworkLock(category, mHandler.obtainMessage(EVENT_QUERY_NETWORK_LOCK_DONE, onComplete));
  5691. + break;
  5692. + default:
  5693. + Rlog.e(LOG_TAG, "queryIccNetworkLock unknown category = " + category);
  5694. + break;
  5695. + }
  5696. + }
  5697. +
  5698. + /**
  5699. + * Set the ICC network lock enabled or disabled
  5700. + * When the operation is complete, onComplete will be sent to its handler
  5701. + */
  5702. + public void setIccNetworkLockEnabled(int category,
  5703. + int lockop, String password, String data_imsi, String gid1, String gid2, Message onComplete) {
  5704. + if (DBG) log("SetIccNetworkEnabled(): category = " + category
  5705. + + " lockop = " + lockop + " password = " + password
  5706. + + " data_imsi = " + data_imsi + " gid1 = " + gid1 + " gid2 = " + gid2);
  5707. +
  5708. + switch(lockop) {
  5709. + case CommandsInterface.OP_REMOVE:
  5710. + case CommandsInterface.OP_ADD:
  5711. + case CommandsInterface.OP_LOCK:
  5712. + case CommandsInterface.OP_PERMANENT_UNLOCK:
  5713. + case CommandsInterface.OP_UNLOCK:
  5714. + mCi.setNetworkLock(category, lockop, password, data_imsi, gid1, gid2, mHandler.obtainMessage(EVENT_CHANGE_NETWORK_LOCK_DONE, onComplete));
  5715. + break;
  5716. + default:
  5717. + Rlog.e(LOG_TAG, "SetIccNetworkEnabled unknown operation" + lockop);
  5718. + break;
  5719. + }
  5720. + }
  5721. }
  5722. diff --git a/src/java/com/android/internal/telephony/uicc/UiccController.java b/src/java/com/android/internal/telephony/uicc/UiccController.java
  5723. index 3e5d679..e3cc67c 100644
  5724. --- a/src/java/com/android/internal/telephony/uicc/UiccController.java
  5725. +++ b/src/java/com/android/internal/telephony/uicc/UiccController.java
  5726. @@ -18,14 +18,19 @@ package com.android.internal.telephony.uicc;
  5727.  
  5728. import android.content.Context;
  5729. import android.content.Intent;
  5730. +import android.content.SharedPreferences;
  5731. +import android.content.BroadcastReceiver;
  5732. +import android.content.IntentFilter;
  5733.  
  5734. import android.os.AsyncResult;
  5735. +import android.os.Bundle;
  5736. import android.os.Handler;
  5737. import android.os.Message;
  5738. import android.os.Registrant;
  5739. import android.os.RegistrantList;
  5740. import android.os.SystemProperties;
  5741. import android.telephony.TelephonyManager;
  5742. +import android.telephony.SubscriptionManager;
  5743. import android.telephony.Rlog;
  5744. import android.text.format.Time;
  5745.  
  5746. @@ -34,7 +39,10 @@ import android.telephony.ServiceState;
  5747. import com.android.internal.telephony.CommandsInterface;
  5748. import com.android.internal.telephony.PhoneConstants;
  5749. import com.android.internal.telephony.SubscriptionController;
  5750. +import com.android.internal.telephony.IccCardConstants;
  5751. +import com.android.internal.telephony.TelephonyIntents;
  5752. import com.android.internal.telephony.uicc.IccCardApplicationStatus.AppState;
  5753. +import com.android.internal.telephony.uicc.IccCardApplicationStatus.PersoSubState;
  5754.  
  5755. import java.io.FileDescriptor;
  5756. import java.io.PrintWriter;
  5757. @@ -97,6 +105,36 @@ public class UiccController extends Handler {
  5758. private static final int EVENT_REFRESH = 4;
  5759. private static final int EVENT_REFRESH_OEM = 5;
  5760.  
  5761. + // MTK
  5762. + protected static final int EVENT_RADIO_AVAILABLE = 100;
  5763. + protected static final int EVENT_VIRTUAL_SIM_ON = 101;
  5764. + protected static final int EVENT_VIRTUAL_SIM_OFF = 102;
  5765. + protected static final int EVENT_SIM_MISSING = 103;
  5766. + protected static final int EVENT_QUERY_SIM_MISSING_STATUS = 104;
  5767. + protected static final int EVENT_SIM_RECOVERY = 105;
  5768. + protected static final int EVENT_GET_ICC_STATUS_DONE_FOR_SIM_MISSING = 106;
  5769. + protected static final int EVENT_GET_ICC_STATUS_DONE_FOR_SIM_RECOVERY = 107;
  5770. + protected static final int EVENT_QUERY_ICCID_DONE_FOR_HOT_SWAP = 108;
  5771. + protected static final int EVENT_SIM_PLUG_OUT = 109;
  5772. + protected static final int EVENT_SIM_PLUG_IN = 110;
  5773. + protected static final int EVENT_HOTSWAP_GET_ICC_STATUS_DONE = 111;
  5774. + protected static final int EVENT_QUERY_SIM_STATUS_FOR_PLUG_IN = 112;
  5775. + protected static final int EVENT_QUERY_SIM_MISSING = 113;
  5776. + protected static final int EVENT_INVALID_SIM_DETECTED = 114;
  5777. + protected static final int EVENT_REPOLL_SML_STATE = 115;
  5778. + protected static final int EVENT_COMMON_SLOT_NO_CHANGED = 116;
  5779. +
  5780. + //Multi-application
  5781. + protected static final int EVENT_TURN_ON_ISIM_APPLICATION_DONE = 200;
  5782. + protected static final int EVENT_GET_ICC_APPLICATION_STATUS = 201;
  5783. + protected static final int EVENT_APPLICATION_SESSION_CHANGED = 202;
  5784. +
  5785. + private static final int SML_FEATURE_NO_NEED_BROADCAST_INTENT = 0;
  5786. + private static final int SML_FEATURE_NEED_BROADCAST_INTENT = 1;
  5787. + private static final String ACTION_RESET_MODEM = "android.intent.action.sim.ACTION_RESET_MODEM";
  5788. + private static final String PROPERTY_3G_SWITCH = "gsm.3gswitch";
  5789. + private static final String COMMON_SLOT_PROPERTY = "ro.mtk_sim_hot_swap_common_slot";
  5790. +
  5791. private CommandsInterface[] mCis;
  5792. private UiccCard[] mUiccCards = new UiccCard[TelephonyManager.getDefault().getPhoneCount()];
  5793.  
  5794. @@ -109,6 +147,15 @@ public class UiccController extends Handler {
  5795.  
  5796. private boolean mOEMHookSimRefresh = false;
  5797.  
  5798. + // MTK
  5799. + private boolean mIsHotSwap = false;
  5800. + private boolean mClearMsisdn = false;
  5801. +
  5802. + private RegistrantList mRecoveryRegistrants = new RegistrantList();
  5803. + //Multi-application
  5804. + private int[] mImsSessionId = new int[TelephonyManager.getDefault().getPhoneCount()];
  5805. + private RegistrantList mApplicationChangedRegistrants = new RegistrantList();
  5806. +
  5807. // Logging for dumpsys. Useful in cases when the cards run into errors.
  5808. private static final int MAX_PROACTIVE_COMMANDS_TO_LOG = 20;
  5809. private LinkedList<String> mCardLogs = new LinkedList<String>();
  5810. @@ -131,9 +178,11 @@ public class UiccController extends Handler {
  5811. com.android.internal.R.bool.config_sim_refresh_for_dual_mode_card);
  5812. for (int i = 0; i < mCis.length; i++) {
  5813. Integer index = new Integer(i);
  5814. - if (SystemProperties.getBoolean("persist.radio.apm_sim_not_pwdn", false)) {
  5815. + if (SystemProperties.getBoolean("persist.radio.apm_sim_not_pwdn", false) ||
  5816. + SystemProperties.get("gsm.version.ril-impl").startsWith("mtk")) {
  5817. // Reading ICC status in airplane mode is only supported in QCOM
  5818. // RILs when this property is set to true
  5819. + // and MTK RILs
  5820. mCis[i].registerForAvailable(this, EVENT_ICC_STATUS_CHANGED, index);
  5821. } else {
  5822. mCis[i].registerForOn(this, EVENT_ICC_STATUS_CHANGED, index);
  5823. @@ -142,12 +191,30 @@ public class UiccController extends Handler {
  5824. mCis[i].registerForIccStatusChanged(this, EVENT_ICC_STATUS_CHANGED, index);
  5825. // TODO remove this once modem correctly notifies the unsols
  5826. mCis[i].registerForNotAvailable(this, EVENT_RADIO_UNAVAILABLE, index);
  5827. +
  5828. + mCis[i].registerForVirtualSimOn(this, EVENT_VIRTUAL_SIM_ON, index);
  5829. + mCis[i].registerForVirtualSimOff(this, EVENT_VIRTUAL_SIM_OFF, index);
  5830. + mCis[i].registerForSimMissing(this, EVENT_SIM_MISSING, index);
  5831. + mCis[i].registerForSimRecovery(this, EVENT_SIM_RECOVERY, index);
  5832. + mCis[i].registerForSimPlugOut(this, EVENT_SIM_PLUG_OUT, index);
  5833. + mCis[i].registerForSimPlugIn(this, EVENT_SIM_PLUG_IN, index);
  5834. + mCis[i].registerForCommonSlotNoChanged(this, EVENT_COMMON_SLOT_NO_CHANGED, index);
  5835. + mCis[i].registerForSessionChanged(this, EVENT_APPLICATION_SESSION_CHANGED, index);
  5836. +
  5837. if (mOEMHookSimRefresh) {
  5838. mCis[i].registerForSimRefreshEvent(this, EVENT_REFRESH_OEM, index);
  5839. } else {
  5840. mCis[i].registerForIccRefresh(this, EVENT_REFRESH, index);
  5841. }
  5842. }
  5843. +
  5844. + IntentFilter filter = new IntentFilter();
  5845. + /* TODO: Wait for SIM Info migration done
  5846. + filter.addAction(TelephonyIntents.ACTION_SIM_INFO_UPDATE);
  5847. + */
  5848. + filter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED);
  5849. + filter.addAction(ACTION_RESET_MODEM);
  5850. + mContext.registerReceiver(mIntentReceiver, filter);
  5851. }
  5852.  
  5853. public static UiccController getInstance() {
  5854. @@ -239,6 +306,23 @@ public class UiccController extends Handler {
  5855. }
  5856. }
  5857.  
  5858. + //Notifies when card status changes
  5859. + public void registerForIccRecovery(Handler h, int what, Object obj) {
  5860. + synchronized (mLock) {
  5861. + Registrant r = new Registrant(h, what, obj);
  5862. + mRecoveryRegistrants.add(r);
  5863. + //Notify registrant right after registering, so that it will get the latest ICC status,
  5864. + //otherwise which may not happen until there is an actual change in ICC status.
  5865. + r.notifyRegistrant();
  5866. + }
  5867. + }
  5868. +
  5869. + public void unregisterForIccRecovery(Handler h) {
  5870. + synchronized (mLock) {
  5871. + mRecoveryRegistrants.remove(h);
  5872. + }
  5873. + }
  5874. +
  5875. @Override
  5876. public void handleMessage (Message msg) {
  5877. synchronized (mLock) {
  5878. @@ -259,6 +343,38 @@ public class UiccController extends Handler {
  5879. AsyncResult ar = (AsyncResult)msg.obj;
  5880. onGetIccCardStatusDone(ar, index);
  5881. break;
  5882. + case EVENT_REPOLL_SML_STATE:
  5883. + if (DBG) log("Received EVENT_REPOLL_SML_STATE");
  5884. + ar = (AsyncResult) msg.obj;
  5885. + boolean needIntent = msg.arg1 == SML_FEATURE_NEED_BROADCAST_INTENT ? true : false;
  5886. +
  5887. + //Update Uicc Card status.
  5888. + onGetIccCardStatusDone(ar, index, false);
  5889. +
  5890. + // If we still in Network lock, broadcast intent if caller need this intent.
  5891. + if (mUiccCards[index] != null && needIntent == true) {
  5892. + UiccCardApplication app = mUiccCards[index].getApplication(APP_FAM_3GPP);
  5893. + if (app == null) {
  5894. + if (DBG) log("UiccCardApplication = null");
  5895. + break;
  5896. + }
  5897. + if (app.getState() == AppState.APPSTATE_SUBSCRIPTION_PERSO) {
  5898. + Intent lockIntent = new Intent();
  5899. + if (null == lockIntent) {
  5900. + if (DBG) log("New intent failed");
  5901. + return;
  5902. + }
  5903. + if (DBG) log("Broadcast ACTION_UNLOCK_SIM_LOCK");
  5904. + lockIntent.setAction(TelephonyIntents.ACTION_UNLOCK_SIM_LOCK);
  5905. + lockIntent.putExtra(IccCardConstants.INTENT_KEY_ICC_STATE,
  5906. + IccCardConstants.INTENT_VALUE_ICC_LOCKED);
  5907. + lockIntent.putExtra(IccCardConstants.INTENT_KEY_LOCKED_REASON,
  5908. + parsePersoType(app.getPersoSubState()));
  5909. + SubscriptionManager.putPhoneIdAndSubIdExtra(lockIntent, index);
  5910. + mContext.sendBroadcast(lockIntent);
  5911. + }
  5912. + }
  5913. + break;
  5914. case EVENT_RADIO_UNAVAILABLE:
  5915. if (DBG) log("EVENT_RADIO_UNAVAILABLE, dispose card");
  5916. if (mUiccCards[index] != null) {
  5917. @@ -267,6 +383,90 @@ public class UiccController extends Handler {
  5918. mUiccCards[index] = null;
  5919. mIccChangedRegistrants.notifyRegistrants(new AsyncResult(null, index, null));
  5920. break;
  5921. + case EVENT_TURN_ON_ISIM_APPLICATION_DONE:
  5922. + if (DBG) log("Received EVENT_TURN_ON_ISIM_APPLICATION_DONE");
  5923. + ar = (AsyncResult) msg.obj;
  5924. + if (ar.exception != null) {
  5925. + Rlog.e(LOG_TAG, "[SIM " + index + "] Error turn on ISIM. ", ar.exception);
  5926. + return;
  5927. + }
  5928. +
  5929. + //Response format: <Application ID>, <Session ID>
  5930. + int[] ints = (int[]) ar.result;
  5931. + if (DBG) log("Application ID = " + ints[0] + "Session ID = " + ints[1]);
  5932. +
  5933. + mImsSessionId[index] = ints[1];
  5934. + mCis[index].getIccApplicationStatus(mImsSessionId[index],
  5935. + obtainMessage(EVENT_GET_ICC_APPLICATION_STATUS, index));
  5936. + break;
  5937. +
  5938. + case EVENT_GET_ICC_APPLICATION_STATUS:
  5939. + if (DBG) log("Received EVENT_GET_ICC_APPLICATION_STATUS");
  5940. + ar = (AsyncResult) msg.obj;
  5941. + onGetIccApplicationStatusDone(ar, index);
  5942. + break;
  5943. +
  5944. + case EVENT_APPLICATION_SESSION_CHANGED:
  5945. + if (DBG) log("Received EVENT_APPLICATION_SESSION_CHANGED");
  5946. + ar = (AsyncResult) msg.obj;
  5947. +
  5948. + //Response format: <Application ID>, <Session ID>
  5949. + int[] result = (int[]) ar.result;
  5950. + // FIXME: application id and array index? only support one application now.
  5951. + if (DBG) log("Application = " + result[0] + ", Session = " + result[1]);
  5952. + mImsSessionId[index] = result[1];
  5953. + break;
  5954. + case EVENT_VIRTUAL_SIM_ON:
  5955. + mCis[index].getIccCardStatus(obtainMessage(EVENT_GET_ICC_STATUS_DONE, index));
  5956. + // setNotificationVirtual(index, EVENT_VIRTUAL_SIM_ON);
  5957. + SharedPreferences shOn = mContext.getSharedPreferences("AutoAnswer", 1);
  5958. + SharedPreferences.Editor editorOn = shOn.edit();
  5959. + editorOn.putBoolean("flag", true);
  5960. + editorOn.commit();
  5961. + break;
  5962. + case EVENT_VIRTUAL_SIM_OFF:
  5963. + if (DBG) log("handleMessage (EVENT_VIRTUAL_SIM_OFF)");
  5964. + mCis[index].getIccCardStatus(obtainMessage(EVENT_GET_ICC_STATUS_DONE, index));
  5965. + // removeNotificationVirtual(index, EVENT_VIRTUAL_SIM_ON);
  5966. + //setNotification(index, EVENT_SIM_MISSING);
  5967. + SharedPreferences shOff = mContext.getSharedPreferences("AutoAnswer", 1);
  5968. + SharedPreferences.Editor editorOff = shOff.edit();
  5969. + editorOff.putBoolean("flag", false);
  5970. + editorOff.commit();
  5971. + break;
  5972. + case EVENT_SIM_RECOVERY:
  5973. + if (DBG) log("handleMessage (EVENT_SIM_RECOVERY)");
  5974. + mCis[index].getIccCardStatus(obtainMessage(EVENT_GET_ICC_STATUS_DONE_FOR_SIM_RECOVERY, index));
  5975. + mRecoveryRegistrants.notifyRegistrants(new AsyncResult(null, index, null));
  5976. + //disableSimMissingNotification(index);
  5977. +
  5978. + //ALPS01209124
  5979. + Intent intent = new Intent();
  5980. + intent.setAction(TelephonyIntents.ACTION_SIM_RECOVERY_DONE);
  5981. + mContext.sendBroadcast(intent);
  5982. + break;
  5983. + case EVENT_SIM_MISSING:
  5984. + if (DBG) log("handleMessage (EVENT_SIM_MISSING)");
  5985. + //setNotification(index, EVENT_SIM_MISSING);
  5986. + mCis[index].getIccCardStatus(obtainMessage(EVENT_GET_ICC_STATUS_DONE_FOR_SIM_MISSING, index));
  5987. + break;
  5988. + case EVENT_GET_ICC_STATUS_DONE_FOR_SIM_MISSING:
  5989. + if (DBG) log("Received EVENT_GET_ICC_STATUS_DONE_FOR_SIM_MISSING");
  5990. + ar = (AsyncResult) msg.obj;
  5991. + onGetIccCardStatusDone(ar, index, false);
  5992. + case EVENT_GET_ICC_STATUS_DONE_FOR_SIM_RECOVERY:
  5993. + if (DBG) log("Received EVENT_GET_ICC_STATUS_DONE_FOR_SIM_RECOVERY");
  5994. + ar = (AsyncResult) msg.obj;
  5995. + onGetIccCardStatusDone(ar, index, false);
  5996. + break;
  5997. + case EVENT_COMMON_SLOT_NO_CHANGED:
  5998. + if (DBG) log("handleMessage (EVENT_COMMON_SLOT_NO_CHANGED)");
  5999. + Intent intentNoChanged = new Intent(TelephonyIntents.ACTION_COMMON_SLOT_NO_CHANGED);
  6000. + int slotId = index.intValue();
  6001. + SubscriptionManager.putPhoneIdAndSubIdExtra(intentNoChanged, slotId);
  6002. + log("Broadcasting intent ACTION_COMMON_SLOT_NO_CHANGED for mSlotId : " + slotId);
  6003. + mContext.sendBroadcast(intentNoChanged);
  6004. + break;
  6005. case EVENT_REFRESH:
  6006. ar = (AsyncResult)msg.obj;
  6007. if (DBG) log("Sim REFRESH received");
  6008. @@ -437,4 +637,223 @@ public class UiccController extends Handler {
  6009. pw.println(" " + mCardLogs.get(i));
  6010. }
  6011. }
  6012. +
  6013. + // MTK
  6014. + private synchronized void onGetIccCardStatusDone(AsyncResult ar, Integer index, boolean isUpdate) {
  6015. + if (ar.exception != null) {
  6016. + Rlog.e(LOG_TAG, "Error getting ICC status. "
  6017. + + "RIL_REQUEST_GET_ICC_STATUS should "
  6018. + + "never return an error", ar.exception);
  6019. + return;
  6020. + }
  6021. + if (!isValidCardIndex(index)) {
  6022. + Rlog.e(LOG_TAG, "onGetIccCardStatusDone: invalid index : " + index);
  6023. + return;
  6024. + }
  6025. + if (DBG) log("onGetIccCardStatusDone, index " + index + "isUpdateSiminfo " + isUpdate);
  6026. +
  6027. + IccCardStatus status = (IccCardStatus) ar.result;
  6028. +
  6029. + //if (status.mCardState == IccCardStatus.CardState.CARDSTATE_PRESENT) {
  6030. + // if (DBG) log("onGetIccCardStatusDone, disableSimMissingNotification because card is present");
  6031. + // disableSimMissingNotification(index);
  6032. + //}
  6033. +
  6034. + if (mUiccCards[index] == null) {
  6035. + //Create new card
  6036. + mUiccCards[index] = new UiccCard(mContext, mCis[index], status, index, isUpdate);
  6037. +
  6038. +/*
  6039. + // Update the UiccCard in base class, so that if someone calls
  6040. + // UiccManager.getUiccCard(), it will return the default card.
  6041. + if (index == PhoneConstants.DEFAULT_CARD_INDEX) {
  6042. + mUiccCard = mUiccCards[index];
  6043. + }
  6044. +*/
  6045. + } else {
  6046. + //Update already existing card
  6047. + mUiccCards[index].update(mContext, mCis[index] , status, isUpdate);
  6048. + }
  6049. +
  6050. + if (DBG) log("Notifying IccChangedRegistrants");
  6051. + // TODO: Think if it is possible to pass isUpdate
  6052. + if (!SystemProperties.get(COMMON_SLOT_PROPERTY).equals("1")) {
  6053. + mIccChangedRegistrants.notifyRegistrants(new AsyncResult(null, index, null));
  6054. + } else {
  6055. + Bundle result = new Bundle();
  6056. + result.putInt("Index", index.intValue());
  6057. + result.putBoolean("ForceUpdate", isUpdate);
  6058. +
  6059. + mIccChangedRegistrants.notifyRegistrants(new AsyncResult(null, result, null));
  6060. + }
  6061. + }
  6062. +
  6063. + private final BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
  6064. + public void onReceive(Context context, Intent intent) {
  6065. + if (intent == null) return;
  6066. + String action = intent.getAction();
  6067. + log("mIntentReceiver Receive action " + action);
  6068. +
  6069. + if (TelephonyIntents.ACTION_SIM_STATE_CHANGED.equals(intent.getAction())) {
  6070. + log(intent.toString() + intent.getStringExtra(IccCardConstants.INTENT_KEY_ICC_STATE));
  6071. + String stateExtra = intent.getStringExtra(IccCardConstants.INTENT_KEY_ICC_STATE);
  6072. + int slot = intent.getIntExtra(PhoneConstants.SLOT_KEY, PhoneConstants.SIM_ID_1);
  6073. + log("mIntentReceiver ACTION_SIM_STATE_CHANGED slot " + slot + " ,state " + stateExtra);
  6074. +
  6075. + if (slot >= TelephonyManager.getDefault().getPhoneCount()) {
  6076. + Rlog.e(LOG_TAG, "BroadcastReceiver SIM State changed slot is invalid");
  6077. + return;
  6078. + }
  6079. +
  6080. + String iccType = ((getUiccCard(slot) != null) ? getUiccCard(slot).getIccCardType() : "");
  6081. +
  6082. + if (IccCardConstants.INTENT_VALUE_ICC_READY.equals(stateExtra)
  6083. + && "USIM".equals(iccType)) {
  6084. + mCis[slot].openIccApplication(0, obtainMessage(EVENT_TURN_ON_ISIM_APPLICATION_DONE, slot));
  6085. + }
  6086. + } else if (action.equals(ACTION_RESET_MODEM)) {
  6087. + int simIdFor3G = SystemProperties.getInt(PROPERTY_3G_SWITCH, 1) - 1;
  6088. + int slotId = intent.getIntExtra("SLOT_ID", 0);
  6089. + if (slotId < 0 || slotId >= mCis.length) {
  6090. + log("Receive ACTION_RESET_MODEM: invalid slot id." + slotId);
  6091. + return;
  6092. + }
  6093. + log("mIntentReceiver Receive ACTION_RESET_MODEM: " + slotId);
  6094. + if (simIdFor3G == slotId) {
  6095. + log("phone " + simIdFor3G + " will reset modem");
  6096. + mCis[slotId].resetRadio(null);
  6097. + }
  6098. + } /* else if (TelephonyIntents.ACTION_SIM_INFO_UPDATE.equals(action)) {
  6099. + //ALPS00776430: Since EF_MSISDN can not be read/wrtie without verify PIN.
  6100. + //We need to clear it or update it to avoid user to get the cached data before.
  6101. + new Thread() {
  6102. + @Override
  6103. + public void run() {
  6104. + SIMInfo simInfo = SIMInfo.getSIMInfoBySlot(mContext, mSimId);
  6105. + if (simInfo!= null && mClearMsisdn == false) {
  6106. + mClearMsisdn = true;
  6107. + log("Initial sim info.");
  6108. + IccRecords iccRecord = getIccRecords(APP_FAM_3GPP);
  6109. + if(iccRecord != null) {
  6110. + SIMInfo.setNumber(mContext, iccRecord.getMsisdnNumber(), simInfo.mSimId);
  6111. + } else {
  6112. + SIMInfo.setNumber(mContext, "", simInfo.mSimId);
  6113. + }
  6114. + Intent intent = new Intent(TelephonyIntents.ACTION_SIM_INFO_UPDATE);
  6115. + ActivityManagerNative.broadcastStickyIntent(intent, READ_PHONE_STATE, UserHandle.USER_ALL);
  6116. + }
  6117. + }
  6118. + }.start();
  6119. + } */
  6120. + }
  6121. + };
  6122. +
  6123. + private synchronized void onGetIccApplicationStatusDone(AsyncResult ar, Integer index) {
  6124. + if (ar.exception != null) {
  6125. + Rlog.e(LOG_TAG, "Error getting ICC status. "
  6126. + + "RIL_REQUEST_GET_ICC_APPLICATION_STATUS should "
  6127. + + "never return an error", ar.exception);
  6128. + return;
  6129. + }
  6130. + if (!isValidCardIndex(index)) {
  6131. + Rlog.e(LOG_TAG, "onGetIccApplicationStatusDone: invalid index : " + index);
  6132. + return;
  6133. + }
  6134. + if (DBG) log("onGetIccApplicationStatusDone, index " + index);
  6135. +
  6136. + IccCardStatus status = (IccCardStatus) ar.result;
  6137. +
  6138. + if (mUiccCards[index] == null) {
  6139. + //Create new card
  6140. + mUiccCards[index] = new UiccCard(mContext, mCis[index], status, index);
  6141. +
  6142. +/*
  6143. + // Update the UiccCard in base class, so that if someone calls
  6144. + // UiccManager.getUiccCard(), it will return the default card.
  6145. + if (index == PhoneConstants.DEFAULT_CARD_INDEX) {
  6146. + mUiccCard = mUiccCards[index];
  6147. + }
  6148. +*/
  6149. + } else {
  6150. + //Update already existing card
  6151. + mUiccCards[index].update(mContext, mCis[index] , status);
  6152. + }
  6153. +
  6154. + if (DBG) log("Notifying mApplicationChangedRegistrants");
  6155. + mApplicationChangedRegistrants.notifyRegistrants();
  6156. + }
  6157. +
  6158. + private int mBtSlotId = -1;
  6159. +
  6160. + /**
  6161. + * Get BT connected sim id.
  6162. + *
  6163. + * @internal
  6164. + */
  6165. + public int getBtConnectedSimId() {
  6166. + if (DBG) log("getBtConnectedSimId, slot " + mBtSlotId);
  6167. + return mBtSlotId;
  6168. + }
  6169. +
  6170. + /**
  6171. + * Set BT connected sim id.
  6172. + *
  6173. + * @internal
  6174. + */
  6175. + public void setBtConnectedSimId(int simId) {
  6176. + mBtSlotId = simId;
  6177. + if (DBG) log("setBtConnectedSimId, slot " + mBtSlotId);
  6178. + }
  6179. +
  6180. + /**
  6181. + * Parse network lock reason string.
  6182. + *
  6183. + * @param state network lock type
  6184. + * @return network lock string
  6185. + *
  6186. + */
  6187. + private String parsePersoType(PersoSubState state) {
  6188. + if (DBG) log("parsePersoType, state = " + state);
  6189. + switch (state) {
  6190. + case PERSOSUBSTATE_SIM_NETWORK:
  6191. + return IccCardConstants.INTENT_VALUE_LOCKED_NETWORK;
  6192. + case PERSOSUBSTATE_SIM_NETWORK_SUBSET:
  6193. + return IccCardConstants.INTENT_VALUE_LOCKED_NETWORK_SUBSET;
  6194. + case PERSOSUBSTATE_SIM_CORPORATE:
  6195. + return IccCardConstants.INTENT_VALUE_LOCKED_CORPORATE;
  6196. + case PERSOSUBSTATE_SIM_SERVICE_PROVIDER:
  6197. + return IccCardConstants.INTENT_VALUE_LOCKED_SERVICE_PROVIDER;
  6198. + case PERSOSUBSTATE_SIM_SIM:
  6199. + return IccCardConstants.INTENT_VALUE_LOCKED_SIM;
  6200. + default:
  6201. + break;
  6202. + }
  6203. + return IccCardConstants.INTENT_VALUE_ICC_UNKNOWN;
  6204. + }
  6205. +
  6206. + //Modem SML change feature.
  6207. + public void repollIccStateForModemSmlChangeFeatrue(int slotId, boolean needIntent) {
  6208. + if (DBG) log("repollIccStateForModemSmlChangeFeatrue, needIntent = " + needIntent);
  6209. + int arg1 = needIntent == true ? SML_FEATURE_NEED_BROADCAST_INTENT : SML_FEATURE_NO_NEED_BROADCAST_INTENT;
  6210. + //Use arg1 to determine the intent is needed or not
  6211. + //Use object to indicated slotId
  6212. + mCis[slotId].getIccCardStatus(obtainMessage(EVENT_REPOLL_SML_STATE, arg1, 0, slotId));
  6213. + }
  6214. +
  6215. + //Notifies when application status changes
  6216. + public void registerForApplicationChanged(Handler h, int what, Object obj) {
  6217. + synchronized (mLock) {
  6218. + Registrant r = new Registrant(h, what, obj);
  6219. + mApplicationChangedRegistrants.add(r);
  6220. + //Notify registrant right after registering, so that it will get the latest application status,
  6221. + //otherwise which may not happen until there is an actual change in application status.
  6222. + r.notifyRegistrant();
  6223. + }
  6224. + }
  6225. +
  6226. + public void unregisterForApplicationChanged(Handler h) {
  6227. + synchronized (mLock) {
  6228. + mApplicationChangedRegistrants.remove(h);
  6229. + }
  6230. + }
  6231. }
  6232. diff --git a/src/java/com/android/internal/telephony/uicc/UsimFileHandler.java b/src/java/com/android/internal/telephony/uicc/UsimFileHandler.java
  6233. index 612d55e..426814d 100644
  6234. --- a/src/java/com/android/internal/telephony/uicc/UsimFileHandler.java
  6235. +++ b/src/java/com/android/internal/telephony/uicc/UsimFileHandler.java
  6236. @@ -35,7 +35,10 @@ public final class UsimFileHandler extends IccFileHandler implements IccConstant
  6237. @Override
  6238. protected String getEFPath(int efid) {
  6239. switch(efid) {
  6240. + case EF_ICCID:
  6241. + return null;
  6242. case EF_SMS:
  6243. + case EF_SMSP: // [ALPS01206315] Support EF_SMSP
  6244. case EF_EXT6:
  6245. case EF_EXT5:
  6246. case EF_MWIS:
  6247. @@ -60,9 +63,13 @@ public final class UsimFileHandler extends IccFileHandler implements IccConstant
  6248. case EF_CSP_CPHS:
  6249. case EF_GID1:
  6250. case EF_LI:
  6251. + case EF_ECC:
  6252. case EF_PLMNWACT:
  6253. return MF_SIM + DF_ADF;
  6254.  
  6255. + case EF_PSISMSC:
  6256. + return /*MF_SIM +*/ DF_TELECOM;
  6257. +
  6258. case EF_PBR:
  6259. // we only support global phonebook.
  6260. return MF_SIM + DF_TELECOM + DF_PHONEBOOK;
  6261. diff --git a/src/java/com/mediatek/internal/telephony/EtwsNotification.java b/src/java/com/mediatek/internal/telephony/EtwsNotification.java
  6262. new file mode 100644
  6263. index 0000000..064f7eb
  6264. --- /dev/null
  6265. +++ b/src/java/com/mediatek/internal/telephony/EtwsNotification.java
  6266. @@ -0,0 +1,42 @@
  6267. +package com.mediatek.internal.telephony;
  6268. +
  6269. +import com.android.internal.telephony.IccUtils;
  6270. +
  6271. +public class EtwsNotification {
  6272. + public int warningType;
  6273. + public int messageId;
  6274. + public int serialNumber;
  6275. + public String plmnId;
  6276. + public String securityInfo;
  6277. +
  6278. + public String toString() {
  6279. + return "EtwsNotification: " + warningType + ", " + messageId + ", " + serialNumber
  6280. + + ", " + plmnId + ", " + securityInfo;
  6281. + }
  6282. +
  6283. + public boolean isDuplicatedEtws(EtwsNotification other) {
  6284. + if (this.warningType == other.warningType
  6285. + && this.messageId == other.messageId
  6286. + && this.serialNumber == other.serialNumber
  6287. + && this.plmnId.equals(other.plmnId)) {
  6288. + return true;
  6289. + }
  6290. +
  6291. + return false;
  6292. + }
  6293. +
  6294. + public byte[] getEtwsPdu() {
  6295. + byte[] etwsPdu = new byte[56];
  6296. + byte[] serialNumberBytes = EtwsUtils.intToBytes(serialNumber);
  6297. + System.arraycopy(serialNumberBytes, 2, etwsPdu, 0, 2);
  6298. + byte[] messageIdBytes = EtwsUtils.intToBytes(messageId);
  6299. + System.arraycopy(messageIdBytes, 2, etwsPdu, 2, 2);
  6300. + byte[] warningTypeBytes = EtwsUtils.intToBytes(warningType);
  6301. + System.arraycopy(warningTypeBytes, 2, etwsPdu, 4, 2);
  6302. + if (securityInfo != null) {
  6303. + System.arraycopy(IccUtils.hexStringToBytes(securityInfo), 0, etwsPdu, 6, 50);
  6304. + }
  6305. +
  6306. + return etwsPdu;
  6307. + }
  6308. +}
  6309. \ No newline at end of file
  6310. diff --git a/src/java/com/mediatek/internal/telephony/EtwsUtils.java b/src/java/com/mediatek/internal/telephony/EtwsUtils.java
  6311. new file mode 100644
  6312. index 0000000..bed25a0
  6313. --- /dev/null
  6314. +++ b/src/java/com/mediatek/internal/telephony/EtwsUtils.java
  6315. @@ -0,0 +1,31 @@
  6316. +package com.mediatek.internal.telephony;
  6317. +
  6318. +public class EtwsUtils {
  6319. + public static final int ETWS_PDU_LENGTH = 56;
  6320. +
  6321. + public static byte[] intToBytes(int value) {
  6322. + byte[] ret = new byte[4];
  6323. + for (int i = 0; i < 4; ++i) {
  6324. + ret[3 - i] = (byte) (value & 0xff);
  6325. + value >>= 8;
  6326. + }
  6327. +
  6328. + return ret;
  6329. + }
  6330. +
  6331. + public static int bytesToInt(byte[] values) {
  6332. + if (values == null || values.length == 0 || values.length > 4) {
  6333. + throw new RuntimeException("valid byte array");
  6334. + }
  6335. +
  6336. + int ret = 0;
  6337. + int len = values.length - 1;
  6338. + for (int i = 0; i < len; ++i) {
  6339. + ret |= (values[i] & 0xff);
  6340. + ret <<= 8;
  6341. + }
  6342. + ret |= (values[len] & 0xff);
  6343. +
  6344. + return ret;
  6345. + }
  6346. +}
  6347. \ No newline at end of file
  6348. diff --git a/src/java/com/mediatek/internal/telephony/FemtoCellInfo.aidl b/src/java/com/mediatek/internal/telephony/FemtoCellInfo.aidl
  6349. new file mode 100755
  6350. index 0000000..2ee8f03
  6351. --- /dev/null
  6352. +++ b/src/java/com/mediatek/internal/telephony/FemtoCellInfo.aidl
  6353. @@ -0,0 +1,19 @@
  6354. +/*
  6355. +** Copyright 2007, The Android Open Source Project
  6356. +**
  6357. +** Licensed under the Apache License, Version 2.0 (the "License");
  6358. +** you may not use this file except in compliance with the License.
  6359. +** You may obtain a copy of the License at
  6360. +**
  6361. +** http://www.apache.org/licenses/LICENSE-2.0
  6362. +**
  6363. +** Unless required by applicable law or agreed to in writing, software
  6364. +** distributed under the License is distributed on an "AS IS" BASIS,
  6365. +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  6366. +** See the License for the specific language governing permissions and
  6367. +** limitations under the License.
  6368. +*/
  6369. +
  6370. +package com.mediatek.internal.telephony;
  6371. +
  6372. +parcelable FemtoCellInfo;
  6373. diff --git a/src/java/com/mediatek/internal/telephony/FemtoCellInfo.java b/src/java/com/mediatek/internal/telephony/FemtoCellInfo.java
  6374. new file mode 100755
  6375. index 0000000..173f1f2
  6376. --- /dev/null
  6377. +++ b/src/java/com/mediatek/internal/telephony/FemtoCellInfo.java
  6378. @@ -0,0 +1,154 @@
  6379. +/*
  6380. + * Copyright (C) 2006 The Android Open Source Project
  6381. + *
  6382. + * Licensed under the Apache License, Version 2.0 (the "License");
  6383. + * you may not use this file except in compliance with the License.
  6384. + * You may obtain a copy of the License at
  6385. + *
  6386. + * http://www.apache.org/licenses/LICENSE-2.0
  6387. + *
  6388. + * Unless required by applicable law or agreed to in writing, software
  6389. + * distributed under the License is distributed on an "AS IS" BASIS,
  6390. + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  6391. + * See the License for the specific language governing permissions and
  6392. + * limitations under the License.
  6393. + */
  6394. +package com.mediatek.internal.telephony;
  6395. +
  6396. +import android.os.Parcel;
  6397. +import android.os.Parcelable;
  6398. +
  6399. +/**
  6400. + * {@hide}
  6401. + */
  6402. +public class FemtoCellInfo implements Parcelable {
  6403. + /* This CSG is Not in EFACSGL nor in EFOCSGL */
  6404. + public static final int CSG_ICON_TYPE_NOT_ALLOWED = 0;
  6405. +
  6406. + /* This CSG is in Allowed CSG List (EFACSGL) */
  6407. + public static final int CSG_ICON_TYPE_ALLOWED = 1;
  6408. +
  6409. + /* This CSG is in Operator CSG List (EFOCSGL) */
  6410. + public static final int CSG_ICON_TYPE_OPERATOR = 2;
  6411. +
  6412. + /* This CSG is in Operator CSGs. However, it is unauthorized, meaning that UE's registration has been rejected by cause #25.*/
  6413. + public static final int CSG_ICON_TYPE_OPERATOR_UNAUTHORIZED = 3;
  6414. +
  6415. + private int csgId;
  6416. + private int csgIconType; /* FemtoCellInfo.CSG_ICON_TYPE_xxx */
  6417. + private String homeNodeBName;
  6418. + private String operatorNumeric; /* ex: "46000" */
  6419. + private String operatorAlphaLong; /* ex: "China Mobile" */
  6420. + private int rat = 0; /* ServiceState.RIL_RADIO_TECHNOLOGY_xxx */
  6421. +
  6422. +/**
  6423. + * Get registered CSG Id
  6424. + * @internal
  6425. + */
  6426. + public int getCsgId() {
  6427. + return csgId;
  6428. + }
  6429. +
  6430. +/**
  6431. + * Get registered CSG Icon Type
  6432. + * @internal
  6433. + */
  6434. + public int getCsgIconType() {
  6435. + return csgIconType;
  6436. + }
  6437. +
  6438. +/**
  6439. + * Get Home NodeB Name(if exist)
  6440. + * @internal
  6441. + */
  6442. + public String getHomeNodeBName() {
  6443. + return homeNodeBName;
  6444. + }
  6445. +
  6446. +/**
  6447. + * Get registered CSG Rat information
  6448. + */
  6449. + public int getCsgRat() {
  6450. + return rat;
  6451. + }
  6452. +
  6453. +/**
  6454. + * Get registered operator numeric code
  6455. + */
  6456. + public String getOperatorNumeric() {
  6457. + return operatorNumeric;
  6458. + }
  6459. +
  6460. +/**
  6461. + * Get registered operator alphanumeric long name
  6462. + * @internal
  6463. + */
  6464. + public String getOperatorAlphaLong() {
  6465. + return operatorAlphaLong;
  6466. + }
  6467. +
  6468. + public FemtoCellInfo(int csgId, int csgIconType, String homeNodeBName, String operatorNumeric, String operatorAlphaLong, int rat) {
  6469. + this.csgId = csgId;
  6470. + this.csgIconType = csgIconType;
  6471. + this.homeNodeBName = homeNodeBName;
  6472. + this.operatorNumeric = operatorNumeric;
  6473. + this.operatorAlphaLong = operatorAlphaLong;
  6474. + this.rat = rat;
  6475. + }
  6476. +
  6477. + public String toString() {
  6478. + return "FemtoCellInfo " + csgId
  6479. + + "/" + csgIconType
  6480. + + "/" + homeNodeBName
  6481. + + "/" + operatorNumeric
  6482. + + "/" + operatorAlphaLong
  6483. + + "/" + rat;
  6484. + }
  6485. +
  6486. + /**
  6487. + * Parcelable interface implemented below.
  6488. + * This is a simple effort to make FemtoCellInfo parcelable rather than
  6489. + * trying to make the conventional containing object (AsyncResult),
  6490. + * implement parcelable.
  6491. + */
  6492. +
  6493. + public int describeContents() {
  6494. + return 0;
  6495. + }
  6496. +
  6497. + /**
  6498. + * Implement the Parcelable interface.
  6499. + * Method to serialize a FemtoCellInfo object.
  6500. + */
  6501. + public void writeToParcel(Parcel dest, int flags) {
  6502. + dest.writeInt(csgId);
  6503. + dest.writeInt(csgIconType);
  6504. + dest.writeString(homeNodeBName);
  6505. + dest.writeString(operatorNumeric);
  6506. + dest.writeString(operatorAlphaLong);
  6507. + dest.writeInt(rat);
  6508. + }
  6509. +
  6510. + /**
  6511. + * Implement the Parcelable interface
  6512. + * Method to deserialize a FemtoCellInfo object, or an array thereof.
  6513. + */
  6514. + public static final Creator<FemtoCellInfo> CREATOR =
  6515. + new Creator<FemtoCellInfo>() {
  6516. + public FemtoCellInfo createFromParcel(Parcel in) {
  6517. + FemtoCellInfo femtoCellInfo = new FemtoCellInfo(
  6518. + in.readInt(), /*csgId*/
  6519. + in.readInt(), /*csgIconType*/
  6520. + in.readString(), /*homeNodeBName*/
  6521. + in.readString(), /*operatorNumeric*/
  6522. + in.readString(), /*operatorAlphaLong*/
  6523. + in.readInt()); /*rat*/
  6524. + return femtoCellInfo;
  6525. + }
  6526. +
  6527. + public FemtoCellInfo[] newArray(int size) {
  6528. + return new FemtoCellInfo[size];
  6529. + }
  6530. + };
  6531. +}
  6532. +
  6533. diff --git a/src/java/com/mediatek/internal/telephony/ModemSwitchHandler.java b/src/java/com/mediatek/internal/telephony/ModemSwitchHandler.java
  6534. new file mode 100755
  6535. index 0000000..0f0638d
  6536. --- /dev/null
  6537. +++ b/src/java/com/mediatek/internal/telephony/ModemSwitchHandler.java
  6538. @@ -0,0 +1,244 @@
  6539. +/* Copyright Statement:
  6540. + *
  6541. + * This software/firmware and related documentation ("MediaTek Software") are
  6542. + * protected under relevant copyright laws. The information contained herein
  6543. + * is confidential and proprietary to MediaTek Inc. and/or its licensors.
  6544. + * Without the prior written permission of MediaTek inc. and/or its licensors,
  6545. + * any reproduction, modification, use or disclosure of MediaTek Software,
  6546. + * and information contained herein, in whole or in part, shall be strictly prohibited.
  6547. + *
  6548. + * MediaTek Inc. (C) 2010. All rights reserved.
  6549. + *
  6550. + * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  6551. + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  6552. + * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
  6553. + * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  6554. + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  6555. + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  6556. + * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  6557. + * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  6558. + * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
  6559. + * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
  6560. + * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
  6561. + * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
  6562. + * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  6563. + * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
  6564. + * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  6565. + * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  6566. + * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
  6567. + * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  6568. + *
  6569. + * The following software/firmware and/or related documentation ("MediaTek Software")
  6570. + * have been modified by MediaTek Inc. All revisions are subject to any receiver's
  6571. + * applicable license agreements with MediaTek Inc.
  6572. + */
  6573. +
  6574. +package com.mediatek.internal.telephony;
  6575. +
  6576. +import android.content.Context;
  6577. +import android.content.Intent;
  6578. +import android.os.SystemProperties;
  6579. +import android.telephony.Rlog;
  6580. +
  6581. +import com.android.internal.telephony.CommandsInterface;
  6582. +import com.android.internal.telephony.Phone;
  6583. +import com.android.internal.telephony.PhoneBase;
  6584. +import com.android.internal.telephony.PhoneConstants;
  6585. +import com.android.internal.telephony.PhoneFactory;
  6586. +import com.android.internal.telephony.PhoneProxy;
  6587. +import com.android.internal.telephony.TelephonyIntents;
  6588. +import com.android.internal.telephony.TelephonyProperties;
  6589. +
  6590. +import com.mediatek.internal.telephony.worldphone.WorldPhoneUtil;
  6591. +
  6592. +public class ModemSwitchHandler {
  6593. + private static final String LOG_TAG = "PHONE";
  6594. +
  6595. + /** @internal */
  6596. + public static final int MD_TYPE_UNKNOWN = 0;
  6597. + /** @internal */
  6598. + public static final int MD_TYPE_WG = 3;
  6599. + /** @internal */
  6600. + public static final int MD_TYPE_TG = 4;
  6601. + /** @internal */
  6602. + public static final int MD_TYPE_LWG = 5;
  6603. + /** @internal */
  6604. + public static final int MD_TYPE_LTG = 6;
  6605. + /** @internal */
  6606. + public static final int MD_TYPE_FDD = 100;
  6607. + /** @internal */
  6608. + public static final int MD_TYPE_TDD = 101;
  6609. + private static final int PROJECT_SIM_NUM = WorldPhoneUtil.getProjectSimNum();
  6610. +
  6611. + private static int sCurrentModemType = getActiveModemType();
  6612. + private static Phone[] sProxyPhones = null;
  6613. + private static Phone[] sActivePhones = new Phone[PROJECT_SIM_NUM];
  6614. + private static Context sContext = null;
  6615. + private static CommandsInterface[] sCi = new CommandsInterface[PROJECT_SIM_NUM];
  6616. +
  6617. + public ModemSwitchHandler() {
  6618. + logd("Constructor invoked");
  6619. + logd("Init modem type: " + sCurrentModemType);
  6620. + sProxyPhones = PhoneFactory.getPhones();
  6621. + for (int i = 0; i < PROJECT_SIM_NUM; i++) {
  6622. + sActivePhones[i] = ((PhoneProxy) sProxyPhones[i]).getActivePhone();
  6623. + sCi[i] = ((PhoneBase) sActivePhones[i]).mCi;
  6624. + }
  6625. + if (PhoneFactory.getDefaultPhone() != null) {
  6626. + sContext = PhoneFactory.getDefaultPhone().getContext();
  6627. + } else {
  6628. + logd("DefaultPhone = null");
  6629. + }
  6630. + }
  6631. +
  6632. + /**
  6633. + * Trigger TRM to switch modem type
  6634. + * @param modemType 3 : switch to WG(MD_TYPE_WG)
  6635. + * 4 : switch to TG(MD_TYPE_TG)
  6636. + * 5 : switch to FDD CSFB(MD_TYPE_LWG)
  6637. + * 6 : switch to TDD CSFB(MD_TYPE_LTG)
  6638. + */
  6639. + public static void switchModem(int modemType) {
  6640. + int protocolSim = WorldPhoneUtil.getMajorSim();
  6641. + logd("protocolSim: " + protocolSim);
  6642. + if (protocolSim >= PhoneConstants.SIM_ID_1 && protocolSim <= PhoneConstants.SIM_ID_4) {
  6643. + switchModem(sCi[protocolSim], modemType);
  6644. + } else {
  6645. + switchModem(sCi[PhoneConstants.SIM_ID_1], modemType);
  6646. + }
  6647. + }
  6648. +
  6649. + /**
  6650. + * Trigger TRM to switch modem type with desinated RIL instance
  6651. + * @param modemType 3 : switch to WG(MD_TYPE_WG)
  6652. + * 4 : switch to TG(MD_TYPE_TG)
  6653. + * 5 : switch to FDD CSFB(MD_TYPE_LWG)
  6654. + * 6 : switch to TDD CSFB(MD_TYPE_LTG)
  6655. + */
  6656. + public static void switchModem(CommandsInterface ci, int modemType) {
  6657. + logd("[switchModem]");
  6658. + if (modemType == sCurrentModemType) {
  6659. + if (modemType == MD_TYPE_WG) {
  6660. + logd("Already in WG modem");
  6661. + } else if (modemType == MD_TYPE_TG) {
  6662. + logd("Already in TG modem");
  6663. + } else if (modemType == MD_TYPE_LWG) {
  6664. + logd("Already in FDD CSFB modem");
  6665. + } else if (modemType == MD_TYPE_LTG) {
  6666. + logd("Already in TDD CSFB modem");
  6667. + }
  6668. + return;
  6669. + }
  6670. + if (ci.getRadioState() == CommandsInterface.RadioState.RADIO_UNAVAILABLE) {
  6671. + logd("Radio unavailable, can not switch modem");
  6672. + return;
  6673. + }
  6674. + if (modemType == MD_TYPE_WG) {
  6675. + ci.setTrm(9, null);
  6676. + } else if (modemType == MD_TYPE_TG) {
  6677. + ci.setTrm(10, null);
  6678. + } else if (modemType == MD_TYPE_LWG) {
  6679. + ci.setTrm(11, null);
  6680. + } else if (modemType == MD_TYPE_LTG) {
  6681. + ci.setTrm(12, null);
  6682. + } else {
  6683. + logd("Invalid modem type:" + modemType);
  6684. + return;
  6685. + }
  6686. + // Update sCurrentModemType variable & set ril.active.md system property
  6687. + setActiveModemType(modemType);
  6688. +
  6689. + // Broadcast modem switch notification
  6690. + logd("Broadcast intent ACTION_MD_TYPE_CHANGE");
  6691. + Intent intent = new Intent(TelephonyIntents.ACTION_MD_TYPE_CHANGE);
  6692. + intent.putExtra(TelephonyIntents.EXTRA_MD_TYPE, modemType);
  6693. + sContext.sendBroadcast(intent);
  6694. + }
  6695. +
  6696. + /**
  6697. + * Trigger CCCI to reload modem bin
  6698. + * @param modemType 3 : reload WG(MD_TYPE_WG)
  6699. + * 4 : reload TG(MD_TYPE_TG)
  6700. + * 5 : reload FDD CSFB(MD_TYPE_LWG)
  6701. + * 6 : reload TDD CSFB(MD_TYPE_LTG)
  6702. + */
  6703. + public static void reloadModem(int modemType) {
  6704. + int majorSim = WorldPhoneUtil.getMajorSim();
  6705. + if (majorSim >= PhoneConstants.SIM_ID_1 && majorSim <= PhoneConstants.SIM_ID_4) {
  6706. + reloadModem(sCi[majorSim], modemType);
  6707. + } else {
  6708. + reloadModem(sCi[PhoneConstants.SIM_ID_1], modemType);
  6709. + }
  6710. + }
  6711. +
  6712. + /**
  6713. + * Trigger CCCI to reload modem bin with desinated RIL instance
  6714. + * @param modemType 3 : reload WG(MD_TYPE_WG)
  6715. + * 4 : reload TG(MD_TYPE_TG)
  6716. + * 5 : reload FDD CSFB(MD_TYPE_LWG)
  6717. + * 6 : reload TDD CSFB(MD_TYPE_LTG)
  6718. + */
  6719. + public static void reloadModem(CommandsInterface ci, int modemType) {
  6720. + logd("[reloadModem]");
  6721. + if (ci.getRadioState() == CommandsInterface.RadioState.RADIO_UNAVAILABLE) {
  6722. + logd("Radio unavailable, can not reload modem");
  6723. + return;
  6724. + }
  6725. + if (modemType == MD_TYPE_WG) {
  6726. + ci.setTrm(14, null);
  6727. + } else if (modemType == MD_TYPE_TG) {
  6728. + ci.setTrm(15, null);
  6729. + } else if (modemType == MD_TYPE_LWG) {
  6730. + ci.setTrm(16, null);
  6731. + } else if (modemType == MD_TYPE_LTG) {
  6732. + ci.setTrm(17, null);
  6733. + } else {
  6734. + logd("Invalid modem type:" + modemType);
  6735. + }
  6736. + }
  6737. +
  6738. + /**
  6739. + * Returns current modem type
  6740. + * @internal
  6741. + * @return 0 : modem type is unknown
  6742. + * 3 : switch to WG(MD_TYPE_WG)
  6743. + * 4 : switch to TG(MD_TYPE_TG)
  6744. + * 5 : switch to FDD CSFB(MD_TYPE_LWG)
  6745. + * 6 : switch to TDD CSFB(MD_TYPE_LTG)
  6746. + */
  6747. + public static int getActiveModemType() {
  6748. + sCurrentModemType = Integer.valueOf(
  6749. + SystemProperties.get(TelephonyProperties.PROPERTY_ACTIVE_MD, Integer.toString(MD_TYPE_UNKNOWN)));
  6750. +
  6751. + return sCurrentModemType;
  6752. + }
  6753. +
  6754. + public static void setActiveModemType(int modemType) {
  6755. + SystemProperties.set(TelephonyProperties.PROPERTY_ACTIVE_MD, Integer.toString(modemType));
  6756. + sCurrentModemType = modemType;
  6757. + logd("[setActiveModemType] " + modemToString(sCurrentModemType));
  6758. + }
  6759. +
  6760. + public static String modemToString(int modemType) {
  6761. + String modemString;
  6762. + if (modemType == MD_TYPE_WG) {
  6763. + modemString = "WG";
  6764. + } else if (modemType == MD_TYPE_TG) {
  6765. + modemString = "TG";
  6766. + } else if (modemType == MD_TYPE_LWG) {
  6767. + modemString = "FDD CSFB";
  6768. + } else if (modemType == MD_TYPE_LTG) {
  6769. + modemString = "TDD CSFB";
  6770. + } else if (modemType == MD_TYPE_UNKNOWN) {
  6771. + modemString = "UNKNOWN";
  6772. + } else {
  6773. + modemString = "Invalid modem type";
  6774. + }
  6775. +
  6776. + return modemString;
  6777. + }
  6778. +
  6779. + private static void logd(String msg) {
  6780. + Rlog.d(LOG_TAG, "[MSH]" + msg);
  6781. + }
  6782. +}
  6783. diff --git a/src/java/com/mediatek/internal/telephony/NetworkInfoWithAcT.aidl b/src/java/com/mediatek/internal/telephony/NetworkInfoWithAcT.aidl
  6784. new file mode 100755
  6785. index 0000000..b604df8
  6786. --- /dev/null
  6787. +++ b/src/java/com/mediatek/internal/telephony/NetworkInfoWithAcT.aidl
  6788. @@ -0,0 +1,57 @@
  6789. +/* Copyright Statement:
  6790. + *
  6791. + * This software/firmware and related documentation ("MediaTek Software") are
  6792. + * protected under relevant copyright laws. The information contained herein
  6793. + * is confidential and proprietary to MediaTek Inc. and/or its licensors.
  6794. + * Without the prior written permission of MediaTek inc. and/or its licensors,
  6795. + * any reproduction, modification, use or disclosure of MediaTek Software,
  6796. + * and information contained herein, in whole or in part, shall be strictly prohibited.
  6797. + *
  6798. + * MediaTek Inc. (C) 2010. All rights reserved.
  6799. + *
  6800. + * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  6801. + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  6802. + * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
  6803. + * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  6804. + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  6805. + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  6806. + * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  6807. + * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  6808. + * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
  6809. + * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
  6810. + * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
  6811. + * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
  6812. + * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  6813. + * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
  6814. + * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  6815. + * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  6816. + * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
  6817. + * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  6818. + */
  6819. +
  6820. +/*
  6821. + * Copyright (C) 2008 The Android Open Source Project
  6822. + *
  6823. + * Licensed under the Apache License, Version 2.0 (the "License");
  6824. + * you may not use this file except in compliance with the License.
  6825. + * You may obtain a copy of the License at
  6826. + *
  6827. + * http://www.apache.org/licenses/LICENSE-2.0
  6828. + *
  6829. + * Unless required by applicable law or agreed to in writing, software
  6830. + * distributed under the License is distributed on an "AS IS" BASIS,
  6831. + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  6832. + * See the License for the specific language governing permissions and
  6833. + * limitations under the License.
  6834. + */
  6835. +
  6836. +package com.mediatek.internal.telephony;
  6837. +
  6838. +/**
  6839. + * Used to indicate that the NetworkInfo object is parcelable to aidl.
  6840. + * This is a simple effort to make NetworkInfo parcelable rather than
  6841. + * trying to make the conventional containing object (AsyncResult),
  6842. + * implement parcelable. This functionality is needed for the
  6843. + * NetworkQueryService to fix 1128695
  6844. + */
  6845. +parcelable NetworkInfoWithAcT;
  6846. diff --git a/src/java/com/mediatek/internal/telephony/NetworkInfoWithAcT.java b/src/java/com/mediatek/internal/telephony/NetworkInfoWithAcT.java
  6847. new file mode 100755
  6848. index 0000000..12d848e
  6849. --- /dev/null
  6850. +++ b/src/java/com/mediatek/internal/telephony/NetworkInfoWithAcT.java
  6851. @@ -0,0 +1,201 @@
  6852. +/* Copyright Statement:
  6853. + *
  6854. + * This software/firmware and related documentation ("MediaTek Software") are
  6855. + * protected under relevant copyright laws. The information contained herein
  6856. + * is confidential and proprietary to MediaTek Inc. and/or its licensors.
  6857. + * Without the prior written permission of MediaTek inc. and/or its licensors,
  6858. + * any reproduction, modification, use or disclosure of MediaTek Software,
  6859. + * and information contained herein, in whole or in part, shall be strictly prohibited.
  6860. + *
  6861. + * MediaTek Inc. (C) 2010. All rights reserved.
  6862. + *
  6863. + * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  6864. + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  6865. + * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
  6866. + * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  6867. + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  6868. + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  6869. + * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  6870. + * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  6871. + * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
  6872. + * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
  6873. + * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
  6874. + * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
  6875. + * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  6876. + * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
  6877. + * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  6878. + * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  6879. + * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
  6880. + * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  6881. + */
  6882. +
  6883. +/*
  6884. + * Copyright (C) 2006 The Android Open Source Project
  6885. + *
  6886. + * Licensed under the Apache License, Version 2.0 (the "License");
  6887. + * you may not use this file except in compliance with the License.
  6888. + * You may obtain a copy of the License at
  6889. + *
  6890. + * http://www.apache.org/licenses/LICENSE-2.0
  6891. + *
  6892. + * Unless required by applicable law or agreed to in writing, software
  6893. + * distributed under the License is distributed on an "AS IS" BASIS,
  6894. + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  6895. + * See the License for the specific language governing permissions and
  6896. + * limitations under the License.
  6897. + */
  6898. +
  6899. +package com.mediatek.internal.telephony;
  6900. +
  6901. +import android.os.Parcel;
  6902. +import android.os.Parcelable;
  6903. +
  6904. +/**
  6905. + * Entry of preferred network list in UICC card. ex: EF_PLMNSEL
  6906. + * {@hide}
  6907. + * @internal
  6908. + */
  6909. +public class NetworkInfoWithAcT implements Parcelable {
  6910. +
  6911. + String operatorAlphaName;
  6912. + String operatorNumeric;
  6913. +
  6914. + int nAct;
  6915. + int nPriority; // priority is the index of the plmn in the list.
  6916. +
  6917. +
  6918. +/**
  6919. + * Get Operator alpha name ex: Vodafone
  6920. + * @internal
  6921. + */
  6922. + public String
  6923. + getOperatorAlphaName() {
  6924. + return operatorAlphaName;
  6925. + }
  6926. +
  6927. +/**
  6928. + * Get member Operator PLMN ID ex: 53001
  6929. + * @internal
  6930. + */
  6931. + public String
  6932. + getOperatorNumeric() {
  6933. + return operatorNumeric;
  6934. + }
  6935. +
  6936. +/**
  6937. + * Get access techonolgy of the PLMN. It's a bitmap value. <bit3, bit2,bit1,bit0> => < E-UTRAN_Act ,UTRAN_Act,GSM_Compact_Act ,Gsm_Act >
  6938. + * @internal
  6939. + */
  6940. + public int
  6941. + getAccessTechnology() {
  6942. + return nAct;
  6943. + }
  6944. +
  6945. +/**
  6946. + * Get priority, index of the PLMN in the list
  6947. + * @internal
  6948. + */
  6949. + public int
  6950. + getPriority() {
  6951. + return nPriority;
  6952. + }
  6953. +
  6954. +/**
  6955. + * Set Operator alpha name ex: Vodafone
  6956. + *
  6957. + * @internal
  6958. + */
  6959. + public void
  6960. + setOperatorAlphaName(String operatorAlphaName) {
  6961. + this.operatorAlphaName = operatorAlphaName;
  6962. + }
  6963. +
  6964. +/**
  6965. + * Set member Operator PLMN ID ex: 53001
  6966. + * @internal
  6967. + */
  6968. + public void
  6969. + setOperatorNumeric(String operatorNumeric) {
  6970. + this.operatorNumeric = operatorNumeric;
  6971. + }
  6972. +
  6973. +/**
  6974. + * Set access techonolgy of the PLMN. It's a bitmap value. <bit3, bit2,bit1,bit0> => < E-UTRAN_Act ,UTRAN_Act,GSM_Compact_Act ,Gsm_Act >
  6975. + *
  6976. + * @internal
  6977. + */
  6978. + public void
  6979. + setAccessTechnology(int nAct) {
  6980. + this.nAct = nAct;
  6981. + }
  6982. +
  6983. +/**
  6984. + * Set priority, index of the PLMN in the list
  6985. + * @internal
  6986. + */
  6987. + public void
  6988. + setPriority(int nIndex) {
  6989. + this.nPriority = nIndex;
  6990. + }
  6991. +
  6992. + public NetworkInfoWithAcT(String operatorAlphaLong,
  6993. + String operatorNumeric,
  6994. + int nAct,
  6995. + int nPriority) {
  6996. +
  6997. + this.operatorAlphaName = operatorAlphaLong;
  6998. + this.operatorNumeric = operatorNumeric;
  6999. + this.nAct = nAct;
  7000. + this.nPriority = nPriority;
  7001. + }
  7002. +
  7003. + public String toString() {
  7004. + return "NetworkInfoWithAcT " + operatorAlphaName
  7005. + + "/" + operatorNumeric
  7006. + + "/" + nAct
  7007. + + "/" + nPriority;
  7008. + }
  7009. +
  7010. + /**
  7011. + * Parcelable interface implemented below.
  7012. + * This is a simple effort to make NetworkInfo parcelable rather than
  7013. + * trying to make the conventional containing object (AsyncResult),
  7014. + * implement parcelable. This functionality is needed for the
  7015. + * NetworkQueryService to fix 1128695.
  7016. + */
  7017. +
  7018. + public int describeContents() {
  7019. + return 0;
  7020. + }
  7021. +
  7022. + /**
  7023. + * Implement the Parcelable interface.
  7024. + * Method to serialize a NetworkInfo object.
  7025. + */
  7026. + public void writeToParcel(Parcel dest, int flags) {
  7027. + dest.writeString(operatorAlphaName);
  7028. + dest.writeString(operatorNumeric);
  7029. + dest.writeInt(nAct);
  7030. + dest.writeInt(nPriority);
  7031. + }
  7032. +
  7033. + /**
  7034. + * Implement the Parcelable interface
  7035. + * Method to deserialize a NetworkInfo object, or an array thereof.
  7036. + */
  7037. + public static final Creator<NetworkInfoWithAcT> CREATOR =
  7038. + new Creator<NetworkInfoWithAcT>() {
  7039. + public NetworkInfoWithAcT createFromParcel(Parcel in) {
  7040. + NetworkInfoWithAcT netInfoWithAct = new NetworkInfoWithAcT(
  7041. + in.readString(), /*operatorAlphaLong*/
  7042. + in.readString(), /*operatorNumeric*/
  7043. + in.readInt(), /*operatorNumeric*/
  7044. + in.readInt()); /*state*/
  7045. + return netInfoWithAct;
  7046. + }
  7047. +
  7048. + public NetworkInfoWithAcT[] newArray(int size) {
  7049. + return new NetworkInfoWithAcT[size];
  7050. + }
  7051. + };
  7052. +}
  7053. diff --git a/src/java/com/mediatek/internal/telephony/NetworkManager.java b/src/java/com/mediatek/internal/telephony/NetworkManager.java
  7054. new file mode 100755
  7055. index 0000000..7e1d320
  7056. --- /dev/null
  7057. +++ b/src/java/com/mediatek/internal/telephony/NetworkManager.java
  7058. @@ -0,0 +1,101 @@
  7059. +
  7060. +package com.mediatek.internal.telephony;
  7061. +
  7062. +import android.os.Handler;
  7063. +import android.os.Message;
  7064. +import android.util.Log;
  7065. +import android.content.Context;
  7066. +
  7067. +import com.android.internal.telephony.CommandsInterface;
  7068. +
  7069. +public class NetworkManager extends Handler {
  7070. + static final String LOG_TAG = "GSM";
  7071. + private static NetworkManager sNetworkManager;
  7072. + private Context mContext;
  7073. + private CommandsInterface[] mCi;
  7074. + private int mPhoneCount;
  7075. +
  7076. + protected static final int EVENT_GET_AVAILABLE_NW = 1;
  7077. +
  7078. + public static NetworkManager init(Context context, int phoneCount, CommandsInterface[] ci) {
  7079. + synchronized (NetworkManager.class) {
  7080. + if (sNetworkManager == null) {
  7081. + sNetworkManager = new NetworkManager(context, phoneCount, ci);
  7082. + }
  7083. + return sNetworkManager;
  7084. + }
  7085. + }
  7086. +
  7087. + public static NetworkManager getInstance() {
  7088. + return sNetworkManager;
  7089. + }
  7090. +
  7091. + private NetworkManager(Context context , int phoneCount, CommandsInterface[] ci) {
  7092. +
  7093. + log("Initialize NetworkManager under airplane mode phoneCount= " + phoneCount);
  7094. +
  7095. + mContext = context;
  7096. + mCi = ci;
  7097. + mPhoneCount = phoneCount;
  7098. + }
  7099. +
  7100. + /**
  7101. + * To scan all available networks. i.e. PLMN list
  7102. + * @param Message for on complete
  7103. + * @param simId Indicate which sim(slot) to query
  7104. + * @internal
  7105. + */
  7106. + public void getAvailableNetworks(int subId, Message response) {
  7107. + /*
  7108. + int activeSim = -1;
  7109. + for (int i=0; i<PhoneConstants.GEMINI_SIM_NUM;++i) {
  7110. + if (!mGeminiDataMgr.isGprsDetached(i)) {
  7111. + activeSim = i;
  7112. + break;
  7113. + }
  7114. + }
  7115. +
  7116. + Rlog.d(LOG_TAG, "getAvailableNetworksGemini activeSIM="+activeSim);
  7117. +
  7118. + if (activeSim == -1 || activeSim == simId ||
  7119. + PhoneFactory.isDualTalkMode()) {
  7120. + getPhonebyId(simId).getAvailableNetworks(response);
  7121. + } else {
  7122. + PhoneBase phoneBase = getPhoneBase(activeSim);
  7123. + if (phoneBase instanceof GSMPhone) {
  7124. + Rlog.d(LOG_TAG, "activeSim: " + activeSim + ", simId: " + simId);
  7125. + mActiveApnTypes = getActiveApnTypesGemini(activeSim);
  7126. + mGeminiDataMgr.cleanupAllConnection(activeSim);
  7127. + }
  7128. + mGettingAvailableNetwork = true;
  7129. + Message msg = obtainMessage(EVENT_GET_AVAILABLE_NW);
  7130. + msg.arg1 = activeSim;
  7131. + msg.arg2 = simId;
  7132. + msg.obj = response;
  7133. + mGeminiDataMgr.registerForDetached(activeSim, this, EVENT_GPRS_DETACHED, msg);
  7134. + }
  7135. + */
  7136. + return;
  7137. + }
  7138. +
  7139. + @Override
  7140. + public void handleMessage(Message msg) {
  7141. + switch (msg.what) {
  7142. + case EVENT_GET_AVAILABLE_NW:
  7143. + synchronized (this) {
  7144. +
  7145. + }
  7146. + break;
  7147. +
  7148. + default:
  7149. + log("Unhandled message with number: " + msg.what);
  7150. + break;
  7151. + }
  7152. + }
  7153. +
  7154. + private static void log(String s) {
  7155. + // Log.d(LOG_TAG, "[NetworkManager] " + s);
  7156. + }
  7157. +}
  7158. +
  7159. +
  7160. diff --git a/src/java/com/mediatek/internal/telephony/RadioCapabilitySwitchUtil.java b/src/java/com/mediatek/internal/telephony/RadioCapabilitySwitchUtil.java
  7161. new file mode 100755
  7162. index 0000000..76d3f39
  7163. --- /dev/null
  7164. +++ b/src/java/com/mediatek/internal/telephony/RadioCapabilitySwitchUtil.java
  7165. @@ -0,0 +1,310 @@
  7166. +/* Copyright Statement:
  7167. + *
  7168. + * This software/firmware and related documentation ("MediaTek Software") are
  7169. + * protected under relevant copyright laws. The information contained herein is
  7170. + * confidential and proprietary to MediaTek Inc. and/or its licensors. Without
  7171. + * the prior written permission of MediaTek inc. and/or its licensors, any
  7172. + * reproduction, modification, use or disclosure of MediaTek Software, and
  7173. + * information contained herein, in whole or in part, shall be strictly
  7174. + * prohibited.
  7175. + *
  7176. + * MediaTek Inc. (C) 2014. All rights reserved.
  7177. + *
  7178. + * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  7179. + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  7180. + * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
  7181. + * ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
  7182. + * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
  7183. + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  7184. + * NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
  7185. + * RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
  7186. + * INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
  7187. + * TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
  7188. + * RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
  7189. + * OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
  7190. + * SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
  7191. + * RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  7192. + * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
  7193. + * ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
  7194. + * RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
  7195. + * MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
  7196. + * CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  7197. + *
  7198. + * The following software/firmware and/or related documentation ("MediaTek
  7199. + * Software") have been modified by MediaTek Inc. All revisions are subject to
  7200. + * any receiver's applicable license agreements with MediaTek Inc.
  7201. + */
  7202. +
  7203. +package com.mediatek.internal.telephony;
  7204. +
  7205. +import android.os.SystemProperties;
  7206. +
  7207. +import android.telephony.PhoneRatFamily;
  7208. +import android.telephony.SubscriptionManager;
  7209. +import android.telephony.TelephonyManager;
  7210. +import android.util.Log;
  7211. +
  7212. +import com.android.internal.telephony.Phone;
  7213. +import com.android.internal.telephony.PhoneConstants;
  7214. +
  7215. +import java.util.Arrays;
  7216. +
  7217. +/**
  7218. + * Utility for capability switch.
  7219. + *
  7220. + */
  7221. +public class RadioCapabilitySwitchUtil {
  7222. + private static final String LOG_TAG = "GSM";
  7223. +
  7224. + public static final int SIM_OP_INFO_OVERSEA = 0;
  7225. + public static final int SIM_OP_INFO_OP01 = 1;
  7226. + public static final int SIM_OP_INFO_OP02 = 2;
  7227. +
  7228. + public static final int SIM_TYPE_SIM = 0;
  7229. + public static final int SIM_TYPE_USIM = 1;
  7230. + public static final int SIM_TYPE_OTHER = 2;
  7231. +
  7232. + public static final String MAIN_SIM_PROP = "persist.radio.simswitch.iccid";
  7233. + private static final String PROPERTY_ICCID = "ril.iccid.sim";
  7234. + // OP01 SIMs
  7235. + private static final String[] PLMN_TABLE_TYPE1 = {
  7236. + "46000", "46002", "46007", "46008", "46011",
  7237. + // Lab test IMSI
  7238. + "00101", "00211", "00321", "00431", "00541", "00651",
  7239. + "00761", "00871", "00902", "01012", "01122", "01232",
  7240. + "46004", "46602", "50270", "46003"
  7241. + };
  7242. +
  7243. + // non-OP01 SIMs
  7244. + private static final String[] PLMN_TABLE_TYPE3 = {
  7245. + "46001", "46006", "46009", "45407",
  7246. + "46005", "45502"
  7247. + };
  7248. +
  7249. + /**
  7250. + * Update current main protocol ICCID.
  7251. + *
  7252. + * @param mProxyPhones Phone array for all phones
  7253. + */
  7254. + public static void updateIccid(Phone[] mProxyPhones) {
  7255. + for (int i = 0; i < mProxyPhones.length; i++) {
  7256. + if ((mProxyPhones[i].getPhoneRatFamily() & PhoneRatFamily.PHONE_RAT_FAMILY_3G)
  7257. + == PhoneRatFamily.PHONE_RAT_FAMILY_3G) {
  7258. + String currIccId = SystemProperties.get(PROPERTY_ICCID + (i + 1));
  7259. + SystemProperties.set(MAIN_SIM_PROP, currIccId);
  7260. + logd("updateIccid " + currIccId);
  7261. + break;
  7262. + }
  7263. + }
  7264. + }
  7265. +
  7266. + /**
  7267. + * Get all SIMs operator and type.
  7268. + *
  7269. + * @param simOpInfo SIM operator info
  7270. + * @param simType SIM type
  7271. + */
  7272. + public static void getSimInfo(int[] simOpInfo, int[] simType) {
  7273. + String[] strMnc = new String[simOpInfo.length];
  7274. + String[] strSimType = new String[simOpInfo.length];
  7275. + String propStr;
  7276. +
  7277. + for (int i = 0; i < simOpInfo.length; i++) {
  7278. + if (i == 0) {
  7279. + propStr = "gsm.ril.uicctype";
  7280. + } else {
  7281. + propStr = "gsm.ril.uicctype." + (i + 1);
  7282. + }
  7283. + strSimType[i] = SystemProperties.get(propStr, "");
  7284. + if (strSimType[i].equals("SIM")) {
  7285. + simType[i] = RadioCapabilitySwitchUtil.SIM_TYPE_SIM;
  7286. + } else if (strSimType[i].equals("USIM")) {
  7287. + simType[i] = RadioCapabilitySwitchUtil.SIM_TYPE_USIM;
  7288. + } else {
  7289. + simType[i] = RadioCapabilitySwitchUtil.SIM_TYPE_OTHER;
  7290. + }
  7291. + logd("SimType[" + i + "]= " + strSimType[i] + ", simType[" + i + "]=" + simType[i]);
  7292. + final int tmpMnc = TelephonyManager.getTelephonyProperty("gsm.sim.operator.numeric",
  7293. + SubscriptionManager.getSubId(i)[0], -1); // getSubIdUsingPhoneId not implemented
  7294. + strMnc[i] = tmpMnc < 0 ? "" : Integer.toString(tmpMnc);
  7295. + logd("strMnc[" + i + "] from operator.numeric:" + strMnc[i]);
  7296. + if (strMnc[i].equals("")) {
  7297. + if (i == 0) {
  7298. + propStr = "gsm.sim.ril.mcc.mnc";
  7299. + } else {
  7300. + propStr = "gsm.sim.ril.mcc.mnc." + (i + 1);
  7301. + }
  7302. + strMnc[i] = SystemProperties.get(propStr, "");
  7303. + logd("strMnc[" + i + "] from ril.mcc.mnc:" + strMnc[i]);
  7304. + }
  7305. + for (String mccmnc : PLMN_TABLE_TYPE1) {
  7306. + if (strMnc[i].equals(mccmnc)) {
  7307. + simOpInfo[i] = SIM_OP_INFO_OP01;
  7308. + // MTK, just why didn't you break
  7309. + break;
  7310. + }
  7311. + }
  7312. + for (String mccmnc : PLMN_TABLE_TYPE3) {
  7313. + if (strMnc[i].equals(mccmnc)) {
  7314. + simOpInfo[i] = SIM_OP_INFO_OP02;
  7315. + break;
  7316. + }
  7317. + }
  7318. + logd("strMnc[" + i + "]= " + strMnc[i] + ", simOpInfo[" + i + "]=" + simOpInfo[i]);
  7319. + }
  7320. + logd("getSimInfo(simOpInfo): " + Arrays.toString(simOpInfo));
  7321. + logd("getSimInfo(simType): " + Arrays.toString(simType));
  7322. + }
  7323. +
  7324. + /**
  7325. + * Check if need to switch capability.
  7326. + *
  7327. + * @param mProxyPhones Phone array for all phones
  7328. + * @param rats new capability for phones
  7329. + * @return ture or false
  7330. + */
  7331. + public static boolean isNeedSwitchInOpPackage(Phone[] mProxyPhones, PhoneRatFamily[] rats) {
  7332. + String operatorSpec = SystemProperties.get("ro.operator.optr", "");
  7333. + int[] simOpInfo = new int[mProxyPhones.length];
  7334. + int[] simType = new int[mProxyPhones.length];
  7335. +
  7336. + logd("Operator Spec:" + operatorSpec);
  7337. + // TODO: fix OP01 and OP02
  7338. + return true;
  7339. +
  7340. + /*
  7341. + if (operatorSpec.equals("OP02")) {
  7342. + // disable capability switch in op02 package
  7343. + return false;
  7344. + } else if (operatorSpec.equals("OP01")) {
  7345. + // handle later
  7346. + } else {
  7347. + // OM package, default enable
  7348. + return true;
  7349. + }
  7350. + getSimInfo(simOpInfo, simType);
  7351. + // find target phone ID
  7352. + int targetPhoneId;
  7353. + for (targetPhoneId = 0; targetPhoneId < rats.length; targetPhoneId++) {
  7354. + if ((rats[targetPhoneId].getRatFamily() & PhoneRatFamily.PHONE_RAT_FAMILY_3G)
  7355. + == PhoneRatFamily.PHONE_RAT_FAMILY_3G) {
  7356. + break;
  7357. + }
  7358. + }
  7359. + if (operatorSpec.equals("OP01")) {
  7360. + return checkOp01(targetPhoneId, simOpInfo, simType);
  7361. + } else {
  7362. + return true;
  7363. + }
  7364. + */
  7365. + }
  7366. +
  7367. + /**
  7368. + * Check if any higher priority SIM exists.
  7369. + *
  7370. + * @param curId current phone ID uses main capability
  7371. + * @param op01Usim array to indicate if op01 USIM
  7372. + * @param op01Sim array to indicate if op01 SIM
  7373. + * @param overseaUsim array to indicate if oversea USIM
  7374. + * @param overseaSim array to indicate if oversea SIM
  7375. + * @return higher priority SIM ID
  7376. + */
  7377. + /*
  7378. + public static int getHigherPrioritySimForOp01(int curId, boolean[] op01Usim, boolean[] op01Sim
  7379. + , boolean[] overseaUsim, boolean[] overseaSim) {
  7380. + int targetSim = -1;
  7381. + int phoneNum = op01Usim.length;
  7382. +
  7383. + if (op01Usim[curId] == true) {
  7384. + return curId;
  7385. + }
  7386. + for (int i = 0; i < phoneNum; i++) {
  7387. + if (op01Usim[i] == true) {
  7388. + targetSim = i;
  7389. + }
  7390. + }
  7391. + if (targetSim != -1 || op01Sim[curId] == true) {
  7392. + return targetSim;
  7393. + }
  7394. + for (int i = 0; i < phoneNum; i++) {
  7395. + if (op01Sim[i] == true) {
  7396. + targetSim = i;
  7397. + }
  7398. + }
  7399. + if (targetSim != -1 || overseaUsim[curId] == true) {
  7400. + return targetSim;
  7401. + }
  7402. + for (int i = 0; i < phoneNum; i++) {
  7403. + if (overseaUsim[i] == true) {
  7404. + targetSim = i;
  7405. + }
  7406. + }
  7407. + if (targetSim != -1 || overseaSim[curId] == true) {
  7408. + return targetSim;
  7409. + }
  7410. + for (int i = 0; i < phoneNum; i++) {
  7411. + if (overseaSim[i] == true) {
  7412. + targetSim = i;
  7413. + }
  7414. + }
  7415. + return targetSim;
  7416. + }
  7417. +
  7418. + private static boolean checkOp01(int targetPhoneId, int[] simOpInfo, int[] simType) {
  7419. + int curPhoneId = Integer.valueOf(
  7420. + SystemProperties.get(PhoneConstants.CAPABILITY_SWITCH_PROP, "1")) - 1;
  7421. +
  7422. + logd("checkOp01 : curPhoneId: " + curPhoneId);
  7423. + if (simOpInfo[targetPhoneId] == SIM_OP_INFO_OP01) {
  7424. + if (simType[targetPhoneId] == SIM_TYPE_SIM) {
  7425. + if ((simOpInfo[curPhoneId] == SIM_OP_INFO_OP01)
  7426. + && simType[curPhoneId] != SIM_TYPE_SIM) {
  7427. + logd("checkOp01 : case 1,2; stay in current phone");
  7428. + return false;
  7429. + } else {
  7430. + // case 3: op01-SIM + op01-SIM
  7431. + // case 4: op01-SIM + others
  7432. + logd("checkOp01 : case 3,4");
  7433. + return true;
  7434. + }
  7435. + } else { // USIM, ISIM...
  7436. + // case 1: op01-USIM + op01-USIM
  7437. + // case 2: op01-USIM + others
  7438. + logd("checkOp01 : case 1,2");
  7439. + return true;
  7440. + }
  7441. + } else if (simOpInfo[targetPhoneId] == SIM_OP_INFO_OVERSEA) {
  7442. + if (simOpInfo[curPhoneId] == SIM_OP_INFO_OP01) {
  7443. + logd("checkOp01 : case 1,2,3,4; stay in current phone");
  7444. + return false;
  7445. + } else if (simType[targetPhoneId] == SIM_TYPE_SIM) {
  7446. + if ((simOpInfo[curPhoneId] == SIM_OP_INFO_OVERSEA)
  7447. + && simType[curPhoneId] != SIM_TYPE_SIM) {
  7448. + logd("checkOp01 : case 5,6; stay in current phone");
  7449. + return false;
  7450. + } else {
  7451. + // case 7: non-China SIM + non-China SIM
  7452. + // case 8: non-China SIM + others
  7453. + logd("checkOp01 : case 7,8");
  7454. + return true;
  7455. + }
  7456. + } else { // USIM, ISIM...
  7457. + // case 5: non-China USIM + non-China USIM
  7458. + // case 6: non-China USIM + others
  7459. + logd("checkOp01 : case 5,6");
  7460. + return true;
  7461. + }
  7462. + } else {
  7463. + // case 9: non-op01 USIM/SIM + non-op01 USIM/SIM
  7464. + logd("checkOp01 : case 9");
  7465. + return false;
  7466. + }
  7467. + }
  7468. + */
  7469. +
  7470. + private static void logd(String s) {
  7471. + //Log.d(LOG_TAG, "[RadioCapSwitchUtil] " + s);
  7472. + }
  7473. +}
  7474. +
  7475. +
  7476. diff --git a/src/java/com/mediatek/internal/telephony/dataconnection/FdManager.java b/src/java/com/mediatek/internal/telephony/dataconnection/FdManager.java
  7477. new file mode 100755
  7478. index 0000000..4063293
  7479. --- /dev/null
  7480. +++ b/src/java/com/mediatek/internal/telephony/dataconnection/FdManager.java
  7481. @@ -0,0 +1,421 @@
  7482. +/* Copyright Statement:
  7483. + *
  7484. + * This software/firmware and related documentation ("MediaTek Software") are
  7485. + * protected under relevant copyright laws. The information contained herein is
  7486. + * confidential and proprietary to MediaTek Inc. and/or its licensors. Without
  7487. + * the prior written permission of MediaTek inc. and/or its licensors, any
  7488. + * reproduction, modification, use or disclosure of MediaTek Software, and
  7489. + * information contained herein, in whole or in part, shall be strictly
  7490. + * prohibited.
  7491. + *
  7492. + * MediaTek Inc. (C) 2010. All rights reserved.
  7493. + *
  7494. + * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  7495. + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  7496. + * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
  7497. + * ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
  7498. + * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
  7499. + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  7500. + * NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
  7501. + * RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
  7502. + * INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
  7503. + * TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
  7504. + * RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
  7505. + * OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
  7506. + * SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
  7507. + * RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  7508. + * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
  7509. + * ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
  7510. + * RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
  7511. + * MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
  7512. + * CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  7513. + *
  7514. + * The following software/firmware and/or related documentation ("MediaTek
  7515. + * Software") have been modified by MediaTek Inc. All revisions are subject to
  7516. + * any receiver's applicable license agreements with MediaTek Inc.
  7517. + */
  7518. +
  7519. +
  7520. +package com.mediatek.internal.telephony.dataconnection;
  7521. +
  7522. +import android.content.BroadcastReceiver;
  7523. +import android.content.ContentResolver;
  7524. +import android.content.Context;
  7525. +import android.content.Intent;
  7526. +import android.content.IntentFilter;
  7527. +import android.net.ConnectivityManager;
  7528. +import android.os.AsyncResult;
  7529. +import android.os.BatteryManager;
  7530. +import android.os.Handler;
  7531. +import android.os.HandlerThread;
  7532. +import android.os.Message;
  7533. +import android.os.Messenger;
  7534. +import android.os.SystemProperties;
  7535. +import android.telephony.Rlog;
  7536. +import android.telephony.SubscriptionManager;
  7537. +import android.util.Log;
  7538. +import android.util.SparseArray;
  7539. +
  7540. +import com.android.internal.telephony.PhoneBase;
  7541. +import com.android.internal.telephony.PhoneConstants;
  7542. +import com.android.internal.telephony.PhoneFactory;
  7543. +import com.android.internal.telephony.TelephonyIntents;
  7544. +import com.android.internal.telephony.gsm.GSMPhone;
  7545. +
  7546. +//import com.mediatek.settings.FeatureOption;
  7547. +//import com.mediatek.common.featureoption.FeatureOption;
  7548. +
  7549. +import java.util.ArrayList;
  7550. +
  7551. +public class FdManager extends Handler {
  7552. + // M:Fast Dormancy Manager
  7553. + protected static final boolean DBG = true;
  7554. + protected static final String LOG_TAG = "FdManager";
  7555. + protected static final String PROPERTY_3G_SWITCH = "gsm.3gswitch";
  7556. + protected static final String PROPERTY_MTK_FD_SUPPORT = "ro.mtk_fd_support";
  7557. + protected static final String PROPERTY_RIL_FD_MODE = "ril.fd.mode";
  7558. + protected static final String PROPERTY_FD_ON_CHARGE = "fd.on.charge";
  7559. + protected static final String PROPERTY_FD_SCREEN_OFF_ONLY = "fd.screen.off.only";
  7560. + private static final String STR_PROPERTY_FD_SCREEN_ON_TIMER = "persist.radio.fd.counter";
  7561. + private static final String STR_PROPERTY_FD_SCREEN_ON_R8_TIMER = "persist.radio.fd.r8.counter";
  7562. + private static final String STR_PROPERTY_FD_SCREEN_OFF_TIMER = "persist.radio.fd.off.counter";
  7563. + private static final String
  7564. + STR_PROPERTY_FD_SCREEN_OFF_R8_TIMER = "persist.radio.fd.off.r8.counter";
  7565. +
  7566. + private static final int BASE = 0;
  7567. + private static final int EVENT_FD_MODE_SET = BASE + 0;
  7568. +
  7569. + public enum FdModeType {
  7570. + DISABLE_MD_FD,
  7571. + ENABLE_MD_FD,
  7572. + SET_FD_INACTIVITY_TIMER,
  7573. + INFO_MD_SCREEN_STATUS
  7574. + }
  7575. +
  7576. + public enum FdTimerType {
  7577. + ScreenOffLegacyFd,
  7578. + ScreenOnLegacyFd,
  7579. + ScreenOffR8Fd,
  7580. + ScreenOnR8Fd,
  7581. + SupportedTimerTypes
  7582. + }
  7583. +
  7584. + private static final SparseArray<FdManager> sFdManagers = new SparseArray<FdManager>();
  7585. +
  7586. + private PhoneBase mPhone;
  7587. + private boolean mChargingMode = false;
  7588. + private boolean mIsTetheredMode = false;
  7589. + private int mEnableFdOnCharging = 0;
  7590. + private boolean mIsScreenOn = true;
  7591. + private static int numberOfSupportedTypes;
  7592. + private static String timerValue[] = {"50", "150", "50", "150"};
  7593. + //Time Unit:0.1 sec => {5sec, 15sec, 5sec, 15sec}
  7594. +
  7595. + protected BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
  7596. + @Override
  7597. + public void onReceive(Context context, Intent intent) {
  7598. + String action = intent.getAction();
  7599. + if (DBG) logd("onReceive: action=" + action);
  7600. + int fdMdEnableMode = Integer.parseInt(SystemProperties.get(PROPERTY_RIL_FD_MODE, "0"));
  7601. + int fdSimId = SystemProperties.getInt(PROPERTY_3G_SWITCH, 1) - 1;
  7602. + if (action.equals(Intent.ACTION_SCREEN_ON)) {
  7603. + mIsScreenOn = true;
  7604. + if (isFdSupport()) {
  7605. + if (DBG) logd("fdMdEnableMode=" + fdMdEnableMode + ", 3gSimID="
  7606. + + fdSimId + ", when switching to SCREEN ON");
  7607. + mIsScreenOn = true;
  7608. + if (fdMdEnableMode == 1) {
  7609. + //fdMdEnableMode == 1: It means that the Fast Dormancy polling
  7610. + // & decision mechanism is implemented by modem side
  7611. + if (mPhone.getPhoneId() == fdSimId) {
  7612. + mPhone.mCi.setFDMode(FdModeType.INFO_MD_SCREEN_STATUS.ordinal(), 1, -1,
  7613. + obtainMessage(EVENT_FD_MODE_SET));
  7614. +
  7615. + if (isFdScreenOffOnly()) {
  7616. + if (DBG) {
  7617. + logd("Because FD_SCREEN_OFF_ONLY, disable fd when screen on.");
  7618. + }
  7619. + updateFdMdEnableStatus(false);
  7620. + }
  7621. + }
  7622. + } else {
  7623. + logd("Not Support AP-trigger FD now");
  7624. + }
  7625. + }
  7626. + } else if (action.equals(Intent.ACTION_SCREEN_OFF)) {
  7627. + mIsScreenOn = false;
  7628. + if (isFdSupport()) {
  7629. + if (fdMdEnableMode == 1) {
  7630. + if (DBG) logd("fdMdEnableMode=" + fdMdEnableMode + ", 3gSimID="
  7631. + + fdSimId + ", when switching to SCREEN OFF");
  7632. + if (mPhone.getPhoneId() == fdSimId) {
  7633. + mPhone.mCi.setFDMode(FdModeType.INFO_MD_SCREEN_STATUS.ordinal(), 0, -1,
  7634. + obtainMessage(EVENT_FD_MODE_SET));
  7635. +
  7636. + if (isFdScreenOffOnly() && checkNeedTurnOn()) {
  7637. + if (DBG) {
  7638. + logd("Because FD_SCREEN_OFF_ONLY, turn on fd when screen off.");
  7639. + }
  7640. + updateFdMdEnableStatus(true);
  7641. + }
  7642. + }
  7643. + } else {
  7644. + logd("Not Support AP-trigger FD now");
  7645. + }
  7646. + }
  7647. + } else if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {
  7648. + if (isFdSupport()){
  7649. + int status = intent.getIntExtra("status", 0);
  7650. + int plugged = intent.getIntExtra("plugged", 0);
  7651. + boolean previousChargingMode = mChargingMode;
  7652. +
  7653. + String sChargingModeStr = "", sPluggedStr = "";
  7654. + mChargingMode = status == BatteryManager.BATTERY_STATUS_CHARGING;
  7655. + sChargingModeStr = mChargingMode ? "Charging" : "Non-Charging";
  7656. +
  7657. + if (plugged == BatteryManager.BATTERY_PLUGGED_AC) {
  7658. + sPluggedStr="Plugged in AC";
  7659. + } else if (plugged == BatteryManager.BATTERY_PLUGGED_USB) {
  7660. + sPluggedStr="Plugged in USB";
  7661. + }
  7662. +
  7663. + if ((plugged == BatteryManager.BATTERY_PLUGGED_AC)
  7664. + || (plugged == BatteryManager.BATTERY_PLUGGED_USB)) {
  7665. + mChargingMode = true;
  7666. + }
  7667. +
  7668. + int previousEnableFDOnCharging = mEnableFdOnCharging;
  7669. + mEnableFdOnCharging =
  7670. + Integer.parseInt(SystemProperties.get(PROPERTY_FD_ON_CHARGE, "0"));
  7671. +
  7672. + if ((previousChargingMode != mChargingMode)
  7673. + || (previousEnableFDOnCharging != mEnableFdOnCharging)) {
  7674. + if (DBG) logd("fdMdEnableMode=" + fdMdEnableMode + ", 3gSimID="
  7675. + + fdSimId + ", when charging state is changed");
  7676. + if (DBG) logd("previousEnableFdOnCharging=" + previousEnableFDOnCharging
  7677. + + ", mEnableFdOnCharging=" + mEnableFdOnCharging
  7678. + + ", when charging state is changed");
  7679. + if (DBG) logd("previousChargingMode=" + previousChargingMode
  7680. + + ", mChargingMode=" + mChargingMode + ", status=" + status
  7681. + + "(" + sPluggedStr + ")");
  7682. + }
  7683. +
  7684. +
  7685. + if (fdMdEnableMode == 1) {
  7686. + if (mPhone.getPhoneId() == fdSimId) {
  7687. + if ((previousChargingMode != mChargingMode)
  7688. + || (previousEnableFDOnCharging != mEnableFdOnCharging)) {
  7689. + updateFdMdEnableStatus(checkNeedTurnOn());
  7690. + }
  7691. + }
  7692. + }
  7693. + }
  7694. + } else if (action.equals(ConnectivityManager.ACTION_TETHER_STATE_CHANGED)) {
  7695. + if (isFdSupport()){
  7696. + logd("Received ConnectivityManager.ACTION_TETHER_STATE_CHANGED");
  7697. + ArrayList<String> active =
  7698. + intent.getStringArrayListExtra(ConnectivityManager.EXTRA_ACTIVE_TETHER);
  7699. + mIsTetheredMode = ((active != null) && (active.size() > 0));
  7700. + logd("[TETHER_STATE_CHANGED]mIsTetheredMode = " + mIsTetheredMode
  7701. + + "mChargingMode=" + mChargingMode);
  7702. + updateFdMdEnableStatus(checkNeedTurnOn());
  7703. + }
  7704. + }
  7705. + }
  7706. + };
  7707. +
  7708. +
  7709. + public static FdManager getInstance(PhoneBase phone) {
  7710. + if (isFdSupport()) {
  7711. + if (phone.getPhoneId() < 0) {
  7712. + Rlog.e(LOG_TAG, "phoneId " + phone.getPhoneId() + " is invalid!");
  7713. + return null;
  7714. + }
  7715. + FdManager fdMgr = sFdManagers.get(phone.getPhoneId());
  7716. + if (fdMgr == null) {
  7717. + //PhoneBase phone = (PhoneBase) PhoneFactory.getPhone(phone.getPhoneId());
  7718. + if (phone != null) {
  7719. + Rlog.d(LOG_TAG, "FDManager for phoneId:" + phone.getPhoneId()
  7720. + + " doesn't exist, create it");
  7721. + fdMgr = new FdManager(phone);
  7722. + sFdManagers.put(phone.getPhoneId(), fdMgr);
  7723. + } else {
  7724. + Rlog.e(LOG_TAG, "FDManager for phoneId:" + phone.getPhoneId()
  7725. + + " can't get phone to init!");
  7726. + }
  7727. + }
  7728. + return fdMgr;
  7729. + }
  7730. + return null;
  7731. + }
  7732. +
  7733. + private FdManager(PhoneBase p) {
  7734. + mPhone = p;
  7735. + logd("FastDormancyManager init");
  7736. +
  7737. + IntentFilter filter = new IntentFilter();
  7738. + filter.addAction(Intent.ACTION_SCREEN_ON);
  7739. + filter.addAction(Intent.ACTION_SCREEN_OFF);
  7740. + filter.addAction(Intent.ACTION_BATTERY_CHANGED);
  7741. + filter.addAction(ConnectivityManager.ACTION_TETHER_STATE_CHANGED);
  7742. + mPhone.getContext().registerReceiver(mIntentReceiver, filter, null, mPhone);
  7743. +
  7744. + initFdTimer();
  7745. +
  7746. + }
  7747. +
  7748. + public void dispose() {
  7749. + if (DBG) logd("FD.dispose");
  7750. + if (isFdSupport()) {
  7751. + mPhone.getContext().unregisterReceiver(this.mIntentReceiver);
  7752. + sFdManagers.remove(mPhone.getPhoneId());
  7753. + }
  7754. + }
  7755. +
  7756. + private void initFdTimer() {
  7757. + String timerStr[] = new String[4];
  7758. + timerStr[0] = SystemProperties.get(STR_PROPERTY_FD_SCREEN_OFF_TIMER, "5");
  7759. + timerValue[FdTimerType.ScreenOffLegacyFd.ordinal()] =
  7760. + Integer.toString((int)(Double.parseDouble(timerStr[0])*10));
  7761. + timerStr[1] = SystemProperties.get(STR_PROPERTY_FD_SCREEN_ON_TIMER, "15");
  7762. + timerValue[FdTimerType.ScreenOnLegacyFd.ordinal()] =
  7763. + Integer.toString((int)(Double.parseDouble(timerStr[1])*10));
  7764. + timerStr[2] = SystemProperties.get(STR_PROPERTY_FD_SCREEN_OFF_R8_TIMER, "5");
  7765. + timerValue[FdTimerType.ScreenOffR8Fd.ordinal()] =
  7766. + Integer.toString((int)(Double.parseDouble(timerStr[2])*10));
  7767. + timerStr[3] = SystemProperties.get(STR_PROPERTY_FD_SCREEN_ON_R8_TIMER, "15");
  7768. + timerValue[FdTimerType.ScreenOnR8Fd.ordinal()] =
  7769. + Integer.toString((int)(Double.parseDouble(timerStr[3])*10));
  7770. + logd("Default FD timers=" + timerValue[0] + "," + timerValue[1] + ","
  7771. + + timerValue[2] + "," + timerValue[3]);
  7772. +
  7773. + }
  7774. +
  7775. + public int getNumberOfSupportedTypes() {
  7776. + return FdTimerType.SupportedTimerTypes.ordinal();
  7777. + }
  7778. +
  7779. + /**
  7780. + * setFdTimerValue
  7781. + * @param String array for new Timer Value
  7782. + * @param Message for on complete
  7783. + */
  7784. + public int setFdTimerValue(String newTimerValue[], Message onComplete) {
  7785. + int fdMdEnableMode = Integer.parseInt(SystemProperties.get(PROPERTY_RIL_FD_MODE, "0"));
  7786. + int fdSimId = SystemProperties.getInt(PROPERTY_3G_SWITCH, 1) - 1;
  7787. + if (isFdSupport() && fdMdEnableMode == 1 && mPhone.getPhoneId() == fdSimId) {
  7788. + // TODO: remove FeatureOption
  7789. + for (int i=0; i < newTimerValue.length; i++) {
  7790. + timerValue[i] = newTimerValue[i];
  7791. + }
  7792. + mPhone.mCi.setFDMode(FdModeType.SET_FD_INACTIVITY_TIMER.ordinal(),
  7793. + FdTimerType.ScreenOffLegacyFd.ordinal(),
  7794. + Integer.parseInt(timerValue[FdTimerType.ScreenOffLegacyFd.ordinal()]), null);
  7795. + mPhone.mCi.setFDMode(FdModeType.SET_FD_INACTIVITY_TIMER.ordinal(),
  7796. + FdTimerType.ScreenOnLegacyFd.ordinal(),
  7797. + Integer.parseInt(timerValue[FdTimerType.ScreenOnLegacyFd.ordinal()]), null);
  7798. + mPhone.mCi.setFDMode(FdModeType.SET_FD_INACTIVITY_TIMER.ordinal(),
  7799. + FdTimerType.ScreenOffR8Fd.ordinal(),
  7800. + Integer.parseInt(timerValue[FdTimerType.ScreenOffR8Fd.ordinal()]), null);
  7801. + mPhone.mCi.setFDMode(FdModeType.SET_FD_INACTIVITY_TIMER.ordinal(),
  7802. + FdTimerType.ScreenOnR8Fd.ordinal(),
  7803. + Integer.parseInt(timerValue[FdTimerType.ScreenOnR8Fd.ordinal()]), onComplete);
  7804. + logd("Set Default FD timers=" + timerValue[0] + "," + timerValue[1] + ","
  7805. + + timerValue[2] + "," + timerValue[3]);
  7806. + }
  7807. + return 0;
  7808. + }
  7809. +
  7810. + /**
  7811. + * setFdTimerValue
  7812. + * @param String array for new Timer Value
  7813. + * @param Message for on complete
  7814. + * @param PhoneBase for input context
  7815. + */
  7816. + public int setFdTimerValue(String newTimerValue[], Message onComplete, PhoneBase phone) {
  7817. + FdManager fdMgr = getInstance(phone);
  7818. + if (fdMgr != null) {
  7819. + fdMgr.setFdTimerValue(newTimerValue, onComplete);
  7820. + } else {
  7821. + logd("setFDTimerValue fail!");
  7822. + }
  7823. + return 0;
  7824. + }
  7825. +
  7826. + /**
  7827. + * getFdTimerValue
  7828. + * @return FD Timer String array
  7829. + */
  7830. + public static String[] getFdTimerValue() {
  7831. + return timerValue;
  7832. + }
  7833. +
  7834. + @Override
  7835. + public void handleMessage(Message msg) {
  7836. + AsyncResult ar;
  7837. + switch (msg.what) {
  7838. + case EVENT_FD_MODE_SET:
  7839. + ar = (AsyncResult) msg.obj;
  7840. + if (ar.exception != null) {
  7841. + if (DBG) logd("SET_FD_MODE ERROR");
  7842. + }
  7843. + break;
  7844. + default:
  7845. + Rlog.e("FdManager", "Unidentified event msg=" + msg);
  7846. + break;
  7847. + }
  7848. + }
  7849. +
  7850. + private void updateFdMdEnableStatus(boolean enabled) {
  7851. + int fdMdEnableMode = Integer.parseInt(SystemProperties.get(PROPERTY_RIL_FD_MODE, "0"));
  7852. + int fdSimId = SystemProperties.getInt(PROPERTY_3G_SWITCH, 1) - 1;
  7853. + if (DBG) logd("updateFdMdEnableStatus(): enabled=" + enabled + ",fdMdEnableMode="
  7854. + + fdMdEnableMode + ", 3gSimID=" + fdSimId);
  7855. + if (fdMdEnableMode == 1 && mPhone.getPhoneId() == fdSimId) {
  7856. + if (enabled) {
  7857. + mPhone.mCi.setFDMode(FdModeType.ENABLE_MD_FD.ordinal(), -1, -1,
  7858. + obtainMessage(EVENT_FD_MODE_SET));
  7859. + } else {
  7860. + mPhone.mCi.setFDMode(FdModeType.DISABLE_MD_FD.ordinal(), -1, -1,
  7861. + obtainMessage(EVENT_FD_MODE_SET));
  7862. + }
  7863. + }
  7864. + }
  7865. +
  7866. + // TODO: check onRecordsLoaded
  7867. + public void disableFdWhenTethering() {
  7868. + if (isFdSupport()) {
  7869. + ConnectivityManager connMgr = (ConnectivityManager) mPhone.getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
  7870. + if ((connMgr != null) && (connMgr.getTetheredIfaces() != null)) {
  7871. + mIsTetheredMode = (connMgr.getTetheredIfaces().length > 0);
  7872. + }
  7873. +
  7874. + logd("mIsTetheredMode = " + mIsTetheredMode + "mChargingMode=" + mChargingMode);
  7875. + updateFdMdEnableStatus(checkNeedTurnOn());
  7876. + }
  7877. + }
  7878. +
  7879. + /**
  7880. + * checkNeedTurnOn.
  7881. + * when Fd Screen Off only mode, check screen state to make sure the turn on or not
  7882. + * @return boolean need or not
  7883. + */
  7884. + private boolean checkNeedTurnOn() {
  7885. + return (!(isFdScreenOffOnly() && mIsScreenOn) &&
  7886. + !(mChargingMode && (mEnableFdOnCharging == 0)) &&
  7887. + !mIsTetheredMode);
  7888. + }
  7889. +
  7890. + public static boolean isFdScreenOffOnly() {
  7891. + return SystemProperties.getInt(PROPERTY_FD_SCREEN_OFF_ONLY, 0) == 1;
  7892. + }
  7893. +
  7894. + public static boolean isFdSupport() {
  7895. + return SystemProperties.getInt(PROPERTY_MTK_FD_SUPPORT, 1) == 1;
  7896. + }
  7897. +
  7898. + protected void logd(String s) {
  7899. + Rlog.d(LOG_TAG, "[GDCT][phoneId" + mPhone.getPhoneId() + "]"+ s);
  7900. + }
  7901. +}
  7902. +
  7903. diff --git a/src/java/com/mediatek/internal/telephony/uicc/IccCardProxyEx.java b/src/java/com/mediatek/internal/telephony/uicc/IccCardProxyEx.java
  7904. new file mode 100755
  7905. index 0000000..4ba67ac
  7906. --- /dev/null
  7907. +++ b/src/java/com/mediatek/internal/telephony/uicc/IccCardProxyEx.java
  7908. @@ -0,0 +1,390 @@
  7909. +/*
  7910. + * Copyright (C) 2012 The Android Open Source Project
  7911. + *
  7912. + * Licensed under the Apache License, Version 2.0 (the "License");
  7913. + * you may not use this file except in compliance with the License.
  7914. + * You may obtain a copy of the License at
  7915. + *
  7916. + * http://www.apache.org/licenses/LICENSE-2.0
  7917. + *
  7918. + * Unless required by applicable law or agreed to in writing, software
  7919. + * distributed under the License is distributed on an "AS IS" BASIS,
  7920. + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  7921. + * See the License for the specific language governing permissions and
  7922. + * limitations under the License.
  7923. + */
  7924. +
  7925. +package com.mediatek.internal.telephony.uicc;
  7926. +
  7927. +
  7928. +import static android.Manifest.permission.READ_PHONE_STATE;
  7929. +import android.app.ActivityManagerNative;
  7930. +import android.content.Context;
  7931. +import android.content.Intent;
  7932. +import android.os.AsyncResult;
  7933. +import android.os.Handler;
  7934. +import android.os.Message;
  7935. +import android.os.UserHandle;
  7936. +
  7937. +import android.telephony.TelephonyManager;
  7938. +import android.telephony.SubscriptionManager;
  7939. +import android.telephony.Rlog;
  7940. +
  7941. +import com.android.internal.telephony.CommandsInterface;
  7942. +import com.android.internal.telephony.IccCardConstants;
  7943. +import com.android.internal.telephony.IccCardConstants.State;
  7944. +import com.android.internal.telephony.TelephonyIntents;
  7945. +import com.android.internal.telephony.uicc.UiccController;
  7946. +import com.android.internal.telephony.uicc.UiccCard;
  7947. +import com.android.internal.telephony.uicc.UiccCardApplication;
  7948. +import com.android.internal.telephony.uicc.IccRecords;
  7949. +import com.android.internal.telephony.uicc.IccFileHandler;
  7950. +import com.android.internal.telephony.uicc.IccCardStatus;
  7951. +import com.android.internal.telephony.uicc.IccCardStatus.CardState;
  7952. +import com.android.internal.telephony.uicc.IccCardApplicationStatus.PersoSubState;
  7953. +import com.android.internal.telephony.PhoneConstants;
  7954. +
  7955. +/**
  7956. + * @Deprecated use {@link UiccController}.getUiccCard instead.
  7957. + *
  7958. + * The Phone App assumes that there is only one icc card, and one icc application
  7959. + * available at a time. Moreover, it assumes such object (represented with IccCard)
  7960. + * is available all the time (whether {@link RILConstants.RIL_REQUEST_GET_SIM_STATUS} returned
  7961. + * or not, whether card has desired application or not, whether there really is a card in the
  7962. + * slot or not).
  7963. + *
  7964. + * UiccController, however, can handle multiple instances of icc objects (multiple
  7965. + * {@link UiccCardApplication}, multiple {@link IccFileHandler}, multiple {@link IccRecords})
  7966. + * created and destroyed dynamically during phone operation.
  7967. + *
  7968. + * This class implements the IccCard interface that is always available (right after default
  7969. + * phone object is constructed) to expose the current (based on voice radio technology)
  7970. + * application on the uicc card, so that external apps won't break.
  7971. + */
  7972. +
  7973. +public class IccCardProxyEx extends Handler {
  7974. + private static final boolean DBG = true;
  7975. + private static final String LOG_TAG = "IccCardProxyEx";
  7976. +
  7977. + private static final int EVENT_RADIO_OFF_OR_UNAVAILABLE = 1;
  7978. + private static final int EVENT_ICC_CHANGED = 2;
  7979. + private static final int EVENT_APP_READY = 3;
  7980. + private static final int EVENT_RECORDS_LOADED = 4;
  7981. +
  7982. + private final Object mLock = new Object();
  7983. + private Context mContext;
  7984. + private CommandsInterface mCi;
  7985. +
  7986. + private static final int APPLICATION_ID_ISIM = 0;
  7987. + private static final int APPLICATION_ID_MAX = 1;
  7988. +
  7989. + private int mCurrentAppType = UiccController.APP_FAM_IMS;
  7990. + private UiccController mUiccController = null;
  7991. +
  7992. + private UiccCard mUiccCard = null;
  7993. + private UiccCardApplication[] mUiccApplication =
  7994. + new UiccCardApplication[IccCardStatus.CARD_MAX_APPS];
  7995. + private IccRecords[] mIccRecords =
  7996. + new IccRecords[IccCardStatus.CARD_MAX_APPS];
  7997. +
  7998. + private State[] mExternalState = new State[]{State.UNKNOWN};
  7999. + private int mSlotId;
  8000. +
  8001. + public IccCardProxyEx(Context context, CommandsInterface ci) {
  8002. + this(context, ci, PhoneConstants.SIM_ID_1);
  8003. + }
  8004. +
  8005. + public IccCardProxyEx(Context context, CommandsInterface ci, int slotId) {
  8006. + this.mContext = context;
  8007. + this.mCi = ci;
  8008. + // FIXME: slotId or phoneId?
  8009. + mSlotId = slotId;
  8010. +
  8011. + Integer index = new Integer(mSlotId);
  8012. + mUiccController = UiccController.getInstance();
  8013. + ci.registerForOffOrNotAvailable(this, EVENT_RADIO_OFF_OR_UNAVAILABLE, index);
  8014. + mUiccController.registerForApplicationChanged(this, EVENT_ICC_CHANGED, index);
  8015. +
  8016. + setExternalState(State.NOT_READY, 0);
  8017. + log("Creating");
  8018. + }
  8019. +
  8020. + public void dispose() {
  8021. + synchronized (mLock) {
  8022. + log("Disposing");
  8023. + //Cleanup icc references
  8024. + mCi.unregisterForOffOrNotAvailable(this);
  8025. + mUiccController.unregisterForApplicationChanged(this);
  8026. + mUiccController = null;
  8027. + }
  8028. + }
  8029. +
  8030. + public void handleMessage(Message msg) {
  8031. + AsyncResult ar;
  8032. + int appId;
  8033. + log("receive message " + msg.what);
  8034. +
  8035. + Integer index = getIndex(msg);
  8036. +
  8037. + if (index < 0 || index >= TelephonyManager.getDefault().getPhoneCount() || index != mSlotId) {
  8038. + loge("Invalid index : " + index + " received with event " + msg.what);
  8039. + return;
  8040. + }
  8041. +
  8042. + switch (msg.what) {
  8043. + case EVENT_RADIO_OFF_OR_UNAVAILABLE:
  8044. + for (int i = 0; i < APPLICATION_ID_MAX; i++) {
  8045. + setExternalState(State.NOT_READY, i);
  8046. + }
  8047. + break;
  8048. +
  8049. + case EVENT_ICC_CHANGED:
  8050. + updateIccAvailability(0);
  8051. + break;
  8052. +
  8053. + case EVENT_APP_READY:
  8054. + ar = (AsyncResult) (msg.obj);
  8055. + appId = ((Integer) ar.userObj).intValue();
  8056. + setExternalState(State.READY, appId);
  8057. + break;
  8058. +
  8059. + case EVENT_RECORDS_LOADED:
  8060. + ar = (AsyncResult) (msg.obj);
  8061. + appId = ((Integer) ar.userObj).intValue();
  8062. + broadcastIccStateChangedIntent(IccCardConstants.INTENT_VALUE_ICC_LOADED, null, appId);
  8063. +
  8064. + break;
  8065. + default:
  8066. + loge("Unhandled message with number: " + msg.what);
  8067. + break;
  8068. + }
  8069. + }
  8070. +
  8071. + private void updateIccAvailability(int appId) {
  8072. + synchronized (mLock) {
  8073. + UiccCard newCard = mUiccController.getUiccCard();
  8074. + CardState state = CardState.CARDSTATE_ABSENT;
  8075. + UiccCardApplication newApp = null;
  8076. + IccRecords newRecords = null;
  8077. + int appType = 0;
  8078. +
  8079. + switch(appId) {
  8080. + case 0:
  8081. + appType = UiccController.APP_FAM_IMS;
  8082. + break;
  8083. + default:
  8084. + break;
  8085. + }
  8086. +
  8087. + if (newCard != null) {
  8088. + state = newCard.getCardState();
  8089. + newApp = newCard.getApplication(appType);
  8090. + if (newApp != null) {
  8091. + newRecords = newApp.getIccRecords();
  8092. + }
  8093. + }
  8094. +
  8095. + if (mIccRecords[appId] != newRecords || mUiccApplication[appId] != newApp || mUiccCard != newCard) {
  8096. + if (DBG) log("Icc changed. Reregestering.");
  8097. + unregisterUiccCardEvents(appId);
  8098. + mUiccCard = newCard;
  8099. + mUiccApplication[appId] = newApp;
  8100. + mIccRecords[appId] = newRecords;
  8101. + registerUiccCardEvents(appId);
  8102. + }
  8103. +
  8104. + updateExternalState(appId);
  8105. + }
  8106. + }
  8107. +
  8108. + private void updateExternalState(int appId) {
  8109. +
  8110. + if (mUiccCard == null) {
  8111. + setExternalState(State.NOT_READY, appId);
  8112. + return;
  8113. + } else if (mUiccCard.getCardState() == CardState.CARDSTATE_ABSENT) {
  8114. + setExternalState(State.ABSENT, appId);
  8115. + return;
  8116. + }
  8117. +
  8118. + if (DBG) log("CardState = " + mUiccCard.getCardState());
  8119. +
  8120. + if (mUiccCard.getCardState() == CardState.CARDSTATE_ERROR ||
  8121. + mUiccApplication[appId] == null) {
  8122. + setExternalState(State.UNKNOWN, appId);
  8123. + return;
  8124. + }
  8125. +
  8126. + if (DBG) log("application state = " + mUiccApplication[appId].getState());
  8127. + if (DBG) log("mUiccApplication[appId] = " + mUiccApplication[appId]);
  8128. +
  8129. + switch (mUiccApplication[appId].getState()) {
  8130. + case APPSTATE_UNKNOWN:
  8131. + case APPSTATE_DETECTED:
  8132. + setExternalState(State.UNKNOWN, appId);
  8133. + break;
  8134. + case APPSTATE_READY:
  8135. + setExternalState(State.READY, appId);
  8136. + break;
  8137. + }
  8138. + }
  8139. +
  8140. + private void registerUiccCardEvents(int appId) {
  8141. + Integer aid = new Integer(appId);
  8142. + if (mUiccApplication[appId] != null) {
  8143. + mUiccApplication[appId].registerForReady(this, EVENT_APP_READY, (Object) aid);
  8144. + }
  8145. + if (mIccRecords[appId] != null) {
  8146. + mIccRecords[appId].registerForRecordsLoaded(this, EVENT_RECORDS_LOADED, (Object) aid);
  8147. + }
  8148. + }
  8149. +
  8150. + private void unregisterUiccCardEvents(int appId) {
  8151. + if (mUiccApplication[appId] != null) mUiccApplication[appId].unregisterForReady(this);
  8152. + if (mIccRecords[appId] != null) mIccRecords[appId].unregisterForRecordsLoaded(this);
  8153. + }
  8154. +
  8155. + private void broadcastIccStateChangedIntent(String value, String reason, int appId) {
  8156. + synchronized (mLock) {
  8157. +
  8158. + Intent intent = new Intent(TelephonyIntents.ACTION_SIM_STATE_CHANGED_MULTI_APPLICATION);
  8159. + intent.putExtra(PhoneConstants.PHONE_NAME_KEY, "Phone");
  8160. + intent.putExtra(IccCardConstants.INTENT_KEY_ICC_STATE, value);
  8161. + intent.putExtra(IccCardConstants.INTENT_KEY_LOCKED_REASON, reason);
  8162. + // FIXME: putPhoneIdAndSubIdExtra is phone based API, slot id might not equal to phone id.
  8163. + SubscriptionManager.putPhoneIdAndSubIdExtra(intent, mSlotId);
  8164. + intent.putExtra("appId", appId);
  8165. + if (DBG) log("Broadcasting intent ACTION_SIM_STATE_CHANGED_MULTI_APPLICATION " + value
  8166. + + " reason " + reason + " slotd id " + mSlotId + " app id " + appId);
  8167. + ActivityManagerNative.broadcastStickyIntent(intent, READ_PHONE_STATE,
  8168. + UserHandle.USER_ALL);
  8169. + }
  8170. + }
  8171. +
  8172. + private void setExternalState(State newState, boolean override, int appId) {
  8173. + synchronized (mLock) {
  8174. + if (DBG) log("setExternalState(): mExternalState = " + mExternalState[appId] +
  8175. + " newState = " + newState + " override = " + override);
  8176. +
  8177. + if (!override && newState == mExternalState[appId]) {
  8178. + return;
  8179. + }
  8180. +
  8181. + mExternalState[appId] = newState;
  8182. +
  8183. + broadcastIccStateChangedIntent(getIccStateIntentString(mExternalState[appId]),
  8184. + getIccStateReason(mExternalState[appId], appId), appId);
  8185. + }
  8186. + }
  8187. +
  8188. + private void setExternalState(State newState, int appId) {
  8189. + if (DBG) log("setExternalState(): newState = " + newState + "appId = " + appId);
  8190. + setExternalState(newState, false, appId);
  8191. + }
  8192. +
  8193. + private String getIccStateIntentString(State state) {
  8194. + switch (state) {
  8195. + case ABSENT: return IccCardConstants.INTENT_VALUE_ICC_ABSENT;
  8196. + case PIN_REQUIRED: return IccCardConstants.INTENT_VALUE_ICC_LOCKED;
  8197. + case PUK_REQUIRED: return IccCardConstants.INTENT_VALUE_ICC_LOCKED;
  8198. + case PERSO_LOCKED: return IccCardConstants.INTENT_VALUE_ICC_LOCKED;
  8199. + case READY: return IccCardConstants.INTENT_VALUE_ICC_READY;
  8200. + case NOT_READY: return IccCardConstants.INTENT_VALUE_ICC_NOT_READY;
  8201. + case PERM_DISABLED: return IccCardConstants.INTENT_VALUE_ICC_LOCKED;
  8202. + default: return IccCardConstants.INTENT_VALUE_ICC_UNKNOWN;
  8203. + }
  8204. + }
  8205. +
  8206. + /**
  8207. + * Locked state have a reason (PIN, PUK, NETWORK, PERM_DISABLED)
  8208. + * @return reason
  8209. + */
  8210. + private String getIccStateReason(State state, int appId) {
  8211. + switch (state) {
  8212. + case PIN_REQUIRED: return IccCardConstants.INTENT_VALUE_LOCKED_ON_PIN;
  8213. + case PUK_REQUIRED: return IccCardConstants.INTENT_VALUE_LOCKED_ON_PUK;
  8214. + case PERSO_LOCKED:
  8215. + switch (mUiccApplication[appId].getPersoSubState()) {
  8216. + case PERSOSUBSTATE_SIM_NETWORK: return IccCardConstants.INTENT_VALUE_LOCKED_NETWORK;
  8217. + case PERSOSUBSTATE_SIM_NETWORK_SUBSET: return IccCardConstants.INTENT_VALUE_LOCKED_NETWORK_SUBSET;
  8218. + case PERSOSUBSTATE_SIM_CORPORATE: return IccCardConstants.INTENT_VALUE_LOCKED_CORPORATE;
  8219. + case PERSOSUBSTATE_SIM_SERVICE_PROVIDER: return IccCardConstants.INTENT_VALUE_LOCKED_SERVICE_PROVIDER;
  8220. + case PERSOSUBSTATE_SIM_SIM: return IccCardConstants.INTENT_VALUE_LOCKED_SIM;
  8221. + default: return null;
  8222. + }
  8223. + case PERM_DISABLED: return IccCardConstants.INTENT_VALUE_ABSENT_ON_PERM_DISABLED;
  8224. + default: return null;
  8225. + }
  8226. + }
  8227. +
  8228. + /* IccCard interface implementation */
  8229. + // TODO: MTK use ICS solution, there is only three state, radio.on, radio.off, radio.not.available
  8230. +
  8231. + public State getState(int appId) {
  8232. + synchronized (mLock) {
  8233. + return mExternalState[appId];
  8234. + }
  8235. + }
  8236. +
  8237. +
  8238. + public IccRecords getIccRecords(int family) {
  8239. + int appId = -1;
  8240. + synchronized (mLock) {
  8241. + switch (family) {
  8242. + case UiccController.APP_FAM_IMS:
  8243. + appId = 0;
  8244. + break;
  8245. + default:
  8246. + if (DBG) log("Not Support");
  8247. + break;
  8248. + }
  8249. +
  8250. + if (appId != -1) {
  8251. + return mIccRecords[appId];
  8252. + } else {
  8253. + return null;
  8254. + }
  8255. + }
  8256. + }
  8257. +
  8258. + public IccFileHandler getIccFileHandler(int appId) {
  8259. + synchronized (mLock) {
  8260. + if (mUiccApplication[appId] != null) {
  8261. + return mUiccApplication[appId].getIccFileHandler();
  8262. + }
  8263. + return null;
  8264. + }
  8265. + }
  8266. +
  8267. + private Integer getIndex(Message msg) {
  8268. + AsyncResult ar;
  8269. + // FIXME: PhoneConstants.DEFAULT_CARD_INDEX will be changed?
  8270. + Integer index = new Integer(PhoneConstants.DEFAULT_CARD_INDEX);
  8271. +
  8272. + /*
  8273. + * The events can be come in two ways. By explicitly sending it using
  8274. + * sendMessage, in this case the user object passed is msg.obj and from
  8275. + * the CommandsInterface, in this case the user object is msg.obj.userObj
  8276. + */
  8277. + if (msg != null) {
  8278. + if (msg.obj != null && msg.obj instanceof Integer) {
  8279. + index = (Integer) msg.obj;
  8280. + } else if (msg.obj != null && msg.obj instanceof AsyncResult) {
  8281. + ar = (AsyncResult) msg.obj;
  8282. + if (ar.userObj != null && ar.userObj instanceof Integer) {
  8283. + index = (Integer) ar.userObj;
  8284. + }
  8285. + }
  8286. + }
  8287. + return index;
  8288. + }
  8289. +
  8290. +
  8291. + private void log(String msg) {
  8292. + Rlog.d(LOG_TAG, "[SIM" + (mSlotId == 0 ? "1" : "2") + "] " + msg);
  8293. + }
  8294. +
  8295. + private void loge(String msg) {
  8296. + Rlog.e(LOG_TAG, "[SIM" + (mSlotId == 0 ? "1" : "2") + "] " + msg);
  8297. + }
  8298. +}
  8299. diff --git a/src/java/com/mediatek/internal/telephony/worldphone/IWorldPhone.java b/src/java/com/mediatek/internal/telephony/worldphone/IWorldPhone.java
  8300. new file mode 100755
  8301. index 0000000..94b065e
  8302. --- /dev/null
  8303. +++ b/src/java/com/mediatek/internal/telephony/worldphone/IWorldPhone.java
  8304. @@ -0,0 +1,86 @@
  8305. +/* Copyright Statement:
  8306. + *
  8307. + * This software/firmware and related documentation ("MediaTek Software") are
  8308. + * protected under relevant copyright laws. The information contained herein
  8309. + * is confidential and proprietary to MediaTek Inc. and/or its licensors.
  8310. + * Without the prior written permission of MediaTek inc. and/or its licensors,
  8311. + * any reproduction, modification, use or disclosure of MediaTek Software,
  8312. + * and information contained herein, in whole or in part, shall be strictly prohibited.
  8313. + *
  8314. + * MediaTek Inc. (C) 2010. All rights reserved.
  8315. + *
  8316. + * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  8317. + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  8318. + * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
  8319. + * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  8320. + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  8321. + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  8322. + * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  8323. + * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  8324. + * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
  8325. + * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
  8326. + * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
  8327. + * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
  8328. + * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  8329. + * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
  8330. + * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  8331. + * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  8332. + * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
  8333. + * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  8334. + *
  8335. + * The following software/firmware and/or related documentation ("MediaTek Software")
  8336. + * have been modified by MediaTek Inc. All revisions are subject to any receiver's
  8337. + * applicable license agreements with MediaTek Inc.
  8338. + */
  8339. +package com.mediatek.internal.telephony.worldphone;
  8340. +
  8341. +public interface IWorldPhone {
  8342. + public static final String LOG_TAG = "PHONE";
  8343. +
  8344. + public static final int POLICY_OM = 0;
  8345. + public static final int POLICY_OP01 = 1;
  8346. +
  8347. + static final int SELECTION_MODE_MANUAL = 0;
  8348. + static final int SELECTION_MODE_AUTO = 1;
  8349. +
  8350. + static final int UNKNOWN_USER = 0;
  8351. + static final int TYPE1_USER = 1;
  8352. + static final int TYPE2_USER = 2;
  8353. + static final int TYPE3_USER = 3;
  8354. +
  8355. + static final int REGION_UNKNOWN = 0;
  8356. + static final int REGION_DOMESTIC = 1;
  8357. + static final int REGION_FOREIGN = 2;
  8358. +
  8359. + static final int EVENT_RADIO_ON_1 = 0;
  8360. + static final int EVENT_RADIO_ON_2 = 1;
  8361. + static final int EVENT_REG_PLMN_CHANGED_1 = 10;
  8362. + static final int EVENT_REG_PLMN_CHANGED_2 = 11;
  8363. + static final int EVENT_REG_SUSPENDED_1 = 30;
  8364. + static final int EVENT_REG_SUSPENDED_2 = 31;
  8365. + static final int EVENT_STORE_MODEM_TYPE = 40;
  8366. + static final int EVENT_QUERY_MODEM_TYPE = 50;
  8367. + static final int EVENT_INVALID_SIM_NOTIFY_1 = 60;
  8368. + static final int EVENT_INVALID_SIM_NOTIFY_2 = 61;
  8369. +
  8370. + static final int DEFAULT_MAJOR_SIM = 0;
  8371. + static final int MAJOR_CAPABILITY_OFF = -1;
  8372. + static final int AUTO_SWITCH_OFF = -98;
  8373. + static final int MAJOR_SIM_UNKNOWN = -99;
  8374. +
  8375. + static final int CAMP_ON_NOT_DENIED = 0;
  8376. + static final int CAMP_ON_DENY_REASON_UNKNOWN = 1;
  8377. + static final int CAMP_ON_DENY_REASON_NEED_SWITCH_TO_FDD = 2;
  8378. + static final int CAMP_ON_DENY_REASON_NEED_SWITCH_TO_TDD = 3;
  8379. + static final int CAMP_ON_DENY_REASON_DOMESTIC_FDD_MD = 4;
  8380. +
  8381. + static final int ICC_CARD_TYPE_UNKNOWN = 0;
  8382. + static final int ICC_CARD_TYPE_SIM = 1;
  8383. + static final int ICC_CARD_TYPE_USIM = 2;
  8384. +
  8385. + static final String NO_OP = "OM";
  8386. + static final String ACTION_SHUTDOWN_IPO = "android.intent.action.ACTION_SHUTDOWN_IPO";
  8387. + static final String ACTION_ADB_SWITCH_MODEM = "android.intent.action.ACTION_ADB_SWITCH_MODEM";
  8388. +
  8389. + public void setModemSelectionMode(int mode, int modemType);
  8390. +}
  8391. diff --git a/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneOm.java b/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneOm.java
  8392. new file mode 100755
  8393. index 0000000..c517ad8
  8394. --- /dev/null
  8395. +++ b/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneOm.java
  8396. @@ -0,0 +1,912 @@
  8397. +/* Copyright Statement:
  8398. + *
  8399. + * This software/firmware and related documentation ("MediaTek Software") are
  8400. + * protected under relevant copyright laws. The information contained herein
  8401. + * is confidential and proprietary to MediaTek Inc. and/or its licensors.
  8402. + * Without the prior written permission of MediaTek inc. and/or its licensors,
  8403. + * any reproduction, modification, use or disclosure of MediaTek Software,
  8404. + * and information contained herein, in whole or in part, shall be strictly prohibited.
  8405. + *
  8406. + * MediaTek Inc. (C) 2010. All rights reserved.
  8407. + *
  8408. + * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  8409. + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  8410. + * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
  8411. + * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  8412. + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  8413. + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  8414. + * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  8415. + * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  8416. + * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
  8417. + * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
  8418. + * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
  8419. + * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
  8420. + * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  8421. + * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
  8422. + * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  8423. + * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  8424. + * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
  8425. + * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  8426. + *
  8427. + * The following software/firmware and/or related documentation ("MediaTek Software")
  8428. + * have been modified by MediaTek Inc. All revisions are subject to any receiver's
  8429. + * applicable license agreements with MediaTek Inc.
  8430. + */
  8431. +package com.mediatek.internal.telephony.worldphone;
  8432. +
  8433. +import android.content.BroadcastReceiver;
  8434. +import android.content.Context;
  8435. +import android.content.Intent;
  8436. +import android.content.IntentFilter;
  8437. +import android.os.AsyncResult;
  8438. +import android.os.Handler;
  8439. +import android.os.Message;
  8440. +import android.os.SystemProperties;
  8441. +import android.provider.Settings;
  8442. +import android.telephony.ServiceState;
  8443. +import android.telephony.Rlog;
  8444. +
  8445. +import com.android.internal.telephony.CommandsInterface;
  8446. +import com.android.internal.telephony.IccCardConstants;
  8447. +import com.android.internal.telephony.Phone;
  8448. +import com.android.internal.telephony.PhoneBase;
  8449. +import com.android.internal.telephony.PhoneConstants;
  8450. +import com.android.internal.telephony.PhoneFactory;
  8451. +import com.android.internal.telephony.PhoneProxy;
  8452. +import com.android.internal.telephony.TelephonyIntents;
  8453. +import com.android.internal.telephony.uicc.IccRecords;
  8454. +import com.android.internal.telephony.uicc.UiccController;
  8455. +
  8456. +import com.mediatek.internal.telephony.ModemSwitchHandler;
  8457. +
  8458. +/**
  8459. + *@hide
  8460. + */
  8461. +public class WorldPhoneOm extends Handler implements IWorldPhone {
  8462. + private static Object sLock = new Object();
  8463. + private static final int PROJECT_SIM_NUM = WorldPhoneUtil.getProjectSimNum();
  8464. + private static final int[] FDD_STANDBY_TIMER = {
  8465. + 60
  8466. + };
  8467. + private static final int[] TDD_STANDBY_TIMER = {
  8468. + 40
  8469. + };
  8470. + private static final String[] PLMN_TABLE_TYPE1 = {
  8471. + "46000", "46002", "46007", "46008", "46011"
  8472. + };
  8473. + private static final String[] PLMN_TABLE_TYPE3 = {
  8474. + "46001", "46006", "46009", "45407",
  8475. + "46003", "46005", "45502"
  8476. + };
  8477. + private static final String[] MCC_TABLE_DOMESTIC = {
  8478. + "460"
  8479. + };
  8480. +
  8481. + private static Context sContext = null;
  8482. + private static Phone sDefultPhone = null;
  8483. + private static Phone[] sProxyPhones = null;
  8484. + private static Phone[] sActivePhones = new Phone[PROJECT_SIM_NUM];
  8485. + private static CommandsInterface[] sCi = new CommandsInterface[PROJECT_SIM_NUM];
  8486. + private static String sOperatorSpec;
  8487. + private static String sPlmnSs;
  8488. + private static String sLastPlmn;
  8489. + private static String[] sImsi = new String[PROJECT_SIM_NUM];
  8490. + private static String[] sNwPlmnStrings;
  8491. + private static int sVoiceRegState;
  8492. + private static int sDataRegState;
  8493. + // private static int sRilVoiceRegState;
  8494. + // private static int sRilDataRegState;
  8495. + private static int sRilVoiceRadioTechnology;
  8496. + private static int sRilDataRadioTechnology;
  8497. + private static int sUserType;
  8498. + private static int sRegion;
  8499. + private static int sDenyReason;
  8500. + private static int sSuspendId;
  8501. + private static int sMajorSim;
  8502. + private static int sDefaultBootUpModem = ModemSwitchHandler.MD_TYPE_UNKNOWN;
  8503. + private static int[] sIccCardType = new int[PROJECT_SIM_NUM];
  8504. + private static boolean sVoiceCapable;
  8505. + private static boolean[] sIsInvalidSim = new boolean[PROJECT_SIM_NUM];
  8506. + private static boolean[] sSuspendWaitImsi = new boolean[PROJECT_SIM_NUM];
  8507. + private static boolean[] sFirstSelect = new boolean[PROJECT_SIM_NUM];
  8508. + private static UiccController sUiccController = null;
  8509. + private static IccRecords[] sIccRecordsInstance = new IccRecords[PROJECT_SIM_NUM];
  8510. + private static ServiceState sServiceState;
  8511. + private static ModemSwitchHandler sModemSwitchHandler = null;
  8512. + private static int sTddStandByCounter;
  8513. + private static int sFddStandByCounter;
  8514. + private static boolean sWaitInTdd;
  8515. + private static boolean sWaitInFdd;
  8516. +
  8517. + public WorldPhoneOm() {
  8518. + logd("Constructor invoked");
  8519. + sOperatorSpec = SystemProperties.get("ro.operator.optr", NO_OP);
  8520. + logd("Operator Spec:" + sOperatorSpec);
  8521. + sDefultPhone = PhoneFactory.getDefaultPhone();
  8522. + sProxyPhones = PhoneFactory.getPhones();
  8523. + for (int i = 0; i < PROJECT_SIM_NUM; i++) {
  8524. + sActivePhones[i] = ((PhoneProxy) sProxyPhones[i]).getActivePhone();
  8525. + sCi[i] = ((PhoneBase) sActivePhones[i]).mCi;
  8526. + }
  8527. + for (int i = 0; i < PROJECT_SIM_NUM; i++) {
  8528. + sCi[i].setOnPlmnChangeNotification(this, EVENT_REG_PLMN_CHANGED_1 + i, null);
  8529. + sCi[i].setOnRegistrationSuspended(this, EVENT_REG_SUSPENDED_1 + i, null);
  8530. + sCi[i].registerForOn(this, EVENT_RADIO_ON_1 + i, null);
  8531. + // sCi[i].setInvalidSimInfo(this, EVENT_INVALID_SIM_NOTIFY_1 + i, null);
  8532. + }
  8533. +
  8534. + sModemSwitchHandler = new ModemSwitchHandler();
  8535. + logd(ModemSwitchHandler.modemToString(ModemSwitchHandler.getActiveModemType()));
  8536. +
  8537. + IntentFilter intentFilter = new IntentFilter(TelephonyIntents.ACTION_SIM_STATE_CHANGED);
  8538. + intentFilter.addAction(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED);
  8539. + intentFilter.addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED);
  8540. + intentFilter.addAction(ACTION_SHUTDOWN_IPO);
  8541. + intentFilter.addAction(ACTION_ADB_SWITCH_MODEM);
  8542. + intentFilter.addAction(TelephonyIntents.ACTION_SET_PHONE_RAT_FAMILY_DONE);
  8543. + if (sDefultPhone != null) {
  8544. + sContext = sDefultPhone.getContext();
  8545. + } else {
  8546. + logd("DefaultPhone = null");
  8547. + }
  8548. + sVoiceCapable = sContext.getResources().getBoolean(com.android.internal.R.bool.config_voice_capable);
  8549. + sContext.registerReceiver(mWorldPhoneReceiver, intentFilter);
  8550. +
  8551. + sTddStandByCounter = 0;
  8552. + sFddStandByCounter = 0;
  8553. + sWaitInTdd = false;
  8554. + sWaitInFdd = false;
  8555. + sRegion = REGION_UNKNOWN;
  8556. + sLastPlmn = null;
  8557. + resetAllProperties();
  8558. + if (WorldPhoneUtil.getModemSelectionMode() == SELECTION_MODE_MANUAL) {
  8559. + logd("Auto select disable");
  8560. + sMajorSim = AUTO_SWITCH_OFF;
  8561. + // Settings.Global.putInt(sContext.getContentResolver(),
  8562. + // Settings.Global.WORLD_PHONE_AUTO_SELECT_MODE, SELECTION_MODE_MANUAL);
  8563. + } else {
  8564. + logd("Auto select enable");
  8565. + // Settings.Global.putInt(sContext.getContentResolver(),
  8566. + // Settings.Global.WORLD_PHONE_AUTO_SELECT_MODE, SELECTION_MODE_AUTO);
  8567. + }
  8568. + // FDD_STANDBY_TIMER[sFddStandByCounter] = Settings.Global.getInt(
  8569. + // sContext.getContentResolver(), Settings.Global.WORLD_PHONE_FDD_MODEM_TIMER, FDD_STANDBY_TIMER[sFddStandByCounter]);
  8570. + // Settings.Global.putInt(sContext.getContentResolver(),
  8571. + // Settings.Global.WORLD_PHONE_FDD_MODEM_TIMER, FDD_STANDBY_TIMER[sFddStandByCounter]);
  8572. + logd("FDD_STANDBY_TIMER = " + FDD_STANDBY_TIMER[sFddStandByCounter] + "s");
  8573. + logd("sDefaultBootUpModem = " + sDefaultBootUpModem);
  8574. + }
  8575. +
  8576. + private final BroadcastReceiver mWorldPhoneReceiver = new BroadcastReceiver() {
  8577. + public void onReceive(Context context, Intent intent) {
  8578. + logd("[Receiver]+");
  8579. + String action = intent.getAction();
  8580. + logd("Action: " + action);
  8581. + int slotId;
  8582. + if (action.equals(TelephonyIntents.ACTION_SIM_STATE_CHANGED)) {
  8583. + String simStatus = intent.getStringExtra(IccCardConstants.INTENT_KEY_ICC_STATE);
  8584. + slotId = intent.getIntExtra(PhoneConstants.SLOT_KEY, PhoneConstants.SIM_ID_1);
  8585. + logd("slotId: " + slotId + " simStatus: " + simStatus);
  8586. + if (simStatus.equals(IccCardConstants.INTENT_VALUE_ICC_IMSI)) {
  8587. + if (sMajorSim == MAJOR_SIM_UNKNOWN) {
  8588. + sMajorSim = WorldPhoneUtil.getMajorSim();
  8589. + }
  8590. + sUiccController = UiccController.getInstance();
  8591. + if (sUiccController != null) {
  8592. + sIccRecordsInstance[slotId] = sUiccController.getIccRecords(slotId, UiccController.APP_FAM_3GPP);
  8593. + } else {
  8594. + logd("Null sUiccController");
  8595. + return;
  8596. + }
  8597. + if (sIccRecordsInstance[slotId] != null) {
  8598. + sImsi[slotId] = sIccRecordsInstance[slotId].getIMSI();
  8599. + } else {
  8600. + logd("Null sIccRecordsInstance");
  8601. + return;
  8602. + }
  8603. + sIccCardType[slotId] = getIccCardType(slotId);
  8604. + logd("sImsi[" + slotId + "]:" + sImsi[slotId]);
  8605. + if (slotId == sMajorSim) {
  8606. + logd("Major SIM");
  8607. + sUserType = getUserType(sImsi[slotId]);
  8608. + if (sFirstSelect[slotId]) {
  8609. + sFirstSelect[slotId] = false;
  8610. + if (sUserType == TYPE1_USER) {
  8611. + if (sRegion == REGION_DOMESTIC) {
  8612. + handleSwitchModem(ModemSwitchHandler.MD_TYPE_TDD);
  8613. + } else if (sRegion == REGION_FOREIGN) {
  8614. + handleSwitchModem(ModemSwitchHandler.MD_TYPE_FDD);
  8615. + } else {
  8616. + logd("Region unknown");
  8617. + }
  8618. + } else if (sUserType == TYPE2_USER || sUserType == TYPE3_USER) {
  8619. + handleSwitchModem(ModemSwitchHandler.MD_TYPE_FDD);
  8620. + }
  8621. + }
  8622. + if (sSuspendWaitImsi[slotId]) {
  8623. + sSuspendWaitImsi[slotId] = false;
  8624. + logd("IMSI fot slot" + slotId + " now ready, resuming PLMN:"
  8625. + + sNwPlmnStrings[0] + " with ID:" + sSuspendId);
  8626. + resumeCampingProcedure(slotId);
  8627. + }
  8628. + } else {
  8629. + logd("Not major SIM");
  8630. + getUserType(sImsi[slotId]);
  8631. + }
  8632. + } else if (simStatus.equals(IccCardConstants.INTENT_VALUE_ICC_ABSENT)) {
  8633. + sLastPlmn = null;
  8634. + sImsi[slotId] = "";
  8635. + sFirstSelect[slotId] = true;
  8636. + sIsInvalidSim[slotId] = false;
  8637. + sSuspendWaitImsi[slotId] = false;
  8638. + sIccCardType[slotId] = ICC_CARD_TYPE_UNKNOWN;
  8639. + if (slotId == sMajorSim) {
  8640. + logd("Major SIM removed, no world phone service");
  8641. + removeModemStandByTimer();
  8642. + sUserType = UNKNOWN_USER;
  8643. + sDenyReason = CAMP_ON_DENY_REASON_UNKNOWN;
  8644. + sMajorSim = MAJOR_SIM_UNKNOWN;
  8645. + } else {
  8646. + logd("SIM" + slotId + " is not major SIM");
  8647. + }
  8648. + }
  8649. + } else if (action.equals(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED)) {
  8650. + sServiceState = ServiceState.newFromBundle(intent.getExtras());
  8651. + if (sServiceState != null) {
  8652. + slotId = intent.getIntExtra(PhoneConstants.SLOT_KEY, PhoneConstants.SIM_ID_1);
  8653. + sPlmnSs = sServiceState.getOperatorNumeric();
  8654. + sVoiceRegState = sServiceState.getVoiceRegState();
  8655. + // sRilVoiceRegState = sServiceState.getRilVoiceRegState();
  8656. + sRilVoiceRadioTechnology = sServiceState.getRilVoiceRadioTechnology();
  8657. + sDataRegState = sServiceState.getDataRegState();
  8658. + // sRilDataRegState = sServiceState.getRilDataRegState();
  8659. + sRilDataRadioTechnology = sServiceState.getRilDataRadioTechnology();
  8660. + logd("slotId: " + slotId + ", " + WorldPhoneUtil.iccCardTypeToString(sIccCardType[slotId]));
  8661. + logd("sMajorSim: " + sMajorSim);
  8662. + logd(ModemSwitchHandler.modemToString(ModemSwitchHandler.getActiveModemType()));
  8663. + logd("sPlmnSs: " + sPlmnSs);
  8664. + logd("sVoiceRegState: " + WorldPhoneUtil.stateToString(sVoiceRegState));
  8665. + // logd("sRilVoiceRegState: " + WorldPhoneUtil.regStateToString(sRilVoiceRegState));
  8666. + logd("sRilVoiceRadioTech: " + sServiceState.rilRadioTechnologyToString(sRilVoiceRadioTechnology));
  8667. + logd("sDataRegState: " + WorldPhoneUtil.stateToString(sDataRegState));
  8668. + // logd("sRilDataRegState: " + WorldPhoneUtil.regStateToString(sRilDataRegState));
  8669. + logd("sRilDataRadioTech: " + sServiceState.rilRadioTechnologyToString(sRilDataRadioTechnology));
  8670. + if (slotId == sMajorSim) {
  8671. + if (isNoService()) {
  8672. + handleNoService();
  8673. + } else if (isInService()) {
  8674. + sLastPlmn = sPlmnSs;
  8675. + removeModemStandByTimer();
  8676. + }
  8677. + }
  8678. + } else {
  8679. + logd("Null sServiceState");
  8680. + }
  8681. + } else if (action.equals(ACTION_SHUTDOWN_IPO)) {
  8682. + if (sDefaultBootUpModem == ModemSwitchHandler.MD_TYPE_FDD) {
  8683. + if (WorldPhoneUtil.isLteSupport()) {
  8684. + ModemSwitchHandler.reloadModem(sCi[PhoneConstants.SIM_ID_1], ModemSwitchHandler.MD_TYPE_LWG);
  8685. + logd("Reload to FDD CSFB modem");
  8686. + } else {
  8687. + ModemSwitchHandler.reloadModem(sCi[PhoneConstants.SIM_ID_1], ModemSwitchHandler.MD_TYPE_WG);
  8688. + logd("Reload to WG modem");
  8689. + }
  8690. + } else if (sDefaultBootUpModem == ModemSwitchHandler.MD_TYPE_TDD) {
  8691. + if (WorldPhoneUtil.isLteSupport()) {
  8692. + ModemSwitchHandler.reloadModem(sCi[PhoneConstants.SIM_ID_1], ModemSwitchHandler.MD_TYPE_LTG);
  8693. + logd("Reload to TDD CSFB modem");
  8694. + } else {
  8695. + ModemSwitchHandler.reloadModem(sCi[PhoneConstants.SIM_ID_1], ModemSwitchHandler.MD_TYPE_TG);
  8696. + logd("Reload to TG modem");
  8697. + }
  8698. + }
  8699. + } else if (action.equals(ACTION_ADB_SWITCH_MODEM)) {
  8700. + int toModem = intent.getIntExtra(TelephonyIntents.EXTRA_MD_TYPE, ModemSwitchHandler.MD_TYPE_UNKNOWN);
  8701. + logd("toModem: " + toModem);
  8702. + if (toModem == ModemSwitchHandler.MD_TYPE_WG
  8703. + || toModem == ModemSwitchHandler.MD_TYPE_TG
  8704. + || toModem == ModemSwitchHandler.MD_TYPE_LWG
  8705. + || toModem == ModemSwitchHandler.MD_TYPE_LTG) {
  8706. + setModemSelectionMode(IWorldPhone.SELECTION_MODE_MANUAL, toModem);
  8707. + } else {
  8708. + setModemSelectionMode(IWorldPhone.SELECTION_MODE_AUTO, toModem);
  8709. + }
  8710. + } else if (action.equals(Intent.ACTION_AIRPLANE_MODE_CHANGED)) {
  8711. + if (intent.getBooleanExtra("state", false) == false) {
  8712. + logd("Leave flight mode");
  8713. + sLastPlmn = null;
  8714. + for (int i = 0; i < PROJECT_SIM_NUM; i++) {
  8715. + sIsInvalidSim[i] = false;
  8716. + }
  8717. + } else {
  8718. + logd("Enter flight mode");
  8719. + for (int i = 0; i < PROJECT_SIM_NUM; i++) {
  8720. + sFirstSelect[i] = true;
  8721. + }
  8722. + }
  8723. + } else if (action.equals(TelephonyIntents.ACTION_SET_PHONE_RAT_FAMILY_DONE)) {
  8724. + if (sMajorSim != AUTO_SWITCH_OFF) {
  8725. + sMajorSim = WorldPhoneUtil.getMajorSim();
  8726. + }
  8727. + handleSimSwitched();
  8728. + }
  8729. + logd("[Receiver]-");
  8730. + }
  8731. + };
  8732. +
  8733. + public void handleMessage(Message msg) {
  8734. + AsyncResult ar = (AsyncResult) msg.obj;
  8735. + switch (msg.what) {
  8736. + case EVENT_RADIO_ON_1:
  8737. + logd("handleMessage : <EVENT_RADIO_ON>");
  8738. + handleRadioOn(PhoneConstants.SIM_ID_1);
  8739. + break;
  8740. + case EVENT_REG_PLMN_CHANGED_1:
  8741. + logd("handleMessage : <EVENT_REG_PLMN_CHANGED>");
  8742. + handlePlmnChange(ar, PhoneConstants.SIM_ID_1);
  8743. + break;
  8744. + case EVENT_REG_SUSPENDED_1:
  8745. + logd("handleMessage : <EVENT_REG_SUSPENDED>");
  8746. + handleRegistrationSuspend(ar, PhoneConstants.SIM_ID_1);
  8747. + break;
  8748. + case EVENT_RADIO_ON_2:
  8749. + logd("handleMessage : <EVENT_RADIO_ON>");
  8750. + handleRadioOn(PhoneConstants.SIM_ID_2);
  8751. + break;
  8752. + case EVENT_REG_PLMN_CHANGED_2:
  8753. + logd("handleMessage : <EVENT_REG_PLMN_CHANGED>");
  8754. + handlePlmnChange(ar, PhoneConstants.SIM_ID_2);
  8755. + break;
  8756. + case EVENT_REG_SUSPENDED_2:
  8757. + logd("handleMessage : <EVENT_REG_SUSPENDED>");
  8758. + handleRegistrationSuspend(ar, PhoneConstants.SIM_ID_2);
  8759. + break;
  8760. + case EVENT_INVALID_SIM_NOTIFY_1:
  8761. + logd("handleMessage : <EVENT_INVALID_SIM_NOTIFY>");
  8762. + handleInvalidSimNotify(PhoneConstants.SIM_ID_1, ar);
  8763. + break;
  8764. + case EVENT_INVALID_SIM_NOTIFY_2:
  8765. + logd("handleMessage : <EVENT_INVALID_SIM_NOTIFY>");
  8766. + handleInvalidSimNotify(PhoneConstants.SIM_ID_2, ar);
  8767. + break;
  8768. + default:
  8769. + logd("Unknown msg:" + msg.what);
  8770. + }
  8771. + }
  8772. +
  8773. + private void handleRadioOn(int slotId) {
  8774. + logd("Slot" + slotId);
  8775. + if (sMajorSim == MAJOR_SIM_UNKNOWN) {
  8776. + sMajorSim = WorldPhoneUtil.getMajorSim();
  8777. + }
  8778. + }
  8779. +
  8780. + private void handlePlmnChange(AsyncResult ar, int slotId) {
  8781. + logd("Slot" + slotId);
  8782. + if (sMajorSim == MAJOR_SIM_UNKNOWN) {
  8783. + sMajorSim = WorldPhoneUtil.getMajorSim();
  8784. + }
  8785. + if (ar.exception == null && ar.result != null) {
  8786. + String[] plmnString = (String[]) ar.result;
  8787. + if (slotId == sMajorSim) {
  8788. + sNwPlmnStrings = plmnString;
  8789. + }
  8790. + for (int i = 0; i < plmnString.length; i++) {
  8791. + logd("plmnString[" + i + "]=" + plmnString[i]);
  8792. + }
  8793. + if (sMajorSim == slotId && sUserType == TYPE1_USER
  8794. + && sDenyReason != CAMP_ON_DENY_REASON_NEED_SWITCH_TO_FDD) {
  8795. + searchForDesignateService(plmnString[0]);
  8796. + }
  8797. + // To speed up performance in foreign countries, once get PLMN(no matter which slot)
  8798. + // determine region right away and switch modem type if needed
  8799. + sRegion = getRegion(plmnString[0]);
  8800. + if (sUserType != TYPE3_USER && sRegion == REGION_FOREIGN
  8801. + && sMajorSim != AUTO_SWITCH_OFF && sMajorSim != MAJOR_CAPABILITY_OFF) {
  8802. + handleSwitchModem(ModemSwitchHandler.MD_TYPE_FDD);
  8803. + }
  8804. + } else {
  8805. + logd("AsyncResult is wrong " + ar.exception);
  8806. + }
  8807. + }
  8808. +
  8809. + private void handleRegistrationSuspend(AsyncResult ar, int slotId) {
  8810. + logd("Slot" + slotId);
  8811. + if (ar.exception == null && ar.result != null) {
  8812. + sSuspendId = ((int[]) ar.result)[0];
  8813. + logd("Suspending with Id=" + sSuspendId);
  8814. + if (sMajorSim == slotId) {
  8815. + if (sUserType != UNKNOWN_USER) {
  8816. + resumeCampingProcedure(slotId);
  8817. + } else {
  8818. + sSuspendWaitImsi[slotId] = true;
  8819. + logd("User type unknown, wait for IMSI");
  8820. + }
  8821. + } else {
  8822. + logd("Not major slot, camp on OK");
  8823. + sCi[slotId].setResumeRegistration(sSuspendId, null);
  8824. + }
  8825. + } else {
  8826. + logd("AsyncResult is wrong " + ar.exception);
  8827. + }
  8828. + }
  8829. +
  8830. + private void handleInvalidSimNotify(int slotId, AsyncResult ar) {
  8831. + logd("Slot" + slotId);
  8832. + if (ar.exception == null && ar.result != null) {
  8833. + String[] invalidSimInfo = (String[]) ar.result;
  8834. + String plmn = invalidSimInfo[0];
  8835. + int cs_invalid = Integer.parseInt(invalidSimInfo[1]);
  8836. + int ps_invalid = Integer.parseInt(invalidSimInfo[2]);
  8837. + int cause = Integer.parseInt(invalidSimInfo[3]);
  8838. + int testMode = -1;
  8839. + testMode = SystemProperties.getInt("gsm.gcf.testmode", 0);
  8840. + if (testMode != 0) {
  8841. + logd("Invalid SIM notified during test mode: " + testMode);
  8842. + return;
  8843. + }
  8844. + logd("testMode:" + testMode + ", cause: " + cause + ", cs_invalid: " + cs_invalid + ", ps_invalid: " + ps_invalid + ", plmn: " + plmn);
  8845. + if (sVoiceCapable && cs_invalid == 1) {
  8846. + if (sLastPlmn == null) {
  8847. + logd("CS reject, invalid SIM");
  8848. + sIsInvalidSim[slotId] = true;
  8849. + return;
  8850. + }
  8851. + }
  8852. + if (ps_invalid == 1) {
  8853. + if (sLastPlmn == null) {
  8854. + logd("PS reject, invalid SIM");
  8855. + sIsInvalidSim[slotId] = true;
  8856. + return;
  8857. + }
  8858. + }
  8859. + } else {
  8860. + logd("AsyncResult is wrong " + ar.exception);
  8861. + }
  8862. + }
  8863. +
  8864. + private void handleSwitchModem(int toModem) {
  8865. + if (sIsInvalidSim[WorldPhoneUtil.getMajorSim()]
  8866. + && WorldPhoneUtil.getModemSelectionMode() == SELECTION_MODE_AUTO) {
  8867. + logd("Invalid SIM, switch not executed!");
  8868. + return;
  8869. + }
  8870. + if (toModem == ModemSwitchHandler.MD_TYPE_TDD) {
  8871. + if (WorldPhoneUtil.isLteSupport()) {
  8872. + toModem = ModemSwitchHandler.MD_TYPE_LTG;
  8873. + } else {
  8874. + toModem = ModemSwitchHandler.MD_TYPE_TG;
  8875. + }
  8876. + } else if (toModem == ModemSwitchHandler.MD_TYPE_FDD) {
  8877. + if (WorldPhoneUtil.isLteSupport()) {
  8878. + toModem = ModemSwitchHandler.MD_TYPE_LWG;
  8879. + } else {
  8880. + toModem = ModemSwitchHandler.MD_TYPE_WG;
  8881. + }
  8882. + }
  8883. + if (sMajorSim == AUTO_SWITCH_OFF) {
  8884. + logd("Storing modem type: " + toModem);
  8885. + sCi[PhoneConstants.SIM_ID_1].storeModemType(toModem, null);
  8886. + } else {
  8887. + if (sDefaultBootUpModem == ModemSwitchHandler.MD_TYPE_UNKNOWN) {
  8888. + logd("Storing modem type: " + toModem);
  8889. + sCi[PhoneConstants.SIM_ID_1].storeModemType(toModem, null);
  8890. + } else if (sDefaultBootUpModem == ModemSwitchHandler.MD_TYPE_FDD) {
  8891. + if (WorldPhoneUtil.isLteSupport()) {
  8892. + logd("Storing modem type: " + ModemSwitchHandler.MD_TYPE_WG);
  8893. + sCi[PhoneConstants.SIM_ID_1].storeModemType(ModemSwitchHandler.MD_TYPE_LWG, null);
  8894. + } else {
  8895. + logd("Storing modem type: " + ModemSwitchHandler.MD_TYPE_LWG);
  8896. + sCi[PhoneConstants.SIM_ID_1].storeModemType(ModemSwitchHandler.MD_TYPE_WG, null);
  8897. + }
  8898. + } else if (sDefaultBootUpModem == ModemSwitchHandler.MD_TYPE_TDD) {
  8899. + if (WorldPhoneUtil.isLteSupport()) {
  8900. + logd("Storing modem type: " + ModemSwitchHandler.MD_TYPE_WG);
  8901. + sCi[PhoneConstants.SIM_ID_1].storeModemType(ModemSwitchHandler.MD_TYPE_LTG, null);
  8902. + } else {
  8903. + logd("Storing modem type: " + ModemSwitchHandler.MD_TYPE_LWG);
  8904. + sCi[PhoneConstants.SIM_ID_1].storeModemType(ModemSwitchHandler.MD_TYPE_TG, null);
  8905. + }
  8906. + }
  8907. + }
  8908. + if (toModem == ModemSwitchHandler.getActiveModemType()) {
  8909. + if (toModem == ModemSwitchHandler.MD_TYPE_WG) {
  8910. + logd("Already in WG modem");
  8911. + } else if (toModem == ModemSwitchHandler.MD_TYPE_TG) {
  8912. + logd("Already in TG modem");
  8913. + } else if (toModem == ModemSwitchHandler.MD_TYPE_LWG) {
  8914. + logd("Already in FDD CSFB modem");
  8915. + } else if (toModem == ModemSwitchHandler.MD_TYPE_LTG) {
  8916. + logd("Already in TDD CSFB modem");
  8917. + }
  8918. + return;
  8919. + } else {
  8920. + for (int i = 0; i < PROJECT_SIM_NUM; i++) {
  8921. + if (sActivePhones[i].getState() != PhoneConstants.State.IDLE) {
  8922. + logd("Phone" + i + " is not idle, modem switch not allowed");
  8923. + return;
  8924. + }
  8925. + }
  8926. + removeModemStandByTimer();
  8927. + if (toModem == ModemSwitchHandler.MD_TYPE_WG) {
  8928. + logd("Switching to WG modem");
  8929. + } else if (toModem == ModemSwitchHandler.MD_TYPE_TG) {
  8930. + logd("Switching to TG modem");
  8931. + } else if (toModem == ModemSwitchHandler.MD_TYPE_LWG) {
  8932. + logd("Switching to FDD CSFB modem");
  8933. + } else if (toModem == ModemSwitchHandler.MD_TYPE_LTG) {
  8934. + logd("Switching to TDD CSFB modem");
  8935. + }
  8936. + ModemSwitchHandler.switchModem(toModem);
  8937. + resetNetworkProperties();
  8938. + }
  8939. + }
  8940. +
  8941. + private void handleSimSwitched() {
  8942. + if (sMajorSim == MAJOR_CAPABILITY_OFF) {
  8943. + logd("Major capability turned off");
  8944. + removeModemStandByTimer();
  8945. + sUserType = UNKNOWN_USER;
  8946. + } else if (sMajorSim == AUTO_SWITCH_OFF) {
  8947. + logd("Auto modem selection disabled");
  8948. + removeModemStandByTimer();
  8949. + } else if (sMajorSim == MAJOR_SIM_UNKNOWN) {
  8950. + logd("Major SIM unknown");
  8951. + } else {
  8952. + logd("Auto modem selection enabled");
  8953. + logd("Major capability in slot" + sMajorSim);
  8954. + if (sImsi[sMajorSim] == null || sImsi[sMajorSim].equals("")) {
  8955. + // may caused by receive 3g switched intent when boot up
  8956. + logd("Major slot IMSI not ready");
  8957. + sUserType = UNKNOWN_USER;
  8958. + return;
  8959. + }
  8960. + sUserType = getUserType(sImsi[sMajorSim]);
  8961. + if (sUserType == TYPE1_USER) {
  8962. + if (sNwPlmnStrings != null) {
  8963. + sRegion = getRegion(sNwPlmnStrings[0]);
  8964. + }
  8965. + if (sRegion == REGION_DOMESTIC) {
  8966. + sFirstSelect[sMajorSim] = false;
  8967. + sIccCardType[sMajorSim] = getIccCardType(sMajorSim);
  8968. + handleSwitchModem(ModemSwitchHandler.MD_TYPE_TDD);
  8969. + } else if (sRegion == REGION_FOREIGN) {
  8970. + sFirstSelect[sMajorSim] = false;
  8971. + handleSwitchModem(ModemSwitchHandler.MD_TYPE_FDD);
  8972. + } else {
  8973. + logd("Unknown region");
  8974. + }
  8975. + } else if (sUserType == TYPE2_USER || sUserType == TYPE3_USER) {
  8976. + sFirstSelect[sMajorSim] = false;
  8977. + handleSwitchModem(ModemSwitchHandler.MD_TYPE_FDD);
  8978. + } else {
  8979. + logd("Unknown user type");
  8980. + }
  8981. + }
  8982. + }
  8983. +
  8984. + private void handleNoService() {
  8985. + logd("[handleNoService]+ Can not find service");
  8986. + logd("Type" + sUserType + " user");
  8987. + logd(WorldPhoneUtil.regionToString(sRegion));
  8988. + int mdType = ModemSwitchHandler.getActiveModemType();
  8989. + logd(ModemSwitchHandler.modemToString(mdType));
  8990. + IccCardConstants.State iccState = ((PhoneProxy) sProxyPhones[sMajorSim]).getIccCard().getState();
  8991. + if (iccState == IccCardConstants.State.READY) {
  8992. + if (sUserType == TYPE1_USER) {
  8993. + if (mdType == ModemSwitchHandler.MD_TYPE_LTG
  8994. + || mdType == ModemSwitchHandler.MD_TYPE_TG) {
  8995. + if (TDD_STANDBY_TIMER[sTddStandByCounter] >= 0) {
  8996. + if (!sWaitInTdd) {
  8997. + sWaitInTdd = true;
  8998. + logd("Wait " + TDD_STANDBY_TIMER[sTddStandByCounter] + "s. Timer index = " + sTddStandByCounter);
  8999. + postDelayed(mTddStandByTimerRunnable, TDD_STANDBY_TIMER[sTddStandByCounter] * 1000);
  9000. + } else {
  9001. + logd("Timer already set:" + TDD_STANDBY_TIMER[sTddStandByCounter] + "s");
  9002. + }
  9003. + } else {
  9004. + logd("Standby in TDD modem");
  9005. + }
  9006. + } else if (mdType == ModemSwitchHandler.MD_TYPE_LWG
  9007. + || mdType == ModemSwitchHandler.MD_TYPE_WG) {
  9008. + if (FDD_STANDBY_TIMER[sFddStandByCounter] >= 0) {
  9009. + if (!sWaitInFdd) {
  9010. + sWaitInFdd = true;
  9011. + logd("Wait " + FDD_STANDBY_TIMER[sFddStandByCounter] + "s. Timer index = " + sFddStandByCounter);
  9012. + postDelayed(mFddStandByTimerRunnable, FDD_STANDBY_TIMER[sFddStandByCounter] * 1000);
  9013. + } else {
  9014. + logd("Timer already set:" + FDD_STANDBY_TIMER[sFddStandByCounter] + "s");
  9015. + }
  9016. + } else {
  9017. + logd("Standby in FDD modem");
  9018. + }
  9019. + }
  9020. + } else if (sUserType == TYPE2_USER || sUserType == TYPE3_USER) {
  9021. + if (mdType == ModemSwitchHandler.MD_TYPE_LWG
  9022. + || mdType == ModemSwitchHandler.MD_TYPE_WG) {
  9023. + logd("Standby in FDD modem");
  9024. + } else {
  9025. + logd("Should not enter this state");
  9026. + }
  9027. + } else {
  9028. + logd("Unknow user type");
  9029. + }
  9030. + } else {
  9031. + logd("IccState not ready");
  9032. + }
  9033. + logd("[handleNoService]-");
  9034. +
  9035. + return;
  9036. + }
  9037. +
  9038. + private boolean isAllowCampOn(String plmnString, int slotId) {
  9039. + logd("[isAllowCampOn]+ " + plmnString);
  9040. + logd("User type: " + sUserType);
  9041. + logd(WorldPhoneUtil.iccCardTypeToString(sIccCardType[slotId]));
  9042. + sRegion = getRegion(plmnString);
  9043. + int mdType = ModemSwitchHandler.getActiveModemType();
  9044. + logd(ModemSwitchHandler.modemToString(mdType));
  9045. + if (sUserType == TYPE1_USER) {
  9046. + if (sRegion == REGION_DOMESTIC) {
  9047. + if (mdType == ModemSwitchHandler.MD_TYPE_LTG
  9048. + || mdType == ModemSwitchHandler.MD_TYPE_TG) {
  9049. + sDenyReason = CAMP_ON_NOT_DENIED;
  9050. + logd("Camp on OK");
  9051. + logd("[isAllowCampOn]-");
  9052. + return true;
  9053. + } else if (mdType == ModemSwitchHandler.MD_TYPE_LWG
  9054. + || mdType == ModemSwitchHandler.MD_TYPE_WG) {
  9055. + sDenyReason = CAMP_ON_DENY_REASON_NEED_SWITCH_TO_TDD;
  9056. + logd("Camp on REJECT");
  9057. + logd("[isAllowCampOn]-");
  9058. + return false;
  9059. + }
  9060. + } else if (sRegion == REGION_FOREIGN) {
  9061. + if (mdType == ModemSwitchHandler.MD_TYPE_LTG
  9062. + || mdType == ModemSwitchHandler.MD_TYPE_TG) {
  9063. + sDenyReason = CAMP_ON_DENY_REASON_NEED_SWITCH_TO_FDD;
  9064. + logd("Camp on REJECT");
  9065. + logd("[isAllowCampOn]-");
  9066. + return false;
  9067. + } else if (mdType == ModemSwitchHandler.MD_TYPE_LWG
  9068. + || mdType == ModemSwitchHandler.MD_TYPE_WG) {
  9069. + sDenyReason = CAMP_ON_NOT_DENIED;
  9070. + logd("Camp on OK");
  9071. + logd("[isAllowCampOn]-");
  9072. + return true;
  9073. + }
  9074. + } else {
  9075. + logd("Unknow region");
  9076. + }
  9077. + } else if (sUserType == TYPE2_USER || sUserType == TYPE3_USER) {
  9078. + if (mdType == ModemSwitchHandler.MD_TYPE_LTG
  9079. + || mdType == ModemSwitchHandler.MD_TYPE_TG) {
  9080. + sDenyReason = CAMP_ON_DENY_REASON_NEED_SWITCH_TO_FDD;
  9081. + logd("Camp on REJECT");
  9082. + logd("[isAllowCampOn]-");
  9083. + return false;
  9084. + } else if (mdType == ModemSwitchHandler.MD_TYPE_LWG
  9085. + || mdType == ModemSwitchHandler.MD_TYPE_WG) {
  9086. + sDenyReason = CAMP_ON_NOT_DENIED;
  9087. + logd("Camp on OK");
  9088. + logd("[isAllowCampOn]-");
  9089. + return true;
  9090. + }
  9091. + } else {
  9092. + logd("Unknown user type");
  9093. + }
  9094. + sDenyReason = CAMP_ON_DENY_REASON_UNKNOWN;
  9095. + logd("Camp on REJECT");
  9096. + logd("[isAllowCampOn]-");
  9097. +
  9098. + return false;
  9099. + }
  9100. +
  9101. + private boolean isInService() {
  9102. + boolean inService = false;
  9103. +
  9104. + if (sVoiceRegState == ServiceState.STATE_IN_SERVICE
  9105. + || sDataRegState == ServiceState.STATE_IN_SERVICE) {
  9106. + inService = true;
  9107. + }
  9108. + logd("inService: " + inService);
  9109. +
  9110. + return inService;
  9111. + }
  9112. +
  9113. + private boolean isNoService() {
  9114. + boolean noService = false;
  9115. +
  9116. + if (sVoiceRegState == ServiceState.STATE_OUT_OF_SERVICE
  9117. + // && sRilVoiceRegState == ServiceState.REGISTRATION_STATE_NOT_REGISTERED_AND_NOT_SEARCHING
  9118. + && sDataRegState == ServiceState.STATE_OUT_OF_SERVICE
  9119. + // && sRilDataRegState == ServiceState.REGISTRATION_STATE_NOT_REGISTERED_AND_NOT_SEARCHING) {
  9120. + ) {
  9121. + noService = true;
  9122. + } else {
  9123. + noService = false;
  9124. + }
  9125. + logd("noService: " + noService);
  9126. +
  9127. + return noService;
  9128. + }
  9129. +
  9130. + private int getIccCardType(int slotId) {
  9131. + int simType;
  9132. + String simString = "Unknown";
  9133. +
  9134. + simString = ((PhoneProxy) sProxyPhones[slotId]).getIccCard().getIccCardType();
  9135. + if (simString.equals("SIM")) {
  9136. + logd("IccCard type: SIM");
  9137. + simType = ICC_CARD_TYPE_SIM;
  9138. + } else if (simString.equals("USIM")) {
  9139. + logd("IccCard type: USIM");
  9140. + simType = ICC_CARD_TYPE_USIM;
  9141. + } else {
  9142. + logd("IccCard type: Unknown");
  9143. + simType = ICC_CARD_TYPE_UNKNOWN;
  9144. + }
  9145. +
  9146. + return simType;
  9147. + }
  9148. +
  9149. + private int getRegion(String plmn) {
  9150. + String currentMcc;
  9151. + if (plmn == null) {
  9152. + logd("[getRegion] null PLMN");
  9153. + return REGION_UNKNOWN;
  9154. + }
  9155. + currentMcc = plmn.substring(0, 3);
  9156. + for (String mcc : MCC_TABLE_DOMESTIC) {
  9157. + if (currentMcc.equals(mcc)) {
  9158. + logd("[getRegion] REGION_DOMESTIC");
  9159. + return REGION_DOMESTIC;
  9160. + }
  9161. + }
  9162. + logd("[getRegion] REGION_FOREIGN");
  9163. + return REGION_FOREIGN;
  9164. + }
  9165. +
  9166. + private int getUserType(String imsi) {
  9167. + if (imsi != null && !imsi.equals("")) {
  9168. + imsi = imsi.substring(0, 5);
  9169. + for (String mccmnc : PLMN_TABLE_TYPE1) {
  9170. + if (imsi.equals(mccmnc)) {
  9171. + logd("[getUserType] Type1 user");
  9172. + return TYPE1_USER;
  9173. + }
  9174. + }
  9175. + for (String mccmnc : PLMN_TABLE_TYPE3) {
  9176. + if (imsi.equals(mccmnc)) {
  9177. + logd("[getUserType] Type3 user");
  9178. + return TYPE3_USER;
  9179. + }
  9180. + }
  9181. + logd("[getUserType] Type2 user");
  9182. + return TYPE2_USER;
  9183. + } else {
  9184. + logd("[getUserType] null IMSI");
  9185. + return UNKNOWN_USER;
  9186. + }
  9187. + }
  9188. +
  9189. + private void resumeCampingProcedure(int slotId) {
  9190. + logd("Resume camping slot" + slotId);
  9191. + String plmnString = sNwPlmnStrings[0];
  9192. + if (isAllowCampOn(plmnString, slotId)) {
  9193. + removeModemStandByTimer();
  9194. + sCi[slotId].setResumeRegistration(sSuspendId, null);
  9195. + } else {
  9196. + logd("Because: " + WorldPhoneUtil.denyReasonToString(sDenyReason));
  9197. + if (sDenyReason == CAMP_ON_DENY_REASON_NEED_SWITCH_TO_FDD) {
  9198. + handleSwitchModem(ModemSwitchHandler.MD_TYPE_FDD);
  9199. + } else if (sDenyReason == CAMP_ON_DENY_REASON_NEED_SWITCH_TO_TDD) {
  9200. + handleSwitchModem(ModemSwitchHandler.MD_TYPE_TDD);
  9201. + }
  9202. + }
  9203. + }
  9204. +
  9205. + private Runnable mTddStandByTimerRunnable = new Runnable() {
  9206. + public void run() {
  9207. + sTddStandByCounter++;
  9208. + if (sTddStandByCounter >= TDD_STANDBY_TIMER.length) {
  9209. + sTddStandByCounter = TDD_STANDBY_TIMER.length - 1;
  9210. + }
  9211. + logd("TDD time out!");
  9212. + handleSwitchModem(ModemSwitchHandler.MD_TYPE_FDD);
  9213. + }
  9214. + };
  9215. +
  9216. + private Runnable mFddStandByTimerRunnable = new Runnable() {
  9217. + public void run() {
  9218. + sFddStandByCounter++;
  9219. + if (sFddStandByCounter >= FDD_STANDBY_TIMER.length) {
  9220. + sFddStandByCounter = FDD_STANDBY_TIMER.length - 1;
  9221. + }
  9222. + logd("FDD time out!");
  9223. + handleSwitchModem(ModemSwitchHandler.MD_TYPE_TDD);
  9224. + }
  9225. + };
  9226. +
  9227. + private void removeModemStandByTimer() {
  9228. + if (sWaitInTdd) {
  9229. + logd("Remove TDD wait timer. Set sWaitInTdd = false");
  9230. + sWaitInTdd = false;
  9231. + removeCallbacks(mTddStandByTimerRunnable);
  9232. + }
  9233. + if (sWaitInFdd) {
  9234. + logd("Remove FDD wait timer. Set sWaitInFdd = false");
  9235. + sWaitInFdd = false;
  9236. + removeCallbacks(mFddStandByTimerRunnable);
  9237. + }
  9238. + }
  9239. +
  9240. + private void resetAllProperties() {
  9241. + logd("[resetAllProperties]");
  9242. + sNwPlmnStrings = null;
  9243. + for (int i = 0; i < PROJECT_SIM_NUM; i++) {
  9244. + sFirstSelect[i] = true;
  9245. + }
  9246. + sDenyReason = CAMP_ON_DENY_REASON_UNKNOWN;
  9247. + resetSimProperties();
  9248. + resetNetworkProperties();
  9249. + }
  9250. +
  9251. + private void resetNetworkProperties() {
  9252. + logd("[resetNetworkProperties]");
  9253. + synchronized (sLock) {
  9254. + for (int i = 0; i < PROJECT_SIM_NUM; i++) {
  9255. + sSuspendWaitImsi[i] = false;
  9256. + }
  9257. + }
  9258. + }
  9259. +
  9260. + private void resetSimProperties() {
  9261. + logd("[resetSimProperties]");
  9262. + synchronized (sLock) {
  9263. + for (int i = 0; i < PROJECT_SIM_NUM; i++) {
  9264. + sImsi[i] = "";
  9265. + sIccCardType[i] = ICC_CARD_TYPE_UNKNOWN;
  9266. + }
  9267. + sUserType = UNKNOWN_USER;
  9268. + sMajorSim = WorldPhoneUtil.getMajorSim();
  9269. + }
  9270. + }
  9271. +
  9272. + private void searchForDesignateService(String strPlmn) {
  9273. + if (strPlmn == null) {
  9274. + logd("[searchForDesignateService]- null source");
  9275. + return;
  9276. + }
  9277. + strPlmn = strPlmn.substring(0, 5);
  9278. + for (String mccmnc : PLMN_TABLE_TYPE1) {
  9279. + if (strPlmn.equals(mccmnc)) {
  9280. + logd("Find TD service");
  9281. + logd("sUserType: " + sUserType + " sRegion: " + sRegion);
  9282. + logd(ModemSwitchHandler.modemToString(ModemSwitchHandler.getActiveModemType()));
  9283. + handleSwitchModem(ModemSwitchHandler.MD_TYPE_TDD);
  9284. + break;
  9285. + }
  9286. + }
  9287. +
  9288. + return;
  9289. + }
  9290. +
  9291. + public void setModemSelectionMode(int mode, int modemType) {
  9292. + // Settings.Global.putInt(sContext.getContentResolver(),
  9293. + // Settings.Global.WORLD_PHONE_AUTO_SELECT_MODE, mode);
  9294. + if (mode == SELECTION_MODE_AUTO) {
  9295. + logd("Modem Selection <AUTO>");
  9296. + sMajorSim = WorldPhoneUtil.getMajorSim();
  9297. + handleSimSwitched();
  9298. + } else {
  9299. + logd("Modem Selection <MANUAL>");
  9300. + sMajorSim = AUTO_SWITCH_OFF;
  9301. + handleSwitchModem(modemType);
  9302. + }
  9303. + }
  9304. +
  9305. + private static void logd(String msg) {
  9306. + Rlog.d(LOG_TAG, "[WPOM]" + msg);
  9307. + }
  9308. +}
  9309. diff --git a/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneUtil.java b/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneUtil.java
  9310. new file mode 100755
  9311. index 0000000..f2c5b41
  9312. --- /dev/null
  9313. +++ b/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneUtil.java
  9314. @@ -0,0 +1,246 @@
  9315. +/* Copyright Statement:
  9316. + *
  9317. + * This software/firmware and related documentation ("MediaTek Software") are
  9318. + * protected under relevant copyright laws. The information contained herein
  9319. + * is confidential and proprietary to MediaTek Inc. and/or its licensors.
  9320. + * Without the prior written permission of MediaTek inc. and/or its licensors,
  9321. + * any reproduction, modification, use or disclosure of MediaTek Software,
  9322. + * and information contained herein, in whole or in part, shall be strictly prohibited.
  9323. + *
  9324. + * MediaTek Inc. (C) 2010. All rights reserved.
  9325. + *
  9326. + * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  9327. + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  9328. + * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
  9329. + * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  9330. + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  9331. + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  9332. + * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  9333. + * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  9334. + * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
  9335. + * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
  9336. + * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
  9337. + * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
  9338. + * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  9339. + * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
  9340. + * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  9341. + * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  9342. + * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
  9343. + * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  9344. + *
  9345. + * The following software/firmware and/or related documentation ("MediaTek Software")
  9346. + * have been modified by MediaTek Inc. All revisions are subject to any receiver's
  9347. + * applicable license agreements with MediaTek Inc.
  9348. + */
  9349. +package com.mediatek.internal.telephony.worldphone;
  9350. +
  9351. +import android.content.Context;
  9352. +import android.os.SystemProperties;
  9353. +import android.provider.Settings;
  9354. +import android.telephony.PhoneRatFamily;
  9355. +import android.telephony.Rlog;
  9356. +import android.telephony.ServiceState;
  9357. +import android.telephony.TelephonyManager;
  9358. +
  9359. +import com.android.internal.telephony.Phone;
  9360. +import com.android.internal.telephony.PhoneBase;
  9361. +import com.android.internal.telephony.PhoneConstants;
  9362. +import com.android.internal.telephony.PhoneFactory;
  9363. +import com.android.internal.telephony.PhoneProxy;
  9364. +import com.android.internal.telephony.TelephonyProperties;
  9365. +
  9366. +
  9367. +/**
  9368. + *@hide
  9369. + */
  9370. +public class WorldPhoneUtil implements IWorldPhone {
  9371. + private static final int PROJECT_SIM_NUM = TelephonyManager.getDefault().getSimCount();
  9372. + private static final boolean IS_WORLD_PHONE_SUPPORT = true; // (SystemProperties.getInt(TelephonyProperties.PROPERTY_WORLD_PHONE, 0) == 1);
  9373. + private static final boolean IS_LTE_SUPPORT = (SystemProperties.getInt("ro.mtk_lte_support", 0) == 1);
  9374. + private static Context sContext = null;
  9375. + private static Phone sDefultPhone = null;
  9376. + private static Phone[] sProxyPhones = null;
  9377. + private static Phone[] sActivePhones = new Phone[PROJECT_SIM_NUM];
  9378. +
  9379. + public WorldPhoneUtil() {
  9380. + logd("Constructor invoked");
  9381. + sDefultPhone = PhoneFactory.getDefaultPhone();
  9382. + sProxyPhones = PhoneFactory.getPhones();
  9383. + for (int i = 0; i < PROJECT_SIM_NUM; i++) {
  9384. + sActivePhones[i] = ((PhoneProxy) sProxyPhones[i]).getActivePhone();
  9385. + }
  9386. + if (sDefultPhone != null) {
  9387. + sContext = sDefultPhone.getContext();
  9388. + } else {
  9389. + logd("DefaultPhone = null");
  9390. + }
  9391. + }
  9392. +
  9393. + public static int getProjectSimNum() {
  9394. + return PROJECT_SIM_NUM;
  9395. + }
  9396. +
  9397. + public static int getMajorSim() {
  9398. + if (sProxyPhones == null) {
  9399. + logd("[getMajorSim] sProxyPhones = null");
  9400. + return DEFAULT_MAJOR_SIM;
  9401. + }
  9402. + for (int i = 0; i < PROJECT_SIM_NUM; i++) {
  9403. + if ((((PhoneBase) sActivePhones[i]).getPhoneRatFamily()
  9404. + & PhoneRatFamily.PHONE_RAT_FAMILY_3G) == PhoneRatFamily.PHONE_RAT_FAMILY_3G) {
  9405. + logd("[getMajorSim]: " + i);
  9406. + return i;
  9407. + }
  9408. + }
  9409. + logd("[getMajorSim]: fail to get major SIM");
  9410. +
  9411. + return DEFAULT_MAJOR_SIM;
  9412. + }
  9413. +
  9414. + public static int getModemSelectionMode() {
  9415. + if (sContext == null) {
  9416. + logd("sContext = null");
  9417. + return SELECTION_MODE_AUTO;
  9418. + }
  9419. +
  9420. + logd("getModemSelectionMode: always auto!");
  9421. + return SELECTION_MODE_AUTO;
  9422. + /*
  9423. + return Settings.Global.getInt(sContext.getContentResolver(),
  9424. + Settings.Global.WORLD_PHONE_AUTO_SELECT_MODE, SELECTION_MODE_AUTO);
  9425. + */
  9426. + }
  9427. +
  9428. + public static boolean isWorldPhoneSupport() {
  9429. + return IS_WORLD_PHONE_SUPPORT;
  9430. + }
  9431. +
  9432. + public static boolean isLteSupport() {
  9433. + return IS_LTE_SUPPORT;
  9434. + }
  9435. +
  9436. + public static String regionToString(int region) {
  9437. + String regionString;
  9438. + switch (region) {
  9439. + case REGION_UNKNOWN:
  9440. + regionString = "REGION_UNKNOWN";
  9441. + break;
  9442. + case REGION_DOMESTIC:
  9443. + regionString = "REGION_DOMESTIC";
  9444. + break;
  9445. + case REGION_FOREIGN:
  9446. + regionString = "REGION_FOREIGN";
  9447. + break;
  9448. + default:
  9449. + regionString = "Invalid Region";
  9450. + break;
  9451. + }
  9452. +
  9453. + return regionString;
  9454. + }
  9455. +
  9456. + public static String stateToString(int state) {
  9457. + String stateString;
  9458. + switch (state) {
  9459. + case ServiceState.STATE_POWER_OFF:
  9460. + stateString = "STATE_POWER_OFF";
  9461. + break;
  9462. + case ServiceState.STATE_IN_SERVICE:
  9463. + stateString = "STATE_IN_SERVICE";
  9464. + break;
  9465. + case ServiceState.STATE_OUT_OF_SERVICE:
  9466. + stateString = "STATE_OUT_OF_SERVICE";
  9467. + break;
  9468. + case ServiceState.STATE_EMERGENCY_ONLY:
  9469. + stateString = "STATE_EMERGENCY_ONLY";
  9470. + break;
  9471. + default:
  9472. + stateString = "Invalid State";
  9473. + break;
  9474. + }
  9475. +
  9476. + return stateString;
  9477. + }
  9478. +
  9479. + public static String regStateToString(int regState) {
  9480. + String rsString;
  9481. + switch (regState) {
  9482. + case ServiceState.REGISTRATION_STATE_NOT_REGISTERED_AND_NOT_SEARCHING:
  9483. + rsString = "REGISTRATION_STATE_NOT_REGISTERED_AND_NOT_SEARCHING";
  9484. + break;
  9485. + case ServiceState.REGISTRATION_STATE_HOME_NETWORK:
  9486. + rsString = "REGISTRATION_STATE_HOME_NETWORK";
  9487. + break;
  9488. + case ServiceState.REGISTRATION_STATE_NOT_REGISTERED_AND_SEARCHING:
  9489. + rsString = "REGISTRATION_STATE_NOT_REGISTERED_AND_SEARCHING";
  9490. + break;
  9491. + case ServiceState.REGISTRATION_STATE_REGISTRATION_DENIED:
  9492. + rsString = "REGISTRATION_STATE_REGISTRATION_DENIED";
  9493. + break;
  9494. + case ServiceState.REGISTRATION_STATE_UNKNOWN:
  9495. + rsString = "REGISTRATION_STATE_UNKNOWN";
  9496. + break;
  9497. + case ServiceState.REGISTRATION_STATE_ROAMING:
  9498. + rsString = "REGISTRATION_STATE_ROAMING";
  9499. + break;
  9500. + default:
  9501. + rsString = "Invalid RegState";
  9502. + break;
  9503. + }
  9504. +
  9505. + return rsString;
  9506. + }
  9507. +
  9508. + public static String denyReasonToString(int reason) {
  9509. + String drString;
  9510. + switch (reason) {
  9511. + case CAMP_ON_NOT_DENIED:
  9512. + drString = "CAMP_ON_NOT_DENIED";
  9513. + break;
  9514. + case CAMP_ON_DENY_REASON_UNKNOWN:
  9515. + drString = "CAMP_ON_DENY_REASON_UNKNOWN";
  9516. + break;
  9517. + case CAMP_ON_DENY_REASON_NEED_SWITCH_TO_FDD:
  9518. + drString = "CAMP_ON_DENY_REASON_NEED_SWITCH_TO_FDD";
  9519. + break;
  9520. + case CAMP_ON_DENY_REASON_NEED_SWITCH_TO_TDD:
  9521. + drString = "CAMP_ON_DENY_REASON_NEED_SWITCH_TO_TDD";
  9522. + break;
  9523. + case CAMP_ON_DENY_REASON_DOMESTIC_FDD_MD:
  9524. + drString = "CAMP_ON_DENY_REASON_DOMESTIC_FDD_MD";
  9525. + break;
  9526. + default:
  9527. + drString = "Invalid Reason";
  9528. + break;
  9529. + }
  9530. +
  9531. + return drString;
  9532. + }
  9533. +
  9534. + public static String iccCardTypeToString(int iccCardType) {
  9535. + String iccTypeString;
  9536. + switch (iccCardType) {
  9537. + case ICC_CARD_TYPE_SIM:
  9538. + iccTypeString = "SIM";
  9539. + break;
  9540. + case ICC_CARD_TYPE_USIM:
  9541. + iccTypeString = "USIM";
  9542. + break;
  9543. + case ICC_CARD_TYPE_UNKNOWN:
  9544. + iccTypeString = "Icc Card Type Unknown";
  9545. + break;
  9546. + default:
  9547. + iccTypeString = "Invalid Icc Card Type";
  9548. + break;
  9549. + }
  9550. +
  9551. + return iccTypeString;
  9552. + }
  9553. +
  9554. + public void setModemSelectionMode(int mode, int modemType) {
  9555. + }
  9556. +
  9557. + private static void logd(String msg) {
  9558. + Rlog.d(LOG_TAG, "[WPP_UTIL]" + msg);
  9559. + }
  9560. +}
  9561. diff --git a/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneWrapper.java b/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneWrapper.java
  9562. new file mode 100755
  9563. index 0000000..6f7c85f
  9564. --- /dev/null
  9565. +++ b/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneWrapper.java
  9566. @@ -0,0 +1,86 @@
  9567. +/* Copyright Statement:
  9568. + *
  9569. + * This software/firmware and related documentation ("MediaTek Software") are
  9570. + * protected under relevant copyright laws. The information contained herein
  9571. + * is confidential and proprietary to MediaTek Inc. and/or its licensors.
  9572. + * Without the prior written permission of MediaTek inc. and/or its licensors,
  9573. + * any reproduction, modification, use or disclosure of MediaTek Software,
  9574. + * and information contained herein, in whole or in part, shall be strictly prohibited.
  9575. + *
  9576. + * MediaTek Inc. (C) 2010. All rights reserved.
  9577. + *
  9578. + * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  9579. + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  9580. + * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
  9581. + * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  9582. + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  9583. + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  9584. + * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  9585. + * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  9586. + * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
  9587. + * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
  9588. + * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
  9589. + * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
  9590. + * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  9591. + * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
  9592. + * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  9593. + * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  9594. + * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
  9595. + * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  9596. + *
  9597. + * The following software/firmware and/or related documentation ("MediaTek Software")
  9598. + * have been modified by MediaTek Inc. All revisions are subject to any receiver's
  9599. + * applicable license agreements with MediaTek Inc.
  9600. + */
  9601. +package com.mediatek.internal.telephony.worldphone;
  9602. +
  9603. +import android.os.SystemProperties;
  9604. +import android.telephony.Rlog;
  9605. +
  9606. +
  9607. +
  9608. +/**
  9609. + *@hide
  9610. + */
  9611. +public class WorldPhoneWrapper implements IWorldPhone {
  9612. + private static int sOperatorSpec = -1;
  9613. + private static IWorldPhone sWorldPhoneInstance = null;
  9614. + private static WorldPhoneUtil sWorldPhoneUtil = null;
  9615. +
  9616. + public WorldPhoneWrapper() {
  9617. + }
  9618. +
  9619. + public static IWorldPhone getWorldPhoneInstance() {
  9620. + if (sWorldPhoneInstance == null) {
  9621. + String optr = SystemProperties.get("ro.operator.optr");
  9622. + if (optr != null && optr.equals("OP01")) {
  9623. + // sOperatorSpec = POLICY_OP01;
  9624. + logd("getWorldPhoneInstance: POLICY_OP01 not implemented!");
  9625. + sOperatorSpec = POLICY_OM;
  9626. + } else {
  9627. + sOperatorSpec = POLICY_OM;
  9628. + }
  9629. + sWorldPhoneUtil = new WorldPhoneUtil();
  9630. + if (sOperatorSpec == POLICY_OP01) {
  9631. + // sWorldPhoneInstance = new WorldPhoneOp01();
  9632. + } else if (sOperatorSpec == POLICY_OM) {
  9633. + sWorldPhoneInstance = new WorldPhoneOm();
  9634. + }
  9635. + }
  9636. + logd("sOperatorSpec: " + sOperatorSpec + ", isLteSupport: " + WorldPhoneUtil.isLteSupport());
  9637. +
  9638. + return sWorldPhoneInstance;
  9639. + }
  9640. +
  9641. + public void setModemSelectionMode(int mode, int modemType) {
  9642. + if (sOperatorSpec == POLICY_OP01 || sOperatorSpec == POLICY_OM) {
  9643. + sWorldPhoneInstance.setModemSelectionMode(mode, modemType);
  9644. + } else {
  9645. + logd("Unknown World Phone Spec");
  9646. + }
  9647. + }
  9648. +
  9649. + private static void logd(String msg) {
  9650. + Rlog.d(LOG_TAG, "[WPO_WRAPPER]" + msg);
  9651. + }
  9652. +}
  9653. --
  9654. 1.9.1
Add Comment
Please, Sign In to add comment
Public Pastes
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!