/*
 * Copyright (C) 2008 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.phone;

import android.app.AlertDialog;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.database.Cursor;
import android.os.AsyncResult;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.preference.CheckBoxPreference;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceScreen;
import android.provider.Settings;
import android.provider.Contacts.PhonesColumns;
import android.telephony.PhoneNumberUtils;
import android.telephony.ServiceState;
import android.text.TextUtils;
import android.util.Log;
import android.view.WindowManager;

import com.android.internal.telephony.CallForwardInfo;
import com.android.internal.telephony.CommandsInterface;
import com.android.internal.telephony.Phone;
import com.android.internal.telephony.PhoneFactory;
import com.android.internal.telephony.cdma.TtyIntent;
import android.content.Context;

public class CallFeaturesSetting extends PreferenceActivity
        implements DialogInterface.OnClickListener,
        Preference.OnPreferenceChangeListener,
        EditPhoneNumberPreference.OnDialogClosedListener,
        EditPhoneNumberPreference.GetDefaultNumberListener{

    // intent action for this activity.
    public static final String ACTION_ADD_VOICEMAIL =
        "com.android.phone.CallFeaturesSetting.ADD_VOICEMAIL";

    // debug data
    private static final String LOG_TAG = "CallFeaturesSetting";
    private static final boolean DBG = false;

    // string contants
    private static final String NUM_PROJECTION[] = {PhonesColumns.NUMBER};
    private static final String SRC_TAGS[]       = {"{0}"};

    // String keys for preference lookup
    private static final String BUTTON_CLIR_KEY  = "button_clir_key";
    private static final String BUTTON_CW_KEY    = "button_cw_key";
    private static final String BUTTON_CFU_KEY   = "button_cfu_key";
    private static final String BUTTON_CFB_KEY   = "button_cfb_key";
    private static final String BUTTON_CFNRY_KEY = "button_cfnry_key";
    private static final String BUTTON_CFNRC_KEY = "button_cfnrc_key";
    private static final String BUTTON_VOICEMAIL_KEY = "button_voicemail_key";
    private static final String BUTTON_FDN_KEY   = "button_fdn_key";

    // used to store the state of expanded preferences
    private static final String BUTTON_GSM_MORE_EXPAND_KEY = "button_gsm_more_expand_key";
    private static final String BUTTON_CDMA_MORE_EXPAND_KEY = "button_cdma_more_expand_key";

    private static final String BUTTON_CF_EXPAND_KEY = "button_cf_expand_key";
    private static final String SUMMARY_CFU_KEY   = "summary_cfu_key";
    private static final String SUMMARY_CFB_KEY   = "summary_cfb_key";
    private static final String SUMMARY_CFNRY_KEY = "summary_cfnry_key";
    private static final String SUMMARY_CFNRC_KEY = "summary_cfnrc_key";

    private static final String APP_STATE_KEY     = "app_state_key";
    private static final String DISPLAY_MODE_KEY  = "display_mode_key";

    private static final String BUTTON_TTY_KEY = "button_tty_mode_key";
    private static final String BUTTON_VP_KEY = "button_voice_privacy_key";
    private static final String BUTTON_DS_KEY = "dtmf_settings";

    private Intent mContactListIntent;
    private Intent mFDNSettingIntent;

    // events
    private static final int EVENT_SERVICE_STATE_CHANGED = 100;
    private static final int EVENT_CLIR_EXECUTED         = 200;
    private static final int EVENT_CW_EXECUTED           = 300;
    private static final int EVENT_CF_EXECUTED           = 400;
    /** Event for Async voicemail change call */
    private static final int EVENT_VOICEMAIL_CHANGED     = 500;
    /** track the query cancel event. */
    private static final int EVENT_INITAL_QUERY_CANCELED = 600;
    /** Event for TTY mode change */
    private static final int EVENT_TTY_EXECUTED          = 700;
    private static final int EVENT_TTY_MODE_SET          = 800;
    private static final int EVENT_ENHANCED_VP_EXECUTED  = 1000;

    // preferred TTY mode
    // 0 = disabled
    // 1 = full mode
    // 2 = HCO mode
    // 3 = VCO mode
    static final int preferredTtyMode = 0;

    // preferred VoicePrivacy mode
    // 0 = disabled
    // 1 = enabled
    static final int preferredVPMode = 1;

    // Dtmf tone types
    static final int DTMF_TONE_TYPE_NORMAL = 0;
    static final int DTMF_TONE_TYPE_LONG   = 1;

    // preferred DTMF Tones mode
    static final int preferredDtmfMode = DTMF_TONE_TYPE_NORMAL;


    /** Handle to voicemail pref */
    private static final int VOICEMAIL_PREF_ID = CommandsInterface.CF_REASON_NOT_REACHABLE + 1;

    private Phone mPhone;

    private static final int BUSY_DIALOG = 100;
    private static final int EXCEPTION_ERROR = 200;
    private static final int RESPONSE_ERROR = 300;
    private static final int VM_NOCHANGE_ERROR = 400;
    private static final int VM_RESPONSE_ERROR = 500;

    /** used to track errors with the radio off. */
    private static final int RADIO_OFF_ERROR = 800;
    private static final int INITIAL_BUSY_DIALOG = 900;

    // dialog identifiers for voicemail
    private static final int VOICEMAIL_DIALOG_CONFIRM = 600;
    private static final int VOICEMAIL_DIALOG_PROGRESS = 700;

    // status message sent back from handlers
    //  handleGetCLIRMessage
    //  handleGetCWMessage
    //  handleGetCFMessage
    private static final int MSG_OK = 100;
    private static final int MSG_EXCEPTION = 200;
    private static final int MSG_UNEXPECTED_RESPONSE = 300;
    // special statuses for voicemail controls.
    private static final int MSG_VM_EXCEPTION = 400;
    private static final int MSG_VM_BUSY = 500;
    private static final int MSG_VM_OK = 600;
    private static final int MSG_VM_NOCHANGE = 700;
    private static final int MSG_RADIO_OFF = 800;

    // application states including network error state.
    // this includes seperate state for the inital query, which is cancelable.
    private enum AppState {
        INPUT_READY,
        DIALOG_OPEN,
        WAITING_NUMBER_SELECT,
        BUSY_NETWORK_CONNECT,
        NETWORK_ERROR,
        INITIAL_QUERY
    };
    private AppState mAppState;

    /** Additional state tracking to handle expanded views (lazy queries)*/
    private static final int DISP_MODE_MAIN = -1;
    private static final int DISP_MODE_CF = -2;
    private static final int DISP_MODE_MORE = -3;
    private int mDisplayMode;
    private boolean mCFDataStale = true;
    private boolean mMoreDataStale = true;
    private boolean mIsBusyDialogAvailable = false;

    // toggle buttons
    private PreferenceScreen mSubMenuFDNSettings;
    private ListPreference mButtonCLIR;
    private CheckBoxPreference mButtonCW;
    private EditPhoneNumberPreference mButtonCFU;
    private EditPhoneNumberPreference mButtonCFB;
    private EditPhoneNumberPreference mButtonCFNRy;
    private EditPhoneNumberPreference mButtonCFNRc;
    private EditPhoneNumberPreference mSubMenuVoicemailSettings;
    private PreferenceScreen mButtonCFExpand;
    private PreferenceScreen mButtonGSMMoreExpand;
    private CheckBoxPreference mButtonVoicePrivacy;
    private ListPreference mButtonTTY;
    private ListPreference mButtonDS;

    // cf number strings
    private String mDialingNumCFU;
    private String mDialingNumCFB;
    private String mDialingNumCFNRy;
    private String mDialingNumCFNRc;
    /** string to hold old voicemail number as it is being updated. */
    private String mOldVmNumber;


    /*
     * Click Listeners, handle click based on objects attached to UI.
     */

    // Click listener for all toggle events
    @Override
    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
        if (mAppState != AppState.INPUT_READY) {
            if (DBG) {
                log("onPreferencesHierarchyClick: preference request denied, currently busy.");
            }
            return false;
        }

        if (DBG) log("onPreferencesHierarchyClick: request preference click.");

        AppState nextState = AppState.INPUT_READY;

        if (preference == mButtonCW) {
            handleCWClickRequest(mButtonCW.isChecked());
            nextState = AppState.BUSY_NETWORK_CONNECT;

        } else if (preference == mButtonCLIR) {
            // let the normal listpreference UI take care of this.
            return false;

        } else if ((preference instanceof EditPhoneNumberPreference) &&
                ((preference == mButtonCFU) || (preference == mButtonCFB) ||
                (preference == mButtonCFNRy) || (preference == mButtonCFNRc) ||
                (preference == mSubMenuVoicemailSettings))) {
            nextState = AppState.DIALOG_OPEN;
        } else if (preference == mSubMenuFDNSettings) {
            // let the intent handler from the caller take care of the
            // navigation to the FDN screen.
            return false;

        /** perform the requested expansion, and query the network.*/
        } else if (preference == mButtonCFExpand){
            setDisplayMode(DISP_MODE_CF);
            return true;
        } else if (preference == mButtonGSMMoreExpand){
            // TODO - should have handler for mButtonCDMAMoreExpand?
            setDisplayMode(DISP_MODE_MORE);
        } else if (preference == mButtonVoicePrivacy) {
            handleVoicePrivacyClickRequest(mButtonVoicePrivacy.isChecked());
        } else if (preference == mButtonTTY) {
            //displays the value taken from the Settings.System
            int settingsTtyMode = android.provider.Settings.Secure.getInt(
                    mPhone.getContext().getContentResolver(),
                    android.provider.Settings.Secure.PREFERRED_TTY_MODE ,
                    preferredTtyMode);
            mButtonTTY.setValue(Integer.toString(settingsTtyMode));
            return true;
        } else if (preference == mButtonDS) {
            // Let the normal listpreference UI take care of this
            return false;
        }

        if (nextState != AppState.INPUT_READY) {
            setAppState(nextState);
            return true;
        }

        return false;
    }

    /**
     * Implemented to support onPreferenceChangeListener to look for preference
     * changes specifically on CLIR.
     *
     * @param preference is the preference to be changed, should be mButtonCLIR.
     * @param objValue should be the value of the selection, NOT its localized
     * display value.
     */
    public boolean onPreferenceChange(Preference preference, Object objValue) {
        if (preference == mButtonCLIR) {
            // send the command and update state.
            handleCLIRClickRequest(mButtonCLIR.findIndexOfValue((String) objValue));
            setAppState(AppState.BUSY_NETWORK_CONNECT);
        } else if (preference == mButtonTTY) {
            // send the command and update state.
            handleTTYClickRequest(preference, objValue);
        } else if (preference == mButtonDS) {
            int index = mButtonDS.findIndexOfValue((String) objValue);
            Settings.System.putInt(mPhone.getContext().getContentResolver(),
                    Settings.System.DTMF_TONE_TYPE_WHEN_DIALING, index);
        }
        // always let the preference setting proceed.
        return true;
    }


    /**
     * Perform the query request for the expanded items upon user request.
     */
    public void setDisplayMode(int displayMode) {
        mDisplayMode = displayMode;

        // look for the data if it is considered stale.
        if ((mCFDataStale && (displayMode == DISP_MODE_CF)) ||
                (mMoreDataStale && (displayMode == DISP_MODE_MORE))){
            if (DBG) log("setDisplayMode: performing requested expansion.");

            // check for CDMA, if so just open without querying
            if ( mPhone.getPhoneName().equals("CDMA") ) {
                setAppState(AppState.INPUT_READY);
            } else {
                // If airplane mode is on, do not bother querying.
                if (Settings.System.getInt(getContentResolver(),
                        Settings.System.AIRPLANE_MODE_ON, 0) <= 0 ) {
                    // query state if radio is available
                    //  if its out of service, just wait for the radio to be ready
                    //  if its neither of these states, throw up an error.
                    setAppState(AppState.INITIAL_QUERY);

                    int radioState = mPhone.getServiceState().getState();

                    if (radioState == ServiceState.STATE_IN_SERVICE) {
                        // Query ONLY what we are currently expanding.
                        if (displayMode == DISP_MODE_CF) {
                            queryAllCFOptions();
                        } else {
                            queryMoreOptions();
                        }
                    } else if (radioState == ServiceState.STATE_POWER_OFF){
                        if (DBG) log("onCreate: radio not ready, waiting for signal.");
                        mPhone.registerForServiceStateChanged(mNetworkServiceHandler,
                                EVENT_SERVICE_STATE_CHANGED, null);
                    } else {
                        setAppState(AppState.NETWORK_ERROR, MSG_EXCEPTION);
                    }
                } else {
                    if (DBG) log("setDisplayMode: radio is off!");
                    setAppState(AppState.NETWORK_ERROR, MSG_RADIO_OFF);
                }
            }
        }
    }

    // Preference click listener invoked on OnDialogClosed for EditPhoneNumberPreference.
    public void onDialogClosed(EditPhoneNumberPreference preference, int buttonClicked) {
        if (mAppState != AppState.DIALOG_OPEN) {
            if (DBG) {
                log("onPreferenceClick: preference request denied, currently busy.");
            }
            return;
        } else if (buttonClicked == DialogInterface.BUTTON2) {
            // Button2 is the cancel button.
            setAppState (AppState.INPUT_READY);
            return;
        }

        if (DBG) log("onPreferenceClick: request preference click on dialog close.");

        AppState nextState = AppState.INPUT_READY;

        if (preference instanceof EditPhoneNumberPreference) {
            EditPhoneNumberPreference epn = preference;

            if (epn == mSubMenuVoicemailSettings) {
                handleVMBtnClickRequest();

            } else {
                int reason = 0;
                int time = 0;
                String number = "";
                // We use CommandsInterface.CF_ACTION_REGISTRATION for both the Enable
                // and Update (Button1) functions.
                int action = (epn.isToggled() || (buttonClicked == DialogInterface.BUTTON1)) ?
                        CommandsInterface.CF_ACTION_REGISTRATION :
                        CommandsInterface.CF_ACTION_DISABLE;

                // The formatted string seems to be giving the MMI codes some problems,
                // so we strip the formatting first before sending the number.
                number = PhoneNumberUtils.stripSeparators((epn.getPhoneNumber()));
                if (epn == mButtonCFU) {
                    nextState = AppState.BUSY_NETWORK_CONNECT;
                    reason = CommandsInterface.CF_REASON_UNCONDITIONAL;
                    mDialingNumCFU = number;
                } else if (epn == mButtonCFB) {
                    nextState = AppState.BUSY_NETWORK_CONNECT;
                    reason = CommandsInterface.CF_REASON_BUSY;
                    mDialingNumCFB = number;
                } else if (epn == mButtonCFNRy) {
                    nextState = AppState.BUSY_NETWORK_CONNECT;
                    reason = CommandsInterface.CF_REASON_NO_REPLY;
                    time = 20;
                    mDialingNumCFNRy = number;
                } else if (epn == mButtonCFNRc) {
                    nextState = AppState.BUSY_NETWORK_CONNECT;
                    reason = CommandsInterface.CF_REASON_NOT_REACHABLE;
                    mDialingNumCFNRc = number;
                }

                if (nextState == AppState.BUSY_NETWORK_CONNECT) {
                    handleCFBtnClickRequest(action, reason, time, number);
                }

                if (nextState != AppState.DIALOG_OPEN) {
                    setAppState(nextState);
                }
            }
        }
    }

    /**
     * Implemented for EditPhoneNumberPreference.GetDefaultNumberListener.
     * This method set the default values for the various
     * EditPhoneNumberPreference dialogs.
     */
    public String onGetDefaultNumber(EditPhoneNumberPreference preference) {
        if (preference == mSubMenuVoicemailSettings) {
            // update the voicemail number field, which takes care of the
            // mSubMenuVoicemailSettings itself, so we should return null.
            if (DBG) log("updating default for voicemail dialog");
            updateVoiceNumberField();
            return null;
        }

        String vmDisplay = mPhone.getVoiceMailNumber();
        if (TextUtils.isEmpty(vmDisplay)) {
            // if there is no voicemail number, we just return null to
            // indicate no contribution.
            return null;
        }

        // Return the voicemail number prepended with "VM: "
        if (DBG) log("updating default for call forwarding dialogs");
        return getString(R.string.voicemail_abbreviated) + " " + vmDisplay;
    }


    // override the startsubactivity call to make changes in state consistent.
    @Override
    public void startActivityForResult(Intent intent, int requestCode) {
        if (requestCode == -1) {
            // this is an intent requested from the preference framework.
            super.startActivityForResult(intent, requestCode);
            return;
        }

        if (mAppState != AppState.DIALOG_OPEN) {
            if (DBG) {
                log("startSubActivity: dialog start activity request denied, currently busy.");
            }
            return;
        }

        if (DBG) log("startSubActivity: starting requested subactivity");

        super.startActivityForResult(intent, requestCode);

        setAppState (AppState.WAITING_NUMBER_SELECT);
    }

    // asynchronous result call after contacts are selected.
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        // there are cases where the contact picker may end up sending us more than one
        // request.  We want to ignore the request if we're not in the correct state.
        if (mAppState != AppState.WAITING_NUMBER_SELECT) {
            if (DBG) log("onActivityResult: wrong state, ignoring message from contact picker.");
            return;
        } else {
            setAppState(AppState.DIALOG_OPEN);
        }

        if (resultCode != RESULT_OK) {
            if (DBG) log("onActivityResult: contact picker result not OK.");
            return;
        }

        Cursor cursor = getContentResolver().query(data.getData(),
                NUM_PROJECTION, null, null, null);
        if ((cursor == null) || (!cursor.moveToFirst())) {
            if (DBG) log("onActivityResult: bad contact data, no results found.");
            return;
        }

        switch (requestCode) {
            case CommandsInterface.CF_REASON_UNCONDITIONAL:
                mButtonCFU.onPickActivityResult(cursor.getString(0));
                break;
            case CommandsInterface.CF_REASON_BUSY:
                mButtonCFB.onPickActivityResult(cursor.getString(0));
                break;
            case CommandsInterface.CF_REASON_NO_REPLY:
                mButtonCFNRy.onPickActivityResult(cursor.getString(0));
                break;
            case CommandsInterface.CF_REASON_NOT_REACHABLE:
                mButtonCFNRc.onPickActivityResult(cursor.getString(0));
                break;
            case VOICEMAIL_PREF_ID:
                mSubMenuVoicemailSettings.onPickActivityResult(cursor.getString(0));
                break;
            default:
                // TODO: may need exception here.
        }

    }

    // CLIR object
    private void handleCLIRClickRequest(int i) {
        if (DBG) log("handleCLIRClickRequest: requesting set Call Line Id Restriction (CLIR) to " +
                (i == CommandsInterface.CLIR_INVOCATION ? "ENABLE" :
                    (i == CommandsInterface.CLIR_SUPPRESSION ? "DISABLE" : "NETWORK DEFAULT")));
        mPhone.setOutgoingCallerIdDisplay(i,
                Message.obtain(mSetOptionComplete, EVENT_CLIR_EXECUTED));
    }

    // CW object
    private void handleCWClickRequest(boolean b) {
        if (DBG) log("handleCWClickRequest: requesting set call waiting enable (CW) to" +
                Boolean.toString(b));
        mPhone.setCallWaiting(b, Message.obtain(mSetOptionComplete, EVENT_CW_EXECUTED));
    }

    // CF Button objects
    private void handleCFBtnClickRequest(int action, int reason, int time, String number) {
        if (DBG) log("handleCFBtnClickRequest: requesting set call forwarding (CF) " +
                Integer.toString(reason) + " to " + Integer.toString(action) + " with number " +
                number);
        mPhone.setCallForwardingOption(action,
                reason,
                number,
                time,
                Message.obtain(mSetOptionComplete, EVENT_CF_EXECUTED, reason, 0));
    }

    // Voicemail button logic
    private void handleVMBtnClickRequest() {
        // normally called on the dialog close.

        // Since we're stripping the formatting out on the getPhoneNumber()
        // call now, we won't need to do so here anymore.
        String newVMNumber = mSubMenuVoicemailSettings.getPhoneNumber();

        // empty vm number == clearing the vm number ?
        if (newVMNumber == null) {
            newVMNumber = "";
        }

        //throw a warning if they are the same.
        if (newVMNumber.equals(mOldVmNumber)) {
            setAppState(AppState.INPUT_READY, MSG_VM_NOCHANGE);
            return;
        }

        // otherwise, set it.
        setAppState (AppState.BUSY_NETWORK_CONNECT, MSG_VM_BUSY);
        if (DBG) log("save voicemail #: " + newVMNumber);
        mPhone.setVoiceMailNumber(
                mPhone.getVoiceMailAlphaTag().toString(),
                newVMNumber,
                Message.obtain(mSetOptionComplete, EVENT_VOICEMAIL_CHANGED));
    }

    /*
     * Callback to handle option update completions
     */

    // **Callback on option setting when complete.
    private Handler mSetOptionComplete = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            // query to make sure we're looking at the same data as that in the network.
            switch (msg.what) {
                case EVENT_CLIR_EXECUTED:
                    handleSetCLIRMessage();
                    break;
                case EVENT_CW_EXECUTED:
                    handleSetCWMessage();
                    break;
                case EVENT_CF_EXECUTED:
                    handleSetCFMessage(msg.arg1, (AsyncResult) msg.obj);
                    break;
                case EVENT_VOICEMAIL_CHANGED:
                    handleSetVMMessage((AsyncResult) msg.obj);
                    break;
                default:
                    // TODO: should never reach this, may want to throw exception
            }
        }
    };

    // CLIR Object
    private void handleSetCLIRMessage() {
        if (DBG) {
            log("handleSetCLIRMessage: set CLIR request complete, reading value from network.");
        }
        mPhone.getOutgoingCallerIdDisplay(Message.obtain(mGetOptionComplete, EVENT_CLIR_EXECUTED));
    }

    // CW Object
    private void handleSetCWMessage() {
        if (DBG) {
            log("handleSetCWMessage: set CW request complete, reading value back from network.");
        }
        mPhone.getCallWaiting(Message.obtain(mGetOptionComplete, EVENT_CW_EXECUTED));
    }

    // CF Objects
    private void handleSetCFMessage(int reason, AsyncResult r) {
        if (DBG) {
            log("handleSetCFMessage: set CF request complete, reading value back from network.");
        }

        // handle the exception in the set function's async result by
        // propagating it to the getCallForwarding function.  This is
        // so that we can display the error AFTER the setting has gone
        // through the standard (set/get) cycle.
        mPhone.getCallForwardingOption(reason,
                Message.obtain(mGetOptionComplete, EVENT_CF_EXECUTED, reason, 0, r.exception));
    }

    // Voicemail Object
    private void handleSetVMMessage(AsyncResult ar) {
        if (DBG) {
            log("handleSetVMMessage: set VM request complete");
        }
        if (ar.exception == null) {
            if (DBG) log("change VM success!");
            setAppState(AppState.INPUT_READY, MSG_VM_OK);
        } else {
            // TODO: may want to check the exception and branch on it.
            if (DBG) log("change VM failed!");
            setAppState(AppState.NETWORK_ERROR, MSG_VM_EXCEPTION);
        }
        updateVoiceNumberField();
    }

    /*
     * Callback to handle query completions
     */

    // **Callback on option getting when complete.
    private Handler mGetOptionComplete = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            boolean bHandled = false;
            int status = MSG_OK;
            switch (msg.what) {
                case EVENT_CLIR_EXECUTED:
                    status = handleGetCLIRMessage((AsyncResult) msg.obj);
                    bHandled = true;
                    break;
                case EVENT_CW_EXECUTED:
                    status = handleGetCWMessage((AsyncResult) msg.obj);
                    bHandled = true;
                    break;
                case EVENT_CF_EXECUTED:
                    status = handleGetCFMessage((AsyncResult) msg.obj, msg.arg1);
                    bHandled = true;
                    break;
                default:
                    // TODO: should never reach this, may want to throw exception
            }
            if (status != MSG_OK) {
                setAppState(AppState.NETWORK_ERROR, status);
            } else if (bHandled) {
                setAppState(AppState.INPUT_READY);
            }
        }
    };

    // CLIR Object
    private int handleGetCLIRMessage(AsyncResult ar) {
        // done with query, display the new settings.
        if (ar.exception != null) {
            if (DBG) log("handleGetCLIRMessage: Error getting CLIR enable state.");
            return MSG_EXCEPTION;
        } else {
            int clirArray[] = (int[]) ar.result;
            if (clirArray.length != 2) {
                if (DBG) log("handleGetCLIRMessage: Error getting CLIR state, unexpected value.");
                return MSG_UNEXPECTED_RESPONSE;
            } else {
                if (DBG) log("handleGetCLIRMessage: CLIR enable state successfully queried.");
                syncCLIRUIState(clirArray);
            }
        }
        return MSG_OK;
    }

    // CW Object
    private int handleGetCWMessage(AsyncResult ar) {
        if (ar.exception != null) {
            if (DBG) log("handleGetCWMessage: Error getting CW enable state.");
            return MSG_EXCEPTION;
        } else {
            if (DBG) log("handleGetCWMessage: CW enable state successfully queried.");
            syncCWState((int[]) ar.result);
        }
        return MSG_OK;
    }

    // VP Object
    private int handleGetVPMessage(AsyncResult ar, int voicePrivacyMode) {
        if (ar.exception != null) {
            if (DBG) log("handleGetVPMessage: Error getting VP enable state.");
            return MSG_EXCEPTION;
        } else {
            Log.d(LOG_TAG, "voicePrivacyMode = " + voicePrivacyMode);
            syncVPState((int[]) ar.result);
        }

        return MSG_OK;
    }

    // CF Object
    private int handleGetCFMessage(AsyncResult ar, int reason) {
        // done with query, display the new settings.
        if (ar.exception != null) {
            if (DBG) log("handleGetCFMessage: Error getting CF enable state.");
            return MSG_EXCEPTION;
        } else if (ar.userObj instanceof Throwable) {
            // TODO: I don't think it makes sense to throw the error up to
            // the user, but this may be reconsidered.  For now, just log
            // the specific error and throw up a generic error.
            if (DBG) log("handleGetCFMessage: Error during set call, reason: " + reason +
                    " exception: " + ((Throwable) ar.userObj).toString());
            return MSG_UNEXPECTED_RESPONSE;
        } else {
            CallForwardInfo cfInfoArray[] = (CallForwardInfo[]) ar.result;
            if (cfInfoArray.length == 0) {
                if (DBG) log("handleGetCFMessage: Error getting CF state, unexpected value.");
                return MSG_UNEXPECTED_RESPONSE;
            } else {
                // TODO: look through the information for the voice data
                // in reality, we should probably take the other service
                // classes into account, but this may be more than we
                // want to expose to the user.
                for (int i = 0, length = cfInfoArray.length; i < length; i++) {
                    if ((CommandsInterface.SERVICE_CLASS_VOICE &
                            cfInfoArray[i].serviceClass) != 0) {
                        if (DBG) {
                            log("handleGetCFMessage: CF state successfully queried for reason " +
                                Integer.toBinaryString(reason));
                        }
                        syncCFUIState(reason, cfInfoArray[i]);
                        break;
                    }
                }
            }
        }
        return MSG_OK;
    }

    /*
     * Methods used to sync UI state with that of the network
     */

    // set the state of the UI based on CW State
    private void syncCWState(int cwArray[]) {
        if (DBG) log("syncCWState: Setting UI state consistent with CW enable state of " +
                ((cwArray[0] == 1) ? "ENABLED" : "DISABLED"));
        mButtonCW.setChecked(cwArray[0] == 1);
    }

    /**
     * The logic in this method is based upon the code in {@link CommandsInterface#getCLIR()}.
     *
     * @param clirArgs is the int[2] retrieved from the getCLIR response, please refer to
     * the link above more more details.
     */
    private void syncCLIRUIState(int clirArgs[]) {
        if (DBG) log("syncCLIRUIState: Setting UI state consistent with CLIR.");

        // enable if the setting is valid.
        final boolean enabled = clirArgs[1] == 1 || clirArgs[1] == 3 || clirArgs[1] == 4;
        mButtonCLIR.setEnabled(enabled);

        // set the value of the preference based upon the clirArgs.
        int value = CommandsInterface.CLIR_DEFAULT;
        switch (clirArgs[1]) {
            case 1: // Permanently provisioned
            case 3: // Temporary presentation disallowed
            case 4: // Temporary presentation allowed
                switch (clirArgs[0]) {
                    case 1: // CLIR invoked
                        value = CommandsInterface.CLIR_INVOCATION;
                        break;
                    case 2: // CLIR suppressed
                        value = CommandsInterface.CLIR_SUPPRESSION;
                        break;
                    case 0: // Network default
                    default:
                        value = CommandsInterface.CLIR_DEFAULT;
                        break;
                }
                break;
            case 0: // Not Provisioned
            case 2: // Unknown (network error, etc)
            default:
                value = CommandsInterface.CLIR_DEFAULT;
                break;
        }
        setButtonCLIRValue(value);
    }

    /**
     * Helper function to set both the value and the summary of the CLIR preference.
     */
    private void setButtonCLIRValue (int value) {

        if (mButtonCLIR == null) {
            return;
        }

        // first, set the value.
        mButtonCLIR.setValueIndex(value);

        // set the string summary to reflect the value
        int summary = R.string.sum_default_caller_id;
        switch (value) {
            case CommandsInterface.CLIR_SUPPRESSION:
                summary = R.string.sum_show_caller_id;
                break;
            case CommandsInterface.CLIR_INVOCATION:
                summary = R.string.sum_hide_caller_id;
                break;
            case CommandsInterface.CLIR_DEFAULT:
                summary = R.string.sum_default_caller_id;
                break;
        }
        mButtonCLIR.setSummary(summary);
    }

    // called by syncCFUIState to do repetitive changes to UI button state.
    private void adjustCFbuttonState(EditPhoneNumberPreference epn,
            boolean isActive, int template, String number) {

        if (epn == null) {
            return;
        }

        CharSequence summaryOn = "";

        if (isActive) {
            if (number != null) {
                String values[] = {number};
                summaryOn = TextUtils.replace(getText(template), SRC_TAGS, values);
            }
            epn.setSummaryOn(summaryOn);
        }

        epn.setToggled(isActive);
        epn.setPhoneNumber(number);
    }

    // set the state of the UI based on CF State
    private void syncCFUIState(int reason, CallForwardInfo info) {
        boolean active = (info.status == 1);
        switch (reason) {
            case CommandsInterface.CF_REASON_UNCONDITIONAL:
                if (DBG) log("syncCFUIState: Setting UI state consistent with CFU.");
                adjustCFbuttonState(mButtonCFU, active, R.string.sum_cfu_enabled, info.number);
                mDialingNumCFU = info.number;
                break;
            case CommandsInterface.CF_REASON_BUSY:
                if (DBG) log("syncCFUIState: Setting UI state consistent with CFB.");
                adjustCFbuttonState(mButtonCFB, active, R.string.sum_cfb_enabled, info.number);
                mDialingNumCFB = info.number;
                break;
            case CommandsInterface.CF_REASON_NO_REPLY:
                if (DBG) log("syncCFUIState: Setting UI state consistent with CFNRy.");
                adjustCFbuttonState(mButtonCFNRy, active, R.string.sum_cfnry_enabled, info.number);
                mDialingNumCFNRy = info.number;
                break;
            case CommandsInterface.CF_REASON_NOT_REACHABLE:
                if (DBG) log("syncCFUIState: Setting UI state consistent with CFNRc.");
                adjustCFbuttonState(mButtonCFNRc, active, R.string.sum_cfnrc_enabled, info.number);
                mDialingNumCFNRc = info.number;
                break;
        }
    }

    // update the voicemail number from what we've recorded on the sim.
    private void updateVoiceNumberField() {
        if (mSubMenuVoicemailSettings == null) {
            return;
        }

        mOldVmNumber = mPhone.getVoiceMailNumber();
        if (mOldVmNumber == null) {
            mOldVmNumber = "";
        }
        mSubMenuVoicemailSettings.setPhoneNumber(mOldVmNumber);
    }


    /*
     * Helper Methods for Activity class.
     * The inital query commands are split into two pieces now
     * for individual expansion.  This combined with the ability
     * to cancel queries allows for a much better user experience,
     * and also ensures that the user only waits to update the
     * data that is relevant.
     */

    // Handler to track service availability.
    private Handler mNetworkServiceHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case EVENT_SERVICE_STATE_CHANGED: {
                        ServiceState state = (ServiceState) ((AsyncResult) msg.obj).result;
                        if (state.getState() == ServiceState.STATE_IN_SERVICE) {
                            if (DBG) {
                                log("mNetworkServiceHandler: network available for queries.");
                            }
                            // Query ONLY what we are interested in now.
                            switch (mDisplayMode) {
                                case DISP_MODE_CF:
                                    queryAllCFOptions();
                                    break;
                                case DISP_MODE_MORE:
                                    queryMoreOptions();
                                    break;
                            }

                            mPhone.unregisterForServiceStateChanged(mNetworkServiceHandler);
                        }
                    }
                    break;
                case EVENT_INITAL_QUERY_CANCELED:
                    if (DBG) log("mNetworkServiceHandler: cancel query requested.");
                    dismissExpandedDialog();
                    break;
            }
        }
    };

    // Request to begin querying for all options.
    private void queryAllCFOptions() {
        if (DBG) log("queryAllCFOptions: begin querying call features.");
        mPhone.getCallForwardingOption(CommandsInterface.CF_REASON_UNCONDITIONAL,
                Message.obtain(mGetAllCFOptionsComplete, EVENT_CF_EXECUTED,
                        CommandsInterface.CF_REASON_UNCONDITIONAL, 0));
    }

    // callback after each step of querying for all options.
    private Handler mGetAllCFOptionsComplete = new Handler() {
        @Override
        public void handleMessage(Message msg) {

            AsyncResult ar = (AsyncResult) msg.obj;
            int status = MSG_OK;

            switch (msg.what) {
                case EVENT_CF_EXECUTED:
                    status = handleGetCFMessage(ar, msg.arg1);
                    int nextReason = -1;
                    switch (msg.arg1) {
                        case CommandsInterface.CF_REASON_UNCONDITIONAL:
                            if (DBG) log("mGetAllOptionsComplete: CFU query done, querying CFB.");
                            nextReason = CommandsInterface.CF_REASON_BUSY;
                            break;
                        case CommandsInterface.CF_REASON_BUSY:
                            if (DBG) {
                                log("mGetAllOptionsComplete: CFB query done, querying CFNRy.");
                            }
                            nextReason = CommandsInterface.CF_REASON_NO_REPLY;
                            break;
                        case CommandsInterface.CF_REASON_NO_REPLY:
                            if (DBG) {
                                log("mGetAllOptionsComplete: CFNRy query done, querying CFNRc.");
                            }
                            nextReason = CommandsInterface.CF_REASON_NOT_REACHABLE;
                            break;
                        case CommandsInterface.CF_REASON_NOT_REACHABLE:
                            if (DBG) {
                                log("mGetAllOptionsComplete: CFNRc query done, querying CLIR.");
                            }
                            break;
                        default:
                            // TODO: should never reach this, may want to throw exception
                    }
                    if (status != MSG_OK) {
                        setAppState(AppState.NETWORK_ERROR, status);
                    } else {
                        if (nextReason != -1) {
                            mPhone.getCallForwardingOption(nextReason,
                                    Message.obtain(mGetAllCFOptionsComplete, EVENT_CF_EXECUTED,
                                            nextReason, 0));
                        } else {
                            mCFDataStale = false;
                            setAppState(AppState.INPUT_READY);
                        }
                    }
                    break;

                default:
                    // TODO: should never reach this, may want to throw exception
                    break;
            }
        }
    };

    // Request to begin querying for all options.
    private void queryMoreOptions() {
        if (DBG) log("queryMoreOptions: begin querying call features.");
        mPhone.getOutgoingCallerIdDisplay(
                Message.obtain(mGetMoreOptionsComplete, EVENT_CLIR_EXECUTED));
    }

    // callback after each step of querying for all options.
    private Handler mGetMoreOptionsComplete = new Handler() {
        @Override
        public void handleMessage(Message msg) {

            AsyncResult ar = (AsyncResult) msg.obj;
            int status = MSG_OK;

            switch (msg.what) {
                case EVENT_CLIR_EXECUTED:
                    status = handleGetCLIRMessage(ar);
                    if (DBG) log("mGetAllOptionsComplete: CLIR query done, querying CW.");
                    if (status != MSG_OK) {
                        setAppState(AppState.NETWORK_ERROR, status);
                    } else {
                        mPhone.getCallWaiting(Message.obtain(mGetMoreOptionsComplete,
                                EVENT_CW_EXECUTED));
                    }
                    break;

                case EVENT_CW_EXECUTED:
                    status = handleGetCWMessage(ar);
                    if (DBG) {
                        log("mGetAllOptionsComplete: CW query done, querying VP.");
                    }
                    if (status != MSG_OK) {
                        setAppState(AppState.NETWORK_ERROR, status);
                    } else {
                        if (mPhone.getPhoneName().equals("GSM")) {
                            mMoreDataStale = false;
                            setAppState(AppState.INPUT_READY);
                        } else {
                            mPhone.getEnhancedVoicePrivacy(Message.obtain(mGetMoreOptionsComplete,
                                EVENT_ENHANCED_VP_EXECUTED));
                        }
                    }
                    break;

                case EVENT_ENHANCED_VP_EXECUTED:
                    status = handleGetVPMessage(ar, msg.arg1);
                    if (DBG) {
                        log("mGetAllOptionsComplete: VP query done, all call features queried.");
                    }
                    if (status != MSG_OK) {
                        setAppState(AppState.NETWORK_ERROR, status);
                    } else {
                        mMoreDataStale = false;
                        setAppState(AppState.INPUT_READY);
                    }
                    break;

                default:
                    // TODO: should never reach this, may want to throw exception
                    break;
            }
        }
    };

    // dialog creation method, called by showDialog()
    @Override
    protected Dialog onCreateDialog(int id) {

        if ((id == BUSY_DIALOG) || (id == VOICEMAIL_DIALOG_PROGRESS) ||
                (id == INITIAL_BUSY_DIALOG)) {
            ProgressDialog dialog = new ProgressDialog(this);
            dialog.setTitle(getText(R.string.updating_title));
            dialog.setIndeterminate(true);

            switch (id) {
                case BUSY_DIALOG:
                    mIsBusyDialogAvailable = true;
                    dialog.setCancelable(false);
                    dialog.setMessage(getText(R.string.updating_settings));
                    break;
                case VOICEMAIL_DIALOG_PROGRESS:
                    dialog.setCancelable(false);
                    dialog.setMessage(getText(R.string.vm_save_number));
                    break;
                case INITIAL_BUSY_DIALOG:
                    // Allowing the user to cancel on the initial query.
                    dialog.setCancelable(true);
                    dialog.setCancelMessage(
                            mNetworkServiceHandler.obtainMessage(EVENT_INITAL_QUERY_CANCELED));
                    dialog.setMessage(getText(R.string.reading_settings));
                    break;
            }
            // make the dialog more obvious by bluring the background.
            dialog.getWindow().addFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND);

            return dialog;

        // Handle error dialog codes
        } else if ((id == RESPONSE_ERROR) || (id == EXCEPTION_ERROR) ||
                (id == VM_RESPONSE_ERROR) || (id == VM_NOCHANGE_ERROR) ||
                (id == VOICEMAIL_DIALOG_CONFIRM) || (id == RADIO_OFF_ERROR)){

            AlertDialog.Builder b = new AlertDialog.Builder(this);

            int msgId;
            int titleId = R.string.error_updating_title;
            switch (id) {
                case VOICEMAIL_DIALOG_CONFIRM:
                    msgId = R.string.vm_changed;
                    titleId = R.string.voicemail;
                    // Set Button 2
                    b.setNegativeButton(R.string.close_dialog, this);
                    break;
                case VM_NOCHANGE_ERROR:
                    // even though this is technically an error,
                    // keep the title friendly.
                    msgId = R.string.no_change;
                    titleId = R.string.voicemail;
                    // Set Button 2
                    b.setNegativeButton(R.string.close_dialog, this);
                    break;
                case VM_RESPONSE_ERROR:
                    msgId = R.string.vm_change_failed;
                    // Set Button 1
                    b.setPositiveButton(R.string.close_dialog, this);
                    break;
                case RESPONSE_ERROR:
                    msgId = R.string.response_error;
                    // Set Button 2, tells the activity that the error is
                    // recoverable on dialog exit.
                    b.setNegativeButton(R.string.close_dialog, this);
                    break;
                case RADIO_OFF_ERROR:
                    msgId = R.string.radio_off_error;
                    // Set Button 3
                    b.setNeutralButton(R.string.close_dialog, this);
                    break;
                case EXCEPTION_ERROR:
                default:
                    msgId = R.string.exception_error;
                    // Set Button 3, tells the activity that the error is
                    // not recoverable on dialog exit.
                    b.setNeutralButton(R.string.close_dialog, this);
                    break;
            }

            b.setTitle(getText(titleId));
            b.setMessage(getText(msgId));
            b.setCancelable(false);
            AlertDialog dialog = b.create();

            // make the dialog more obvious by bluring the background.
            dialog.getWindow().addFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND);

            return dialog;
        }

        return null;
    }

    // This is a method implemented for DialogInterface.OnClickListener.
    // Used with the error dialog to close the app, voicemail dialog to just dismiss.
    // Close button is mapped to BUTTON1 for the errors that close the activity,
    // while those that are mapped to 3 only move the preference focus.
    public void onClick(DialogInterface dialog, int which) {
        dialog.dismiss();
        switch (which){
            case DialogInterface.BUTTON3:
                // Neutral Button, used when we want to cancel expansion.
                dismissExpandedDialog();
                break;
            case DialogInterface.BUTTON1:
                // Negative Button
                finish();
                break;
            default:
                // just let the dialog close and go back to the input
                // ready state
                setAppState (AppState.INPUT_READY);
                // Positive Button
        }
    }

    /** dismiss the expanded dialog view, going back to the main preference view */
    private void dismissExpandedDialog() {
        // The dialogs that can invoke this method (via onClick()), can ONLY
        // be reached when either expanded dialog (More or Call Forwarding)
        // is open.  However, the Monkey somehow managed to get to this code
        // without the expanded dialogs being available (1305094).  Adding null
        // pointer checks just as a good measure.  This should be fine because
        // if the expanded dialog is NOT shown, we want to ignore the dismiss
        // message and go to INPUT_READY anyway.
        switch (mDisplayMode) {
            case DISP_MODE_CF:
                if (mButtonCFExpand != null && mButtonCFExpand.getDialog() != null) {
                    mButtonCFExpand.getDialog().dismiss();
                }
                break;
            case DISP_MODE_MORE:
                if (mButtonGSMMoreExpand != null && mButtonGSMMoreExpand.getDialog() != null) {
                    // TODO - check for mButtonCDMAMoreExpand symmetry
                    mButtonGSMMoreExpand.getDialog().dismiss();
                }
                break;
        }
        mDisplayMode = DISP_MODE_MAIN;
        setAppState (AppState.INPUT_READY);
    }

    // set the app state when no error message needs to be set.
    private void setAppState(AppState requestedState) throws IllegalStateException{
        if (requestedState == AppState.NETWORK_ERROR) {
            if (DBG) log("setAppState: illegal error state without reason.");
            throw new IllegalStateException ("illegal error state without reason.");
        }
        setAppState (requestedState, MSG_OK);
    }

    // set the app state with optional status.
    private void setAppState(AppState requestedState, int msgStatus)
            throws IllegalStateException{

        if (requestedState == mAppState) {
            if (DBG) log("setAppState: requestedState same as current state. ignoring.");
            return;
        }

        // handle errors
        // make sure we dismiss the correct dialogs.
        if (requestedState == AppState.NETWORK_ERROR) {
            if (DBG) log("setAppState: " + requestedState + ": " + msgStatus);
            switch (msgStatus) {
                case MSG_EXCEPTION:
                    if (mAppState == AppState.INITIAL_QUERY) {
                        dismissDialog(INITIAL_BUSY_DIALOG);
                    } else {
                        dismissBusyDialog();
                    }
                    showDialog (EXCEPTION_ERROR);
                    break;
                case MSG_RADIO_OFF:
                    showDialog (RADIO_OFF_ERROR);
                    break;
                case MSG_UNEXPECTED_RESPONSE:
                    if (mAppState == AppState.INITIAL_QUERY) {
                        dismissDialog(INITIAL_BUSY_DIALOG);
                    } else {
                        dismissBusyDialog();
                    }
                    showDialog (RESPONSE_ERROR);
                    break;
                case MSG_VM_EXCEPTION:
                    dismissDialog(VOICEMAIL_DIALOG_PROGRESS);
                    showDialog (VM_RESPONSE_ERROR);
                    break;
                case MSG_OK:
                default:
                    // This should never happen.
            }
            mAppState = requestedState;
            return;
        }

        switch (mAppState) {
            // We can now transition out of the NETWORK_ERROR state, when the
            // user is moving from the expanded views back to the main view.
            case NETWORK_ERROR:
                if (requestedState != AppState.INPUT_READY) {
                    if (DBG) log("setAppState: illegal transition from NETWORK_ERROR");
                    throw new IllegalStateException
                            ("illegal transition from NETWORK_ERROR");
                }
                break;
            case INPUT_READY:
                if (DBG) log("setAppState: displaying busy dialog, reason: " + requestedState);
                if (requestedState == AppState.INITIAL_QUERY) {
                    showDialog(INITIAL_BUSY_DIALOG);
                } else if (requestedState == AppState.BUSY_NETWORK_CONNECT) {
                    showDialog(BUSY_DIALOG);
                } else if (requestedState == AppState.WAITING_NUMBER_SELECT) {
                    if (DBG) log("setAppState: illegal transition from INPUT_READY");
                    throw new IllegalStateException
                            ("illegal transition from INPUT_READY");
                }
                break;
            case DIALOG_OPEN:
                if (requestedState == AppState.INPUT_READY) {
                    if (msgStatus == MSG_VM_NOCHANGE) {
                        showDialog(VM_NOCHANGE_ERROR);
                    }
                } else {
                    if (msgStatus == MSG_VM_BUSY) {
                        showDialog(VOICEMAIL_DIALOG_PROGRESS);
                    } else {
                        showDialog(BUSY_DIALOG);
                    }
                }
                break;
            case INITIAL_QUERY:
                // the initial query state can ONLY go to the input ready state.
                if (requestedState != AppState.INPUT_READY) {
                    if (DBG) log("setAppState: illegal transition from INITIAL_QUERY");
                    throw new IllegalStateException
                            ("illegal transition from INITIAL_QUERY");
                }
                dismissDialog(INITIAL_BUSY_DIALOG);
                break;
            case BUSY_NETWORK_CONNECT:
                if (requestedState != AppState.INPUT_READY) {
                    if (DBG) log("setAppState: illegal transition from BUSY_NETWORK_CONNECT");
                    throw new IllegalStateException
                            ("illegal transition from BUSY_NETWORK_CONNECT");
                }
                if (msgStatus == MSG_VM_OK) {
                    dismissDialog(VOICEMAIL_DIALOG_PROGRESS);
                    showDialog(VOICEMAIL_DIALOG_CONFIRM);
                } else {
                    dismissBusyDialog();
                }
                break;
            case WAITING_NUMBER_SELECT:
                if (requestedState != AppState.DIALOG_OPEN) {
                    if (DBG) log("setAppState: illegal transition from WAITING_NUMBER_SELECT");
                    throw new IllegalStateException
                            ("illegal transition from WAITING_NUMBER_SELECT");
                }
                dismissBusyDialog();
                break;
        }
        mAppState = requestedState;
    }

    /**
     * Make sure that the busy dialog is available before we try to close it.
     * This check needs to be done because the generic busy dialog is used for
     * a number of cases, but we need to make sure it has been displayed before
     * being dismissed.
     */
    private final void dismissBusyDialog() {
        if (mIsBusyDialogAvailable) {
            dismissDialog(BUSY_DIALOG);
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        mPhone = PhoneFactory.getDefaultPhone();

        // upon resumption from the sub-activity, make sure we re-enable the
        // preferences.
        getPreferenceScreen().setEnabled(true);

        if (mPhone.getPhoneName().equals("CDMA")) {
            // Set UI state in onResume because a user could go home, launch some
            // app to change this setting's backend, and re-launch this settings app
            // and the UI state would be inconsistent with actual state
            handleSetVPMessage();
            mPhone.queryTTYMode(Message.obtain(mQueryTTYComplete, EVENT_TTY_EXECUTED));
            // TODO(Moto): Re-launch DTMF settings if necessary onResume
        }

    }

    /*
     * Activity class methods
     */

    @Override
    protected void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        mPhone = PhoneFactory.getDefaultPhone();

        // If the phone loads in CDMA mode , Call Settings XML is CDMA specific
        // TODO: For World Phone, that has options to switch n/w mode dynamically, this
        // design will not work and this piece of code may be moved to onResume()
        if (mPhone.getPhoneName().equals("CDMA")) {
            addPreferencesFromResource(R.xml.cdma_call_feature_setting);
        } else {
            addPreferencesFromResource(R.xml.call_feature_setting);
        }
        // get buttons
        PreferenceScreen prefSet = getPreferenceScreen();
        mSubMenuVoicemailSettings = (EditPhoneNumberPreference)
                prefSet.findPreference(BUTTON_VOICEMAIL_KEY);
        mSubMenuFDNSettings = (PreferenceScreen) prefSet.findPreference(BUTTON_FDN_KEY);

        if (mPhone.getPhoneName().equals("CDMA")) {
            mButtonVoicePrivacy = (CheckBoxPreference) findPreference(BUTTON_VP_KEY);

            mButtonTTY = (ListPreference) prefSet.findPreference(BUTTON_TTY_KEY);
            mButtonTTY.setOnPreferenceChangeListener(this);

            // Get the ttyMode from Settings.System and displays it
            int settingsTtyMode = android.provider.Settings.Secure.getInt(
                    mPhone.getContext().getContentResolver(),
                    android.provider.Settings.Secure.PREFERRED_TTY_MODE,
                    preferredTtyMode);
            mButtonTTY.setValue(Integer.toString(settingsTtyMode));
            UpdatePreferredTtyModeSummary(settingsTtyMode);

            mButtonDS = (ListPreference) findPreference(BUTTON_DS_KEY);
            int index = Settings.System.getInt(getContentResolver(),
                    Settings.System.DTMF_TONE_TYPE_WHEN_DIALING, preferredDtmfMode);
            mButtonDS.setValueIndex(index);
            mButtonDS.setOnPreferenceChangeListener(this);
        } else if (mPhone.getPhoneName().equals("GSM")) {
            mButtonCLIR  = (ListPreference) prefSet.findPreference(BUTTON_CLIR_KEY);
            mButtonCW    = (CheckBoxPreference) prefSet.findPreference(BUTTON_CW_KEY);
            mButtonCFU   = (EditPhoneNumberPreference) prefSet.findPreference(BUTTON_CFU_KEY);
            mButtonCFB   = (EditPhoneNumberPreference) prefSet.findPreference(BUTTON_CFB_KEY);
            mButtonCFNRy = (EditPhoneNumberPreference) prefSet.findPreference(BUTTON_CFNRY_KEY);
            mButtonCFNRc = (EditPhoneNumberPreference) prefSet.findPreference(BUTTON_CFNRC_KEY);

            // get a reference to the Preference Screens for Call Forwarding and "More" settings.
            mButtonCFExpand = (PreferenceScreen) prefSet.findPreference(BUTTON_CF_EXPAND_KEY);
            mButtonGSMMoreExpand = (PreferenceScreen) prefSet.findPreference(
                    BUTTON_GSM_MORE_EXPAND_KEY);

            // The intent code that resided here in the past has been moved into the
            // more conventional location in network_setting.xml

            // Set links to the current activity and any UI settings that
            // effect the dialog for each preference.  Also set the
            // dependencies between the child (CFB, CFNRy, CFNRc)
            // preferences and the CFU preference.
            if (mButtonCFU != null){
                mButtonCFU.setParentActivity(this, CommandsInterface.CF_REASON_UNCONDITIONAL, this);
                mButtonCFU.setDialogOnClosedListener(this);
                mButtonCFU.setDialogTitle(R.string.labelCF);
                mButtonCFU.setDialogMessage(R.string.messageCFU);
            }

            if (mButtonCFB != null) {
                mButtonCFB.setParentActivity(this, CommandsInterface.CF_REASON_BUSY, this);
                mButtonCFB.setDialogOnClosedListener(this);
                mButtonCFB.setDependency(BUTTON_CFU_KEY);
                mButtonCFB.setDialogTitle(R.string.labelCF);
                mButtonCFB.setDialogMessage(R.string.messageCFB);
            }

            if (mButtonCFNRy != null) {
                mButtonCFNRy.setParentActivity(this, CommandsInterface.CF_REASON_NO_REPLY, this);
                mButtonCFNRy.setDialogOnClosedListener(this);
                mButtonCFNRy.setDependency(BUTTON_CFU_KEY);
                mButtonCFNRy.setDialogTitle(R.string.labelCF);
                mButtonCFNRy.setDialogMessage(R.string.messageCFNRy);
            }

            if (mButtonCFNRc != null) {
                mButtonCFNRc.setParentActivity(this, CommandsInterface.CF_REASON_NOT_REACHABLE, this);
                mButtonCFNRc.setDialogOnClosedListener(this);
                mButtonCFNRc.setDependency(BUTTON_CFU_KEY);
                mButtonCFNRc.setDialogTitle(R.string.labelCF);
                mButtonCFNRc.setDialogMessage(R.string.messageCFNRc);
            }

            // set the listener for the CLIR list preference so we can issue CLIR commands.
            if (mButtonCLIR != null ) {
                mButtonCLIR.setOnPreferenceChangeListener(this);
            }

            if (mSubMenuFDNSettings != null) {
                mFDNSettingIntent = new Intent(Intent.ACTION_MAIN);
                mFDNSettingIntent.setClassName(this, FdnSetting.class.getName());
                mSubMenuFDNSettings.setIntent (mFDNSettingIntent);
            }
        }

        if (mSubMenuVoicemailSettings != null) {
            mSubMenuVoicemailSettings.setParentActivity(this, VOICEMAIL_PREF_ID, this);
            mSubMenuVoicemailSettings.setDialogOnClosedListener(this);
            mSubMenuVoicemailSettings.setDialogTitle(R.string.voicemail_settings_number_label);
        }

        // create intent to bring up contact list
        mContactListIntent = new Intent(Intent.ACTION_GET_CONTENT);
        mContactListIntent.setType(android.provider.Contacts.Phones.CONTENT_ITEM_TYPE);

        if (mSubMenuFDNSettings != null) {
            mFDNSettingIntent = new Intent(Intent.ACTION_MAIN);
            mFDNSettingIntent.setClassName(this, FdnSetting.class.getName());
            mSubMenuFDNSettings.setIntent (mFDNSettingIntent);
        }

        mAppState = AppState.INPUT_READY;

        if (icicle != null) {
            if (mPhone.getPhoneName().equals("CDMA")) {
                mButtonVoicePrivacy.setChecked(icicle.getBoolean(BUTTON_VP_KEY));
            } else if (mPhone.getPhoneName().equals("GSM")) {
                // retrieve number state
                mDialingNumCFU = icicle.getString(SUMMARY_CFU_KEY);
                mDialingNumCFB = icicle.getString(SUMMARY_CFB_KEY);
                mDialingNumCFNRy = icicle.getString(SUMMARY_CFNRY_KEY);
                mDialingNumCFNRc = icicle.getString(SUMMARY_CFNRC_KEY);

                // reset CF buttons
                adjustCFbuttonState(mButtonCFU, icicle.getBoolean(BUTTON_CFU_KEY),
                        R.string.sum_cfu_enabled, mDialingNumCFU);
                adjustCFbuttonState(mButtonCFB, icicle.getBoolean(BUTTON_CFB_KEY),
                        R.string.sum_cfb_enabled, mDialingNumCFB);
                adjustCFbuttonState(mButtonCFNRy, icicle.getBoolean(BUTTON_CFNRY_KEY),
                        R.string.sum_cfnry_enabled, mDialingNumCFNRy);
                adjustCFbuttonState(mButtonCFNRc, icicle.getBoolean(BUTTON_CFNRC_KEY),
                        R.string.sum_cfnrc_enabled, mDialingNumCFNRc);

                // reset other button state
                setButtonCLIRValue(icicle.getInt(BUTTON_CLIR_KEY));
                if (mButtonCW != null) {
                    mButtonCW.setChecked(icicle.getBoolean(BUTTON_CW_KEY));
                }

                mCFDataStale = icicle.getBoolean(BUTTON_CF_EXPAND_KEY);
                mMoreDataStale = icicle.getBoolean(BUTTON_GSM_MORE_EXPAND_KEY);
            }

            // set app state
            mAppState = (AppState) icicle.getSerializable(APP_STATE_KEY);
            mDisplayMode = icicle.getInt(DISPLAY_MODE_KEY);

        } else {
            // The queries here are now lazily done, and all data is assumed stale
            // when we first start the activity.
            mCFDataStale = true;
            mMoreDataStale = true;

            // check the intent that started this activity and pop up the voicemail
            // dialog if we've been asked to.
            if (getIntent().getAction().equals(ACTION_ADD_VOICEMAIL)) {
                setAppState(AppState.DIALOG_OPEN);
                mSubMenuVoicemailSettings.showPhoneNumberDialog();
            }
        }

        updateVoiceNumberField();
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);

        if (DBG) log("onSaveInstanceState: saving relevant UI state.");

        // save button state
        if (mPhone.getPhoneName().equals("CDMA")) {
            outState.putBoolean(BUTTON_VP_KEY, mButtonVoicePrivacy.isChecked());
            outState.putInt(BUTTON_TTY_KEY, mButtonTTY.findIndexOfValue(mButtonTTY.getValue()));
        } else if (mPhone.getPhoneName().equals("GSM")) {
            if (mButtonCLIR != null) {
                outState.putInt(BUTTON_CLIR_KEY, mButtonCLIR.findIndexOfValue(mButtonCLIR.getValue()));
            }
            if (mButtonCW != null) {
                outState.putBoolean(BUTTON_CW_KEY, mButtonCW.isChecked());
            }
            if (mButtonCFU != null) {
                outState.putBoolean(BUTTON_CFU_KEY, mButtonCFU.isToggled());
           }
            if (mButtonCFB != null) {
                outState.putBoolean(BUTTON_CFB_KEY, mButtonCFB.isToggled());
            }
            if (mButtonCFNRy != null) {
                outState.putBoolean(BUTTON_CFNRY_KEY, mButtonCFNRy.isToggled());
            }
            if (mButtonCFNRc != null) {
                 outState.putBoolean(BUTTON_CFNRC_KEY, mButtonCFNRc.isToggled());
            }

            // save number state
            outState.putString(SUMMARY_CFU_KEY, mDialingNumCFU);
            outState.putString(SUMMARY_CFB_KEY, mDialingNumCFB);
            outState.putString(SUMMARY_CFNRY_KEY, mDialingNumCFNRy);
            outState.putString(SUMMARY_CFNRC_KEY, mDialingNumCFNRc);

            outState.putBoolean(BUTTON_CF_EXPAND_KEY, mCFDataStale);
            outState.putBoolean(BUTTON_GSM_MORE_EXPAND_KEY, mMoreDataStale);
        }
        // save state of the app
        outState.putSerializable(APP_STATE_KEY, mAppState);

        outState.putInt(DISPLAY_MODE_KEY, mDisplayMode);
    }

    // TTY object
    private void handleTTYClickRequest(Preference preference, Object objValue) {
        int buttonTtyMode;
        buttonTtyMode = Integer.valueOf((String) objValue).intValue();
        int settingsTtyMode = android.provider.Settings.Secure.getInt(
                mPhone.getContext().getContentResolver(),
                android.provider.Settings.Secure.PREFERRED_TTY_MODE, preferredTtyMode);
        if (DBG) log("handleTTYClickRequest: requesting set TTY mode enable (TTY) to" +
                Integer.toString(buttonTtyMode));

        if (buttonTtyMode != settingsTtyMode) {
            switch(buttonTtyMode) {
            case Phone.TTY_MODE_OFF:
                mPhone.setTTYMode(Phone.TTY_MODE_OFF,
                        Message.obtain(mSetTTYComplete, EVENT_TTY_MODE_SET));
                break;
            case Phone.TTY_MODE_FULL:
                mPhone.setTTYMode(Phone.TTY_MODE_FULL,
                        Message.obtain(mSetTTYComplete, EVENT_TTY_MODE_SET));
                break;
            case Phone.TTY_MODE_HCO:
                mPhone.setTTYMode(Phone.TTY_MODE_HCO,
                        Message.obtain(mSetTTYComplete, EVENT_TTY_MODE_SET));
                break;
            case Phone.TTY_MODE_VCO:
                mPhone.setTTYMode(Phone.TTY_MODE_VCO,
                        Message.obtain(mSetTTYComplete, EVENT_TTY_MODE_SET));
                break;
            default:
                mPhone.setTTYMode(Phone.TTY_MODE_OFF,
                        Message.obtain(mSetTTYComplete, EVENT_TTY_MODE_SET));
            }
            UpdatePreferredTtyModeSummary(buttonTtyMode);

            android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
                    android.provider.Settings.Secure.PREFERRED_TTY_MODE,
                    buttonTtyMode );
        }
    }

    /*
     * Callback to handle TTY mode update completions
     */

    // **Callback on TTY mode when complete.
    private Handler mSetTTYComplete = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            // query to make sure we're looking at the same data as that in the network.
            switch (msg.what) {
                case EVENT_TTY_EXECUTED:
                    handleQueryTtyResponse(msg);
                    onResume();
                    break;
                case EVENT_TTY_MODE_SET:
                    onResume();
                    break;
                default:
                    // TODO: should never reach this, may want to throw exception
            }
        }
    };

    // TTY Object
    private void handleSetTTYMessage() {
        if (DBG) {
            log("handleSetTTYMessage: set TTY request complete, reading value from network.");
        }
        mPhone.queryTTYMode(Message.obtain(mQueryTTYComplete, EVENT_TTY_EXECUTED));
        android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
                android.provider.Settings.Secure.TTY_MODE_ENABLED, preferredTtyMode );
    }

    private void handleQueryTtyResponse(Message msg) {
        AsyncResult ar = (AsyncResult) msg.obj;

        if (ar.exception == null) {
            int ttyMode = ((int[])ar.result)[0];


            int settingsTtyMode = android.provider.Settings.Secure.getInt(
                    mPhone.getContext().getContentResolver(),
                    android.provider.Settings.Secure.PREFERRED_TTY_MODE,
                    preferredTtyMode);

            //check that modemNetworkMode is from an accepted value
            if (ttyMode == Phone.TTY_MODE_OFF ||
                    ttyMode == Phone.TTY_MODE_HCO ||
                    ttyMode == Phone.TTY_MODE_VCO ||
                    ttyMode == Phone.TTY_MODE_FULL) {

                //check changes in modemNetworkMode and updates settingsNetworkMode
                if (ttyMode != settingsTtyMode) {
                    if (DBG) {
                        log("handleGetPreferredNetworkTypeResponse: if 2: " +
                                "modemNetworkMode != settingsNetworkMode");
                    }

                    settingsTtyMode = ttyMode;

                    if (DBG) { log("handleGetPreferredNetworkTypeResponse: if 2: " +
                            "settingsNetworkMode = " + settingsTtyMode);
                    }

                    //changes the Settings.System accordingly to modemNetworkMode
                    android.provider.Settings.Secure.putInt(
                            mPhone.getContext().getContentResolver(),
                            android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
                            settingsTtyMode);
                }

                UpdatePreferredTtyModeSummary(ttyMode);
                // changes the mButtonPreferredNetworkMode accordingly to modemNetworkMode
                mButtonTTY.setValue(Integer.toString(ttyMode));
            } else {
                if (DBG) log("handleGetPreferredNetworkTypeResponse: else: reset to default");
                resetTtyModeToDefault();
            }
        }
    }

    private void resetTtyModeToDefault() {
        //set the mButtonPreferredTtyMode
        mButtonTTY.setValue(Integer.toString(preferredTtyMode));
        //set the Settings.System
        android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
                    android.provider.Settings.Secure.PREFERRED_TTY_MODE,
                    preferredTtyMode );
        //Set the Modem
        mPhone.setTTYMode(preferredTtyMode,
                Message.obtain(mSetTTYComplete, EVENT_TTY_EXECUTED));
    }

    private void UpdatePreferredTtyModeSummary(int TtyMode) {
        switch(TtyMode) {
            case Phone.TTY_MODE_OFF:
                mButtonTTY.setSummary("TTY Mode OFF");
                break;
            case Phone.TTY_MODE_HCO:
                mButtonTTY.setSummary("TTY Mode HCO");
                break;
            case Phone.TTY_MODE_VCO:
                mButtonTTY.setSummary("TTY Mode VCO");
                break;
            case Phone.TTY_MODE_FULL:
                mButtonTTY.setSummary("TTY Mode Full");
                break;
            default:
                mButtonTTY.setSummary("TTY Mode OFF");
        }
    }

    /*
     * Callback to handle query completions
     */

    // **Callback on option getting when complete.
    private Handler mQueryTTYComplete = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case EVENT_TTY_EXECUTED:
                    handleQueryTTYModeMessage((AsyncResult) msg.obj);
                    break;
                default:
                    // TODO: should never reach this, may want to throw exception
            }
        }
    };

    // TTY Object
    private int handleQueryTTYModeMessage(AsyncResult ar) {
        if (ar.exception != null) {
            if (DBG) log("handleQueryTTYModeMessage: Error getting TTY enable state.");
            return MSG_EXCEPTION;
        } else {
            if (DBG) log("handleQueryTTYModeMessage: TTY enable state successfully queried.");
            syncTTYState((int[]) ar.result);
            android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
                    android.provider.Settings.Secure.TTY_MODE_ENABLED, preferredTtyMode );
        }
        return MSG_OK;
    }
    /**
     * Tells the StatusBar whether the TTY mode is enabled or disabled
     */
    private static void setStatusBarIcon(Context context, boolean enabled) {
        Intent ttyModeChanged = new Intent(TtyIntent.TTY_ENABLED_CHANGE_ACTION);
        ttyModeChanged.putExtra("ttyEnabled", enabled);
        context.sendBroadcast(ttyModeChanged);
    }

    // set the state of the UI based on TTY State
    private void syncTTYState(int ttyArray[]) {
    if (DBG) log("syncTTYState: Setting UI state consistent with TTY enable state of " +
           ((ttyArray[0] != 0) ? "ENABLED" : "DISABLED"));

        Context context = this;

        if (ttyArray[0] == 0) {
            // turn off TTY icon at StatusBar
            setStatusBarIcon(context, false);
        }
        else {
            //display TTY icon at StatusBar
            setStatusBarIcon(context, true);
        }
    }


    //VP object click
    private void handleVoicePrivacyClickRequest(boolean value) {
        mPhone.enableEnhancedVoicePrivacy(value, Message.obtain(mSetVoicePrivacyComplete,
                EVENT_ENHANCED_VP_EXECUTED));
    }

    // **Callback on VP mode when complete.
    private Handler mSetVoicePrivacyComplete = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            // query to make sure we're looking at the same data as that in the network.
            switch (msg.what) {
                case EVENT_ENHANCED_VP_EXECUTED:
                    handleSetVPMessage();
                    break;
                default:
                    // TODO: should never reach this, may want to throw exception
            }
        }
    };

    // VP Object Set
    private void handleSetVPMessage() {
        mPhone.getEnhancedVoicePrivacy(Message.obtain(mQueryVoicePrivacyComplete,
                EVENT_ENHANCED_VP_EXECUTED));
        android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
                android.provider.Settings.Secure.ENHANCED_VOICE_PRIVACY_ENABLED, preferredVPMode);
    }

    /*
     * Callback to handle VP query completions
     */

    // **Callback on option getting when complete.
    private Handler mQueryVoicePrivacyComplete = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case EVENT_ENHANCED_VP_EXECUTED:
                    handleQueryVPModeMessage((AsyncResult) msg.obj);
                    break;
                default:
                    // TODO: should never reach this, may want to throw exception
            }
        }
    };

    // VP Object Query
    private int handleQueryVPModeMessage(AsyncResult ar) {
        if (ar.exception != null) {
            if (DBG) {
                log("handleQueryVPModeMessage: Error getting VoicePrivacy enable state.");
            }
            return MSG_EXCEPTION;
        } else {
            if (DBG) {
                log("handleQueryVPModeMessage: VoicePrivacy enable state successfully queried.");
            }
            syncVPState((int[]) ar.result);
            android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
                    android.provider.Settings.Secure.ENHANCED_VOICE_PRIVACY_ENABLED,
                    preferredVPMode );
        }
        return MSG_OK;
    }

    // set the state of the UI based on VP state
    private void syncVPState(int vpArray[]) {
        Log.d(LOG_TAG, "syncVPState: Setting UI state consistent with VP enable state of"
                + ((vpArray[0] != 0) ? "ENABLED" : "DISABLED"));
        mButtonVoicePrivacy.setChecked(vpArray[0] != 0);
    }

    private static void log(String msg) {
        Log.d(LOG_TAG, msg);
    }
}