· 9 years ago · Oct 12, 2016, 07:26 AM
1From 19044254448d50faed4427ae444ddc6c4717916f Mon Sep 17 00:00:00 2001
2From: olegsvs <oleg.texet@gmail.com>
3Date: Sun, 12 Jun 2016 13:19:03 -0400
4Subject: [PATCH] Patch for 6735 mtk
5
6Change-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
74diff --git a/src/java/com/android/internal/telephony/BaseCommands.java b/src/java/com/android/internal/telephony/BaseCommands.java
75index 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 }
306diff --git a/src/java/com/android/internal/telephony/CommandsInterface.java b/src/java/com/android/internal/telephony/CommandsInterface.java
307index 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 }
579diff --git a/src/java/com/android/internal/telephony/HardwareConfig.java b/src/java/com/android/internal/telephony/HardwareConfig.java
580index 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
599diff --git a/src/java/com/android/internal/telephony/IccCard.java b/src/java/com/android/internal/telephony/IccCard.java
600index 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 }
704diff --git a/src/java/com/android/internal/telephony/MediaTekRIL.java b/src/java/com/android/internal/telephony/MediaTekRIL.java
705new file mode 100644
706index 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+}
2969diff --git a/src/java/com/android/internal/telephony/Phone.java b/src/java/com/android/internal/telephony/Phone.java
2970index 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 }
3013diff --git a/src/java/com/android/internal/telephony/PhoneBase.java b/src/java/com/android/internal/telephony/PhoneBase.java
3014index 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);
3121diff --git a/src/java/com/android/internal/telephony/PhoneFactory.java b/src/java/com/android/internal/telephony/PhoneFactory.java
3122index 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 {
3173diff --git a/src/java/com/android/internal/telephony/PhoneProxy.java b/src/java/com/android/internal/telephony/PhoneProxy.java
3174index 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 }
3205diff --git a/src/java/com/android/internal/telephony/RIL.java b/src/java/com/android/internal/telephony/RIL.java
3206index 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 }
3817diff --git a/src/java/com/android/internal/telephony/ServiceStateTracker.java b/src/java/com/android/internal/telephony/ServiceStateTracker.java
3818index 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 /**
3850diff --git a/src/java/com/android/internal/telephony/SubscriptionInfoUpdater.java b/src/java/com/android/internal/telephony/SubscriptionInfoUpdater.java
3851index 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]);
3863diff --git a/src/java/com/android/internal/telephony/cdma/CdmaSubscriptionSourceManager.java b/src/java/com/android/internal/telephony/cdma/CdmaSubscriptionSourceManager.java
3864index 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();
3876diff --git a/src/java/com/android/internal/telephony/dataconnection/ApnSetting.java b/src/java/com/android/internal/telephony/dataconnection/ApnSetting.java
3877index 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
3928diff --git a/src/java/com/android/internal/telephony/dataconnection/DcTracker.java b/src/java/com/android/internal/telephony/dataconnection/DcTracker.java
3929index 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 }
3970diff --git a/src/java/com/android/internal/telephony/dataconnection/DcTrackerBase.java b/src/java/com/android/internal/telephony/dataconnection/DcTrackerBase.java
3971index 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
3994diff --git a/src/java/com/android/internal/telephony/gsm/GSMPhone.java b/src/java/com/android/internal/telephony/gsm/GSMPhone.java
3995index 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 /**
4157diff --git a/src/java/com/android/internal/telephony/gsm/GsmMmiCode.java b/src/java/com/android/internal/telephony/gsm/GsmMmiCode.java
4158index 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 }
4343diff --git a/src/java/com/android/internal/telephony/gsm/GsmServiceStateTracker.java b/src/java/com/android/internal/telephony/gsm/GsmServiceStateTracker.java
4344index 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);
4427diff --git a/src/java/com/android/internal/telephony/imsphone/ImsPhone.java b/src/java/com/android/internal/telephony/imsphone/ImsPhone.java
4428index 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();
4463diff --git a/src/java/com/android/internal/telephony/imsphone/ImsPhoneCommandInterface.java b/src/java/com/android/internal/telephony/imsphone/ImsPhoneCommandInterface.java
4464index 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 }
4520diff --git a/src/java/com/android/internal/telephony/imsphone/ImsPhoneMmiCode.java b/src/java/com/android/internal/telephony/imsphone/ImsPhoneMmiCode.java
4521index 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 }
4550diff --git a/src/java/com/android/internal/telephony/sip/SipCommandInterface.java b/src/java/com/android/internal/telephony/sip/SipCommandInterface.java
4551index 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 }
4607diff --git a/src/java/com/android/internal/telephony/test/SimulatedCommands.java b/src/java/com/android/internal/telephony/test/SimulatedCommands.java
4608index 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 }
4650diff --git a/src/java/com/android/internal/telephony/uicc/IccCardProxy.java b/src/java/com/android/internal/telephony/uicc/IccCardProxy.java
4651index 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 }
4954diff --git a/src/java/com/android/internal/telephony/uicc/IccConstants.java b/src/java/com/android/internal/telephony/uicc/IccConstants.java
4955index 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 }
4993diff --git a/src/java/com/android/internal/telephony/uicc/IccFileHandler.java b/src/java/com/android/internal/telephony/uicc/IccFileHandler.java
4994index 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 }
5324diff --git a/src/java/com/android/internal/telephony/uicc/RuimRecords.java b/src/java/com/android/internal/telephony/uicc/RuimRecords.java
5325index 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;
5347diff --git a/src/java/com/android/internal/telephony/uicc/SIMRecords.java b/src/java/com/android/internal/telephony/uicc/SIMRecords.java
5348index 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;
5370diff --git a/src/java/com/android/internal/telephony/uicc/UiccCard.java b/src/java/com/android/internal/telephony/uicc/UiccCard.java
5371index 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 }
5502diff --git a/src/java/com/android/internal/telephony/uicc/UiccCardApplication.java b/src/java/com/android/internal/telephony/uicc/UiccCardApplication.java
5503index 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 }
5722diff --git a/src/java/com/android/internal/telephony/uicc/UiccController.java b/src/java/com/android/internal/telephony/uicc/UiccController.java
5723index 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 }
6232diff --git a/src/java/com/android/internal/telephony/uicc/UsimFileHandler.java b/src/java/com/android/internal/telephony/uicc/UsimFileHandler.java
6233index 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;
6261diff --git a/src/java/com/mediatek/internal/telephony/EtwsNotification.java b/src/java/com/mediatek/internal/telephony/EtwsNotification.java
6262new file mode 100644
6263index 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
6310diff --git a/src/java/com/mediatek/internal/telephony/EtwsUtils.java b/src/java/com/mediatek/internal/telephony/EtwsUtils.java
6311new file mode 100644
6312index 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
6348diff --git a/src/java/com/mediatek/internal/telephony/FemtoCellInfo.aidl b/src/java/com/mediatek/internal/telephony/FemtoCellInfo.aidl
6349new file mode 100755
6350index 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;
6373diff --git a/src/java/com/mediatek/internal/telephony/FemtoCellInfo.java b/src/java/com/mediatek/internal/telephony/FemtoCellInfo.java
6374new file mode 100755
6375index 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+
6533diff --git a/src/java/com/mediatek/internal/telephony/ModemSwitchHandler.java b/src/java/com/mediatek/internal/telephony/ModemSwitchHandler.java
6534new file mode 100755
6535index 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+}
6783diff --git a/src/java/com/mediatek/internal/telephony/NetworkInfoWithAcT.aidl b/src/java/com/mediatek/internal/telephony/NetworkInfoWithAcT.aidl
6784new file mode 100755
6785index 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;
6846diff --git a/src/java/com/mediatek/internal/telephony/NetworkInfoWithAcT.java b/src/java/com/mediatek/internal/telephony/NetworkInfoWithAcT.java
6847new file mode 100755
6848index 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+}
7053diff --git a/src/java/com/mediatek/internal/telephony/NetworkManager.java b/src/java/com/mediatek/internal/telephony/NetworkManager.java
7054new file mode 100755
7055index 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+
7160diff --git a/src/java/com/mediatek/internal/telephony/RadioCapabilitySwitchUtil.java b/src/java/com/mediatek/internal/telephony/RadioCapabilitySwitchUtil.java
7161new file mode 100755
7162index 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+
7476diff --git a/src/java/com/mediatek/internal/telephony/dataconnection/FdManager.java b/src/java/com/mediatek/internal/telephony/dataconnection/FdManager.java
7477new file mode 100755
7478index 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+
7903diff --git a/src/java/com/mediatek/internal/telephony/uicc/IccCardProxyEx.java b/src/java/com/mediatek/internal/telephony/uicc/IccCardProxyEx.java
7904new file mode 100755
7905index 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+}
8299diff --git a/src/java/com/mediatek/internal/telephony/worldphone/IWorldPhone.java b/src/java/com/mediatek/internal/telephony/worldphone/IWorldPhone.java
8300new file mode 100755
8301index 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+}
8391diff --git a/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneOm.java b/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneOm.java
8392new file mode 100755
8393index 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+}
9309diff --git a/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneUtil.java b/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneUtil.java
9310new file mode 100755
9311index 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+}
9561diff --git a/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneWrapper.java b/src/java/com/mediatek/internal/telephony/worldphone/WorldPhoneWrapper.java
9562new file mode 100755
9563index 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--
96541.9.1