blob: 283d6125fdc55d7a67d45433e3e25c373e3bddcf [file] [log] [blame]
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001/*
2 * Copyright (C) 2008 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.phone;
18
19import android.app.ActionBar;
20import android.app.AlertDialog;
21import android.content.DialogInterface;
22import android.os.AsyncResult;
23import android.os.Bundle;
24import android.os.Handler;
25import android.os.Message;
26import android.util.Log;
27import android.preference.PreferenceActivity;
28import android.preference.PreferenceScreen;
29import android.view.MenuItem;
30import android.view.WindowManager;
31import android.widget.Toast;
32
33import com.android.internal.telephony.CommandException;
34import com.android.internal.telephony.Phone;
35
36/**
37 * FDN settings UI for the Phone app.
38 * Rewritten to look and behave closer to the other preferences.
39 */
40public class FdnSetting extends PreferenceActivity
41 implements EditPinPreference.OnPinEnteredListener, DialogInterface.OnCancelListener {
42
43 private static final String LOG_TAG = PhoneGlobals.LOG_TAG;
44 private static final boolean DBG = false;
45
46 private Phone mPhone;
47
48 /**
49 * Events we handle.
50 * The first is used for toggling FDN enable, the second for the PIN change.
51 */
52 private static final int EVENT_PIN2_ENTRY_COMPLETE = 100;
53 private static final int EVENT_PIN2_CHANGE_COMPLETE = 200;
54
55 // String keys for preference lookup
56 // We only care about the pin preferences here, the manage FDN contacts
57 // Preference is handled solely in xml.
58 private static final String BUTTON_FDN_ENABLE_KEY = "button_fdn_enable_key";
59 private static final String BUTTON_CHANGE_PIN2_KEY = "button_change_pin2_key";
60
61 private EditPinPreference mButtonEnableFDN;
62 private EditPinPreference mButtonChangePin2;
63
64 // State variables
65 private String mOldPin;
66 private String mNewPin;
67 private String mPuk2;
68 private static final int PIN_CHANGE_OLD = 0;
69 private static final int PIN_CHANGE_NEW = 1;
70 private static final int PIN_CHANGE_REENTER = 2;
71 private static final int PIN_CHANGE_PUK = 3;
72 private static final int PIN_CHANGE_NEW_PIN_FOR_PUK = 4;
73 private static final int PIN_CHANGE_REENTER_PIN_FOR_PUK = 5;
74 private int mPinChangeState;
75 private boolean mIsPuk2Locked; // Indicates we know that we are PUK2 blocked.
76
77 private static final String SKIP_OLD_PIN_KEY = "skip_old_pin_key";
78 private static final String PIN_CHANGE_STATE_KEY = "pin_change_state_key";
79 private static final String OLD_PIN_KEY = "old_pin_key";
80 private static final String NEW_PIN_KEY = "new_pin_key";
81 private static final String DIALOG_MESSAGE_KEY = "dialog_message_key";
82 private static final String DIALOG_PIN_ENTRY_KEY = "dialog_pin_entry_key";
83
84 // size limits for the pin.
85 private static final int MIN_PIN_LENGTH = 4;
86 private static final int MAX_PIN_LENGTH = 8;
87
88 /**
89 * Delegate to the respective handlers.
90 */
91 @Override
92 public void onPinEntered(EditPinPreference preference, boolean positiveResult) {
93 if (preference == mButtonEnableFDN) {
94 toggleFDNEnable(positiveResult);
95 } else if (preference == mButtonChangePin2){
96 updatePINChangeState(positiveResult);
97 }
98 }
99
100 /**
101 * Attempt to toggle FDN activation.
102 */
103 private void toggleFDNEnable(boolean positiveResult) {
104 if (!positiveResult) {
105 return;
106 }
107
108 // validate the pin first, before submitting it to the RIL for FDN enable.
109 String password = mButtonEnableFDN.getText();
110 if (validatePin (password, false)) {
111 // get the relevant data for the icc call
112 boolean isEnabled = mPhone.getIccCard().getIccFdnEnabled();
113 Message onComplete = mFDNHandler.obtainMessage(EVENT_PIN2_ENTRY_COMPLETE);
114
115 // make fdn request
116 mPhone.getIccCard().setIccFdnEnabled(!isEnabled, password, onComplete);
117 } else {
118 // throw up error if the pin is invalid.
119 displayMessage(R.string.invalidPin2);
120 }
121
122 mButtonEnableFDN.setText("");
123 }
124
125 /**
126 * Attempt to change the pin.
127 */
128 private void updatePINChangeState(boolean positiveResult) {
129 if (DBG) log("updatePINChangeState positive=" + positiveResult
130 + " mPinChangeState=" + mPinChangeState
131 + " mSkipOldPin=" + mIsPuk2Locked);
132
133 if (!positiveResult) {
134 // reset the state on cancel, either to expect PUK2 or PIN2
135 if (!mIsPuk2Locked) {
136 resetPinChangeState();
137 } else {
138 resetPinChangeStateForPUK2();
139 }
140 return;
141 }
142
143 // Progress through the dialog states, generally in this order:
144 // 1. Enter old pin
145 // 2. Enter new pin
146 // 3. Re-Enter new pin
147 // While handling any error conditions that may show up in between.
148 // Also handle the PUK2 entry, if it is requested.
149 //
150 // In general, if any invalid entries are made, the dialog re-
151 // appears with text to indicate what the issue is.
152 switch (mPinChangeState) {
153 case PIN_CHANGE_OLD:
154 mOldPin = mButtonChangePin2.getText();
155 mButtonChangePin2.setText("");
156 // if the pin is not valid, display a message and reset the state.
157 if (validatePin (mOldPin, false)) {
158 mPinChangeState = PIN_CHANGE_NEW;
159 displayPinChangeDialog();
160 } else {
161 displayPinChangeDialog(R.string.invalidPin2, true);
162 }
163 break;
164 case PIN_CHANGE_NEW:
165 mNewPin = mButtonChangePin2.getText();
166 mButtonChangePin2.setText("");
167 // if the new pin is not valid, display a message and reset the state.
168 if (validatePin (mNewPin, false)) {
169 mPinChangeState = PIN_CHANGE_REENTER;
170 displayPinChangeDialog();
171 } else {
172 displayPinChangeDialog(R.string.invalidPin2, true);
173 }
174 break;
175 case PIN_CHANGE_REENTER:
176 // if the re-entered pin is not valid, display a message and reset the state.
177 if (!mNewPin.equals(mButtonChangePin2.getText())) {
178 mPinChangeState = PIN_CHANGE_NEW;
179 mButtonChangePin2.setText("");
180 displayPinChangeDialog(R.string.mismatchPin2, true);
181 } else {
182 // If the PIN is valid, then we submit the change PIN request.
183 mButtonChangePin2.setText("");
184 Message onComplete = mFDNHandler.obtainMessage(
185 EVENT_PIN2_CHANGE_COMPLETE);
186 mPhone.getIccCard().changeIccFdnPassword(
187 mOldPin, mNewPin, onComplete);
188 }
189 break;
190 case PIN_CHANGE_PUK: {
191 // Doh! too many incorrect requests, PUK requested.
192 mPuk2 = mButtonChangePin2.getText();
193 mButtonChangePin2.setText("");
194 // if the puk is not valid, display
195 // a message and reset the state.
196 if (validatePin (mPuk2, true)) {
197 mPinChangeState = PIN_CHANGE_NEW_PIN_FOR_PUK;
198 displayPinChangeDialog();
199 } else {
200 displayPinChangeDialog(R.string.invalidPuk2, true);
201 }
202 }
203 break;
204 case PIN_CHANGE_NEW_PIN_FOR_PUK:
205 mNewPin = mButtonChangePin2.getText();
206 mButtonChangePin2.setText("");
207 // if the new pin is not valid, display
208 // a message and reset the state.
209 if (validatePin (mNewPin, false)) {
210 mPinChangeState = PIN_CHANGE_REENTER_PIN_FOR_PUK;
211 displayPinChangeDialog();
212 } else {
213 displayPinChangeDialog(R.string.invalidPin2, true);
214 }
215 break;
216 case PIN_CHANGE_REENTER_PIN_FOR_PUK:
217 // if the re-entered pin is not valid, display
218 // a message and reset the state.
219 if (!mNewPin.equals(mButtonChangePin2.getText())) {
220 mPinChangeState = PIN_CHANGE_NEW_PIN_FOR_PUK;
221 mButtonChangePin2.setText("");
222 displayPinChangeDialog(R.string.mismatchPin2, true);
223 } else {
224 // Both puk2 and new pin2 are ready to submit
225 mButtonChangePin2.setText("");
226 Message onComplete = mFDNHandler.obtainMessage(
227 EVENT_PIN2_CHANGE_COMPLETE);
228 mPhone.getIccCard().supplyPuk2(mPuk2, mNewPin, onComplete);
229 }
230 break;
231 }
232 }
233
234 /**
235 * Handler for asynchronous replies from the sim.
236 */
237 private final Handler mFDNHandler = new Handler() {
238 @Override
239 public void handleMessage(Message msg) {
240 switch (msg.what) {
241
242 // when we are enabling FDN, either we are unsuccessful and display
243 // a toast, or just update the UI.
244 case EVENT_PIN2_ENTRY_COMPLETE: {
245 AsyncResult ar = (AsyncResult) msg.obj;
246 if (ar.exception != null) {
247 // see if PUK2 is requested and alert the user accordingly.
248 CommandException ce = (CommandException) ar.exception;
249 if (ce.getCommandError() == CommandException.Error.SIM_PUK2) {
250 // make sure we set the PUK2 state so that we can skip
251 // some redundant behaviour.
252 displayMessage(R.string.fdn_enable_puk2_requested);
253 resetPinChangeStateForPUK2();
254 } else {
255 displayMessage(R.string.pin2_invalid);
256 }
257 }
258 updateEnableFDN();
259 }
260 break;
261
262 // when changing the pin we need to pay attention to whether or not
263 // the error requests a PUK (usually after too many incorrect tries)
264 // Set the state accordingly.
265 case EVENT_PIN2_CHANGE_COMPLETE: {
266 if (DBG)
267 log("Handle EVENT_PIN2_CHANGE_COMPLETE");
268 AsyncResult ar = (AsyncResult) msg.obj;
269 if (ar.exception != null) {
270 CommandException ce = (CommandException) ar.exception;
271 if (ce.getCommandError() == CommandException.Error.SIM_PUK2) {
272 // throw an alert dialog on the screen, displaying the
273 // request for a PUK2. set the cancel listener to
274 // FdnSetting.onCancel().
275 AlertDialog a = new AlertDialog.Builder(FdnSetting.this)
276 .setMessage(R.string.puk2_requested)
277 .setCancelable(true)
278 .setOnCancelListener(FdnSetting.this)
279 .create();
280 a.getWindow().addFlags(
281 WindowManager.LayoutParams.FLAG_DIM_BEHIND);
282 a.show();
283 } else {
284 // set the correct error message depending upon the state.
285 // Reset the state depending upon or knowledge of the PUK state.
286 if (!mIsPuk2Locked) {
287 displayMessage(R.string.badPin2);
288 resetPinChangeState();
289 } else {
290 displayMessage(R.string.badPuk2);
291 resetPinChangeStateForPUK2();
292 }
293 }
294 } else {
295 // reset to normal behaviour on successful change.
296 displayMessage(R.string.pin2_changed);
297 resetPinChangeState();
298 }
299 }
300 break;
301 }
302 }
303 };
304
305 /**
306 * Cancel listener for the PUK2 request alert dialog.
307 */
308 @Override
309 public void onCancel(DialogInterface dialog) {
310 // set the state of the preference and then display the dialog.
311 resetPinChangeStateForPUK2();
312 displayPinChangeDialog(0, true);
313 }
314
315 /**
316 * Display a toast for message, like the rest of the settings.
317 */
318 private final void displayMessage(int strId) {
319 Toast.makeText(this, getString(strId), Toast.LENGTH_SHORT)
320 .show();
321 }
322
323 /**
324 * The next two functions are for updating the message field on the dialog.
325 */
326 private final void displayPinChangeDialog() {
327 displayPinChangeDialog(0, true);
328 }
329
330 private final void displayPinChangeDialog(int strId, boolean shouldDisplay) {
331 int msgId;
332 switch (mPinChangeState) {
333 case PIN_CHANGE_OLD:
334 msgId = R.string.oldPin2Label;
335 break;
336 case PIN_CHANGE_NEW:
337 case PIN_CHANGE_NEW_PIN_FOR_PUK:
338 msgId = R.string.newPin2Label;
339 break;
340 case PIN_CHANGE_REENTER:
341 case PIN_CHANGE_REENTER_PIN_FOR_PUK:
342 msgId = R.string.confirmPin2Label;
343 break;
344 case PIN_CHANGE_PUK:
345 default:
346 msgId = R.string.label_puk2_code;
347 break;
348 }
349
350 // append the note / additional message, if needed.
351 if (strId != 0) {
352 mButtonChangePin2.setDialogMessage(getText(msgId) + "\n" + getText(strId));
353 } else {
354 mButtonChangePin2.setDialogMessage(msgId);
355 }
356
357 // only display if requested.
358 if (shouldDisplay) {
359 mButtonChangePin2.showPinDialog();
360 }
361 }
362
363 /**
364 * Reset the state of the pin change dialog.
365 */
366 private final void resetPinChangeState() {
367 if (DBG) log("resetPinChangeState");
368 mPinChangeState = PIN_CHANGE_OLD;
369 displayPinChangeDialog(0, false);
370 mOldPin = mNewPin = "";
371 mIsPuk2Locked = false;
372 }
373
374 /**
375 * Reset the state of the pin change dialog solely for PUK2 use.
376 */
377 private final void resetPinChangeStateForPUK2() {
378 if (DBG) log("resetPinChangeStateForPUK2");
379 mPinChangeState = PIN_CHANGE_PUK;
380 displayPinChangeDialog(0, false);
381 mOldPin = mNewPin = mPuk2 = "";
382 mIsPuk2Locked = true;
383 }
384
385 /**
386 * Validate the pin entry.
387 *
388 * @param pin This is the pin to validate
389 * @param isPuk Boolean indicating whether we are to treat
390 * the pin input as a puk.
391 */
392 private boolean validatePin(String pin, boolean isPuk) {
393
394 // for pin, we have 4-8 numbers, or puk, we use only 8.
395 int pinMinimum = isPuk ? MAX_PIN_LENGTH : MIN_PIN_LENGTH;
396
397 // check validity
398 if (pin == null || pin.length() < pinMinimum || pin.length() > MAX_PIN_LENGTH) {
399 return false;
400 } else {
401 return true;
402 }
403 }
404
405 /**
406 * Reflect the updated FDN state in the UI.
407 */
408 private void updateEnableFDN() {
409 if (mPhone.getIccCard().getIccFdnEnabled()) {
410 mButtonEnableFDN.setTitle(R.string.enable_fdn_ok);
411 mButtonEnableFDN.setSummary(R.string.fdn_enabled);
412 mButtonEnableFDN.setDialogTitle(R.string.disable_fdn);
413 } else {
414 mButtonEnableFDN.setTitle(R.string.disable_fdn_ok);
415 mButtonEnableFDN.setSummary(R.string.fdn_disabled);
416 mButtonEnableFDN.setDialogTitle(R.string.enable_fdn);
417 }
418 }
419
420 @Override
421 protected void onCreate(Bundle icicle) {
422 super.onCreate(icicle);
423
424 addPreferencesFromResource(R.xml.fdn_setting);
425
426 mPhone = PhoneGlobals.getPhone();
427
428 //get UI object references
429 PreferenceScreen prefSet = getPreferenceScreen();
430 mButtonEnableFDN = (EditPinPreference) prefSet.findPreference(BUTTON_FDN_ENABLE_KEY);
431 mButtonChangePin2 = (EditPinPreference) prefSet.findPreference(BUTTON_CHANGE_PIN2_KEY);
432
433 //assign click listener and update state
434 mButtonEnableFDN.setOnPinEnteredListener(this);
435 updateEnableFDN();
436
437 mButtonChangePin2.setOnPinEnteredListener(this);
438
439 // Only reset the pin change dialog if we're not in the middle of changing it.
440 if (icicle == null) {
441 resetPinChangeState();
442 } else {
443 mIsPuk2Locked = icicle.getBoolean(SKIP_OLD_PIN_KEY);
444 mPinChangeState = icicle.getInt(PIN_CHANGE_STATE_KEY);
445 mOldPin = icicle.getString(OLD_PIN_KEY);
446 mNewPin = icicle.getString(NEW_PIN_KEY);
447 mButtonChangePin2.setDialogMessage(icicle.getString(DIALOG_MESSAGE_KEY));
448 mButtonChangePin2.setText(icicle.getString(DIALOG_PIN_ENTRY_KEY));
449 }
450
451 ActionBar actionBar = getActionBar();
452 if (actionBar != null) {
453 // android.R.id.home will be triggered in onOptionsItemSelected()
454 actionBar.setDisplayHomeAsUpEnabled(true);
455 }
456 }
457
458 @Override
459 protected void onResume() {
460 super.onResume();
461 mPhone = PhoneGlobals.getPhone();
462 updateEnableFDN();
463 }
464
465 /**
466 * Save the state of the pin change.
467 */
468 @Override
469 protected void onSaveInstanceState(Bundle out) {
470 super.onSaveInstanceState(out);
471 out.putBoolean(SKIP_OLD_PIN_KEY, mIsPuk2Locked);
472 out.putInt(PIN_CHANGE_STATE_KEY, mPinChangeState);
473 out.putString(OLD_PIN_KEY, mOldPin);
474 out.putString(NEW_PIN_KEY, mNewPin);
475 out.putString(DIALOG_MESSAGE_KEY, mButtonChangePin2.getDialogMessage().toString());
476 out.putString(DIALOG_PIN_ENTRY_KEY, mButtonChangePin2.getText());
477 }
478
479 @Override
480 public boolean onOptionsItemSelected(MenuItem item) {
481 final int itemId = item.getItemId();
482 if (itemId == android.R.id.home) { // See ActionBar#setDisplayHomeAsUpEnabled()
483 CallFeaturesSetting.goUpToTopLevelSetting(this);
484 return true;
485 }
486 return super.onOptionsItemSelected(item);
487 }
488
489 private void log(String msg) {
490 Log.d(LOG_TAG, "FdnSetting: " + msg);
491 }
492}
493