/* * Copyright (C) 2006, 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.internal.telephony.uicc; import android.content.Context; import android.os.AsyncResult; import android.os.Handler; import android.os.Message; import android.os.Registrant; import android.os.RegistrantList; import android.telephony.Rlog; import com.android.internal.telephony.CommandsInterface; import com.android.internal.telephony.PhoneConstants; import com.android.internal.telephony.uicc.IccCardApplicationStatus.AppState; import com.android.internal.telephony.uicc.IccCardApplicationStatus.AppType; import com.android.internal.telephony.uicc.IccCardApplicationStatus.PersoSubState; import com.android.internal.telephony.uicc.IccCardStatus.PinState; import com.android.internal.telephony.SubscriptionController; import java.io.FileDescriptor; import java.io.PrintWriter; /** * {@hide} */ public class UiccCardApplication { private static final String LOG_TAG = "UiccCardApplication"; private static final boolean DBG = true; private static final int EVENT_PIN1_PUK1_DONE = 1; private static final int EVENT_CHANGE_PIN1_DONE = 2; private static final int EVENT_CHANGE_PIN2_DONE = 3; private static final int EVENT_QUERY_FACILITY_FDN_DONE = 4; private static final int EVENT_CHANGE_FACILITY_FDN_DONE = 5; private static final int EVENT_QUERY_FACILITY_LOCK_DONE = 6; private static final int EVENT_CHANGE_FACILITY_LOCK_DONE = 7; private static final int EVENT_PIN2_PUK2_DONE = 8; private static final int EVENT_RADIO_UNAVAILABLE = 9; /** * These values are for authContext (parameter P2) per 3GPP TS 31.102 (Section 7.1.2) */ public static final int AUTH_CONTEXT_EAP_SIM = 128; public static final int AUTH_CONTEXT_EAP_AKA = 129; public static final int AUTH_CONTEXT_UNDEFINED = -1; private final Object mLock = new Object(); private UiccCard mUiccCard; //parent private AppState mAppState; private AppType mAppType; private int mAuthContext; private PersoSubState mPersoSubState; private String mAid; private String mAppLabel; private boolean mPin1Replaced; private PinState mPin1State; private PinState mPin2State; private boolean mIccFdnEnabled; private boolean mDesiredFdnEnabled; private boolean mIccLockEnabled; private boolean mDesiredPinLocked; private boolean mIccFdnAvailable = true; // Default is enabled. private CommandsInterface mCi; private Context mContext; private IccRecords mIccRecords; private IccFileHandler mIccFh; private boolean mDestroyed;//set to true once this App is commanded to be disposed of. private RegistrantList mReadyRegistrants = new RegistrantList(); private RegistrantList mPinLockedRegistrants = new RegistrantList(); private RegistrantList mNetworkLockedRegistrants = new RegistrantList(); UiccCardApplication(UiccCard uiccCard, IccCardApplicationStatus as, Context c, CommandsInterface ci) { if (DBG) log("Creating UiccApp: " + as); mUiccCard = uiccCard; mAppState = as.app_state; mAppType = as.app_type; mAuthContext = getAuthContext(mAppType); mPersoSubState = as.perso_substate; mAid = as.aid; mAppLabel = as.app_label; mPin1Replaced = (as.pin1_replaced != 0); mPin1State = as.pin1; mPin2State = as.pin2; mContext = c; mCi = ci; mIccFh = createIccFileHandler(as.app_type); mIccRecords = createIccRecords(as.app_type, mContext, mCi); if (mAppState == AppState.APPSTATE_READY) { queryFdn(); queryPin1State(); } mCi.registerForNotAvailable(mHandler, EVENT_RADIO_UNAVAILABLE, null); } void update (IccCardApplicationStatus as, Context c, CommandsInterface ci) { synchronized (mLock) { if (mDestroyed) { loge("Application updated after destroyed! Fix me!"); return; } if (DBG) log(mAppType + " update. New " + as); mContext = c; mCi = ci; AppType oldAppType = mAppType; AppState oldAppState = mAppState; PersoSubState oldPersoSubState = mPersoSubState; mAppType = as.app_type; mAuthContext = getAuthContext(mAppType); mAppState = as.app_state; mPersoSubState = as.perso_substate; mAid = as.aid; mAppLabel = as.app_label; mPin1Replaced = (as.pin1_replaced != 0); mPin1State = as.pin1; mPin2State = as.pin2; if (mAppType != oldAppType) { if (mIccFh != null) { mIccFh.dispose();} if (mIccRecords != null) { mIccRecords.dispose();} mIccFh = createIccFileHandler(as.app_type); mIccRecords = createIccRecords(as.app_type, c, ci); } if (mPersoSubState != oldPersoSubState && mPersoSubState == PersoSubState.PERSOSUBSTATE_SIM_NETWORK) { notifyNetworkLockedRegistrantsIfNeeded(null); } if (mAppState != oldAppState) { if (DBG) log(oldAppType + " changed state: " + oldAppState + " -> " + mAppState); // If the app state turns to APPSTATE_READY, then query FDN status, //as it might have failed in earlier attempt. if (mAppState == AppState.APPSTATE_READY) { queryFdn(); queryPin1State(); } notifyPinLockedRegistrantsIfNeeded(null); notifyReadyRegistrantsIfNeeded(null); } } } void dispose() { synchronized (mLock) { if (DBG) log(mAppType + " being Disposed"); mDestroyed = true; if (mIccRecords != null) { mIccRecords.dispose();} if (mIccFh != null) { mIccFh.dispose();} mIccRecords = null; mIccFh = null; mCi.unregisterForNotAvailable(mHandler); } } private IccRecords createIccRecords(AppType type, Context c, CommandsInterface ci) { if (type == AppType.APPTYPE_USIM || type == AppType.APPTYPE_SIM) { return new SIMRecords(this, c, ci); } else if (type == AppType.APPTYPE_RUIM || type == AppType.APPTYPE_CSIM){ return new RuimRecords(this, c, ci); } else if (type == AppType.APPTYPE_ISIM) { return new IsimUiccRecords(this, c, ci); } else { // Unknown app type (maybe detection is still in progress) return null; } } private IccFileHandler createIccFileHandler(AppType type) { switch (type) { case APPTYPE_SIM: return new SIMFileHandler(this, mAid, mCi); case APPTYPE_RUIM: return new RuimFileHandler(this, mAid, mCi); case APPTYPE_USIM: return new UsimFileHandler(this, mAid, mCi); case APPTYPE_CSIM: return new CsimFileHandler(this, mAid, mCi); case APPTYPE_ISIM: return new IsimFileHandler(this, mAid, mCi); default: return null; } } /** Assumes mLock is held. */ void queryFdn() { //This shouldn't change run-time. So needs to be called only once. int serviceClassX; serviceClassX = CommandsInterface.SERVICE_CLASS_VOICE + CommandsInterface.SERVICE_CLASS_DATA + CommandsInterface.SERVICE_CLASS_FAX; mCi.queryFacilityLockForApp ( CommandsInterface.CB_FACILITY_BA_FD, "", serviceClassX, mAid, mHandler.obtainMessage(EVENT_QUERY_FACILITY_FDN_DONE)); } /** * Interpret EVENT_QUERY_FACILITY_LOCK_DONE * @param ar is asyncResult of Query_Facility_Locked */ private void onQueryFdnEnabled(AsyncResult ar) { synchronized (mLock) { if (ar.exception != null) { if (DBG) log("Error in querying facility lock:" + ar.exception); return; } int[] result = (int[])ar.result; if(result.length != 0) { //0 - Available & Disabled, 1-Available & Enabled, 2-Unavailable. if (result[0] == 2) { mIccFdnEnabled = false; mIccFdnAvailable = false; } else { mIccFdnEnabled = (result[0] == 1) ? true : false; mIccFdnAvailable = true; } log("Query facility FDN : FDN service available: "+ mIccFdnAvailable +" enabled: " + mIccFdnEnabled); } else { loge("Bogus facility lock response"); } } } private void onChangeFdnDone(AsyncResult ar) { synchronized (mLock) { int attemptsRemaining = -1; if (ar.exception == null) { mIccFdnEnabled = mDesiredFdnEnabled; if (DBG) log("EVENT_CHANGE_FACILITY_FDN_DONE: " + "mIccFdnEnabled=" + mIccFdnEnabled); } else { attemptsRemaining = parsePinPukErrorResult(ar); loge("Error change facility fdn with exception " + ar.exception); } Message response = (Message)ar.userObj; response.arg1 = attemptsRemaining; AsyncResult.forMessage(response).exception = ar.exception; response.sendToTarget(); } } /** REMOVE when mIccLockEnabled is not needed, assumes mLock is held */ private void queryPin1State() { int serviceClassX = CommandsInterface.SERVICE_CLASS_VOICE + CommandsInterface.SERVICE_CLASS_DATA + CommandsInterface.SERVICE_CLASS_FAX; mCi.queryFacilityLockForApp ( CommandsInterface.CB_FACILITY_BA_SIM, "", serviceClassX, mAid, mHandler.obtainMessage(EVENT_QUERY_FACILITY_LOCK_DONE)); } /** REMOVE when mIccLockEnabled is not needed*/ private void onQueryFacilityLock(AsyncResult ar) { synchronized (mLock) { if(ar.exception != null) { if (DBG) log("Error in querying facility lock:" + ar.exception); return; } int[] ints = (int[])ar.result; if(ints.length != 0) { if (DBG) log("Query facility lock : " + ints[0]); mIccLockEnabled = (ints[0] != 0); if (mIccLockEnabled) { mPinLockedRegistrants.notifyRegistrants(); } // Sanity check: we expect mPin1State to match mIccLockEnabled. // When mPin1State is DISABLED mIccLockEanbled should be false. // When mPin1State is ENABLED mIccLockEnabled should be true. // // Here we validate these assumptions to assist in identifying which ril/radio's // have not correctly implemented GET_SIM_STATUS switch (mPin1State) { case PINSTATE_DISABLED: if (mIccLockEnabled) { loge("QUERY_FACILITY_LOCK:enabled GET_SIM_STATUS.Pin1:disabled." + " Fixme"); } break; case PINSTATE_ENABLED_NOT_VERIFIED: case PINSTATE_ENABLED_VERIFIED: case PINSTATE_ENABLED_BLOCKED: case PINSTATE_ENABLED_PERM_BLOCKED: if (!mIccLockEnabled) { loge("QUERY_FACILITY_LOCK:disabled GET_SIM_STATUS.Pin1:enabled." + " Fixme"); } case PINSTATE_UNKNOWN: default: if (DBG) log("Ignoring: pin1state=" + mPin1State); break; } } else { loge("Bogus facility lock response"); } } } /** REMOVE when mIccLockEnabled is not needed */ private void onChangeFacilityLock(AsyncResult ar) { synchronized (mLock) { int attemptsRemaining = -1; if (ar.exception == null) { mIccLockEnabled = mDesiredPinLocked; if (DBG) log( "EVENT_CHANGE_FACILITY_LOCK_DONE: mIccLockEnabled= " + mIccLockEnabled); } else { attemptsRemaining = parsePinPukErrorResult(ar); loge("Error change facility lock with exception " + ar.exception); } Message response = (Message)ar.userObj; AsyncResult.forMessage(response).exception = ar.exception; response.arg1 = attemptsRemaining; response.sendToTarget(); } } /** * Parse the error response to obtain number of attempts remaining */ private int parsePinPukErrorResult(AsyncResult ar) { int[] result = (int[]) ar.result; if (result == null) { return -1; } else { int length = result.length; int attemptsRemaining = -1; if (length > 0) { attemptsRemaining = result[0]; } log("parsePinPukErrorResult: attemptsRemaining=" + attemptsRemaining); return attemptsRemaining; } } private Handler mHandler = new Handler() { @Override public void handleMessage(Message msg){ AsyncResult ar; if (mDestroyed) { loge("Received message " + msg + "[" + msg.what + "] while being destroyed. Ignoring."); return; } switch (msg.what) { case EVENT_PIN1_PUK1_DONE: case EVENT_PIN2_PUK2_DONE: case EVENT_CHANGE_PIN1_DONE: case EVENT_CHANGE_PIN2_DONE: // a PIN/PUK/PIN2/PUK2 complete // request has completed. ar.userObj is the response Message int attemptsRemaining = -1; ar = (AsyncResult)msg.obj; if ((ar.exception != null) && (ar.result != null)) { attemptsRemaining = parsePinPukErrorResult(ar); } Message response = (Message)ar.userObj; AsyncResult.forMessage(response).exception = ar.exception; response.arg1 = attemptsRemaining; response.sendToTarget(); break; case EVENT_QUERY_FACILITY_FDN_DONE: ar = (AsyncResult)msg.obj; onQueryFdnEnabled(ar); break; case EVENT_CHANGE_FACILITY_FDN_DONE: ar = (AsyncResult)msg.obj; onChangeFdnDone(ar); break; case EVENT_QUERY_FACILITY_LOCK_DONE: ar = (AsyncResult)msg.obj; onQueryFacilityLock(ar); break; case EVENT_CHANGE_FACILITY_LOCK_DONE: ar = (AsyncResult)msg.obj; onChangeFacilityLock(ar); break; case EVENT_RADIO_UNAVAILABLE: if (DBG) log("handleMessage (EVENT_RADIO_UNAVAILABLE)"); mAppState = AppState.APPSTATE_UNKNOWN; break; default: loge("Unknown Event " + msg.what); } } }; public void registerForReady(Handler h, int what, Object obj) { synchronized (mLock) { Registrant r = new Registrant (h, what, obj); mReadyRegistrants.add(r); notifyReadyRegistrantsIfNeeded(r); } } public void unregisterForReady(Handler h) { synchronized (mLock) { mReadyRegistrants.remove(h); } } /** * Notifies handler of any transition into State.isPinLocked() */ public void registerForLocked(Handler h, int what, Object obj) { synchronized (mLock) { Registrant r = new Registrant (h, what, obj); mPinLockedRegistrants.add(r); notifyPinLockedRegistrantsIfNeeded(r); } } public void unregisterForLocked(Handler h) { synchronized (mLock) { mPinLockedRegistrants.remove(h); } } /** * Notifies handler of any transition into State.NETWORK_LOCKED */ public void registerForNetworkLocked(Handler h, int what, Object obj) { synchronized (mLock) { Registrant r = new Registrant (h, what, obj); mNetworkLockedRegistrants.add(r); notifyNetworkLockedRegistrantsIfNeeded(r); } } public void unregisterForNetworkLocked(Handler h) { synchronized (mLock) { mNetworkLockedRegistrants.remove(h); } } /** * Notifies specified registrant, assume mLock is held. * * @param r Registrant to be notified. If null - all registrants will be notified */ private void notifyReadyRegistrantsIfNeeded(Registrant r) { if (mDestroyed) { return; } if (mAppState == AppState.APPSTATE_READY) { if (mPin1State == PinState.PINSTATE_ENABLED_NOT_VERIFIED || mPin1State == PinState.PINSTATE_ENABLED_BLOCKED || mPin1State == PinState.PINSTATE_ENABLED_PERM_BLOCKED) { loge("Sanity check failed! APPSTATE is ready while PIN1 is not verified!!!"); // Don't notify if application is in insane state return; } if (r == null) { if (DBG) log("Notifying registrants: READY"); mReadyRegistrants.notifyRegistrants(); } else { if (DBG) log("Notifying 1 registrant: READY"); r.notifyRegistrant(new AsyncResult(null, null, null)); } } } /** * Notifies specified registrant, assume mLock is held. * * @param r Registrant to be notified. If null - all registrants will be notified */ private void notifyPinLockedRegistrantsIfNeeded(Registrant r) { if (mDestroyed) { return; } if (mAppState == AppState.APPSTATE_PIN || mAppState == AppState.APPSTATE_PUK) { if (mPin1State == PinState.PINSTATE_ENABLED_VERIFIED || mPin1State == PinState.PINSTATE_DISABLED) { loge("Sanity check failed! APPSTATE is locked while PIN1 is not!!!"); //Don't notify if application is in insane state return; } if (r == null) { if (DBG) log("Notifying registrants: LOCKED"); mPinLockedRegistrants.notifyRegistrants(); } else { if (DBG) log("Notifying 1 registrant: LOCKED"); r.notifyRegistrant(new AsyncResult(null, null, null)); } } } /** * Notifies specified registrant, assume mLock is held. * * @param r Registrant to be notified. If null - all registrants will be notified */ private void notifyNetworkLockedRegistrantsIfNeeded(Registrant r) { if (mDestroyed) { return; } if (mAppState == AppState.APPSTATE_SUBSCRIPTION_PERSO && mPersoSubState == PersoSubState.PERSOSUBSTATE_SIM_NETWORK) { if (r == null) { if (DBG) log("Notifying registrants: NETWORK_LOCKED"); mNetworkLockedRegistrants.notifyRegistrants(); } else { if (DBG) log("Notifying 1 registrant: NETWORK_LOCED"); r.notifyRegistrant(new AsyncResult(null, null, null)); } } } public AppState getState() { synchronized (mLock) { return mAppState; } } public AppType getType() { synchronized (mLock) { return mAppType; } } public int getAuthContext() { synchronized (mLock) { return mAuthContext; } } /** * Returns the authContext based on the type of UiccCard. * * @param appType the app type * @return authContext corresponding to the type or AUTH_CONTEXT_UNDEFINED if appType not * supported */ private static int getAuthContext(AppType appType) { int authContext; switch (appType) { case APPTYPE_SIM: authContext = AUTH_CONTEXT_EAP_SIM; break; case APPTYPE_USIM: authContext = AUTH_CONTEXT_EAP_AKA; break; default: authContext = AUTH_CONTEXT_UNDEFINED; break; } return authContext; } public PersoSubState getPersoSubState() { synchronized (mLock) { return mPersoSubState; } } public String getAid() { synchronized (mLock) { return mAid; } } public String getAppLabel() { return mAppLabel; } public PinState getPin1State() { synchronized (mLock) { if (mPin1Replaced) { return mUiccCard.getUniversalPinState(); } return mPin1State; } } public IccFileHandler getIccFileHandler() { synchronized (mLock) { return mIccFh; } } public IccRecords getIccRecords() { synchronized (mLock) { return mIccRecords; } } /** * Supply the ICC PIN to the ICC * * When the operation is complete, onComplete will be sent to its * Handler. * * onComplete.obj will be an AsyncResult * onComplete.arg1 = remaining attempts before puk locked or -1 if unknown * * ((AsyncResult)onComplete.obj).exception == null on success * ((AsyncResult)onComplete.obj).exception != null on fail * * If the supplied PIN is incorrect: * ((AsyncResult)onComplete.obj).exception != null * && ((AsyncResult)onComplete.obj).exception * instanceof com.android.internal.telephony.gsm.CommandException) * && ((CommandException)(((AsyncResult)onComplete.obj).exception)) * .getCommandError() == CommandException.Error.PASSWORD_INCORRECT */ public void supplyPin (String pin, Message onComplete) { synchronized (mLock) { mCi.supplyIccPinForApp(pin, mAid, mHandler.obtainMessage(EVENT_PIN1_PUK1_DONE, onComplete)); } } /** * Supply the ICC PUK to the ICC * * When the operation is complete, onComplete will be sent to its * Handler. * * onComplete.obj will be an AsyncResult * onComplete.arg1 = remaining attempts before Icc will be permanently unusable * or -1 if unknown * * ((AsyncResult)onComplete.obj).exception == null on success * ((AsyncResult)onComplete.obj).exception != null on fail * * If the supplied PIN is incorrect: * ((AsyncResult)onComplete.obj).exception != null * && ((AsyncResult)onComplete.obj).exception * instanceof com.android.internal.telephony.gsm.CommandException) * && ((CommandException)(((AsyncResult)onComplete.obj).exception)) * .getCommandError() == CommandException.Error.PASSWORD_INCORRECT * * */ public void supplyPuk (String puk, String newPin, Message onComplete) { synchronized (mLock) { mCi.supplyIccPukForApp(puk, newPin, mAid, mHandler.obtainMessage(EVENT_PIN1_PUK1_DONE, onComplete)); } } public void supplyPin2 (String pin2, Message onComplete) { synchronized (mLock) { mCi.supplyIccPin2ForApp(pin2, mAid, mHandler.obtainMessage(EVENT_PIN2_PUK2_DONE, onComplete)); } } public void supplyPuk2 (String puk2, String newPin2, Message onComplete) { synchronized (mLock) { mCi.supplyIccPuk2ForApp(puk2, newPin2, mAid, mHandler.obtainMessage(EVENT_PIN2_PUK2_DONE, onComplete)); } } public void supplyNetworkDepersonalization (String pin, Message onComplete) { synchronized (mLock) { if (DBG) log("supplyNetworkDepersonalization"); mCi.supplyNetworkDepersonalization(pin, onComplete); } } /** * Check whether ICC pin lock is enabled * This is a sync call which returns the cached pin enabled state * * @return true for ICC locked enabled * false for ICC locked disabled */ public boolean getIccLockEnabled() { return mIccLockEnabled; /* STOPSHIP: Remove line above and all code associated with setting mIccLockEanbled once all RIL correctly sends the pin1 state. // Use getPin1State to take into account pin1Replaced flag PinState pinState = getPin1State(); return pinState == PinState.PINSTATE_ENABLED_NOT_VERIFIED || pinState == PinState.PINSTATE_ENABLED_VERIFIED || pinState == PinState.PINSTATE_ENABLED_BLOCKED || pinState == PinState.PINSTATE_ENABLED_PERM_BLOCKED;*/ } /** * Check whether ICC fdn (fixed dialing number) is enabled * This is a sync call which returns the cached pin enabled state * * @return true for ICC fdn enabled * false for ICC fdn disabled */ public boolean getIccFdnEnabled() { synchronized (mLock) { return mIccFdnEnabled; } } /** * Check whether fdn (fixed dialing number) service is available. * @return true if ICC fdn service available * false if ICC fdn service not available */ public boolean getIccFdnAvailable() { return mIccFdnAvailable; } /** * Set the ICC pin lock enabled or disabled * When the operation is complete, onComplete will be sent to its handler * * @param enabled "true" for locked "false" for unlocked. * @param password needed to change the ICC pin state, aka. Pin1 * @param onComplete * onComplete.obj will be an AsyncResult * ((AsyncResult)onComplete.obj).exception == null on success * ((AsyncResult)onComplete.obj).exception != null on fail */ public void setIccLockEnabled (boolean enabled, String password, Message onComplete) { synchronized (mLock) { int serviceClassX; serviceClassX = CommandsInterface.SERVICE_CLASS_VOICE + CommandsInterface.SERVICE_CLASS_DATA + CommandsInterface.SERVICE_CLASS_FAX; mDesiredPinLocked = enabled; mCi.setFacilityLockForApp(CommandsInterface.CB_FACILITY_BA_SIM, enabled, password, serviceClassX, mAid, mHandler.obtainMessage(EVENT_CHANGE_FACILITY_LOCK_DONE, onComplete)); } } /** * Set the ICC fdn enabled or disabled * When the operation is complete, onComplete will be sent to its handler * * @param enabled "true" for locked "false" for unlocked. * @param password needed to change the ICC fdn enable, aka Pin2 * @param onComplete * onComplete.obj will be an AsyncResult * ((AsyncResult)onComplete.obj).exception == null on success * ((AsyncResult)onComplete.obj).exception != null on fail */ public void setIccFdnEnabled (boolean enabled, String password, Message onComplete) { synchronized (mLock) { int serviceClassX; serviceClassX = CommandsInterface.SERVICE_CLASS_VOICE + CommandsInterface.SERVICE_CLASS_DATA + CommandsInterface.SERVICE_CLASS_FAX + CommandsInterface.SERVICE_CLASS_SMS; mDesiredFdnEnabled = enabled; mCi.setFacilityLockForApp(CommandsInterface.CB_FACILITY_BA_FD, enabled, password, serviceClassX, mAid, mHandler.obtainMessage(EVENT_CHANGE_FACILITY_FDN_DONE, onComplete)); } } /** * Change the ICC password used in ICC pin lock * When the operation is complete, onComplete will be sent to its handler * * @param oldPassword is the old password * @param newPassword is the new password * @param onComplete * onComplete.obj will be an AsyncResult * onComplete.arg1 = attempts remaining or -1 if unknown * ((AsyncResult)onComplete.obj).exception == null on success * ((AsyncResult)onComplete.obj).exception != null on fail */ public void changeIccLockPassword(String oldPassword, String newPassword, Message onComplete) { synchronized (mLock) { if (DBG) log("changeIccLockPassword"); mCi.changeIccPinForApp(oldPassword, newPassword, mAid, mHandler.obtainMessage(EVENT_CHANGE_PIN1_DONE, onComplete)); } } /** * Change the ICC password used in ICC fdn enable * When the operation is complete, onComplete will be sent to its handler * * @param oldPassword is the old password * @param newPassword is the new password * @param onComplete * onComplete.obj will be an AsyncResult * ((AsyncResult)onComplete.obj).exception == null on success * ((AsyncResult)onComplete.obj).exception != null on fail */ public void changeIccFdnPassword(String oldPassword, String newPassword, Message onComplete) { synchronized (mLock) { if (DBG) log("changeIccFdnPassword"); mCi.changeIccPin2ForApp(oldPassword, newPassword, mAid, mHandler.obtainMessage(EVENT_CHANGE_PIN2_DONE, onComplete)); } } /** * @return true if ICC card is PIN2 blocked */ public boolean getIccPin2Blocked() { synchronized (mLock) { return mPin2State == PinState.PINSTATE_ENABLED_BLOCKED; } } /** * @return true if ICC card is PUK2 blocked */ public boolean getIccPuk2Blocked() { synchronized (mLock) { return mPin2State == PinState.PINSTATE_ENABLED_PERM_BLOCKED; } } public int getPhoneId() { return mUiccCard.getPhoneId(); } protected UiccCard getUiccCard() { return mUiccCard; } private void log(String msg) { Rlog.d(LOG_TAG, msg); } private void loge(String msg) { Rlog.e(LOG_TAG, msg); } public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { pw.println("UiccCardApplication: " + this); pw.println(" mUiccCard=" + mUiccCard); pw.println(" mAppState=" + mAppState); pw.println(" mAppType=" + mAppType); pw.println(" mPersoSubState=" + mPersoSubState); pw.println(" mAid=" + mAid); pw.println(" mAppLabel=" + mAppLabel); pw.println(" mPin1Replaced=" + mPin1Replaced); pw.println(" mPin1State=" + mPin1State); pw.println(" mPin2State=" + mPin2State); pw.println(" mIccFdnEnabled=" + mIccFdnEnabled); pw.println(" mDesiredFdnEnabled=" + mDesiredFdnEnabled); pw.println(" mIccLockEnabled=" + mIccLockEnabled); pw.println(" mDesiredPinLocked=" + mDesiredPinLocked); pw.println(" mCi=" + mCi); pw.println(" mIccRecords=" + mIccRecords); pw.println(" mIccFh=" + mIccFh); pw.println(" mDestroyed=" + mDestroyed); pw.println(" mReadyRegistrants: size=" + mReadyRegistrants.size()); for (int i = 0; i < mReadyRegistrants.size(); i++) { pw.println(" mReadyRegistrants[" + i + "]=" + ((Registrant)mReadyRegistrants.get(i)).getHandler()); } pw.println(" mPinLockedRegistrants: size=" + mPinLockedRegistrants.size()); for (int i = 0; i < mPinLockedRegistrants.size(); i++) { pw.println(" mPinLockedRegistrants[" + i + "]=" + ((Registrant)mPinLockedRegistrants.get(i)).getHandler()); } pw.println(" mNetworkLockedRegistrants: size=" + mNetworkLockedRegistrants.size()); for (int i = 0; i < mNetworkLockedRegistrants.size(); i++) { pw.println(" mNetworkLockedRegistrants[" + i + "]=" + ((Registrant)mNetworkLockedRegistrants.get(i)).getHandler()); } pw.flush(); } }