1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.keyguard;
18
19import android.content.Context;
20import android.content.res.ColorStateList;
21import android.content.res.Resources;
22import android.app.Activity;
23import android.app.AlertDialog;
24import android.app.Dialog;
25import android.app.ProgressDialog;
26import android.graphics.Color;
27import android.os.RemoteException;
28import android.os.ServiceManager;
29import android.telephony.SubscriptionInfo;
30import android.telephony.SubscriptionManager;
31import android.telephony.TelephonyManager;
32import android.util.AttributeSet;
33import android.util.Log;
34import android.view.WindowManager;
35import android.widget.ImageView;
36
37import com.android.internal.telephony.ITelephony;
38import com.android.internal.telephony.IccCardConstants;
39import com.android.internal.telephony.PhoneConstants;
40import com.android.internal.telephony.IccCardConstants.State;
41
42
43/**
44 * Displays a PIN pad for entering a PUK (Pin Unlock Kode) provided by a carrier.
45 */
46public class KeyguardSimPukView extends KeyguardPinBasedInputView {
47    private static final String LOG_TAG = "KeyguardSimPukView";
48    private static final boolean DEBUG = KeyguardConstants.DEBUG;
49    public static final String TAG = "KeyguardSimPukView";
50
51    private ProgressDialog mSimUnlockProgressDialog = null;
52    private CheckSimPuk mCheckSimPukThread;
53    private String mPukText;
54    private String mPinText;
55    private StateMachine mStateMachine = new StateMachine();
56    private AlertDialog mRemainingAttemptsDialog;
57    private int mSubId;
58    private ImageView mSimImageView;
59
60    KeyguardUpdateMonitorCallback mUpdateMonitorCallback = new KeyguardUpdateMonitorCallback() {
61        @Override
62        public void onSimStateChanged(int subId, int slotId, State simState) {
63           if (DEBUG) Log.v(TAG, "onSimStateChanged(subId=" + subId + ",state=" + simState + ")");
64           resetState();
65       };
66    };
67
68    public KeyguardSimPukView(Context context) {
69        this(context, null);
70    }
71
72    public KeyguardSimPukView(Context context, AttributeSet attrs) {
73        super(context, attrs);
74    }
75
76    private class StateMachine {
77        final int ENTER_PUK = 0;
78        final int ENTER_PIN = 1;
79        final int CONFIRM_PIN = 2;
80        final int DONE = 3;
81        private int state = ENTER_PUK;
82
83        public void next() {
84            int msg = 0;
85            if (state == ENTER_PUK) {
86                if (checkPuk()) {
87                    state = ENTER_PIN;
88                    msg = R.string.kg_puk_enter_pin_hint;
89                } else {
90                    msg = R.string.kg_invalid_sim_puk_hint;
91                }
92            } else if (state == ENTER_PIN) {
93                if (checkPin()) {
94                    state = CONFIRM_PIN;
95                    msg = R.string.kg_enter_confirm_pin_hint;
96                } else {
97                    msg = R.string.kg_invalid_sim_pin_hint;
98                }
99            } else if (state == CONFIRM_PIN) {
100                if (confirmPin()) {
101                    state = DONE;
102                    msg = R.string.keyguard_sim_unlock_progress_dialog_message;
103                    updateSim();
104                } else {
105                    state = ENTER_PIN; // try again?
106                    msg = R.string.kg_invalid_confirm_pin_hint;
107                }
108            }
109            resetPasswordText(true /* animate */, true /* announce */);
110            if (msg != 0) {
111                mSecurityMessageDisplay.setMessage(msg);
112            }
113        }
114
115        void reset() {
116            mPinText="";
117            mPukText="";
118            state = ENTER_PUK;
119            KeyguardUpdateMonitor monitor = KeyguardUpdateMonitor.getInstance(mContext);
120            mSubId = monitor.getNextSubIdForState(IccCardConstants.State.PUK_REQUIRED);
121            if (SubscriptionManager.isValidSubscriptionId(mSubId)) {
122                int count = TelephonyManager.getDefault().getSimCount();
123                Resources rez = getResources();
124                final String msg;
125                int color = Color.WHITE;
126                if (count < 2) {
127                    msg = rez.getString(R.string.kg_puk_enter_puk_hint);
128                } else {
129                    SubscriptionInfo info = monitor.getSubscriptionInfoForSubId(mSubId);
130                    CharSequence displayName = info != null ? info.getDisplayName() : "";
131                    msg = rez.getString(R.string.kg_puk_enter_puk_hint_multi, displayName);
132                    if (info != null) {
133                        color = info.getIconTint();
134                    }
135                }
136                mSecurityMessageDisplay.setMessage(msg);
137                mSimImageView.setImageTintList(ColorStateList.valueOf(color));
138            }
139            mPasswordEntry.requestFocus();
140        }
141    }
142
143    @Override
144    protected int getPromtReasonStringRes(int reason) {
145        // No message on SIM Puk
146        return 0;
147    }
148
149    private String getPukPasswordErrorMessage(int attemptsRemaining) {
150        String displayMessage;
151
152        if (attemptsRemaining == 0) {
153            displayMessage = getContext().getString(R.string.kg_password_wrong_puk_code_dead);
154        } else if (attemptsRemaining > 0) {
155            displayMessage = getContext().getResources()
156                    .getQuantityString(R.plurals.kg_password_wrong_puk_code, attemptsRemaining,
157                            attemptsRemaining);
158        } else {
159            displayMessage = getContext().getString(R.string.kg_password_puk_failed);
160        }
161        if (DEBUG) Log.d(LOG_TAG, "getPukPasswordErrorMessage:"
162                + " attemptsRemaining=" + attemptsRemaining + " displayMessage=" + displayMessage);
163        return displayMessage;
164    }
165
166    @Override
167    public void resetState() {
168        super.resetState();
169        mStateMachine.reset();
170    }
171
172    @Override
173    protected boolean shouldLockout(long deadline) {
174        // SIM PUK doesn't have a timed lockout
175        return false;
176    }
177
178    @Override
179    protected int getPasswordTextViewId() {
180        return R.id.pukEntry;
181    }
182
183    @Override
184    protected void onFinishInflate() {
185        super.onFinishInflate();
186
187        if (mEcaView instanceof EmergencyCarrierArea) {
188            ((EmergencyCarrierArea) mEcaView).setCarrierTextVisible(true);
189        }
190        mSimImageView = findViewById(R.id.keyguard_sim);
191    }
192
193    @Override
194    protected void onAttachedToWindow() {
195        super.onAttachedToWindow();
196        KeyguardUpdateMonitor.getInstance(mContext).registerCallback(mUpdateMonitorCallback);
197    }
198
199    @Override
200    protected void onDetachedFromWindow() {
201        super.onDetachedFromWindow();
202        KeyguardUpdateMonitor.getInstance(mContext).removeCallback(mUpdateMonitorCallback);
203    }
204
205    @Override
206    public void showUsabilityHint() {
207    }
208
209    @Override
210    public void onPause() {
211        // dismiss the dialog.
212        if (mSimUnlockProgressDialog != null) {
213            mSimUnlockProgressDialog.dismiss();
214            mSimUnlockProgressDialog = null;
215        }
216    }
217
218    /**
219     * Since the IPC can block, we want to run the request in a separate thread
220     * with a callback.
221     */
222    private abstract class CheckSimPuk extends Thread {
223
224        private final String mPin, mPuk;
225        private final int mSubId;
226
227        protected CheckSimPuk(String puk, String pin, int subId) {
228            mPuk = puk;
229            mPin = pin;
230            mSubId = subId;
231        }
232
233        abstract void onSimLockChangedResponse(final int result, final int attemptsRemaining);
234
235        @Override
236        public void run() {
237            try {
238                if (DEBUG) Log.v(TAG, "call supplyPukReportResult()");
239                final int[] result = ITelephony.Stub.asInterface(ServiceManager
240                    .checkService("phone")).supplyPukReportResultForSubscriber(mSubId, mPuk, mPin);
241                if (DEBUG) {
242                    Log.v(TAG, "supplyPukReportResult returned: " + result[0] + " " + result[1]);
243                }
244                post(new Runnable() {
245                    @Override
246                    public void run() {
247                        onSimLockChangedResponse(result[0], result[1]);
248                    }
249                });
250            } catch (RemoteException e) {
251                Log.e(TAG, "RemoteException for supplyPukReportResult:", e);
252                post(new Runnable() {
253                    @Override
254                    public void run() {
255                        onSimLockChangedResponse(PhoneConstants.PIN_GENERAL_FAILURE, -1);
256                    }
257                });
258            }
259        }
260    }
261
262    private Dialog getSimUnlockProgressDialog() {
263        if (mSimUnlockProgressDialog == null) {
264            mSimUnlockProgressDialog = new ProgressDialog(mContext);
265            mSimUnlockProgressDialog.setMessage(
266                    mContext.getString(R.string.kg_sim_unlock_progress_dialog_message));
267            mSimUnlockProgressDialog.setIndeterminate(true);
268            mSimUnlockProgressDialog.setCancelable(false);
269            if (!(mContext instanceof Activity)) {
270                mSimUnlockProgressDialog.getWindow().setType(
271                        WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG);
272            }
273        }
274        return mSimUnlockProgressDialog;
275    }
276
277    private Dialog getPukRemainingAttemptsDialog(int remaining) {
278        String msg = getPukPasswordErrorMessage(remaining);
279        if (mRemainingAttemptsDialog == null) {
280            AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
281            builder.setMessage(msg);
282            builder.setCancelable(false);
283            builder.setNeutralButton(R.string.ok, null);
284            mRemainingAttemptsDialog = builder.create();
285            mRemainingAttemptsDialog.getWindow().setType(
286                    WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG);
287        } else {
288            mRemainingAttemptsDialog.setMessage(msg);
289        }
290        return mRemainingAttemptsDialog;
291    }
292
293    private boolean checkPuk() {
294        // make sure the puk is at least 8 digits long.
295        if (mPasswordEntry.getText().length() == 8) {
296            mPukText = mPasswordEntry.getText();
297            return true;
298        }
299        return false;
300    }
301
302    private boolean checkPin() {
303        // make sure the PIN is between 4 and 8 digits
304        int length = mPasswordEntry.getText().length();
305        if (length >= 4 && length <= 8) {
306            mPinText = mPasswordEntry.getText();
307            return true;
308        }
309        return false;
310    }
311
312    public boolean confirmPin() {
313        return mPinText.equals(mPasswordEntry.getText());
314    }
315
316    private void updateSim() {
317        getSimUnlockProgressDialog().show();
318
319        if (mCheckSimPukThread == null) {
320            mCheckSimPukThread = new CheckSimPuk(mPukText, mPinText, mSubId) {
321                @Override
322                void onSimLockChangedResponse(final int result, final int attemptsRemaining) {
323                    post(new Runnable() {
324                        @Override
325                        public void run() {
326                            if (mSimUnlockProgressDialog != null) {
327                                mSimUnlockProgressDialog.hide();
328                            }
329                            resetPasswordText(true /* animate */,
330                                    result != PhoneConstants.PIN_RESULT_SUCCESS /* announce */);
331                            if (result == PhoneConstants.PIN_RESULT_SUCCESS) {
332                                KeyguardUpdateMonitor.getInstance(getContext())
333                                        .reportSimUnlocked(mSubId);
334                                mCallback.dismiss(true, KeyguardUpdateMonitor.getCurrentUser());
335                            } else {
336                                if (result == PhoneConstants.PIN_PASSWORD_INCORRECT) {
337                                    if (attemptsRemaining <= 2) {
338                                        // this is getting critical - show dialog
339                                        getPukRemainingAttemptsDialog(attemptsRemaining).show();
340                                    } else {
341                                        // show message
342                                        mSecurityMessageDisplay.setMessage(
343                                                getPukPasswordErrorMessage(attemptsRemaining));
344                                    }
345                                } else {
346                                    mSecurityMessageDisplay.setMessage(getContext().getString(
347                                            R.string.kg_password_puk_failed));
348                                }
349                                if (DEBUG) Log.d(LOG_TAG, "verifyPasswordAndUnlock "
350                                        + " UpdateSim.onSimCheckResponse: "
351                                        + " attemptsRemaining=" + attemptsRemaining);
352                                mStateMachine.reset();
353                            }
354                            mCheckSimPukThread = null;
355                        }
356                    });
357                }
358            };
359            mCheckSimPukThread.start();
360        }
361    }
362
363    @Override
364    protected void verifyPasswordAndUnlock() {
365        mStateMachine.next();
366    }
367
368    @Override
369    public void startAppearAnimation() {
370        // noop.
371    }
372
373    @Override
374    public boolean startDisappearAnimation(Runnable finishRunnable) {
375        return false;
376    }
377}
378
379
380