SIP: duplicate PhoneApp for telephony integration development

Change-Id: Ieca0d08314c33026afe3ea47c0844e0920a58659

1 files changed, 475 insertions, 0 deletions

diff --git a/phone/src/com/android/phone2/Settings.java b/phone/src/com/android/phone2/Settings.java
new file mode 100644
index 0000000..bf2b956
--- /dev/null
+++ b/phone/src/com/android/phone2/Settings.java
@@ -0,0 +1,475 @@
+/*
+ * Copyright (C) 2006 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.phone2;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.net.ConnectivityManager;
+import android.net.ThrottleManager;
+import android.os.AsyncResult;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.os.SystemProperties;
+import android.preference.CheckBoxPreference;
+import android.preference.ListPreference;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceScreen;
+import android.util.Log;
+
+import com.android.internal.telephony.Phone;
+import com.android.internal.telephony.PhoneFactory;
+import com.android.internal.telephony.TelephonyIntents;
+import com.android.internal.telephony.TelephonyProperties;
+
+/**
+ * List of Phone-specific settings screens.
+ */
+public class Settings extends PreferenceActivity implements DialogInterface.OnClickListener,
+        DialogInterface.OnDismissListener, Preference.OnPreferenceChangeListener{
+
+    // debug data
+    private static final String LOG_TAG = "NetworkSettings";
+    private static final boolean DBG = true;
+    public static final int REQUEST_CODE_EXIT_ECM         = 17;
+
+    //String keys for preference lookup
+    private static final String BUTTON_DATA_ENABLED_KEY = "button_data_enabled_key";
+    private static final String BUTTON_DATA_USAGE_KEY = "button_data_usage_key";
+    private static final String BUTTON_PREFERED_NETWORK_MODE = "preferred_network_mode_key";
+    private static final String BUTTON_ROAMING_KEY = "button_roaming_key";
+    private static final String BUTTON_CDMA_ROAMING_KEY = "cdma_roaming_mode_key";
+
+    private static final String BUTTON_GSM_UMTS_OPTIONS = "gsm_umts_options_key";
+    private static final String BUTTON_CDMA_OPTIONS = "cdma_options_key";
+
+    static final int preferredNetworkMode = Phone.PREFERRED_NT_MODE;
+
+    //UI objects
+    private ListPreference mButtonPreferredNetworkMode;
+    private CheckBoxPreference mButtonDataRoam;
+    private CheckBoxPreference mButtonDataEnabled;
+    private CdmaRoamingListPreference mButtonCdmaRoam;
+
+    private Preference mButtonDataUsage;
+    private DataUsageListener mDataUsageListener;
+    private static final String iface = "rmnet0"; //TODO: this will go away
+
+    private Phone mPhone;
+    private MyHandler mHandler;
+    private boolean mOkClicked;
+
+    //GsmUmts options and Cdma options
+    GsmUmtsOptions gsmumtsOptions;
+    CdmaOptions cdmaOptions;
+
+
+    //This is a method implemented for DialogInterface.OnClickListener.
+    //  Used to dismiss the dialogs when they come up.
+    public void onClick(DialogInterface dialog, int which) {
+        if (which == DialogInterface.BUTTON1) {
+            mPhone.setDataRoamingEnabled(true);
+            mOkClicked = true;
+        } else {
+            // Reset the toggle
+            mButtonDataRoam.setChecked(false);
+        }
+    }
+
+    public void onDismiss(DialogInterface dialog) {
+        // Assuming that onClick gets called first
+        if (!mOkClicked) {
+            mButtonDataRoam.setChecked(false);
+        }
+    }
+
+    /**
+     * Invoked on each preference click in this hierarchy, overrides
+     * PreferenceActivity's implementation.  Used to make sure we track the
+     * preference click events.
+     */
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
+        if (gsmumtsOptions != null &&
+                gsmumtsOptions.onPreferenceTreeClick(preferenceScreen, preference) == true) {
+            return true;
+        } else if (cdmaOptions != null &&
+                   cdmaOptions.onPreferenceTreeClick(preferenceScreen, preference) == true) {
+            if (Boolean.parseBoolean(
+                    SystemProperties.get(TelephonyProperties.PROPERTY_INECM_MODE))) {
+                // In ECM mode launch ECM app dialog
+                startActivityForResult(
+                    new Intent(TelephonyIntents.ACTION_SHOW_NOTICE_ECM_BLOCK_OTHERS, null),
+                    REQUEST_CODE_EXIT_ECM);
+            }
+            return true;
+        } else if (preference == mButtonPreferredNetworkMode) {
+            //displays the value taken from the Settings.System
+            int settingsNetworkMode = android.provider.Settings.Secure.getInt(mPhone.getContext().
+                    getContentResolver(), android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
+                    preferredNetworkMode);
+            mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode));
+            return true;
+        }
+        else if (preference == mButtonDataRoam) {
+            if (DBG) log("onPreferenceTreeClick: preference == mButtonDataRoam.");
+
+            //normally called on the toggle click
+            if (mButtonDataRoam.isChecked()) {
+                // First confirm with a warning dialog about charges
+                mOkClicked = false;
+                new AlertDialog.Builder(this).setMessage(
+                        getResources().getString(R.string.roaming_warning))
+                        .setTitle(android.R.string.dialog_alert_title)
+                        .setIcon(android.R.drawable.ic_dialog_alert)
+                        .setPositiveButton(android.R.string.yes, this)
+                        .setNegativeButton(android.R.string.no, this)
+                        .show()
+                        .setOnDismissListener(this);
+            }
+            else {
+                mPhone.setDataRoamingEnabled(false);
+            }
+            return true;
+        } else if (preference == mButtonDataEnabled) {
+            if (DBG) log("onPreferenceTreeClick: preference == mButtonDataEnabled.");
+            ConnectivityManager cm =
+                    (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
+
+            cm.setMobileDataEnabled(mButtonDataEnabled.isChecked());
+            return true;
+        } else {
+            // if the button is anything but the simple toggle preference,
+            // we'll need to disable all preferences to reject all click
+            // events until the sub-activity's UI comes up.
+            preferenceScreen.setEnabled(false);
+            // Let the intents be launched by the Preference manager
+            return false;
+        }
+    }
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        addPreferencesFromResource(R.xml.network_setting);
+
+        mPhone = PhoneFactory.getDefaultPhone();
+        mHandler = new MyHandler();
+
+        //get UI object references
+        PreferenceScreen prefSet = getPreferenceScreen();
+
+        mButtonDataEnabled = (CheckBoxPreference) prefSet.findPreference(BUTTON_DATA_ENABLED_KEY);
+        mButtonDataRoam = (CheckBoxPreference) prefSet.findPreference(BUTTON_ROAMING_KEY);
+        mButtonPreferredNetworkMode = (ListPreference) prefSet.findPreference(
+                BUTTON_PREFERED_NETWORK_MODE);
+        mButtonDataUsage = prefSet.findPreference(BUTTON_DATA_USAGE_KEY);
+
+        if (getResources().getBoolean(R.bool.world_phone) == true) {
+            // set the listener for the mButtonPreferredNetworkMode list preference so we can issue
+            // change Preferred Network Mode.
+            mButtonPreferredNetworkMode.setOnPreferenceChangeListener(this);
+
+            //Get the networkMode from Settings.System and displays it
+            int settingsNetworkMode = android.provider.Settings.Secure.getInt(mPhone.getContext().
+                    getContentResolver(),android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
+                    preferredNetworkMode);
+            mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode));
+            // The intent code that resided here in the past has been moved into the
+            // more conventional location in network_setting.xml
+
+        } else {
+            prefSet.removePreference(mButtonPreferredNetworkMode);
+            prefSet.removePreference(prefSet.findPreference(BUTTON_GSM_UMTS_OPTIONS));
+            prefSet.removePreference(prefSet.findPreference(BUTTON_CDMA_OPTIONS));
+            int phoneType = mPhone.getPhoneType();
+            if (phoneType == Phone.PHONE_TYPE_CDMA) {
+                addPreferencesFromResource(R.xml.cdma_options);
+                mButtonCdmaRoam =
+                    (CdmaRoamingListPreference) prefSet.findPreference(BUTTON_CDMA_ROAMING_KEY);
+                cdmaOptions = new CdmaOptions();
+            } else if (phoneType == Phone.PHONE_TYPE_GSM) {
+                addPreferencesFromResource(R.xml.gsm_umts_options);
+                gsmumtsOptions = new GsmUmtsOptions();
+            } else {
+                throw new IllegalStateException("Unexpected phone type: " + phoneType);
+            }
+        }
+        ThrottleManager tm = (ThrottleManager) getSystemService(Context.THROTTLE_SERVICE);
+        mDataUsageListener = new DataUsageListener(this, mButtonDataUsage, prefSet);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        // upon resumption from the sub-activity, make sure we re-enable the
+        // preferences.
+        getPreferenceScreen().setEnabled(true);
+
+        ConnectivityManager cm =
+                (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
+        mButtonDataEnabled.setChecked(cm.getMobileDataEnabled());
+
+        // 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
+        mButtonDataRoam.setChecked(mPhone.getDataRoamingEnabled());
+
+        if (getPreferenceScreen().findPreference(BUTTON_PREFERED_NETWORK_MODE) != null)  {
+            mPhone.getPreferredNetworkType(mHandler.obtainMessage(
+                    MyHandler.MESSAGE_GET_PREFERRED_NETWORK_TYPE));
+        }
+        mDataUsageListener.resume();
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        mDataUsageListener.pause();
+    }
+
+    /**
+     * 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 == mButtonPreferredNetworkMode) {
+            //NOTE onPreferenceChange seems to be called even if there is no change
+            //Check if the button value is changed from the System.Setting
+            mButtonPreferredNetworkMode.setValue((String) objValue);
+            int buttonNetworkMode;
+            buttonNetworkMode = Integer.valueOf((String) objValue).intValue();
+            int settingsNetworkMode = android.provider.Settings.Secure.getInt(
+                    mPhone.getContext().getContentResolver(),
+                    android.provider.Settings.Secure.PREFERRED_NETWORK_MODE, preferredNetworkMode);
+            if (buttonNetworkMode != settingsNetworkMode) {
+                int modemNetworkMode;
+                switch(buttonNetworkMode) {
+                    case Phone.NT_MODE_GLOBAL:
+                        modemNetworkMode = Phone.NT_MODE_GLOBAL;
+                        break;
+                    case Phone.NT_MODE_EVDO_NO_CDMA:
+                        modemNetworkMode = Phone.NT_MODE_EVDO_NO_CDMA;
+                        break;
+                    case Phone.NT_MODE_CDMA_NO_EVDO:
+                        modemNetworkMode = Phone.NT_MODE_CDMA_NO_EVDO;
+                        break;
+                    case Phone.NT_MODE_CDMA:
+                        modemNetworkMode = Phone.NT_MODE_CDMA;
+                        break;
+                    case Phone.NT_MODE_GSM_UMTS:
+                        modemNetworkMode = Phone.NT_MODE_GSM_UMTS;
+                        break;
+                    case Phone.NT_MODE_WCDMA_ONLY:
+                        modemNetworkMode = Phone.NT_MODE_WCDMA_ONLY;
+                        break;
+                    case Phone.NT_MODE_GSM_ONLY:
+                        modemNetworkMode = Phone.NT_MODE_GSM_ONLY;
+                        break;
+                    case Phone.NT_MODE_WCDMA_PREF:
+                        modemNetworkMode = Phone.NT_MODE_WCDMA_PREF;
+                        break;
+                    default:
+                        modemNetworkMode = Phone.PREFERRED_NT_MODE;
+                }
+                UpdatePreferredNetworkModeSummary(buttonNetworkMode);
+
+                android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
+                        android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
+                        buttonNetworkMode );
+                //Set the modem network mode
+                mPhone.setPreferredNetworkType(modemNetworkMode, mHandler
+                        .obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE));
+            }
+        }
+
+        // always let the preference setting proceed.
+        return true;
+    }
+
+    private class MyHandler extends Handler {
+
+        private static final int MESSAGE_GET_PREFERRED_NETWORK_TYPE = 0;
+        private static final int MESSAGE_SET_PREFERRED_NETWORK_TYPE = 1;
+
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case MESSAGE_GET_PREFERRED_NETWORK_TYPE:
+                    handleGetPreferredNetworkTypeResponse(msg);
+                    break;
+
+                case MESSAGE_SET_PREFERRED_NETWORK_TYPE:
+                    handleSetPreferredNetworkTypeResponse(msg);
+                    break;
+            }
+        }
+
+        private void handleGetPreferredNetworkTypeResponse(Message msg) {
+            AsyncResult ar = (AsyncResult) msg.obj;
+
+            if (ar.exception == null) {
+                int modemNetworkMode = ((int[])ar.result)[0];
+
+                if (DBG) {
+                    log ("handleGetPreferredNetworkTypeResponse: modemNetworkMode = " +
+                            modemNetworkMode);
+                }
+
+                int settingsNetworkMode = android.provider.Settings.Secure.getInt(
+                        mPhone.getContext().getContentResolver(),
+                        android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
+                        preferredNetworkMode);
+
+                if (DBG) {
+                    log("handleGetPreferredNetworkTypeReponse: settingsNetworkMode = " +
+                            settingsNetworkMode);
+                }
+
+                //check that modemNetworkMode is from an accepted value
+                if (modemNetworkMode == Phone.NT_MODE_WCDMA_PREF ||
+                        modemNetworkMode == Phone.NT_MODE_GSM_ONLY ||
+                        modemNetworkMode == Phone.NT_MODE_WCDMA_ONLY ||
+                        modemNetworkMode == Phone.NT_MODE_GSM_UMTS ||
+                        modemNetworkMode == Phone.NT_MODE_CDMA ||
+                        modemNetworkMode == Phone.NT_MODE_CDMA_NO_EVDO ||
+                        modemNetworkMode == Phone.NT_MODE_EVDO_NO_CDMA ||
+                        modemNetworkMode == Phone.NT_MODE_GLOBAL ) {
+                    if (DBG) {
+                        log("handleGetPreferredNetworkTypeResponse: if 1: modemNetworkMode = " +
+                                modemNetworkMode);
+                    }
+
+                    //check changes in modemNetworkMode and updates settingsNetworkMode
+                    if (modemNetworkMode != settingsNetworkMode) {
+                        if (DBG) {
+                            log("handleGetPreferredNetworkTypeResponse: if 2: " +
+                                    "modemNetworkMode != settingsNetworkMode");
+                        }
+
+                        settingsNetworkMode = modemNetworkMode;
+
+                        if (DBG) { log("handleGetPreferredNetworkTypeResponse: if 2: " +
+                                "settingsNetworkMode = " + settingsNetworkMode);
+                        }
+
+                        //changes the Settings.System accordingly to modemNetworkMode
+                        android.provider.Settings.Secure.putInt(
+                                mPhone.getContext().getContentResolver(),
+                                android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
+                                settingsNetworkMode );
+                    }
+
+                    UpdatePreferredNetworkModeSummary(modemNetworkMode);
+                    // changes the mButtonPreferredNetworkMode accordingly to modemNetworkMode
+                    mButtonPreferredNetworkMode.setValue(Integer.toString(modemNetworkMode));
+                } else {
+                    if (DBG) log("handleGetPreferredNetworkTypeResponse: else: reset to default");
+                    resetNetworkModeToDefault();
+                }
+            }
+        }
+
+        private void handleSetPreferredNetworkTypeResponse(Message msg) {
+            AsyncResult ar = (AsyncResult) msg.obj;
+
+            if (ar.exception == null) {
+                int networkMode = Integer.valueOf(
+                        mButtonPreferredNetworkMode.getValue()).intValue();
+                android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
+                        android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
+                        networkMode );
+            } else {
+                mPhone.getPreferredNetworkType(obtainMessage(MESSAGE_GET_PREFERRED_NETWORK_TYPE));
+            }
+        }
+
+        private void resetNetworkModeToDefault() {
+            //set the mButtonPreferredNetworkMode
+            mButtonPreferredNetworkMode.setValue(Integer.toString(preferredNetworkMode));
+            //set the Settings.System
+            android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
+                        android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
+                        preferredNetworkMode );
+            //Set the Modem
+            mPhone.setPreferredNetworkType(preferredNetworkMode,
+                    this.obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE));
+        }
+    }
+
+    private void UpdatePreferredNetworkModeSummary(int NetworkMode) {
+        switch(NetworkMode) {
+            case Phone.NT_MODE_WCDMA_PREF:
+                // TODO T: Make all of these strings come from res/values/strings.xml.
+                mButtonPreferredNetworkMode.setSummary("Preferred network mode: WCDMA pref");
+                break;
+            case Phone.NT_MODE_GSM_ONLY:
+                mButtonPreferredNetworkMode.setSummary("Preferred network mode: GSM only");
+                break;
+            case Phone.NT_MODE_WCDMA_ONLY:
+                mButtonPreferredNetworkMode.setSummary("Preferred network mode: WCDMA only");
+                break;
+            case Phone.NT_MODE_GSM_UMTS:
+                mButtonPreferredNetworkMode.setSummary("Preferred network mode: GSM/WCDMA");
+                break;
+            case Phone.NT_MODE_CDMA:
+                mButtonPreferredNetworkMode.setSummary("Preferred network mode: CDMA / EvDo");
+                break;
+            case Phone.NT_MODE_CDMA_NO_EVDO:
+                mButtonPreferredNetworkMode.setSummary("Preferred network mode: CDMA only");
+                break;
+            case Phone.NT_MODE_EVDO_NO_CDMA:
+                mButtonPreferredNetworkMode.setSummary("Preferred network mode: EvDo only");
+                break;
+            case Phone.NT_MODE_GLOBAL:
+            default:
+                mButtonPreferredNetworkMode.setSummary("Preferred network mode: Global");
+        }
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        switch(requestCode) {
+        case REQUEST_CODE_EXIT_ECM:
+            Boolean isChoiceYes =
+                data.getBooleanExtra(EmergencyCallbackModeExitDialog.EXTRA_EXIT_ECM_RESULT, false);
+            if (isChoiceYes) {
+                // If the phone exits from ECM mode, show the system selection Options
+                mButtonCdmaRoam.showDialog(null);
+            } else {
+                // do nothing
+            }
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    private static void log(String msg) {
+        Log.d(LOG_TAG, msg);
+    }
+}