auto import from //depot/cupcake/@135843

78 files changed, 19917 insertions, 0 deletions

diff --git a/src/com/android/settings/ActivityPicker.java b/src/com/android/settings/ActivityPicker.java
new file mode 100644
index 0000000..47e005f
--- /dev/null
+++ b/src/com/android/settings/ActivityPicker.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * 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.settings;
+
+import android.app.LauncherActivity;
+import android.content.Intent;
+import android.os.Parcelable;
+import android.view.View;
+import android.widget.ListView;
+
+/**
+ * Displays a list of all activities matching the incoming {@link Intent.EXTRA_INTENT}
+ * query, along with any applicable icons. 
+ */
+public class ActivityPicker extends LauncherActivity {
+    
+    @Override
+    protected Intent getTargetIntent() {
+        Intent intent = this.getIntent();
+        Intent targetIntent = new Intent(Intent.ACTION_MAIN, null);
+        targetIntent.addCategory(Intent.CATEGORY_DEFAULT);
+        
+        // Use a custom title for this dialog, if provided
+        if (intent.hasExtra(Intent.EXTRA_TITLE)) {
+            String title = intent.getStringExtra(Intent.EXTRA_TITLE);
+            setTitle(title);
+        }
+        
+        Parcelable parcel = intent.getParcelableExtra(Intent.EXTRA_INTENT);
+        if (parcel instanceof Intent) {
+            targetIntent = (Intent) parcel;
+        }
+        
+        return targetIntent;
+    }
+
+    @Override
+    protected void onListItemClick(ListView l, View v, int position, long id) {
+        Intent intent = intentForPosition(position);
+        setResult(RESULT_OK, intent);
+        finish();
+    }
+
+}
diff --git a/src/com/android/settings/AirplaneModeEnabler.java b/src/com/android/settings/AirplaneModeEnabler.java
new file mode 100644
index 0000000..f105712
--- /dev/null
+++ b/src/com/android/settings/AirplaneModeEnabler.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2007 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.settings;
+
+import com.android.internal.telephony.PhoneStateIntentReceiver;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Handler;
+import android.os.Message;
+import android.preference.CheckBoxPreference;
+import android.preference.Preference;
+import android.provider.Settings;
+import android.telephony.ServiceState;
+
+public class AirplaneModeEnabler implements Preference.OnPreferenceChangeListener {
+
+    private final Context mContext;
+
+    private PhoneStateIntentReceiver mPhoneStateReceiver;
+    
+    private final CheckBoxPreference mCheckBoxPref;
+
+    private static final int EVENT_SERVICE_STATE_CHANGED = 3;
+
+    private Handler mHandler = new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case EVENT_SERVICE_STATE_CHANGED:
+                    onAirplaneModeChanged();
+                    break;
+            }
+        }
+    };
+
+    public AirplaneModeEnabler(Context context, CheckBoxPreference airplaneModeCheckBoxPreference) {
+        
+        mContext = context;
+        mCheckBoxPref = airplaneModeCheckBoxPreference;
+        
+        airplaneModeCheckBoxPreference.setPersistent(false);
+    
+        mPhoneStateReceiver = new PhoneStateIntentReceiver(mContext, mHandler);
+        mPhoneStateReceiver.notifyServiceState(EVENT_SERVICE_STATE_CHANGED);
+    }
+
+    public void resume() {
+        
+        // This is the widget enabled state, not the preference toggled state
+        mCheckBoxPref.setEnabled(true);
+        mCheckBoxPref.setChecked(isAirplaneModeOn(mContext));
+
+        mPhoneStateReceiver.registerIntent();
+        mCheckBoxPref.setOnPreferenceChangeListener(this);
+    }
+    
+    public void pause() {
+        mPhoneStateReceiver.unregisterIntent();
+        mCheckBoxPref.setOnPreferenceChangeListener(null);
+    }
+    
+    static boolean isAirplaneModeOn(Context context) {
+        return Settings.System.getInt(context.getContentResolver(),
+                Settings.System.AIRPLANE_MODE_ON, 0) != 0;
+    }
+
+    private void setAirplaneModeOn(boolean enabling) {
+        
+        mCheckBoxPref.setEnabled(false);
+        mCheckBoxPref.setSummary(enabling ? R.string.airplane_mode_turning_on
+                : R.string.airplane_mode_turning_off);
+        
+        // Change the system setting
+        Settings.System.putInt(mContext.getContentResolver(), Settings.System.AIRPLANE_MODE_ON, 
+                                enabling ? 1 : 0);
+        
+        // Post the intent
+        Intent intent = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED);
+        intent.putExtra("state", enabling);
+        mContext.sendBroadcast(intent);
+    }
+
+    /**
+     * Called when we've received confirmation that the airplane mode was set.
+     */
+    private void onAirplaneModeChanged() {
+        ServiceState serviceState = mPhoneStateReceiver.getServiceState();
+        boolean airplaneModeEnabled = serviceState.getState() == ServiceState.STATE_POWER_OFF;
+        mCheckBoxPref.setChecked(airplaneModeEnabled);
+        mCheckBoxPref.setSummary(airplaneModeEnabled ? null : 
+                mContext.getString(R.string.airplane_mode_summary));            
+        mCheckBoxPref.setEnabled(true);
+    }
+    
+    /**
+     * Called when someone clicks on the checkbox preference.
+     */
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        setAirplaneModeOn((Boolean) newValue);
+        return true;
+    }
+
+}
diff --git a/src/com/android/settings/ApnEditor.java b/src/com/android/settings/ApnEditor.java
new file mode 100644
index 0000000..f1fa2ef
--- /dev/null
+++ b/src/com/android/settings/ApnEditor.java
@@ -0,0 +1,403 @@
+/*
+ * 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.settings;
+
+import android.app.AlertDialog;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.SystemProperties;
+import android.preference.EditTextPreference;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.provider.Telephony;
+import com.android.internal.telephony.TelephonyProperties;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuItem;
+
+
+public class ApnEditor extends PreferenceActivity 
+        implements SharedPreferences.OnSharedPreferenceChangeListener {
+    
+
+    private final static String TAG = ApnEditor.class.getSimpleName();
+    
+    private final static String SAVED_POS = "pos";
+    
+    private static final int MENU_DELETE = Menu.FIRST;
+    private static final int MENU_SAVE = Menu.FIRST + 1;
+    private static final int MENU_CANCEL = Menu.FIRST + 2;
+    
+    private static String sNotSet;
+    private EditTextPreference mName;
+    private EditTextPreference mApn;
+    private EditTextPreference mProxy;
+    private EditTextPreference mPort;
+    private EditTextPreference mUser;
+    private EditTextPreference mServer;
+    private EditTextPreference mPassword;
+    private EditTextPreference mMmsc;
+    private EditTextPreference mMcc;
+    private EditTextPreference mMnc;
+    private EditTextPreference mMmsProxy;
+    private EditTextPreference mMmsPort;
+    private EditTextPreference mApnType;
+    private String mCurMnc;
+    private String mCurMcc;
+    
+    private Uri mUri;
+    private Cursor mCursor;
+    private boolean mNewApn;
+    private boolean mFirstTime;
+    private Resources mRes;
+    
+    /**
+     * Standard projection for the interesting columns of a normal note.
+     */
+    private static final String[] sProjection = new String[] {
+            Telephony.Carriers._ID,     // 0
+            Telephony.Carriers.NAME,    // 1
+            Telephony.Carriers.APN,     // 2
+            Telephony.Carriers.PROXY,   // 3
+            Telephony.Carriers.PORT,    // 4
+            Telephony.Carriers.USER,    // 5
+            Telephony.Carriers.SERVER,  // 6
+            Telephony.Carriers.PASSWORD, // 7
+            Telephony.Carriers.MMSC, // 8
+            Telephony.Carriers.MCC, // 9
+            Telephony.Carriers.MNC, // 10
+            Telephony.Carriers.NUMERIC, // 11
+            Telephony.Carriers.MMSPROXY,// 12
+            Telephony.Carriers.MMSPORT, // 13
+            Telephony.Carriers.TYPE, // 14
+    };
+    
+    private static final int ID_INDEX = 0;
+    private static final int NAME_INDEX = 1;
+    private static final int APN_INDEX = 2;
+    private static final int PROXY_INDEX = 3;
+    private static final int PORT_INDEX = 4;
+    private static final int USER_INDEX = 5;
+    private static final int SERVER_INDEX = 6;
+    private static final int PASSWORD_INDEX = 7;
+    private static final int MMSC_INDEX = 8;
+    private static final int MCC_INDEX = 9;
+    private static final int MNC_INDEX = 10;
+    private static final int MMSPROXY_INDEX = 12;
+    private static final int MMSPORT_INDEX = 13;
+    private static final int TYPE_INDEX = 14;
+    
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        addPreferencesFromResource(R.xml.apn_editor);
+
+        sNotSet = getResources().getString(R.string.apn_not_set);
+        mName = (EditTextPreference) findPreference("apn_name");
+        mApn = (EditTextPreference) findPreference("apn_apn");
+        mProxy = (EditTextPreference) findPreference("apn_http_proxy");
+        mPort = (EditTextPreference) findPreference("apn_http_port");
+        mUser = (EditTextPreference) findPreference("apn_user");
+        mServer = (EditTextPreference) findPreference("apn_server");
+        mPassword = (EditTextPreference) findPreference("apn_password");
+        mMmsProxy = (EditTextPreference) findPreference("apn_mms_proxy");
+        mMmsPort = (EditTextPreference) findPreference("apn_mms_port");
+        mMmsc = (EditTextPreference) findPreference("apn_mmsc");
+        mMcc = (EditTextPreference) findPreference("apn_mcc");
+        mMnc = (EditTextPreference) findPreference("apn_mnc");
+        mApnType = (EditTextPreference) findPreference("apn_type");
+        
+        mRes = getResources();
+        
+        final Intent intent = getIntent();
+        final String action = intent.getAction();
+
+        mFirstTime = icicle == null;
+        
+        if (action.equals(Intent.ACTION_EDIT)) {
+            mUri = intent.getData();
+        } else if (action.equals(Intent.ACTION_INSERT)) {
+            if (mFirstTime) {
+                mUri = getContentResolver().insert(intent.getData(), new ContentValues());
+            } else {
+                mUri = ContentUris.withAppendedId(Telephony.Carriers.CONTENT_URI, 
+                        icicle.getInt(SAVED_POS));
+            }
+            mNewApn = true;
+            // If we were unable to create a new note, then just finish
+            // this activity.  A RESULT_CANCELED will be sent back to the
+            // original activity if they requested a result.
+            if (mUri == null) {
+                Log.w(TAG, "Failed to insert new telephony provider into "
+                        + getIntent().getData());
+                finish();
+                return;
+            }
+            
+            // The new entry was created, so assume all will end well and
+            // set the result to be returned.
+            setResult(RESULT_OK, (new Intent()).setAction(mUri.toString()));
+
+        } else {
+            finish();
+            return;
+        }
+
+        mCursor = managedQuery(mUri, sProjection, null, null);
+        mCursor.moveToFirst();
+        
+        fillUi();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
+    }
+    
+    @Override
+    public void onPause() {
+        getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this);
+        super.onPause();        
+    }
+    
+    private void fillUi() {
+        if (mFirstTime) {            
+            mFirstTime = false;
+            // Fill in all the values from the db in both text editor and summary
+            mName.setText(mCursor.getString(NAME_INDEX));
+            mApn.setText(mCursor.getString(APN_INDEX));
+            mProxy.setText(mCursor.getString(PROXY_INDEX));
+            mPort.setText(mCursor.getString(PORT_INDEX));
+            mUser.setText(mCursor.getString(USER_INDEX));
+            mServer.setText(mCursor.getString(SERVER_INDEX));
+            mPassword.setText(mCursor.getString(PASSWORD_INDEX));
+            mMmsProxy.setText(mCursor.getString(MMSPROXY_INDEX));
+            mMmsPort.setText(mCursor.getString(MMSPORT_INDEX));
+            mMmsc.setText(mCursor.getString(MMSC_INDEX));
+            mMcc.setText(mCursor.getString(MCC_INDEX));
+            mMnc.setText(mCursor.getString(MNC_INDEX));
+            mApnType.setText(mCursor.getString(TYPE_INDEX));
+            if (mNewApn) {
+                String numeric = 
+                    SystemProperties.get(TelephonyProperties.PROPERTY_SIM_OPERATOR_NUMERIC);
+                // MCC is first 3 chars and then in 2 - 3 chars of MNC
+                if (numeric != null && numeric.length() > 4) {
+                    // Country code
+                    String mcc = numeric.substring(0, 3);
+                    // Network code
+                    String mnc = numeric.substring(3);
+                    // Auto populate MNC and MCC for new entries, based on what SIM reports
+                    mMcc.setText(mcc);
+                    mMnc.setText(mnc);
+                    mCurMnc = mnc;
+                    mCurMcc = mcc;
+                }
+            }
+        }
+        
+        mName.setSummary(checkNull(mName.getText()));
+        mApn.setSummary(checkNull(mApn.getText()));
+        mProxy.setSummary(checkNull(mProxy.getText()));
+        mPort.setSummary(checkNull(mPort.getText()));
+        mUser.setSummary(checkNull(mUser.getText()));
+        mServer.setSummary(checkNull(mServer.getText()));
+        mPassword.setSummary(starify(mPassword.getText()));
+        mMmsProxy.setSummary(checkNull(mMmsProxy.getText()));
+        mMmsPort.setSummary(checkNull(mMmsPort.getText()));
+        mMmsc.setSummary(checkNull(mMmsc.getText()));
+        mMcc.setSummary(checkNull(mMcc.getText()));
+        mMnc.setSummary(checkNull(mMnc.getText()));
+        mApnType.setSummary(checkNull(mApnType.getText()));
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        super.onCreateOptionsMenu(menu);
+        // If it's a new APN, then cancel will delete the new entry in onPause
+        if (!mNewApn) {
+            menu.add(0, MENU_DELETE, 0, R.string.menu_delete)
+                .setIcon(android.R.drawable.ic_menu_delete);
+        }
+        menu.add(0, MENU_SAVE, 0, R.string.menu_save)
+            .setIcon(android.R.drawable.ic_menu_save);
+        menu.add(0, MENU_CANCEL, 0, R.string.menu_cancel)
+            .setIcon(android.R.drawable.ic_menu_close_clear_cancel);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+        case MENU_DELETE:
+            deleteApn();
+            return true;
+        case MENU_SAVE:
+            if (validateAndSave(false)) {
+                finish();
+            }
+            return true;
+        case MENU_CANCEL:
+            if (mNewApn) {
+                getContentResolver().delete(mUri, null, null);
+            }
+            finish();
+            return true;
+        }
+        return super.onOptionsItemSelected(item);
+    }
+    
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        switch (keyCode) {
+            case KeyEvent.KEYCODE_BACK: {
+                if (validateAndSave(false)) {
+                    finish();
+                }
+                return true;
+            }
+        }
+        return super.onKeyDown(keyCode, event);
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle icicle) {
+        super.onSaveInstanceState(icicle);
+        validateAndSave(true);
+        icicle.putInt(SAVED_POS, mCursor.getInt(ID_INDEX));
+    }
+    
+    /**
+     * Check the key fields' validity and save if valid.
+     * @param force save even if the fields are not valid, if the app is
+     *        being suspended
+     * @return true if the data was saved
+     */
+    private boolean validateAndSave(boolean force) {
+        String name = checkNotSet(mName.getText());
+        String apn = checkNotSet(mApn.getText());
+        String mcc = checkNotSet(mMcc.getText());
+        String mnc = checkNotSet(mMnc.getText());
+        
+        String errorMsg = null;
+        if (name.length() < 1) {
+            errorMsg = mRes.getString(R.string.error_name_empty);
+        } else if (apn.length() < 1) {
+            errorMsg = mRes.getString(R.string.error_apn_empty);
+        } else if (mcc.length() != 3) {
+            errorMsg = mRes.getString(R.string.error_mcc_not3);
+        } else if ((mnc.length() & 0xFFFE) != 2) {
+            errorMsg = mRes.getString(R.string.error_mnc_not23);
+        }
+        
+        if (errorMsg != null && !force) {
+            showErrorMessage(errorMsg);
+            return false;
+        }
+        
+        if (!mCursor.moveToFirst()) {
+            Log.w(TAG,
+                    "Could not go to the first row in the Cursor when saving data.");
+            return false;
+        }
+        
+        ContentValues values = new ContentValues();
+        
+        values.put(Telephony.Carriers.NAME, name);
+        values.put(Telephony.Carriers.APN, apn);
+        values.put(Telephony.Carriers.PROXY, checkNotSet(mProxy.getText()));
+        values.put(Telephony.Carriers.PORT, checkNotSet(mPort.getText()));
+        values.put(Telephony.Carriers.MMSPROXY, checkNotSet(mMmsProxy.getText()));
+        values.put(Telephony.Carriers.MMSPORT, checkNotSet(mMmsPort.getText()));
+        values.put(Telephony.Carriers.USER, checkNotSet(mUser.getText()));
+        values.put(Telephony.Carriers.SERVER, checkNotSet(mServer.getText()));
+        values.put(Telephony.Carriers.PASSWORD, checkNotSet(mPassword.getText()));
+        values.put(Telephony.Carriers.MMSC, checkNotSet(mMmsc.getText()));            
+        values.put(Telephony.Carriers.TYPE, checkNotSet(mApnType.getText()));
+
+        values.put(Telephony.Carriers.MCC, mcc);
+        values.put(Telephony.Carriers.MNC, mnc);
+        
+        values.put(Telephony.Carriers.NUMERIC, mcc + mnc);
+        
+        if (mCurMnc != null && mCurMcc != null) {
+            if (mCurMnc.equals(mnc) && mCurMcc.equals(mcc)) {
+                values.put(Telephony.Carriers.CURRENT, 1);
+            }
+        }
+        
+        getContentResolver().update(mUri, values, null, null);
+        
+        return true;
+    }
+
+    private void showErrorMessage(String message) {
+        new AlertDialog.Builder(this)
+            .setTitle(R.string.error_title)
+            .setMessage(message)
+            .setPositiveButton(android.R.string.ok, null)
+            .show();
+    }
+
+    private void deleteApn() {
+        getContentResolver().delete(mUri, null, null);
+        finish();
+    }
+    
+    private String starify(String value) {
+        if (value == null || value.length() == 0) {
+            return sNotSet;
+        } else {
+            char[] password = new char[value.length()];
+            for (int i = 0; i < password.length; i++) {
+                password[i] = '*';
+            }
+            return new String(password);
+        }
+    }
+    
+    private String checkNull(String value) {
+        if (value == null || value.length() == 0) {
+            return sNotSet;
+        } else {
+            return value;
+        }
+    }
+    
+    private String checkNotSet(String value) {
+        if (value == null || value.equals(sNotSet)) {
+            return "";
+        } else {
+            return value;
+        }
+    }
+    
+    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+        Preference pref = findPreference(key);
+        if (pref != null) {
+            pref.setSummary(checkNull(sharedPreferences.getString(key, "")));
+        }
+    }
+}
diff --git a/src/com/android/settings/ApnSettings.java b/src/com/android/settings/ApnSettings.java
new file mode 100644
index 0000000..87e3412
--- /dev/null
+++ b/src/com/android/settings/ApnSettings.java
@@ -0,0 +1,229 @@
+/*
+ * 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.settings;
+
+import android.app.Dialog;
+import android.app.ProgressDialog;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.Intent;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Message;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceGroup;
+import android.preference.PreferenceScreen;
+import android.provider.Telephony;
+import android.text.TextUtils;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.widget.Toast;
+
+public class ApnSettings extends PreferenceActivity {
+
+    public static final String EXTRA_POSITION = "position";
+    public static final String RESTORE_CARRIERS_URI =
+        "content://telephony/carriers/restore";
+
+    private static final int ID_INDEX = 0;
+    private static final int NAME_INDEX = 1;
+    private static final int APN_INDEX = 2;
+
+    private static final int MENU_NEW = Menu.FIRST;
+    private static final int MENU_RESTORE = Menu.FIRST + 1;
+
+    private static final int EVENT_RESTORE_DEFAULTAPN_START = 1;
+    private static final int EVENT_RESTORE_DEFAULTAPN_COMPLETE = 2;
+
+    private static final int DIALOG_RESTORE_DEFAULTAPN = 1001;
+
+    private static final Uri DEFAULTAPN_URI = Uri.parse(RESTORE_CARRIERS_URI);
+
+    private static boolean mRestoreDefaultApnMode;
+
+    private RestoreApnUiHandler mRestoreApnUiHandler;
+    private RestoreApnProcessHandler mRestoreApnProcessHandler;
+
+    private Cursor mCursor;
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        addPreferencesFromResource(R.xml.apn_settings);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        if (!mRestoreDefaultApnMode) {
+            fillList();
+        } else {
+            showDialog(DIALOG_RESTORE_DEFAULTAPN);
+        }
+    }
+
+    private void fillList() {
+        mCursor = managedQuery(Telephony.Carriers.CONTENT_URI, new String[] {
+                "_id", "name", "apn"}, null, Telephony.Carriers.DEFAULT_SORT_ORDER);
+
+        PreferenceGroup apnList = (PreferenceGroup) findPreference("apn_list");
+        apnList.removeAll();
+
+        mCursor.moveToFirst();
+        while (!mCursor.isAfterLast()) {
+            String name = mCursor.getString(NAME_INDEX);
+            String apn = mCursor.getString(APN_INDEX);
+
+            if (name != null && apn != null && TextUtils.getTrimmedLength(name) > 0
+                    && TextUtils.getTrimmedLength(apn) > 0) {
+                Preference pref = new Preference((Context) this);
+                pref.setKey(mCursor.getString(ID_INDEX));
+                pref.setTitle(name);
+                pref.setSummary(apn);
+                pref.setPersistent(false);
+                apnList.addPreference(pref);
+            }
+
+            mCursor.moveToNext();
+        }
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        super.onCreateOptionsMenu(menu);
+        menu.add(0, MENU_NEW, 0,
+                getResources().getString(R.string.menu_new))
+                .setIcon(android.R.drawable.ic_menu_add);
+        menu.add(0, MENU_RESTORE, 0,
+                getResources().getString(R.string.menu_restore))
+                .setIcon(android.R.drawable.ic_menu_upload);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+        case MENU_NEW:
+            addNewApn();
+            return true;
+
+        case MENU_RESTORE:
+            restoreDefaultApn();
+            return true;
+        }
+        return super.onOptionsItemSelected(item);
+    }
+
+    private void addNewApn() {
+        startActivity(new Intent(Intent.ACTION_INSERT, Telephony.Carriers.CONTENT_URI));
+    }
+
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
+        int pos = Integer.parseInt(preference.getKey());
+        Uri url = ContentUris.withAppendedId(Telephony.Carriers.CONTENT_URI, pos);
+        startActivity(new Intent(Intent.ACTION_EDIT, url));
+        return true;
+    }
+
+    private boolean restoreDefaultApn() {
+        showDialog(DIALOG_RESTORE_DEFAULTAPN);
+        mRestoreDefaultApnMode = true;
+
+        if (mRestoreApnUiHandler == null) {
+            mRestoreApnUiHandler = new RestoreApnUiHandler();
+        }
+
+        if (mRestoreApnProcessHandler == null) {
+            HandlerThread restoreDefaultApnThread = new HandlerThread(
+                    "Restore default APN Handler: Process Thread");
+            restoreDefaultApnThread.start();
+            mRestoreApnProcessHandler = new RestoreApnProcessHandler(
+                    restoreDefaultApnThread.getLooper(), mRestoreApnUiHandler);
+        }
+
+        mRestoreApnProcessHandler
+                .sendEmptyMessage(EVENT_RESTORE_DEFAULTAPN_START);
+        return true;
+    }
+
+    private class RestoreApnUiHandler extends Handler {
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case EVENT_RESTORE_DEFAULTAPN_COMPLETE:
+                    fillList();
+                    getPreferenceScreen().setEnabled(true);
+                    mRestoreDefaultApnMode = false;
+                    dismissDialog(DIALOG_RESTORE_DEFAULTAPN);
+                    Toast.makeText(
+                        ApnSettings.this,
+                        getResources().getString(
+                                R.string.restore_default_apn_completed),
+                        Toast.LENGTH_LONG).show();
+                    break;
+            }
+        }
+    }
+
+    private class RestoreApnProcessHandler extends Handler {
+        private Handler mRestoreApnUiHandler;
+
+        public RestoreApnProcessHandler(Looper looper, Handler restoreApnUiHandler) {
+            super(looper);
+            this.mRestoreApnUiHandler = restoreApnUiHandler;
+        }
+
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case EVENT_RESTORE_DEFAULTAPN_START:
+                    ContentResolver resolver = getContentResolver();
+                    resolver.delete(DEFAULTAPN_URI, null, null);                    
+                    mRestoreApnUiHandler
+                        .sendEmptyMessage(EVENT_RESTORE_DEFAULTAPN_COMPLETE);
+                    break;
+            }
+        }
+    }
+
+    @Override
+    protected Dialog onCreateDialog(int id) {
+        if (id == DIALOG_RESTORE_DEFAULTAPN) {
+            ProgressDialog dialog = new ProgressDialog(this);
+            dialog.setMessage(getResources().getString(R.string.restore_default_apn));
+            dialog.setCancelable(false);
+            return dialog;
+        }
+        return null;
+    }
+
+    @Override
+    protected void onPrepareDialog(int id, Dialog dialog) {
+        if (id == DIALOG_RESTORE_DEFAULTAPN) {
+            getPreferenceScreen().setEnabled(false);
+        }
+    }
+}
diff --git a/src/com/android/settings/ApplicationSettings.java b/src/com/android/settings/ApplicationSettings.java
new file mode 100644
index 0000000..85fe11f
--- /dev/null
+++ b/src/com/android/settings/ApplicationSettings.java
@@ -0,0 +1,98 @@
+/*
+ * 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.settings;
+
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceScreen;
+import android.provider.Settings;
+
+public class ApplicationSettings extends PreferenceActivity implements
+        DialogInterface.OnClickListener {
+    
+    private static final String KEY_TOGGLE_INSTALL_APPLICATIONS = "toggle_install_applications";
+    private static final String KEY_QUICK_LAUNCH = "quick_launch";
+
+    private CheckBoxPreference mToggleAppInstallation;
+    
+    private DialogInterface mWarnInstallApps;
+    
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        addPreferencesFromResource(R.xml.application_settings);
+
+        mToggleAppInstallation = (CheckBoxPreference) findPreference(KEY_TOGGLE_INSTALL_APPLICATIONS);
+        mToggleAppInstallation.setChecked(isNonMarketAppsAllowed());
+
+        if (getResources().getConfiguration().keyboard == Configuration.KEYBOARD_NOKEYS) {
+            // No hard keyboard, remove the setting for quick launch
+            Preference quickLaunchSetting = findPreference(KEY_QUICK_LAUNCH);
+            getPreferenceScreen().removePreference(quickLaunchSetting);
+        }
+    }
+
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
+        if (preference == mToggleAppInstallation) {
+            if (mToggleAppInstallation.isChecked()) {
+                mToggleAppInstallation.setChecked(false);
+                warnAppInstallation();
+            } else {
+                setNonMarketAppsAllowed(false);
+            }
+        }
+        
+        return super.onPreferenceTreeClick(preferenceScreen, preference);
+    }
+
+    public void onClick(DialogInterface dialog, int which) {
+        if (dialog == mWarnInstallApps && which == DialogInterface.BUTTON1) {
+            setNonMarketAppsAllowed(true);
+            mToggleAppInstallation.setChecked(true);
+        }
+    }
+
+    private void setNonMarketAppsAllowed(boolean enabled) {
+        // Change the system setting
+        Settings.Secure.putInt(getContentResolver(), Settings.Secure.INSTALL_NON_MARKET_APPS, 
+                                enabled ? 1 : 0);
+    }
+    
+    private boolean isNonMarketAppsAllowed() {
+        return Settings.Secure.getInt(getContentResolver(), 
+                                      Settings.Secure.INSTALL_NON_MARKET_APPS, 0) > 0;
+    }
+
+    private void warnAppInstallation() {
+        mWarnInstallApps = new AlertDialog.Builder(this)
+                .setTitle(getString(R.string.error_title))
+                .setIcon(com.android.internal.R.drawable.ic_dialog_alert)
+                .setMessage(getResources().getString(R.string.install_all_warning))
+                .setPositiveButton(android.R.string.yes, this)
+                .setNegativeButton(android.R.string.no, null)
+                .show();
+    }
+    
+    
+}
diff --git a/src/com/android/settings/BandMode.java b/src/com/android/settings/BandMode.java
new file mode 100644
index 0000000..1297cad
--- /dev/null
+++ b/src/com/android/settings/BandMode.java
@@ -0,0 +1,217 @@
+package com.android.settings;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import com.android.internal.telephony.Phone;
+import com.android.internal.telephony.PhoneFactory;
+import android.os.Bundle;
+import android.os.Message;
+import android.os.Handler;
+import android.os.AsyncResult;
+import android.util.Log;
+import android.content.DialogInterface;
+import android.view.View;
+import android.view.WindowManager;
+import android.view.Window;
+import android.widget.ListView;
+import android.widget.ArrayAdapter;
+import android.widget.AdapterView;
+
+
+/**
+ * Radio Band Mode Selection Class
+ *
+ * It will query baseband about all available band modes and display them
+ * in screen. It will display all six band modes if the query failed.
+ *
+ * After user select one band, it will send the selection to baseband.
+ *
+ * It will alter user the result of select operation and exit, no matter success
+ * or not.
+ *
+ */
+public class BandMode extends Activity {
+    private static final String LOG_TAG = "phone";
+    private static final boolean DBG = false;
+
+    private static final int EVENT_BAND_SCAN_COMPLETED = 100;
+    private static final int EVENT_BAND_SELECTION_DONE = 200;
+
+    private static final String[] BAND_NAMES = new String[] {
+            "Automatic",
+            "EURO Band",
+            "USA Band",
+            "JAPAN Band",
+            "AUS Band",
+            "AUS2 Band"
+    };
+
+    private ListView mBandList;
+    private ArrayAdapter mBandListAdapter;
+    private BandListItem mTargetBand = null;
+    private DialogInterface mProgressPanel;
+
+    private Phone mPhone = null;
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
+        
+        setContentView(R.layout.band_mode);
+
+        setTitle(getString(R.string.band_mode_title));
+        getWindow().setLayout(WindowManager.LayoutParams.FILL_PARENT,
+                                    WindowManager.LayoutParams.WRAP_CONTENT);
+
+        mPhone = PhoneFactory.getDefaultPhone();
+
+        mBandList = (ListView) findViewById(R.id.band);
+        mBandListAdapter = new ArrayAdapter<BandListItem>(this,
+                android.R.layout.simple_list_item_1);
+        mBandList.setAdapter(mBandListAdapter);
+        mBandList.setOnItemClickListener(mBandSelectionHandler);
+
+
+
+        loadBandList();
+    }
+
+    private AdapterView.OnItemClickListener mBandSelectionHandler =
+            new AdapterView.OnItemClickListener () {
+                public void onItemClick(AdapterView parent, View v,
+                        int position, long id) {
+
+                    getWindow().setFeatureInt(
+                            Window.FEATURE_INDETERMINATE_PROGRESS,
+                            Window.PROGRESS_VISIBILITY_ON);
+
+                    mTargetBand = (BandListItem) parent.getAdapter().getItem(position);
+
+                    if (DBG) log("Select band : " + mTargetBand.toString());
+
+                    Message msg =
+                            mHandler.obtainMessage(EVENT_BAND_SELECTION_DONE);
+                    mPhone.setBandMode(mTargetBand.getBand(), msg);
+                }
+            };
+
+    private class BandListItem {
+        private int mBandMode = Phone.BM_UNSPECIFIED;
+
+        public BandListItem(int bm) {
+            mBandMode = bm;
+        }
+
+        public int getBand() {
+            return mBandMode;
+        }
+
+        public String toString() {
+            return BAND_NAMES[mBandMode];
+        }
+    }
+
+    private void loadBandList() {
+        String str = getString(R.string.band_mode_loading);
+
+        if (DBG) log(str);
+
+
+        //ProgressDialog.show(this, null, str, true, true, null);
+        mProgressPanel = new AlertDialog.Builder(this)
+            .setMessage(str)
+            .show();
+
+        Message msg = mHandler.obtainMessage(EVENT_BAND_SCAN_COMPLETED);
+        mPhone.queryAvailableBandMode(msg);
+
+    }
+
+    private void bandListLoaded(AsyncResult result) {
+        if (DBG) log("network list loaded");
+
+        if (mProgressPanel != null) mProgressPanel.dismiss();
+
+        clearList();
+
+        boolean addBandSuccess = false;
+        BandListItem item;
+
+        if (result.result != null) {
+            int bands[] = (int[])result.result;
+            int size = bands[0];
+
+            if (size > 0) {
+                for (int i=1; i<size; i++) {
+                    item = new BandListItem(bands[i]);
+                    mBandListAdapter.add(item);
+                    if (DBG) log("Add " + item.toString());
+                }
+                addBandSuccess = true;
+            }
+        }
+
+        if (addBandSuccess == false) {
+            if (DBG) log("Error in query, add default list");
+            for (int i=0; i<Phone.BM_BOUNDARY; i++) {
+                item = new BandListItem(i);
+                mBandListAdapter.add(item);
+                if (DBG) log("Add default " + item.toString());
+            }
+        }
+        mBandList.requestFocus();
+    }
+
+    private void displayBandSelectionResult(Throwable ex) {
+        String status = getString(R.string.band_mode_set)
+                +" [" + mTargetBand.toString() + "] ";
+
+        if (ex != null) {
+            status = status + getString(R.string.band_mode_failed);
+        } else {
+            status = status + getString(R.string.band_mode_succeeded);
+        }
+
+        mProgressPanel = new AlertDialog.Builder(this)
+            .setMessage(status)
+            .setPositiveButton(android.R.string.ok, null).show();
+    }
+
+    private void clearList() {
+        while(mBandListAdapter.getCount() > 0) {
+            mBandListAdapter.remove(
+                    mBandListAdapter.getItem(0));
+        }
+    }
+
+    private void log(String msg) {
+        Log.d(LOG_TAG, "[BandsList] " + msg);
+    }
+
+    private Handler mHandler = new Handler() {
+        public void handleMessage(Message msg) {
+            AsyncResult ar;
+            switch (msg.what) {
+                case EVENT_BAND_SCAN_COMPLETED:
+                    ar = (AsyncResult) msg.obj;
+
+                    bandListLoaded(ar);
+                    break;
+
+                case EVENT_BAND_SELECTION_DONE:
+                    ar = (AsyncResult) msg.obj;
+
+                    getWindow().setFeatureInt(
+                            Window.FEATURE_INDETERMINATE_PROGRESS,
+                            Window.PROGRESS_VISIBILITY_OFF);
+
+                    displayBandSelectionResult(ar.exception);
+                    break;
+            }
+        }
+    };
+
+
+}
diff --git a/src/com/android/settings/BatteryInfo.java b/src/com/android/settings/BatteryInfo.java
new file mode 100644
index 0000000..f9962fa
--- /dev/null
+++ b/src/com/android/settings/BatteryInfo.java
@@ -0,0 +1,208 @@
+/*
+ * 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.settings;
+
+import android.app.Activity;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.BatteryManager;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IPowerManager;
+import android.os.Message;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.os.SystemClock;
+import android.text.format.DateUtils;
+import android.widget.TextView;
+
+import com.android.internal.app.IBatteryStats;
+
+public class BatteryInfo extends Activity {
+    private TextView mStatus;
+    private TextView mLevel;
+    private TextView mScale;
+    private TextView mHealth;
+    private TextView mVoltage;
+    private TextView mTemperature;
+    private TextView mTechnology;
+    private TextView mUptime;
+    private TextView mAwakeBattery;
+    private TextView mAwakePlugged;
+    private TextView mScreenOn;
+    private IBatteryStats mBatteryStats;
+    private IPowerManager mScreenStats;
+    
+    private static final int EVENT_TICK = 1;
+    
+    private Handler mHandler = new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case EVENT_TICK:
+                    updateBatteryStats();
+                    sendEmptyMessageDelayed(EVENT_TICK, 1000);
+                    break;
+            }
+        }
+    };
+
+    /**
+     * Format a number of tenths-units as a decimal string without using a
+     * conversion to float.  E.g. 347 -> "34.7"
+     */
+    private final String tenthsToFixedString(int x) {
+        int tens = x / 10;
+        return new String("" + tens + "." + (x - 10*tens));
+    }
+
+   /**
+    *Listens for intent broadcasts
+    */
+    private IntentFilter   mIntentFilter;
+
+    private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {
+                int plugType = intent.getIntExtra("plugged", 0);
+
+                mLevel.setText("" + intent.getIntExtra("level", 0));
+                mScale.setText("" + intent.getIntExtra("scale", 0));
+                mVoltage.setText("" + intent.getIntExtra("voltage", 0) + " "
+                        + getString(R.string.battery_info_voltage_units));
+                mTemperature.setText("" + tenthsToFixedString(intent.getIntExtra("temperature", 0))
+                        + getString(R.string.battery_info_temperature_units));
+                mTechnology.setText("" + intent.getStringExtra("technology"));
+                
+                int status = intent.getIntExtra("status", BatteryManager.BATTERY_STATUS_UNKNOWN);
+                String statusString;
+                if (status == BatteryManager.BATTERY_STATUS_CHARGING) {
+                    statusString = getString(R.string.battery_info_status_charging);
+                    if (plugType > 0) {
+                        statusString = statusString + " " + getString(
+                                (plugType == BatteryManager.BATTERY_PLUGGED_AC)
+                                        ? R.string.battery_info_status_charging_ac
+                                        : R.string.battery_info_status_charging_usb);
+                    }
+                } else if (status == BatteryManager.BATTERY_STATUS_DISCHARGING) {
+                    statusString = getString(R.string.battery_info_status_discharging);
+                } else if (status == BatteryManager.BATTERY_STATUS_NOT_CHARGING) {
+                    statusString = getString(R.string.battery_info_status_not_charging);
+                } else if (status == BatteryManager.BATTERY_STATUS_FULL) {
+                    statusString = getString(R.string.battery_info_status_full);
+                } else {
+                    statusString = getString(R.string.battery_info_status_unknown);
+                }
+                mStatus.setText(statusString);
+
+                int health = intent.getIntExtra("health", BatteryManager.BATTERY_HEALTH_UNKNOWN);
+                String healthString;
+                if (health == BatteryManager.BATTERY_HEALTH_GOOD) {
+                    healthString = getString(R.string.battery_info_health_good);
+                } else if (health == BatteryManager.BATTERY_HEALTH_OVERHEAT) {
+                    healthString = getString(R.string.battery_info_health_overheat);
+                } else if (health == BatteryManager.BATTERY_HEALTH_DEAD) {
+                    healthString = getString(R.string.battery_info_health_dead);
+                } else if (health == BatteryManager.BATTERY_HEALTH_OVER_VOLTAGE) {
+                    healthString = getString(R.string.battery_info_health_over_voltage);
+                } else if (health == BatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE) {
+                    healthString = getString(R.string.battery_info_health_unspecified_failure);
+                } else {
+                    healthString = getString(R.string.battery_info_health_unknown);
+                }
+                mHealth.setText(healthString);
+            }
+        }
+    };
+
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        setContentView(R.layout.battery_info);
+
+        // create the IntentFilter that will be used to listen
+        // to battery status broadcasts
+        mIntentFilter = new IntentFilter();
+        mIntentFilter.addAction(Intent.ACTION_BATTERY_CHANGED);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+
+        mStatus = (TextView)findViewById(R.id.status);
+        mLevel = (TextView)findViewById(R.id.level);
+        mScale = (TextView)findViewById(R.id.scale);
+        mHealth = (TextView)findViewById(R.id.health);
+        mTechnology = (TextView)findViewById(R.id.technology);
+        mVoltage = (TextView)findViewById(R.id.voltage);
+        mTemperature = (TextView)findViewById(R.id.temperature);
+        mUptime = (TextView) findViewById(R.id.uptime);
+        mAwakeBattery = (TextView) findViewById(R.id.awakeBattery);
+        mAwakePlugged = (TextView) findViewById(R.id.awakePlugged);
+        mScreenOn = (TextView) findViewById(R.id.screenOn);
+        
+        // Get awake time plugged in and on battery
+        mBatteryStats = IBatteryStats.Stub.asInterface(ServiceManager.getService("batteryinfo"));
+        mScreenStats = IPowerManager.Stub.asInterface(ServiceManager.getService(POWER_SERVICE));
+        mHandler.sendEmptyMessageDelayed(EVENT_TICK, 1000);
+        
+        registerReceiver(mIntentReceiver, mIntentFilter);
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        mHandler.removeMessages(EVENT_TICK);
+        
+        // we are no longer on the screen stop the observers
+        unregisterReceiver(mIntentReceiver);
+    }
+
+    private void updateBatteryStats() {
+        long uptime = SystemClock.elapsedRealtime();
+        mUptime.setText(DateUtils.formatElapsedTime(uptime / 1000));
+        
+        if (mBatteryStats != null) {
+            try {
+                long awakeTimeBattery = mBatteryStats.getAwakeTimeBattery() / 1000;
+                long awakeTimePluggedIn = mBatteryStats.getAwakeTimePlugged() / 1000;
+                mAwakeBattery.setText(DateUtils.formatElapsedTime(awakeTimeBattery / 1000) 
+                        + " (" + (100 * awakeTimeBattery / uptime) + "%)");
+                mAwakePlugged.setText(DateUtils.formatElapsedTime(awakeTimePluggedIn / 1000)
+                        + " (" + (100 * awakeTimePluggedIn / uptime) + "%)");
+            } catch (RemoteException re) {
+                mAwakeBattery.setText("Unknown");
+                mAwakePlugged.setText("Unknown");            
+            }
+        }
+        if (mScreenStats != null) {
+            try {
+                long screenOnTime = mScreenStats.getScreenOnTime();
+                mScreenOn.setText(DateUtils.formatElapsedTime(screenOnTime / 1000));
+            } catch (RemoteException re) {
+                mScreenOn.setText("Unknown");
+            }
+        }
+    }
+    
+}
diff --git a/src/com/android/settings/BrightnessPreference.java b/src/com/android/settings/BrightnessPreference.java
new file mode 100644
index 0000000..a9851cc
--- /dev/null
+++ b/src/com/android/settings/BrightnessPreference.java
@@ -0,0 +1,103 @@
+/*
+ * 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.settings;
+
+import android.content.Context;
+import android.os.RemoteException;
+import android.os.IHardwareService;
+import android.os.ServiceManager;
+import android.preference.SeekBarPreference;
+import android.provider.Settings;
+import android.provider.Settings.SettingNotFoundException;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.View;
+import android.widget.SeekBar;
+
+import java.util.Map;
+
+public class BrightnessPreference extends SeekBarPreference implements
+        SeekBar.OnSeekBarChangeListener {
+
+    private SeekBar mSeekBar;
+    
+    private int mOldBrightness;
+    
+    // Backlight range is from 0 - 255. Need to make sure that user
+    // doesn't set the backlight to 0 and get stuck
+    private static final int MINIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_DIM + 10;
+    private static final int MAXIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_ON;
+
+    public BrightnessPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @Override
+    protected void onBindDialogView(View view) {
+        super.onBindDialogView(view);
+
+        mSeekBar = getSeekBar(view);
+        mSeekBar.setOnSeekBarChangeListener(this);
+        mSeekBar.setMax(MAXIMUM_BACKLIGHT - MINIMUM_BACKLIGHT);
+        try {
+            mOldBrightness = Settings.System.getInt(getContext().getContentResolver(), 
+                Settings.System.SCREEN_BRIGHTNESS);
+        } catch (SettingNotFoundException snfe) {
+            mOldBrightness = MAXIMUM_BACKLIGHT;
+        }
+        mSeekBar.setProgress(mOldBrightness - MINIMUM_BACKLIGHT);
+    }
+
+    public void onProgressChanged(SeekBar seekBar, int progress,
+            boolean fromTouch) {
+        setBrightness(progress + MINIMUM_BACKLIGHT);
+    }
+
+    public void onStartTrackingTouch(SeekBar seekBar) {
+        // NA
+    }
+
+    public void onStopTrackingTouch(SeekBar seekBar) {
+        // NA
+    }
+
+    @Override
+    protected void onDialogClosed(boolean positiveResult) {
+        super.onDialogClosed(positiveResult);
+        
+        if (positiveResult) {
+            Settings.System.putInt(getContext().getContentResolver(), 
+                    Settings.System.SCREEN_BRIGHTNESS,
+                    mSeekBar.getProgress() + MINIMUM_BACKLIGHT);
+        } else {
+            setBrightness(mOldBrightness);
+        }
+    }
+    
+    private void setBrightness(int brightness) {
+        try {
+            IHardwareService hardware = IHardwareService.Stub.asInterface(
+                    ServiceManager.getService("hardware"));
+            if (hardware != null) {
+                hardware.setScreenBacklight(brightness);
+            }
+        } catch (RemoteException doe) {
+            
+        }        
+    }
+}
+
diff --git a/src/com/android/settings/ChooseLockPattern.java b/src/com/android/settings/ChooseLockPattern.java
new file mode 100644
index 0000000..47fc07f
--- /dev/null
+++ b/src/com/android/settings/ChooseLockPattern.java
@@ -0,0 +1,497 @@
+/*
+ * Copyright (C) 2007 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.settings;
+
+import com.google.android.collect.Lists;
+
+import com.android.internal.widget.LinearLayoutWithDefaultTouchRecepient;
+import com.android.internal.widget.LockPatternUtils;
+import com.android.internal.widget.LockPatternView;
+import static com.android.internal.widget.LockPatternView.DisplayMode;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.Window;
+import android.widget.TextView;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * If the user has a lock pattern set already, makes them confirm the existing one.
+ *
+ * Then, prompts the user to choose a lock pattern:
+ * - prompts for initial pattern
+ * - asks for confirmation / restart
+ * - saves chosen password when confirmed
+ */
+public class ChooseLockPattern extends Activity implements View.OnClickListener{
+
+    /**
+     * Used by the choose lock pattern wizard to indicate the wizard is
+     * finished, and each activity in the wizard should finish.
+     * <p>
+     * Previously, each activity in the wizard would finish itself after
+     * starting the next activity. However, this leads to broken 'Back'
+     * behavior. So, now an activity does not finish itself until it gets this
+     * result.
+     */
+    static final int RESULT_FINISHED = RESULT_FIRST_USER;
+    
+    // how long after a confirmation message is shown before moving on
+    static final int INFORMATION_MSG_TIMEOUT_MS = 3000;
+
+    // how long we wait to clear a wrong pattern
+    private static final int WRONG_PATTERN_CLEAR_TIMEOUT_MS = 2000;
+
+    private static final int ID_EMPTY_MESSAGE = -1;
+
+
+    protected TextView mHeaderText;
+    protected LockPatternView mLockPatternView;
+    protected TextView mFooterText;
+    private TextView mFooterLeftButton;
+    private TextView mFooterRightButton;
+
+    protected List<LockPatternView.Cell> mChosenPattern = null;
+
+    protected LockPatternUtils mLockPatternUtils;
+
+    /**
+     * The patten used during the help screen to show how to draw a pattern.
+     */
+    private final List<LockPatternView.Cell> mAnimatePattern =
+            Collections.unmodifiableList(
+                Lists.newArrayList(
+                        LockPatternView.Cell.of(0, 0),
+                        LockPatternView.Cell.of(0, 1),
+                        LockPatternView.Cell.of(1, 1),
+                        LockPatternView.Cell.of(2, 1)
+                    ));
+
+
+    /**
+     * The pattern listener that responds according to a user choosing a new
+     * lock pattern.
+     */
+    protected LockPatternView.OnPatternListener mChooseNewLockPatternListener = new LockPatternView.OnPatternListener() {
+
+            public void onPatternStart() {
+                mLockPatternView.removeCallbacks(mClearPatternRunnable);
+                patternInProgress();
+            }
+
+            public void onPatternCleared() {
+                mLockPatternView.removeCallbacks(mClearPatternRunnable);
+            }
+
+            public void onPatternDetected(List<LockPatternView.Cell> pattern) {
+                if (mUiStage == Stage.NeedToConfirm || mUiStage == Stage.ConfirmWrong) {
+                    if (mChosenPattern == null) throw new IllegalStateException("null chosen pattern in stage 'need to confirm");
+                    if (mChosenPattern.equals(pattern)) {
+                        updateStage(Stage.ChoiceConfirmed);
+                    } else {
+                        updateStage(Stage.ConfirmWrong);
+                    }
+                } else if (mUiStage == Stage.Introduction || mUiStage == Stage.ChoiceTooShort){
+                    if (pattern.size() < LockPatternUtils.MIN_LOCK_PATTERN_SIZE) {
+                        updateStage(Stage.ChoiceTooShort);
+                    } else {
+                        mChosenPattern = new ArrayList<LockPatternView.Cell>(pattern);
+                        updateStage(Stage.FirstChoiceValid);
+                    }
+                } else {
+                    throw new IllegalStateException("Unexpected stage " + mUiStage + " when "
+                            + "entering the pattern.");
+                }
+            }
+
+            private void patternInProgress() {
+                mHeaderText.setText(R.string.lockpattern_recording_inprogress);
+                mFooterText.setText("");
+                mFooterLeftButton.setEnabled(false);
+                mFooterRightButton.setEnabled(false);
+            }
+     };
+
+
+    /**
+     * The states of the left footer button.
+     */
+    enum LeftButtonMode {
+        Cancel(R.string.cancel, true),
+        CancelDisabled(R.string.cancel, false),
+        Retry(R.string.lockpattern_retry_button_text, true),
+        RetryDisabled(R.string.lockpattern_retry_button_text, false),
+        Gone(ID_EMPTY_MESSAGE, false);
+
+
+        /**
+         * @param text The displayed text for this mode.
+         * @param enabled Whether the button should be enabled.
+         */
+        LeftButtonMode(int text, boolean enabled) {
+            this.text = text;
+            this.enabled = enabled;
+        }
+
+        final int text;
+        final boolean enabled;
+    }
+
+    /**
+     * The states of the right button.
+     */
+    enum RightButtonMode {
+        Continue(R.string.lockpattern_continue_button_text, true),
+        ContinueDisabled(R.string.lockpattern_continue_button_text, false),
+        Confirm(R.string.lockpattern_confirm_button_text, true),
+        ConfirmDisabled(R.string.lockpattern_confirm_button_text, false),
+        Ok(android.R.string.ok, true);
+
+        /**
+         * @param text The displayed text for this mode.
+         * @param enabled Whether the button should be enabled.
+         */
+        RightButtonMode(int text, boolean enabled) {
+            this.text = text;
+            this.enabled = enabled;
+        }
+
+        final int text;
+        final boolean enabled;
+    }
+
+    /**
+     * Keep track internally of where the user is in choosing a pattern.
+     */
+    protected enum Stage {
+
+        Introduction(
+                R.string.lockpattern_recording_intro_header,
+                LeftButtonMode.Cancel, RightButtonMode.ContinueDisabled,
+                R.string.lockpattern_recording_intro_footer, true),
+        HelpScreen(
+                R.string.lockpattern_settings_help_how_to_record,
+                LeftButtonMode.Gone, RightButtonMode.Ok, ID_EMPTY_MESSAGE, false),
+        ChoiceTooShort(
+                R.string.lockpattern_recording_incorrect_too_short,
+                LeftButtonMode.Retry, RightButtonMode.ContinueDisabled,
+                ID_EMPTY_MESSAGE, true),
+        FirstChoiceValid(
+                R.string.lockpattern_pattern_entered_header,
+                LeftButtonMode.Retry, RightButtonMode.Continue, ID_EMPTY_MESSAGE, false),
+        NeedToConfirm(
+                R.string.lockpattern_need_to_confirm,
+                LeftButtonMode.CancelDisabled, RightButtonMode.ConfirmDisabled,
+                ID_EMPTY_MESSAGE, true),
+        ConfirmWrong(
+                R.string.lockpattern_need_to_unlock_wrong,
+                LeftButtonMode.Cancel, RightButtonMode.ConfirmDisabled,
+                ID_EMPTY_MESSAGE, true),
+        ChoiceConfirmed(
+                R.string.lockpattern_pattern_confirmed_header,
+                LeftButtonMode.Cancel, RightButtonMode.Confirm, ID_EMPTY_MESSAGE, false);
+
+
+        /**
+         * @param headerMessage The message displayed at the top.
+         * @param leftMode The mode of the left button.
+         * @param rightMode The mode of the right button.
+         * @param footerMessage The footer message.
+         * @param patternEnabled Whether the pattern widget is enabled.
+         */
+        Stage(int headerMessage,
+                LeftButtonMode leftMode,
+                RightButtonMode rightMode,
+                int footerMessage, boolean patternEnabled) {
+            this.headerMessage = headerMessage;
+            this.leftMode = leftMode;
+            this.rightMode = rightMode;
+            this.footerMessage = footerMessage;
+            this.patternEnabled = patternEnabled;
+        }
+
+        final int headerMessage;
+        final LeftButtonMode leftMode;
+        final RightButtonMode rightMode;
+        final int footerMessage;
+        final boolean patternEnabled;
+    }
+
+    private Stage mUiStage = Stage.Introduction;
+
+    private Runnable mClearPatternRunnable = new Runnable() {
+        public void run() {
+            mLockPatternView.clearPattern();
+        }
+    };
+
+    private static final String KEY_UI_STAGE = "uiStage";
+    private static final String KEY_PATTERN_CHOICE = "chosenPattern";
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        mLockPatternUtils = new LockPatternUtils(getContentResolver());
+
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+
+        setupViews();
+        
+        // make it so unhandled touch events within the unlock screen go to the
+        // lock pattern view.
+        final LinearLayoutWithDefaultTouchRecepient topLayout
+                = (LinearLayoutWithDefaultTouchRecepient) findViewById(
+                R.id.topLayout);
+        topLayout.setDefaultTouchRecepient(mLockPatternView);
+
+        if (savedInstanceState == null) {
+            // first launch
+            updateStage(Stage.Introduction);
+            if (mLockPatternUtils.savedPatternExists()) {
+                confirmPattern();
+            } 
+        } else {
+            // restore from previous state
+            final String patternString = savedInstanceState.getString(KEY_PATTERN_CHOICE);
+            if (patternString != null) {
+                mChosenPattern = LockPatternUtils.stringToPattern(patternString);
+            }
+            updateStage(Stage.values()[savedInstanceState.getInt(KEY_UI_STAGE)]);
+        }
+    }
+    
+    /**
+     * Keep all "find view" related stuff confined to this function since in
+     * case someone needs to subclass and customize.
+     */
+    protected void setupViews() {
+        setContentView(R.layout.choose_lock_pattern);
+        
+        mHeaderText = (TextView) findViewById(R.id.headerText);
+
+        mLockPatternView = (LockPatternView) findViewById(R.id.lockPattern);
+        mLockPatternView.setOnPatternListener(mChooseNewLockPatternListener);
+        mLockPatternView.setTactileFeedbackEnabled(mLockPatternUtils.isTactileFeedbackEnabled());        
+
+        mFooterText = (TextView) findViewById(R.id.footerText);
+
+        mFooterLeftButton = (TextView) findViewById(R.id.footerLeftButton);
+        mFooterRightButton = (TextView) findViewById(R.id.footerRightButton);
+
+        mFooterLeftButton.setOnClickListener(this);
+        mFooterRightButton.setOnClickListener(this);
+    }
+
+    public void onClick(View v) {
+        if (v == mFooterLeftButton) {
+            if (mUiStage.leftMode == LeftButtonMode.Retry) {
+                mChosenPattern = null;
+                mLockPatternView.clearPattern();
+                updateStage(Stage.Introduction);
+            } else if (mUiStage.leftMode == LeftButtonMode.Cancel) {
+                // They are canceling the entire wizard
+                setResult(RESULT_FINISHED);
+                finish();
+            } else {
+                throw new IllegalStateException("left footer button pressed, but stage of " +
+                    mUiStage + " doesn't make sense");
+            }
+        } else if (v == mFooterRightButton) {
+
+            if (mUiStage.rightMode == RightButtonMode.Continue) {
+                if (mUiStage != Stage.FirstChoiceValid) {
+                    throw new IllegalStateException("expected ui stage " + Stage.FirstChoiceValid
+                            + " when button is " + RightButtonMode.Continue);
+                }
+                updateStage(Stage.NeedToConfirm);
+            } else if (mUiStage.rightMode == RightButtonMode.Confirm) {
+                if (mUiStage != Stage.ChoiceConfirmed) {
+                    throw new IllegalStateException("expected ui stage " + Stage.ChoiceConfirmed
+                            + " when button is " + RightButtonMode.Confirm);
+                }
+                saveChosenPatternAndFinish();
+            } else if (mUiStage.rightMode == RightButtonMode.Ok) {
+                if (mUiStage != Stage.HelpScreen) {
+                    throw new IllegalStateException("Help screen is only mode with ok button, but " +
+                            "stage is " + mUiStage);
+                }
+                mLockPatternView.clearPattern();
+                mLockPatternView.setDisplayMode(DisplayMode.Correct);
+                updateStage(Stage.Introduction);
+            }
+        }
+    }
+
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
+            if (mUiStage == Stage.HelpScreen) {
+                updateStage(Stage.Introduction);
+                return true;
+            }
+        }
+        if (keyCode == KeyEvent.KEYCODE_MENU && mUiStage == Stage.Introduction) {
+            updateStage(Stage.HelpScreen);
+            return true;
+        }
+
+        return super.onKeyDown(keyCode, event);
+    }
+
+    /**
+     * Launch screen to confirm the existing lock pattern.
+     * @see #onActivityResult(int, int, android.content.Intent)
+     */
+    protected void confirmPattern() {
+        final Intent intent = new Intent();
+        intent.setClassName("com.android.settings", "com.android.settings.ConfirmLockPattern");
+        startActivityForResult(intent, 55);
+    }
+
+    /**
+     * @see #confirmPattern
+     */
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode,
+            Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+
+        if (requestCode != 55) {
+            return;
+        }
+
+        if (resultCode != Activity.RESULT_OK) {
+            setResult(RESULT_FINISHED);
+            finish();
+        }
+        updateStage(Stage.Introduction);
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+
+        outState.putInt(KEY_UI_STAGE, mUiStage.ordinal());
+        if (mChosenPattern != null) {
+            outState.putString(KEY_PATTERN_CHOICE, LockPatternUtils.patternToString(mChosenPattern));
+        }
+    }
+
+
+    /**
+     * Updates the messages and buttons appropriate to what stage the user
+     * is at in choosing a view.  This doesn't handle clearing out the pattern;
+     * the pattern is expected to be in the right state.
+     * @param stage
+     */
+    protected void updateStage(Stage stage) {
+
+        mUiStage = stage;
+
+        // header text, footer text, visibility and 
+        // enabled state all known from the stage
+        if (stage == Stage.ChoiceTooShort) {
+            mHeaderText.setText(
+                    getResources().getString(
+                            stage.headerMessage,
+                            LockPatternUtils.MIN_LOCK_PATTERN_SIZE));
+        } else {
+            mHeaderText.setText(stage.headerMessage);
+        }
+        if (stage.footerMessage == ID_EMPTY_MESSAGE) {
+            mFooterText.setText("");
+        } else {
+            mFooterText.setText(stage.footerMessage);
+        }
+
+        if (stage.leftMode == LeftButtonMode.Gone) {
+            mFooterLeftButton.setVisibility(View.GONE);
+        } else {
+            mFooterLeftButton.setVisibility(View.VISIBLE);
+            mFooterLeftButton.setText(stage.leftMode.text);
+            mFooterLeftButton.setEnabled(stage.leftMode.enabled);
+        }
+
+        mFooterRightButton.setText(stage.rightMode.text);
+        mFooterRightButton.setEnabled(stage.rightMode.enabled);
+
+        // same for whether the patten is enabled
+        if (stage.patternEnabled) {
+            mLockPatternView.enableInput();
+        } else {
+            mLockPatternView.disableInput();
+        }
+
+        // the rest of the stuff varies enough that it is easier just to handle
+        // on a case by case basis.
+        mLockPatternView.setDisplayMode(DisplayMode.Correct);
+
+        switch (mUiStage) {
+            case Introduction:
+                mLockPatternView.clearPattern();
+                break;
+            case HelpScreen:
+                mLockPatternView.setPattern(DisplayMode.Animate, mAnimatePattern);
+                break;
+            case ChoiceTooShort:
+                mLockPatternView.setDisplayMode(DisplayMode.Wrong);
+                postClearPatternRunnable();
+                break;
+            case FirstChoiceValid:
+                break;
+            case NeedToConfirm:
+                mLockPatternView.clearPattern();
+                break;
+            case ConfirmWrong:
+                mLockPatternView.setDisplayMode(DisplayMode.Wrong);
+                postClearPatternRunnable();
+                break;
+            case ChoiceConfirmed:
+                break;
+        }
+    }
+
+
+    // clear the wrong pattern unless they have started a new one
+    // already
+    private void postClearPatternRunnable() {
+        mLockPatternView.removeCallbacks(mClearPatternRunnable);
+        mLockPatternView.postDelayed(mClearPatternRunnable, WRONG_PATTERN_CLEAR_TIMEOUT_MS);
+    }
+
+    private void saveChosenPatternAndFinish() {
+        boolean patternExistedBefore = mLockPatternUtils.savedPatternExists();
+        mLockPatternUtils.saveLockPattern(mChosenPattern);
+
+        // if setting pattern for first time, enable the lock gesture.  otherwise,
+        // keep the user's setting.
+        if (!patternExistedBefore) {
+            mLockPatternUtils.setLockPatternEnabled(true);
+            mLockPatternUtils.setVisiblePatternEnabled(true);
+        }
+        
+        setResult(RESULT_FINISHED);
+        finish();
+    }
+}
diff --git a/src/com/android/settings/ChooseLockPatternExample.java b/src/com/android/settings/ChooseLockPatternExample.java
new file mode 100644
index 0000000..77517b9
--- /dev/null
+++ b/src/com/android/settings/ChooseLockPatternExample.java
@@ -0,0 +1,104 @@
+/*
+ * 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.settings;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.graphics.drawable.AnimationDrawable;
+import android.os.Bundle;
+import android.os.Handler;
+import android.view.View;
+import android.widget.ImageView;
+
+public class ChooseLockPatternExample extends Activity implements View.OnClickListener {
+    private static final int REQUESTCODE_CHOOSE = 1;
+    private static final long START_DELAY = 1000;
+    protected static final String TAG = "Settings";
+    private View mNextButton;
+    private View mSkipButton;
+    private View mImageView;
+    private AnimationDrawable mAnimation;
+    private Handler mHandler = new Handler();
+    private Runnable mRunnable = new Runnable() {
+        public void run() {
+            startAnimation(mAnimation);
+        }
+    };
+   
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.choose_lock_pattern_example);
+        initViews();
+    }
+    
+    @Override
+    protected void onResume() {
+        super.onResume();
+        mHandler.postDelayed(mRunnable, START_DELAY);
+    }
+    
+    @Override
+    protected void onPause() {
+        super.onPause();
+        stopAnimation(mAnimation);
+    }
+    
+    public void onClick(View v) {
+        if (v == mSkipButton) {
+            // Canceling, so finish all
+            setResult(ChooseLockPattern.RESULT_FINISHED);
+            finish();
+        } else if (v == mNextButton) {
+            stopAnimation(mAnimation);
+            Intent intent = new Intent(this, ChooseLockPattern.class);
+            startActivityForResult(intent, REQUESTCODE_CHOOSE);
+        }
+    }
+    
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (requestCode == REQUESTCODE_CHOOSE && resultCode == ChooseLockPattern.RESULT_FINISHED) {
+            setResult(resultCode);
+            finish();
+        }
+    }
+    
+    private void initViews() {
+        mNextButton = findViewById(R.id.next_button);
+        mNextButton.setOnClickListener(this);
+        
+        mSkipButton = findViewById(R.id.skip_button);
+        mSkipButton.setOnClickListener(this);
+        
+        mImageView = (ImageView) findViewById(R.id.lock_anim);
+        mImageView.setBackgroundResource(R.drawable.lock_anim);
+        mImageView.setOnClickListener(this);
+        mAnimation = (AnimationDrawable) mImageView.getBackground();
+    }
+    
+    protected void startAnimation(final AnimationDrawable animation) {
+        if (animation != null && !animation.isRunning()) {
+            animation.run();
+        }
+    }
+   
+    protected void stopAnimation(final AnimationDrawable animation) {
+        if (animation != null && animation.isRunning()) animation.stop();
+    }
+}
+
diff --git a/src/com/android/settings/ChooseLockPatternTutorial.java b/src/com/android/settings/ChooseLockPatternTutorial.java
new file mode 100644
index 0000000..a0a878a
--- /dev/null
+++ b/src/com/android/settings/ChooseLockPatternTutorial.java
@@ -0,0 +1,75 @@
+/*
+ * 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.settings;
+
+import com.android.internal.widget.LockPatternUtils;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+
+public class ChooseLockPatternTutorial extends Activity implements View.OnClickListener {
+    private static final int REQUESTCODE_EXAMPLE = 1;
+    
+    private View mNextButton;
+    private View mSkipButton;
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        // Don't show the tutorial if the user has seen it before.
+        LockPatternUtils lockPatternUtils = new LockPatternUtils(getContentResolver());
+        if (savedInstanceState == null && lockPatternUtils.savedPatternExists()) {
+            Intent intent = new Intent();
+            intent.setClassName("com.android.settings", "com.android.settings.ChooseLockPattern");
+            startActivity(intent);
+            finish();
+        } else {
+            initViews();
+        }
+    }
+    
+    private void initViews() {
+        setContentView(R.layout.choose_lock_pattern_tutorial);
+        mNextButton = findViewById(R.id.next_button);
+        mNextButton.setOnClickListener(this);
+        mSkipButton = findViewById(R.id.skip_button);
+        mSkipButton.setOnClickListener(this);
+    }
+
+    public void onClick(View v) {
+        if (v == mSkipButton) {
+            // Canceling, so finish all
+            setResult(ChooseLockPattern.RESULT_FINISHED);
+            finish();
+        } else if (v == mNextButton) {
+            startActivityForResult(new Intent(this, ChooseLockPatternExample.class),
+                    REQUESTCODE_EXAMPLE);
+        }
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (requestCode == REQUESTCODE_EXAMPLE && resultCode == ChooseLockPattern.RESULT_FINISHED) {
+            setResult(resultCode);
+            finish();
+        }
+    }
+    
+}
+
diff --git a/src/com/android/settings/ConfirmLockPattern.java b/src/com/android/settings/ConfirmLockPattern.java
new file mode 100644
index 0000000..44baccc
--- /dev/null
+++ b/src/com/android/settings/ConfirmLockPattern.java
@@ -0,0 +1,260 @@
+/*
+ * 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.settings;
+
+import com.android.internal.widget.LockPatternUtils;
+import com.android.internal.widget.LockPatternView;
+import com.android.internal.widget.LinearLayoutWithDefaultTouchRecepient;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.CountDownTimer;
+import android.os.SystemClock;
+import android.os.Bundle;
+import android.widget.TextView;
+import android.view.Window;
+
+import java.util.List;
+
+/**
+ * Launch this when you want the user to confirm their lock pattern.
+ *
+ * Sets an activity result of {@link Activity#RESULT_OK} when the user
+ * successfully confirmed their pattern.
+ */
+public class ConfirmLockPattern extends Activity {
+
+    /**
+     * Names of {@link CharSequence} fields within the originating {@link Intent}
+     * that are used to configure the keyguard confirmation view's labeling.
+     * The view will use the system-defined resource strings for any labels that
+     * the caller does not supply.
+     */
+    public static final String HEADER_TEXT = "com.android.settings.ConfirmLockPattern.header";
+    public static final String FOOTER_TEXT = "com.android.settings.ConfirmLockPattern.footer";
+    public static final String HEADER_WRONG_TEXT = "com.android.settings.ConfirmLockPattern.header_wrong";
+    public static final String FOOTER_WRONG_TEXT = "com.android.settings.ConfirmLockPattern.footer_wrong";
+
+    // how long we wait to clear a wrong pattern
+    private static final int WRONG_PATTERN_CLEAR_TIMEOUT_MS = 2000;
+
+    private static final String KEY_NUM_WRONG_ATTEMPTS = "num_wrong_attempts";
+
+    private LockPatternView mLockPatternView;
+    private LockPatternUtils mLockPatternUtils;
+    private int mNumWrongConfirmAttempts;
+    private CountDownTimer mCountdownTimer;
+
+    private TextView mHeaderTextView;
+    private TextView mFooterTextView;
+
+    // caller-supplied text for various prompts
+    private CharSequence mHeaderText;
+    private CharSequence mFooterText;
+    private CharSequence mHeaderWrongText;
+    private CharSequence mFooterWrongText;
+
+
+    private enum Stage {
+        NeedToUnlock,
+        NeedToUnlockWrong,
+        LockedOut
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        mLockPatternUtils = new LockPatternUtils(getContentResolver());
+
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        setContentView(R.layout.confirm_lock_pattern);
+
+        mHeaderTextView = (TextView) findViewById(R.id.headerText);
+        mLockPatternView = (LockPatternView) findViewById(R.id.lockPattern);
+        mFooterTextView = (TextView) findViewById(R.id.footerText);
+
+        // make it so unhandled touch events within the unlock screen go to the
+        // lock pattern view.
+        final LinearLayoutWithDefaultTouchRecepient topLayout
+                = (LinearLayoutWithDefaultTouchRecepient) findViewById(
+                R.id.topLayout);
+        topLayout.setDefaultTouchRecepient(mLockPatternView);        
+
+        Intent intent = getIntent();
+        if (intent != null) {
+            mHeaderText = intent.getCharSequenceExtra(HEADER_TEXT);
+            mFooterText = intent.getCharSequenceExtra(FOOTER_TEXT);
+            mHeaderWrongText = intent.getCharSequenceExtra(HEADER_WRONG_TEXT);
+            mFooterWrongText = intent.getCharSequenceExtra(FOOTER_WRONG_TEXT);
+        }
+
+        mLockPatternView.setTactileFeedbackEnabled(mLockPatternUtils.isTactileFeedbackEnabled());
+        mLockPatternView.setOnPatternListener(mConfirmExistingLockPatternListener);
+        updateStage(Stage.NeedToUnlock);
+
+        if (savedInstanceState != null) {
+            mNumWrongConfirmAttempts = savedInstanceState.getInt(KEY_NUM_WRONG_ATTEMPTS);
+        } else {
+            // on first launch, if no lock pattern is set, then finish with
+            // success (don't want user to get stuck confirming something that
+            // doesn't exist).
+            if (!mLockPatternUtils.savedPatternExists()) {
+                setResult(RESULT_OK);
+                finish();
+            }
+        }
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        // deliberately not calling super since we are managing this in full
+        outState.putInt(KEY_NUM_WRONG_ATTEMPTS, mNumWrongConfirmAttempts);
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        if (mCountdownTimer != null) {
+            mCountdownTimer.cancel();
+        }
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        // if the user is currently locked out, enforce it.
+        long deadline = mLockPatternUtils.getLockoutAttemptDeadline();
+        if (deadline != 0) {
+            handleAttemptLockout(deadline);
+        }
+    }
+
+    private void updateStage(Stage stage) {
+
+        switch (stage) {
+            case NeedToUnlock:
+                if (mHeaderText != null) {
+                    mHeaderTextView.setText(mHeaderText);
+                } else {
+                    mHeaderTextView.setText(R.string.lockpattern_need_to_unlock);
+                }
+                if (mFooterText != null) {
+                    mFooterTextView.setText(mFooterText);
+                } else {
+                    mFooterTextView.setText(R.string.lockpattern_need_to_unlock_footer);
+                }
+                
+                mLockPatternView.setEnabled(true);
+                mLockPatternView.enableInput();
+                break;
+            case NeedToUnlockWrong:
+                if (mHeaderWrongText != null) {
+                    mHeaderTextView.setText(mHeaderWrongText);
+                } else {
+                    mHeaderTextView.setText(R.string.lockpattern_need_to_unlock_wrong);
+                }
+                if (mFooterWrongText != null) {
+                    mFooterTextView.setText(mFooterWrongText);
+                } else {
+                    mFooterTextView.setText(R.string.lockpattern_need_to_unlock_wrong_footer);
+                }
+                
+                mLockPatternView.setDisplayMode(LockPatternView.DisplayMode.Wrong);
+                mLockPatternView.setEnabled(true);
+                mLockPatternView.enableInput();
+                break;
+            case LockedOut:
+                mLockPatternView.clearPattern();
+                // enabled = false means: disable input, and have the
+                // appearance of being disabled.
+                mLockPatternView.setEnabled(false); // appearance of being disabled
+                break;
+        }
+    }
+
+    private Runnable mClearPatternRunnable = new Runnable() {
+        public void run() {
+            mLockPatternView.clearPattern();
+        }
+    };
+
+    // clear the wrong pattern unless they have started a new one
+    // already
+    private void postClearPatternRunnable() {
+        mLockPatternView.removeCallbacks(mClearPatternRunnable);
+        mLockPatternView.postDelayed(mClearPatternRunnable, WRONG_PATTERN_CLEAR_TIMEOUT_MS);
+    }
+
+    /**
+     * The pattern listener that responds according to a user confirming
+     * an existing lock pattern.
+     */
+    private LockPatternView.OnPatternListener mConfirmExistingLockPatternListener = new LockPatternView.OnPatternListener()  {
+
+        public void onPatternStart() {
+            mLockPatternView.removeCallbacks(mClearPatternRunnable);
+        }
+
+        public void onPatternCleared() {
+            mLockPatternView.removeCallbacks(mClearPatternRunnable);
+        }
+
+        public void onPatternDetected(List<LockPatternView.Cell> pattern) {
+            if (mLockPatternUtils.checkPattern(pattern)) {
+                setResult(RESULT_OK);
+                finish();
+            } else {
+                if (pattern.size() >= LockPatternUtils.MIN_PATTERN_REGISTER_FAIL &&
+                        ++mNumWrongConfirmAttempts >= LockPatternUtils.FAILED_ATTEMPTS_BEFORE_TIMEOUT) {
+                    long deadline = mLockPatternUtils.setLockoutAttemptDeadline();
+                    handleAttemptLockout(deadline);
+                } else {
+                    updateStage(Stage.NeedToUnlockWrong);
+                    postClearPatternRunnable();
+                }
+            }
+        }
+    };
+
+
+    private void handleAttemptLockout(long elapsedRealtimeDeadline) {
+        updateStage(Stage.LockedOut);
+        long elapsedRealtime = SystemClock.elapsedRealtime();
+        mCountdownTimer = new CountDownTimer(
+                elapsedRealtimeDeadline - elapsedRealtime,
+                LockPatternUtils.FAILED_ATTEMPT_COUNTDOWN_INTERVAL_MS) {
+
+            @Override
+            public void onTick(long millisUntilFinished) {
+                mHeaderTextView.setText(R.string.lockpattern_too_many_failed_confirmation_attempts_header);
+                final int secondsCountdown = (int) (millisUntilFinished / 1000);
+                mFooterTextView.setText(getString(
+                        R.string.lockpattern_too_many_failed_confirmation_attempts_footer,
+                        secondsCountdown));
+            }
+
+            @Override
+            public void onFinish() {
+                mNumWrongConfirmAttempts = 0;
+                updateStage(Stage.NeedToUnlock);
+            }
+        }.start();
+    }
+}
diff --git a/src/com/android/settings/DateTimeSettings.java b/src/com/android/settings/DateTimeSettings.java
new file mode 100644
index 0000000..e78215a
--- /dev/null
+++ b/src/com/android/settings/DateTimeSettings.java
@@ -0,0 +1,366 @@
+/*
+ * 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.settings;
+
+import android.app.Dialog;
+import android.app.DatePickerDialog;
+import android.app.TimePickerDialog;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.os.Bundle;
+import android.os.SystemClock;
+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.Settings.SettingNotFoundException;
+import android.text.format.DateFormat;
+import android.widget.DatePicker;
+import android.widget.TimePicker;
+
+import java.util.Calendar;
+import java.util.Date;
+import java.util.TimeZone;
+
+public class DateTimeSettings 
+        extends PreferenceActivity 
+        implements OnSharedPreferenceChangeListener,
+                TimePickerDialog.OnTimeSetListener , DatePickerDialog.OnDateSetListener {
+
+    private static final String HOURS_12 = "12";
+    private static final String HOURS_24 = "24";
+    
+    private Calendar mDummyDate;
+    private static final String KEY_DATE_FORMAT = "date_format";
+    private static final String KEY_AUTO_TIME = "auto_time";
+
+    private static final int DIALOG_DATEPICKER = 0;
+    private static final int DIALOG_TIMEPICKER = 1;
+    
+    private CheckBoxPreference mAutoPref;
+    private Preference mTimePref;
+    private Preference mTime24Pref;
+    private Preference mTimeZone;
+    private Preference mDatePref;
+    private ListPreference mDateFormat;
+    
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        
+        addPreferencesFromResource(R.xml.date_time_prefs);
+        
+        initUI();        
+    }
+    
+    private void initUI() {
+        boolean autoEnabled = getAutoState();
+
+        mDummyDate = Calendar.getInstance();
+        mDummyDate.set(mDummyDate.get(Calendar.YEAR), 11, 31, 13, 0, 0);
+        
+        mAutoPref = (CheckBoxPreference) findPreference(KEY_AUTO_TIME);
+        mAutoPref.setChecked(autoEnabled);
+        mTimePref = findPreference("time");
+        mTime24Pref = findPreference("24 hour");
+        mTimeZone = findPreference("timezone");
+        mDatePref = findPreference("date");
+        mDateFormat = (ListPreference) findPreference(KEY_DATE_FORMAT);
+        
+        int currentFormatIndex = -1;
+        String [] dateFormats = getResources().getStringArray(R.array.date_format_values);
+        String [] formattedDates = new String[dateFormats.length];
+        String currentFormat = getDateFormat();
+        // Initialize if DATE_FORMAT is not set in the system settings
+        // This can happen after a factory reset (or data wipe)
+        if (currentFormat == null) {
+            currentFormat = getResources().getString(R.string.default_date_format);
+            setDateFormat(currentFormat);
+        }
+        for (int i = 0; i < formattedDates.length; i++) {
+            formattedDates[i] = DateFormat.format(dateFormats[i], mDummyDate).toString();
+            if (currentFormat.equals(dateFormats[i])) currentFormatIndex = i;
+        }
+        
+        mDateFormat.setEntries(formattedDates);
+        mDateFormat.setEntryValues(R.array.date_format_values);
+        mDateFormat.setValue(currentFormat);
+        
+        mTimePref.setEnabled(!autoEnabled);
+        mDatePref.setEnabled(!autoEnabled);
+        mTimeZone.setEnabled(!autoEnabled);
+
+        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);        
+    }
+
+    
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        ((CheckBoxPreference)mTime24Pref).setChecked(is24Hour());
+
+        // Register for time ticks and other reasons for time change
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(Intent.ACTION_TIME_TICK);
+        filter.addAction(Intent.ACTION_TIME_CHANGED);
+        filter.addAction(Intent.ACTION_TIMEZONE_CHANGED);
+        registerReceiver(mIntentReceiver, filter, null, null);
+        
+        updateTimeAndDateDisplay();
+    }
+
+    @Override 
+    protected void onPause() {
+        super.onPause();
+        unregisterReceiver(mIntentReceiver);
+    }
+    
+    private void updateTimeAndDateDisplay() {
+        java.text.DateFormat shortDateFormat = DateFormat.getDateFormat(this);
+        Date now = Calendar.getInstance().getTime();
+        Date dummyDate = mDummyDate.getTime();
+        mTimePref.setSummary(DateFormat.getTimeFormat(this).format(now));
+        mTimeZone.setSummary(getTimeZoneText());
+        mDatePref.setSummary(shortDateFormat.format(now));
+        mDateFormat.setSummary(shortDateFormat.format(dummyDate));
+    }
+
+    public void onDateSet(DatePicker view, int year, int month, int day) {
+        Calendar c = Calendar.getInstance();
+
+        c.set(Calendar.YEAR, year);
+        c.set(Calendar.MONTH, month);
+        c.set(Calendar.DAY_OF_MONTH, day);
+        long when = c.getTimeInMillis();
+
+        if (when / 1000 < Integer.MAX_VALUE) {
+            SystemClock.setCurrentTimeMillis(when);
+        }
+        updateTimeAndDateDisplay();
+    }
+
+    public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
+        Calendar c = Calendar.getInstance();
+
+        c.set(Calendar.HOUR_OF_DAY, hourOfDay);
+        c.set(Calendar.MINUTE, minute);
+        long when = c.getTimeInMillis();
+
+        if (when / 1000 < Integer.MAX_VALUE) {
+            SystemClock.setCurrentTimeMillis(when);
+        }
+        updateTimeAndDateDisplay();
+        timeUpdated();
+    }
+
+    public void onSharedPreferenceChanged(SharedPreferences preferences, String key) {
+        if (key.equals(KEY_DATE_FORMAT)) {
+            String format = preferences.getString(key, 
+                    getResources().getString(R.string.default_date_format));
+            Settings.System.putString(getContentResolver(), 
+                    Settings.System.DATE_FORMAT, format);
+            updateTimeAndDateDisplay();
+        } else if (key.equals(KEY_AUTO_TIME)) {
+            boolean autoEnabled = preferences.getBoolean(key, true);
+            Settings.System.putInt(getContentResolver(), 
+                    Settings.System.AUTO_TIME, 
+                    autoEnabled ? 1 : 0);
+            mTimePref.setEnabled(!autoEnabled);
+            mDatePref.setEnabled(!autoEnabled);
+            mTimeZone.setEnabled(!autoEnabled);
+        }
+    }
+
+    @Override
+    public Dialog onCreateDialog(int id) {
+        Dialog d;
+
+        switch (id) {
+        case DIALOG_DATEPICKER: {
+            final Calendar calendar = Calendar.getInstance();
+            d = new DatePickerDialog(
+                this,
+                this,
+                calendar.get(Calendar.YEAR),
+                calendar.get(Calendar.MONTH),
+                calendar.get(Calendar.DAY_OF_MONTH));
+            d.setTitle(getResources().getString(R.string.date_time_changeDate_text));
+            break;
+        }
+        case DIALOG_TIMEPICKER: {
+            final Calendar calendar = Calendar.getInstance();
+            d = new TimePickerDialog(
+                    this,
+                    this,
+                    calendar.get(Calendar.HOUR_OF_DAY),
+                    calendar.get(Calendar.MINUTE),
+                    DateFormat.is24HourFormat(this));
+            d.setTitle(getResources().getString(R.string.date_time_changeTime_text));
+            break;
+        }
+        default:
+            d = null;
+            break;
+        }
+
+        return d;
+    }
+
+    @Override
+    public void onPrepareDialog(int id, Dialog d) {
+        switch (id) {
+        case DIALOG_DATEPICKER: {
+            DatePickerDialog datePicker = (DatePickerDialog)d;
+            final Calendar calendar = Calendar.getInstance();
+            datePicker.updateDate(
+                    calendar.get(Calendar.YEAR),
+                    calendar.get(Calendar.MONTH),
+                    calendar.get(Calendar.DAY_OF_MONTH));
+            break;
+        }
+        case DIALOG_TIMEPICKER: {
+            TimePickerDialog timePicker = (TimePickerDialog)d;
+            final Calendar calendar = Calendar.getInstance();
+            timePicker.updateTime(
+                    calendar.get(Calendar.HOUR_OF_DAY),
+                    calendar.get(Calendar.MINUTE));
+            break;
+        }
+        default:
+            break;
+        }
+    }
+    
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
+        if (preference == mDatePref) {
+            showDialog(DIALOG_DATEPICKER);
+        } else if (preference == mTimePref) {
+            // The 24-hour mode may have changed, so recreate the dialog
+            removeDialog(DIALOG_TIMEPICKER);
+            showDialog(DIALOG_TIMEPICKER);
+        } else if (preference == mTime24Pref) {
+            set24Hour(((CheckBoxPreference)mTime24Pref).isChecked());
+            updateTimeAndDateDisplay();
+            timeUpdated();
+        } else if (preference == mTimeZone) {
+            Intent intent = new Intent();
+            intent.setClass(this, ZoneList.class);
+            startActivityForResult(intent, 0);
+        }
+        return false;
+    }
+    
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode,
+            Intent data) {
+        updateTimeAndDateDisplay();
+    }
+    
+    private void timeUpdated() {
+        Intent timeChanged = new Intent(Intent.ACTION_TIME_CHANGED);
+        sendBroadcast(timeChanged);
+    }
+    
+    /*  Get & Set values from the system settings  */
+    
+    private boolean is24Hour() {
+        return DateFormat.is24HourFormat(this);
+    }
+    
+    private void set24Hour(boolean is24Hour) {
+        Settings.System.putString(getContentResolver(),
+                Settings.System.TIME_12_24,
+                is24Hour? HOURS_24 : HOURS_12);
+    }
+    
+    private String getDateFormat() {
+        return Settings.System.getString(getContentResolver(), 
+                Settings.System.DATE_FORMAT);
+    }
+    
+    private boolean getAutoState() {
+        try {
+            return Settings.System.getInt(getContentResolver(), 
+                Settings.System.AUTO_TIME) > 0;            
+        } catch (SettingNotFoundException snfe) {
+            return true;
+        }
+    }
+
+    private void setDateFormat(String format) {
+        Settings.System.putString(getContentResolver(), Settings.System.DATE_FORMAT, format);        
+    }
+    
+    /*  Helper routines to format timezone */
+    
+    private String getTimeZoneText() {
+        TimeZone    tz = java.util.Calendar.getInstance().getTimeZone();
+        boolean daylight = tz.inDaylightTime(new Date());
+        StringBuilder sb = new StringBuilder();
+
+        sb.append(formatOffset(tz.getRawOffset() +
+                               (daylight ? tz.getDSTSavings() : 0))).
+            append(", ").
+            append(tz.getDisplayName(daylight, TimeZone.LONG));
+
+        return sb.toString();        
+    }
+
+    private char[] formatOffset(int off) {
+        off = off / 1000 / 60;
+
+        char[] buf = new char[9];
+        buf[0] = 'G';
+        buf[1] = 'M';
+        buf[2] = 'T';
+
+        if (off < 0) {
+            buf[3] = '-';
+            off = -off;
+        } else {
+            buf[3] = '+';
+        }
+
+        int hours = off / 60; 
+        int minutes = off % 60;
+
+        buf[4] = (char) ('0' + hours / 10);
+        buf[5] = (char) ('0' + hours % 10);
+
+        buf[6] = ':';
+
+        buf[7] = (char) ('0' + minutes / 10);
+        buf[8] = (char) ('0' + minutes % 10);
+
+        return buf;
+    }
+    
+    private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            updateTimeAndDateDisplay();
+        }
+    };
+}
diff --git a/src/com/android/settings/DateTimeSettingsSetupWizard.java b/src/com/android/settings/DateTimeSettingsSetupWizard.java
new file mode 100644
index 0000000..8dd970b
--- /dev/null
+++ b/src/com/android/settings/DateTimeSettingsSetupWizard.java
@@ -0,0 +1,41 @@
+/*
+ * 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.settings;
+
+import android.os.Bundle;
+import android.view.View;
+import android.view.Window;
+import android.view.View.OnClickListener;
+import android.widget.LinearLayout;
+
+public class DateTimeSettingsSetupWizard extends DateTimeSettings implements OnClickListener {
+    private View mNextButton;
+    
+    @Override
+    protected void onCreate(Bundle icicle) {
+        requestWindowFeature(Window.FEATURE_NO_TITLE); 
+        super.onCreate(icicle);
+        setContentView(R.layout.date_time_settings_setupwizard);
+        mNextButton = findViewById(R.id.next_button);
+        mNextButton.setOnClickListener(this);
+    }
+
+    public void onClick(View v) {
+        setResult(RESULT_OK);
+        finish();
+    }
+}
diff --git a/src/com/android/settings/DebugIntentSender.java b/src/com/android/settings/DebugIntentSender.java
new file mode 100644
index 0000000..9fed947
--- /dev/null
+++ b/src/com/android/settings/DebugIntentSender.java
@@ -0,0 +1,88 @@
+/*
+ * 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.settings;
+
+import android.app.Activity;
+import android.widget.EditText;
+import android.widget.Button;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+import android.text.TextUtils;
+import android.text.Spannable;
+import android.text.Selection;
+import android.net.Uri;
+
+/**
+ * A simple activity that provides a UI for sending intents
+ */
+public class DebugIntentSender extends Activity {
+    private EditText mIntentField;
+    private EditText mDataField;
+    private EditText mAccountField;
+    private EditText mResourceField;
+    private Button mSendBroadcastButton;
+    private Button mStartActivityButton;
+    private View.OnClickListener mClicked = new View.OnClickListener() {
+        public void onClick(View v) {
+            if ((v == mSendBroadcastButton) ||
+                       (v == mStartActivityButton)) {
+                String intentAction = mIntentField.getText().toString();
+                String intentData = mDataField.getText().toString();
+                String account = mAccountField.getText().toString();
+                String resource = mResourceField.getText().toString();
+
+                Intent intent = new Intent(intentAction);
+                if (!TextUtils.isEmpty(intentData)) {
+                    intent.setData(Uri.parse(intentData));
+                }
+                intent.putExtra("account", account);
+                intent.putExtra("resource", resource);
+                if (v == mSendBroadcastButton) {
+                    sendBroadcast(intent);
+                } else {
+                    startActivity(intent);
+                }
+
+                setResult(RESULT_OK);
+                finish();
+            }
+        }
+    };
+
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        setContentView(R.layout.intent_sender);
+
+        mIntentField = (EditText) findViewById(R.id.intent);
+        mIntentField.setText(Intent.ACTION_SYNC);
+        Selection.selectAll((Spannable) mIntentField.getText());
+
+        mDataField = (EditText) findViewById(R.id.data);
+        mDataField.setBackgroundResource(android.R.drawable.editbox_background);
+
+        mAccountField = (EditText) findViewById(R.id.account);
+        mResourceField = (EditText) findViewById(R.id.resource);
+
+        mSendBroadcastButton = (Button) findViewById(R.id.sendbroadcast);
+        mSendBroadcastButton.setOnClickListener(mClicked);
+
+        mStartActivityButton = (Button) findViewById(R.id.startactivity);
+        mStartActivityButton.setOnClickListener(mClicked);
+    }
+}
diff --git a/src/com/android/settings/DefaultRingtonePreference.java b/src/com/android/settings/DefaultRingtonePreference.java
new file mode 100644
index 0000000..8eed563
--- /dev/null
+++ b/src/com/android/settings/DefaultRingtonePreference.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2007 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.settings;
+
+
+import android.content.Context;
+import android.content.Intent;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.preference.RingtonePreference;
+import android.util.AttributeSet;
+import android.util.Config;
+import android.util.Log;
+
+public class DefaultRingtonePreference extends RingtonePreference {
+    private static final String TAG = "DefaultRingtonePreference";
+    
+    public DefaultRingtonePreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @Override
+    protected void onPrepareRingtonePickerIntent(Intent ringtonePickerIntent) {
+        super.onPrepareRingtonePickerIntent(ringtonePickerIntent);
+        
+        /*
+         * Since this preference is for choosing the default ringtone, it
+         * doesn't make sense to show a 'Default' item.
+         */
+        ringtonePickerIntent.putExtra(RingtoneManager.EXTRA_RINGTONE_SHOW_DEFAULT, false);
+        
+        /*
+         * Similarly, 'Silent' shouldn't be shown here. 
+         */
+        ringtonePickerIntent.putExtra(RingtoneManager.EXTRA_RINGTONE_SHOW_SILENT, false);
+    }
+
+    @Override
+    protected void onSaveRingtone(Uri ringtoneUri) {
+        RingtoneManager.setActualDefaultRingtoneUri(getContext(), getRingtoneType(), ringtoneUri);
+    }
+
+    @Override
+    protected Uri onRestoreRingtone() {
+        return RingtoneManager.getActualDefaultRingtoneUri(getContext(), getRingtoneType());
+    }
+    
+}
diff --git a/src/com/android/settings/DevelopmentSettings.java b/src/com/android/settings/DevelopmentSettings.java
new file mode 100644
index 0000000..155f085
--- /dev/null
+++ b/src/com/android/settings/DevelopmentSettings.java
@@ -0,0 +1,88 @@
+/*
+ * 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.settings;
+
+import android.os.BatteryManager;
+import android.os.Bundle;
+import android.os.SystemProperties;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceScreen;
+import android.preference.CheckBoxPreference;
+import android.provider.Settings;
+import android.text.TextUtils;
+
+/*
+ * Displays preferences for application developers.
+ */
+public class DevelopmentSettings extends PreferenceActivity {
+
+    private static final String ENABLE_ADB = "enable_adb";
+    private static final String KEEP_SCREEN_ON = "keep_screen_on";
+    private static final String ALLOW_MOCK_LOCATION = "allow_mock_location";
+
+    private CheckBoxPreference mEnableAdb;
+    private CheckBoxPreference mKeepScreenOn;
+    private CheckBoxPreference mAllowMockLocation;
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        addPreferencesFromResource(R.xml.development_prefs);
+
+        mEnableAdb = (CheckBoxPreference) findPreference(ENABLE_ADB);
+        mKeepScreenOn = (CheckBoxPreference) findPreference(KEEP_SCREEN_ON);
+        mAllowMockLocation = (CheckBoxPreference) findPreference(ALLOW_MOCK_LOCATION);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        
+        mEnableAdb.setChecked(Settings.Secure.getInt(getContentResolver(),
+                Settings.Secure.ADB_ENABLED, 0) != 0);
+        mKeepScreenOn.setChecked(Settings.System.getInt(getContentResolver(),
+                Settings.System.STAY_ON_WHILE_PLUGGED_IN, 0) != 0);
+        mAllowMockLocation.setChecked(Settings.Secure.getInt(getContentResolver(),
+                Settings.Secure.ALLOW_MOCK_LOCATION, 0) != 0);
+    }
+
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
+
+        // Those monkeys kept committing suicide, so we add this property
+        // to disable this functionality
+        if (!TextUtils.isEmpty(SystemProperties.get("ro.monkey"))) {
+            return false;
+        }
+
+        if (preference == mEnableAdb) {
+            Settings.Secure.putInt(getContentResolver(), Settings.Secure.ADB_ENABLED, 
+                    mEnableAdb.isChecked() ? 1 : 0);
+        } else if (preference == mKeepScreenOn) {
+            Settings.System.putInt(getContentResolver(), Settings.System.STAY_ON_WHILE_PLUGGED_IN, 
+                    mKeepScreenOn.isChecked() ? 
+                    (BatteryManager.BATTERY_PLUGGED_AC | BatteryManager.BATTERY_PLUGGED_USB) : 0);
+        } else if (preference == mAllowMockLocation) {
+            Settings.Secure.putInt(getContentResolver(), Settings.Secure.ALLOW_MOCK_LOCATION,
+                    mAllowMockLocation.isChecked() ? 1 : 0);
+        }
+        
+        return false;
+    }
+}
diff --git a/src/com/android/settings/DeviceInfoSettings.java b/src/com/android/settings/DeviceInfoSettings.java
new file mode 100644
index 0000000..be01f7d
--- /dev/null
+++ b/src/com/android/settings/DeviceInfoSettings.java
@@ -0,0 +1,153 @@
+/*
+ * 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.settings;
+
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.SystemProperties;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceGroup;
+import android.util.Config;
+import android.util.Log;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class DeviceInfoSettings extends PreferenceActivity {
+
+    private static final String TAG = "DeviceInfoSettings";
+    private static final boolean LOGD = false || Config.LOGD;
+
+    private static final String KEY_CONTAINER = "container";
+    private static final String KEY_TEAM = "team";
+    private static final String KEY_CONTRIBUTORS = "contributors";
+    private static final String KEY_TERMS = "terms";
+    private static final String KEY_LICENSE = "license";
+    private static final String KEY_COPYRIGHT = "copyright";
+    private static final String KEY_SYSTEM_UPDATE_SETTINGS = "system_update_settings";
+    
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        
+        addPreferencesFromResource(R.xml.device_info_settings);
+       
+        setStringSummary("firmware_version", Build.VERSION.RELEASE);
+        setValueSummary("baseband_version", "gsm.version.baseband");
+        setStringSummary("device_model", Build.MODEL);
+        setStringSummary("build_number", Build.DISPLAY);
+        findPreference("kernel_version").setSummary(getFormattedKernelVersion());
+
+        /*
+         * Settings is a generic app and should not contain any device-specific
+         * info.
+         */
+        
+        // These are contained in the "container" preference group
+        PreferenceGroup parentPreference = (PreferenceGroup) findPreference(KEY_CONTAINER);
+        Utils.updatePreferenceToSpecificActivityOrRemove(this, parentPreference, KEY_TERMS,
+                Utils.UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY);
+        Utils.updatePreferenceToSpecificActivityOrRemove(this, parentPreference, KEY_LICENSE,
+                Utils.UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY);
+        Utils.updatePreferenceToSpecificActivityOrRemove(this, parentPreference, KEY_COPYRIGHT,
+                Utils.UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY);
+        Utils.updatePreferenceToSpecificActivityOrRemove(this, parentPreference, KEY_TEAM,
+                Utils.UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY);
+        
+        // These are contained by the root preference screen
+        parentPreference = getPreferenceScreen();
+        Utils.updatePreferenceToSpecificActivityOrRemove(this, parentPreference,
+                KEY_SYSTEM_UPDATE_SETTINGS,
+                Utils.UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY);
+        Utils.updatePreferenceToSpecificActivityOrRemove(this, parentPreference, KEY_CONTRIBUTORS,
+                Utils.UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY);
+    }
+    
+    private void setStringSummary(String preference, String value) {
+        try {
+            findPreference(preference).setSummary(value);
+        } catch (RuntimeException e) {
+            findPreference(preference).setSummary(
+                getResources().getString(R.string.device_info_default));
+        }
+    }
+    
+    private void setValueSummary(String preference, String property) {
+        try {
+            findPreference(preference).setSummary(
+                    SystemProperties.get(property, 
+                            getResources().getString(R.string.device_info_default)));
+        } catch (RuntimeException e) {
+
+        }
+    }
+
+    private String getFormattedKernelVersion() {
+        String procVersionStr;
+
+        try {
+            BufferedReader reader = new BufferedReader(new FileReader("/proc/version"), 256);
+            try {
+                procVersionStr = reader.readLine();
+            } finally {
+                reader.close();
+            }
+
+            final String PROC_VERSION_REGEX =
+                "\\w+\\s+" + /* ignore: Linux */
+                "\\w+\\s+" + /* ignore: version */
+                "([^\\s]+)\\s+" + /* group 1: 2.6.22-omap1 */
+                "\\(([^\\s@]+(?:@[^\\s.]+)?)[^)]*\\)\\s+" + /* group 2: (xxxxxx@xxxxx.constant) */
+                "\\([^)]+\\)\\s+" + /* ignore: (gcc ..) */
+                "([^\\s]+)\\s+" + /* group 3: #26 */
+                "(?:PREEMPT\\s+)?" + /* ignore: PREEMPT (optional) */
+                "(.+)"; /* group 4: date */
+
+            Pattern p = Pattern.compile(PROC_VERSION_REGEX);
+            Matcher m = p.matcher(procVersionStr);
+
+            if (!m.matches()) {
+                Log.e(TAG, "Regex did not match on /proc/version: " + procVersionStr);
+                return "Unavailable";
+            } else if (m.groupCount() < 4) {
+                Log.e(TAG, "Regex match on /proc/version only returned " + m.groupCount()
+                        + " groups");
+                return "Unavailable";
+            } else {
+                return (new StringBuilder(m.group(1)).append("\n").append(
+                        m.group(2)).append(" ").append(m.group(3)).append("\n")
+                        .append(m.group(4))).toString();
+            }
+        } catch (IOException e) {  
+            Log.e(TAG,
+                "IO Exception when getting kernel version for Device Info screen",
+                e);
+
+            return "Unavailable";
+        }
+    }
+
+}
diff --git a/src/com/android/settings/Display.java b/src/com/android/settings/Display.java
new file mode 100644
index 0000000..f90e0f0
--- /dev/null
+++ b/src/com/android/settings/Display.java
@@ -0,0 +1,138 @@
+/*
+ * 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.settings;
+
+import android.app.Activity;
+import android.app.ActivityManagerNative;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.util.DisplayMetrics;
+import android.util.TypedValue;
+import android.view.View;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.Spinner;
+import android.widget.TextView;
+
+
+public class Display extends Activity implements View.OnClickListener {
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        setContentView(R.layout.display);
+
+        mFontSize = (Spinner) findViewById(R.id.fontSize);
+        mFontSize.setOnItemSelectedListener(mFontSizeChanged);
+        String[] states = new String[3];
+        Resources r = getResources();
+        states[0] = r.getString(R.string.small_font);
+        states[1] = r.getString(R.string.medium_font);
+        states[2] = r.getString(R.string.large_font);
+        ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,
+                android.R.layout.simple_spinner_item, states);
+        adapter.setDropDownViewResource(
+                android.R.layout.simple_spinner_dropdown_item);
+        mFontSize.setAdapter(adapter);
+
+        mPreview = (TextView) findViewById(R.id.preview);
+        mPreview.setText(r.getText(R.string.font_size_preview_text));
+
+        Button save = (Button) findViewById(R.id.save);
+        save.setText(r.getText(R.string.font_size_save));
+        save.setOnClickListener(this);
+
+        mTextSizeTyped = new TypedValue();
+        TypedArray styledAttributes = 
+            obtainStyledAttributes(android.R.styleable.TextView);
+        styledAttributes.getValue(android.R.styleable.TextView_textSize,
+                mTextSizeTyped);
+
+        DisplayMetrics metrics = getResources().getDisplayMetrics();
+        mDisplayMetrics = new DisplayMetrics();
+        mDisplayMetrics.density = metrics.density;
+        mDisplayMetrics.heightPixels = metrics.heightPixels;
+        mDisplayMetrics.scaledDensity = metrics.scaledDensity;
+        mDisplayMetrics.widthPixels = metrics.widthPixels;
+        mDisplayMetrics.xdpi = metrics.xdpi;
+        mDisplayMetrics.ydpi = metrics.ydpi;
+        
+        styledAttributes.recycle();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        try {
+            mCurConfig.updateFrom(
+                ActivityManagerNative.getDefault().getConfiguration());
+        } catch (RemoteException e) {
+        }
+        if (mCurConfig.fontScale < 1) {
+            mFontSize.setSelection(0);
+        } else if (mCurConfig.fontScale > 1) {
+            mFontSize.setSelection(2);
+        } else {
+            mFontSize.setSelection(1);
+        }
+        updateFontScale();
+    }
+
+    private void updateFontScale() {
+        mDisplayMetrics.scaledDensity = mDisplayMetrics.density *
+                mCurConfig.fontScale;
+
+        float size = mTextSizeTyped.getDimension(mDisplayMetrics);
+        mPreview.setTextSize(TypedValue.COMPLEX_UNIT_PX, size);
+    }
+
+    public void onClick(View v) {
+        try {
+            ActivityManagerNative.getDefault().updateConfiguration(mCurConfig);
+        } catch (RemoteException e) {
+        }
+        finish();
+    }
+
+    private Spinner.OnItemSelectedListener mFontSizeChanged
+                                    = new Spinner.OnItemSelectedListener() {
+        public void onItemSelected(android.widget.AdapterView av, View v,
+                                    int position, long id) {
+            if (position == 0) {
+                mCurConfig.fontScale = .75f;
+            } else if (position == 2) {
+                mCurConfig.fontScale = 1.25f;
+            } else {
+                mCurConfig.fontScale = 1.0f;
+            }
+
+            updateFontScale();
+        }
+
+        public void onNothingSelected(android.widget.AdapterView av) {
+        }
+    };
+
+    private Spinner mFontSize;
+    private TextView mPreview;
+    private TypedValue mTextSizeTyped;
+    private DisplayMetrics mDisplayMetrics;
+    private Configuration mCurConfig = new Configuration();
+}
diff --git a/src/com/android/settings/EditPinPreference.java b/src/com/android/settings/EditPinPreference.java
new file mode 100644
index 0000000..ee3143c
--- /dev/null
+++ b/src/com/android/settings/EditPinPreference.java
@@ -0,0 +1,84 @@
+/*
+ * 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.settings;
+
+import android.content.Context;
+import android.preference.EditTextPreference;
+import android.text.method.DigitsKeyListener;
+import android.text.method.PasswordTransformationMethod;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.EditText;
+
+import java.util.Map;
+
+/**
+ * TODO: Add a soft dialpad for PIN entry.
+ */
+class EditPinPreference extends EditTextPreference {
+
+    private boolean mDialogOpen;
+    
+    interface OnPinEnteredListener {
+        void onPinEntered(EditPinPreference preference, boolean positiveResult);
+    }
+    
+    private OnPinEnteredListener mPinListener;
+    
+    public EditPinPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public EditPinPreference(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+    
+    public void setOnPinEnteredListener(OnPinEnteredListener listener) {
+        mPinListener = listener;
+    }
+    
+    @Override
+    protected void onBindDialogView(View view) {
+        super.onBindDialogView(view);
+        
+        final EditText editText = (EditText) view.findViewById(android.R.id.edit);
+        
+        if (editText != null) {
+            editText.setSingleLine(true);
+            editText.setTransformationMethod(PasswordTransformationMethod.getInstance());
+            editText.setKeyListener(DigitsKeyListener.getInstance());
+        }
+    }
+
+    public boolean isDialogOpen() {
+        return mDialogOpen;
+    }
+    
+    @Override
+    protected void onDialogClosed(boolean positiveResult) {
+        super.onDialogClosed(positiveResult);
+        mDialogOpen = false;
+        if (mPinListener != null) {
+            mPinListener.onPinEntered(this, positiveResult);
+        }
+    }
+    
+    public void showPinDialog() {
+        mDialogOpen = true;
+        showDialog(null);
+    }
+}
diff --git a/src/com/android/settings/GadgetPickActivity.java b/src/com/android/settings/GadgetPickActivity.java
new file mode 100644
index 0000000..840a6a5
--- /dev/null
+++ b/src/com/android/settings/GadgetPickActivity.java
@@ -0,0 +1,131 @@
+/*
+ * 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.settings;
+
+import android.app.LauncherActivity;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.gadget.GadgetProviderInfo;
+import android.gadget.GadgetManager;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.ListView;
+import android.util.Log;
+
+import java.text.Collator;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+
+public class GadgetPickActivity extends LauncherActivity
+{
+    private static final String TAG = "GadgetPickActivity";
+
+    GadgetManager mGadgetManager;
+    int mGadgetId;
+    
+    public GadgetPickActivity() {
+        mGadgetManager = GadgetManager.getInstance(this);
+    }
+
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        Bundle extras = getIntent().getExtras();
+        mGadgetId = extras.getInt(GadgetManager.EXTRA_GADGET_ID);
+
+        setResultData(RESULT_CANCELED);
+    }
+
+    @Override
+    public void onListItemClick(ListView l, View v, int position, long id)
+    {
+        Intent intent = intentForPosition(position);
+        int result;
+        try {
+            mGadgetManager.bindGadgetId(mGadgetId, intent.getComponent());
+            result = RESULT_OK;
+        } catch (IllegalArgumentException e) {
+            // This is thrown if they're already bound, or otherwise somehow
+            // bogus.  Set the result to canceled, and exit.  The app *should*
+            // clean up at this point.  We could pass the error along, but
+            // it's not clear that that's useful -- the gadget will simply not
+            // appear.
+            result = RESULT_CANCELED;
+        }
+        setResultData(result);
+        finish();
+    }
+    
+    @Override
+    public List<ListItem> makeListItems() {
+        List<GadgetProviderInfo> installed = mGadgetManager.getInstalledProviders();
+        PackageManager pm = getPackageManager();
+
+        Drawable defaultIcon = null;
+        IconResizer resizer = new IconResizer();
+
+        ArrayList<ListItem> result = new ArrayList();
+        final int N = installed.size();
+        for (int i=0; i<N; i++) {
+            GadgetProviderInfo info = installed.get(i);
+
+            LauncherActivity.ListItem item = new LauncherActivity.ListItem();
+            item.packageName = info.provider.getPackageName();
+            item.className = info.provider.getClassName();
+            
+            item.label = info.label;
+            if (info.icon != 0) {
+                Drawable d = pm.getDrawable( item.packageName, info.icon, null);
+                if (d != null) {
+                    item.icon = resizer.createIconThumbnail(d);
+                } else {
+                    Log.w(TAG, "Can't load icon drawable 0x" + Integer.toHexString(info.icon)
+                            + " for package: " + item.packageName);
+                }
+            }
+            if (item.icon == null) {
+                // (including error case above)
+                if (defaultIcon == null) {
+                    // TODO: Load standard icon.
+                }
+                item.icon = defaultIcon;
+            }
+            
+            result.add(item);
+        }
+
+        Collections.sort(result, new Comparator<ListItem>() {
+                Collator mCollator = Collator.getInstance();
+                public int compare(ListItem lhs, ListItem rhs) {
+                    return mCollator.compare(lhs.label, rhs.label);
+                }
+            });
+        return result;
+    }
+
+    void setResultData(int code) {
+        Intent result = new Intent();
+        result.putExtra(GadgetManager.EXTRA_GADGET_ID, mGadgetId);
+        setResult(code, result);
+    }
+}
+
diff --git a/src/com/android/settings/InputMethodsSettings.java b/src/com/android/settings/InputMethodsSettings.java
new file mode 100644
index 0000000..51b770d
--- /dev/null
+++ b/src/com/android/settings/InputMethodsSettings.java
@@ -0,0 +1,191 @@
+/*
+ * 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.settings;
+
+import java.util.HashSet;
+import java.util.List;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.os.SystemProperties;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceScreen;
+import android.preference.CheckBoxPreference;
+import android.provider.Settings;
+import android.text.TextUtils;
+import android.view.inputmethod.InputMethodInfo;
+import android.view.inputmethod.InputMethodManager;
+
+/*
+ * Displays preferences for input methods.
+ */
+public class InputMethodsSettings extends PreferenceActivity {
+    private List<InputMethodInfo> mInputMethodProperties;
+
+    final TextUtils.SimpleStringSplitter mStringColonSplitter
+            = new TextUtils.SimpleStringSplitter(':');
+    
+    private String mLastInputMethodId;
+    private String mLastTickedInputMethodId;
+
+    static public String getInputMethodIdFromKey(String key) {
+        return key;
+    }
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        addPreferencesFromResource(R.xml.input_methods_prefs);
+
+        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+
+        mInputMethodProperties = imm.getInputMethodList();
+
+        mLastInputMethodId = Settings.Secure.getString(getContentResolver(),
+            Settings.Secure.DEFAULT_INPUT_METHOD);
+
+        int N = (mInputMethodProperties == null ? 0 : mInputMethodProperties
+                .size());
+        for (int i = 0; i < N; ++i) {
+            InputMethodInfo property = mInputMethodProperties.get(i);
+            String prefKey = property.getId();
+
+            CharSequence label = property.loadLabel(getPackageManager());
+            
+            // Add a check box.
+            CheckBoxPreference chkbxPref = new CheckBoxPreference(this);
+            chkbxPref.setKey(prefKey);
+            chkbxPref.setTitle(label);
+            getPreferenceScreen().addPreference(chkbxPref);
+
+            // If setting activity is available, add a setting screen entry.
+            if (null != property.getSettingsActivity()) {
+                PreferenceScreen prefScreen = new PreferenceScreen(this, null);
+                prefScreen.setKey(property.getSettingsActivity());
+                prefScreen.setTitle(getResources().getString(
+                        R.string.input_methods_settings_label_format, label));
+                getPreferenceScreen().addPreference(prefScreen);
+            }
+        }
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        final HashSet<String> enabled = new HashSet<String>();
+        String enabledStr = Settings.Secure.getString(getContentResolver(),
+                Settings.Secure.ENABLED_INPUT_METHODS);
+        if (enabledStr != null) {
+            final TextUtils.SimpleStringSplitter splitter = mStringColonSplitter;
+            splitter.setString(enabledStr);
+            while (splitter.hasNext()) {
+                enabled.add(splitter.next());
+            }
+        }
+        
+        // Update the statuses of the Check Boxes.
+        int N = mInputMethodProperties.size();
+        for (int i = 0; i < N; ++i) {
+            final String id = mInputMethodProperties.get(i).getId();
+            CheckBoxPreference pref = (CheckBoxPreference) findPreference(mInputMethodProperties
+                    .get(i).getId());
+            pref.setChecked(enabled.contains(id));
+        }
+        mLastTickedInputMethodId = null;
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        StringBuilder builder = new StringBuilder(256);
+        
+        boolean haveLastInputMethod = false;
+        
+        int firstEnabled = -1;
+        int N = mInputMethodProperties.size();
+        for (int i = 0; i < N; ++i) {
+            final String id = mInputMethodProperties.get(i).getId();
+            CheckBoxPreference pref = (CheckBoxPreference) findPreference(id);
+            boolean hasIt = id.equals(mLastInputMethodId);
+            if (pref.isChecked()) {
+                if (builder.length() > 0) builder.append(':');
+                builder.append(id);
+                if (firstEnabled < 0) {
+                    firstEnabled = i;
+                }
+                if (hasIt) haveLastInputMethod = true;
+            } else if (hasIt) {
+                mLastInputMethodId = mLastTickedInputMethodId;
+            }
+        }
+
+        // If the last input method is unset, set it as the first enabled one.
+        if (null == mLastInputMethodId || "".equals(mLastInputMethodId)) {
+            if (firstEnabled >= 0) {
+                mLastInputMethodId = mInputMethodProperties.get(firstEnabled).getId();
+            } else {
+                mLastInputMethodId = null;
+            }
+        }
+        
+        Settings.Secure.putString(getContentResolver(),
+            Settings.Secure.ENABLED_INPUT_METHODS, builder.toString());
+        Settings.Secure.putString(getContentResolver(),
+            Settings.Secure.DEFAULT_INPUT_METHOD, mLastInputMethodId);
+    }
+
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
+            Preference preference) {
+
+        // Those monkeys kept committing suicide, so we add this property
+        // to disable this functionality
+        if (!TextUtils.isEmpty(SystemProperties.get("ro.monkey"))) {
+            return false;
+        }
+
+        if (preference instanceof CheckBoxPreference) {
+            CheckBoxPreference chkPref = (CheckBoxPreference) preference;
+            String id = getInputMethodIdFromKey(chkPref.getKey());
+            if (chkPref.isChecked()) {
+                mLastTickedInputMethodId = id;
+            } else if (id.equals(mLastTickedInputMethodId)) {
+                mLastTickedInputMethodId = null;
+            }
+        } else if (preference instanceof PreferenceScreen) {
+            if (preference.getIntent() == null) {
+                PreferenceScreen pref = (PreferenceScreen) preference;
+                String activityName = pref.getKey();
+                String packageName = activityName.substring(0, activityName
+                        .lastIndexOf("."));
+                if (activityName.length() > 0) {
+                    Intent i = new Intent(Intent.ACTION_MAIN);
+                    i.setClassName(packageName, activityName);
+                    startActivity(i);
+                }
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/src/com/android/settings/InstalledAppDetails.java b/src/com/android/settings/InstalledAppDetails.java
new file mode 100644
index 0000000..327874b
--- /dev/null
+++ b/src/com/android/settings/InstalledAppDetails.java
@@ -0,0 +1,478 @@
+
+
+/**
+ * Copyright (C) 2007 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.settings;
+
+import com.android.settings.R;
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.IPackageDataObserver;
+import android.content.pm.IPackageStatsObserver;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageStats;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.text.format.Formatter;
+import android.util.Config;
+import android.util.Log;
+import java.util.ArrayList;
+import java.util.List;
+import android.content.ComponentName;
+import android.view.View;
+import android.widget.AppSecurityPermissions;
+import android.widget.Button;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+/**
+ * Activity to display application information from Settings. This activity presents
+ * extended information associated with a package like code, data, total size, permissions
+ * used by the application and also the set of default launchable activities.
+ * For system applications, an option to clear user data is displayed only if data size is > 0.
+ * System applications that do not want clear user data do not have this option.
+ * For non-system applications, there is no option to clear data. Instead there is an option to
+ * uninstall the application.
+ */
+public class InstalledAppDetails extends Activity implements View.OnClickListener, DialogInterface.OnClickListener  {
+    private static final String TAG="InstalledAppDetails";
+    private static final int _UNKNOWN_APP=R.string.unknown;
+    private ApplicationInfo mAppInfo;
+    private Button mAppButton;
+    private Button mActivitiesButton;
+    private boolean mCanUninstall;
+    private boolean localLOGV=Config.LOGV || false;
+    private TextView mAppSnippetSize;
+    private TextView mTotalSize;
+    private TextView mAppSize;
+    private TextView mDataSize;
+    private PkgSizeObserver mSizeObserver;
+    private ClearUserDataObserver mClearDataObserver;
+    // Views related to cache info
+    private View mCachePanel;
+    private TextView mCacheSize;
+    private Button mClearCacheButton;
+    private ClearCacheObserver mClearCacheObserver;
+    private Button mForceStopButton;
+    
+    PackageStats mSizeInfo;
+    private Button mManageSpaceButton;
+    private PackageManager mPm;
+    
+    //internal constants used in Handler
+    private static final int OP_SUCCESSFUL = 1;
+    private static final int OP_FAILED = 2;
+    private static final int CLEAR_USER_DATA = 1;
+    private static final int GET_PKG_SIZE = 2;
+    private static final int CLEAR_CACHE = 3;
+    private static final String ATTR_PACKAGE_STATS="PackageStats";
+    
+    // invalid size value used initially and also when size retrieval through PackageManager
+    // fails for whatever reason
+    private static final int SIZE_INVALID = -1;
+    
+    // Resource strings
+    private CharSequence mInvalidSizeStr;
+    private CharSequence mComputingStr;
+    private CharSequence mAppButtonText;
+    
+    // Possible btn states
+    private enum AppButtonStates {
+        CLEAR_DATA,
+        UNINSTALL,
+        NONE
+    } 
+    private AppButtonStates mAppButtonState;
+    
+    private Handler mHandler = new Handler() {
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case CLEAR_USER_DATA:
+                    processClearMsg(msg);
+                    break;
+                case GET_PKG_SIZE:
+                    refreshSizeInfo(msg);
+                    break;
+                case CLEAR_CACHE:
+                    // Refresh size info
+                    mPm.getPackageSizeInfo(mAppInfo.packageName, mSizeObserver);
+                    break;
+                default:
+                    break;
+            }
+        }
+    };
+    
+    private boolean isUninstallable() {
+        if (((mAppInfo.flags&ApplicationInfo.FLAG_SYSTEM) != 0) && 
+                ((mAppInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) == 0)) {
+            return false;
+        }
+        return true;
+    }
+    
+    class ClearUserDataObserver extends IPackageDataObserver.Stub {
+       public void onRemoveCompleted(final String packageName, final boolean succeeded) {
+           final Message msg = mHandler.obtainMessage(CLEAR_USER_DATA);
+           msg.arg1 = succeeded?OP_SUCCESSFUL:OP_FAILED;
+           mHandler.sendMessage(msg);
+        }
+    }
+    
+    class PkgSizeObserver extends IPackageStatsObserver.Stub {
+        public int idx;
+        public void onGetStatsCompleted(PackageStats pStats, boolean succeeded) {
+             Message msg = mHandler.obtainMessage(GET_PKG_SIZE);
+             Bundle data = new Bundle();
+             data.putParcelable(ATTR_PACKAGE_STATS, pStats);
+             msg.setData(data);
+             mHandler.sendMessage(msg);
+            
+         }
+     }
+    
+    class ClearCacheObserver extends IPackageDataObserver.Stub {
+        public void onRemoveCompleted(final String packageName, final boolean succeeded) {
+            final Message msg = mHandler.obtainMessage(CLEAR_CACHE);
+            msg.arg1 = succeeded?OP_SUCCESSFUL:OP_FAILED;
+            mHandler.sendMessage(msg);
+         }
+     }
+    
+    private String getSizeStr(long size) {
+        if (size == SIZE_INVALID) {
+            return mInvalidSizeStr.toString();
+        }
+        return Formatter.formatFileSize(this, size);
+    }
+    
+    private void setAppBtnState() {
+        boolean visible = false;
+        if(mCanUninstall) {
+            //app can clear user data
+            if((mAppInfo.flags & ApplicationInfo.FLAG_ALLOW_CLEAR_USER_DATA) 
+                    == ApplicationInfo.FLAG_ALLOW_CLEAR_USER_DATA) {
+                mAppButtonText = getText(R.string.clear_user_data_text);
+               mAppButtonState = AppButtonStates.CLEAR_DATA;
+               visible = true;
+            } else {
+                //hide button if diableClearUserData is set
+                visible = false;
+                mAppButtonState = AppButtonStates.NONE;
+            }
+        } else {
+            visible = true;
+            mAppButtonState = AppButtonStates.UNINSTALL;
+            mAppButtonText = getText(R.string.uninstall_text);
+        }
+        if(visible) {
+            mAppButton.setText(mAppButtonText);
+            mAppButton.setVisibility(View.VISIBLE);
+        } else {
+            mAppButton.setVisibility(View.GONE);
+        }
+    }
+    
+    /** Called when the activity is first created. */
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        //get package manager
+        mPm = getPackageManager();
+        //get application's name from intent
+        Intent intent = getIntent();
+        final String packageName = intent.getStringExtra(ManageApplications.APP_PKG_NAME);
+        mComputingStr = getText(R.string.computing_size);
+        // Try retrieving package stats again
+        CharSequence totalSizeStr, appSizeStr, dataSizeStr;
+        totalSizeStr = appSizeStr = dataSizeStr = mComputingStr;
+        if(localLOGV) Log.i(TAG, "Have to compute package sizes");
+        mSizeObserver = new PkgSizeObserver();
+        mPm.getPackageSizeInfo(packageName, mSizeObserver);
+
+        try {
+            mAppInfo = mPm.getApplicationInfo(packageName, 
+                    PackageManager.GET_UNINSTALLED_PACKAGES);
+        } catch (NameNotFoundException e) {
+            Log.e(TAG, "Exception when retrieving package:"+packageName, e);
+            displayErrorDialog(R.string.app_not_found_dlg_text, true, true);
+        }
+        setContentView(R.layout.installed_app_details);       
+        ((ImageView)findViewById(R.id.app_icon)).setImageDrawable(mAppInfo.loadIcon(mPm));
+        //set application name TODO version
+        CharSequence appName = mAppInfo.loadLabel(mPm);
+        if(appName == null) {
+            appName = getString(_UNKNOWN_APP);
+        }
+        ((TextView)findViewById(R.id.app_name)).setText(appName);
+        mAppSnippetSize = ((TextView)findViewById(R.id.app_size));
+        mAppSnippetSize.setText(totalSizeStr);
+        //TODO download str and download url
+        //set values on views
+        mTotalSize = (TextView)findViewById(R.id.total_size_text);
+        mTotalSize.setText(totalSizeStr);
+        mAppSize = (TextView)findViewById(R.id.application_size_text);
+        mAppSize.setText(appSizeStr);
+        mDataSize = (TextView)findViewById(R.id.data_size_text);
+        mDataSize.setText(dataSizeStr);
+         
+         mAppButton = ((Button)findViewById(R.id.uninstall_button));
+        //determine if app is a system app
+         mCanUninstall = !isUninstallable();
+         if(localLOGV) Log.i(TAG, "Is systemPackage "+mCanUninstall);
+         setAppBtnState();
+         mManageSpaceButton = (Button)findViewById(R.id.manage_space_button);
+         if(mAppInfo.manageSpaceActivityName != null) {
+             mManageSpaceButton.setVisibility(View.VISIBLE);
+             mManageSpaceButton.setOnClickListener(this);
+         }
+         
+         // Cache section
+         mCachePanel = findViewById(R.id.cache_panel);
+         mCacheSize = (TextView) findViewById(R.id.cache_size_text);
+         mCacheSize.setText(mComputingStr);
+         mClearCacheButton = (Button) findViewById(R.id.clear_cache_button);
+         mForceStopButton = (Button) findViewById(R.id.force_stop_button);
+         mForceStopButton.setOnClickListener(this);
+         
+         //clear activities
+         mActivitiesButton = (Button)findViewById(R.id.clear_activities_button);
+         List<ComponentName> prefActList = new ArrayList<ComponentName>();
+         //intent list cannot be null. so pass empty list
+         List<IntentFilter> intentList = new ArrayList<IntentFilter>();
+         mPm.getPreferredActivities(intentList,  prefActList, packageName);
+         if(localLOGV) Log.i(TAG, "Have "+prefActList.size()+" number of activities in prefered list");
+         TextView autoLaunchView = (TextView)findViewById(R.id.auto_launch);
+         if(prefActList.size() <= 0) {
+             //disable clear activities button
+             autoLaunchView.setText(R.string.auto_launch_disable_text);
+             mActivitiesButton.setEnabled(false);
+         } else {
+             autoLaunchView.setText(R.string.auto_launch_enable_text);
+             mActivitiesButton.setOnClickListener(this);
+         }
+         
+         // security permissions section
+         LinearLayout permsView = (LinearLayout) findViewById(R.id.permissions_section);
+         AppSecurityPermissions asp = new AppSecurityPermissions(this, packageName);
+         if(asp.getPermissionCount() > 0) {
+             permsView.setVisibility(View.VISIBLE);
+             // Make the security sections header visible
+             LinearLayout securityList = (LinearLayout) permsView.findViewById(
+                     R.id.security_settings_list);
+             securityList.addView(asp.getPermissionsView());
+         } else {
+             permsView.setVisibility(View.GONE);
+         }
+    }
+    
+    private void displayErrorDialog(int msgId, final boolean finish, final boolean changed) {
+        //display confirmation dialog
+        new AlertDialog.Builder(this)
+        .setTitle(getString(R.string.app_not_found_dlg_title))
+        .setIcon(android.R.drawable.ic_dialog_alert)
+        .setMessage(getString(msgId))
+        .setNeutralButton(getString(R.string.dlg_ok), 
+                new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        //force to recompute changed value
+                        setIntentAndFinish(finish, changed);
+                    }
+                }
+        )
+        .show();
+    }
+    
+    private void setIntentAndFinish(boolean finish, boolean appChanged) {
+        if(localLOGV) Log.i(TAG, "appChanged="+appChanged);
+        Intent intent = new Intent();
+        intent.putExtra(ManageApplications.APP_CHG, appChanged);
+        setResult(ManageApplications.RESULT_OK, intent);
+        mAppButton.setEnabled(false);
+        if(finish) {
+            finish();
+        }
+    }
+    
+    /*
+     * Private method to handle get size info notification from observer when
+     * the async operation from PackageManager is complete. The current user data
+     * info has to be refreshed in the manage applications screen as well as the current screen.
+     */
+    private void refreshSizeInfo(Message msg) {
+        boolean changed = false;
+        PackageStats newPs = msg.getData().getParcelable(ATTR_PACKAGE_STATS);
+        long newTot = newPs.cacheSize+newPs.codeSize+newPs.dataSize;
+        if(mSizeInfo == null) {
+            mSizeInfo = newPs;
+            String str = getSizeStr(newTot);
+            mTotalSize.setText(str);
+            mAppSnippetSize.setText(str);
+            mAppSize.setText(getSizeStr(newPs.codeSize));
+            mDataSize.setText(getSizeStr(newPs.dataSize));
+            mCacheSize.setText(getSizeStr(newPs.cacheSize));
+        } else {
+            long oldTot = mSizeInfo.cacheSize+mSizeInfo.codeSize+mSizeInfo.dataSize;
+            if(newTot != oldTot) {
+                String str = getSizeStr(newTot);
+                mTotalSize.setText(str);
+                mAppSnippetSize.setText(str);
+                changed = true;
+            }
+            if(newPs.codeSize != mSizeInfo.codeSize) {
+                mAppSize.setText(getSizeStr(newPs.codeSize));
+                changed = true;
+            }
+            if(newPs.dataSize != mSizeInfo.dataSize) {
+                mDataSize.setText(getSizeStr(newPs.dataSize));
+                changed = true;
+            }
+            if(newPs.cacheSize != mSizeInfo.cacheSize) {
+                mCacheSize.setText(getSizeStr(newPs.cacheSize));
+                changed = true;
+            }
+            if(changed) {
+                mSizeInfo = newPs;
+            }
+        }
+        
+        long data = mSizeInfo.dataSize;
+        // Disable button if data is 0
+        if(mAppButtonState != AppButtonStates.NONE){
+            mAppButton.setText(mAppButtonText);
+            if((mAppButtonState == AppButtonStates.CLEAR_DATA) && (data == 0)) {
+                mAppButton.setEnabled(false);
+            } else {
+                mAppButton.setEnabled(true);
+                mAppButton.setOnClickListener(this);
+            }            
+        }
+        refreshCacheInfo(newPs.cacheSize);
+    }
+    
+    private void refreshCacheInfo(long cacheSize) {
+        // Set cache info
+        mCacheSize.setText(getSizeStr(cacheSize));
+        if (cacheSize <= 0) {
+            mClearCacheButton.setEnabled(false);
+        } else {
+            mClearCacheButton.setOnClickListener(this);
+        }
+    }
+    
+    /*
+     * Private method to handle clear message notification from observer when
+     * the async operation from PackageManager is complete
+     */
+    private void processClearMsg(Message msg) {
+        int result = msg.arg1;
+        String packageName = mAppInfo.packageName;
+        if(result == OP_SUCCESSFUL) {
+            Log.i(TAG, "Cleared user data for system package:"+packageName);
+            mPm.getPackageSizeInfo(packageName, mSizeObserver);
+        } else {
+            mAppButton.setText(R.string.clear_user_data_text);
+            mAppButton.setEnabled(true);
+        }
+    }
+    
+    /*
+     * Private method to initiate clearing user data when the user clicks the clear data 
+     * button for a system package
+     */
+    private  void initiateClearUserDataForSysPkg() {
+        mAppButton.setEnabled(false);
+        //invoke uninstall or clear user data based on sysPackage
+        String packageName = mAppInfo.packageName;
+        Log.i(TAG, "Clearing user data for system package");
+        if(mClearDataObserver == null) {
+            mClearDataObserver = new ClearUserDataObserver();
+        }
+        ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
+        boolean res = am.clearApplicationUserData(packageName, mClearDataObserver);
+        if(!res) {
+            //doesnt initiate clear. some error. should not happen but just log error for now
+            Log.i(TAG, "Couldnt clear application user data for package:"+packageName);
+            displayErrorDialog(R.string.clear_data_failed, false, false);
+        } else {
+                mAppButton.setText(R.string.recompute_size);
+        }
+    }
+    
+    /*
+     * Method implementing functionality of buttons clicked
+     * @see android.view.View.OnClickListener#onClick(android.view.View)
+     */
+    public void onClick(View v) {
+        String packageName = mAppInfo.packageName;
+        if(v == mAppButton) {
+            if(mCanUninstall) {
+                //display confirmation dialog
+                new AlertDialog.Builder(this)
+                .setTitle(getString(R.string.clear_data_dlg_title))
+                .setIcon(android.R.drawable.ic_dialog_alert)
+                .setMessage(getString(R.string.clear_data_dlg_text))
+                .setPositiveButton(R.string.dlg_ok, this)
+                .setNegativeButton(R.string.dlg_cancel, this)
+                .show();
+            } else {
+                //create new intent to launch Uninstaller activity
+                Uri packageURI = Uri.parse("package:"+packageName);
+                Intent uninstallIntent = new Intent(Intent.ACTION_DELETE, packageURI);
+                startActivity(uninstallIntent);
+                setIntentAndFinish(true, true);
+            }
+        } else if(v == mActivitiesButton) {
+            mPm.clearPackagePreferredActivities(packageName);
+            mActivitiesButton.setEnabled(false);
+        } else if(v == mManageSpaceButton) {
+            Intent intent = new Intent(Intent.ACTION_DEFAULT);
+            intent.setClassName(mAppInfo.packageName, mAppInfo.manageSpaceActivityName);
+            startActivityForResult(intent, -1);
+        } else if (v == mClearCacheButton) {
+            // Lazy initialization of observer
+            if (mClearCacheObserver == null) {
+                mClearCacheObserver = new ClearCacheObserver();
+            }
+            mPm.deleteApplicationCacheFiles(packageName, mClearCacheObserver);
+        } else if (v == mForceStopButton) {
+            ActivityManager am = (ActivityManager)getSystemService(
+                    Context.ACTIVITY_SERVICE);
+            am.restartPackage(packageName);
+        }
+    }
+
+    public void onClick(DialogInterface dialog, int which) {
+        if(which == AlertDialog.BUTTON_POSITIVE) {
+            //invoke uninstall or clear user data based on sysPackage
+            initiateClearUserDataForSysPkg();
+        } else {
+            //cancel do nothing just retain existing screen
+        }
+    }
+}
+
diff --git a/src/com/android/settings/LanguageSettings.java b/src/com/android/settings/LanguageSettings.java
new file mode 100644
index 0000000..8463d26
--- /dev/null
+++ b/src/com/android/settings/LanguageSettings.java
@@ -0,0 +1,247 @@
+/*
+ * 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.settings;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.os.SystemProperties;
+import android.preference.CheckBoxPreference;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceGroup;
+import android.preference.PreferenceScreen;
+import android.provider.Settings;
+import android.provider.Settings.System;
+import android.text.TextUtils;
+import android.view.inputmethod.InputMethodInfo;
+import android.view.inputmethod.InputMethodManager;
+
+import java.util.HashSet;
+import java.util.List;
+
+public class LanguageSettings extends PreferenceActivity {
+    
+    private final String[] mSettingsUiKey = {
+            "auto_caps",
+            "auto_replace",
+            "auto_punctuate",
+    };
+    
+    // Note: Order of this array should correspond to the order of the above array
+    private final String[] mSettingsSystemId = {
+            System.TEXT_AUTO_CAPS,
+            System.TEXT_AUTO_REPLACE,
+            System.TEXT_AUTO_PUNCTUATE,
+    };
+
+    // Note: Order of this array should correspond to the order of the above array
+    private final int[] mSettingsDefault = {
+            1,
+            1,
+            1,
+    };
+    
+    private List<InputMethodInfo> mInputMethodProperties;
+
+    final TextUtils.SimpleStringSplitter mStringColonSplitter
+            = new TextUtils.SimpleStringSplitter(':');
+    
+    private String mLastInputMethodId;
+    private String mLastTickedInputMethodId;
+
+    static public String getInputMethodIdFromKey(String key) {
+        return key;
+    }
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        addPreferencesFromResource(R.xml.language_settings);
+
+        if (getAssets().getLocales().length == 1) {
+            getPreferenceScreen().
+                removePreference(findPreference("language_category"));
+        }
+    
+        Configuration config = getResources().getConfiguration();
+        if (config.keyboard != Configuration.KEYBOARD_QWERTY) {
+            getPreferenceScreen().removePreference(
+                    getPreferenceScreen().findPreference("hardkeyboard_category"));
+        } else {
+            ContentResolver resolver = getContentResolver();
+            for (int i = 0; i < mSettingsUiKey.length; i++) {
+                CheckBoxPreference pref = (CheckBoxPreference) findPreference(mSettingsUiKey[i]);
+                pref.setChecked(System.getInt(resolver, mSettingsSystemId[i],
+                                              mSettingsDefault[i]) > 0);
+            }
+        }
+
+        onCreateIMM();
+    }
+    
+    private void onCreateIMM() {
+        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+
+        mInputMethodProperties = imm.getInputMethodList();
+
+        mLastInputMethodId = Settings.Secure.getString(getContentResolver(),
+            Settings.Secure.DEFAULT_INPUT_METHOD);
+        
+        PreferenceGroup textCategory = (PreferenceGroup) findPreference("text_category");
+        
+        int N = (mInputMethodProperties == null ? 0 : mInputMethodProperties
+                .size());
+        for (int i = 0; i < N; ++i) {
+            InputMethodInfo property = mInputMethodProperties.get(i);
+            String prefKey = property.getId();
+
+            CharSequence label = property.loadLabel(getPackageManager());
+            
+            // Add a check box.
+            CheckBoxPreference chkbxPref = new CheckBoxPreference(this);
+            chkbxPref.setKey(prefKey);
+            chkbxPref.setTitle(label);
+            textCategory.addPreference(chkbxPref);
+
+            // If setting activity is available, add a setting screen entry.
+            if (null != property.getSettingsActivity()) {
+                PreferenceScreen prefScreen = new PreferenceScreen(this, null);
+                prefScreen.setKey(property.getSettingsActivity());
+                CharSequence settingsLabel = getResources().getString(
+                        R.string.input_methods_settings_label_format, label);
+                prefScreen.setTitle(settingsLabel);
+                textCategory.addPreference(prefScreen);
+            }
+        }
+    }
+    
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        final HashSet<String> enabled = new HashSet<String>();
+        String enabledStr = Settings.Secure.getString(getContentResolver(),
+                Settings.Secure.ENABLED_INPUT_METHODS);
+        if (enabledStr != null) {
+            final TextUtils.SimpleStringSplitter splitter = mStringColonSplitter;
+            splitter.setString(enabledStr);
+            while (splitter.hasNext()) {
+                enabled.add(splitter.next());
+            }
+        }
+        
+        // Update the statuses of the Check Boxes.
+        int N = mInputMethodProperties.size();
+        for (int i = 0; i < N; ++i) {
+            final String id = mInputMethodProperties.get(i).getId();
+            CheckBoxPreference pref = (CheckBoxPreference) findPreference(mInputMethodProperties
+                    .get(i).getId());
+            pref.setChecked(enabled.contains(id));
+        }
+        mLastTickedInputMethodId = null;
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        StringBuilder builder = new StringBuilder(256);
+        
+        boolean haveLastInputMethod = false;
+        
+        int firstEnabled = -1;
+        int N = mInputMethodProperties.size();
+        for (int i = 0; i < N; ++i) {
+            final String id = mInputMethodProperties.get(i).getId();
+            CheckBoxPreference pref = (CheckBoxPreference) findPreference(id);
+            boolean hasIt = id.equals(mLastInputMethodId);
+            if (pref.isChecked()) {
+                if (builder.length() > 0) builder.append(':');
+                builder.append(id);
+                if (firstEnabled < 0) {
+                    firstEnabled = i;
+                }
+                if (hasIt) haveLastInputMethod = true;
+            } else if (hasIt) {
+                mLastInputMethodId = mLastTickedInputMethodId;
+            }
+        }
+
+        // If the last input method is unset, set it as the first enabled one.
+        if (null == mLastInputMethodId || "".equals(mLastInputMethodId)) {
+            if (firstEnabled >= 0) {
+                mLastInputMethodId = mInputMethodProperties.get(firstEnabled).getId();
+            } else {
+                mLastInputMethodId = null;
+            }
+        }
+        
+        Settings.Secure.putString(getContentResolver(),
+            Settings.Secure.ENABLED_INPUT_METHODS, builder.toString());
+        Settings.Secure.putString(getContentResolver(),
+            Settings.Secure.DEFAULT_INPUT_METHOD, mLastInputMethodId);
+    }
+
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
+
+        // Physical keyboard stuff
+        for (int i = 0; i < mSettingsUiKey.length; i++) {
+            if (mSettingsUiKey[i].equals(preference.getKey())) {
+                System.putInt(getContentResolver(), mSettingsSystemId[i], 
+                        ((CheckBoxPreference)preference).isChecked()? 1 : 0);
+                return true;
+            }
+        }
+
+        // Input Method stuff
+        // Those monkeys kept committing suicide, so we add this property
+        // to disable this functionality
+        if (!TextUtils.isEmpty(SystemProperties.get("ro.monkey"))) {
+            return false;
+        }
+
+        if (preference instanceof CheckBoxPreference) {
+            CheckBoxPreference chkPref = (CheckBoxPreference) preference;
+            String id = getInputMethodIdFromKey(chkPref.getKey());
+            if (chkPref.isChecked()) {
+                mLastTickedInputMethodId = id;
+            } else if (id.equals(mLastTickedInputMethodId)) {
+                mLastTickedInputMethodId = null;
+            }
+        } else if (preference instanceof PreferenceScreen) {
+            if (preference.getIntent() == null) {
+                PreferenceScreen pref = (PreferenceScreen) preference;
+                String activityName = pref.getKey();
+                String packageName = activityName.substring(0, activityName
+                        .lastIndexOf("."));
+                if (activityName.length() > 0) {
+                    Intent i = new Intent(Intent.ACTION_MAIN);
+                    i.setClassName(packageName, activityName);
+                    startActivity(i);
+                }
+            }
+        }
+
+        return super.onPreferenceTreeClick(preferenceScreen, preference);
+    }
+
+}
diff --git a/src/com/android/settings/LauncherGadgetBinder.java b/src/com/android/settings/LauncherGadgetBinder.java
new file mode 100644
index 0000000..f7b5a61
--- /dev/null
+++ b/src/com/android/settings/LauncherGadgetBinder.java
@@ -0,0 +1,225 @@
+/*
+ * 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.settings;
+
+import android.app.Activity;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Intent;
+import android.content.ComponentName;
+import android.database.Cursor;
+import android.database.SQLException;
+import android.gadget.GadgetManager;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.os.Bundle;
+import android.provider.BaseColumns;
+import android.util.Log;
+
+import java.util.ArrayList;
+
+public class LauncherGadgetBinder extends Activity {
+    private static final String TAG = "LauncherGadgetBinder";
+    private static final boolean LOGD = true;
+    
+    static final String AUTHORITY = "com.android.launcher.settings";
+    static final String TABLE_FAVORITES = "favorites";
+    
+    static final String EXTRA_BIND_SOURCES = "com.android.launcher.settings.bindsources";
+    static final String EXTRA_BIND_TARGETS = "com.android.launcher.settings.bindtargets";
+
+    static final String EXTRA_GADGET_BITMAPS = "com.android.camera.gadgetbitmaps";
+    
+    /**
+     * {@link ContentProvider} constants pulled over from Launcher
+     */
+    static final class LauncherProvider implements BaseColumns {
+        static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/" + TABLE_FAVORITES);
+
+        static final String ITEM_TYPE = "itemType";
+        static final String GADGET_ID = "gadgetId";
+        static final String ICON = "icon";
+
+        static final int ITEM_TYPE_GADGET = 4;
+        static final int ITEM_TYPE_WIDGET_CLOCK = 1000;
+        static final int ITEM_TYPE_WIDGET_SEARCH = 1001;
+        static final int ITEM_TYPE_WIDGET_PHOTO_FRAME = 1002;
+    }
+    
+    static final String[] BIND_PROJECTION = new String[] {
+        LauncherProvider._ID,
+        LauncherProvider.ITEM_TYPE,
+        LauncherProvider.GADGET_ID,
+        LauncherProvider.ICON,
+    };
+    
+    static final int INDEX_ID = 0;
+    static final int INDEX_ITEM_TYPE = 1;
+    static final int INDEX_GADGET_ID = 2;
+    static final int INDEX_ICON = 3;
+    
+    static final ComponentName BIND_PHOTO_GADGET = new ComponentName("com.android.camera",
+            "com.android.camera.PhotoGadgetBind");
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        finish();
+
+        // This helper reaches into the Launcher database and binds any unlinked
+        // gadgets. If will remove any items that can't be bound successfully.
+        // We protect this binder at the manifest level by asserting the caller
+        // has the Launcher WRITE_SETTINGS permission.
+        
+        final Intent intent = getIntent();
+        final Bundle extras = intent.getExtras();
+        
+        int[] bindSources = null;
+        ArrayList<ComponentName> bindTargets = null;
+        Exception exception = null;
+
+        try {
+            bindSources = extras.getIntArray(EXTRA_BIND_SOURCES);
+            bindTargets = intent.getParcelableArrayListExtra(EXTRA_BIND_TARGETS);
+        } catch (ClassCastException ex) {
+            exception = ex;
+        }
+        
+        if (exception != null || bindSources == null || bindTargets == null ||
+                bindSources.length != bindTargets.size()) {
+            Log.w(TAG, "Problem reading incoming bind request, or invalid request", exception);
+            return;
+        }
+        
+        final String selectWhere = buildOrWhereString(LauncherProvider.ITEM_TYPE, bindSources);
+        
+        final ContentResolver resolver = getContentResolver();
+        final GadgetManager gadgetManager = GadgetManager.getInstance(this);
+        
+        boolean foundPhotoGadgets = false;
+        final ArrayList<Integer> photoGadgetIds = new ArrayList<Integer>();
+        final ArrayList<Bitmap> photoBitmaps = new ArrayList<Bitmap>();
+        
+        Cursor c = null;
+        
+        try {
+            c = resolver.query(LauncherProvider.CONTENT_URI,
+                    BIND_PROJECTION, selectWhere, null, null);
+            
+            if (LOGD) Log.d(TAG, "found bind cursor count="+c.getCount());
+            
+            final ContentValues values = new ContentValues();
+            while (c != null && c.moveToNext()) {
+                long favoriteId = c.getLong(INDEX_ID);
+                int itemType = c.getInt(INDEX_ITEM_TYPE);
+                int gadgetId = c.getInt(INDEX_GADGET_ID);
+                byte[] iconData = c.getBlob(INDEX_ICON);
+                
+                // Find the binding target for this type
+                ComponentName targetGadget = null;
+                for (int i = 0; i < bindSources.length; i++) {
+                    if (bindSources[i] == itemType) {
+                        targetGadget = bindTargets.get(i);
+                        break;
+                    }
+                }
+                
+                if (LOGD) Log.d(TAG, "found matching targetGadget="+targetGadget.toString()+" for favoriteId="+favoriteId);
+                
+                boolean bindSuccess = false;
+                try {
+                    gadgetManager.bindGadgetId(gadgetId, targetGadget);
+                    bindSuccess = true;
+                } catch (RuntimeException ex) {
+                    Log.w(TAG, "Problem binding gadget", ex);
+                }
+                
+                // Handle special case of photo gadget by loading bitmap and
+                // preparing for later binding
+                if (bindSuccess && iconData != null &&
+                        itemType == LauncherProvider.ITEM_TYPE_WIDGET_PHOTO_FRAME) {
+                    Bitmap bitmap = BitmapFactory.decodeByteArray(iconData, 0, iconData.length);
+                    
+                    photoGadgetIds.add(gadgetId);
+                    photoBitmaps.add(bitmap);
+                    foundPhotoGadgets = true;
+                }
+
+                if (LOGD) Log.d(TAG, "after finished, success="+bindSuccess);
+
+                // Depending on success, update launcher or remove item
+                Uri favoritesUri = ContentUris.withAppendedId(LauncherProvider.CONTENT_URI, favoriteId);
+                if (bindSuccess) {
+                    values.clear();
+                    values.put(LauncherProvider.ITEM_TYPE, LauncherProvider.ITEM_TYPE_GADGET);
+                    values.putNull(LauncherProvider.ICON);
+                    resolver.update(favoritesUri, values, null, null);
+                } else {
+                    resolver.delete(favoritesUri, null, null);
+                }
+                    
+            }
+        } catch (SQLException ex) {
+            Log.w(TAG, "Problem while binding gadgetIds for Launcher", ex);
+        } finally {
+            if (c != null) {
+                c.close();
+            }
+        }
+        
+        if (foundPhotoGadgets) {
+            // Convert gadgetIds into int[]
+            final int N = photoGadgetIds.size();
+            final int[] photoGadgetIdsArray = new int[N];
+            for (int i = 0; i < N; i++) {
+                photoGadgetIdsArray[i] = photoGadgetIds.get(i);
+            }
+            
+            // Launch intent over to handle bitmap binding, but we don't need to
+            // wait around for the result.
+            final Intent bindIntent = new Intent();
+            bindIntent.setComponent(BIND_PHOTO_GADGET);
+            
+            final Bundle bindExtras = new Bundle();
+            bindExtras.putIntArray(GadgetManager.EXTRA_GADGET_IDS, photoGadgetIdsArray);
+            bindExtras.putParcelableArrayList(EXTRA_GADGET_BITMAPS, photoBitmaps);
+            bindIntent.putExtras(bindExtras);
+            
+            startActivity(bindIntent);
+        }
+        
+        if (LOGD) Log.d(TAG, "completely finished with binding for Launcher");
+    }
+    
+    /**
+     * Build a query string that will match any row where the column matches
+     * anything in the values list.
+     */
+    static String buildOrWhereString(String column, int[] values) {
+        StringBuilder selectWhere = new StringBuilder();
+        for (int i = values.length - 1; i >= 0; i--) {
+            selectWhere.append(column).append("=").append(values[i]);
+            if (i > 0) {
+                selectWhere.append(" OR ");
+            }
+        }
+        return selectWhere.toString();
+    }
+    
+}
diff --git a/src/com/android/settings/LocalePicker.java b/src/com/android/settings/LocalePicker.java
new file mode 100644
index 0000000..386d7e0
--- /dev/null
+++ b/src/com/android/settings/LocalePicker.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2007 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.settings;
+
+import android.app.ActivityManagerNative;
+import android.app.IActivityManager;
+import android.app.ListActivity;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.os.SystemProperties;
+import android.util.Log;
+import android.view.View;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+
+import java.io.BufferedWriter;
+import java.io.FileOutputStream;
+import java.util.Arrays;
+import java.util.Locale;
+
+public class LocalePicker extends ListActivity {
+    private static final String TAG = "LocalePicker";
+
+    Loc[] mLocales;
+
+    private static class Loc {
+        String label;
+        Locale locale;
+
+        public Loc(String label, Locale locale) {
+            this.label = label;
+            this.locale = locale;
+        }
+
+        @Override
+        public String toString() {
+            return this.label;
+        }
+    }
+
+    int getContentView() {
+        return R.layout.locale_picker;
+    }
+    
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        setContentView(getContentView());
+
+        String[] locales = getAssets().getLocales();
+        Arrays.sort(locales);
+
+        final int origSize = locales.length;
+        Loc[] preprocess = new Loc[origSize];
+        int finalSize = 0;
+        for (int i = 0 ; i < origSize; i++ ) {
+            String s = locales[i];
+            int len = s.length();
+            if (len == 2) {
+                Locale l = new Locale(s);
+                preprocess[finalSize++] = new Loc(toTitleCase(l.getDisplayLanguage()), l);
+            } else if (len == 5) {
+                String language = s.substring(0, 2);
+                String country = s.substring(3, 5);
+                Locale l = new Locale(language, country);
+
+                if (finalSize == 0) {
+                    preprocess[finalSize++] = new Loc(toTitleCase(l.getDisplayLanguage()), l);
+                } else {
+                    // check previous entry:
+                    //  same lang and no country -> overwrite it with a lang-only name
+                    //  same lang and a country -> upgrade to full name and 
+                    //    insert ours with full name
+                    //  diff lang -> insert ours with lang-only name
+                    if (preprocess[finalSize-1].locale.getLanguage().equals(language)) {
+                       String prevCountry = preprocess[finalSize-1].locale.getCountry();
+                       if (prevCountry.length() == 0) {
+                            preprocess[finalSize-1].locale = l;
+                            preprocess[finalSize-1].label = toTitleCase(l.getDisplayLanguage());
+                        } else {
+                            preprocess[finalSize-1].label = toTitleCase(preprocess[finalSize-1].locale.getDisplayName());
+                            preprocess[finalSize++] = new Loc(toTitleCase(l.getDisplayName()), l);
+                        }
+                    } else {
+                        String displayName;
+                        if (s.equals("zz_ZZ")) {
+                            displayName = "Pseudo...";
+                        } else {
+                            displayName = toTitleCase(l.getDisplayLanguage());
+                        }
+                        preprocess[finalSize++] = new Loc(displayName, l);
+                    }
+                }
+            }
+        }
+        mLocales = new Loc[finalSize];
+        for (int i = 0; i < finalSize ; i++) {
+            mLocales[i] = preprocess[i];
+        }
+        int layoutId = R.layout.locale_picker_item;
+        int fieldId = R.id.locale;
+        ArrayAdapter<Loc> adapter = new ArrayAdapter<Loc>(this, layoutId, fieldId, mLocales);
+        getListView().setAdapter(adapter);
+    }
+
+    private static String toTitleCase(String s) {
+        if (s.length() == 0) {
+            return s;
+        }
+
+        return Character.toUpperCase(s.charAt(0)) + s.substring(1);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        getListView().requestFocus();
+    }
+
+    @Override
+    protected void onListItemClick(ListView l, View v, int position, long id) {
+        try {
+            IActivityManager am = ActivityManagerNative.getDefault();
+            Configuration config = am.getConfiguration();
+
+            Loc loc = mLocales[position];
+            config.locale = loc.locale;
+
+            // indicate this isn't some passing default - the user wants this remembered
+            config.userSetLocale = true;
+
+            am.updateConfiguration(config);
+        } catch (RemoteException e) {
+            // Intentionally left blank
+        }
+        finish();
+    }
+}
diff --git a/src/com/android/settings/LocalePickerInSetupWizard.java b/src/com/android/settings/LocalePickerInSetupWizard.java
new file mode 100644
index 0000000..b160e89
--- /dev/null
+++ b/src/com/android/settings/LocalePickerInSetupWizard.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2007 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.settings;
+
+import android.app.ActivityManagerNative;
+import android.app.IActivityManager;
+import android.app.ListActivity;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.os.SystemProperties;
+import android.util.Log;
+import android.view.View;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+
+import java.io.BufferedWriter;
+import java.io.FileOutputStream;
+import java.util.Arrays;
+import java.util.Locale;
+
+public class LocalePickerInSetupWizard extends LocalePicker {
+    
+    @Override 
+    int getContentView() {
+        return R.layout.locale_picker_in_setupwizard;
+    }
+
+}
diff --git a/src/com/android/settings/ManageApplications.java b/src/com/android/settings/ManageApplications.java
new file mode 100644
index 0000000..74957ed
--- /dev/null
+++ b/src/com/android/settings/ManageApplications.java
@@ -0,0 +1,1307 @@
+/*
+ * 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.settings;
+
+import com.android.settings.R;
+import android.app.ActivityManager;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.ListActivity;
+import android.app.ProgressDialog;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.IPackageStatsObserver;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageStats;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.text.format.Formatter;
+import android.util.Config;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.widget.AdapterView;
+import android.widget.BaseAdapter;
+import android.widget.ImageView;
+import android.widget.ListView;
+import android.widget.TextView;
+import android.widget.AdapterView.OnItemClickListener;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+/**
+ * Activity to pick an application that will be used to display installation information and
+ * options to uninstall/delete user data for system applications. This activity
+ * can be launched through Settings or via the ACTION_MANAGE_PACKAGE_STORAGE
+ * intent.
+ *  Initially a compute in progress message is displayed while the application retrieves
+ *  the list of application information from the PackageManager. The size information
+ *  for each package is refreshed to the screen. The resource(app description and
+ *  icon) information for each package is not available yet, so some default values for size
+ *  icon and descriptions are used initially. Later the resource information for each 
+ *  application is retrieved and dynamically updated on the screen.
+ *  A Broadcast receiver registers for package additions or deletions when the activity is
+ *  in focus. If the user installs or deletes packages when the activity has focus, the receiver
+ *  gets notified and proceeds to add/delete these packages from the list on the screen.
+ *  This is an unlikely scenario but could happen. The entire list gets created every time
+ *  the activity's onStart gets invoked. This is to avoid having the receiver for the entire
+ *  life cycle of the application.
+ *  The applications can be sorted either alphabetically or 
+ *  based on size(descending). If this activity gets launched under low memory
+ *  situations(A low memory notification dispatches intent 
+ *  ACTION_MANAGE_PACKAGE_STORAGE) the list is sorted per size.
+ *  If the user selects an application, extended info(like size, uninstall/clear data options,
+ *  permissions info etc.,) is displayed via the InstalledAppDetails activity.
+ */
+public class ManageApplications extends ListActivity implements
+        OnItemClickListener, DialogInterface.OnCancelListener,
+        DialogInterface.OnClickListener {
+    // TAG for this activity
+    private static final String TAG = "ManageApplications";
+    
+    // Log information boolean
+    private boolean localLOGV = Config.LOGV || false;
+    
+    // attributes used as keys when passing values to InstalledAppDetails activity
+    public static final String APP_PKG_PREFIX = "com.android.settings.";
+    public static final String APP_PKG_NAME = APP_PKG_PREFIX+"ApplicationPkgName";
+    public static final String APP_CHG = APP_PKG_PREFIX+"changed";
+    
+    // attribute name used in receiver for tagging names of added/deleted packages
+    private static final String ATTR_PKG_NAME="PackageName";
+    private static final String ATTR_APP_PKG_STATS="ApplicationPackageStats";
+    
+    // constant value that can be used to check return code from sub activity.
+    private static final int INSTALLED_APP_DETAILS = 1;
+    
+    // sort order that can be changed through the menu can be sorted alphabetically
+    // or size(descending)
+    private static final int MENU_OPTIONS_BASE = 0;
+    public static final int SORT_ORDER_ALPHA = MENU_OPTIONS_BASE + 0;
+    public static final int SORT_ORDER_SIZE = MENU_OPTIONS_BASE + 1;
+    // Filter options used for displayed list of applications
+    public static final int FILTER_APPS_ALL = MENU_OPTIONS_BASE + 2;
+    public static final int FILTER_APPS_THIRD_PARTY = MENU_OPTIONS_BASE + 3;
+    public static final int FILTER_APPS_RUNNING = MENU_OPTIONS_BASE + 4;
+    public static final int FILTER_OPTIONS = MENU_OPTIONS_BASE + 5;
+    // Alert Dialog presented to user to find out the filter option
+    AlertDialog mAlertDlg;
+    // sort order
+    private int mSortOrder = SORT_ORDER_ALPHA;
+    // Filter value
+    int mFilterApps = FILTER_APPS_ALL;
+    
+    // Custom Adapter used for managing items in the list
+    private AppInfoAdapter mAppInfoAdapter;
+    
+    // messages posted to the handler
+    private static final int HANDLER_MESSAGE_BASE = 0;
+    private static final int INIT_PKG_INFO = HANDLER_MESSAGE_BASE+1;
+    private static final int COMPUTE_PKG_SIZE_DONE = HANDLER_MESSAGE_BASE+2;
+    private static final int REMOVE_PKG = HANDLER_MESSAGE_BASE+3;
+    private static final int REORDER_LIST = HANDLER_MESSAGE_BASE+4;
+    private static final int ADD_PKG_START = HANDLER_MESSAGE_BASE+5;
+    private static final int ADD_PKG_DONE = HANDLER_MESSAGE_BASE+6;
+    private static final int REFRESH_ICONS = HANDLER_MESSAGE_BASE+7;
+    private static final int NEXT_LOAD_STEP = HANDLER_MESSAGE_BASE+8;
+    
+    // observer object used for computing pkg sizes
+    private PkgSizeObserver mObserver;
+    // local handle to PackageManager
+    private PackageManager mPm;
+    // Broadcast Receiver object that receives notifications for added/deleted
+    // packages
+    private PackageIntentReceiver mReceiver;
+    // atomic variable used to track if computing pkg sizes is in progress. should be volatile?
+    
+    private boolean mComputeSizes = false;
+    // default icon thats used when displaying applications initially before resource info is
+    // retrieved
+    private Drawable mDefaultAppIcon;
+    
+    // temporary dialog displayed while the application info loads
+    private static final int DLG_BASE = 0;
+    private static final int DLG_LOADING = DLG_BASE + 1;
+    
+    // compute index used to track the application size computations
+    private int mComputeIndex;
+    
+    // Size resource used for packages whose size computation failed for some reason
+    private CharSequence mInvalidSizeStr;
+    private CharSequence mComputingSizeStr;
+    
+    // map used to store list of added and removed packages. Immutable Boolean
+    // variables indicate if a package has been added or removed. If a package is
+    // added or deleted multiple times a single entry with the latest operation will
+    // be recorded in the map.
+    private Map<String, Boolean> mAddRemoveMap;
+    
+    // layout inflater object used to inflate views
+    private LayoutInflater mInflater;
+    
+    // invalid size value used initially and also when size retrieval through PackageManager
+    // fails for whatever reason
+    private static final int SIZE_INVALID = -1;
+    
+    // debug boolean variable to test delays from PackageManager API's
+    private boolean DEBUG_PKG_DELAY = false;
+    
+    // Thread to load resources
+    ResourceLoaderThread mResourceThread;
+    
+    String mCurrentPkgName;
+    
+    //TODO implement a cache system
+    private Map<String, AppInfo> mAppPropCache;
+    
+    // empty message displayed when list is empty
+    private TextView mEmptyView;
+    
+    // Boolean variables indicating state
+    private boolean mLoadLabels = false;
+    private boolean mSizesFirst = false;
+    // ListView used to display list
+    private ListView mListView;
+    // State variables used to figure out menu options and also
+    // initiate the first computation and loading of resources
+    private boolean mJustCreated = true;
+    private boolean mFirst = false;
+    
+    /*
+     * Handler class to handle messages for various operations
+     * Most of the operations that effect Application related data
+     * are posted as messages to the handler to avoid synchronization
+     * when accessing these structures.
+     * When the size retrieval gets kicked off for the first time, a COMPUTE_PKG_SIZE_START
+     * message is posted to the handler which invokes the getSizeInfo for the pkg at index 0
+     * When the PackageManager's asynchronous call back through
+     * PkgSizeObserver.onGetStatsCompleted gets invoked, the application resources like
+     * label, description, icon etc., is loaded in the same thread and these values are
+     * set on the observer. The observer then posts a COMPUTE_PKG_SIZE_DONE message
+     * to the handler. This information is updated on the AppInfoAdapter associated with
+     * the list view of this activity and size info retrieval is initiated for the next package as 
+     * indicated by mComputeIndex
+     * When a package gets added while the activity has focus, the PkgSizeObserver posts
+     * ADD_PKG_START message to the handler.  If the computation is not in progress, the size
+     * is retrieved for the newly added package through the observer object and the newly
+     * installed app info is updated on the screen. If the computation is still in progress
+     * the package is added to an internal structure and action deferred till the computation
+     * is done for all the packages. 
+     * When a package gets deleted, REMOVE_PKG is posted to the handler
+     *  if computation is not in progress(as indicated by
+     * mDoneIniting), the package is deleted from the displayed list of apps. If computation is
+     * still in progress the package is added to an internal structure and action deferred till
+     * the computation is done for all packages.
+     * When the sizes of all packages is computed, the newly
+     * added or removed packages are processed in order.
+     * If the user changes the order in  which these applications are viewed by hitting the
+     * menu key, REORDER_LIST message is posted to the handler. this sorts the list
+     * of items based on the sort order.
+     */
+    private Handler mHandler = new Handler() {
+        public void handleMessage(Message msg) {
+            PackageStats ps;
+            ApplicationInfo info;
+            Bundle data;
+            String pkgName = null;
+            AppInfo appInfo;
+            data = msg.getData();
+            if(data != null) {
+                pkgName = data.getString(ATTR_PKG_NAME);
+            }
+            switch (msg.what) {
+            case INIT_PKG_INFO:
+                if(localLOGV) Log.i(TAG, "Message INIT_PKG_INFO");
+                // Retrieve the package list and init some structures
+                initAppList(mFilterApps);
+                mHandler.sendEmptyMessage(NEXT_LOAD_STEP);
+                break;
+            case COMPUTE_PKG_SIZE_DONE:
+                if(localLOGV) Log.i(TAG, "Message COMPUTE_PKG_SIZE_DONE");
+                if(pkgName == null) {
+                     Log.w(TAG, "Ignoring message");
+                     break;
+                }
+                ps = data.getParcelable(ATTR_APP_PKG_STATS);
+                if(ps == null) {
+                    Log.i(TAG, "Invalid package stats for package:"+pkgName);
+                } else {
+                    int pkgId = mAppInfoAdapter.getIndex(pkgName);
+                    if(mComputeIndex != pkgId) {
+                        //spurious call from stale observer
+                        Log.w(TAG, "Stale call back from PkgSizeObserver");
+                        break;
+                    }
+                    mAppInfoAdapter.updateAppSize(pkgName, ps);
+                }
+                mComputeIndex++;
+                if (mComputeIndex < mAppInfoAdapter.getCount()) {
+                    // initiate compute package size for next pkg in list
+                    mObserver.invokeGetSizeInfo(mAppInfoAdapter.getApplicationInfo(
+                            mComputeIndex), 
+                            COMPUTE_PKG_SIZE_DONE);
+                } else {
+                    // check for added/removed packages
+                    Set<String> keys =  mAddRemoveMap.keySet();
+                    Iterator<String> iter = keys.iterator();
+                    List<String> removeList = new ArrayList<String>();
+                    boolean added = false;
+                    boolean removed = false;
+                    while (iter.hasNext()) {
+                        String key = iter.next();
+                        if (mAddRemoveMap.get(key) == Boolean.TRUE) {
+                            // add
+                            try {
+                                info = mPm.getApplicationInfo(key, 0);
+                                mAppInfoAdapter.addApplicationInfo(info);
+                                added = true;
+                            } catch (NameNotFoundException e) {
+                                Log.w(TAG, "Invalid added package:"+key+" Ignoring entry");
+                            }   
+                        } else {
+                            // remove
+                            removeList.add(key);
+                            removed = true;
+                        }
+                    }
+                    // remove uninstalled packages from list
+                    if (removed) {
+                        mAppInfoAdapter.removeFromList(removeList);
+                    }
+                    // handle newly installed packages
+                    if (added) {
+                        mObserver.invokeGetSizeInfo(mAppInfoAdapter.getApplicationInfo(
+                                mComputeIndex), 
+                                COMPUTE_PKG_SIZE_DONE);
+                    } else {
+                        // end computation here
+                        mComputeSizes = true;
+                        mFirst = true;
+                        mAppInfoAdapter.sortList(mSortOrder);
+                        mHandler.sendEmptyMessage(NEXT_LOAD_STEP);
+                    }
+                }
+                break;
+            case REMOVE_PKG:
+                if(localLOGV) Log.i(TAG, "Message REMOVE_PKG");
+                if(pkgName == null) {
+                    Log.w(TAG, "Ignoring message:REMOVE_PKG for null pkgName");
+                    break;
+                }
+                if (!mComputeSizes) {
+                    Boolean currB = mAddRemoveMap.get(pkgName);
+                    if (currB == null || (currB.equals(Boolean.TRUE))) {
+                        mAddRemoveMap.put(pkgName, Boolean.FALSE);
+                    }
+                    break;
+                }
+                List<String> pkgList = new ArrayList<String>();
+                pkgList.add(pkgName);
+                mAppInfoAdapter.removeFromList(pkgList);
+                break;
+            case REORDER_LIST:
+                if(localLOGV) Log.i(TAG, "Message REORDER_LIST");
+                int menuOption = msg.arg1;
+                if((menuOption == SORT_ORDER_ALPHA) || 
+                        (menuOption == SORT_ORDER_SIZE)) {
+                    // Option to sort list
+                    if (menuOption != mSortOrder) {
+                        mSortOrder = menuOption;
+                        if (localLOGV) Log.i(TAG, "Changing sort order to "+mSortOrder);
+                        mAppInfoAdapter.sortList(mSortOrder);
+                    }
+                } else if(menuOption != mFilterApps) {
+                    // Option to filter list
+                    mFilterApps = menuOption;
+                    boolean ret = mAppInfoAdapter.resetAppList(mFilterApps, 
+                            getInstalledApps(mFilterApps));
+                    if(!ret) {
+                        // Reset cache
+                        mAppPropCache = null;
+                        mFilterApps = FILTER_APPS_ALL;
+                        mHandler.sendEmptyMessage(INIT_PKG_INFO);
+                        sendMessageToHandler(REORDER_LIST, menuOption);
+                    }
+                }
+                break;
+            case ADD_PKG_START:
+                if(localLOGV) Log.i(TAG, "Message ADD_PKG_START");
+                if(pkgName == null) {
+                    Log.w(TAG, "Ignoring message:ADD_PKG_START for null pkgName");
+                    break;
+                }
+                if (!mComputeSizes) {
+                    Boolean currB = mAddRemoveMap.get(pkgName);
+                    if (currB == null || (currB.equals(Boolean.FALSE))) {
+                        mAddRemoveMap.put(pkgName, Boolean.TRUE);
+                    }
+                    break;
+                }
+                try {
+                        info = mPm.getApplicationInfo(pkgName, 0);
+                    } catch (NameNotFoundException e) {
+                        Log.w(TAG, "Couldnt find application info for:"+pkgName);
+                        break;
+                    }
+                mObserver.invokeGetSizeInfo(info, ADD_PKG_DONE);
+                break;
+            case ADD_PKG_DONE:
+                if(localLOGV) Log.i(TAG, "Message COMPUTE_PKG_SIZE_DONE");
+                if(pkgName == null) {
+                    Log.w(TAG, "Ignoring message:ADD_PKG_START for null pkgName");
+                    break;
+                }
+                ps = data.getParcelable(ATTR_APP_PKG_STATS);
+                mAppInfoAdapter.addToList(pkgName, ps);
+                break;
+            case REFRESH_ICONS:
+                Map<String, AppInfo> iconMap = (Map<String, AppInfo>) msg.obj;
+                if(iconMap == null) {
+                    Log.w(TAG, "Error loading icons for applications");
+                } else {
+                    mAppInfoAdapter.updateAppsResourceInfo(iconMap);   
+                }
+                mLoadLabels = true;
+                mHandler.sendEmptyMessage(NEXT_LOAD_STEP);
+                break;
+            case NEXT_LOAD_STEP:
+                if (mComputeSizes && mLoadLabels) {
+                    doneLoadingData();
+                } else if (!mComputeSizes && !mLoadLabels) {
+                     // Either load the package labels or initiate get size info
+                    if (mSizesFirst) {
+                        initComputeSizes();
+                    } else {
+                        initResourceThread();
+                    }
+                } else {
+                    // Create list view from the adapter here. Wait till the sort order
+                    // of list is defined. its either by label or by size. so atleast one of the
+                    // first steps should be complete before filling the list
+                    if (mJustCreated) {
+                        // Set the adapter here.
+                        mJustCreated = false;
+                        mListView.setAdapter(mAppInfoAdapter);
+                        dismissLoadingMsg();
+                    }
+                    if (!mComputeSizes) {
+                        initComputeSizes();
+                    } else if (!mLoadLabels) {
+                        initResourceThread();
+                    }
+                }
+                break;
+            default:
+                break;
+            }
+        }
+    };
+    
+    
+    
+    private void doneLoadingData() {
+        setProgressBarIndeterminateVisibility(false);
+    }
+    
+    List<ApplicationInfo> getInstalledApps(int filterOption) {
+        List<ApplicationInfo> installedAppList = mPm.getInstalledApplications(
+                PackageManager.GET_UNINSTALLED_PACKAGES);
+        if (installedAppList == null) {
+            return new ArrayList<ApplicationInfo> ();
+        }
+        if (filterOption == FILTER_APPS_THIRD_PARTY) {
+            List<ApplicationInfo> appList =new ArrayList<ApplicationInfo> ();
+            for (ApplicationInfo appInfo : installedAppList) {
+                boolean flag = false;
+                if ((appInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) {
+                    // Updated system app
+                    flag = true;
+                } else if ((appInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
+                    // Non-system app
+                    flag = true;
+                }
+                if (flag) {
+                    appList.add(appInfo);
+                }
+            }
+            return appList;
+        } else if (filterOption == FILTER_APPS_RUNNING) {
+            List<ApplicationInfo> appList =new ArrayList<ApplicationInfo> ();
+            List<ActivityManager.RunningAppProcessInfo> procList = getRunningAppProcessesList();
+            if ((procList == null) || (procList.size() == 0)) {
+                return appList;
+            }
+            // Retrieve running processes from ActivityManager
+            for (ActivityManager.RunningAppProcessInfo appProcInfo : procList) {
+                if ((appProcInfo != null)  && (appProcInfo.pkgList != null)){
+                    int size = appProcInfo.pkgList.length;
+                    for (int i = 0; i < size; i++) {
+                        ApplicationInfo appInfo = null;
+                        try {
+                            appInfo = mPm.getApplicationInfo(appProcInfo.pkgList[i], 
+                                    PackageManager.GET_UNINSTALLED_PACKAGES);
+                        } catch (NameNotFoundException e) {
+                           Log.w(TAG, "Error retrieving ApplicationInfo for pkg:"+appProcInfo.pkgList[i]);
+                           continue;
+                        }
+                        if(appInfo != null) {
+                            appList.add(appInfo);
+                        }
+                    }
+                }
+            }
+            return appList;
+        } else {
+            return installedAppList;
+        }
+    }
+    
+    private List<ActivityManager.RunningAppProcessInfo> getRunningAppProcessesList() {
+        ActivityManager am = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
+        return am.getRunningAppProcesses();
+    }
+    
+    // some initialization code used when kicking off the size computation
+    private void initAppList(int filterOption) {
+        setProgressBarIndeterminateVisibility(true);
+        mComputeIndex = 0;
+        mComputeSizes = false;
+        mLoadLabels = false;
+        // Initialize lists
+        List<ApplicationInfo> appList = getInstalledApps(filterOption);
+        mAddRemoveMap = new TreeMap<String, Boolean>();
+        mAppInfoAdapter.resetAppList(filterOption, appList);
+    }
+    
+    // Utility method to start a thread to read application labels and icons
+    private void initResourceThread() {
+        //load resources now
+        if(mResourceThread.isAlive()) {
+            mResourceThread.interrupt();
+        }
+        mResourceThread.loadAllResources(mAppInfoAdapter.getAppList());
+    }
+    
+    private void initComputeSizes() {
+         // initiate compute pkg sizes
+        if (localLOGV) Log.i(TAG, "Initiating compute sizes for first time");
+        if (mAppInfoAdapter.getCount() > 0) {
+            mObserver.invokeGetSizeInfo(mAppInfoAdapter.getApplicationInfo(0),
+                    COMPUTE_PKG_SIZE_DONE);
+        } else {
+            mComputeSizes = true;
+        }
+    }
+    
+    private void showEmptyViewIfListEmpty() {
+        if (localLOGV) Log.i(TAG, "Checking for empty view");
+        if (mAppInfoAdapter.getCount() > 0) {
+            mListView.setVisibility(View.VISIBLE);
+            mEmptyView.setVisibility(View.GONE);
+        } else {
+            mListView.setVisibility(View.GONE);
+            mEmptyView.setVisibility(View.VISIBLE);
+        }
+    }
+    
+    // internal structure used to track added and deleted packages when
+    // the activity has focus
+    class AddRemoveInfo {
+        String pkgName;
+        boolean add;
+        public AddRemoveInfo(String pPkgName, boolean pAdd) {
+            pkgName = pPkgName;
+            add = pAdd;
+        }
+    }
+    
+    class ResourceLoaderThread extends Thread {
+        List<ApplicationInfo> mAppList;
+        
+        void loadAllResources(List<ApplicationInfo> appList) {
+            mAppList = appList;
+            start();
+        }
+
+        public void run() {
+            Map<String, AppInfo> iconMap = new HashMap<String, AppInfo>();
+            if(mAppList == null || mAppList.size() <= 0) {
+                Log.w(TAG, "Empty or null application list");
+            } else {
+                for (ApplicationInfo appInfo : mAppList) {
+                    CharSequence appName = appInfo.loadLabel(mPm);
+                    Drawable appIcon = appInfo.loadIcon(mPm);
+                    iconMap.put(appInfo.packageName, 
+                            new AppInfo(appInfo.packageName, appName, appIcon));
+                }
+            }
+            Message msg = mHandler.obtainMessage(REFRESH_ICONS);
+            msg.obj = iconMap;
+            mHandler.sendMessage(msg);
+        }
+    }
+    
+    /* Internal class representing an application or packages displayable attributes
+     * 
+     */
+    class AppInfo {
+        public String pkgName;
+        int index;
+        public  CharSequence appName;
+        public  Drawable appIcon;
+        public CharSequence appSize;
+        public PackageStats appStats;
+        
+        public void refreshIcon(AppInfo pInfo) {
+            appName = pInfo.appName;
+            appIcon = pInfo.appIcon;
+        }
+
+        public AppInfo(String pName, CharSequence aName, Drawable aIcon) {
+            index = -1;
+            pkgName = pName;
+            appName = aName;
+            appIcon = aIcon;
+            appStats = null;
+            appSize = mComputingSizeStr;
+        }
+        
+        public AppInfo(String pName, int pIndex, CharSequence aName, Drawable aIcon, 
+                PackageStats ps) {
+            index = pIndex;
+            pkgName = pName;
+            appName = aName;
+            appIcon = aIcon;
+            if(ps == null) {
+                appSize = mComputingSizeStr;
+            } else {
+                appStats = ps;
+                appSize = getSizeStr();
+            }
+        }
+        public void setSize(PackageStats ps) {
+            appStats = ps;
+            if (ps != null) {
+                appSize = getSizeStr();
+            }
+        }
+        public long getTotalSize() {
+            PackageStats ps = appStats;
+            if (ps != null) {
+                return ps.cacheSize+ps.codeSize+ps.dataSize;
+            }
+            return SIZE_INVALID;
+        }
+        
+        private String getSizeStr() {
+            PackageStats ps = appStats;
+            String retStr = "";
+            // insert total size information into map to display in view
+            // at this point its guaranteed that ps is not null. but checking anyway
+            if (ps != null) {
+                long size = getTotalSize();
+                if (size == SIZE_INVALID) {
+                    return mInvalidSizeStr.toString();
+                }
+                return Formatter.formatFileSize(ManageApplications.this, size);
+            }
+            return retStr;
+        }
+    }
+    
+    // View Holder used when displaying views
+    static class AppViewHolder {
+        TextView appName;
+        ImageView appIcon;
+        TextView appSize;
+    }
+    
+    /* Custom adapter implementation for the ListView
+     * This adapter maintains a map for each displayed application and its properties
+     * An index value on each AppInfo object indicates the correct position or index
+     * in the list. If the list gets updated dynamically when the user is viewing the list of
+     * applications, we need to return the correct index of position. This is done by mapping
+     * the getId methods via the package name into the internal maps and indices.
+     * The order of applications in the list is mirrored in mAppLocalList
+     */
+    class AppInfoAdapter extends BaseAdapter {
+        private Map<String, AppInfo> mAppPropMap;
+        private List<ApplicationInfo> mAppLocalList;
+        ApplicationInfo.DisplayNameComparator mAlphaComparator;
+        AppInfoComparator mSizeComparator;
+        
+        private AppInfo getFromCache(String packageName) {
+            if(mAppPropCache == null) {
+                return null;
+            }
+            return mAppPropCache.get(packageName);
+        }
+        
+        public AppInfoAdapter(Context c, List<ApplicationInfo> appList) {
+            mAppLocalList = appList;
+            boolean useCache = false;
+            int sortOrder = SORT_ORDER_ALPHA;
+            int imax = mAppLocalList.size();
+            if(mAppPropCache != null) {
+                useCache = true;
+                // Activity has been resumed. can use the cache to populate values initially
+                mAppPropMap = mAppPropCache;
+                sortOrder = mSortOrder;
+            }
+            sortAppList(sortOrder);
+            // Recreate property map
+            mAppPropMap = new TreeMap<String, AppInfo>();
+            for (int i = 0; i < imax; i++) {
+                ApplicationInfo info = mAppLocalList.get(i);
+                AppInfo aInfo = getFromCache(info.packageName);
+                if(aInfo == null){
+                    aInfo = new AppInfo(info.packageName, i, 
+                            info.packageName, mDefaultAppIcon, null);   
+                } else {
+                    aInfo.index = i;
+                }
+                mAppPropMap.put(info.packageName, aInfo);
+            }
+        }
+        
+        public int getCount() {
+            return mAppLocalList.size();
+        }
+        
+        public Object getItem(int position) {
+            return mAppLocalList.get(position);
+        }
+        
+        /*
+         * This method returns the index of the package position in the application list
+         */
+        public int getIndex(String pkgName) {
+            if(pkgName == null) {
+                Log.w(TAG, "Getting index of null package in List Adapter");
+            }
+            int imax = mAppLocalList.size();
+            ApplicationInfo appInfo;
+            for(int i = 0; i < imax; i++) {
+                appInfo = mAppLocalList.get(i);
+                if(appInfo.packageName.equalsIgnoreCase(pkgName)) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+        
+        public ApplicationInfo getApplicationInfo(int position) {
+            int imax = mAppLocalList.size();
+            if( (position < 0) || (position >= imax)) {
+                Log.w(TAG, "Position out of bounds in List Adapter");
+                return null;
+            }
+            return mAppLocalList.get(position);
+        }
+        
+        public void addApplicationInfo(ApplicationInfo info) {
+            if(info == null) {
+                Log.w(TAG, "Ignoring null add in List Adapter");
+                return;
+            }
+            mAppLocalList.add(info);
+        }
+
+        public long getItemId(int position) {
+            int imax = mAppLocalList.size();
+            if( (position < 0) || (position >= imax)) {
+                Log.w(TAG, "Position out of bounds in List Adapter");
+                return -1;
+            }
+            return mAppPropMap.get(mAppLocalList.get(position).packageName).index;
+        }
+        
+        public List<ApplicationInfo> getAppList() {
+            return mAppLocalList;
+        }
+        
+        public View getView(int position, View convertView, ViewGroup parent) {
+            if (position >= mAppLocalList.size()) {
+                Log.w(TAG, "Invalid view position:"+position+", actual size is:"+mAppLocalList.size());
+                return null;
+            }
+            // A ViewHolder keeps references to children views to avoid unneccessary calls
+            // to findViewById() on each row.
+            AppViewHolder holder;
+
+            // When convertView is not null, we can reuse it directly, there is no need
+            // to reinflate it. We only inflate a new View when the convertView supplied
+            // by ListView is null.
+            if (convertView == null) {
+                convertView = mInflater.inflate(R.layout.manage_applications_item, null);
+
+                // Creates a ViewHolder and store references to the two children views
+                // we want to bind data to.
+                holder = new AppViewHolder();
+                holder.appName = (TextView) convertView.findViewById(R.id.app_name);
+                holder.appIcon = (ImageView) convertView.findViewById(R.id.app_icon);
+                holder.appSize = (TextView) convertView.findViewById(R.id.app_size);
+                convertView.setTag(holder);
+            } else {
+                // Get the ViewHolder back to get fast access to the TextView
+                // and the ImageView.
+                holder = (AppViewHolder) convertView.getTag();
+            }
+
+            // Bind the data efficiently with the holder
+            ApplicationInfo appInfo = mAppLocalList.get(position);
+            AppInfo mInfo = mAppPropMap.get(appInfo.packageName);
+            if(mInfo != null) {
+                if(mInfo.appName != null) {
+                    holder.appName.setText(mInfo.appName);
+                }
+                if(mInfo.appIcon != null) {
+                    holder.appIcon.setImageDrawable(mInfo.appIcon);
+                }
+                if (mInfo.appSize != null) {
+                    holder.appSize.setText(mInfo.appSize);
+                }
+            } else {
+                Log.w(TAG, "No info for package:"+appInfo.packageName+" in property map");
+            }
+            return convertView;
+        }
+        
+        private void adjustIndex() {
+            int imax = mAppLocalList.size();
+            ApplicationInfo info;
+            for (int i = 0; i < imax; i++) {
+                info = mAppLocalList.get(i);
+                mAppPropMap.get(info.packageName).index = i;
+            }
+        }
+        
+        public void sortAppList(int sortOrder) {
+            Collections.sort(mAppLocalList, getAppComparator(sortOrder));
+        }
+        
+        public void sortList(int sortOrder) {
+            sortAppList(sortOrder);
+            adjustIndex();
+            notifyDataSetChanged();
+        }
+        
+        public boolean resetAppList(int filterOption, List<ApplicationInfo> appList) {
+           // Create application list based on the filter value
+           mAppLocalList = appList;
+           // Check for all properties in map before sorting. Populate values from cache
+           for(ApplicationInfo applicationInfo : mAppLocalList) {
+               AppInfo appInfo = mAppPropMap.get(applicationInfo.packageName);
+               if(appInfo == null) {
+                   AppInfo rInfo = getFromCache(applicationInfo.packageName);
+                   if(rInfo == null) {
+                       // Need to load resources again. Inconsistency somewhere
+                       return false;
+                   }
+                   mAppPropMap.put(applicationInfo.packageName, rInfo);
+               }
+           }
+           if (mAppLocalList.size() > 0) {
+               sortList(mSortOrder);
+           } else {
+               notifyDataSetChanged();
+           }
+           showEmptyViewIfListEmpty();
+           return true;
+        }
+        
+        private Comparator<ApplicationInfo> getAppComparator(int sortOrder) {
+            if (sortOrder == SORT_ORDER_ALPHA) {
+                // Lazy initialization
+                if (mAlphaComparator == null) {
+                    mAlphaComparator = new ApplicationInfo.DisplayNameComparator(mPm);
+                }
+                return mAlphaComparator;
+            }
+            // Lazy initialization
+            if(mSizeComparator == null) {
+                mSizeComparator = new AppInfoComparator(mAppPropMap);
+            }
+            return mSizeComparator;
+        }
+        
+        public void updateAppsResourceInfo(Map<String, AppInfo> iconMap) {
+            if(iconMap == null) {
+                Log.w(TAG, "Null iconMap when refreshing icon in List Adapter");
+                return;
+            }
+            boolean changed = false;
+            for (ApplicationInfo info : mAppLocalList) {
+                AppInfo pInfo = iconMap.get(info.packageName);
+                if(pInfo != null) {
+                    AppInfo aInfo = mAppPropMap.get(info.packageName);
+                    if (aInfo != null) {
+                        aInfo.refreshIcon(pInfo);
+                    } else {
+                        mAppPropMap.put(info.packageName, pInfo);
+                    }
+                    changed = true;
+                }
+            }
+            if(changed) {
+                notifyDataSetChanged();
+            }
+        }
+        
+        public void addToList(String pkgName, PackageStats ps) {
+            if(pkgName == null) {
+                Log.w(TAG, "Adding null pkg to List Adapter");
+                return;
+            }
+            ApplicationInfo info;
+            try {
+                info = mPm.getApplicationInfo(pkgName, 0);
+            } catch (NameNotFoundException e) {
+                Log.w(TAG, "Ignoring non-existent package:"+pkgName);
+                return;
+            }
+            if(info == null) {
+                // Nothing to do log error message and return
+                Log.i(TAG, "Null ApplicationInfo for package:"+pkgName);
+                return;
+            }
+            // Binary search returns a negative index (ie --index) of the position where
+            // this might be inserted. 
+            int newIdx = Collections.binarySearch(mAppLocalList, info, 
+                    getAppComparator(mSortOrder));
+            if(newIdx >= 0) {
+                Log.i(TAG, "Strange. Package:"+pkgName+" is not new");
+                return;
+            }
+            // New entry
+            newIdx = -newIdx-1;
+            mAppLocalList.add(newIdx, info);
+            mAppPropMap.put(info.packageName, new AppInfo(pkgName, newIdx,
+                    info.loadLabel(mPm), info.loadIcon(mPm), ps));
+            adjustIndex();
+            notifyDataSetChanged();
+        }
+        
+        public void removeFromList(List<String> pkgNames) {
+            if(pkgNames == null) {
+                Log.w(TAG, "Removing null pkg list from List Adapter");
+                return;
+            }
+            int imax = mAppLocalList.size();
+            boolean found = false;
+            ApplicationInfo info;
+            int i, k;
+            String pkgName;
+            int kmax = pkgNames.size();
+            if(kmax  <= 0) {
+                Log.w(TAG, "Removing empty pkg list from List Adapter");
+                return;
+            }
+            int idxArr[] = new int[kmax];
+            for (k = 0; k < kmax; k++) {
+                idxArr[k] = -1;
+            }
+            for (i = 0; i < imax; i++) {
+                info = mAppLocalList.get(i);
+                for (k = 0; k < kmax; k++) {
+                    pkgName = pkgNames.get(k);
+                    if (info.packageName.equalsIgnoreCase(pkgName)) {
+                        idxArr[k] = i;
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            // Sort idxArr
+            Arrays.sort(idxArr);
+            // remove the packages based on decending indices
+            for (k = kmax-1; k >= 0; k--) {
+                // Check if package has been found in the list of existing apps first
+                if(idxArr[k] == -1) {
+                    break;
+                }
+                info = mAppLocalList.get(idxArr[k]);
+                mAppLocalList.remove(idxArr[k]);
+                mAppPropMap.remove(info.packageName);
+                if (localLOGV) Log.i(TAG, "Removed pkg:"+info.packageName+ " list");
+            }
+            if (found) {
+                adjustIndex();
+                notifyDataSetChanged();
+            }
+        }   
+        
+        public void updateAppSize(String pkgName, PackageStats ps) {
+            if(pkgName == null) {
+                return;
+            }
+            AppInfo entry = mAppPropMap.get(pkgName);
+            if (entry == null) {
+                Log.w(TAG, "Entry for package:"+pkgName+"doesnt exist in map");
+                return;
+            }
+            // Copy the index into the newly updated entry
+            entry.setSize(ps);
+            notifyDataSetChanged();
+        }
+
+        public PackageStats getAppStats(String pkgName) {
+            if(pkgName == null) {
+                return null;
+            }
+            AppInfo entry = mAppPropMap.get(pkgName);
+            if (entry == null) {
+                return null;
+            }
+            return entry.appStats;
+        }
+    }
+    
+    /*
+     * Utility method to clear messages to Handler
+     * We need'nt synchronize on the Handler since posting messages is guaranteed
+     * to be thread safe. Even if the other thread that retrieves package sizes
+     * posts a message, we do a cursory check of validity on mAppInfoAdapter's applist
+     */
+    private void clearMessagesInHandler() {
+        mHandler.removeMessages(INIT_PKG_INFO);
+        mHandler.removeMessages(COMPUTE_PKG_SIZE_DONE);
+        mHandler.removeMessages(REMOVE_PKG);
+        mHandler.removeMessages(REORDER_LIST);
+        mHandler.removeMessages(ADD_PKG_START);
+        mHandler.removeMessages(ADD_PKG_DONE);
+    }
+    
+    private void sendMessageToHandler(int msgId, int arg1) {
+        Message msg = mHandler.obtainMessage(msgId);
+        msg.arg1 = arg1;
+        mHandler.sendMessage(msg);
+    }
+    
+    private void sendMessageToHandler(int msgId, Bundle data) {
+        Message msg = mHandler.obtainMessage(msgId);
+        msg.setData(data);
+        mHandler.sendMessage(msg);
+    }
+    
+    private void sendMessageToHandler(int msgId) {
+        mHandler.sendEmptyMessage(msgId);
+    }
+    
+    /*
+     * Stats Observer class used to compute package sizes and retrieve size information
+     * PkgSizeOberver is the call back thats used when invoking getPackageSizeInfo on
+     * PackageManager. The values in call back onGetStatsCompleted are validated
+     * and the specified message is passed to mHandler. The package name
+     * and the AppInfo object corresponding to the package name are set on the message
+     */
+    class PkgSizeObserver extends IPackageStatsObserver.Stub {
+        private ApplicationInfo mAppInfo;
+        private int mMsgId; 
+        public void onGetStatsCompleted(PackageStats pStats, boolean pSucceeded) {
+            if(DEBUG_PKG_DELAY) {
+                try {
+                    Thread.sleep(10*1000);
+                } catch (InterruptedException e) {
+                }
+            }
+            AppInfo appInfo = null;
+            Bundle data = new Bundle();
+            data.putString(ATTR_PKG_NAME, mAppInfo.packageName);
+            if(pSucceeded && pStats != null) {
+                if (localLOGV) Log.i(TAG, "onGetStatsCompleted::"+pStats.packageName+", ("+
+                        pStats.cacheSize+","+
+                        pStats.codeSize+", "+pStats.dataSize);
+                data.putParcelable(ATTR_APP_PKG_STATS, pStats);
+            } else {
+                Log.w(TAG, "Invalid package stats from PackageManager");
+            }
+            //post message to Handler
+            Message msg = mHandler.obtainMessage(mMsgId, data);
+            msg.setData(data);
+            mHandler.sendMessage(msg);
+        }
+
+        public void invokeGetSizeInfo(ApplicationInfo pAppInfo, int msgId) {
+            if(pAppInfo == null || pAppInfo.packageName == null) {
+                return;
+            }
+            if(localLOGV) Log.i(TAG, "Invoking getPackageSizeInfo for package:"+
+                    pAppInfo.packageName);
+            mMsgId = msgId;
+            mAppInfo = pAppInfo;
+            mPm.getPackageSizeInfo(pAppInfo.packageName, this);
+        }
+    }
+    
+    /**
+     * Receives notifications when applications are added/removed.
+     */
+    private class PackageIntentReceiver extends BroadcastReceiver {
+         void registerReceiver() {
+             IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);
+             filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
+             filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
+             filter.addDataScheme("package");
+             ManageApplications.this.registerReceiver(this, filter);
+         }
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String actionStr = intent.getAction();
+            Uri data = intent.getData();
+            String pkgName = data.getEncodedSchemeSpecificPart();
+            if (localLOGV) Log.i(TAG, "action:"+actionStr+", for package:"+pkgName);
+            updatePackageList(actionStr, pkgName);
+        }
+    }
+    
+    private void updatePackageList(String actionStr, String pkgName) {
+        // technically we dont have to invoke handler since onReceive is invoked on
+        // the main thread but doing it here for better clarity
+        if (Intent.ACTION_PACKAGE_ADDED.equalsIgnoreCase(actionStr)) {
+            Bundle data = new Bundle();
+            data.putString(ATTR_PKG_NAME, pkgName);
+            sendMessageToHandler(ADD_PKG_START, data);
+        } else if (Intent.ACTION_PACKAGE_REMOVED.equalsIgnoreCase(actionStr)) {
+            Bundle data = new Bundle();
+            data.putString(ATTR_PKG_NAME, pkgName);
+            sendMessageToHandler(REMOVE_PKG, data);
+        }
+    }
+    
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        Intent lIntent = getIntent();
+        String action = lIntent.getAction();
+        if (action.equals(Intent.ACTION_MANAGE_PACKAGE_STORAGE)) {
+            mSortOrder = SORT_ORDER_SIZE;
+            mSizesFirst = true;
+        }
+        mPm = getPackageManager();
+        // initialize some window features
+        requestWindowFeature(Window.FEATURE_RIGHT_ICON);
+        requestWindowFeature(Window.FEATURE_PROGRESS);
+        requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
+        setContentView(R.layout.compute_sizes);
+        mDefaultAppIcon =Resources.getSystem().getDrawable(
+                com.android.internal.R.drawable.sym_def_app_icon);
+        mInvalidSizeStr = getText(R.string.invalid_size_value);
+        mComputingSizeStr = getText(R.string.computing_size);
+        // initialize the inflater
+        mInflater = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+        mReceiver = new PackageIntentReceiver();
+        mEmptyView = (TextView) findViewById(R.id.empty_view);
+        mObserver = new PkgSizeObserver();
+        // Create adapter and list view here
+        List<ApplicationInfo> appList = getInstalledApps(mSortOrder);
+        mAppInfoAdapter = new AppInfoAdapter(this, appList);
+        ListView lv= (ListView) findViewById(android.R.id.list);
+        //lv.setAdapter(mAppInfoAdapter);
+        lv.setOnItemClickListener(this);
+        lv.setSaveEnabled(true);
+        lv.setItemsCanFocus(true);
+        lv.setOnItemClickListener(this);
+        mListView = lv;
+        showLoadingMsg();
+    }
+    
+    @Override
+    public Dialog onCreateDialog(int id) {
+        if (id == DLG_LOADING) {
+            ProgressDialog dlg = new ProgressDialog(this);
+            dlg.setProgressStyle(ProgressDialog.STYLE_SPINNER);
+            dlg.setMessage(getText(R.string.loading));
+            dlg.setIndeterminate(true);        
+            dlg.setOnCancelListener(this);
+            return dlg;
+        }
+        return null;
+    }
+    
+    
+    private void showLoadingMsg() {
+        showDialog(DLG_LOADING);
+        if(localLOGV) Log.i(TAG, "Displaying Loading message");
+    }
+    
+    private void dismissLoadingMsg() {
+        if(localLOGV) Log.i(TAG, "Dismissing Loading message");
+        dismissDialog(DLG_LOADING);
+    }
+    
+    @Override
+    public void onStart() {
+        super.onStart();
+        // Create a thread to load resources
+        mResourceThread = new ResourceLoaderThread();
+        sendMessageToHandler(INIT_PKG_INFO);
+        // register receiver
+        mReceiver.registerReceiver();
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+        // clear all messages related to application list
+        clearMessagesInHandler();
+        // register receiver here
+        unregisterReceiver(mReceiver);        
+        mAppPropCache = mAppInfoAdapter.mAppPropMap;
+    }
+    
+    // Avoid the restart and pause when orientation changes
+    @Override
+    public void onConfigurationChanged(Configuration newConfig) {
+        super.onConfigurationChanged(newConfig);
+    }
+    
+    /*
+     * comparator class used to sort AppInfo objects based on size
+     */
+    public static class AppInfoComparator implements Comparator<ApplicationInfo> {
+        public AppInfoComparator(Map<String, AppInfo> pAppPropMap) {
+            mAppPropMap= pAppPropMap;
+        }
+
+        public final int compare(ApplicationInfo a, ApplicationInfo b) {
+            AppInfo ainfo = mAppPropMap.get(a.packageName);
+            AppInfo binfo = mAppPropMap.get(b.packageName);
+            long atotal = ainfo.getTotalSize();
+            long btotal = binfo.getTotalSize();
+            long ret = atotal - btotal;
+            // negate result to sort in descending order
+            if (ret < 0) {
+                return 1;
+            }
+            if (ret == 0) {
+                return 0;
+            }
+            return -1;
+        }
+        private Map<String, AppInfo> mAppPropMap;
+    }
+     
+    // utility method used to start sub activity
+    private void startApplicationDetailsActivity() {
+        // Create intent to start new activity
+        Intent intent = new Intent(Intent.ACTION_VIEW);
+        intent.setClass(this, InstalledAppDetails.class);
+        intent.putExtra(APP_PKG_NAME, mCurrentPkgName);
+        // start new activity to display extended information
+        startActivityForResult(intent, INSTALLED_APP_DETAILS);
+    }
+    
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        menu.add(0, SORT_ORDER_ALPHA, 1, R.string.sort_order_alpha)
+                .setIcon(android.R.drawable.ic_menu_sort_alphabetically);
+        menu.add(0, SORT_ORDER_SIZE, 2, R.string.sort_order_size)
+                .setIcon(android.R.drawable.ic_menu_sort_by_size); 
+        menu.add(0, FILTER_OPTIONS, 3, R.string.filter)
+                .setIcon(R.drawable.ic_menu_filter_settings);
+        return true;
+    }
+    
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        if (mFirst) {
+            menu.findItem(SORT_ORDER_ALPHA).setVisible(mSortOrder != SORT_ORDER_ALPHA);
+            menu.findItem(SORT_ORDER_SIZE).setVisible(mSortOrder != SORT_ORDER_SIZE);
+            menu.findItem(FILTER_OPTIONS).setVisible(true);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        int menuId = item.getItemId();
+        if ((menuId == SORT_ORDER_ALPHA) || (menuId == SORT_ORDER_SIZE)) {
+            sendMessageToHandler(REORDER_LIST, menuId);
+        } else if (menuId == FILTER_OPTIONS) {
+            if (mAlertDlg == null) {
+                mAlertDlg = new AlertDialog.Builder(this).
+                        setTitle(R.string.filter_dlg_title).
+                        setNeutralButton(R.string.cancel, this).
+                        setSingleChoiceItems(new CharSequence[] {getText(R.string.filter_apps_all),
+                                getText(R.string.filter_apps_running),
+                                getText(R.string.filter_apps_third_party)},
+                                -1, this).
+                        create();
+            }
+            mAlertDlg.show();
+        }
+        return true;
+    }
+
+    public void onItemClick(AdapterView<?> parent, View view, int position,
+            long id) {
+        ApplicationInfo info = (ApplicationInfo)mAppInfoAdapter.getItem(position);
+        mCurrentPkgName = info.packageName;
+        startApplicationDetailsActivity();
+    }
+    
+    // Finish the activity if the user presses the back button to cancel the activity
+    public void onCancel(DialogInterface dialog) {
+        finish();
+    }
+
+    public void onClick(DialogInterface dialog, int which) {
+        int newOption;
+        switch (which) {
+        // Make sure that values of 0, 1, 2 match options all, running, third_party when
+        // created via the AlertDialog.Builder
+        case 0:
+            newOption = FILTER_APPS_ALL;
+            break;
+        case 1:
+            newOption = FILTER_APPS_RUNNING;
+            break;
+        case 2:
+            newOption = FILTER_APPS_THIRD_PARTY;
+            break;
+        default:
+            return;
+        }
+        mAlertDlg.dismiss();
+        sendMessageToHandler(REORDER_LIST, newOption);
+    }
+}
diff --git a/src/com/android/settings/MasterClear.java b/src/com/android/settings/MasterClear.java
new file mode 100644
index 0000000..38ad608
--- /dev/null
+++ b/src/com/android/settings/MasterClear.java
@@ -0,0 +1,205 @@
+/*
+ * 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.settings;
+
+import com.android.internal.widget.LockPatternUtils;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.ICheckinService;
+import android.os.ServiceManager;
+import android.os.SystemProperties;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.Button;
+
+/**
+ * Confirm and execute a reset of the device to a clean "just out of the box"
+ * state.  Multiple confirmations are required: first, a general "are you sure
+ * you want to do this?" prompt, followed by a keyguard pattern trace if the user
+ * has defined one, followed by a final strongly-worded "THIS WILL ERASE EVERYTHING
+ * ON THE PHONE" prompt.  If at any time the phone is allowed to go to sleep, is
+ * locked, et cetera, then the confirmation sequence is abandoned.
+ */
+public class MasterClear extends Activity {
+
+    private static final int KEYGUARD_REQUEST = 55;
+
+    private LayoutInflater mInflater;
+    private LockPatternUtils mLockUtils;
+
+    private View mInitialView;
+    private Button mInitiateButton;
+
+    private View mFinalView;
+    private Button mFinalButton;
+
+    /** 
+     * The user has gone through the multiple confirmation, so now we go ahead
+     * and invoke the Checkin Service to reset the device to its factory-default
+     * state (rebooting in the process).
+     */
+    private Button.OnClickListener mFinalClickListener = new Button.OnClickListener() {
+            public void onClick(View v) {
+                
+                // Those monkeys kept committing suicide, so we add this property
+                // to disable going through with the master clear
+                if (!TextUtils.isEmpty(SystemProperties.get("ro.monkey"))) {
+                    return;
+                }
+                
+                ICheckinService service = 
+                        ICheckinService.Stub.asInterface(ServiceManager.getService("checkin"));
+                if (service != null) {
+                    try {
+                        // This RPC should never return
+                        service.masterClear();
+                    } catch (android.os.RemoteException e) {
+                        // Intentionally blank - there's nothing we can do here
+                        Log.w("MasterClear", "Unable to invoke ICheckinService.masterClear()");
+                    }
+                } else {
+                    Log.w("MasterClear", "Unable to locate ICheckinService");
+                }
+
+                /* If we reach this point, the master clear didn't happen -- the
+                 * service might have been unregistered with the ServiceManager,
+                 * the RPC might have thrown an exception, or for some reason
+                 * the implementation of masterClear() may have returned instead
+                 * of resetting the device.
+                 */
+                new AlertDialog.Builder(MasterClear.this)
+                        .setMessage(getText(R.string.master_clear_failed))
+                        .setPositiveButton(getText(android.R.string.ok), null)
+                        .show();
+            }
+        };
+
+    /**
+     *  Keyguard validation is run using the standard {@link ConfirmLockPattern}
+     * component as a subactivity
+     */
+    private void runKeyguardConfirmation() {
+        final Intent intent = new Intent();
+        intent.setClassName("com.android.settings",
+                "com.android.settings.ConfirmLockPattern");
+        // supply header and footer text in the intent
+        intent.putExtra(ConfirmLockPattern.HEADER_TEXT,
+                getText(R.string.master_clear_gesture_prompt));
+        intent.putExtra(ConfirmLockPattern.FOOTER_TEXT,
+                getText(R.string.master_clear_gesture_explanation));
+        startActivityForResult(intent, KEYGUARD_REQUEST);
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+
+        if (requestCode != KEYGUARD_REQUEST) {
+            return;
+        }
+
+        // If the user entered a valid keyguard trace, present the final
+        // confirmation prompt; otherwise, go back to the initial state.
+        if (resultCode == Activity.RESULT_OK) {
+            establishFinalConfirmationState();
+        } else {
+            establishInitialState();
+        }
+    }
+
+    /**
+     * If the user clicks to begin the reset sequence, we next require a
+     * keyguard confirmation if the user has currently enabled one.  If there
+     * is no keyguard available, we simply go to the final confirmation prompt.
+     */
+    private Button.OnClickListener mInitiateListener = new Button.OnClickListener() {
+            public void onClick(View v) {
+                if (mLockUtils.isLockPatternEnabled()) {
+                    runKeyguardConfirmation();
+                } else {
+                    establishFinalConfirmationState();
+                }
+            }
+        };
+
+    /**
+     * Configure the UI for the final confirmation interaction
+     */
+    private void establishFinalConfirmationState() {
+        if (mFinalView == null) {
+            mFinalView = mInflater.inflate(R.layout.master_clear_final, null);
+            mFinalButton =
+                    (Button) mFinalView.findViewById(R.id.execute_master_clear);
+            mFinalButton.setOnClickListener(mFinalClickListener);
+        }
+
+        setContentView(mFinalView);
+    }
+
+    /**
+     * In its initial state, the activity presents a button for the user to
+     * click in order to initiate a confirmation sequence.  This method is
+     * called from various other points in the code to reset the activity to
+     * this base state.
+     * 
+     * <p>Reinflating views from resources is expensive and prevents us from
+     * caching widget pointers, so we use a single-inflate pattern:  we lazy-
+     * inflate each view, caching all of the widget pointers we'll need at the
+     * time, then simply reuse the inflated views directly whenever we need
+     * to change contents.
+     */
+    private void establishInitialState() {
+        if (mInitialView == null) {
+            mInitialView = mInflater.inflate(R.layout.master_clear_primary, null);
+            mInitiateButton =
+                    (Button) mInitialView.findViewById(R.id.initiate_master_clear);
+            mInitiateButton.setOnClickListener(mInitiateListener);
+        }
+
+        setContentView(mInitialView);
+    }
+
+    @Override
+    protected void onCreate(Bundle savedState) {
+        super.onCreate(savedState);
+
+        mInitialView = null;
+        mFinalView = null;
+        mInflater = LayoutInflater.from(this);
+        mLockUtils = new LockPatternUtils(getContentResolver());
+
+        establishInitialState();
+    }
+
+    /** Abandon all progress through the confirmation sequence by returning
+     * to the initial view any time the activity is interrupted (e.g. by
+     * idle timeout).
+     */
+    @Override
+    public void onPause() {
+        super.onPause();
+
+        establishInitialState();
+    }
+
+}
diff --git a/src/com/android/settings/MediaFormat.java b/src/com/android/settings/MediaFormat.java
new file mode 100644
index 0000000..3594572
--- /dev/null
+++ b/src/com/android/settings/MediaFormat.java
@@ -0,0 +1,193 @@
+/*
+ * 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.settings;
+
+import com.android.internal.widget.LockPatternUtils;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.IMountService;
+import android.os.ServiceManager;
+import android.os.SystemProperties;
+import android.os.Environment;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.Button;
+
+/**
+ * Confirm and execute a format of the sdcard.
+ * Multiple confirmations are required: first, a general "are you sure
+ * you want to do this?" prompt, followed by a keyguard pattern trace if the user
+ * has defined one, followed by a final strongly-worded "THIS WILL ERASE EVERYTHING
+ * ON THE SD CARD" prompt.  If at any time the phone is allowed to go to sleep, is
+ * locked, et cetera, then the confirmation sequence is abandoned.
+ */
+public class MediaFormat extends Activity {
+
+    private static final int KEYGUARD_REQUEST = 55;
+
+    private LayoutInflater mInflater;
+    private LockPatternUtils mLockUtils;
+
+    private View mInitialView;
+    private Button mInitiateButton;
+
+    private View mFinalView;
+    private Button mFinalButton;
+
+    /** 
+     * The user has gone through the multiple confirmation, so now we go ahead
+     * and invoke the Mount Service to format the SD card.
+     */
+    private Button.OnClickListener mFinalClickListener = new Button.OnClickListener() {
+            public void onClick(View v) {
+                
+                // Those monkeys kept committing suicide, so we add this property
+                // to disable going through with the format
+                if (!TextUtils.isEmpty(SystemProperties.get("ro.monkey"))) {
+                    return;
+                }
+                IMountService service =
+                        IMountService.Stub.asInterface(ServiceManager.getService("mount"));
+                if (service != null) {
+                    try {
+                        service.formatMedia(Environment.getExternalStorageDirectory().toString());
+                    } catch (android.os.RemoteException e) {
+                        // Intentionally blank - there's nothing we can do here
+                        Log.w("MediaFormat", "Unable to invoke IMountService.formatMedia()");
+                    }
+                } else {
+                    Log.w("MediaFormat", "Unable to locate IMountService");
+                }
+            finish();
+            }
+        };
+
+    /**
+     *  Keyguard validation is run using the standard {@link ConfirmLockPattern}
+     * component as a subactivity
+     */
+    private void runKeyguardConfirmation() {
+        final Intent intent = new Intent();
+        intent.setClassName("com.android.settings",
+                "com.android.settings.ConfirmLockPattern");
+        // supply header and footer text in the intent
+        intent.putExtra(ConfirmLockPattern.HEADER_TEXT,
+                getText(R.string.media_format_gesture_prompt));
+        intent.putExtra(ConfirmLockPattern.FOOTER_TEXT,
+                getText(R.string.media_format_gesture_explanation));
+        startActivityForResult(intent, KEYGUARD_REQUEST);
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+
+        if (requestCode != KEYGUARD_REQUEST) {
+            return;
+        }
+
+        // If the user entered a valid keyguard trace, present the final
+        // confirmation prompt; otherwise, go back to the initial state.
+        if (resultCode == Activity.RESULT_OK) {
+            establishFinalConfirmationState();
+        } else {
+            establishInitialState();
+        }
+    }
+
+    /**
+     * If the user clicks to begin the reset sequence, we next require a
+     * keyguard confirmation if the user has currently enabled one.  If there
+     * is no keyguard available, we simply go to the final confirmation prompt.
+     */
+    private Button.OnClickListener mInitiateListener = new Button.OnClickListener() {
+            public void onClick(View v) {
+                if (mLockUtils.isLockPatternEnabled()) {
+                    runKeyguardConfirmation();
+                } else {
+                    establishFinalConfirmationState();
+                }
+            }
+        };
+
+    /**
+     * Configure the UI for the final confirmation interaction
+     */
+    private void establishFinalConfirmationState() {
+        if (mFinalView == null) {
+            mFinalView = mInflater.inflate(R.layout.media_format_final, null);
+            mFinalButton =
+                    (Button) mFinalView.findViewById(R.id.execute_media_format);
+            mFinalButton.setOnClickListener(mFinalClickListener);
+        }
+
+        setContentView(mFinalView);
+    }
+
+    /**
+     * In its initial state, the activity presents a button for the user to
+     * click in order to initiate a confirmation sequence.  This method is
+     * called from various other points in the code to reset the activity to
+     * this base state.
+     * 
+     * <p>Reinflating views from resources is expensive and prevents us from
+     * caching widget pointers, so we use a single-inflate pattern:  we lazy-
+     * inflate each view, caching all of the widget pointers we'll need at the
+     * time, then simply reuse the inflated views directly whenever we need
+     * to change contents.
+     */
+    private void establishInitialState() {
+        if (mInitialView == null) {
+            mInitialView = mInflater.inflate(R.layout.media_format_primary, null);
+            mInitiateButton =
+                    (Button) mInitialView.findViewById(R.id.initiate_media_format);
+            mInitiateButton.setOnClickListener(mInitiateListener);
+        }
+
+        setContentView(mInitialView);
+    }
+
+    @Override
+    protected void onCreate(Bundle savedState) {
+        super.onCreate(savedState);
+
+        mInitialView = null;
+        mFinalView = null;
+        mInflater = LayoutInflater.from(this);
+        mLockUtils = new LockPatternUtils(getContentResolver());
+
+        establishInitialState();
+    }
+
+    /** Abandon all progress through the confirmation sequence by returning
+     * to the initial view any time the activity is interrupted (e.g. by
+     * idle timeout).
+     */
+    @Override
+    public void onPause() {
+        super.onPause();
+
+        establishInitialState();
+    }
+
+}
diff --git a/src/com/android/settings/ProgressCategory.java b/src/com/android/settings/ProgressCategory.java
new file mode 100644
index 0000000..15810b3
--- /dev/null
+++ b/src/com/android/settings/ProgressCategory.java
@@ -0,0 +1,55 @@
+/*
+ * 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.settings;
+
+import android.content.Context;
+import android.preference.PreferenceCategory;
+import android.util.AttributeSet;
+import android.view.View;
+
+import java.util.Map;
+
+public class ProgressCategory extends PreferenceCategory {
+
+    private boolean mProgress = false;
+    
+    public ProgressCategory(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        setLayoutResource(R.layout.preference_progress_category);
+    }
+    
+    @Override
+    public void onBindView(View view) {
+        super.onBindView(view);
+        View textView = view.findViewById(R.id.scanning_text);
+        View progressBar = view.findViewById(R.id.scanning_progress);
+
+        int visibility = mProgress ? View.VISIBLE : View.INVISIBLE;
+        textView.setVisibility(visibility);
+        progressBar.setVisibility(visibility);
+    }
+    
+    /**
+     * Turn on/off the progress indicator and text on the right.
+     * @param progressOn whether or not the progress should be displayed 
+     */
+    public void setProgress(boolean progressOn) {
+        mProgress = progressOn;
+        notifyChanged();
+    }
+}
+
diff --git a/src/com/android/settings/ProxySelector.java b/src/com/android/settings/ProxySelector.java
new file mode 100644
index 0000000..80fe3c9
--- /dev/null
+++ b/src/com/android/settings/ProxySelector.java
@@ -0,0 +1,260 @@
+/*
+ * 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.settings;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.net.Proxy;
+import android.os.Bundle;
+import android.provider.Settings;
+import android.text.Selection;
+import android.text.Spannable;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnFocusChangeListener;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.TextView;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * To start the Proxy Selector activity, create the following intent.
+ *
+ * <code>
+ *      Intent intent = new Intent();
+ *      intent.setClassName("com.android.browser.ProxySelector");
+ *      startActivity(intent);
+ * </code>
+ *
+ * you can add extra options to the intent by using
+ *
+ * <code>
+ *   intent.putExtra(key, value);
+ * </code>
+ *
+ * the extra options are:
+ *
+ * button-label: a string label to display for the okay button
+ * title:        the title of the window
+ * error-text:   If not null, will be used as the label of the error message.
+ */
+public class ProxySelector extends Activity
+{
+    private final static String LOGTAG = "Settings";
+
+    EditText    mHostnameField;
+    EditText    mPortField;
+    Button      mOKButton;
+
+    // Matches blank input, ips, and domain names
+    private static final String HOSTNAME_REGEXP = "^$|^[a-zA-Z0-9]+(\\-[a-zA-Z0-9]+)*(\\.[a-zA-Z0-9]+(\\-[a-zA-Z0-9]+)*)*$";
+    private static final Pattern HOSTNAME_PATTERN;
+    static {
+        HOSTNAME_PATTERN = Pattern.compile(HOSTNAME_REGEXP);
+    }
+
+
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        if (android.util.Config.LOGV) Log.v(LOGTAG, "[ProxySelector] onStart");
+
+        setContentView(R.layout.proxy);
+        initView();
+        populateFields(false);
+    }
+
+    protected void showError(int error) {
+
+        new AlertDialog.Builder(this)
+                .setTitle(R.string.proxy_error)
+                .setMessage(error)
+                .setPositiveButton(R.string.proxy_error_dismiss, null)
+                .show();
+    }
+
+    void initView() {
+
+        mHostnameField = (EditText)findViewById(R.id.hostname);
+        mHostnameField.setOnFocusChangeListener(mOnFocusChangeHandler);
+
+        mPortField = (EditText)findViewById(R.id.port);
+        mPortField.setOnClickListener(mOKHandler);
+        mPortField.setOnFocusChangeListener(mOnFocusChangeHandler);
+
+        mOKButton = (Button)findViewById(R.id.action);
+        mOKButton.setOnClickListener(mOKHandler);
+
+        Button b = (Button)findViewById(R.id.clear);
+        b.setOnClickListener(mClearHandler);
+
+        b = (Button)findViewById(R.id.defaultView);
+        b.setOnClickListener(mDefaultHandler);
+    }
+
+    void populateFields(boolean useDefault) {
+        String hostname = null;
+        int port = -1;
+        if (useDefault) {
+            // Use the default proxy settings provided by the carrier
+            hostname = Proxy.getDefaultHost();
+            port = Proxy.getDefaultPort();
+        } else {
+            // Use the last setting given by the user
+            hostname = Proxy.getHost(this);
+            port = Proxy.getPort(this);
+        }
+
+        if (hostname == null) {
+            hostname = "";
+        }
+
+        mHostnameField.setText(hostname);
+
+        String portStr = port == -1 ? "" : Integer.toString(port);
+        mPortField.setText(portStr);
+
+        Intent intent = getIntent();
+
+        String buttonLabel = intent.getStringExtra("button-label");
+        if (!TextUtils.isEmpty(buttonLabel)) {
+            mOKButton.setText(buttonLabel);
+        }
+
+        String title = intent.getStringExtra("title");
+        if (!TextUtils.isEmpty(title)) {
+            setTitle(title);
+        }
+    }
+
+    /**
+     * validate syntax of hostname and port entries
+     * @return 0 on success, string resource ID on failure
+     */
+    int validate(String hostname, String port) {
+        Matcher match = HOSTNAME_PATTERN.matcher(hostname);
+
+        if (!match.matches()) return R.string.proxy_error_invalid_host;
+
+        if (hostname.length() > 0 && port.length() == 0) {
+            return R.string.proxy_error_empty_port;
+        }
+
+        if (port.length() > 0) {
+            if (hostname.length() == 0) {
+                return R.string.proxy_error_empty_host_set_port;
+            }
+            int portVal = -1;
+            try {
+                portVal = Integer.parseInt(port);
+            } catch (NumberFormatException ex) {
+                return R.string.proxy_error_invalid_port;
+            }
+            if (portVal <= 0 || portVal > 0xFFFF) {
+                return R.string.proxy_error_invalid_port;
+            }
+        }
+        return 0;
+    }
+
+    /**
+     * returns true on success, false if the user must correct something
+     */
+    boolean saveToDb() {
+
+        String hostname = mHostnameField.getText().toString().trim();
+        String portStr = mPortField.getText().toString().trim();
+        int port = -1;
+
+        int result = validate(hostname, portStr);
+        if (result > 0) {
+            showError(result);
+            return false;
+        }
+
+        if (portStr.length() > 0) {
+            try {
+                port = Integer.parseInt(portStr);
+            } catch (NumberFormatException ex) {
+                return false;
+            }
+        }
+
+        // FIXME: The best solution would be to make a better UI that would
+        // disable editing of the text boxes if the user chooses to use the
+        // default settings. i.e. checking a box to always use the default
+        // carrier. http:/b/issue?id=756480
+        // FIXME: This currently will not work if the default host is blank and
+        // the user has cleared the input boxes in order to not use a proxy.
+        // This is a UI problem and can be solved with some better form
+        // controls.
+        // FIXME: If the user types in a proxy that matches the default, should
+        // we keep that setting? Can be fixed with a new UI.
+        ContentResolver res = getContentResolver();
+        if (hostname.equals(Proxy.getDefaultHost())
+                && port == Proxy.getDefaultPort()) {
+            // If the user hit the default button and didn't change any of
+            // the input boxes, treat it as if the user has not specified a
+            // proxy.
+            hostname = null;
+        }
+
+        if (!TextUtils.isEmpty(hostname)) {
+            hostname += ':' + portStr;
+        }
+        Settings.Secure.putString(res, Settings.Secure.HTTP_PROXY, hostname);
+        sendBroadcast(new Intent(Proxy.PROXY_CHANGE_ACTION));
+
+        return true;
+    }
+
+    OnClickListener mOKHandler = new OnClickListener() {
+            public void onClick(View v) {
+                if (saveToDb()) {
+                    finish();
+                }
+            }
+        };
+
+    OnClickListener mClearHandler = new OnClickListener() {
+            public void onClick(View v) {
+                mHostnameField.setText("");
+                mPortField.setText("");
+            }
+        };
+
+    OnClickListener mDefaultHandler = new OnClickListener() {
+            public void onClick(View v) {
+                populateFields(true);
+            }
+        };
+
+    OnFocusChangeListener mOnFocusChangeHandler = new OnFocusChangeListener() {
+            public void onFocusChange(View v, boolean hasFocus) {
+                if (hasFocus) {
+                    TextView textView = (TextView) v;
+                    Selection.selectAll((Spannable) textView.getText());
+                }
+            }
+        };
+}
diff --git a/src/com/android/settings/RadioInfo.java b/src/com/android/settings/RadioInfo.java
new file mode 100644
index 0000000..dbad45d
--- /dev/null
+++ b/src/com/android/settings/RadioInfo.java
@@ -0,0 +1,1184 @@
+/*
+ * 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.settings;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.res.Resources;
+import android.net.Uri;
+import android.os.AsyncResult;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.INetStatService;
+import android.os.Message;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.os.SystemProperties;
+import android.preference.PreferenceManager;
+import android.telephony.CellLocation;
+import android.telephony.PhoneStateListener;
+import android.telephony.ServiceState;
+import android.telephony.TelephonyManager;
+import android.telephony.NeighboringCellInfo;
+import android.telephony.gsm.GsmCellLocation;
+import android.text.format.DateUtils;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.Spinner;
+import android.widget.TextView;
+import android.widget.EditText;
+
+import com.android.internal.telephony.Phone;
+import com.android.internal.telephony.PhoneFactory;
+import com.android.internal.telephony.PhoneStateIntentReceiver;
+import com.android.internal.telephony.TelephonyProperties;
+import com.android.internal.telephony.gsm.GSMPhone;
+import com.android.internal.telephony.gsm.PdpConnection;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.DefaultHttpClient;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class RadioInfo extends Activity {
+    private final String TAG = "phone";
+    
+    private static final int EVENT_PHONE_STATE_CHANGED = 100;
+    private static final int EVENT_SIGNAL_STRENGTH_CHANGED = 200;
+    private static final int EVENT_SERVICE_STATE_CHANGED = 300;
+    private static final int EVENT_CFI_CHANGED = 302;
+
+    private static final int EVENT_QUERY_PREFERRED_TYPE_DONE = 1000;
+    private static final int EVENT_SET_PREFERRED_TYPE_DONE = 1001;
+    private static final int EVENT_QUERY_NEIGHBORING_CIDS_DONE = 1002;
+    private static final int EVENT_SET_QXDMLOG_DONE = 1003;
+    private static final int EVENT_SET_CIPHER_DONE = 1004;
+    private static final int EVENT_QUERY_SMSC_DONE = 1005;
+    private static final int EVENT_UPDATE_SMSC_DONE = 1006;
+
+    private static final int MENU_ITEM_SELECT_BAND  = 0;
+    private static final int MENU_ITEM_VIEW_ADN     = 1;
+    private static final int MENU_ITEM_VIEW_FDN     = 2;
+    private static final int MENU_ITEM_VIEW_SDN     = 3;
+    private static final int MENU_ITEM_GET_PDP_LIST = 4;
+    private static final int MENU_ITEM_TOGGLE_DATA  = 5;
+    private static final int MENU_ITEM_TOGGLE_DATA_ON_BOOT = 6;
+
+    private TextView mImei;
+    private TextView number;
+    private TextView callState;
+    private TextView operatorName;
+    private TextView roamingState;
+    private TextView gsmState;
+    private TextView gprsState;
+    private TextView network;
+    private TextView dBm;
+    private TextView mMwi;
+    private TextView mCfi;
+    private TextView mLocation;
+    private TextView mNeighboringCids;
+    private TextView resets;
+    private TextView attempts;
+    private TextView successes;
+    private TextView disconnects;
+    private TextView sentSinceReceived;
+    private TextView sent;
+    private TextView received;
+    private TextView mPingIpAddr;
+    private TextView mPingHostname;
+    private TextView mHttpClientTest;
+    private TextView cipherState;
+    private TextView dnsCheckState;
+    private EditText smsc;
+    private Button radioPowerButton;
+    private Button qxdmLogButton;
+    private Button cipherToggleButton;
+    private Button dnsCheckToggleButton;
+    private Button pingTestButton;
+    private Button updateSmscButton;
+    private Button refreshSmscButton;
+    private Spinner preferredNetworkType;
+
+    private TelephonyManager mTelephonyManager;
+    private Phone phone = null;
+    private PhoneStateIntentReceiver mPhoneStateReceiver;
+    private INetStatService netstat;
+
+    private OemCommands mOem = null;
+    private boolean mQxdmLogEnabled;
+    // The requested cipher state
+    private boolean mCipherOn;
+
+    private String mPingIpAddrResult;
+    private String mPingHostnameResult;
+    private String mHttpClientTestResult;
+    private boolean mMwiValue = false;
+    private boolean mCfiValue = false;
+
+    private PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
+        @Override
+        public void onDataConnectionStateChanged(int state) {
+            updateDataState();
+            updateDataStats();
+            updatePdpList();
+            updateNetworkType();
+        }
+
+        @Override
+        public void onDataActivity(int direction) {
+            updateDataStats2();
+        }
+
+        @Override
+        public void onCellLocationChanged(CellLocation location) {
+            updateLocation(location);
+        }
+
+        @Override
+        public void onMessageWaitingIndicatorChanged(boolean mwi) {
+            mMwiValue = mwi;
+            updateMessageWaiting();
+        }
+
+        @Override
+        public void onCallForwardingIndicatorChanged(boolean cfi) {
+            mCfiValue = cfi;
+            updateCallRedirect();
+        }
+    };
+
+    private Handler mHandler = new Handler() {
+        public void handleMessage(Message msg) {
+            AsyncResult ar;
+            switch (msg.what) {
+                case EVENT_PHONE_STATE_CHANGED:
+                    updatePhoneState();
+                    break;
+
+                case EVENT_SIGNAL_STRENGTH_CHANGED:
+                    updateSignalStrength();
+                    break;
+
+                case EVENT_SERVICE_STATE_CHANGED:
+                    updateServiceState();
+                    updatePowerState();
+                    break;
+
+                case EVENT_QUERY_PREFERRED_TYPE_DONE:
+                    ar= (AsyncResult) msg.obj;
+                    if (ar.exception == null) {
+                        int type = ((int[])ar.result)[0];
+                        preferredNetworkType.setSelection(type, true);
+                    } else {
+                        preferredNetworkType.setSelection(3, true);
+                    }
+                    break;
+                case EVENT_SET_PREFERRED_TYPE_DONE:
+                    ar= (AsyncResult) msg.obj;
+                    if (ar.exception != null) {
+                        phone.getPreferredNetworkType(
+                                obtainMessage(EVENT_QUERY_PREFERRED_TYPE_DONE));
+                    }
+                    break;
+                case EVENT_QUERY_NEIGHBORING_CIDS_DONE:
+                    ar= (AsyncResult) msg.obj;
+                    if (ar.exception == null) {
+                        updateNeighboringCids((ArrayList<NeighboringCellInfo>)ar.result);
+                    } else {
+                        mNeighboringCids.setText("unknown");
+                    }
+                    break;
+                case EVENT_SET_QXDMLOG_DONE:
+                    ar= (AsyncResult) msg.obj;
+                    if (ar.exception == null) {
+                        mQxdmLogEnabled = !mQxdmLogEnabled;
+                        
+                        updateQxdmState(mQxdmLogEnabled);
+                        displayQxdmEnableResult();
+                    }
+                    break;
+                case EVENT_SET_CIPHER_DONE:
+                    ar= (AsyncResult) msg.obj;
+                    if (ar.exception == null) {
+                        setCiphPref(mCipherOn);
+                    }
+                    updateCiphState();
+                    break;
+                case EVENT_QUERY_SMSC_DONE:
+                    ar= (AsyncResult) msg.obj;
+                    if (ar.exception != null) {
+                        smsc.setText("refresh error");
+                    } else {
+                        byte[] buf = (byte[]) ar.result;
+                        smsc.setText(new String(buf));
+                    }
+                    break;
+                case EVENT_UPDATE_SMSC_DONE:
+                    updateSmscButton.setEnabled(true);
+                    ar= (AsyncResult) msg.obj;
+                    if (ar.exception != null) {
+                        smsc.setText("update error");
+                    }
+                    break;
+                default:
+                    break;
+
+            }
+        }
+    };
+
+    private class OemCommands {
+
+        public  final int OEM_QXDM_SDLOG_DEFAULT_FILE_SIZE = 32;
+        public  final int OEM_QXDM_SDLOG_DEFAULT_MASK = 0;
+        public  final int OEM_QXDM_SDLOG_DEFAULT_MAX_INDEX = 8;
+
+        final int SIZE_OF_INT = 4;
+        final int OEM_FEATURE_ENABLE = 1;
+        final int OEM_FEATURE_DISABLE = 0;
+        final int OEM_SIMPE_FEAUTURE_LEN = 1;
+
+        final int OEM_QXDM_SDLOG_FUNCTAG = 0x00010000;
+        final int OEM_QXDM_SDLOG_LEN = 4;
+        final int OEM_PS_AUTO_ATTACH_FUNCTAG = 0x00020000;
+        final int OEM_CIPHERING_FUNCTAG = 0x00020001;
+        final int OEM_SMSC_UPDATE_FUNCTAG = 0x00020002;
+        final int OEM_SMSC_QUERY_FUNCTAG = 0x00020003;
+        final int OEM_SMSC_QUERY_LEN = 0;
+        
+        /**
+         * The OEM interface to store QXDM to SD.
+         *
+         * To start/stop logging QXDM logs to SD card, use tag
+         * OEM_RIL_HOOK_QXDM_SD_LOG_SETUP 0x00010000
+         *
+         * "data" is a const oem_ril_hook_qxdm_sdlog_setup_data_st *
+         * ((const oem_ril_hook_qxdm_sdlog_setup_data_st *)data)->head.func_tag
+         * should be OEM_RIL_HOOK_QXDM_SD_LOG_SETUP
+         * ((const oem_ril_hook_qxdm_sdlog_setup_data_st *)data)->head.len
+         * should be "sizeof(unsigned int) * 4"
+         * ((const oem_ril_hook_qxdm_sdlog_setup_data_st *)data)->mode
+         * could be 0 for 'stop logging', or 1 for 'start logging'
+         * ((const oem_ril_hook_qxdm_sdlog_setup_data_st *)data)->log_file_size
+         * will assign the size of each log file, and it could be a value between
+         * 1 and 512 (in megabytes, default value is recommended to set as 32).
+         * This value will be ignored when mode == 0.
+         * ((const oem_ril_hook_qxdm_sdlog_setup_data_st *)data)->log_mask will
+         * assign the rule to filter logs, and it is a bitmask (bit0 is for MsgAll,
+         * bit1 is for LogAll, and bit2 is for EventAll) recommended to be set as 0
+         * by default. This value will be ignored when mode == 0.
+         * ((const oem_ril_hook_qxdm_sdlog_setup_data_st *)data)->log_max_fileindex
+         * set the how many logfiles will storted before roll over. This value will
+         * be ignored when mode == 0.
+         *
+         * "response" is NULL
+         *
+         * typedef struct _oem_ril_hook_raw_head_st {
+         *      unsigned int func_tag;
+         *      unsigned int len;
+         * } oem_ril_hook_raw_head_st;
+         *
+         * typedef struct _oem_ril_hook_qxdm_sdlog_setup_data_st {
+         *      oem_ril_hook_raw_head_st head;
+         *      unsigned int mode;
+         *      unsigned int log_file_size;
+         *      unsigned int log_mask;
+         *      unsigned int log_max_fileindex;
+         * } oem_ril_hook_qxdm_sdlog_setup_data_st;
+         *
+         * @param enable set true to start logging QXDM in SD card
+         * @param fileSize is the log file size in MB
+         * @param mask is the log mask to filter
+         * @param maxIndex is the maximum roll-over file number
+         * @return byteArray to use in RIL RAW command
+         */
+        byte[] getQxdmSdlogData(boolean enable, int fileSize, int mask, int maxIndex) {
+            ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            DataOutputStream dos = new DataOutputStream(bos);
+            try {
+                writeIntLittleEndian(dos, OEM_QXDM_SDLOG_FUNCTAG);
+                writeIntLittleEndian(dos, OEM_QXDM_SDLOG_LEN * SIZE_OF_INT);
+                writeIntLittleEndian(dos, enable ?
+                        OEM_FEATURE_ENABLE : OEM_FEATURE_DISABLE);
+                writeIntLittleEndian(dos, fileSize);
+                writeIntLittleEndian(dos, mask);
+                writeIntLittleEndian(dos, maxIndex);
+            } catch (IOException e) {
+                return null;
+            }
+            return bos.toByteArray();
+        }
+
+        byte[] getSmscQueryData() {
+            ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            DataOutputStream dos = new DataOutputStream(bos);
+            try {
+                writeIntLittleEndian(dos, OEM_SMSC_QUERY_FUNCTAG);
+                writeIntLittleEndian(dos, OEM_SMSC_QUERY_LEN * SIZE_OF_INT);
+            } catch (IOException e) {
+                return null;
+            }
+            return bos.toByteArray();
+        }
+
+        byte[] getSmscUpdateData(String smsc) {
+            ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            DataOutputStream dos = new DataOutputStream(bos);
+            try {
+                byte[] smsc_bytes = smsc.getBytes();
+                writeIntLittleEndian(dos, OEM_SMSC_UPDATE_FUNCTAG);
+                writeIntLittleEndian(dos, smsc_bytes.length);
+                dos.write(smsc_bytes);
+            } catch (IOException e) {
+                return null;
+            }
+            return bos.toByteArray();
+        }
+
+        byte[] getPsAutoAttachData(boolean enable) {
+            return getSimpleFeatureData(OEM_PS_AUTO_ATTACH_FUNCTAG, enable);
+        }
+
+        byte[] getCipheringData(boolean enable) {
+            return getSimpleFeatureData(OEM_CIPHERING_FUNCTAG, enable);
+        }
+        
+        private byte[] getSimpleFeatureData(int tag, boolean enable) {
+            ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            DataOutputStream dos = new DataOutputStream(bos);
+            try {
+                writeIntLittleEndian(dos, tag);
+                writeIntLittleEndian(dos, OEM_SIMPE_FEAUTURE_LEN * SIZE_OF_INT);
+                writeIntLittleEndian(dos, enable ?
+                        OEM_FEATURE_ENABLE : OEM_FEATURE_DISABLE);
+            } catch (IOException e) {
+                return null;
+            }
+            return bos.toByteArray();
+        }
+
+        private void writeIntLittleEndian(DataOutputStream dos, int val)
+                throws IOException {
+            dos.writeByte(val);
+            dos.writeByte(val >> 8);
+            dos.writeByte(val >> 16);
+            dos.writeByte(val >> 24);
+        }
+    }
+
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        setContentView(R.layout.radio_info);
+
+        mTelephonyManager = (TelephonyManager)getSystemService(TELEPHONY_SERVICE);
+        phone = PhoneFactory.getDefaultPhone();
+
+        mImei = (TextView) findViewById(R.id.imei);
+        number = (TextView) findViewById(R.id.number);
+        callState = (TextView) findViewById(R.id.call);
+        operatorName = (TextView) findViewById(R.id.operator);
+        roamingState = (TextView) findViewById(R.id.roaming);
+        gsmState = (TextView) findViewById(R.id.gsm);
+        gprsState = (TextView) findViewById(R.id.gprs);
+        network = (TextView) findViewById(R.id.network);
+        dBm = (TextView) findViewById(R.id.dbm);
+        mMwi = (TextView) findViewById(R.id.mwi);
+        mCfi = (TextView) findViewById(R.id.cfi);
+        mLocation = (TextView) findViewById(R.id.location);
+        mNeighboringCids = (TextView) findViewById(R.id.neighboring);
+
+        resets = (TextView) findViewById(R.id.resets);
+        attempts = (TextView) findViewById(R.id.attempts);
+        successes = (TextView) findViewById(R.id.successes);
+        disconnects = (TextView) findViewById(R.id.disconnects);
+        sentSinceReceived = (TextView) findViewById(R.id.sentSinceReceived);
+        sent = (TextView) findViewById(R.id.sent);
+        received = (TextView) findViewById(R.id.received);
+        cipherState = (TextView) findViewById(R.id.ciphState);
+        smsc = (EditText) findViewById(R.id.smsc);
+        dnsCheckState = (TextView) findViewById(R.id.dnsCheckState);
+
+        mPingIpAddr = (TextView) findViewById(R.id.pingIpAddr);
+        mPingHostname = (TextView) findViewById(R.id.pingHostname);
+        mHttpClientTest = (TextView) findViewById(R.id.httpClientTest);
+
+        preferredNetworkType = (Spinner) findViewById(R.id.preferredNetworkType);
+        ArrayAdapter<String> adapter = new ArrayAdapter<String> (this,
+                android.R.layout.simple_spinner_item, mPreferredNetworkLabels);
+        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);        
+        preferredNetworkType.setAdapter(adapter);
+        preferredNetworkType.setOnItemSelectedListener(mPreferredNetworkHandler);
+
+        radioPowerButton = (Button) findViewById(R.id.radio_power);
+        radioPowerButton.setOnClickListener(mPowerButtonHandler);
+
+        qxdmLogButton = (Button) findViewById(R.id.qxdm_log);
+        qxdmLogButton.setOnClickListener(mQxdmButtonHandler);
+
+        cipherToggleButton = (Button) findViewById(R.id.ciph_toggle);
+        cipherToggleButton.setOnClickListener(mCipherButtonHandler);
+        pingTestButton = (Button) findViewById(R.id.ping_test);
+        pingTestButton.setOnClickListener(mPingButtonHandler);
+        updateSmscButton = (Button) findViewById(R.id.update_smsc);
+        updateSmscButton.setOnClickListener(mUpdateSmscButtonHandler);
+        refreshSmscButton = (Button) findViewById(R.id.refresh_smsc);
+        refreshSmscButton.setOnClickListener(mRefreshSmscButtonHandler);
+        dnsCheckToggleButton = (Button) findViewById(R.id.dns_check_toggle);
+        dnsCheckToggleButton.setOnClickListener(mDnsCheckButtonHandler);
+        
+        mPhoneStateReceiver = new PhoneStateIntentReceiver(this, mHandler);
+        mPhoneStateReceiver.notifySignalStrength(EVENT_SIGNAL_STRENGTH_CHANGED);
+        mPhoneStateReceiver.notifyServiceState(EVENT_SERVICE_STATE_CHANGED);
+        mPhoneStateReceiver.notifyPhoneCallState(EVENT_PHONE_STATE_CHANGED);
+                         
+        updateQxdmState(null);
+        mOem = new OemCommands();
+
+        phone.getPreferredNetworkType(
+                mHandler.obtainMessage(EVENT_QUERY_PREFERRED_TYPE_DONE));
+        phone.getNeighboringCids(
+                mHandler.obtainMessage(EVENT_QUERY_NEIGHBORING_CIDS_DONE));
+
+        netstat = INetStatService.Stub.asInterface(ServiceManager.getService("netstat"));
+
+        CellLocation.requestLocationUpdate();
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        updatePhoneState();
+        updateSignalStrength();
+        updateMessageWaiting();
+        updateCallRedirect();
+        updateServiceState();
+        updateLocation(mTelephonyManager.getCellLocation());
+        updateDataState();
+        updateDataStats();
+        updateDataStats2();
+        updatePowerState();
+        updateQxdmState(null);
+        updateProperties();
+        updateCiphState();
+        updateDnsCheckState();
+
+        Log.i(TAG, "[RadioInfo] onResume: register phone & data intents");
+
+        mPhoneStateReceiver.registerIntent();
+        mTelephonyManager.listen(mPhoneStateListener,
+                  PhoneStateListener.LISTEN_DATA_CONNECTION_STATE
+                | PhoneStateListener.LISTEN_DATA_ACTIVITY
+                | PhoneStateListener.LISTEN_CELL_LOCATION
+                | PhoneStateListener.LISTEN_MESSAGE_WAITING_INDICATOR
+                | PhoneStateListener.LISTEN_CALL_FORWARDING_INDICATOR);
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+
+        Log.i(TAG, "[RadioInfo] onPause: unregister phone & data intents");
+
+        mPhoneStateReceiver.unregisterIntent();
+        mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        menu.add(0, MENU_ITEM_SELECT_BAND, 0, R.string.radio_info_band_mode_label).setOnMenuItemClickListener(mSelectBandCallback)
+                .setAlphabeticShortcut('b');
+        menu.add(1, MENU_ITEM_VIEW_ADN, 0,
+                R.string.radioInfo_menu_viewADN).setOnMenuItemClickListener(mViewADNCallback);
+        menu.add(1, MENU_ITEM_VIEW_FDN, 0,
+                R.string.radioInfo_menu_viewFDN).setOnMenuItemClickListener(mViewFDNCallback);
+        menu.add(1, MENU_ITEM_VIEW_SDN, 0,
+                R.string.radioInfo_menu_viewSDN).setOnMenuItemClickListener(mViewSDNCallback);
+        menu.add(1, MENU_ITEM_GET_PDP_LIST,
+                0, R.string.radioInfo_menu_getPDP).setOnMenuItemClickListener(mGetPdpList);
+        menu.add(1, MENU_ITEM_TOGGLE_DATA,
+                0, R.string.radioInfo_menu_disableData).setOnMenuItemClickListener(mToggleData);
+        menu.add(1, MENU_ITEM_TOGGLE_DATA_ON_BOOT,
+                0, R.string.radioInfo_menu_disableDataOnBoot).setOnMenuItemClickListener(mToggleDataOnBoot);
+        return true;
+    }
+
+
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu)
+    {
+        // Get the TOGGLE DATA menu item in the right state.
+        MenuItem item = menu.findItem(MENU_ITEM_TOGGLE_DATA);
+        int state = mTelephonyManager.getDataState();
+        boolean visible = true;
+
+        switch (state) {
+            case TelephonyManager.DATA_CONNECTED:
+            case TelephonyManager.DATA_SUSPENDED:
+                item.setTitle(R.string.radioInfo_menu_disableData);
+                break;
+            case TelephonyManager.DATA_DISCONNECTED:
+                item.setTitle(R.string.radioInfo_menu_enableData);
+                break;
+            default:
+                visible = false;
+                break;
+        }
+        item.setVisible(visible);
+
+        // Get the toggle-data-on-boot menu item in the right state.
+        item = menu.findItem(MENU_ITEM_TOGGLE_DATA_ON_BOOT);
+        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this.getApplication());
+        boolean value = sp.getBoolean(GSMPhone.DATA_DISABLED_ON_BOOT_KEY, false);
+        if (value) {
+            item.setTitle(R.string.radioInfo_menu_enableDataOnBoot);
+        } else {
+            item.setTitle(R.string.radioInfo_menu_disableDataOnBoot);
+        }
+        return true;
+    }
+
+    private boolean isRadioOn() {
+        return phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF;
+    }
+    
+    private void updatePowerState() {
+    	//log("updatePowerState");
+        String buttonText = isRadioOn() ?
+                            getString(R.string.turn_off_radio) :
+                            getString(R.string.turn_on_radio);
+        radioPowerButton.setText(buttonText);    	
+    }
+
+    private void updateQxdmState(Boolean newQxdmStatus) {
+        SharedPreferences sp = 
+          PreferenceManager.getDefaultSharedPreferences(this.getApplication());
+        mQxdmLogEnabled = sp.getBoolean("qxdmstatus", false);
+        // This is called from onCreate, onResume, and the handler when the status
+        // is updated. 
+        if (newQxdmStatus != null) {
+            SharedPreferences.Editor editor = sp.edit();
+            editor.putBoolean("qxdmstatus", newQxdmStatus);
+            editor.commit();
+            mQxdmLogEnabled = newQxdmStatus;
+        }
+        
+        String buttonText = mQxdmLogEnabled ?
+                            getString(R.string.turn_off_qxdm) :
+                            getString(R.string.turn_on_qxdm);
+        qxdmLogButton.setText(buttonText);
+    }
+
+    private void setCiphPref(boolean value) {
+        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this.getApplication());
+        SharedPreferences.Editor editor = sp.edit();
+        editor.putBoolean(GSMPhone.CIPHERING_KEY, value);
+        editor.commit();
+    }
+
+    private boolean getCiphPref() {
+        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this.getApplication());
+        boolean ret = sp.getBoolean(GSMPhone.CIPHERING_KEY, true);
+        return ret;
+    }
+
+    private void updateCiphState() {
+        cipherState.setText(getCiphPref() ? "Ciphering ON" : "Ciphering OFF");
+    }
+
+    private void updateDnsCheckState() {
+        GSMPhone gsmPhone = (GSMPhone) phone;
+        dnsCheckState.setText(gsmPhone.isDnsCheckDisabled() ?
+                "0.0.0.0 allowed" :"0.0.0.0 not allowed");
+    }
+    
+    private final void
+    updateSignalStrength() {
+        int state =
+                mPhoneStateReceiver.getServiceState().getState();
+        Resources r = getResources();
+
+        if ((ServiceState.STATE_OUT_OF_SERVICE == state) ||
+                (ServiceState.STATE_POWER_OFF == state)) {
+            dBm.setText("0");
+        }
+        
+        int signalDbm = mPhoneStateReceiver.getSignalStrengthDbm();
+        
+        if (-1 == signalDbm) signalDbm = 0;
+
+        int signalAsu = mPhoneStateReceiver.getSignalStrength();
+
+        if (-1 == signalAsu) signalAsu = 0;
+
+        dBm.setText(String.valueOf(signalDbm) + " "
+            + r.getString(R.string.radioInfo_display_dbm) + "   "
+            + String.valueOf(signalAsu) + " "
+            + r.getString(R.string.radioInfo_display_asu));
+    }
+
+    private final void updateLocation(CellLocation location) {
+        GsmCellLocation loc = (GsmCellLocation)location;
+        Resources r = getResources();
+
+        int lac = loc.getLac();
+        int cid = loc.getCid();
+
+        mLocation.setText(r.getString(R.string.radioInfo_lac) + " = "
+                          + ((lac == -1) ? "unknown" : Integer.toHexString(lac))
+                          + "   "
+                          + r.getString(R.string.radioInfo_cid) + " = "
+                + ((cid == -1) ? "unknown" : Integer.toHexString(cid)));
+    }
+
+    private final void updateNeighboringCids(ArrayList<NeighboringCellInfo> cids) {
+        String neighborings = "";
+        if (cids != null) {
+            if ( cids.isEmpty() ) {
+                neighborings = "no neighboring cells";
+            } else {
+                for (NeighboringCellInfo cell : cids) {
+                    neighborings += "{" + Integer.toHexString(cell.getCid()) 
+                    + "@" + cell.getRssi() + "} ";
+                }
+            }
+        } else {
+            neighborings = "unknown";
+        }
+        mNeighboringCids.setText(neighborings);
+    }
+
+    private final void
+    updateMessageWaiting() {
+        mMwi.setText(String.valueOf(mMwiValue));
+    }
+
+    private final void
+    updateCallRedirect() {
+        mCfi.setText(String.valueOf(mCfiValue));
+    }
+
+
+    private final void
+    updateServiceState() {
+        ServiceState serviceState = mPhoneStateReceiver.getServiceState();
+        int state = serviceState.getState();
+        Resources r = getResources();
+        String display = r.getString(R.string.radioInfo_unknown);
+        
+        switch (state) {
+            case ServiceState.STATE_IN_SERVICE:
+                display = r.getString(R.string.radioInfo_service_in);
+                break;
+            case ServiceState.STATE_OUT_OF_SERVICE:
+            case ServiceState.STATE_EMERGENCY_ONLY:
+                display = r.getString(R.string.radioInfo_service_emergency);
+                break;
+            case ServiceState.STATE_POWER_OFF:
+                display = r.getString(R.string.radioInfo_service_off);
+                break;
+        }
+        
+        gsmState.setText(display);
+        
+        if (serviceState.getRoaming()) {
+            roamingState.setText(R.string.radioInfo_roaming_in);
+        } else {
+            roamingState.setText(R.string.radioInfo_roaming_not);
+        }
+
+        operatorName.setText(serviceState.getOperatorAlphaLong());
+    }
+
+    private final void
+    updatePhoneState() {
+        Phone.State state = mPhoneStateReceiver.getPhoneState();
+        Resources r = getResources();
+        String display = r.getString(R.string.radioInfo_unknown);
+
+        switch (state) {
+            case IDLE:
+                display = r.getString(R.string.radioInfo_phone_idle);
+                break;
+            case RINGING:
+                display = r.getString(R.string.radioInfo_phone_ringing);
+                break;
+            case OFFHOOK:
+                display = r.getString(R.string.radioInfo_phone_offhook);
+                break;
+        }
+
+        callState.setText(display);
+    }
+
+    private final void
+    updateDataState() {
+        int state = mTelephonyManager.getDataState();
+        Resources r = getResources();
+        String display = r.getString(R.string.radioInfo_unknown);
+
+        switch (state) {
+            case TelephonyManager.DATA_CONNECTED:
+                display = r.getString(R.string.radioInfo_data_connected);
+                break;
+            case TelephonyManager.DATA_CONNECTING:
+                display = r.getString(R.string.radioInfo_data_connecting);
+                break;
+            case TelephonyManager.DATA_DISCONNECTED:
+                display = r.getString(R.string.radioInfo_data_disconnected);
+                break;
+            case TelephonyManager.DATA_SUSPENDED:
+                display = r.getString(R.string.radioInfo_data_suspended);
+                break;
+        }
+        
+        gprsState.setText(display);
+    }
+
+    private final void updateNetworkType() {
+        Resources r = getResources();
+        String display = SystemProperties.get(TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE,
+                r.getString(R.string.radioInfo_unknown));
+
+        network.setText(display);
+    }
+
+    private final void
+    updateProperties() {
+        String s;
+        Resources r = getResources();
+
+        s = phone.getDeviceId();
+        if (s == null) s = r.getString(R.string.radioInfo_unknown); 
+        mImei.setText(s);
+        
+        s = phone.getLine1Number();
+        if (s == null) s = r.getString(R.string.radioInfo_unknown); 
+        number.setText(s);
+    }
+
+    private final void updateDataStats() {
+        String s;
+
+        s = SystemProperties.get("net.gsm.radio-reset", "0");
+        resets.setText(s);
+
+        s = SystemProperties.get("net.gsm.attempt-gprs", "0");
+        attempts.setText(s);
+
+        s = SystemProperties.get("net.gsm.succeed-gprs", "0");
+        successes.setText(s);
+
+        //s = SystemProperties.get("net.gsm.disconnect", "0");
+        //disconnects.setText(s);
+
+        s = SystemProperties.get("net.ppp.reset-by-timeout", "0");
+        sentSinceReceived.setText(s);
+    }
+
+    private final void updateDataStats2() {
+        Resources r = getResources();
+
+        try {
+            long txPackets = netstat.getMobileTxPackets();
+            long rxPackets = netstat.getMobileRxPackets();
+            long txBytes   = netstat.getMobileTxBytes();
+            long rxBytes   = netstat.getMobileRxBytes();
+    
+            String packets = r.getString(R.string.radioInfo_display_packets);
+            String bytes   = r.getString(R.string.radioInfo_display_bytes);
+    
+            sent.setText(txPackets + " " + packets + ", " + txBytes + " " + bytes);
+            received.setText(rxPackets + " " + packets + ", " + rxBytes + " " + bytes);
+        } catch (RemoteException e) {
+        }
+    }
+
+    /**
+     * Ping a IP address.
+     */
+    private final void pingIpAddr() {
+        try {
+            // This is hardcoded IP addr. This is for testing purposes.
+            // We would need to get rid of this before release.
+            String ipAddress = "74.125.47.104";
+            Process p = Runtime.getRuntime().exec("ping -c 1 " + ipAddress);
+            int status = p.waitFor();
+            if (status == 0) {
+                mPingIpAddrResult = "Pass";
+            } else {
+                mPingIpAddrResult = "Fail: IP addr not reachable";
+            }
+        } catch (IOException e) {
+            mPingIpAddrResult = "Fail: IOException";
+        } catch (InterruptedException e) {
+            mPingIpAddrResult = "Fail: InterruptedException";
+        }
+    }
+
+    /**
+     *  Ping a host name
+     */
+    private final void pingHostname() {
+        try {
+            Process p = Runtime.getRuntime().exec("ping -c 1 www.google.com"); 
+            int status = p.waitFor();
+            if (status == 0) {
+                mPingHostnameResult = "Pass";
+            } else {
+                mPingHostnameResult = "Fail: Host unreachable";
+            }
+        } catch (UnknownHostException e) {
+            mPingHostnameResult = "Fail: Unknown Host";
+        } catch (IOException e) {
+            mPingHostnameResult= "Fail: IOException";
+        } catch (InterruptedException e) {
+            mPingHostnameResult = "Fail: InterruptedException";
+        }
+    }
+
+    /**
+     * This function checks for basic functionality of HTTP Client.
+     */
+    private void httpClientTest() {
+        HttpClient client = new DefaultHttpClient();
+        try {
+            HttpGet request = new HttpGet("http://www.google.com");
+            HttpResponse response = client.execute(request);
+            if (response.getStatusLine().getStatusCode() == 200) {
+                mHttpClientTestResult = "Pass";
+            } else {
+                mHttpClientTestResult = "Fail: Code: " + String.valueOf(response);
+            }
+            request.abort();
+        } catch (IOException e) {
+            mHttpClientTestResult = "Fail: IOException";
+        }
+    }
+
+    private void refreshSmsc() {
+        byte[] data = mOem.getSmscQueryData();
+        if (data == null) return;
+        phone.invokeOemRilRequestRaw(data,
+                mHandler.obtainMessage(EVENT_QUERY_SMSC_DONE));
+    }
+
+    private final void updatePingState() {
+        final Handler handler = new Handler();
+        // Set all to unknown since the threads will take a few secs to update.
+        mPingIpAddrResult = getResources().getString(R.string.radioInfo_unknown);
+        mPingHostnameResult = getResources().getString(R.string.radioInfo_unknown);
+        mHttpClientTestResult = getResources().getString(R.string.radioInfo_unknown);
+
+        mPingIpAddr.setText(mPingIpAddrResult);
+        mPingHostname.setText(mPingHostnameResult);
+        mHttpClientTest.setText(mHttpClientTestResult);
+
+        final Runnable updatePingResults = new Runnable() {
+            public void run() {
+                mPingIpAddr.setText(mPingIpAddrResult);
+                mPingHostname.setText(mPingHostnameResult);
+                mHttpClientTest.setText(mHttpClientTestResult);
+            }
+        };
+        Thread ipAddr = new Thread() {
+            @Override
+            public void run() {
+                pingIpAddr();
+                handler.post(updatePingResults);
+            }
+        };
+        ipAddr.start();
+
+        Thread hostname = new Thread() {
+            @Override
+            public void run() {
+                pingHostname();
+                handler.post(updatePingResults);
+            }
+        };
+        hostname.start();
+
+        Thread httpClient = new Thread() {
+            @Override
+            public void run() {
+                httpClientTest();
+                handler.post(updatePingResults);
+            }
+        };
+        httpClient.start();
+    }
+
+    private final void updatePdpList() {
+        StringBuilder sb = new StringBuilder("========DATA=======\n");
+
+        List<PdpConnection> pdps = phone.getCurrentPdpList();
+
+        for (PdpConnection pdp : pdps) {
+            sb.append("    State: ").append(pdp.getState().toString()).append("\n");
+            if (pdp.getState().isActive()) {
+                long timeElapsed =
+                    (System.currentTimeMillis() - pdp.getConnectionTime())/1000;
+                sb.append("    connected at ")
+                  .append(DateUtils.timeString(pdp.getConnectionTime()))
+                  .append(" and elapsed ")
+                  .append(DateUtils.formatElapsedTime(timeElapsed))
+                  .append("\n    to ")
+                  .append(pdp.getApn().toString())
+                  .append("\ninterface: ")
+                  .append(phone.getInterfaceName(phone.getActiveApnTypes()[0]))
+                  .append("\naddress: ")
+                  .append(phone.getIpAddress(phone.getActiveApnTypes()[0]))
+                  .append("\ngateway: ")
+                  .append(phone.getGateway(phone.getActiveApnTypes()[0]));
+                String[] dns = phone.getDnsServers(phone.getActiveApnTypes()[0]);
+                if (dns != null) {
+                    sb.append("\ndns: ").append(dns[0]).append(", ").append(dns[1]);
+                }
+            } else if (pdp.getState().isInactive()) {
+                sb.append("    disconnected with last try at ")
+                  .append(DateUtils.timeString(pdp.getLastFailTime()))
+                  .append("\n    fail because ")
+                  .append(pdp.getLastFailCause().toString());
+            } else {
+                sb.append("    is connecting to ")
+                  .append(pdp.getApn().toString());
+            }
+            sb.append("\n===================");
+        }
+
+
+        disconnects.setText(sb.toString());
+    }
+
+    private void displayQxdmEnableResult() {
+        String status = mQxdmLogEnabled ? "Start QXDM Log" : "Stop QXDM Log";
+
+        DialogInterface mProgressPanel = new AlertDialog.
+                Builder(this).setMessage(status).show();
+
+        mHandler.postDelayed(
+                new Runnable() {
+                    public void run() {
+                        finish();
+                    }
+                }, 2000);
+    }
+
+    private MenuItem.OnMenuItemClickListener mViewADNCallback = new MenuItem.OnMenuItemClickListener() {
+        public boolean onMenuItemClick(MenuItem item) {
+            Intent intent = new Intent(Intent.ACTION_VIEW);
+            // XXX We need to specify the component here because if we don't
+            // the activity manager will try to resolve the type by calling
+            // the content provider, which causes it to be loaded in a process
+            // other than the Dialer process, which causes a lot of stuff to
+            // break.
+            intent.setClassName("com.android.phone",
+                    "com.android.phone.SimContacts");
+            startActivity(intent);
+            return true;
+        }
+    };
+
+    private MenuItem.OnMenuItemClickListener mViewFDNCallback = new MenuItem.OnMenuItemClickListener() {
+        public boolean onMenuItemClick(MenuItem item) {
+            Intent intent = new Intent(Intent.ACTION_VIEW);
+            // XXX We need to specify the component here because if we don't
+            // the activity manager will try to resolve the type by calling
+            // the content provider, which causes it to be loaded in a process
+            // other than the Dialer process, which causes a lot of stuff to
+            // break.
+            intent.setClassName("com.android.phone",
+                    "com.android.phone.FdnList");
+            startActivity(intent);
+            return true;
+        }
+    };
+
+    private MenuItem.OnMenuItemClickListener mViewSDNCallback = new MenuItem.OnMenuItemClickListener() {
+        public boolean onMenuItemClick(MenuItem item) {
+            Intent intent = new Intent(
+                Intent.ACTION_VIEW, Uri.parse("content://sim/sdn"));
+            // XXX We need to specify the component here because if we don't
+            // the activity manager will try to resolve the type by calling
+            // the content provider, which causes it to be loaded in a process
+            // other than the Dialer process, which causes a lot of stuff to
+            // break.
+            intent.setClassName("com.android.phone",
+                    "com.android.phone.ADNList");
+            startActivity(intent);
+            return true;
+        }
+    };
+
+    private void toggleDataDisabledOnBoot() {
+        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this.getApplication());
+        SharedPreferences.Editor editor = sp.edit();
+        boolean value = sp.getBoolean(GSMPhone.DATA_DISABLED_ON_BOOT_KEY, false);
+        editor.putBoolean(GSMPhone.DATA_DISABLED_ON_BOOT_KEY, !value);
+        byte[] data = mOem.getPsAutoAttachData(value);
+        if (data == null) {
+            // don't commit
+            return;
+        }
+
+        editor.commit();
+        phone.invokeOemRilRequestRaw(data, null);
+    }
+
+    private MenuItem.OnMenuItemClickListener mToggleDataOnBoot = new MenuItem.OnMenuItemClickListener() {
+        public boolean onMenuItemClick(MenuItem item) {
+            toggleDataDisabledOnBoot();
+            return true;
+        }
+    };
+    
+    private MenuItem.OnMenuItemClickListener mToggleData = new MenuItem.OnMenuItemClickListener() {
+        public boolean onMenuItemClick(MenuItem item) {
+            int state = mTelephonyManager.getDataState();
+            switch (state) {
+                case TelephonyManager.DATA_CONNECTED:
+                    phone.disableDataConnectivity();
+                    break;
+                case TelephonyManager.DATA_DISCONNECTED:
+                    phone.enableDataConnectivity();
+                    break;
+                default:
+                    // do nothing
+                    break;
+            }
+            return true;
+        }
+    };
+
+    private MenuItem.OnMenuItemClickListener mGetPdpList = new MenuItem.OnMenuItemClickListener() {
+        public boolean onMenuItemClick(MenuItem item) {
+            phone.getPdpContextList(null);
+            return true;
+        }
+    };
+
+    private MenuItem.OnMenuItemClickListener mSelectBandCallback = new MenuItem.OnMenuItemClickListener() {
+        public boolean onMenuItemClick(MenuItem item) {
+            Intent intent = new Intent();
+            intent.setClass(RadioInfo.this, BandMode.class);
+            startActivity(intent);
+            return true;
+        }
+    };
+
+    OnClickListener mPowerButtonHandler = new OnClickListener() {
+        public void onClick(View v) {
+            //log("toggle radio power: currently " + (isRadioOn()?"on":"off"));
+            phone.setRadioPower(!isRadioOn());
+        }
+    };
+
+    OnClickListener mCipherButtonHandler = new OnClickListener() {
+        public void onClick(View v) {
+            mCipherOn = !getCiphPref();
+            byte[] data = mOem.getCipheringData(mCipherOn);
+            
+            if (data == null)
+                return;
+
+            cipherState.setText("Setting...");
+            phone.invokeOemRilRequestRaw(data,
+                    mHandler.obtainMessage(EVENT_SET_CIPHER_DONE));
+        }
+    };
+    
+    OnClickListener mDnsCheckButtonHandler = new OnClickListener() {
+        public void onClick(View v) {
+            GSMPhone gsmPhone = (GSMPhone) phone;
+            gsmPhone.disableDnsCheck(!gsmPhone.isDnsCheckDisabled());
+            updateDnsCheckState();
+        }
+    };
+    
+    OnClickListener mPingButtonHandler = new OnClickListener() {
+        public void onClick(View v) {
+            updatePingState();
+        }
+    };
+
+    OnClickListener mUpdateSmscButtonHandler = new OnClickListener() {
+        public void onClick(View v) {
+            updateSmscButton.setEnabled(false);
+            byte[] data = mOem.getSmscUpdateData(smsc.getText().toString());
+            if (data == null) return;
+            phone.invokeOemRilRequestRaw(data,
+                    mHandler.obtainMessage(EVENT_UPDATE_SMSC_DONE));
+        }
+    };
+
+    OnClickListener mRefreshSmscButtonHandler = new OnClickListener() {
+        public void onClick(View v) {
+            refreshSmsc();
+        }
+    };
+
+    OnClickListener mQxdmButtonHandler = new OnClickListener() {
+        public void onClick(View v) {
+            byte[] data = mOem.getQxdmSdlogData(
+                    !mQxdmLogEnabled,
+                    mOem.OEM_QXDM_SDLOG_DEFAULT_FILE_SIZE,
+                    mOem.OEM_QXDM_SDLOG_DEFAULT_MASK,
+                    mOem.OEM_QXDM_SDLOG_DEFAULT_MAX_INDEX);
+
+            if (data == null)
+                return;
+
+            phone.invokeOemRilRequestRaw(data,
+                    mHandler.obtainMessage(EVENT_SET_QXDMLOG_DONE));
+        }
+    };
+
+    AdapterView.OnItemSelectedListener
+            mPreferredNetworkHandler = new AdapterView.OnItemSelectedListener() {
+        public void onItemSelected(AdapterView parent, View v, int pos, long id) {
+            Message msg = mHandler.obtainMessage(EVENT_SET_PREFERRED_TYPE_DONE);
+            if (pos>=0 && pos<=2) {
+                phone.setPreferredNetworkType(pos, msg);
+            }
+        }
+
+        public void onNothingSelected(AdapterView parent) {
+        }
+    };
+
+    private String[] mPreferredNetworkLabels = {
+            "WCDMA preferred", "GSM only", "WCDMA only", "Unknown"};
+}
diff --git a/src/com/android/settings/RingerVolumePreference.java b/src/com/android/settings/RingerVolumePreference.java
new file mode 100644
index 0000000..2d21ec6
--- /dev/null
+++ b/src/com/android/settings/RingerVolumePreference.java
@@ -0,0 +1,129 @@
+/*
+ * 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.settings;
+
+import android.content.Context;
+import android.media.AudioManager;
+import android.preference.VolumePreference;
+import android.preference.VolumePreference.SeekBarVolumizer;
+import android.provider.Settings;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.CheckBox;
+import android.widget.CompoundButton;
+import android.widget.SeekBar;
+import android.widget.TextView;
+
+/**
+ * Special preference type that allows configuration of both the ring volume and
+ * notification volume.
+ */
+public class RingerVolumePreference extends VolumePreference implements
+        CheckBox.OnCheckedChangeListener {
+    private static final String TAG = "RingerVolumePreference";
+
+    private CheckBox mNotificationsUseRingVolumeCheckbox;
+    private SeekBarVolumizer mNotificationSeekBarVolumizer;
+    private TextView mNotificationVolumeTitle;
+    
+    public RingerVolumePreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+
+        // The always visible seekbar is for ring volume
+        setStreamType(AudioManager.STREAM_RING);
+        
+        setDialogLayoutResource(R.layout.preference_dialog_ringervolume);
+    }
+
+    @Override
+    protected void onBindDialogView(View view) {
+        super.onBindDialogView(view);
+     
+        mNotificationsUseRingVolumeCheckbox =
+                (CheckBox) view.findViewById(R.id.same_notification_volume);
+        mNotificationsUseRingVolumeCheckbox.setOnCheckedChangeListener(this);
+        mNotificationsUseRingVolumeCheckbox.setChecked(Settings.System.getInt(
+                getContext().getContentResolver(),
+                Settings.System.NOTIFICATIONS_USE_RING_VOLUME, 1) == 1);
+        
+        final SeekBar seekBar = (SeekBar) view.findViewById(R.id.notification_volume_seekbar);
+        mNotificationSeekBarVolumizer = new SeekBarVolumizer(getContext(), seekBar,
+                AudioManager.STREAM_NOTIFICATION);
+        
+        mNotificationVolumeTitle = (TextView) view.findViewById(R.id.notification_volume_title);
+        
+        setNotificationVolumeVisibility(!mNotificationsUseRingVolumeCheckbox.isChecked());
+    }
+
+    @Override
+    protected void onDialogClosed(boolean positiveResult) {
+        super.onDialogClosed(positiveResult);
+        
+        if (!positiveResult && mNotificationSeekBarVolumizer != null) {
+            mNotificationSeekBarVolumizer.revertVolume();
+        }
+        
+        cleanup();
+    }
+
+    @Override
+    public void onActivityStop() {
+        super.onActivityStop();
+        cleanup();
+    }
+    
+    public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+        setNotificationVolumeVisibility(!isChecked);
+        
+        Settings.System.putInt(getContext().getContentResolver(),
+                Settings.System.NOTIFICATIONS_USE_RING_VOLUME, isChecked ? 1 : 0);
+        
+        if (isChecked) {
+            // The user wants the notification to be same as ring, so do a
+            // one-time sync right now
+            AudioManager audioManager = (AudioManager) getContext()
+                    .getSystemService(Context.AUDIO_SERVICE);
+            audioManager.setStreamVolume(AudioManager.STREAM_NOTIFICATION,
+                    audioManager.getStreamVolume(AudioManager.STREAM_RING), 0);
+        }
+    }
+
+    @Override
+    protected void onSampleStarting(SeekBarVolumizer volumizer) {
+        super.onSampleStarting(volumizer);
+        
+        if (mNotificationSeekBarVolumizer != null && volumizer != mNotificationSeekBarVolumizer) {
+            mNotificationSeekBarVolumizer.stopSample();
+        }
+    }
+
+    private void setNotificationVolumeVisibility(boolean visible) {
+        if (mNotificationSeekBarVolumizer != null) {
+            mNotificationSeekBarVolumizer.getSeekBar().setVisibility(
+                    visible ? View.VISIBLE : View.GONE);
+            mNotificationVolumeTitle.setVisibility(visible ? View.VISIBLE : View.GONE);
+        }
+    }
+    
+    private void cleanup() {
+        if (mNotificationSeekBarVolumizer != null) {
+            mNotificationSeekBarVolumizer.stop();
+            mNotificationSeekBarVolumizer = null;
+        }
+    }
+    
+}
diff --git a/src/com/android/settings/SdCardIntentReceiver.java b/src/com/android/settings/SdCardIntentReceiver.java
new file mode 100644
index 0000000..9648ec1
--- /dev/null
+++ b/src/com/android/settings/SdCardIntentReceiver.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2007 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.settings;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.BroadcastReceiver;
+import android.util.Config;
+import android.util.Log;
+
+/**
+ * 
+ */
+public class SdCardIntentReceiver extends BroadcastReceiver {
+
+    private static final int SDCARD_STATUS = 1;
+    private static final String TAG = "SdCardIntentReceiver";
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        NotificationManager nm = (NotificationManager) context
+                .getSystemService(Context.NOTIFICATION_SERVICE);
+        String action = intent.getAction();
+        if (Config.LOGD) Log.d(TAG, "onReceiveIntent " + action);
+
+        if (action.equals(Intent.ACTION_MEDIA_MOUNTED)) {
+            nm.cancel(SDCARD_STATUS);
+
+            Intent statusIntent = new Intent(Intent.ACTION_MAIN, null);
+            statusIntent.setClass(context, SdCardSettings.class);
+            nm.notify(SDCARD_STATUS, new Notification(context,
+                    android.R.drawable.stat_notify_sdcard,
+                    null,
+                    System.currentTimeMillis(),
+                    context.getText(R.string.sdcard_setting),
+                    null,
+                    statusIntent));
+        } else if (action.equals(Intent.ACTION_MEDIA_REMOVED)) {
+            nm.cancel(SDCARD_STATUS);
+        } else if (action.equals(Intent.ACTION_MEDIA_SHARED)) {
+            nm.cancel(SDCARD_STATUS);
+
+            Intent statusIntent = new Intent(Intent.ACTION_MAIN, null);
+            statusIntent.setClass(context, SdCardSettings.class);
+            nm.notify(SDCARD_STATUS, new Notification(context,
+                    android.R.drawable.stat_notify_sdcard_usb,
+                    null,
+                    System.currentTimeMillis(),
+                    "SD Card",
+                    null,
+                    statusIntent));
+        }
+    }
+}
diff --git a/src/com/android/settings/SdCardSettings.java b/src/com/android/settings/SdCardSettings.java
new file mode 100644
index 0000000..b6935a2
--- /dev/null
+++ b/src/com/android/settings/SdCardSettings.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright (C) 2007 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.settings;
+
+import android.app.Activity;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.os.Environment;
+import android.os.IMountService;
+import android.os.ServiceManager;
+import android.os.StatFs;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.TextView;
+
+import java.io.File;
+
+
+public class SdCardSettings extends Activity
+{
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        setContentView(R.layout.sdcard_settings_screen);
+
+        mMountService = IMountService.Stub.asInterface(ServiceManager.getService("mount"));
+
+        mRemovedLayout = findViewById(R.id.removed);
+        mMountedLayout = findViewById(R.id.mounted);
+        mUnmountedLayout = findViewById(R.id.unmounted);
+        mScanningLayout = findViewById(R.id.scanning);
+        mSharedLayout = findViewById(R.id.shared);
+        mBadRemovalLayout = findViewById(R.id.bad_removal);
+        mReadOnlyStatus = findViewById(R.id.read_only);
+
+        mMassStorage = (CheckBox)findViewById(R.id.mass_storage);
+        mMassStorage.setOnClickListener(mMassStorageListener);
+
+        Button unmountButton = (Button)findViewById(R.id.sdcard_unmount);
+        unmountButton.setOnClickListener(mUnmountButtonHandler);
+
+        Button formatButton = (Button)findViewById(R.id.sdcard_format);
+        formatButton.setOnClickListener(mFormatButtonHandler);
+
+        mTotalSize = (TextView)findViewById(R.id.total);
+        mUsedSize = (TextView)findViewById(R.id.used);
+        mAvailableSize = (TextView)findViewById(R.id.available);
+
+        // install an intent filter to receive SD card related events.
+        IntentFilter intentFilter = new IntentFilter(Intent.ACTION_MEDIA_REMOVED);
+        intentFilter.addAction(Intent.ACTION_MEDIA_UNMOUNTED);
+        intentFilter.addAction(Intent.ACTION_MEDIA_MOUNTED);
+        intentFilter.addAction(Intent.ACTION_MEDIA_SHARED);
+        intentFilter.addAction(Intent.ACTION_MEDIA_CHECKING);
+        intentFilter.addAction(Intent.ACTION_MEDIA_NOFS);
+        intentFilter.addAction(Intent.ACTION_MEDIA_BAD_REMOVAL);
+        intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_STARTED);
+        intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_FINISHED);
+        intentFilter.addDataScheme("file");
+        registerReceiver(mReceiver, intentFilter);
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        update();
+    }
+
+    private void setLayout(View layout) {
+        mRemovedLayout.setVisibility(layout == mRemovedLayout ? View.VISIBLE : View.GONE);
+        mMountedLayout.setVisibility(layout == mMountedLayout ? View.VISIBLE : View.GONE);
+        mUnmountedLayout.setVisibility(layout == mUnmountedLayout ? View.VISIBLE : View.GONE);
+        mScanningLayout.setVisibility(layout == mScanningLayout ? View.VISIBLE : View.GONE);
+        mSharedLayout.setVisibility(layout == mSharedLayout ? View.VISIBLE : View.GONE);
+        mBadRemovalLayout.setVisibility(layout == mBadRemovalLayout ? View.VISIBLE : View.GONE);
+    }
+
+    private void update() {
+        try {
+            mMassStorage.setChecked(mMountService.getMassStorageEnabled());
+        } catch (RemoteException ex) {
+        }
+
+        String scanVolume = null; // this no longer exists: SystemProperties.get(MediaScanner.CURRENT_VOLUME_PROPERTY, "");
+        boolean scanning = "external".equals(scanVolume);
+
+        if (scanning) {
+            setLayout(mScanningLayout);
+        } else {
+            String status = Environment.getExternalStorageState();
+            boolean readOnly = false;
+
+            if (status.equals(Environment.MEDIA_MOUNTED_READ_ONLY)) {
+                status = Environment.MEDIA_MOUNTED;
+                readOnly = true;
+            }
+
+            if (status.equals(Environment.MEDIA_MOUNTED)) {
+                try {
+                    File path = Environment.getExternalStorageDirectory();
+                    StatFs stat = new StatFs(path.getPath());
+                    long blockSize = stat.getBlockSize();
+                    long totalBlocks = stat.getBlockCount();
+                    long availableBlocks = stat.getAvailableBlocks();
+
+                    mTotalSize.setText(formatSize(totalBlocks * blockSize));
+                    mUsedSize.setText(formatSize((totalBlocks - availableBlocks) * blockSize));
+                    mAvailableSize.setText(formatSize(availableBlocks * blockSize));
+                } catch (IllegalArgumentException e) {
+                    // this can occur if the SD card is removed, but we haven't received the
+                    // ACTION_MEDIA_REMOVED Intent yet.
+                    status = Environment.MEDIA_REMOVED;
+                }
+
+                mReadOnlyStatus.setVisibility(readOnly ? View.VISIBLE : View.GONE);
+                setLayout(mMountedLayout);
+            } else if (status.equals(Environment.MEDIA_UNMOUNTED)) {
+                setLayout(mUnmountedLayout);
+            } else if (status.equals(Environment.MEDIA_REMOVED)) {
+                setLayout(mRemovedLayout);
+            } else if (status.equals(Environment.MEDIA_SHARED)) {
+                setLayout(mSharedLayout);
+            } else if (status.equals(Environment.MEDIA_BAD_REMOVAL)) {
+                setLayout(mBadRemovalLayout);
+            }
+        }
+    }
+
+    private String formatSize(long size) {
+        String suffix = null;
+
+        // add K or M suffix if size is greater than 1K or 1M
+        if (size >= 1024) {
+            suffix = "K";
+            size /= 1024;
+            if (size >= 1024) {
+                suffix = "M";
+                size /= 1024;
+            }
+        }
+
+        StringBuilder resultBuffer = new StringBuilder(Long.toString(size));
+
+        int commaOffset = resultBuffer.length() - 3;
+        while (commaOffset > 0) {
+            resultBuffer.insert(commaOffset, ',');
+            commaOffset -= 3;
+        }
+
+        if (suffix != null)
+            resultBuffer.append(suffix);
+        return resultBuffer.toString();
+    }
+
+    OnClickListener mMassStorageListener = new OnClickListener() {
+        public void onClick(View v) {
+            try {
+                mMountService.setMassStorageEnabled(mMassStorage.isChecked());
+            } catch (RemoteException ex) {
+            }
+        }
+    };
+
+    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            update();
+        }
+    };
+
+    OnClickListener mUnmountButtonHandler = new OnClickListener() {
+        public void onClick(View v) {
+            try {
+                mMountService.unmountMedia(Environment.getExternalStorageDirectory().toString());
+            } catch (RemoteException ex) {
+            }
+        }
+    };
+
+    OnClickListener mFormatButtonHandler = new OnClickListener() {
+        public void onClick(View v) {
+            try {
+                mMountService.formatMedia(Environment.getExternalStorageDirectory().toString());
+            } catch (RemoteException ex) {
+            }
+        }
+    };
+
+
+    private int         mStatus;
+    private IMountService   mMountService;
+
+    private CheckBox    mMassStorage;
+
+    private TextView    mTotalSize;
+    private TextView    mUsedSize;
+    private TextView    mAvailableSize;
+
+    private View        mRemovedLayout;
+    private View        mMountedLayout;
+    private View        mUnmountedLayout;
+    private View        mScanningLayout;
+    private View        mSharedLayout;
+    private View        mBadRemovalLayout;
+    private View        mReadOnlyStatus;
+}
diff --git a/src/com/android/settings/SecuritySettings.java b/src/com/android/settings/SecuritySettings.java
new file mode 100644
index 0000000..cd26492
--- /dev/null
+++ b/src/com/android/settings/SecuritySettings.java
@@ -0,0 +1,304 @@
+/*
+ * Copyright (C) 2007 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.settings;
+
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.location.LocationManager;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceCategory;
+import android.preference.PreferenceScreen;
+import android.provider.Settings;
+import android.util.Config;
+import android.util.Log;
+
+import com.android.internal.widget.LockPatternUtils;
+
+/**
+ * Gesture lock pattern settings.
+ */
+public class SecuritySettings extends PreferenceActivity
+    implements SharedPreferences.OnSharedPreferenceChangeListener {
+
+    // Lock Settings
+    
+    private static final String KEY_LOCK_ENABLED = "lockenabled";
+    private static final String KEY_VISIBLE_PATTERN = "visiblepattern";
+    private static final String KEY_TACTILE_FEEDBACK_ENABLED = "tactilefeedback";
+    private static final int CONFIRM_PATTERN_THEN_DISABLE_REQUEST_CODE = 55;
+    private static final int CONFIRM_PATTERN_THEN_ENABLE_REQUEST_CODE = 56;
+
+    private LockPatternUtils mLockPatternUtils;
+    private CheckBoxPreference mLockEnabled;
+    private CheckBoxPreference mVisiblePattern;
+    private CheckBoxPreference mTactileFeedback;
+    private Preference mChoosePattern;
+
+    private CheckBoxPreference mShowPassword;
+    
+    // Location Settings
+    
+    private static final String LOCATION_NETWORK = "location_network";
+    private static final String LOCATION_GPS = "location_gps";
+
+    private CheckBoxPreference mNetwork;
+    private CheckBoxPreference mGps;
+    private LocationManager mLocationManager;
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        addPreferencesFromResource(R.xml.security_settings);
+
+        mLockPatternUtils = new LockPatternUtils(getContentResolver());
+
+        createPreferenceHierarchy();
+        
+        // Get the available location providers
+        mLocationManager = (LocationManager)
+            getSystemService(Context.LOCATION_SERVICE);
+
+        mNetwork = (CheckBoxPreference) getPreferenceScreen().findPreference(LOCATION_NETWORK);
+        mGps = (CheckBoxPreference) getPreferenceScreen().findPreference(LOCATION_GPS);
+        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
+        updateToggles();
+    }
+
+    private PreferenceScreen createPreferenceHierarchy() {
+        // Root
+        PreferenceScreen root = this.getPreferenceScreen();
+
+        // Inline preferences
+        PreferenceCategory inlinePrefCat = new PreferenceCategory(this);
+        inlinePrefCat.setTitle(R.string.lock_settings_title);
+        root.addPreference(inlinePrefCat);
+
+        // autolock toggle
+        mLockEnabled = new LockEnabledPref(this);
+        mLockEnabled.setTitle(R.string.lockpattern_settings_enable_title);
+        mLockEnabled.setSummary(R.string.lockpattern_settings_enable_summary);
+        mLockEnabled.setKey(KEY_LOCK_ENABLED);
+        inlinePrefCat.addPreference(mLockEnabled);
+
+        // visible pattern
+        mVisiblePattern = new CheckBoxPreference(this);
+        mVisiblePattern.setKey(KEY_VISIBLE_PATTERN);
+        mVisiblePattern.setTitle(R.string.lockpattern_settings_enable_visible_pattern_title);
+        inlinePrefCat.addPreference(mVisiblePattern);
+
+        // tactile feedback
+        mTactileFeedback = new CheckBoxPreference(this);
+        mTactileFeedback.setKey(KEY_TACTILE_FEEDBACK_ENABLED);
+        mTactileFeedback.setTitle(R.string.lockpattern_settings_enable_tactile_feedback_title);
+        inlinePrefCat.addPreference(mTactileFeedback);
+
+        // change pattern lock
+        Intent intent = new Intent();
+        intent.setClassName("com.android.settings",
+                    "com.android.settings.ChooseLockPatternTutorial");
+        mChoosePattern = getPreferenceManager().createPreferenceScreen(this);
+        mChoosePattern.setIntent(intent);
+        inlinePrefCat.addPreference(mChoosePattern);
+        
+        PreferenceScreen simLockPreferences = getPreferenceManager()
+                .createPreferenceScreen(this);
+        simLockPreferences.setTitle(R.string.sim_lock_settings_category);
+        // Intent to launch SIM lock settings
+        intent = new Intent();
+        intent.setClassName("com.android.settings", "com.android.settings.SimLockSettings");
+        simLockPreferences.setIntent(intent);
+        
+        PreferenceCategory simLockCat = new PreferenceCategory(this);
+        simLockCat.setTitle(R.string.sim_lock_settings_title);
+        root.addPreference(simLockCat);
+        simLockCat.addPreference(simLockPreferences);
+
+        // Passwords
+        PreferenceCategory passwordsCat = new PreferenceCategory(this);
+        passwordsCat.setTitle(R.string.security_passwords_title);
+        root.addPreference(passwordsCat);
+        
+        CheckBoxPreference showPassword = mShowPassword = new CheckBoxPreference(this);
+        showPassword.setKey("show_password");
+        showPassword.setTitle(R.string.show_password);
+        showPassword.setSummary(R.string.show_password_summary);
+        showPassword.setPersistent(false);
+        passwordsCat.addPreference(showPassword);
+        
+        return root;
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        boolean patternExists = mLockPatternUtils.savedPatternExists();
+        mLockEnabled.setEnabled(patternExists);
+        mVisiblePattern.setEnabled(patternExists);
+        mTactileFeedback.setEnabled(patternExists);
+
+        mLockEnabled.setChecked(mLockPatternUtils.isLockPatternEnabled());
+        mVisiblePattern.setChecked(mLockPatternUtils.isVisiblePatternEnabled());
+        mTactileFeedback.setChecked(mLockPatternUtils.isTactileFeedbackEnabled());
+
+        int chooseStringRes = mLockPatternUtils.savedPatternExists() ?
+                R.string.lockpattern_settings_change_lock_pattern :
+                R.string.lockpattern_settings_choose_lock_pattern;
+        mChoosePattern.setTitle(chooseStringRes);
+        
+        mShowPassword
+                .setChecked(Settings.System.getInt(getContentResolver(),
+                Settings.System.TEXT_SHOW_PASSWORD, 1) != 0);
+    }
+
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
+            Preference preference) {
+        final String key = preference.getKey();
+
+        if (KEY_LOCK_ENABLED.equals(key)) {
+            mLockPatternUtils.setLockPatternEnabled(isToggled(preference));
+        } else if (KEY_VISIBLE_PATTERN.equals(key)) {
+            mLockPatternUtils.setVisiblePatternEnabled(isToggled(preference));
+        } else if (KEY_TACTILE_FEEDBACK_ENABLED.equals(key)) {
+            mLockPatternUtils.setTactileFeedbackEnabled(isToggled(preference));
+        } else if (preference == mShowPassword) {
+            Settings.System.putInt(getContentResolver(), Settings.System.TEXT_SHOW_PASSWORD,
+                    mShowPassword.isChecked() ? 1 : 0);
+        }
+        
+        return false;
+    }
+
+    /*
+     * Creates toggles for each available location provider
+     */
+    private void updateToggles() {
+        String providers = getAllowedProviders();
+        mNetwork.setChecked(providers.contains(LocationManager.NETWORK_PROVIDER));
+        mGps.setChecked(providers.contains(LocationManager.GPS_PROVIDER));
+    }
+
+    private void updateProviders() {
+        String preferredProviders = "";
+        if (mNetwork.isChecked()) {
+            preferredProviders += LocationManager.NETWORK_PROVIDER;
+        }
+        if (mGps.isChecked()) {
+            preferredProviders += "," + LocationManager.GPS_PROVIDER;
+        }
+        setProviders(preferredProviders);
+    }
+
+    private void setProviders(String providers) {
+        // Update the secure setting LOCATION_PROVIDERS_ALLOWED
+        Settings.Secure.putString(getContentResolver(),
+            Settings.Secure.LOCATION_PROVIDERS_ALLOWED, providers);
+        if (Config.LOGV) {
+            Log.v("Location Accuracy", "Setting LOCATION_PROVIDERS_ALLOWED = " + providers);
+        }
+        // Inform the location manager about the changes
+        mLocationManager.updateProviders();
+    }
+
+    /**
+     * @return string containing a list of providers that have been enabled for use
+     */
+    private String getAllowedProviders() {
+        String allowedProviders =
+            Settings.Secure.getString(getContentResolver(),
+                Settings.Secure.LOCATION_PROVIDERS_ALLOWED);
+        if (allowedProviders == null) {
+            allowedProviders = "";
+        }
+        return allowedProviders;
+    }
+
+    public void onSharedPreferenceChanged(SharedPreferences preferences, String key) {
+        if (LOCATION_NETWORK.equals(key) || LOCATION_GPS.equals(key)) {
+            updateProviders();
+        }
+    }
+
+    private boolean isToggled(Preference pref) {
+        return ((CheckBoxPreference) pref).isChecked();
+    }
+
+
+    /**
+     * For the user to disable keyguard, we first make them verify their
+     * existing pattern.
+     */
+    private class LockEnabledPref extends CheckBoxPreference {
+
+        public LockEnabledPref(Context context) {
+            super(context);
+        }
+
+        @Override
+        protected void onClick() {
+            if (mLockPatternUtils.savedPatternExists()) {
+                if (isChecked()) {
+                    confirmPatternThenDisable();
+                } else {
+                    confirmPatternThenEnable();
+                }
+            } else {
+                super.onClick();
+            }
+        }
+    }
+
+    private void confirmPatternThenEnable() {
+        final Intent intent = new Intent();
+        intent.setClassName("com.android.settings", "com.android.settings.ConfirmLockPattern");
+        startActivityForResult(intent, CONFIRM_PATTERN_THEN_ENABLE_REQUEST_CODE);
+    }
+
+    /**
+     * Launch screen to confirm the existing lock pattern.
+     * @see #onActivityResult(int, int, android.content.Intent)
+     */
+    private void confirmPatternThenDisable() {
+        final Intent intent = new Intent();
+        intent.setClassName("com.android.settings", "com.android.settings.ConfirmLockPattern");
+        startActivityForResult(intent, CONFIRM_PATTERN_THEN_DISABLE_REQUEST_CODE);
+    }
+
+    /**
+     * @see #confirmPatternThenDisable
+     */
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode,
+            Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+
+        final boolean resultOk = resultCode == Activity.RESULT_OK;
+
+        if ((requestCode == CONFIRM_PATTERN_THEN_DISABLE_REQUEST_CODE) && resultOk) {
+            mLockPatternUtils.setLockPatternEnabled(false);
+        } else if ((requestCode == CONFIRM_PATTERN_THEN_ENABLE_REQUEST_CODE) && resultOk) {
+            mLockPatternUtils.setLockPatternEnabled(true);
+        }
+    }
+}
diff --git a/src/com/android/settings/Settings.java b/src/com/android/settings/Settings.java
new file mode 100644
index 0000000..0c4545e
--- /dev/null
+++ b/src/com/android/settings/Settings.java
@@ -0,0 +1,46 @@
+/*
+ * 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.settings;
+
+import android.os.Bundle;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceGroup;
+import android.provider.Settings.System;
+
+public class Settings extends PreferenceActivity {
+
+    private static final String KEY_PARENT = "parent";
+    private static final String KEY_CALL_SETTINGS = "call_settings";
+    private static final String KEY_SYNC_SETTINGS = "sync_settings";
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        
+        addPreferencesFromResource(R.xml.settings);
+        
+        PreferenceGroup parent = (PreferenceGroup) findPreference(KEY_PARENT);
+        Utils.updatePreferenceToSpecificActivityOrRemove(this, parent, KEY_SYNC_SETTINGS, 0);
+    }
+    
+    @Override
+    protected void onResume() {
+        super.onResume();
+        findPreference(KEY_CALL_SETTINGS).setEnabled(!AirplaneModeEnabler.isAirplaneModeOn(this));
+    }
+
+}
diff --git a/src/com/android/settings/SettingsLicenseActivity.java b/src/com/android/settings/SettingsLicenseActivity.java
new file mode 100644
index 0000000..0b809e1
--- /dev/null
+++ b/src/com/android/settings/SettingsLicenseActivity.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2007 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.settings;
+
+import android.os.Bundle;
+import android.os.SystemProperties;
+import android.text.TextUtils;
+import android.util.Config;
+import android.util.Log;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import android.widget.Toast;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.zip.GZIPInputStream;
+
+import com.android.internal.app.AlertActivity;
+import com.android.internal.app.AlertController;
+
+/**
+ * The "dialog" that shows from "License" in the Settings app.
+ */
+public class SettingsLicenseActivity extends AlertActivity {
+
+    private static final String TAG = "SettingsLicenseActivity";
+    private static final boolean LOGV = false || Config.LOGV;
+
+    private static final String DEFAULT_LICENSE_PATH = "/system/etc/NOTICE.html.gz";
+    private static final String PROPERTY_LICENSE_PATH = "ro.config.license_path";
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        String fileName = SystemProperties.get(PROPERTY_LICENSE_PATH, DEFAULT_LICENSE_PATH);
+        if (TextUtils.isEmpty(fileName)) {
+            Log.e(TAG, "The system property for the license file is empty.");
+            showErrorAndFinish();
+            return;
+        }
+
+        InputStreamReader inputReader = null;
+        StringBuilder data = null;
+        try {
+            data = new StringBuilder(2048);
+            char tmp[] = new char[2048];
+            int numRead;
+            if (fileName.endsWith(".gz")) {
+                inputReader = new InputStreamReader(
+                    new GZIPInputStream(new FileInputStream(fileName)));
+            } else {
+                inputReader = new FileReader(fileName);
+            }
+            while ((numRead = inputReader.read(tmp)) >= 0) {
+                data.append(tmp, 0, numRead);
+            }
+        } catch (FileNotFoundException e) {
+            Log.e(TAG, "License HTML file not found at " + fileName, e);
+            showErrorAndFinish();
+            return;
+        } catch (IOException e) {
+            Log.e(TAG, "Error reading license HTML file at " + fileName, e);
+            showErrorAndFinish();
+            return;
+        } finally {
+            try {
+                if (inputReader != null) {
+                    inputReader.close();
+                }
+            } catch (IOException e) {
+            }
+        }
+
+        if (TextUtils.isEmpty(data)) {
+            Log.e(TAG, "License HTML is empty (from " + fileName + ")");
+            showErrorAndFinish();
+            return;
+        }
+
+        WebView webView = new WebView(this);
+
+        // Begin the loading.  This will be done in a separate thread in WebView.
+        webView.loadDataWithBaseURL(null, data.toString(), "text/html", "utf-8", null);
+        webView.setWebViewClient(new WebViewClient() {
+            @Override
+            public void onPageFinished(WebView view, String url) {
+                // Change from 'Loading...' to the real title
+                mAlert.setTitle(getString(R.string.settings_license_activity_title));
+            }
+        });
+
+        final AlertController.AlertParams p = mAlertParams;
+        p.mTitle = getString(R.string.settings_license_activity_loading);
+        p.mView = webView;
+        p.mForceInverseBackground = true;
+        setupAlert();
+    }
+
+    private void showErrorAndFinish() {
+        Toast.makeText(this, R.string.settings_license_activity_unavailable, Toast.LENGTH_LONG)
+                .show();
+        finish();
+    }
+
+}
diff --git a/src/com/android/settings/SimLockSettings.java b/src/com/android/settings/SimLockSettings.java
new file mode 100644
index 0000000..286e3d6
--- /dev/null
+++ b/src/com/android/settings/SimLockSettings.java
@@ -0,0 +1,321 @@
+/*
+ * 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.settings;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.os.AsyncResult;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.CheckBoxPreference;
+import android.preference.PreferenceScreen;
+import com.android.internal.telephony.Phone;
+import com.android.internal.telephony.PhoneFactory;
+import android.widget.Toast;
+
+/**
+ * Implements the preference screen to enable/disable SIM lock and
+ * also the dialogs to change the SIM PIN. In the former case, enabling/disabling
+ * the SIM lock will prompt the user for the current PIN.
+ * In the Change PIN case, it prompts the user for old pin, new pin and new pin
+ * again before attempting to change it. Calls the SimCard interface to execute
+ * these operations.
+ *
+ */
+public class SimLockSettings extends PreferenceActivity 
+        implements EditPinPreference.OnPinEnteredListener {
+
+    private static final int OFF_MODE = 0;
+    // State when enabling/disabling SIM lock
+    private static final int SIM_LOCK_MODE = 1;
+    // State when entering the old pin
+    private static final int SIM_OLD_MODE = 2;
+    // State when entering the new pin - first time
+    private static final int SIM_NEW_MODE = 3;
+    // State when entering the new pin - second time
+    private static final int SIM_REENTER_MODE = 4;
+    
+    // Keys in xml file
+    private static final String PIN_DIALOG = "sim_pin";
+    private static final String PIN_TOGGLE = "sim_toggle";
+    // Keys in icicle
+    private static final String DIALOG_STATE = "dialogState";
+    private static final String DIALOG_PIN = "dialogPin";
+    private static final String DIALOG_ERROR = "dialogError";
+    private static final String ENABLE_TO_STATE = "enableState";
+    
+    private static final int MIN_PIN_LENGTH = 4;
+    private static final int MAX_PIN_LENGTH = 8;
+    // Which dialog to show next when popped up
+    private int mDialogState = OFF_MODE;
+    
+    private String mPin;
+    private String mOldPin;
+    private String mNewPin;
+    private String mError;
+    // Are we trying to enable or disable SIM lock?
+    private boolean mToState;
+    
+    private Phone mPhone;
+    
+    private EditPinPreference mPinDialog;
+    private CheckBoxPreference mPinToggle;
+    
+    private Resources mRes;
+
+    // For async handler to identify request type
+    private static final int ENABLE_SIM_PIN_COMPLETE = 100;
+    private static final int CHANGE_SIM_PIN_COMPLETE = 101;
+
+    // For replies from SimCard interface
+    private Handler mHandler = new Handler() {
+        public void handleMessage(Message msg) {
+            AsyncResult ar = (AsyncResult) msg.obj;
+            switch (msg.what) {
+                case ENABLE_SIM_PIN_COMPLETE:
+                    simLockChanged(ar.exception == null);
+                    break;
+                case CHANGE_SIM_PIN_COMPLETE:
+                    simPinChanged(ar.exception == null);
+                    break;
+            }
+
+            return;
+        }
+    };
+    
+    // For top-level settings screen to query
+    static boolean isSimLockEnabled() {
+        return PhoneFactory.getDefaultPhone().getSimCard().getSimLockEnabled();
+    }
+    
+    static String getSummary(Context context) {
+        Resources res = context.getResources();
+        String summary = isSimLockEnabled() 
+                ? res.getString(R.string.sim_lock_on) 
+                : res.getString(R.string.sim_lock_off);
+        return summary;
+    }
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+    
+        addPreferencesFromResource(R.xml.sim_lock_settings);
+        
+        mPinDialog = (EditPinPreference) findPreference(PIN_DIALOG);
+        mPinToggle = (CheckBoxPreference) findPreference(PIN_TOGGLE);
+        if (savedInstanceState != null && savedInstanceState.containsKey(DIALOG_STATE)) {
+            mDialogState = savedInstanceState.getInt(DIALOG_STATE);
+            mPin = savedInstanceState.getString(DIALOG_PIN);
+            mError = savedInstanceState.getString(DIALOG_ERROR);
+            mToState = savedInstanceState.getBoolean(ENABLE_TO_STATE);
+        }
+
+        mPinDialog.setOnPinEnteredListener(this);
+        
+        // Don't need any changes to be remembered
+        getPreferenceScreen().setPersistent(false);
+        
+        mPhone = PhoneFactory.getDefaultPhone();
+        mRes = getResources();
+    }
+    
+    @Override
+    protected void onResume() {
+        super.onResume();
+        
+        mPinToggle.setChecked(mPhone.getSimCard().getSimLockEnabled());
+        
+        if (mDialogState != OFF_MODE) {
+            showPinDialog();
+        } else {
+            // Prep for standard click on "Change PIN"
+            resetDialogState();
+        }
+    }
+    
+    @Override
+    protected void onSaveInstanceState(Bundle out) {
+        // Need to store this state for slider open/close
+        // There is one case where the dialog is popped up by the preference
+        // framework. In that case, let the preference framework store the
+        // dialog state. In other cases, where this activity manually launches
+        // the dialog, store the state of the dialog.
+        if (mPinDialog.isDialogOpen()) {
+            out.putInt(DIALOG_STATE, mDialogState);
+            out.putString(DIALOG_PIN, mPinDialog.getEditText().getText().toString());
+            out.putString(DIALOG_ERROR, mError);
+            out.putBoolean(ENABLE_TO_STATE, mToState);
+        } else {
+            super.onSaveInstanceState(out);
+        }
+    }
+
+    private void showPinDialog() {
+        if (mDialogState == OFF_MODE) {
+            return;
+        }
+        setDialogValues();
+        
+        mPinDialog.showPinDialog();
+    }
+    
+    private void setDialogValues() {
+        mPinDialog.setText(mPin);
+        String message = "";
+        switch (mDialogState) {
+            case SIM_LOCK_MODE:
+                message = mRes.getString(R.string.sim_enter_pin);
+                mPinDialog.setDialogTitle(mToState 
+                        ? mRes.getString(R.string.sim_enable_sim_lock)
+                        : mRes.getString(R.string.sim_disable_sim_lock));
+                break;
+            case SIM_OLD_MODE:
+                message = mRes.getString(R.string.sim_enter_old);
+                mPinDialog.setDialogTitle(mRes.getString(R.string.sim_change_pin));
+                break;
+            case SIM_NEW_MODE:
+                message = mRes.getString(R.string.sim_enter_new);
+                mPinDialog.setDialogTitle(mRes.getString(R.string.sim_change_pin));
+                break;
+            case SIM_REENTER_MODE:
+                message = mRes.getString(R.string.sim_reenter_new);
+                mPinDialog.setDialogTitle(mRes.getString(R.string.sim_change_pin));
+                break;
+        }
+        if (mError != null) {
+            message = mError + "\n" + message;
+            mError = null;
+        }
+        mPinDialog.setDialogMessage(message);
+    }
+
+    public void onPinEntered(EditPinPreference preference, boolean positiveResult) {
+        if (!positiveResult) {
+            resetDialogState();
+            return;
+        }
+        
+        mPin = preference.getText();
+        if (!reasonablePin(mPin)) {
+            // inject error message and display dialog again
+            mError = mRes.getString(R.string.sim_bad_pin);
+            showPinDialog();
+            return;
+        }
+        switch (mDialogState) {
+            case SIM_LOCK_MODE:
+                tryChangeSimLockState();
+                break;
+            case SIM_OLD_MODE:
+                mOldPin = mPin;
+                mDialogState = SIM_NEW_MODE;
+                mError = null;
+                mPin = null;
+                showPinDialog();
+                break;
+            case SIM_NEW_MODE:
+                mNewPin = mPin;
+                mDialogState = SIM_REENTER_MODE;
+                mPin = null;
+                showPinDialog();
+                break;
+            case SIM_REENTER_MODE:
+                if (!mPin.equals(mNewPin)) {
+                    mError = mRes.getString(R.string.sim_pins_dont_match);
+                    mDialogState = SIM_NEW_MODE;
+                    mPin = null;
+                    showPinDialog();
+                } else {
+                    mError = null;
+                    tryChangePin();
+                }
+                break;
+        }
+    }
+    
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
+        if (preference == mPinToggle) {
+            // Get the new, preferred state
+            mToState = mPinToggle.isChecked();
+            // Flip it back and pop up pin dialog  
+            mPinToggle.setChecked(!mToState);  
+            mDialogState = SIM_LOCK_MODE;
+            showPinDialog();
+        }
+        return true;
+    }
+    
+    private void tryChangeSimLockState() {
+        // Try to change sim lock. If it succeeds, toggle the lock state and 
+        // reset dialog state. Else inject error message and show dialog again.
+        Message callback = Message.obtain(mHandler, ENABLE_SIM_PIN_COMPLETE);
+        mPhone.getSimCard().setSimLockEnabled(mToState, mPin, callback);
+
+    }
+    
+    private void simLockChanged(boolean success) {
+        if (success) {
+            mPinToggle.setChecked(mToState);
+        } else {
+            // TODO: I18N
+            Toast.makeText(this, mRes.getString(R.string.sim_lock_failed), Toast.LENGTH_SHORT)
+                    .show();
+        }
+        resetDialogState();
+    }
+
+    private void simPinChanged(boolean success) {
+        if (!success) {
+         // TODO: I18N
+            Toast.makeText(this, mRes.getString(R.string.sim_change_failed), 
+                    Toast.LENGTH_SHORT)
+                    .show();
+        } else {
+            Toast.makeText(this, mRes.getString(R.string.sim_change_succeeded), 
+                    Toast.LENGTH_SHORT)
+                    .show();
+
+        }
+        resetDialogState();
+    }
+
+    private void tryChangePin() {
+        Message callback = Message.obtain(mHandler, CHANGE_SIM_PIN_COMPLETE);
+        mPhone.getSimCard().changeSimLockPassword(mOldPin,
+                mNewPin, callback);
+    }
+    
+    private boolean reasonablePin(String pin) {
+        if (pin == null || pin.length() < MIN_PIN_LENGTH || pin.length() > MAX_PIN_LENGTH) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+ 
+    private void resetDialogState() {
+        mError = null;
+        mDialogState = SIM_OLD_MODE; // Default for when Change PIN is clicked
+        mPin = "";
+        setDialogValues();
+    }
+}
diff --git a/src/com/android/settings/SoundAndDisplaySettings.java b/src/com/android/settings/SoundAndDisplaySettings.java
new file mode 100644
index 0000000..53912e3
--- /dev/null
+++ b/src/com/android/settings/SoundAndDisplaySettings.java
@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) 2007 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.settings;
+
+import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT;
+
+import android.content.BroadcastReceiver;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.media.AudioManager;
+import android.os.Bundle;
+import android.os.IMountService;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.preference.ListPreference;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceScreen;
+import android.preference.CheckBoxPreference;
+import android.provider.Settings;
+import android.util.Log;
+import android.view.IWindowManager;
+
+public class SoundAndDisplaySettings extends PreferenceActivity implements
+        Preference.OnPreferenceChangeListener {
+    private static final String TAG = "SoundAndDisplaysSettings";
+
+    /** If there is no setting in the provider, use this. */
+    private static final int FALLBACK_SCREEN_TIMEOUT_VALUE = 30000;
+    
+    private static final String KEY_SILENT = "silent";
+    private static final String KEY_VIBRATE = "vibrate";
+    private static final String KEY_SCREEN_TIMEOUT = "screen_timeout";
+    private static final String KEY_DTMF_TONE = "dtmf_tone";
+    private static final String KEY_SOUND_EFFECTS = "sound_effects";
+    private static final String KEY_ANIMATIONS = "animations";
+    private static final String KEY_PLAY_MEDIA_NOTIFICATION_SOUNDS = "play_media_notification_sounds";
+    
+    private CheckBoxPreference mSilent;
+
+    private CheckBoxPreference mPlayMediaNotificationSounds;
+
+    private IMountService mMountService = null;
+
+    /*
+     * If we are currently in one of the silent modes (the ringer mode is set to either
+     * "silent mode" or "vibrate mode"), then toggling the "Phone vibrate"
+     * preference will switch between "silent mode" and "vibrate mode".
+     * Otherwise, it will adjust the normal ringer mode's ring or ring+vibrate
+     * setting.
+     */
+    private CheckBoxPreference mVibrate;
+    private CheckBoxPreference mDtmfTone;
+    private CheckBoxPreference mSoundEffects;
+    private CheckBoxPreference mAnimations;
+    private float[] mAnimationScales;
+    
+    private AudioManager mAudioManager;
+    
+    private IWindowManager mWindowManager;
+
+    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            updateState(false);
+        }
+    };
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        ContentResolver resolver = getContentResolver();
+        
+        mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
+        mWindowManager = IWindowManager.Stub.asInterface(ServiceManager.getService("window"));
+
+        mMountService = IMountService.Stub.asInterface(ServiceManager.getService("mount"));
+        
+        addPreferencesFromResource(R.xml.sound_and_display_settings);
+        
+        mSilent = (CheckBoxPreference) findPreference(KEY_SILENT);
+        mPlayMediaNotificationSounds = (CheckBoxPreference) findPreference(KEY_PLAY_MEDIA_NOTIFICATION_SOUNDS);
+
+        mVibrate = (CheckBoxPreference) findPreference(KEY_VIBRATE);
+        mDtmfTone = (CheckBoxPreference) findPreference(KEY_DTMF_TONE);
+        mDtmfTone.setPersistent(false);
+        mDtmfTone.setChecked(Settings.System.getInt(resolver,
+                Settings.System.DTMF_TONE_WHEN_DIALING, 1) != 0);
+        mSoundEffects = (CheckBoxPreference) findPreference(KEY_SOUND_EFFECTS);
+        mSoundEffects.setPersistent(false);
+        mSoundEffects.setChecked(Settings.System.getInt(resolver,
+                Settings.System.SOUND_EFFECTS_ENABLED, 0) != 0);
+        mAnimations = (CheckBoxPreference) findPreference(KEY_ANIMATIONS);
+        mAnimations.setPersistent(false);
+        
+        ListPreference screenTimeoutPreference =
+            (ListPreference) findPreference(KEY_SCREEN_TIMEOUT);
+        screenTimeoutPreference.setValue(String.valueOf(Settings.System.getInt(
+                resolver, SCREEN_OFF_TIMEOUT, FALLBACK_SCREEN_TIMEOUT_VALUE)));
+        screenTimeoutPreference.setOnPreferenceChangeListener(this);
+    }
+    
+    @Override
+    protected void onResume() {
+        super.onResume();
+        
+        updateState(true);
+        
+        IntentFilter filter = new IntentFilter(AudioManager.RINGER_MODE_CHANGED_ACTION);
+        registerReceiver(mReceiver, filter);
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        unregisterReceiver(mReceiver);
+    }
+
+    private void updateState(boolean force) {
+        final int ringerMode = mAudioManager.getRingerMode();
+        final boolean silentOrVibrateMode =
+                ringerMode != AudioManager.RINGER_MODE_NORMAL;
+        
+        if (silentOrVibrateMode != mSilent.isChecked() || force) {
+            mSilent.setChecked(silentOrVibrateMode);
+        }
+
+        try {
+            mPlayMediaNotificationSounds.setChecked(mMountService.getPlayNotificationSounds());
+        } catch (RemoteException e) {
+        }
+       
+        boolean vibrateSetting;
+        if (silentOrVibrateMode) {
+            vibrateSetting = ringerMode == AudioManager.RINGER_MODE_VIBRATE;
+        } else {
+            vibrateSetting = mAudioManager.getVibrateSetting(AudioManager.VIBRATE_TYPE_RINGER)
+                    == AudioManager.VIBRATE_SETTING_ON;            
+        }
+        if (vibrateSetting != mVibrate.isChecked() || force) {
+            mVibrate.setChecked(vibrateSetting);
+        }
+        
+        boolean animations = true;
+        try {
+            mAnimationScales = mWindowManager.getAnimationScales();
+        } catch (RemoteException e) {
+        }
+        if (mAnimationScales != null) {
+            for (int i=0; i<mAnimationScales.length; i++) {
+                if (mAnimationScales[i] == 0) {
+                    animations = false;
+                    break;
+                }
+            }
+        }
+        if (animations != mAnimations.isChecked() || force) {
+            mAnimations.setChecked(animations);
+        }
+    }
+
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
+
+        if (preference == mSilent) {
+            final boolean silent = mSilent.isChecked();
+            mAudioManager.setRingerMode(silent ? AudioManager.RINGER_MODE_SILENT
+                    : AudioManager.RINGER_MODE_NORMAL);
+            updateState(false);
+            
+        } else if (preference == mPlayMediaNotificationSounds) {
+            try {
+                mMountService.setPlayNotificationSounds(mPlayMediaNotificationSounds.isChecked());
+            } catch (RemoteException e) {
+            }
+        } else if (preference == mVibrate) {
+            final boolean vibrate = mVibrate.isChecked();
+            final boolean silent = mSilent.isChecked();
+            
+            if (silent) {
+                mAudioManager.setRingerMode(vibrate ? AudioManager.RINGER_MODE_VIBRATE :
+                    AudioManager.RINGER_MODE_SILENT);                
+            } else {
+                mAudioManager.setVibrateSetting(AudioManager.VIBRATE_TYPE_RINGER,
+                        vibrate ? AudioManager.VIBRATE_SETTING_ON
+                                : AudioManager.VIBRATE_SETTING_OFF);
+            }
+            
+        } else if (preference == mDtmfTone) {
+            Settings.System.putInt(getContentResolver(), Settings.System.DTMF_TONE_WHEN_DIALING,
+                    mDtmfTone.isChecked() ? 1 : 0);
+            
+        } else if (preference == mSoundEffects) {
+            if (mSoundEffects.isChecked()) {
+                mAudioManager.loadSoundEffects();
+            } else {
+                mAudioManager.unloadSoundEffects();
+            }
+            Settings.System.putInt(getContentResolver(), Settings.System.SOUND_EFFECTS_ENABLED,
+                    mSoundEffects.isChecked() ? 1 : 0);
+            
+        } else if (preference == mAnimations) {
+            for (int i=0; i<mAnimationScales.length; i++) {
+                mAnimationScales[i] = mAnimations.isChecked() ? 1 : 0;
+            }
+            try {
+                mWindowManager.setAnimationScales(mAnimationScales);
+            } catch (RemoteException e) {
+            }
+        }
+        return true;
+    }
+
+    public boolean onPreferenceChange(Preference preference, Object objValue) {
+        if (KEY_SCREEN_TIMEOUT.equals(preference.getKey())) {
+            int value = Integer.parseInt((String) objValue);
+            try {
+                Settings.System.putInt(getContentResolver(), 
+                        SCREEN_OFF_TIMEOUT, value);
+            } catch (NumberFormatException e) {
+                Log.e(TAG, "could not persist screen timeout setting", e);
+            }
+        }
+        
+        return true;
+    }
+
+}
diff --git a/src/com/android/settings/TestingSettings.java b/src/com/android/settings/TestingSettings.java
new file mode 100644
index 0000000..3994560
--- /dev/null
+++ b/src/com/android/settings/TestingSettings.java
@@ -0,0 +1,31 @@
+/*
+ * 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.settings;
+
+import android.os.Bundle;
+import android.preference.PreferenceActivity;
+
+public class TestingSettings extends PreferenceActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        
+        addPreferencesFromResource(R.xml.testing_settings);
+    }
+
+}
diff --git a/src/com/android/settings/TestingSettingsBroadcastReceiver.java b/src/com/android/settings/TestingSettingsBroadcastReceiver.java
new file mode 100644
index 0000000..c6cd7e1
--- /dev/null
+++ b/src/com/android/settings/TestingSettingsBroadcastReceiver.java
@@ -0,0 +1,28 @@
+package com.android.settings;
+
+import android.provider.Telephony;
+import static android.provider.Telephony.Intents.SECRET_CODE_ACTION;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.BroadcastReceiver;
+import android.util.Config;
+import android.util.Log;
+import android.view.KeyEvent;
+
+
+public class TestingSettingsBroadcastReceiver extends BroadcastReceiver {
+  
+    public TestingSettingsBroadcastReceiver() {
+    }
+    
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (intent.getAction().equals(SECRET_CODE_ACTION)) {
+            Intent i = new Intent(Intent.ACTION_MAIN);
+            i.setClass(context, TestingSettings.class);
+            i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            context.startActivity(i);
+        }
+    }
+}
diff --git a/src/com/android/settings/UsageStats.java b/src/com/android/settings/UsageStats.java
new file mode 100755
index 0000000..89caa54
--- /dev/null
+++ b/src/com/android/settings/UsageStats.java
@@ -0,0 +1,249 @@
+
+
+/**
+ * Copyright (C) 2007 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.settings;
+
+import com.android.internal.app.IUsageStats;
+import com.android.settings.R;
+import android.app.Activity;
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import com.android.internal.os.PkgUsageStats;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.BaseAdapter;
+import android.widget.ListView;
+import android.widget.Spinner;
+import android.widget.TextView;
+import android.widget.AdapterView.OnItemSelectedListener;
+
+/**
+ * Activity to display package usage statistics.
+ */
+public class UsageStats extends Activity implements OnItemSelectedListener {
+    private static final String TAG="UsageStatsActivity";
+    private static final boolean localLOGV = true;
+    private Spinner mTypeSpinner;
+    private ListView mListView;
+    private IUsageStats mUsageStatsService;
+    private LayoutInflater mInflater;
+    private UsageStatsAdapter mAdapter;
+    private PackageManager mPm;
+    
+    public static class AppNameComparator implements Comparator<PkgUsageStats> {
+        Map<String, CharSequence> mAppLabelList;
+        AppNameComparator(Map<String, CharSequence> appList) {
+            mAppLabelList = appList;
+        }
+        public final int compare(PkgUsageStats a, PkgUsageStats b) {
+            String alabel = mAppLabelList.get(a.packageName).toString();
+            String blabel = mAppLabelList.get(b.packageName).toString();
+            return alabel.compareTo(blabel);
+        }
+    }
+    
+    public static class LaunchCountComparator implements Comparator<PkgUsageStats> {
+        public final int compare(PkgUsageStats a, PkgUsageStats b) {
+            // return by descending order
+            return b.launchCount - a.launchCount;
+        }
+    }
+    
+    public static class UsageTimeComparator implements Comparator<PkgUsageStats> {
+        public final int compare(PkgUsageStats a, PkgUsageStats b) {
+            long ret = a.usageTime-b.usageTime;
+            if (ret == 0) {
+                return 0;
+            }
+            if (ret < 0) {
+                return 1;
+            }
+            return -1;
+        }
+    }
+    
+     // View Holder used when displaying views
+    static class AppViewHolder {
+        TextView pkgName;
+        TextView launchCount;
+        TextView usageTime;
+    }
+    
+    class UsageStatsAdapter extends BaseAdapter {
+         // Constants defining order for display order
+        private static final int _DISPLAY_ORDER_USAGE_TIME = 0;
+        private static final int _DISPLAY_ORDER_LAUNCH_COUNT = 1;
+        private static final int _DISPLAY_ORDER_APP_NAME = 2;
+        
+        private int mDisplayOrder = _DISPLAY_ORDER_USAGE_TIME;
+        private List<PkgUsageStats> mUsageStats;
+        private LaunchCountComparator mLaunchCountComparator;
+        private UsageTimeComparator mUsageTimeComparator;
+        private AppNameComparator mAppLabelComparator;
+        private HashMap<String, CharSequence> mAppLabelMap;
+        
+        UsageStatsAdapter() {
+            mUsageStats = new ArrayList<PkgUsageStats>();
+            mAppLabelMap = new HashMap<String, CharSequence>();
+            PkgUsageStats[] stats;
+            try {
+                stats = mUsageStatsService.getAllPkgUsageStats();
+            } catch (RemoteException e) {
+                Log.e(TAG, "Failed initializing usage stats service");
+                return;
+            }
+           if (stats == null) {
+               return;
+           }
+           for (PkgUsageStats ps : stats) {
+               mUsageStats.add(ps);
+               // load application labels for each application
+               CharSequence label;
+               try {
+                   ApplicationInfo appInfo = mPm.getApplicationInfo(ps.packageName, 0);
+                   label = appInfo.loadLabel(mPm);
+                } catch (NameNotFoundException e) {
+                    label = ps.packageName;
+                }
+                mAppLabelMap.put(ps.packageName, label);
+           }
+           // Sort list
+           mLaunchCountComparator = new LaunchCountComparator();
+           mUsageTimeComparator = new UsageTimeComparator();
+           mAppLabelComparator = new AppNameComparator(mAppLabelMap);
+           sortList();
+        }
+        public int getCount() {
+            return mUsageStats.size();
+        }
+
+        public Object getItem(int position) {
+            return mUsageStats.get(position);
+        }
+
+        public long getItemId(int position) {
+            return position;
+        }
+
+        public View getView(int position, View convertView, ViewGroup parent) {
+            // A ViewHolder keeps references to children views to avoid unneccessary calls
+            // to findViewById() on each row.
+            AppViewHolder holder;
+
+            // When convertView is not null, we can reuse it directly, there is no need
+            // to reinflate it. We only inflate a new View when the convertView supplied
+            // by ListView is null.
+            if (convertView == null) {
+                convertView = mInflater.inflate(R.layout.usage_stats_item, null);
+
+                // Creates a ViewHolder and store references to the two children views
+                // we want to bind data to.
+                holder = new AppViewHolder();
+                holder.pkgName = (TextView) convertView.findViewById(R.id.package_name);
+                holder.launchCount = (TextView) convertView.findViewById(R.id.launch_count);
+                holder.usageTime = (TextView) convertView.findViewById(R.id.usage_time);
+                convertView.setTag(holder);
+            } else {
+                // Get the ViewHolder back to get fast access to the TextView
+                // and the ImageView.
+                holder = (AppViewHolder) convertView.getTag();
+            }
+
+            // Bind the data efficiently with the holder
+            PkgUsageStats pkgStats = mUsageStats.get(position);
+            if (pkgStats != null) {
+                CharSequence label = mAppLabelMap.get(pkgStats.packageName);
+                holder.pkgName.setText(label);
+                holder.launchCount.setText(String.valueOf(pkgStats.launchCount));
+                holder.usageTime.setText(String.valueOf(pkgStats.usageTime)+" ms");
+            } else {
+                Log.w(TAG, "No usage stats info for package:"+pkgStats.packageName);
+            }
+            return convertView;
+        }
+        
+        void sortList(int sortOrder) {
+            if (mDisplayOrder == sortOrder) {
+                // do nothing
+                return;
+            }
+            mDisplayOrder= sortOrder;
+            sortList();
+        }
+        private void sortList() {
+            if (mDisplayOrder == _DISPLAY_ORDER_USAGE_TIME) {
+                if (localLOGV) Log.i(TAG, "Sorting by usage time");
+                Collections.sort(mUsageStats, mUsageTimeComparator);
+            } else if (mDisplayOrder == _DISPLAY_ORDER_LAUNCH_COUNT) {
+                if (localLOGV) Log.i(TAG, "Sorting launch count");
+                Collections.sort(mUsageStats, mLaunchCountComparator);
+            } else if (mDisplayOrder == _DISPLAY_ORDER_APP_NAME) {
+                if (localLOGV) Log.i(TAG, "Sorting by application name");
+                Collections.sort(mUsageStats, mAppLabelComparator);
+            }
+            notifyDataSetChanged();
+        }
+    }
+
+    /** Called when the activity is first created. */
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        mUsageStatsService = IUsageStats.Stub.asInterface(ServiceManager.getService("usagestats"));
+        if (mUsageStatsService == null) {
+            Log.e(TAG, "Failed to retrieve usagestats service");
+            return;
+        }
+        mInflater = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+        mPm = getPackageManager();
+        
+        setContentView(R.layout.usage_stats);
+        mTypeSpinner = (Spinner) findViewById(R.id.typeSpinner);
+        mTypeSpinner.setOnItemSelectedListener(this);
+        
+        mListView = (ListView) findViewById(R.id.pkg_list);
+        // Initialize the inflater
+        
+        mAdapter = new UsageStatsAdapter();
+        mListView.setAdapter(mAdapter);
+    }
+
+    public void onItemSelected(AdapterView<?> parent, View view, int position,
+            long id) {
+        mAdapter.sortList(position);
+    }
+
+    public void onNothingSelected(AdapterView<?> parent) {
+        // do nothing
+    }
+}
+
diff --git a/src/com/android/settings/UserDictionarySettings.java b/src/com/android/settings/UserDictionarySettings.java
new file mode 100644
index 0000000..aeddcf7
--- /dev/null
+++ b/src/com/android/settings/UserDictionarySettings.java
@@ -0,0 +1,271 @@
+/**
+ * Copyright (C) 2007 Google Inc.
+ *
+ * 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.settings;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.ListActivity;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.database.Cursor;
+import android.os.Bundle;
+import android.provider.UserDictionary;
+import android.text.InputType;
+import android.view.ContextMenu;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.widget.AlphabetIndexer;
+import android.widget.EditText;
+import android.widget.ListAdapter;
+import android.widget.ListView;
+import android.widget.SectionIndexer;
+import android.widget.SimpleCursorAdapter;
+import android.widget.TextView;
+import android.widget.AdapterView.AdapterContextMenuInfo;
+
+import java.util.Locale;
+
+public class UserDictionarySettings extends ListActivity {
+
+    private static final String INSTANCE_KEY_DIALOG_EDITING_WORD = "DIALOG_EDITING_WORD";
+    private static final String INSTANCE_KEY_ADDED_WORD = "DIALOG_ADDED_WORD";
+
+    private static final String[] QUERY_PROJECTION = {
+        UserDictionary.Words._ID, UserDictionary.Words.WORD
+    };
+    
+    // Either the locale is empty (means the word is applicable to all locales)
+    // or the word equals our current locale
+    private static final String QUERY_SELECTION = UserDictionary.Words.LOCALE + "=? OR "
+            + UserDictionary.Words.LOCALE + " is null";
+
+    private static final String DELETE_SELECTION = UserDictionary.Words.WORD + "=?";
+
+    private static final String EXTRA_WORD = "word";
+    
+    private static final int CONTEXT_MENU_EDIT = Menu.FIRST;
+    private static final int CONTEXT_MENU_DELETE = Menu.FIRST + 1;
+    
+    private static final int OPTIONS_MENU_ADD = Menu.FIRST;
+
+    private static final int DIALOG_ADD_OR_EDIT = 0;
+    
+    /** The word being edited in the dialog (null means the user is adding a word). */
+    private String mDialogEditingWord;
+    
+    private Cursor mCursor;
+    
+    private boolean mAddedWordAlready;
+    private boolean mAutoReturn;
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.list_content_with_empty_view);
+        
+        mCursor = createCursor();
+        setListAdapter(createAdapter());
+        
+        TextView emptyView = (TextView) findViewById(R.id.empty);
+        emptyView.setText(R.string.user_dict_settings_empty_text);
+        
+        ListView listView = getListView();
+        listView.setFastScrollEnabled(true);
+        listView.setEmptyView(emptyView);
+
+        registerForContextMenu(listView);
+    }
+    
+    @Override
+    protected void onResume() {
+        super.onResume();
+        if (!mAddedWordAlready 
+                && getIntent().getAction().equals("com.android.settings.USER_DICTIONARY_INSERT")) {
+            String word = getIntent().getStringExtra(EXTRA_WORD);
+            mAutoReturn = true;
+            if (word != null) {
+                showAddOrEditDialog(word);
+            }
+        }
+    }
+    @Override
+    protected void onRestoreInstanceState(Bundle state) {
+        super.onRestoreInstanceState(state);
+        mDialogEditingWord = state.getString(INSTANCE_KEY_DIALOG_EDITING_WORD);
+        mAddedWordAlready = state.getBoolean(INSTANCE_KEY_ADDED_WORD, false);
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putString(INSTANCE_KEY_DIALOG_EDITING_WORD, mDialogEditingWord);
+        outState.putBoolean(INSTANCE_KEY_ADDED_WORD, mAddedWordAlready);
+    }
+
+    private Cursor createCursor() {
+        String currentLocale = Locale.getDefault().toString();
+        // Case-insensitive sort
+        return managedQuery(UserDictionary.Words.CONTENT_URI, QUERY_PROJECTION,
+                QUERY_SELECTION, new String[] { currentLocale },
+                "UPPER(" + UserDictionary.Words.WORD + ")");
+    }
+
+    private ListAdapter createAdapter() {
+        return new MyAdapter(this,
+                android.R.layout.simple_list_item_1, mCursor,
+                new String[] { UserDictionary.Words.WORD },
+                new int[] { android.R.id.text1 });
+    }
+    
+    @Override
+    protected void onListItemClick(ListView l, View v, int position, long id) {
+        showAddOrEditDialog(getWord(position));
+    }
+
+    @Override
+    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+        if (!(menuInfo instanceof AdapterContextMenuInfo)) return;
+        
+        AdapterContextMenuInfo adapterMenuInfo = (AdapterContextMenuInfo) menuInfo;
+        menu.setHeaderTitle(getWord(adapterMenuInfo.position));
+        menu.add(0, CONTEXT_MENU_EDIT, 0, R.string.user_dict_settings_context_menu_edit_title);
+        menu.add(0, CONTEXT_MENU_DELETE, 0, R.string.user_dict_settings_context_menu_delete_title);
+    }
+    
+    @Override
+    public boolean onContextItemSelected(MenuItem item) {
+        ContextMenuInfo menuInfo = item.getMenuInfo();
+        if (!(menuInfo instanceof AdapterContextMenuInfo)) return false;
+        
+        AdapterContextMenuInfo adapterMenuInfo = (AdapterContextMenuInfo) menuInfo;
+        String word = getWord(adapterMenuInfo.position);
+        
+        switch (item.getItemId()) {
+            case CONTEXT_MENU_DELETE:
+                deleteWord(word);
+                return true;
+                
+            case CONTEXT_MENU_EDIT:
+                showAddOrEditDialog(word);
+                return true;
+        }
+        
+        return false;
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        menu.add(0, OPTIONS_MENU_ADD, 0, R.string.user_dict_settings_add_menu_title)
+                .setIcon(R.drawable.ic_menu_add);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        showAddOrEditDialog(null);
+        return true;
+    }
+
+    private void showAddOrEditDialog(String editingWord) {
+        mDialogEditingWord = editingWord;
+        showDialog(DIALOG_ADD_OR_EDIT);
+    }
+    
+    private String getWord(int position) {
+        mCursor.moveToPosition(position);
+        return mCursor.getString(
+                mCursor.getColumnIndexOrThrow(UserDictionary.Words.WORD));
+    }
+    
+    @Override
+    protected Dialog onCreateDialog(int id) {
+        View content = getLayoutInflater().inflate(R.layout.dialog_edittext, null);
+        final EditText editText = (EditText) content.findViewById(R.id.edittext);
+        // No prediction in soft keyboard mode. TODO: Create a better way to disable prediction
+        editText.setInputType(InputType.TYPE_CLASS_TEXT 
+                | InputType.TYPE_TEXT_FLAG_AUTO_COMPLETE);
+        
+        return new AlertDialog.Builder(this)
+                .setTitle(R.string.user_dict_settings_add_dialog_title)
+                .setView(content)
+                .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        onAddOrEditFinished(editText.getText().toString());
+                        if (mAutoReturn) finish();
+                    }})
+                .setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        if (mAutoReturn) finish();                        
+                    }})
+                .create();
+    }
+
+    @Override
+    protected void onPrepareDialog(int id, Dialog d) {
+        AlertDialog dialog = (AlertDialog) d;
+        EditText editText = (EditText) dialog.findViewById(R.id.edittext);
+        editText.setText(mDialogEditingWord);
+    }
+
+    private void onAddOrEditFinished(String word) {
+        if (mDialogEditingWord != null) {
+            // The user was editing a word, so do a delete/add
+            deleteWord(mDialogEditingWord);
+        }
+        
+        // Disallow duplicates
+        deleteWord(word);
+        
+        // TODO: present UI for picking whether to add word to all locales, or current.
+        UserDictionary.Words.addWord(this, word.toString(),
+                250, UserDictionary.Words.LOCALE_TYPE_ALL);
+        mCursor.requery();
+        mAddedWordAlready = true;
+    }
+
+    private void deleteWord(String word) {
+        getContentResolver().delete(UserDictionary.Words.CONTENT_URI, DELETE_SELECTION,
+                new String[] { word });
+    }
+    
+    private static class MyAdapter extends SimpleCursorAdapter implements SectionIndexer {
+        private AlphabetIndexer mIndexer;        
+        
+        public MyAdapter(Context context, int layout, Cursor c, String[] from, int[] to) {
+            super(context, layout, c, from, to);
+
+            int wordColIndex = c.getColumnIndexOrThrow(UserDictionary.Words.WORD);
+            String alphabet = context.getString(com.android.internal.R.string.fast_scroll_alphabet);
+            mIndexer = new AlphabetIndexer(c, wordColIndex, alphabet); 
+        }
+
+        public int getPositionForSection(int section) {
+            return mIndexer.getPositionForSection(section);
+        }
+
+        public int getSectionForPosition(int position) {
+            return mIndexer.getSectionForPosition(position);
+        }
+
+        public Object[] getSections() {
+            return mIndexer.getSections();
+        }
+    }
+}
diff --git a/src/com/android/settings/Utils.java b/src/com/android/settings/Utils.java
new file mode 100644
index 0000000..a23272b
--- /dev/null
+++ b/src/com/android/settings/Utils.java
@@ -0,0 +1,91 @@
+/**
+ * Copyright (C) 2007 Google Inc.
+ *
+ * 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.settings;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.preference.Preference;
+import android.preference.PreferenceGroup;
+
+import java.util.List;
+
+public class Utils {
+
+    /**
+     * Set the preference's title to the matching activity's label.
+     */
+    public static final int UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY = 1;
+
+    /**
+     * Finds a matching activity for a preference's intent. If a matching
+     * activity is not found, it will remove the preference.
+     * 
+     * @param context The context.
+     * @param parentPreferenceGroup The preference group that contains the
+     *            preference whose intent is being resolved.
+     * @param preferenceKey The key of the preference whose intent is being
+     *            resolved.
+     * @param flags 0 or one or more of
+     *            {@link #UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY}
+     *            .
+     * @return Whether an activity was found. If false, the preference was
+     *         removed.
+     */
+    public static boolean updatePreferenceToSpecificActivityOrRemove(Context context,
+            PreferenceGroup parentPreferenceGroup, String preferenceKey, int flags) {
+        
+        Preference preference = parentPreferenceGroup.findPreference(preferenceKey);
+        if (preference == null) {
+            return false;
+        }
+        
+        Intent intent = preference.getIntent();
+        if (intent != null) {
+            // Find the activity that is in the system image
+            PackageManager pm = context.getPackageManager();
+            List<ResolveInfo> list = pm.queryIntentActivities(intent, 0);
+            int listSize = list.size();
+            for (int i = 0; i < listSize; i++) {
+                ResolveInfo resolveInfo = list.get(i);
+                if ((resolveInfo.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM)
+                        != 0) {
+                    
+                    // Replace the intent with this specific activity
+                    preference.setIntent(new Intent().setClassName(
+                            resolveInfo.activityInfo.packageName,
+                            resolveInfo.activityInfo.name));
+
+                    if ((flags & UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY) != 0) {
+                        // Set the preference title to the activity's label
+                        preference.setTitle(resolveInfo.loadLabel(pm));
+                    }
+                    
+                    return true;
+                }
+            }
+        }
+
+        // Did not find a matching activity, so remove the preference
+        parentPreferenceGroup.removePreference(preference);
+        
+        return true;
+    }
+    
+}
diff --git a/src/com/android/settings/WirelessSettings.java b/src/com/android/settings/WirelessSettings.java
new file mode 100644
index 0000000..d112915
--- /dev/null
+++ b/src/com/android/settings/WirelessSettings.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2007 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.settings;
+
+import com.android.settings.bluetooth.BluetoothEnabler;
+import com.android.settings.wifi.WifiEnabler;
+
+import android.net.wifi.WifiManager;
+import android.os.Bundle;
+import android.preference.PreferenceActivity;
+import android.preference.CheckBoxPreference;
+
+public class WirelessSettings extends PreferenceActivity {
+
+    private static final String KEY_TOGGLE_AIRPLANE = "toggle_airplane";
+    private static final String KEY_TOGGLE_BLUETOOTH = "toggle_bluetooth";
+    private static final String KEY_TOGGLE_WIFI = "toggle_wifi";
+
+    private WifiEnabler mWifiEnabler;
+    private AirplaneModeEnabler mAirplaneModeEnabler;
+    private BluetoothEnabler mBtEnabler;
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        addPreferencesFromResource(R.xml.wireless_settings);
+
+        initToggles();
+    }
+    
+    @Override
+    protected void onResume() {
+        super.onResume();
+        
+        mWifiEnabler.resume();
+        mAirplaneModeEnabler.resume();
+        mBtEnabler.resume();
+    }
+    
+    @Override
+    protected void onPause() {
+        super.onPause();
+        
+        mWifiEnabler.pause();
+        mAirplaneModeEnabler.pause();
+        mBtEnabler.pause();
+    }
+    
+    private void initToggles() {
+        
+        mWifiEnabler = new WifiEnabler(
+                this,
+                (WifiManager) getSystemService(WIFI_SERVICE),
+                (CheckBoxPreference) findPreference(KEY_TOGGLE_WIFI));
+        
+        mAirplaneModeEnabler = new AirplaneModeEnabler(
+                this,
+                (CheckBoxPreference) findPreference(KEY_TOGGLE_AIRPLANE));
+        
+        mBtEnabler = new BluetoothEnabler(
+                this,
+                (CheckBoxPreference) findPreference(KEY_TOGGLE_BLUETOOTH));
+    }
+    
+}
diff --git a/src/com/android/settings/ZoneList.java b/src/com/android/settings/ZoneList.java
new file mode 100644
index 0000000..2877f00
--- /dev/null
+++ b/src/com/android/settings/ZoneList.java
@@ -0,0 +1,273 @@
+/*
+ * 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.settings;
+
+import android.app.AlarmManager;
+import android.app.ListActivity;
+import android.content.Context;
+import android.content.res.XmlResourceParser;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.ListAdapter;
+import android.widget.ListView;
+import android.widget.SimpleAdapter;
+
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TimeZone;
+
+/**
+ * This activity displays a list of time zones that match a filter string
+ * such as "Africa", "Europe", etc. Choosing an item from the list will set
+ * the time zone. Pressing Back without choosing from the list will not 
+ * result in a change in the time zone setting.
+ */
+public class ZoneList extends ListActivity {
+    
+    private static final String TAG = "ZoneList";
+    private static final String KEY_ID = "id";
+    private static final String KEY_DISPLAYNAME = "name";
+    private static final String KEY_GMT = "gmt";
+    private static final String KEY_OFFSET = "offset";
+    private static final String XMLTAG_TIMEZONE = "timezone";
+
+    private static final int HOURS_1 = 60 * 60000;
+    private static final int HOURS_24 = 24 * HOURS_1;
+    private static final int HOURS_HALF = HOURS_1 / 2;
+    
+    private static final int MENU_TIMEZONE = Menu.FIRST+1;
+    private static final int MENU_ALPHABETICAL = Menu.FIRST;
+
+    // Initial focus position
+    private int mDefault;
+    
+    private boolean mSortedByTimezone;
+
+    private SimpleAdapter mTimezoneSortedAdapter;
+    private SimpleAdapter mAlphabeticalAdapter;
+    
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        String[] from = new String[] {KEY_DISPLAYNAME, KEY_GMT};
+        int[] to = new int[] {android.R.id.text1, android.R.id.text2};
+
+        MyComparator comparator = new MyComparator(KEY_OFFSET);
+        
+        List<HashMap> timezoneSortedList = getZones();
+        Collections.sort(timezoneSortedList, comparator);
+        mTimezoneSortedAdapter = new SimpleAdapter(this,
+                (List) timezoneSortedList,
+                android.R.layout.simple_list_item_2,
+                from,
+                to);
+
+        List<HashMap> alphabeticalList = new ArrayList<HashMap>(timezoneSortedList);
+        comparator.setSortingKey(KEY_DISPLAYNAME);
+        Collections.sort(alphabeticalList, comparator);
+        mAlphabeticalAdapter = new SimpleAdapter(this,
+                (List) alphabeticalList,
+                android.R.layout.simple_list_item_2,
+                from,
+                to);
+        
+        // Sets the adapter
+        setSorting(true);
+        
+        // If current timezone is in this list, move focus to it
+        setSelection(mDefault);
+        
+        // Assume user may press Back
+        setResult(RESULT_CANCELED);
+    }
+    
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        menu.add(0, MENU_ALPHABETICAL, 0, R.string.zone_list_menu_sort_alphabetically)
+            .setIcon(android.R.drawable.ic_menu_sort_alphabetically);
+        menu.add(0, MENU_TIMEZONE, 0, R.string.zone_list_menu_sort_by_timezone)
+            .setIcon(R.drawable.ic_menu_3d_globe);
+        
+        return true;
+    }
+
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+     
+        if (mSortedByTimezone) {
+            menu.findItem(MENU_TIMEZONE).setVisible(false);
+            menu.findItem(MENU_ALPHABETICAL).setVisible(true);
+        } else {
+            menu.findItem(MENU_TIMEZONE).setVisible(true);
+            menu.findItem(MENU_ALPHABETICAL).setVisible(false);
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+
+            case MENU_TIMEZONE:
+                setSorting(true);
+                return true;
+                
+            case MENU_ALPHABETICAL:
+                setSorting(false);
+                return true;
+                
+            default:
+                return false;
+        }
+    }
+
+    private void setSorting(boolean timezone) {
+        setListAdapter(timezone ? mTimezoneSortedAdapter : mAlphabeticalAdapter);
+        mSortedByTimezone = timezone;
+    }
+    
+    private List<HashMap> getZones() {
+        List<HashMap> myData = new ArrayList<HashMap>();
+        long date = Calendar.getInstance().getTimeInMillis();
+        try {
+            XmlResourceParser xrp = getResources().getXml(R.xml.timezones);
+            while (xrp.next() != XmlResourceParser.START_TAG)
+                ;
+            xrp.next();
+            while (xrp.getEventType() != XmlResourceParser.END_TAG) {
+                while (xrp.getEventType() != XmlResourceParser.START_TAG) {
+                    if (xrp.getEventType() == XmlResourceParser.END_DOCUMENT) {
+                        return myData;
+                    }
+                    xrp.next();
+                }
+                if (xrp.getName().equals(XMLTAG_TIMEZONE)) {
+                    String id = xrp.getAttributeValue(0);
+                    String displayName = xrp.nextText();
+                    addItem(myData, id, displayName, date);
+                }
+                while (xrp.getEventType() != XmlResourceParser.END_TAG) {
+                    xrp.next();
+                }
+                xrp.next();
+            }
+            xrp.close();
+        } catch (XmlPullParserException xppe) {
+            Log.e(TAG, "Ill-formatted timezones.xml file");
+        } catch (java.io.IOException ioe) {
+            Log.e(TAG, "Unable to read timezones.xml file");
+        }
+
+        return myData;
+    }
+
+    protected void addItem(List<HashMap> myData, String id, String displayName, 
+            long date) {
+        HashMap map = new HashMap();
+        map.put(KEY_ID, id);
+        map.put(KEY_DISPLAYNAME, displayName);
+        TimeZone tz = TimeZone.getTimeZone(id);
+        int offset = tz.getOffset(date);
+        int p = Math.abs(offset);
+        StringBuilder name = new StringBuilder();
+        name.append("GMT");
+        
+        if (offset < 0) {
+            name.append('-');
+        } else {
+            name.append('+');
+        }
+        
+        name.append(p / (HOURS_1));
+        name.append(':');
+
+        int min = p / 60000;
+        min %= 60;
+
+        if (min < 10) {
+            name.append('0');
+        }
+        name.append(min);
+        
+        map.put(KEY_GMT, name.toString());
+        map.put(KEY_OFFSET, offset);
+        
+        if (id.equals(TimeZone.getDefault().getID())) {
+            mDefault = myData.size();
+        }
+        
+        myData.add(map);
+    }
+
+    @Override
+    protected void onListItemClick(ListView l, View v, int position, long id) {
+        Map map = (Map) l.getItemAtPosition(position);
+        // Update the system timezone value
+        AlarmManager alarm = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
+        alarm.setTimeZone((String) map.get(KEY_ID));
+        setResult(RESULT_OK);
+        finish();
+    }
+    
+    private static class MyComparator implements Comparator<HashMap> {
+        private String mSortingKey; 
+        
+        public MyComparator(String sortingKey) {
+            mSortingKey = sortingKey;
+        }
+        
+        public void setSortingKey(String sortingKey) {
+            mSortingKey = sortingKey;
+        }
+        
+        public int compare(HashMap map1, HashMap map2) {
+            Object value1 = map1.get(mSortingKey);
+            Object value2 = map2.get(mSortingKey);
+
+            /* 
+             * This should never happen, but just in-case, put non-comparable
+             * items at the end.
+             */
+            if (!isComparable(value1)) {
+                return isComparable(value2) ? 1 : 0;
+            } else if (!isComparable(value2)) {
+                return -1;
+            }
+            
+            return ((Comparable) value1).compareTo(value2);
+        }
+        
+        private boolean isComparable(Object value) {
+            return (value != null) && (value instanceof Comparable); 
+        }
+    }
+    
+}
diff --git a/src/com/android/settings/ZonePicker.java b/src/com/android/settings/ZonePicker.java
new file mode 100644
index 0000000..def5036
--- /dev/null
+++ b/src/com/android/settings/ZonePicker.java
@@ -0,0 +1,70 @@
+/*
+ * 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.settings;
+
+import android.app.ListActivity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ZonePicker extends ListActivity {
+
+    private ArrayAdapter<CharSequence> mFilterAdapter;
+    
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        mFilterAdapter = ArrayAdapter.createFromResource(this,
+                R.array.timezone_filters, android.R.layout.simple_list_item_1);
+        setListAdapter(mFilterAdapter);
+    }
+    
+    protected void addItem(List<Map> data, String name, String zone) {
+        HashMap temp = new HashMap();
+        temp.put("title", name);
+        temp.put("zone", zone);
+        data.add(temp);
+    }
+
+    @Override
+    protected void onListItemClick(ListView l, View v, int position, long id) {
+        String filter = (String) mFilterAdapter.getItem(position);
+        // If All is chosen, reset the filter
+        if (filter.equals("All")) {
+            filter = null;
+        }
+        Intent zoneList = new Intent();
+        zoneList.setClass(this, ZoneList.class);
+        zoneList.putExtra("filter", filter);
+        
+        startActivityForResult(zoneList, 0);
+    }
+    
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        // If subactivity has resulted in a timezone selection, close this act.
+        if (resultCode == RESULT_OK) {
+            finish();
+        }
+    }    
+}
diff --git a/src/com/android/settings/battery_history/BatteryHistory.java b/src/com/android/settings/battery_history/BatteryHistory.java
new file mode 100644
index 0000000..dcf6cbf
--- /dev/null
+++ b/src/com/android/settings/battery_history/BatteryHistory.java
@@ -0,0 +1,861 @@
+/*
+ * 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.settings.battery_history;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+import com.android.internal.app.IBatteryStats;
+import com.android.settings.R;
+
+import android.app.Activity;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.os.BatteryStats;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.os.SystemClock;
+import android.os.BatteryStats.Timer;
+import android.os.BatteryStats.Uid;
+import android.util.Log;
+import android.util.LogPrinter;
+import android.util.SparseArray;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.AdapterView;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.Spinner;
+import android.widget.TextView;
+import android.widget.AdapterView.OnItemSelectedListener;
+
+public class BatteryHistory extends Activity implements OnClickListener, OnItemSelectedListener {
+    private static final String TAG = "BatteryHistory";
+
+    private static final int SECONDS_PER_MINUTE = 60;
+    private static final int SECONDS_PER_HOUR = 60 * 60;
+    private static final int SECONDS_PER_DAY = 24 * 60 * 60;
+    
+    // Must be in sync with the values in res/values/array.xml (id battery_history_type_spinner)
+    private static final int CPU_USAGE = 0;
+    private static final int NETWORK_USAGE = 1;
+    private static final int GPS_USAGE = 2;
+    private static final int SENSOR_USAGE = 3;
+    private static final int WAKELOCK_USAGE = 4;
+    private static final int MISC_USAGE = 5;
+
+    // Must be in sync with the values in res/values/array.xml (id battery_history_which_spinner)
+    private static final int UNPLUGGED = 0;
+    private static final int CURRENT = 1;
+    private static final int TOTAL = 2;
+    
+    private BatteryStats mStats;
+    private int mWhich = BatteryStats.STATS_UNPLUGGED;
+    private int mType = CPU_USAGE;
+    
+    private GraphableButton[] mButtons;
+    IBatteryStats mBatteryInfo;
+    
+    private List<CpuUsage> mCpuUsage = new ArrayList<CpuUsage>();
+    private List<NetworkUsage> mNetworkUsage = new ArrayList<NetworkUsage>();
+    private List<SensorUsage> mSensorUsage = new ArrayList<SensorUsage>();
+    private List<SensorUsage> mGpsUsage = new ArrayList<SensorUsage>();
+    private List<WakelockUsage> mWakelockUsage = new ArrayList<WakelockUsage>();
+    private List<MiscUsage> mMiscUsage = new ArrayList<MiscUsage>();
+    
+    private boolean mHaveCpuUsage, mHaveNetworkUsage, mHaveSensorUsage,
+            mHaveWakelockUsage, mHaveMiscUsage;
+    
+    private LinearLayout mGraphLayout;
+    private LinearLayout mTextLayout;
+    private TextView mMessageText;
+    private TextView mDetailsText;
+    private Button mDetailsBackButton;
+    private Spinner mTypeSpinner;
+    private Spinner mWhichSpinner;
+    
+    private boolean mDetailsShown = false;
+    
+    private static String getLabel(String packageName, PackageManager pm) {
+        try {
+            ApplicationInfo ai = pm.getApplicationInfo(packageName, 0);
+            CharSequence label = ai.loadLabel(pm);
+            if (label != null) {
+                return label.toString();
+            }
+        } catch (NameNotFoundException e) {
+            return packageName;
+        }
+        
+        return "";
+    }
+    
+    void formatTime(double millis, StringBuilder sb) {
+        int seconds = (int) Math.floor(millis / 1000);
+        
+        int days = 0, hours = 0, minutes = 0;
+        if (seconds > SECONDS_PER_DAY) {
+            days = seconds / SECONDS_PER_DAY;
+            seconds -= days * SECONDS_PER_DAY;
+        }
+        if (seconds > SECONDS_PER_HOUR) {
+            hours = seconds / SECONDS_PER_HOUR;
+            seconds -= hours * SECONDS_PER_HOUR;
+        }
+        if (seconds > SECONDS_PER_MINUTE) {
+            minutes = seconds / SECONDS_PER_MINUTE;
+            seconds -= minutes * SECONDS_PER_MINUTE;
+        }
+        if (days > 0) {
+            sb.append(getString(R.string.battery_history_days, days, hours, minutes, seconds));
+        } else if (hours > 0) {
+            sb.append(getString(R.string.battery_history_hours, hours, minutes, seconds));
+        } else if (minutes > 0) { 
+            sb.append(getString(R.string.battery_history_minutes, minutes, seconds));
+        } else {
+            sb.append(getString(R.string.battery_history_seconds, seconds));
+        }
+    }
+    
+    abstract class Graphable implements Comparable<Graphable> {        
+        protected String mName;
+        protected String mNamePackage;
+        protected boolean mUniqueName;
+        protected String[] mPackages;
+        protected String[] mPackageNames;
+        
+        public abstract String getLabel();
+        public abstract double getSortValue();
+        public abstract double[] getValues();
+        public abstract void getInfo(StringBuilder info);
+        
+        public double getMaxValue() {
+            return -Double.MAX_VALUE;            
+        }
+        
+        public int compareTo(Graphable o) {
+            double t = getSortValue();
+            double ot = o.getSortValue();
+            if (t < ot) {
+                // Largest first
+                return 1;
+            } else if (t > ot) {
+                return -1;
+            } else {
+                return 0;
+            }
+        }
+                
+        // Side effects: sets mName and mUniqueName
+        void getNameForUid(int uid) {
+            PackageManager pm = getPackageManager();
+            mPackages = pm.getPackagesForUid(uid);
+            if (mPackages == null) {
+                mName = Integer.toString(uid);
+                mNamePackage = null;
+                return;
+            }
+            
+            mPackageNames = new String[mPackages.length];
+            System.arraycopy(mPackages, 0, mPackageNames, 0, mPackages.length);
+            
+            // Convert package names to user-facing labels where possible
+            for (int i = 0; i < mPackageNames.length; i++) {
+                mPackageNames[i] = BatteryHistory.getLabel(mPackageNames[i], pm);
+            }
+
+            if (mPackageNames.length == 1) {
+                mNamePackage = mPackages[0];
+                mName = mPackageNames[0];
+                mUniqueName = true;
+            } else {
+                mName = getString(R.string.battery_history_uid, uid); // Default name
+                // Look for an official name for this UID.
+                for (String name : mPackages) {
+                    try {
+                        PackageInfo pi = pm.getPackageInfo(name, 0);
+                        if (pi.sharedUserLabel != 0) {
+                            CharSequence nm = pm.getText(name,
+                                    pi.sharedUserLabel, pi.applicationInfo);
+                            if (nm != null) {
+                                mName = nm.toString();
+                                break;
+                            }
+                        }
+                    } catch (PackageManager.NameNotFoundException e) {
+                    }
+                }
+            }
+        }
+    }
+
+    class CpuUsage extends Graphable {
+        String mProcess;
+        double[] mUsage;
+        double mTotalRuntime;
+        long mStarts;
+        
+        public CpuUsage(int uid, String process, long userTime, long systemTime,
+                long starts, long totalRuntime) {
+            getNameForUid(uid);
+            mProcess = process;
+            PackageManager pm = BatteryHistory.this.getPackageManager();
+            mName = BatteryHistory.getLabel(process, pm);
+            mUsage = new double[2];
+            
+            mUsage[0] = userTime;
+            mUsage[1] = userTime + systemTime;
+            mTotalRuntime = totalRuntime;
+            mStarts = starts;
+        }
+        
+        public String getLabel() {
+            return mName;
+        }
+        
+        public double getSortValue() {
+            return mUsage[1];
+        }
+        
+        public double[] getValues() {
+            return mUsage;
+        }
+        
+        public double getMaxValue() {
+            return mTotalRuntime;            
+        }
+        
+        public void getInfo(StringBuilder info) {
+            info.append(getString(R.string.battery_history_cpu_usage, mProcess));
+            info.append("\n\n");
+            info.append(getString(R.string.battery_history_user_time));
+            formatTime(mUsage[0] * 10, info);
+            info.append('\n');
+            info.append(getString(R.string.battery_history_system_time));
+            formatTime((mUsage[1] - mUsage[0]) * 10, info);
+            info.append('\n');
+            info.append(getString(R.string.battery_history_total_time));
+            formatTime((mUsage[1]) * 10, info);
+            info.append('\n');
+            info.append(getString(R.string.battery_history_starts, mStarts));
+        }
+    }
+    
+    class NetworkUsage extends Graphable {
+        double[] mUsage;
+        
+        public NetworkUsage(int uid, long received, long sent) {
+            getNameForUid(uid);
+            
+            mUsage = new double[2];
+            mUsage[0] = received;
+            mUsage[1] = received + sent;
+        }
+        
+        public String getLabel() {
+            return mName;
+        }
+        
+        public double getSortValue() {
+            return mUsage[1];
+        }
+        
+        public double[] getValues() {
+            return mUsage;
+        }
+        
+        public void getInfo(StringBuilder info) {
+            info.append(getString(R.string.battery_history_network_usage, mName));
+            info.append("\n\n");
+            info.append(getString(R.string.battery_history_bytes_received, (long) mUsage[0]));
+            info.append('\n');
+            info.append(getString(R.string.battery_history_bytes_sent,
+                    (long) mUsage[1] - (long) mUsage[0]));
+            info.append('\n');
+            info.append(getString(R.string.battery_history_bytes_total, (long) mUsage[1]));
+
+            if (!mUniqueName) {
+                info.append("\n\n");
+                info.append(getString(R.string.battery_history_packages_sharing_this_uid));
+                info.append('\n');
+
+                PackageManager pm = BatteryHistory.this.getPackageManager();
+                List<String> names = new ArrayList<String>();
+                for (String name : mPackageNames) {
+                    names.add(BatteryHistory.getLabel(name, pm));
+                }
+                Collections.sort(names);
+                for (String name : names) {
+                    info.append("    ");
+                    info.append(name);
+                    info.append('\n');
+                }
+            }
+        }
+    }
+    
+    class SensorUsage extends Graphable {
+        double[] mUsage;
+        double mTotalRealtime;
+        int mCount;
+        
+        public SensorUsage(int uid, long time, int count, long totalRealtime) {
+            getNameForUid(uid);
+            
+            mUsage = new double[1];
+            mUsage[0] = time;
+            mTotalRealtime = totalRealtime;
+            
+            mCount = count;
+        }
+        
+        public String getLabel() {
+            return mName;
+        }
+        
+        public double getSortValue() {
+            return mUsage[0];
+        }
+        
+        public double[] getValues() {
+            return mUsage;
+        }
+        
+        public double getMaxValue() {
+            return mTotalRealtime;            
+        }
+        
+        public void getInfo(StringBuilder info) {
+            info.append(getString(R.string.battery_history_sensor));
+            info.append(mName);
+            info.append("\n\n");
+            info.append(getString(R.string.battery_history_total_time));
+            formatTime(mUsage[0], info);
+            info.append("\n\n");
+        }
+    }
+    
+    
+    class WakelockUsage extends Graphable {
+        double[] mUsage;
+        double mTotalRealtime;
+        int mCount;
+        
+        public WakelockUsage(int uid, long time, int count, long totalRealtime) {
+            getNameForUid(uid);
+            
+            mUsage = new double[1];
+            mUsage[0] = time;
+            mTotalRealtime = totalRealtime;
+            
+            mCount = count;
+        }
+        
+        public String getLabel() {
+            return mName;
+        }
+        
+        public double getSortValue() {
+            return mUsage[0];
+        }
+        
+        public double[] getValues() {
+            return mUsage;
+        }
+        
+        public double getMaxValue() {
+            return mTotalRealtime;            
+        }
+        
+        public void getInfo(StringBuilder info) {
+            info.append(getString(R.string.battery_history_wakelock));
+            info.append(mName);
+            info.append("\n\n");
+            info.append(getString(R.string.battery_history_total_time));
+            formatTime(mUsage[0], info);
+            info.append("\n\n");
+        }
+    }
+    
+    class MiscUsage extends Graphable {
+        int mInfoLabelRes;
+        double[] mUsage;
+        double mTotalRealtime;
+        
+        public MiscUsage(String name, int infoLabelRes, long value,
+                long totalRealtime) {
+            mName = name;
+            
+            mInfoLabelRes = infoLabelRes;
+            
+            mUsage = new double[2];
+            mUsage[0] = value;
+            mTotalRealtime = totalRealtime;
+        }
+        
+        public String getLabel() {
+            return mName;
+        }
+        
+        public double getSortValue() {
+            return mUsage[1];
+        }
+        
+        public double[] getValues() {
+            return mUsage;
+        }
+        
+        public double getMaxValue() {
+            return mTotalRealtime;            
+        }
+        
+        public void getInfo(StringBuilder info) {
+            info.append(getString(mInfoLabelRes));
+            info.append(' ');
+            formatTime(mUsage[0], info);
+            info.append(" (");
+            info.append((mUsage[0]*100)/mTotalRealtime);
+            info.append("%)");
+        }
+    }
+    
+    private List<? extends Graphable> getGraphRecords() {
+        switch (mType) {
+            case CPU_USAGE: return mCpuUsage;
+            case NETWORK_USAGE : return mNetworkUsage;
+            case SENSOR_USAGE: return mSensorUsage;
+            case GPS_USAGE: return mGpsUsage;
+            case WAKELOCK_USAGE: return mWakelockUsage;
+            case MISC_USAGE: return mMiscUsage;
+            default:
+                return (List<? extends Graphable>) null; // TODO
+        }
+    }
+    
+    private void displayGraph() {
+        Log.i(TAG, "displayGraph");
+
+        collectStatistics();
+        
+        // Hide the UI and selectively enable it below
+        mMessageText.setVisibility(View.GONE);
+        for (int i = 0; i < mButtons.length; i++) {
+            mButtons[i].setVisibility(View.INVISIBLE);
+        }
+        
+        double maxValue = -Double.MAX_VALUE;
+        
+        List<? extends Graphable> records = getGraphRecords();
+        for (Graphable g : records) {
+            double[] values = g.getValues();
+            maxValue = Math.max(maxValue, values[values.length - 1]);
+            maxValue = Math.max(maxValue, g.getMaxValue());
+        }
+        
+        int[] colors = new int[2];
+        colors[0] = 0xff0000ff;
+        colors[1] = 0xffff0000;
+        
+        for (int i = 0; i < mButtons.length; i++) {
+            mButtons[i].setVisibility(View.INVISIBLE);
+        }
+        
+        int numRecords = Math.min(records.size(), mButtons.length);
+        if (numRecords == 0) {
+             mMessageText.setVisibility(View.VISIBLE);
+             mMessageText.setText(R.string.battery_history_no_data);
+        } else {
+            for (int i = 0; i < numRecords; i++) {
+                Graphable r = records.get(i);           
+
+                mButtons[i].setText(r.getLabel());
+                mButtons[i].setValues(r.getValues(), maxValue);
+                mButtons[i].setVisibility(View.VISIBLE);
+            }
+        }
+    }
+    
+    private void hideDetails() {
+        mTextLayout.setVisibility(View.GONE);
+        mGraphLayout.setVisibility(View.VISIBLE);
+        mDetailsShown = false;
+    }
+    
+    private void showDetails(int id) {
+        mGraphLayout.setVisibility(View.GONE);
+        mTextLayout.setVisibility(View.VISIBLE);
+            
+        StringBuilder info = new StringBuilder();
+        List<? extends Graphable> records = getGraphRecords();
+        if (id < records.size()) {
+            Graphable record = records.get(id);
+            record.getInfo(info);
+        } else {
+            info.append(getString(R.string.battery_history_details_for, id));
+        }
+        mDetailsText.setText(info.toString());
+        mDetailsShown = true;
+    }
+
+    private void processCpuUsage() {
+        mCpuUsage.clear();
+        
+        long uSecTime = SystemClock.uptimeMillis() * 1000;
+        final long uSecNow = mStats.computeBatteryUptime(uSecTime, mWhich) / 1000;
+        
+        SparseArray<? extends Uid> uidStats = mStats.getUidStats();
+        final int NU = uidStats.size();
+        for (int iu = 0; iu < NU; iu++) {
+            Uid u = uidStats.valueAt(iu);
+
+            Map<String, ? extends BatteryStats.Uid.Proc> processStats = u.getProcessStats();
+            if (processStats.size() > 0) {
+                for (Map.Entry<String, ? extends BatteryStats.Uid.Proc> ent
+                        : processStats.entrySet()) {
+
+                    Uid.Proc ps = ent.getValue();
+                    long userTime = ps.getUserTime(mWhich);
+                    long systemTime = ps.getSystemTime(mWhich);
+                    long starts = ps.getStarts(mWhich);
+
+                    if (userTime != 0 || systemTime != 0) {
+                        mCpuUsage.add(new CpuUsage(u.getUid(), ent.getKey(),
+                                userTime, systemTime, starts, uSecNow));
+                    }
+                }
+            }
+        }
+        Collections.sort(mCpuUsage);
+    }
+    
+    private void processNetworkUsage() {
+        mNetworkUsage.clear();
+        
+        SparseArray<? extends Uid> uidStats = mStats.getUidStats();
+        final int NU = uidStats.size();
+        for (int iu = 0; iu < NU; iu++) {
+            Uid u = uidStats.valueAt(iu);
+            
+            long received = u.getTcpBytesReceived(mWhich);
+            long sent = u.getTcpBytesSent(mWhich);
+            if (received + sent > 0) {
+                mNetworkUsage.add(new NetworkUsage(u.getUid(), received, sent));
+            }
+        }
+        Collections.sort(mNetworkUsage);
+    }
+    
+    private void processSensorUsage() {
+        mGpsUsage.clear();
+        mSensorUsage.clear();
+        
+        long uSecTime = SystemClock.elapsedRealtime() * 1000;
+        final long uSecNow = mStats.computeBatteryRealtime(uSecTime, mWhich) / 1000;
+        
+        SparseArray<? extends Uid> uidStats = mStats.getUidStats();
+        final int NU = uidStats.size();
+        for (int iu = 0; iu < NU; iu++) {
+            Uid u = uidStats.valueAt(iu);
+            int uid = u.getUid();
+            
+            Map<Integer, ? extends BatteryStats.Uid.Sensor> sensorStats = u.getSensorStats();
+            long timeGps = 0;
+            int countGps = 0;
+            long timeOther = 0;
+            int countOther = 0;
+            if (sensorStats.size() > 0) {
+                for (Map.Entry<Integer, ? extends BatteryStats.Uid.Sensor> ent
+                        : sensorStats.entrySet()) {
+
+                    Uid.Sensor se = ent.getValue();
+                    int handle = se.getHandle();
+                    Timer timer = se.getSensorTime();
+                    if (timer != null) {
+                        // Convert from microseconds to milliseconds with rounding
+                        long totalTime = (timer.getTotalTime(uSecNow, mWhich) + 500) / 1000;
+                        int count = timer.getCount(mWhich);
+                        if (handle == BatteryStats.Uid.Sensor.GPS) {
+                            timeGps += totalTime;
+                            countGps += count;
+                        } else {
+                            timeOther += totalTime;
+                            countOther += count;
+                        }
+                    }
+                }
+            }
+            
+            if (timeGps > 0) {
+                mGpsUsage.add(new SensorUsage(uid, timeGps, countGps, uSecNow));
+            }
+            if (timeOther > 0) {
+                mSensorUsage.add(new SensorUsage(uid, timeOther, countOther, uSecNow));
+            }
+        }
+        
+        Collections.sort(mGpsUsage);
+        Collections.sort(mSensorUsage);
+    }
+    
+    private void processWakelockUsage() {
+        mWakelockUsage.clear();
+        
+        long uSecTime = SystemClock.elapsedRealtime() * 1000;
+        final long uSecNow = mStats.computeBatteryRealtime(uSecTime, mWhich) / 1000;
+        
+        SparseArray<? extends Uid> uidStats = mStats.getUidStats();
+        final int NU = uidStats.size();
+        for (int iu = 0; iu < NU; iu++) {
+            Uid u = uidStats.valueAt(iu);
+            int uid = u.getUid();
+            
+            Map<String, ? extends BatteryStats.Uid.Wakelock> wakelockStats = u.getWakelockStats();
+            long time = 0;
+            int count = 0;
+            if (wakelockStats.size() > 0) {
+                for (Map.Entry<String, ? extends BatteryStats.Uid.Wakelock> ent
+                        : wakelockStats.entrySet()) {
+
+                    Uid.Wakelock wl = ent.getValue();
+                    Timer timer = wl.getWakeTime(BatteryStats.WAKE_TYPE_PARTIAL);
+                    if (timer != null) {
+                        // Convert from microseconds to milliseconds with rounding
+                        time += (timer.getTotalTime(uSecNow, mWhich) + 500) / 1000;
+                        count += timer.getCount(mWhich);
+                    }
+                }
+            }
+            
+            if (time > 0) {
+                mWakelockUsage.add(new WakelockUsage(uid, time, count, uSecNow));
+            }
+        }
+        
+        Collections.sort(mWakelockUsage);
+    }
+    
+    private void processMiscUsage() {
+        mMiscUsage.clear();
+        
+        long rawRealtime = SystemClock.elapsedRealtime() * 1000;
+        final long batteryRealtime = mStats.getBatteryRealtime(rawRealtime);
+        final long whichRealtime = mStats.computeBatteryRealtime(rawRealtime, mWhich) / 1000;
+        
+        long time = mStats.computeBatteryUptime(SystemClock.uptimeMillis() * 1000, mWhich) / 1000;
+        if (time > 0) {
+            mMiscUsage.add(new MiscUsage(getString(
+                    R.string.battery_history_awake_label),
+                    R.string.battery_history_awake,
+                    time, whichRealtime)); 
+        }
+        
+        time = mStats.getScreenOnTime(batteryRealtime, mWhich) / 1000;
+        if (time > 0) {
+            mMiscUsage.add(new MiscUsage(getString(
+                    R.string.battery_history_screen_on_label),
+                    R.string.battery_history_screen_on,
+                    time, whichRealtime)); 
+        }
+        
+        time = mStats.getPhoneOnTime(batteryRealtime, mWhich) / 1000;
+        if (time > 0) {
+            mMiscUsage.add(new MiscUsage(getString(
+                    R.string.battery_history_phone_on_label),
+                    R.string.battery_history_phone_on,
+                    time, whichRealtime)); 
+        }
+        
+        Collections.sort(mMiscUsage);
+    }
+    
+    private void collectStatistics() {
+        if (mType == CPU_USAGE) {
+            if (!mHaveCpuUsage) {
+                mHaveCpuUsage = true;
+                processCpuUsage();
+            }
+        }
+        if (mType == NETWORK_USAGE) {
+            if (!mHaveNetworkUsage) {
+                mHaveNetworkUsage = true;
+                processNetworkUsage();
+            }
+        }
+        if (mType == GPS_USAGE || mType == SENSOR_USAGE) {
+            if (!mHaveSensorUsage) {
+                mHaveSensorUsage = true;
+                processSensorUsage();
+            }
+        }
+        if (mType == WAKELOCK_USAGE) {
+            if (!mHaveWakelockUsage) {
+                mHaveWakelockUsage = true;
+                processWakelockUsage();
+            }
+        }
+        if (mType == MISC_USAGE) {
+            if (!mHaveMiscUsage) {
+                mHaveMiscUsage = true;
+                processMiscUsage();
+            }
+        }
+    }
+    
+    private void load() {
+        try {
+            byte[] data = mBatteryInfo.getStatistics();
+            Parcel parcel = Parcel.obtain();
+            //Log.i(TAG, "Got data: " + data.length + " bytes");
+            parcel.unmarshall(data, 0, data.length);
+            parcel.setDataPosition(0);
+            mStats = com.android.internal.os.BatteryStatsImpl.CREATOR
+                    .createFromParcel(parcel);
+            //Log.i(TAG, "RECEIVED BATTERY INFO:");
+            //mStats.dumpLocked(new LogPrinter(Log.INFO, TAG));
+            
+            mHaveCpuUsage =  mHaveNetworkUsage =  mHaveSensorUsage
+                    = mHaveWakelockUsage = mHaveMiscUsage = false;
+        } catch (RemoteException e) {
+            Log.e(TAG, "RemoteException:", e);
+        }
+    }
+    
+    public void onClick(View v) {
+        if (v == mDetailsBackButton) {
+            hideDetails();
+            return;
+        }
+        
+        int id = ((Integer) v.getTag()).intValue();
+        showDetails(id);
+    }
+    
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        if (keyCode == KeyEvent.KEYCODE_BACK && mDetailsShown) {
+            hideDetails();
+            return true;
+        }
+        return super.onKeyDown(keyCode, event);
+    }
+
+    public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
+        int oldWhich = mWhich;
+        
+        if (parent.equals(mTypeSpinner)) {
+            mType = position;
+        } else if (parent.equals(mWhichSpinner)) {
+            switch (position) {
+                case UNPLUGGED:
+                    mWhich = BatteryStats.STATS_UNPLUGGED;
+                    break;
+                case CURRENT:
+                    mWhich = BatteryStats.STATS_CURRENT;
+                    break;
+                case TOTAL:
+                    mWhich = BatteryStats.STATS_TOTAL;
+                    break;
+            }
+        }
+        
+        if (oldWhich != mWhich) {
+            mHaveCpuUsage =  mHaveNetworkUsage =  mHaveSensorUsage
+                    = mHaveWakelockUsage = mHaveMiscUsage = false;
+        }
+        
+        displayGraph();
+    }
+
+    public void onNothingSelected(AdapterView<?> parent) {
+        // Do nothing
+    }
+    
+    @Override
+    public Object onRetainNonConfigurationInstance() {
+        BatteryStats stats = mStats;
+        mStats = null;
+        return stats;
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        if (mStats != null) {
+            outState.putParcelable("stats", mStats);
+        }
+        outState.putInt("type", mType);
+        outState.putInt("which", mWhich);
+    }
+
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        Log.i(TAG, "onCreate");
+        
+        setContentView(R.layout.battery_history);
+        
+        mGraphLayout = (LinearLayout) findViewById(R.id.graphLayout);
+        mTextLayout = (LinearLayout) findViewById(R.id.textLayout);
+        mDetailsText = (TextView) findViewById(R.id.detailsText);
+        mMessageText = (TextView) findViewById(R.id.messageText);
+        
+        mTypeSpinner = (Spinner) findViewById(R.id.typeSpinner);
+        mTypeSpinner.setOnItemSelectedListener(this);
+        
+        mWhichSpinner = (Spinner) findViewById(R.id.whichSpinner);
+        mWhichSpinner.setOnItemSelectedListener(this);
+        mWhichSpinner.setEnabled(true);
+        
+        mButtons = new GraphableButton[8];
+        mButtons[0] = (GraphableButton) findViewById(R.id.button0);
+        mButtons[1] = (GraphableButton) findViewById(R.id.button1);
+        mButtons[2] = (GraphableButton) findViewById(R.id.button2);
+        mButtons[3] = (GraphableButton) findViewById(R.id.button3);
+        mButtons[4] = (GraphableButton) findViewById(R.id.button4);
+        mButtons[5] = (GraphableButton) findViewById(R.id.button5);
+        mButtons[6] = (GraphableButton) findViewById(R.id.button6);
+        mButtons[7] = (GraphableButton) findViewById(R.id.button7);
+        
+        for (int i = 0; i < mButtons.length; i++) {
+            mButtons[i].setTag(i);
+            mButtons[i].setOnClickListener(this);
+        }
+        
+        mBatteryInfo = IBatteryStats.Stub.asInterface(
+                ServiceManager.getService("batteryinfo"));
+        
+        mStats = (BatteryStats)getLastNonConfigurationInstance();
+        if (icicle != null) {
+            if (mStats == null) {
+                mStats = (BatteryStats)icicle.getParcelable("stats");
+            }
+            mType = icicle.getInt("type");
+            mWhich = icicle.getInt("which");
+        }
+        if (mStats == null) {
+            load();
+        }
+        displayGraph();
+    }
+}
diff --git a/src/com/android/settings/battery_history/GraphableButton.java b/src/com/android/settings/battery_history/GraphableButton.java
new file mode 100644
index 0000000..39028d0
--- /dev/null
+++ b/src/com/android/settings/battery_history/GraphableButton.java
@@ -0,0 +1,55 @@
+package com.android.settings.battery_history;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.widget.Button;
+
+public class GraphableButton extends Button {
+    private static final String TAG = "GraphableButton";
+
+    static Paint[] sPaint = new Paint[2];
+    static {
+        sPaint[0] = new Paint();
+        sPaint[0].setStyle(Paint.Style.FILL);
+        sPaint[0].setColor(Color.BLUE);
+        
+        sPaint[1] = new Paint();
+        sPaint[1].setStyle(Paint.Style.FILL);
+        sPaint[1].setColor(Color.RED);
+    }
+    
+    double[] mValues;
+    
+    public GraphableButton(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+    
+    public void setValues(double[] values, double maxValue) {
+        mValues = values.clone();
+        for (int i = 0; i < values.length; i++) {
+            mValues[i] /= maxValue;
+        }
+    }
+    
+    @Override
+    public void onDraw(Canvas canvas) {
+        Log.i(TAG, "onDraw: w = " + getWidth() + ", h = " + getHeight());
+        
+        int xmin = getPaddingLeft();
+        int xmax = getWidth() - getPaddingRight();
+        int ymin = getPaddingTop();
+        int ymax = getHeight() - getPaddingBottom();
+        
+        int startx = xmin;
+        for (int i = 0; i < mValues.length; i++) {
+            int endx = xmin + (int) (mValues[i] * (xmax - xmin));
+            canvas.drawRect(startx, ymin, endx, ymax, sPaint[i]);
+            startx = endx;
+        }
+        super.onDraw(canvas);
+    }
+}
diff --git a/src/com/android/settings/bluetooth/BluetoothDevicePreference.java b/src/com/android/settings/bluetooth/BluetoothDevicePreference.java
new file mode 100644
index 0000000..f0a8189
--- /dev/null
+++ b/src/com/android/settings/bluetooth/BluetoothDevicePreference.java
@@ -0,0 +1,122 @@
+/*
+ * 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.settings.bluetooth;
+
+import com.android.settings.R;
+
+import android.content.Context;
+import android.preference.Preference;
+import android.util.TypedValue;
+import android.view.View;
+import android.widget.ImageView;
+
+/**
+ * BluetoothDevicePreference is the preference type used to display each remote
+ * Bluetooth device in the Bluetooth Settings screen.
+ */
+public class BluetoothDevicePreference extends Preference implements LocalBluetoothDevice.Callback {
+    private static final String TAG = "BluetoothDevicePreference";
+
+    private static int sDimAlpha = Integer.MIN_VALUE;
+    
+    private LocalBluetoothDevice mLocalDevice;
+    
+    /**
+     * Cached local copy of whether the device is busy. This is only updated
+     * from {@link #onDeviceAttributesChanged(LocalBluetoothDevice)}.
+     */ 
+    private boolean mIsBusy;
+    
+    public BluetoothDevicePreference(Context context, LocalBluetoothDevice localDevice) {
+        super(context);
+
+        if (sDimAlpha == Integer.MIN_VALUE) {
+            TypedValue outValue = new TypedValue();
+            context.getTheme().resolveAttribute(android.R.attr.disabledAlpha, outValue, true);
+            sDimAlpha = (int) (outValue.getFloat() * 255);
+        }
+            
+        mLocalDevice = localDevice;
+        
+        setLayoutResource(R.layout.preference_bluetooth);
+        
+        localDevice.registerCallback(this);
+        
+        onDeviceAttributesChanged(localDevice);
+    }
+    
+    public LocalBluetoothDevice getDevice() {
+        return mLocalDevice;
+    }
+
+    @Override
+    protected void onPrepareForRemoval() {
+        super.onPrepareForRemoval();
+        mLocalDevice.unregisterCallback(this);
+    }
+
+    public void onDeviceAttributesChanged(LocalBluetoothDevice device) {
+
+        /*
+         * The preference framework takes care of making sure the value has
+         * changed before proceeding.
+         */
+        
+        setTitle(mLocalDevice.getName());
+        
+        /*
+         * TODO: Showed "Paired" even though it was "Connected". This may be
+         * related to BluetoothHeadset not bound to the actual
+         * BluetoothHeadsetService when we got here.
+         */
+        setSummary(mLocalDevice.getSummary());
+
+        // Used to gray out the item
+        mIsBusy = mLocalDevice.isBusy();
+        
+        // Data has changed
+        notifyChanged();
+        
+        // This could affect ordering, so notify that also
+        notifyHierarchyChanged();
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return super.isEnabled() && !mIsBusy;
+    }
+
+    @Override
+    protected void onBindView(View view) {
+        super.onBindView(view);
+
+        ImageView btClass = (ImageView) view.findViewById(R.id.btClass);
+        btClass.setImageResource(mLocalDevice.getBtClassDrawable());
+        btClass.setAlpha(isEnabled() ? 255 : sDimAlpha);        
+    }
+
+    @Override
+    public int compareTo(Preference another) {
+        if (!(another instanceof BluetoothDevicePreference)) {
+            // Put other preference types above us
+            return 1;
+        }
+        
+        return mLocalDevice.compareTo(((BluetoothDevicePreference) another).mLocalDevice);
+    }
+ 
+}
diff --git a/src/com/android/settings/bluetooth/BluetoothDiscoverableEnabler.java b/src/com/android/settings/bluetooth/BluetoothDiscoverableEnabler.java
new file mode 100644
index 0000000..a51f9b5
--- /dev/null
+++ b/src/com/android/settings/bluetooth/BluetoothDiscoverableEnabler.java
@@ -0,0 +1,198 @@
+/*
+ * 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.settings.bluetooth;
+
+import com.android.settings.R;
+
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothError;
+import android.bluetooth.BluetoothIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.os.Handler;
+import android.os.SystemProperties;
+import android.preference.Preference;
+import android.preference.CheckBoxPreference;
+import android.util.Log;
+
+/**
+ * BluetoothDiscoverableEnabler is a helper to manage the "Discoverable"
+ * checkbox. It sets/unsets discoverability and keeps track of how much time
+ * until the the discoverability is automatically turned off.
+ */
+public class BluetoothDiscoverableEnabler implements Preference.OnPreferenceChangeListener {
+    private static final String TAG = "BluetoothDiscoverableEnabler";
+    private static final boolean V = LocalBluetoothManager.V;
+    
+    private static final String SYSTEM_PROPERTY_DISCOVERABLE_TIMEOUT =
+            "debug.bt.discoverable_time";
+    private static final int DISCOVERABLE_TIMEOUT = 120; 
+
+    private static final String SHARED_PREFERENCES_KEY_DISCOVERABLE_END_TIMESTAMP =
+            "discoverable_end_timestamp";
+    
+    private final Context mContext;
+    private final Handler mUiHandler;
+    private final CheckBoxPreference mCheckBoxPreference;
+    
+    private final LocalBluetoothManager mLocalManager;
+    
+    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (BluetoothIntent.SCAN_MODE_CHANGED_ACTION.equals(intent.getAction())) {
+                int mode = intent.getIntExtra(BluetoothIntent.SCAN_MODE, BluetoothError.ERROR);
+                if (mode != BluetoothError.ERROR) {
+                    handleModeChanged(mode);
+                }
+            }
+        }
+    };
+
+    private final Runnable mUpdateCountdownSummaryRunnable = new Runnable() {
+        public void run() {
+            updateCountdownSummary();        
+        } 
+    };
+
+    public BluetoothDiscoverableEnabler(Context context, CheckBoxPreference checkBoxPreference) {
+        mContext = context;
+        mUiHandler = new Handler();
+        mCheckBoxPreference = checkBoxPreference;
+        
+        checkBoxPreference.setPersistent(false);
+        
+        mLocalManager = LocalBluetoothManager.getInstance(context);
+        if (mLocalManager == null) {
+            // Bluetooth not supported
+            checkBoxPreference.setEnabled(false);
+        }
+    }
+
+    public void resume() {
+        if (mLocalManager == null) {
+            return;
+        }
+
+        IntentFilter filter = new IntentFilter(BluetoothIntent.SCAN_MODE_CHANGED_ACTION);
+        filter.addAction(BluetoothIntent.DISABLED_ACTION);
+        mContext.registerReceiver(mReceiver, filter);
+        mCheckBoxPreference.setOnPreferenceChangeListener(this);
+        
+        handleModeChanged(mLocalManager.getBluetoothManager().getScanMode());
+    }
+    
+    public void pause() {
+        if (mLocalManager == null) {
+            return;
+        }
+        
+        mUiHandler.removeCallbacks(mUpdateCountdownSummaryRunnable);
+        mCheckBoxPreference.setOnPreferenceChangeListener(null);
+        mContext.unregisterReceiver(mReceiver);
+    }
+    
+    public boolean onPreferenceChange(Preference preference, Object value) {
+        if (V) {
+            Log.v(TAG, "Preference changed to " + value);
+        }
+        
+        // Turn on/off BT discoverability
+        setEnabled((Boolean) value);
+        
+        return true;
+    }
+    
+    private void setEnabled(final boolean enable) {
+        BluetoothDevice manager = mLocalManager.getBluetoothManager();
+        
+        if (enable) {
+
+            int timeout = getDiscoverableTimeout();
+            manager.setDiscoverableTimeout(timeout);
+            
+            long endTimestamp = System.currentTimeMillis() + timeout * 1000;
+            persistDiscoverableEndTimestamp(endTimestamp);
+            
+            manager.setScanMode(BluetoothDevice.SCAN_MODE_CONNECTABLE_DISCOVERABLE);
+        } else {
+            manager.setScanMode(BluetoothDevice.SCAN_MODE_CONNECTABLE);
+        }
+    }
+
+    private int getDiscoverableTimeout() {
+        int timeout = SystemProperties.getInt(SYSTEM_PROPERTY_DISCOVERABLE_TIMEOUT, -1);
+        if (timeout <= 0) {
+            timeout = DISCOVERABLE_TIMEOUT;
+        }
+        
+        return timeout;
+    }
+
+    private void persistDiscoverableEndTimestamp(long endTimestamp) {
+        SharedPreferences.Editor editor = mLocalManager.getSharedPreferences().edit();
+        editor.putLong(SHARED_PREFERENCES_KEY_DISCOVERABLE_END_TIMESTAMP, endTimestamp);
+        editor.commit();
+    }
+    
+    private void handleModeChanged(int mode) {
+        if (V) {
+            Log.v(TAG, "Got mode changed: " + mode);
+        }
+        
+        if (mode == BluetoothDevice.SCAN_MODE_CONNECTABLE_DISCOVERABLE) {
+            mCheckBoxPreference.setChecked(true);
+            updateCountdownSummary();
+            
+        } else {
+            mCheckBoxPreference.setChecked(false);
+        }
+    }
+    
+    private void updateCountdownSummary() {
+        int mode = mLocalManager.getBluetoothManager().getScanMode();
+        if (mode != BluetoothDevice.SCAN_MODE_CONNECTABLE_DISCOVERABLE) {
+            return;
+        }
+            
+        long currentTimestamp = System.currentTimeMillis();
+        long endTimestamp = mLocalManager.getSharedPreferences().getLong(
+                SHARED_PREFERENCES_KEY_DISCOVERABLE_END_TIMESTAMP, 0);
+            
+        if (currentTimestamp > endTimestamp) {
+            // We're still in discoverable mode, but maybe there isn't a timeout.
+            mCheckBoxPreference.setSummaryOn(null);
+            return;
+        }
+        
+        String formattedTimeLeft = String.valueOf((endTimestamp - currentTimestamp) / 1000);
+        
+        mCheckBoxPreference.setSummaryOn(
+                mContext.getResources().getString(R.string.bluetooth_is_discoverable,
+                        formattedTimeLeft));
+        
+        synchronized (this) {
+            mUiHandler.removeCallbacks(mUpdateCountdownSummaryRunnable);
+            mUiHandler.postDelayed(mUpdateCountdownSummaryRunnable, 1000);
+        }
+    }
+    
+        
+}
diff --git a/src/com/android/settings/bluetooth/BluetoothEnabler.java b/src/com/android/settings/bluetooth/BluetoothEnabler.java
new file mode 100644
index 0000000..661700f
--- /dev/null
+++ b/src/com/android/settings/bluetooth/BluetoothEnabler.java
@@ -0,0 +1,149 @@
+/*
+ * 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.settings.bluetooth;
+
+import com.android.settings.R;
+import com.android.settings.bluetooth.LocalBluetoothManager.ExtendedBluetoothState;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.preference.Preference;
+import android.preference.CheckBoxPreference;
+import android.text.TextUtils;
+import android.util.Config;
+
+/**
+ * BluetoothEnabler is a helper to manage the Bluetooth on/off checkbox
+ * preference. It is turns on/off Bluetooth and ensures the summary of the
+ * preference reflects the current state.
+ */
+public class BluetoothEnabler implements Preference.OnPreferenceChangeListener {
+    
+    private static final boolean LOCAL_LOGD = Config.LOGD || false;
+    private static final String TAG = "BluetoothEnabler";
+    
+    private final Context mContext; 
+    private final CheckBoxPreference mCheckBoxPreference;
+    private final CharSequence mOriginalSummary;
+    
+    private final LocalBluetoothManager mLocalManager;
+
+    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            handleStateChanged(mLocalManager.getBluetoothState());
+        }
+    };
+
+    public BluetoothEnabler(Context context, CheckBoxPreference checkBoxPreference) {
+        mContext = context;
+        mCheckBoxPreference = checkBoxPreference;
+        
+        mOriginalSummary = checkBoxPreference.getSummary();
+        checkBoxPreference.setPersistent(false);
+        
+        mLocalManager = LocalBluetoothManager.getInstance(context);
+        if (mLocalManager == null) {
+            // Bluetooth not supported
+            checkBoxPreference.setEnabled(false);
+        }
+    }
+
+    public void resume() {
+        if (mLocalManager == null) {
+            return;
+        }
+        
+        ExtendedBluetoothState state = mLocalManager.getBluetoothState();
+        // This is the widget enabled state, not the preference toggled state
+        mCheckBoxPreference.setEnabled(state == ExtendedBluetoothState.ENABLED ||
+                state == ExtendedBluetoothState.DISABLED);
+        // BT state is not a sticky broadcast, so set it manually
+        handleStateChanged(state);
+        
+        mContext.registerReceiver(mReceiver, 
+                new IntentFilter(LocalBluetoothManager.EXTENDED_BLUETOOTH_STATE_CHANGED_ACTION));
+        mCheckBoxPreference.setOnPreferenceChangeListener(this);
+    }
+    
+    public void pause() {
+        if (mLocalManager == null) {
+            return;
+        }
+        
+        mContext.unregisterReceiver(mReceiver);
+        mCheckBoxPreference.setOnPreferenceChangeListener(null);
+    }
+    
+    public boolean onPreferenceChange(Preference preference, Object value) {
+        // Turn on/off BT
+        setEnabled((Boolean) value);
+        
+        // Don't update UI to opposite state until we're sure
+        return false;
+    }
+    
+    private void setEnabled(final boolean enable) {
+        // Disable preference
+        mCheckBoxPreference.setEnabled(false);
+        
+        mLocalManager.setBluetoothEnabled(enable);
+    }
+    
+    private void handleStateChanged(ExtendedBluetoothState state) {
+
+        if (state == ExtendedBluetoothState.DISABLED || state == ExtendedBluetoothState.ENABLED) {
+            mCheckBoxPreference.setChecked(state == ExtendedBluetoothState.ENABLED);
+            mCheckBoxPreference
+                    .setSummary(state == ExtendedBluetoothState.DISABLED ? mOriginalSummary : null);
+            
+            mCheckBoxPreference.setEnabled(isEnabledByDependency());
+            
+        } else if (state == ExtendedBluetoothState.ENABLING ||
+                state == ExtendedBluetoothState.DISABLING) {
+            mCheckBoxPreference.setSummary(state == ExtendedBluetoothState.ENABLING
+                    ? R.string.wifi_starting
+                    : R.string.wifi_stopping);
+            
+        } else if (state == ExtendedBluetoothState.UNKNOWN) {
+            mCheckBoxPreference.setChecked(false);
+            mCheckBoxPreference.setSummary(R.string.wifi_error);
+            mCheckBoxPreference.setEnabled(true);
+        }
+    }
+
+    private boolean isEnabledByDependency() {
+        Preference dep = getDependencyPreference();
+        if (dep == null) {
+            return true;
+        }
+        
+        return !dep.shouldDisableDependents();
+    }
+    
+    private Preference getDependencyPreference() {
+        String depKey = mCheckBoxPreference.getDependency();
+        if (TextUtils.isEmpty(depKey)) {
+            return null;
+        }
+        
+        return mCheckBoxPreference.getPreferenceManager().findPreference(depKey);
+    }
+    
+}
diff --git a/src/com/android/settings/bluetooth/BluetoothEventRedirector.java b/src/com/android/settings/bluetooth/BluetoothEventRedirector.java
new file mode 100644
index 0000000..2ad5726
--- /dev/null
+++ b/src/com/android/settings/bluetooth/BluetoothEventRedirector.java
@@ -0,0 +1,147 @@
+/*
+ * 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.settings.bluetooth;
+
+import com.android.settings.bluetooth.LocalBluetoothManager.ExtendedBluetoothState;
+
+import android.bluetooth.BluetoothA2dp;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothHeadset;
+import android.bluetooth.BluetoothError;
+import android.bluetooth.BluetoothIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.util.Log;
+
+/**
+ * BluetoothEventRedirector receives broadcasts and callbacks from the Bluetooth
+ * API and dispatches the event on the UI thread to the right class in the
+ * Settings.
+ */
+public class BluetoothEventRedirector {
+    private static final String TAG = "BluetoothEventRedirector";
+    private static final boolean V = LocalBluetoothManager.V;
+    
+    private LocalBluetoothManager mManager;
+    
+    private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (V) {
+                Log.v(TAG, "Received " + intent.getAction());
+            }
+            
+            String action = intent.getAction();
+            String address = intent.getStringExtra(BluetoothIntent.ADDRESS);
+                
+            if (action.equals(BluetoothIntent.ENABLED_ACTION)) {
+                mManager.setBluetoothStateInt(ExtendedBluetoothState.ENABLED);
+                
+            } else if (action.equals(BluetoothIntent.DISABLED_ACTION)) {
+                mManager.setBluetoothStateInt(ExtendedBluetoothState.DISABLED);
+                    
+            } else if (action.equals(BluetoothIntent.DISCOVERY_STARTED_ACTION)) {
+                mManager.onScanningStateChanged(true);
+                
+            } else if (action.equals(BluetoothIntent.DISCOVERY_COMPLETED_ACTION)) {
+                mManager.onScanningStateChanged(false);
+                    
+            } else if (action.equals(BluetoothIntent.REMOTE_DEVICE_FOUND_ACTION)) {
+                short rssi = intent.getShortExtra(BluetoothIntent.RSSI, Short.MIN_VALUE);
+                mManager.getLocalDeviceManager().onDeviceAppeared(address, rssi);
+                
+            } else if (action.equals(BluetoothIntent.REMOTE_DEVICE_DISAPPEARED_ACTION)) {
+                mManager.getLocalDeviceManager().onDeviceDisappeared(address);
+                
+            } else if (action.equals(BluetoothIntent.REMOTE_NAME_UPDATED_ACTION)) {
+                mManager.getLocalDeviceManager().onDeviceNameUpdated(address);
+                
+            } else if (action.equals(BluetoothIntent.BOND_STATE_CHANGED_ACTION)) {
+                int bondState = intent.getIntExtra(BluetoothIntent.BOND_STATE,
+                                                   BluetoothError.ERROR);
+                mManager.getLocalDeviceManager().onBondingStateChanged(address, bondState);
+                if (bondState == BluetoothDevice.BOND_NOT_BONDED) {
+                    int reason = intent.getIntExtra(BluetoothIntent.REASON, BluetoothError.ERROR);
+                    if (reason == BluetoothDevice.UNBOND_REASON_AUTH_FAILED ||
+                            reason == BluetoothDevice.UNBOND_REASON_AUTH_REJECTED ||
+                            reason == BluetoothDevice.UNBOND_REASON_REMOTE_DEVICE_DOWN) {
+                        mManager.getLocalDeviceManager().onBondingError(address, reason);
+                    }
+                }
+                
+            } else if (action.equals(BluetoothIntent.HEADSET_STATE_CHANGED_ACTION)) {
+                mManager.getLocalDeviceManager().onProfileStateChanged(address);
+
+                int newState = intent.getIntExtra(BluetoothIntent.HEADSET_STATE, 0);
+                int oldState = intent.getIntExtra(BluetoothIntent.HEADSET_PREVIOUS_STATE, 0);
+                if (newState == BluetoothHeadset.STATE_DISCONNECTED &&
+                        oldState == BluetoothHeadset.STATE_CONNECTING) {
+                    Log.i(TAG, "Failed to connect BT headset");
+                }
+                
+            } else if (action.equals(BluetoothA2dp.SINK_STATE_CHANGED_ACTION)) {
+                mManager.getLocalDeviceManager().onProfileStateChanged(address);
+
+                int newState = intent.getIntExtra(BluetoothA2dp.SINK_STATE, 0);
+                int oldState = intent.getIntExtra(BluetoothA2dp.SINK_PREVIOUS_STATE, 0);
+                if (newState == BluetoothA2dp.STATE_DISCONNECTED &&
+                        oldState == BluetoothA2dp.STATE_CONNECTING) {
+                    Log.i(TAG, "Failed to connect BT A2DP");
+                }
+                
+            } else if (action.equals(BluetoothIntent.REMOTE_DEVICE_CLASS_UPDATED_ACTION)) {
+                mManager.getLocalDeviceManager().onBtClassChanged(address);
+                
+            }
+        }
+    };
+
+    public BluetoothEventRedirector(LocalBluetoothManager localBluetoothManager) {
+        mManager = localBluetoothManager;
+    }
+
+    public void start() {
+        IntentFilter filter = new IntentFilter();
+        
+        // Bluetooth on/off broadcasts
+        filter.addAction(BluetoothIntent.ENABLED_ACTION);
+        filter.addAction(BluetoothIntent.DISABLED_ACTION);
+        
+        // Discovery broadcasts
+        filter.addAction(BluetoothIntent.DISCOVERY_STARTED_ACTION);
+        filter.addAction(BluetoothIntent.DISCOVERY_COMPLETED_ACTION);
+        filter.addAction(BluetoothIntent.REMOTE_DEVICE_DISAPPEARED_ACTION);
+        filter.addAction(BluetoothIntent.REMOTE_DEVICE_FOUND_ACTION);
+        filter.addAction(BluetoothIntent.REMOTE_NAME_UPDATED_ACTION);
+        
+        // Pairing broadcasts
+        filter.addAction(BluetoothIntent.BOND_STATE_CHANGED_ACTION);
+        
+        // Fine-grained state broadcasts
+        filter.addAction(BluetoothA2dp.SINK_STATE_CHANGED_ACTION);
+        filter.addAction(BluetoothIntent.HEADSET_STATE_CHANGED_ACTION);
+        filter.addAction(BluetoothIntent.REMOTE_DEVICE_CLASS_UPDATED_ACTION);
+        
+        mManager.getContext().registerReceiver(mBroadcastReceiver, filter);
+    }
+    
+    public void stop() {
+        mManager.getContext().unregisterReceiver(mBroadcastReceiver);   
+    }
+}
diff --git a/src/com/android/settings/bluetooth/BluetoothNamePreference.java b/src/com/android/settings/bluetooth/BluetoothNamePreference.java
new file mode 100644
index 0000000..3065b26
--- /dev/null
+++ b/src/com/android/settings/bluetooth/BluetoothNamePreference.java
@@ -0,0 +1,79 @@
+/*
+ * 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.settings.bluetooth;
+
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.preference.EditTextPreference;
+import android.preference.PreferenceManager;
+import android.util.AttributeSet;
+
+/**
+ * BluetoothNamePreference is the preference type for editing the device's
+ * Bluetooth name. It asks the user for a name, and persists it via the
+ * Bluetooth API.
+ */
+public class BluetoothNamePreference extends EditTextPreference {
+    private static final String TAG = "BluetoothNamePreference";
+
+    private LocalBluetoothManager mLocalManager;
+    
+    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            setSummaryToName();
+        }
+    };
+    
+    public BluetoothNamePreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        
+        mLocalManager = LocalBluetoothManager.getInstance(context);
+        
+        setSummaryToName();        
+    }
+
+    public void resume() {
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(BluetoothIntent.ENABLED_ACTION);
+        filter.addAction(BluetoothIntent.NAME_CHANGED_ACTION);
+        getContext().registerReceiver(mReceiver, filter);
+    }
+    
+    public void pause() {
+        getContext().unregisterReceiver(mReceiver);
+    }
+    
+    private void setSummaryToName() {
+        BluetoothDevice manager = mLocalManager.getBluetoothManager();
+        if (manager.isEnabled()) {
+            setSummary(manager.getName());
+        }
+    }
+
+    @Override
+    protected boolean persistString(String value) {
+        BluetoothDevice manager = mLocalManager.getBluetoothManager();
+        manager.setName(value);
+        return true;        
+    }
+    
+}
diff --git a/src/com/android/settings/bluetooth/BluetoothPinDialog.java b/src/com/android/settings/bluetooth/BluetoothPinDialog.java
new file mode 100644
index 0000000..5e289f7
--- /dev/null
+++ b/src/com/android/settings/bluetooth/BluetoothPinDialog.java
@@ -0,0 +1,202 @@
+/*
+ * 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.settings.bluetooth;
+
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import android.text.Editable;
+import android.text.InputFilter;
+import android.text.TextWatcher;
+import android.text.InputFilter.LengthFilter;
+import android.util.Log;
+import android.view.View;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.TextView;
+
+import com.android.internal.app.AlertActivity;
+import com.android.internal.app.AlertController;
+import com.android.settings.R;
+
+/**
+ * BluetoothPinDialog asks the user to enter a PIN for pairing with a remote
+ * Bluetooth device. It is an activity that appears as a dialog.
+ */
+public class BluetoothPinDialog extends AlertActivity implements DialogInterface.OnClickListener,
+        TextWatcher {
+    private static final String TAG = "BluetoothPinDialog";
+
+    private LocalBluetoothManager mLocalManager;
+    private String mAddress;
+    private EditText mPinView;
+    private Button mOkButton;
+
+    private static final String INSTANCE_KEY_PAIRING_CANCELED = "received_pairing_canceled";
+    private boolean mReceivedPairingCanceled;
+    
+    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (!BluetoothIntent.PAIRING_CANCEL_ACTION.equals(intent.getAction())) {
+                return;
+            }
+            
+            String address = intent.getStringExtra(BluetoothIntent.ADDRESS);
+            if (address == null || address.equals(mAddress)) {
+                onReceivedPairingCanceled();
+            }
+        }
+    };
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        Intent intent = getIntent();
+        if (!intent.getAction().equals(BluetoothIntent.PAIRING_REQUEST_ACTION))
+        {
+            Log.e(TAG,
+                  "Error: this activity may be started only with intent " +
+                  BluetoothIntent.PAIRING_REQUEST_ACTION);
+            finish();
+        }
+        
+        mLocalManager = LocalBluetoothManager.getInstance(this);
+        mAddress = intent.getStringExtra(BluetoothIntent.ADDRESS);
+        
+        // Set up the "dialog"
+        final AlertController.AlertParams p = mAlertParams;
+        p.mIconId = android.R.drawable.ic_dialog_info;
+        p.mTitle = getString(R.string.bluetooth_pin_entry);
+        p.mView = createView();
+        p.mPositiveButtonText = getString(android.R.string.ok);
+        p.mPositiveButtonListener = this;
+        p.mNegativeButtonText = getString(android.R.string.cancel);
+        p.mNegativeButtonListener = this;
+        setupAlert();
+        
+        mOkButton = mAlert.getButton(DialogInterface.BUTTON_POSITIVE);
+        mOkButton.setEnabled(false);
+
+        /*
+         * Leave this registered through pause/resume since we still want to
+         * finish the activity in the background if pairing is canceled.
+         */
+        registerReceiver(mReceiver, new IntentFilter(BluetoothIntent.PAIRING_CANCEL_ACTION));
+    }
+
+    @Override
+    protected void onRestoreInstanceState(Bundle savedInstanceState) {
+        super.onRestoreInstanceState(savedInstanceState);
+        
+        mReceivedPairingCanceled = savedInstanceState.getBoolean(INSTANCE_KEY_PAIRING_CANCELED);
+        if (mReceivedPairingCanceled) {
+            onReceivedPairingCanceled();
+        }
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        
+        outState.putBoolean(INSTANCE_KEY_PAIRING_CANCELED, mReceivedPairingCanceled);
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        
+        unregisterReceiver(mReceiver);
+    }
+
+    private View createView() {
+        View view = getLayoutInflater().inflate(R.layout.bluetooth_pin_entry, null);
+        
+        String name = mLocalManager.getLocalDeviceManager().getName(mAddress);
+        TextView messageView = (TextView) view.findViewById(R.id.message);
+        messageView.setText(getString(R.string.bluetooth_enter_pin_msg, name));
+        
+        mPinView = (EditText) view.findViewById(R.id.text);
+        mPinView.addTextChangedListener(this);
+        // Maximum of 10 characters in a PIN
+        mPinView.setFilters(new InputFilter[] { new LengthFilter(10) });
+        
+        return view;
+    }
+
+    public void afterTextChanged(Editable s) {
+        if (s.length() > 0) {
+            mOkButton.setEnabled(true);
+        }
+    }
+
+    private void onReceivedPairingCanceled() {
+        mReceivedPairingCanceled = true;
+        
+        TextView messageView = (TextView) findViewById(R.id.message);
+        messageView.setText(getString(R.string.bluetooth_pairing_error_message,
+                mLocalManager.getLocalDeviceManager().getName(mAddress)));
+        
+        mPinView.setVisibility(View.GONE);
+        mPinView.clearFocus();
+        mPinView.removeTextChangedListener(this);
+
+        mOkButton.setEnabled(true);
+        mAlert.getButton(DialogInterface.BUTTON_NEGATIVE).setVisibility(View.GONE);
+    }
+    
+    private void onPair(String pin) {
+        byte[] pinBytes = BluetoothDevice.convertPinToBytes(pin);
+        
+        if (pinBytes == null) {
+            return;
+        }
+        
+        mLocalManager.getBluetoothManager().setPin(mAddress, pinBytes);
+    }
+
+    private void onCancel() {
+        mLocalManager.getBluetoothManager().cancelBondProcess(mAddress);
+    }
+    
+    public void onClick(DialogInterface dialog, int which) {
+        switch (which) {
+            case DialogInterface.BUTTON_POSITIVE:
+                onPair(mPinView.getText().toString());
+                break;
+                
+            case DialogInterface.BUTTON_NEGATIVE:
+                onCancel();
+                break;
+        }
+    }
+
+    /* Not used */
+    public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+    }
+
+    /* Not used */
+    public void onTextChanged(CharSequence s, int start, int before, int count) {
+    }
+
+}
diff --git a/src/com/android/settings/bluetooth/BluetoothPinRequest.java b/src/com/android/settings/bluetooth/BluetoothPinRequest.java
new file mode 100644
index 0000000..619052d
--- /dev/null
+++ b/src/com/android/settings/bluetooth/BluetoothPinRequest.java
@@ -0,0 +1,96 @@
+/*
+ * 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.settings.bluetooth;
+
+import com.android.settings.R;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.text.TextUtils;
+
+/**
+ * BluetoothPinRequest is a receiver for any Bluetooth pairing PIN request. It
+ * checks if the Bluetooth Settings is currently visible and brings up the PIN
+ * entry dialog. Otherwise it puts a Notification in the status bar, which can
+ * be clicked to bring up the PIN entry dialog.
+ */
+public class BluetoothPinRequest extends BroadcastReceiver {
+
+    public static final int NOTIFICATION_ID = android.R.drawable.stat_sys_data_bluetooth;
+    
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        String action = intent.getAction();
+        if (action.equals(BluetoothIntent.PAIRING_REQUEST_ACTION)) {
+
+            LocalBluetoothManager localManager = LocalBluetoothManager.getInstance(context);        
+        
+            String address = intent.getStringExtra(BluetoothIntent.ADDRESS);
+            Intent pinIntent = new Intent();
+            pinIntent.setClass(context, BluetoothPinDialog.class);
+            pinIntent.putExtra(BluetoothIntent.ADDRESS, address); 
+            pinIntent.setAction(BluetoothIntent.PAIRING_REQUEST_ACTION);
+            pinIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            
+            if (localManager.getForegroundActivity() != null) {
+                // Since the BT-related activity is in the foreground, just open the dialog
+                context.startActivity(pinIntent);
+                
+            } else {
+                
+                // Put up a notification that leads to the dialog
+                Resources res = context.getResources();
+                Notification notification = new Notification(
+                        android.R.drawable.stat_sys_data_bluetooth,
+                        res.getString(R.string.bluetooth_notif_ticker),
+                        System.currentTimeMillis());
+
+                PendingIntent pending = PendingIntent.getActivity(context, 0, 
+                        pinIntent, PendingIntent.FLAG_ONE_SHOT);
+                
+                String name = intent.getStringExtra(BluetoothIntent.NAME);
+                if (TextUtils.isEmpty(name)) {
+                    name = localManager.getLocalDeviceManager().getName(address);
+                }
+                
+                notification.setLatestEventInfo(context, 
+                        res.getString(R.string.bluetooth_notif_title), 
+                        res.getString(R.string.bluetooth_notif_message) + name, 
+                        pending);
+                notification.flags |= Notification.FLAG_AUTO_CANCEL;
+                
+                NotificationManager manager = (NotificationManager) 
+                        context.getSystemService(Context.NOTIFICATION_SERVICE);
+                manager.notify(NOTIFICATION_ID, notification);
+            }
+            
+        } else if (action.equals(BluetoothIntent.PAIRING_CANCEL_ACTION)) {
+            
+            // Remove the notification
+            NotificationManager manager = (NotificationManager) context
+                    .getSystemService(Context.NOTIFICATION_SERVICE);
+            manager.cancel(NOTIFICATION_ID);
+        }
+    }
+}
diff --git a/src/com/android/settings/bluetooth/BluetoothSettings.java b/src/com/android/settings/bluetooth/BluetoothSettings.java
new file mode 100644
index 0000000..5adada3
--- /dev/null
+++ b/src/com/android/settings/bluetooth/BluetoothSettings.java
@@ -0,0 +1,260 @@
+/*
+ * 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.settings.bluetooth;
+
+import com.android.settings.ProgressCategory;
+import com.android.settings.R;
+import com.android.settings.bluetooth.LocalBluetoothManager.ExtendedBluetoothState;
+
+import java.util.List;
+import java.util.WeakHashMap;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceScreen;
+import android.view.ContextMenu;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.widget.AdapterView.AdapterContextMenuInfo;
+
+/**
+ * BluetoothSettings is the Settings screen for Bluetooth configuration and
+ * connection management.
+ */
+public class BluetoothSettings extends PreferenceActivity
+        implements LocalBluetoothManager.Callback {
+
+    private static final String TAG = "BluetoothSettings";
+
+    private static final int MENU_SCAN = Menu.FIRST;
+    
+    private static final String KEY_BT_CHECKBOX = "bt_checkbox";
+    private static final String KEY_BT_DISCOVERABLE = "bt_discoverable";
+    private static final String KEY_BT_DEVICE_LIST = "bt_device_list";
+    private static final String KEY_BT_NAME = "bt_name";
+    private static final String KEY_BT_SCAN = "bt_scan";
+    
+    private LocalBluetoothManager mLocalManager;
+    
+    private BluetoothEnabler mEnabler;
+    private BluetoothDiscoverableEnabler mDiscoverableEnabler;
+    
+    private BluetoothNamePreference mNamePreference;
+    
+    private ProgressCategory mDeviceList;
+    
+    private WeakHashMap<LocalBluetoothDevice, BluetoothDevicePreference> mDevicePreferenceMap =
+            new WeakHashMap<LocalBluetoothDevice, BluetoothDevicePreference>();
+    
+    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            // TODO: put this in callback instead of receiving
+            onBluetoothStateChanged(mLocalManager.getBluetoothState());
+        }
+    };
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        mLocalManager = LocalBluetoothManager.getInstance(this);
+        if (mLocalManager == null) finish();        
+        
+        addPreferencesFromResource(R.xml.bluetooth_settings);
+        
+        mEnabler = new BluetoothEnabler(
+                this,
+                (CheckBoxPreference) findPreference(KEY_BT_CHECKBOX));
+        
+        mDiscoverableEnabler = new BluetoothDiscoverableEnabler(
+                this,
+                (CheckBoxPreference) findPreference(KEY_BT_DISCOVERABLE));
+    
+        mNamePreference = (BluetoothNamePreference) findPreference(KEY_BT_NAME);
+        
+        mDeviceList = (ProgressCategory) findPreference(KEY_BT_DEVICE_LIST);
+        
+        registerForContextMenu(getListView());
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        
+        // Repopulate (which isn't too bad since it's cached in the settings
+        // bluetooth manager
+        mDevicePreferenceMap.clear();
+        mDeviceList.removeAll();
+        addDevices();
+
+        mEnabler.resume();
+        mDiscoverableEnabler.resume();
+        mNamePreference.resume();
+        mLocalManager.registerCallback(this);
+        
+        mLocalManager.startScanning(false);
+
+        registerReceiver(mReceiver, 
+                new IntentFilter(LocalBluetoothManager.EXTENDED_BLUETOOTH_STATE_CHANGED_ACTION));
+        
+        mLocalManager.setForegroundActivity(this);
+    }
+    
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        mLocalManager.setForegroundActivity(null);
+        
+        unregisterReceiver(mReceiver);
+        
+        mLocalManager.unregisterCallback(this);
+        mNamePreference.pause();
+        mDiscoverableEnabler.pause();
+        mEnabler.pause();
+    }
+
+    private void addDevices() {
+        List<LocalBluetoothDevice> devices = mLocalManager.getLocalDeviceManager().getDevicesCopy();
+        for (LocalBluetoothDevice device : devices) {
+            onDeviceAdded(device);
+        }
+    }
+    
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        menu.add(0, MENU_SCAN, 0, R.string.bluetooth_scan_for_devices)
+                .setIcon(com.android.internal.R.drawable.ic_menu_refresh)
+                .setAlphabeticShortcut('r');
+        return true;
+    }
+
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        menu.findItem(MENU_SCAN).setEnabled(mLocalManager.getBluetoothManager().isEnabled());
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+        
+            case MENU_SCAN:
+                mLocalManager.startScanning(true);
+                return true;
+                
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
+            Preference preference) {
+
+        if (KEY_BT_SCAN.equals(preference.getKey())) {
+            mLocalManager.startScanning(true);
+            return true;
+        }
+        
+        if (preference instanceof BluetoothDevicePreference) {
+            BluetoothDevicePreference btPreference = (BluetoothDevicePreference) preference;
+            btPreference.getDevice().onClicked();
+            return true;
+        }
+        
+        return super.onPreferenceTreeClick(preferenceScreen, preference);
+    }
+    
+    @Override
+    public void onCreateContextMenu(ContextMenu menu, View v,
+            ContextMenuInfo menuInfo) {
+        LocalBluetoothDevice device = getDeviceFromMenuInfo(menuInfo);
+        if (device == null) return;
+        
+        device.onCreateContextMenu(menu);
+    }
+
+    @Override
+    public boolean onContextItemSelected(MenuItem item) {
+        LocalBluetoothDevice device = getDeviceFromMenuInfo(item.getMenuInfo());
+        if (device == null) return false;
+        
+        device.onContextItemSelected(item);
+        return true;
+    }
+
+    private LocalBluetoothDevice getDeviceFromMenuInfo(ContextMenuInfo menuInfo) {
+        if ((menuInfo == null) || !(menuInfo instanceof AdapterContextMenuInfo)) {
+            return null;
+        }
+        
+        AdapterContextMenuInfo adapterMenuInfo = (AdapterContextMenuInfo) menuInfo;
+        Preference pref = (Preference) getPreferenceScreen().getRootAdapter().getItem(
+                adapterMenuInfo.position);
+        if (pref == null || !(pref instanceof BluetoothDevicePreference)) {
+            return null;
+        }
+
+        return ((BluetoothDevicePreference) pref).getDevice();
+    }
+    
+    public void onDeviceAdded(LocalBluetoothDevice device) {
+
+        if (mDevicePreferenceMap.get(device) != null) {
+            throw new IllegalStateException("Got onDeviceAdded, but device already exists");
+        }
+        
+        createDevicePreference(device);            
+    }
+
+    private void createDevicePreference(LocalBluetoothDevice device) {
+        BluetoothDevicePreference preference = new BluetoothDevicePreference(this, device);
+        mDeviceList.addPreference(preference);
+        mDevicePreferenceMap.put(device, preference);
+    }
+    
+    public void onDeviceDeleted(LocalBluetoothDevice device) {
+        BluetoothDevicePreference preference = mDevicePreferenceMap.remove(device);
+        if (preference != null) {
+            mDeviceList.removePreference(preference);
+        }
+    }
+
+    public void onScanningStateChanged(boolean started) {
+        mDeviceList.setProgress(started);
+    }
+    
+    private void onBluetoothStateChanged(ExtendedBluetoothState bluetoothState) {
+        // When bluetooth is enabled (and we are in the activity, which we are),
+        // we should start a scan
+        if (bluetoothState == ExtendedBluetoothState.ENABLED) {
+            mLocalManager.startScanning(false);
+        } else if (bluetoothState == ExtendedBluetoothState.DISABLED) {
+            mDeviceList.setProgress(false);
+        }
+    }
+}
diff --git a/src/com/android/settings/bluetooth/ConnectSpecificProfilesActivity.java b/src/com/android/settings/bluetooth/ConnectSpecificProfilesActivity.java
new file mode 100644
index 0000000..7dd1b70
--- /dev/null
+++ b/src/com/android/settings/bluetooth/ConnectSpecificProfilesActivity.java
@@ -0,0 +1,298 @@
+/*
+ * 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.settings.bluetooth;
+
+import com.android.settings.R;
+import com.android.settings.bluetooth.LocalBluetoothProfileManager.Profile;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceGroup;
+import android.text.TextUtils;
+import android.util.Log;
+
+/**
+ * ConnectSpecificProfilesActivity presents the user with all of the profiles
+ * for a particular device, and allows him to choose which should be connected
+ * (or disconnected).
+ */
+public class ConnectSpecificProfilesActivity extends PreferenceActivity
+        implements LocalBluetoothDevice.Callback, Preference.OnPreferenceChangeListener {
+    private static final String TAG = "ConnectSpecificProfilesActivity";
+
+    private static final String KEY_ONLINE_MODE = "online_mode";
+    private static final String KEY_TITLE = "title";
+    private static final String KEY_PROFILE_CONTAINER = "profile_container";
+
+    public static final String EXTRA_ADDRESS = "address";
+    
+    private LocalBluetoothManager mManager;
+    private LocalBluetoothDevice mDevice;
+    
+    private PreferenceGroup mProfileContainer;
+    private CheckBoxPreference mOnlineModePreference;
+
+    /**
+     * The current mode of this activity and its checkboxes (either online mode
+     * or offline mode). In online mode, user interactions with the profile
+     * checkboxes will also toggle the profile's connectivity. In offline mode,
+     * they will not, and only the preferred state will be saved for the
+     * profile.
+     */
+    private boolean mOnlineMode;
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        
+        String address;
+        if (savedInstanceState != null) {
+            address = savedInstanceState.getString(EXTRA_ADDRESS);
+        } else {
+            Intent intent = getIntent();
+            address = intent.getStringExtra(EXTRA_ADDRESS);
+        }
+
+        if (TextUtils.isEmpty(address)) {
+            Log.w(TAG, "Activity started without address");
+            finish();
+        }
+        
+        mManager = LocalBluetoothManager.getInstance(this);
+        mDevice = mManager.getLocalDeviceManager().findDevice(address);
+        if (mDevice == null) {
+            Log.w(TAG, "Device not found, cannot connect to it");
+            finish();
+        }
+
+        addPreferencesFromResource(R.xml.bluetooth_device_advanced);
+        mProfileContainer = (PreferenceGroup) findPreference(KEY_PROFILE_CONTAINER);
+        
+        // Set the title of the screen
+        findPreference(KEY_TITLE).setTitle(
+                getString(R.string.bluetooth_device_advanced_title, mDevice.getName()));
+
+        // Listen for check/uncheck of the online mode checkbox
+        mOnlineModePreference = (CheckBoxPreference) findPreference(KEY_ONLINE_MODE);
+        mOnlineModePreference.setOnPreferenceChangeListener(this);
+        
+        // Add a preference for each profile
+        addPreferencesForProfiles();
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        
+        outState.putString(EXTRA_ADDRESS, mDevice.getAddress());
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        
+        mManager.setForegroundActivity(this);
+        mDevice.registerCallback(this);
+
+        refresh();
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        
+        mDevice.unregisterCallback(this);
+        mManager.setForegroundActivity(null);
+    }
+
+    private void addPreferencesForProfiles() {
+        for (Profile profile : mDevice.getProfiles()) {
+            Preference pref = createProfilePreference(profile);
+            mProfileContainer.addPreference(pref);
+        }
+    }
+
+    /**
+     * Creates a checkbox preference for the particular profile. The key will be
+     * the profile's name.
+     * 
+     * @param profile The profile for which the preference controls.
+     * @return A preference that allows the user to choose whether this profile
+     *         will be connected to.
+     */
+    private CheckBoxPreference createProfilePreference(Profile profile) {
+        CheckBoxPreference pref = new CheckBoxPreference(this);
+        pref.setKey(profile.toString());
+        pref.setTitle(profile.localizedString);
+        pref.setPersistent(false);
+        pref.setOnPreferenceChangeListener(this);
+
+        refreshProfilePreference(pref, profile);
+        
+        return pref;
+    }
+
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        String key = preference.getKey();
+        if (TextUtils.isEmpty(key) || newValue == null) return true;
+        
+        if (key.equals(KEY_ONLINE_MODE)) {
+            onOnlineModeCheckedStateChanged((Boolean) newValue);
+            
+        } else {
+            Profile profile = getProfileOf(preference);
+            if (profile == null) return false;
+            onProfileCheckedStateChanged(profile, (Boolean) newValue);
+        }
+
+        return true;
+    }
+
+    private void onOnlineModeCheckedStateChanged(boolean checked) {
+        setOnlineMode(checked, true);
+    }
+    
+    private void onProfileCheckedStateChanged(Profile profile, boolean checked) {
+        if (mOnlineMode) {
+            if (checked) {
+                mDevice.connect(profile);
+            } else {
+                mDevice.disconnect(profile);
+            }
+        }
+        
+        LocalBluetoothProfileManager profileManager = LocalBluetoothProfileManager
+                .getProfileManager(mManager, profile);
+        profileManager.setPreferred(mDevice.getAddress(), checked);
+    }
+    
+    public void onDeviceAttributesChanged(LocalBluetoothDevice device) {
+        refresh();
+    }
+
+    private void refresh() {
+        // We are in 'online mode' if we are connected, connecting, or disconnecting
+        setOnlineMode(mDevice.isConnected() || mDevice.isBusy(), false);
+        refreshProfiles();
+    }
+
+    /**
+     * Switches between online/offline mode.
+     * 
+     * @param onlineMode Whether to be in online mode, or offline mode.
+     * @param takeAction Whether to take action (i.e., connect or disconnect)
+     *            based on the new online mode.
+     */
+    private void setOnlineMode(boolean onlineMode, boolean takeAction) {
+        mOnlineMode = onlineMode;
+            
+        if (takeAction) {
+            if (onlineMode) {
+                mDevice.connect();
+            } else {
+                mDevice.disconnect();
+            }
+        }
+            
+        refreshOnlineModePreference();
+    }
+    
+    private void refreshOnlineModePreference() {
+        mOnlineModePreference.setChecked(mOnlineMode);
+
+        /* Gray out checkbox while connecting and disconnecting */
+        mOnlineModePreference.setEnabled(!mDevice.isBusy());
+
+        /**
+         * If the device is online, show status. Otherwise, show a summary that
+         * describes what the checkbox does.
+         */
+        mOnlineModePreference.setSummary(mOnlineMode ? mDevice.getSummary()
+                : R.string.bluetooth_device_advanced_online_mode_summary);
+    }
+    
+    private void refreshProfiles() {
+        for (Profile profile : mDevice.getProfiles()) {
+            CheckBoxPreference profilePref =
+                    (CheckBoxPreference) findPreference(profile.toString());
+            if (profilePref == null) {
+                profilePref = createProfilePreference(profile);
+                mProfileContainer.addPreference(profilePref);
+            } else {
+                refreshProfilePreference(profilePref, profile);
+            }
+        }
+    }
+    
+    private void refreshProfilePreference(CheckBoxPreference profilePref, Profile profile) {
+        String address = mDevice.getAddress();
+        LocalBluetoothProfileManager profileManager = LocalBluetoothProfileManager
+                .getProfileManager(mManager, profile);
+        
+        int connectionStatus = profileManager.getConnectionStatus(address);
+
+        /* Gray out checkbox while connecting and disconnecting */
+        profilePref.setEnabled(!mDevice.isBusy());
+
+        profilePref.setSummary(getProfileSummary(profileManager, profile, address,
+                connectionStatus, mOnlineMode));
+        
+        profilePref.setChecked(profileManager.isPreferred(address));
+    }
+
+    private Profile getProfileOf(Preference pref) {
+        if (!(pref instanceof CheckBoxPreference)) return null;
+        String key = pref.getKey();
+        if (TextUtils.isEmpty(key)) return null;
+        
+        try {
+            return Profile.valueOf(pref.getKey());
+        } catch (IllegalArgumentException e) {
+            return null;
+        }
+    }
+
+    private static int getProfileSummary(LocalBluetoothProfileManager profileManager,
+            Profile profile, String address, int connectionStatus, boolean onlineMode) {
+        if (!onlineMode || connectionStatus == SettingsBtStatus.CONNECTION_STATUS_DISCONNECTED) {
+            return getProfileSummaryForSettingPreference(profile);
+        } else {
+            return profileManager.getSummary(address);
+        }
+    }
+    
+    /**
+     * Gets the summary that describes when checked, it will become a preferred profile.
+     * 
+     * @param profile The profile to get the summary for.
+     * @return The summary.
+     */
+    private static final int getProfileSummaryForSettingPreference(Profile profile) {
+        switch (profile) {
+            case A2DP:
+                return R.string.bluetooth_a2dp_profile_summary_use_for;
+            case HEADSET:
+                return R.string.bluetooth_headset_profile_summary_use_for;
+            default:
+                return 0;
+        }
+    }
+    
+}
diff --git a/src/com/android/settings/bluetooth/LocalBluetoothDevice.java b/src/com/android/settings/bluetooth/LocalBluetoothDevice.java
new file mode 100644
index 0000000..a488540
--- /dev/null
+++ b/src/com/android/settings/bluetooth/LocalBluetoothDevice.java
@@ -0,0 +1,576 @@
+/*
+ * 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.settings.bluetooth;
+
+import com.android.settings.R;
+import com.android.settings.bluetooth.LocalBluetoothProfileManager.Profile;
+
+import android.app.AlertDialog;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothClass;
+import android.bluetooth.IBluetoothDeviceCallback;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.Menu;
+import android.view.MenuItem;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * LocalBluetoothDevice represents a remote Bluetooth device. It contains
+ * attributes of the device (such as the address, name, RSSI, etc.) and
+ * functionality that can be performed on the device (connect, pair, disconnect,
+ * etc.).
+ */
+public class LocalBluetoothDevice implements Comparable<LocalBluetoothDevice> {
+    private static final String TAG = "LocalBluetoothDevice";
+
+    private static final int CONTEXT_ITEM_CONNECT = Menu.FIRST + 1;
+    private static final int CONTEXT_ITEM_DISCONNECT = Menu.FIRST + 2;
+    private static final int CONTEXT_ITEM_UNPAIR = Menu.FIRST + 3;
+    private static final int CONTEXT_ITEM_CONNECT_ADVANCED = Menu.FIRST + 4;
+
+    private final String mAddress;
+    private String mName;
+    private short mRssi;
+    private int mBtClass = BluetoothClass.ERROR;
+
+    private List<Profile> mProfiles = new ArrayList<Profile>();
+
+    private boolean mVisible;
+
+    private final LocalBluetoothManager mLocalManager;
+
+    private List<Callback> mCallbacks = new ArrayList<Callback>();
+
+    /**
+     * When we connect to multiple profiles, we only want to display a single
+     * error even if they all fail. This tracks that state.
+     */
+    private boolean mIsConnectingErrorPossible;
+
+    LocalBluetoothDevice(Context context, String address) {
+        mLocalManager = LocalBluetoothManager.getInstance(context);
+        if (mLocalManager == null) {
+            throw new IllegalStateException(
+                    "Cannot use LocalBluetoothDevice without Bluetooth hardware");
+        }
+
+        mAddress = address;
+
+        fillData();
+    }
+
+    public void onClicked() {
+        int bondState = getBondState();
+
+        if (isConnected()) {
+            askDisconnect();
+        } else if (bondState == BluetoothDevice.BOND_BONDED) {
+            connect();
+        } else if (bondState == BluetoothDevice.BOND_NOT_BONDED) {
+            pair();
+        }
+    }
+
+    public void disconnect() {
+        for (Profile profile : mProfiles) {
+            disconnect(profile);
+        }
+    }
+
+    public void disconnect(Profile profile) {
+        LocalBluetoothProfileManager profileManager =
+                LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile);
+        int status = profileManager.getConnectionStatus(mAddress);
+        if (SettingsBtStatus.isConnectionStatusConnected(status)) {
+            profileManager.disconnect(mAddress);
+        }
+    }
+
+    public void askDisconnect() {
+        Context context = mLocalManager.getForegroundActivity();
+        if (context == null) {
+            // Cannot ask, since we need an activity context
+            disconnect();
+            return;
+        }
+
+        Resources res = context.getResources();
+
+        String name = getName();
+        if (TextUtils.isEmpty(name)) {
+            name = res.getString(R.string.bluetooth_device);
+        }
+        String message = res.getString(R.string.bluetooth_disconnect_blank, name);
+
+        DialogInterface.OnClickListener disconnectListener = new DialogInterface.OnClickListener() {
+            public void onClick(DialogInterface dialog, int which) {
+                disconnect();
+            }
+        };
+
+        AlertDialog ad = new AlertDialog.Builder(context)
+                .setTitle(getName())
+                .setMessage(message)
+                .setPositiveButton(android.R.string.ok, disconnectListener)
+                .setNegativeButton(android.R.string.cancel, null)
+                .show();
+    }
+
+    public void connect() {
+        if (!ensurePaired()) return;
+
+        // Reset the only-show-one-error-dialog tracking variable
+        mIsConnectingErrorPossible = true;
+
+        Context context = mLocalManager.getContext();
+        boolean hasAtLeastOnePreferredProfile = false;
+        for (Profile profile : mProfiles) {
+            LocalBluetoothProfileManager profileManager =
+                    LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile);
+            if (profileManager.isPreferred(mAddress)) {
+                hasAtLeastOnePreferredProfile = true;
+                connectInt(profile);
+            }
+        }
+
+        if (!hasAtLeastOnePreferredProfile) {
+            connectAndPreferAllProfiles();
+        }
+    }
+
+    private void connectAndPreferAllProfiles() {
+        if (!ensurePaired()) return;
+
+        // Reset the only-show-one-error-dialog tracking variable
+        mIsConnectingErrorPossible = true;
+
+        Context context = mLocalManager.getContext();
+        for (Profile profile : mProfiles) {
+            LocalBluetoothProfileManager profileManager =
+                    LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile);
+            profileManager.setPreferred(mAddress, true);
+            connectInt(profile);
+        }
+    }
+
+    public void connect(Profile profile) {
+        // Reset the only-show-one-error-dialog tracking variable
+        mIsConnectingErrorPossible = true;
+        connectInt(profile);
+    }
+
+    public void connectInt(Profile profile) {
+        if (!ensurePaired()) return;
+
+        LocalBluetoothProfileManager profileManager =
+                LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile);
+        int status = profileManager.getConnectionStatus(mAddress);
+        if (!SettingsBtStatus.isConnectionStatusConnected(status)) {
+            if (profileManager.connect(mAddress) != BluetoothDevice.RESULT_SUCCESS) {
+                Log.i(TAG, "Failed to connect " + profile.toString() + " to " + mName);
+            }
+        }
+    }
+
+    public void showConnectingError() {
+        if (!mIsConnectingErrorPossible) return;
+        mIsConnectingErrorPossible = false;
+
+        mLocalManager.showError(mAddress, R.string.bluetooth_error_title,
+                R.string.bluetooth_connecting_error_message);
+    }
+
+    private boolean ensurePaired() {
+        if (getBondState() == BluetoothDevice.BOND_NOT_BONDED) {
+            pair();
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    public void pair() {
+        BluetoothDevice manager = mLocalManager.getBluetoothManager();
+
+        // Pairing is unreliable while scanning, so cancel discovery
+        if (manager.isDiscovering()) {
+            manager.cancelDiscovery();
+        }
+
+        if (!mLocalManager.getBluetoothManager().createBond(mAddress)) {
+            mLocalManager.showError(mAddress, R.string.bluetooth_error_title,
+                    R.string.bluetooth_pairing_error_message);
+        }
+    }
+
+    public void unpair() {
+        BluetoothDevice manager = mLocalManager.getBluetoothManager();
+
+        switch (getBondState()) {
+        case BluetoothDevice.BOND_BONDED:
+            manager.removeBond(mAddress);
+            break;
+
+        case BluetoothDevice.BOND_BONDING:
+            manager.cancelBondProcess(mAddress);
+            break;
+        }
+    }
+
+    private void fillData() {
+        BluetoothDevice manager = mLocalManager.getBluetoothManager();
+
+        fetchName();
+        fetchBtClass();
+
+        mVisible = false;
+
+        dispatchAttributesChanged();
+    }
+
+    public String getAddress() {
+        return mAddress;
+    }
+
+    public String getName() {
+        return mName;
+    }
+
+    public void refreshName() {
+        fetchName();
+        dispatchAttributesChanged();
+    }
+
+    private void fetchName() {
+        mName = mLocalManager.getBluetoothManager().getRemoteName(mAddress);
+
+        if (TextUtils.isEmpty(mName)) {
+            mName = mAddress;
+        }
+    }
+
+    public void refresh() {
+        dispatchAttributesChanged();
+    }
+
+    public boolean isVisible() {
+        return mVisible;
+    }
+
+    void setVisible(boolean visible) {
+        if (mVisible != visible) {
+            mVisible = visible;
+            dispatchAttributesChanged();
+        }
+    }
+
+    public int getBondState() {
+        return mLocalManager.getBluetoothManager().getBondState(mAddress);
+    }
+
+    void setRssi(short rssi) {
+        if (mRssi != rssi) {
+            mRssi = rssi;
+            dispatchAttributesChanged();
+        }
+    }
+
+    /**
+     * Checks whether we are connected to this device (any profile counts).
+     *
+     * @return Whether it is connected.
+     */
+    public boolean isConnected() {
+        for (Profile profile : mProfiles) {
+            int status = LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile)
+                    .getConnectionStatus(mAddress);
+            if (SettingsBtStatus.isConnectionStatusConnected(status)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public boolean isBusy() {
+        for (Profile profile : mProfiles) {
+            int status = LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile)
+                    .getConnectionStatus(mAddress);
+            if (SettingsBtStatus.isConnectionStatusBusy(status)) {
+                return true;
+            }
+        }
+
+        if (getBondState() == BluetoothDevice.BOND_BONDING) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public int getBtClassDrawable() {
+
+        // First try looking at profiles
+        if (mProfiles.contains(Profile.A2DP)) {
+            return R.drawable.ic_bt_headphones_a2dp;
+        } else if (mProfiles.contains(Profile.HEADSET)) {
+            return R.drawable.ic_bt_headset_hfp;
+        }
+
+        // Fallback on class
+        switch (BluetoothClass.Device.Major.getDeviceMajor(mBtClass)) {
+        case BluetoothClass.Device.Major.COMPUTER:
+            return R.drawable.ic_bt_laptop;
+
+        case BluetoothClass.Device.Major.PHONE:
+            return R.drawable.ic_bt_cellphone;
+
+        default:
+            return 0;
+        }
+    }
+
+    /**
+     * Fetches a new value for the cached BT class.
+     */
+    private void fetchBtClass() {
+        mBtClass = mLocalManager.getBluetoothManager().getRemoteClass(mAddress);
+        mProfiles.clear();
+        LocalBluetoothProfileManager.fill(mBtClass, mProfiles);
+    }
+
+    /**
+     * Refreshes the UI for the BT class, including fetching the latest value
+     * for the class.
+     */
+    public void refreshBtClass() {
+        fetchBtClass();
+        dispatchAttributesChanged();
+    }
+
+    public int getSummary() {
+        // TODO: clean up
+        int oneOffSummary = getOneOffSummary();
+        if (oneOffSummary != 0) {
+            return oneOffSummary;
+        }
+
+        for (Profile profile : mProfiles) {
+            LocalBluetoothProfileManager profileManager = LocalBluetoothProfileManager
+                    .getProfileManager(mLocalManager, profile);
+            int connectionStatus = profileManager.getConnectionStatus(mAddress);
+
+            if (SettingsBtStatus.isConnectionStatusConnected(connectionStatus) ||
+                    connectionStatus == SettingsBtStatus.CONNECTION_STATUS_CONNECTING ||
+                    connectionStatus == SettingsBtStatus.CONNECTION_STATUS_DISCONNECTING) {
+                return SettingsBtStatus.getConnectionStatusSummary(connectionStatus);
+            }
+        }
+
+        return SettingsBtStatus.getPairingStatusSummary(getBondState());
+    }
+
+    /**
+     * We have special summaries when particular profiles are connected. This
+     * checks for those states and returns an applicable summary.
+     *
+     * @return A one-off summary that is applicable for the current state, or 0.
+     */
+    private int getOneOffSummary() {
+        boolean isA2dpConnected = false, isHeadsetConnected = false, isConnecting = false;
+
+        if (mProfiles.contains(Profile.A2DP)) {
+            LocalBluetoothProfileManager profileManager = LocalBluetoothProfileManager
+                    .getProfileManager(mLocalManager, Profile.A2DP);
+            isConnecting = profileManager.getConnectionStatus(mAddress) ==
+                    SettingsBtStatus.CONNECTION_STATUS_CONNECTING;
+            isA2dpConnected = profileManager.isConnected(mAddress);
+        }
+
+        if (mProfiles.contains(Profile.HEADSET)) {
+            LocalBluetoothProfileManager profileManager = LocalBluetoothProfileManager
+                    .getProfileManager(mLocalManager, Profile.HEADSET);
+            isConnecting |= profileManager.getConnectionStatus(mAddress) ==
+                    SettingsBtStatus.CONNECTION_STATUS_CONNECTING;
+            isHeadsetConnected = profileManager.isConnected(mAddress);
+        }
+
+        if (isConnecting) {
+            // If any of these important profiles is connecting, prefer that
+            return SettingsBtStatus.getConnectionStatusSummary(
+                    SettingsBtStatus.CONNECTION_STATUS_CONNECTING);
+        } else if (isA2dpConnected && isHeadsetConnected) {
+            return R.string.bluetooth_summary_connected_to_a2dp_headset;
+        } else if (isA2dpConnected) {
+            return R.string.bluetooth_summary_connected_to_a2dp;
+        } else if (isHeadsetConnected) {
+            return R.string.bluetooth_summary_connected_to_headset;
+        } else {
+            return 0;
+        }
+    }
+
+    public List<Profile> getProfiles() {
+        return new ArrayList<Profile>(mProfiles);
+    }
+
+    public void onCreateContextMenu(ContextMenu menu) {
+        // No context menu if it is busy (none of these items are applicable if busy)
+        if (isBusy()) return;
+
+        int bondState = getBondState();
+        boolean isConnected = isConnected();
+        boolean hasProfiles = mProfiles.size() > 0;
+
+        menu.setHeaderTitle(getName());
+
+        if (isConnected) {
+            menu.add(0, CONTEXT_ITEM_DISCONNECT, 0, R.string.bluetooth_device_context_disconnect);
+        } else if (hasProfiles) {
+            // For connection action, show either "Connect" or "Pair & connect"
+            int connectString = (bondState == BluetoothDevice.BOND_NOT_BONDED)
+                    ? R.string.bluetooth_device_context_pair_connect
+                    : R.string.bluetooth_device_context_connect;
+            menu.add(0, CONTEXT_ITEM_CONNECT, 0, connectString);
+        }
+
+        if (bondState == BluetoothDevice.BOND_BONDED) {
+            // For unpair action, show either "Unpair" or "Disconnect & unpair"
+            int unpairString = isConnected
+                    ? R.string.bluetooth_device_context_disconnect_unpair
+                    : R.string.bluetooth_device_context_unpair;
+            menu.add(0, CONTEXT_ITEM_UNPAIR, 0, unpairString);
+
+            // Show the connection options item
+            menu.add(0, CONTEXT_ITEM_CONNECT_ADVANCED, 0,
+                    R.string.bluetooth_device_context_connect_advanced);
+        }
+    }
+
+    /**
+     * Called when a context menu item is clicked.
+     *
+     * @param item The item that was clicked.
+     */
+    public void onContextItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case CONTEXT_ITEM_DISCONNECT:
+                disconnect();
+                break;
+
+            case CONTEXT_ITEM_CONNECT:
+                connect();
+                break;
+
+            case CONTEXT_ITEM_UNPAIR:
+                mLocalManager.getBluetoothManager().disconnectRemoteDeviceAcl(mAddress);
+                unpair();
+                break;
+
+            case CONTEXT_ITEM_CONNECT_ADVANCED:
+                Intent intent = new Intent();
+                // Need an activity context to open this in our task
+                Context context = mLocalManager.getForegroundActivity();
+                if (context == null) {
+                    // Fallback on application context, and open in a new task
+                    context = mLocalManager.getContext();
+                    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                }
+                intent.setClass(context, ConnectSpecificProfilesActivity.class);
+                intent.putExtra(ConnectSpecificProfilesActivity.EXTRA_ADDRESS, mAddress);
+                context.startActivity(intent);
+                break;
+        }
+    }
+
+    public void registerCallback(Callback callback) {
+        synchronized (mCallbacks) {
+            mCallbacks.add(callback);
+        }
+    }
+
+    public void unregisterCallback(Callback callback) {
+        synchronized (mCallbacks) {
+            mCallbacks.remove(callback);
+        }
+    }
+
+    private void dispatchAttributesChanged() {
+        synchronized (mCallbacks) {
+            for (Callback callback : mCallbacks) {
+                callback.onDeviceAttributesChanged(this);
+            }
+        }
+    }
+
+    @Override
+    public String toString() {
+        return mAddress;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if ((o == null) || !(o instanceof LocalBluetoothDevice)) {
+            throw new ClassCastException();
+        }
+
+        return mAddress.equals(((LocalBluetoothDevice) o).mAddress);
+    }
+
+    @Override
+    public int hashCode() {
+        return mAddress.hashCode();
+    }
+
+    public int compareTo(LocalBluetoothDevice another) {
+        int comparison;
+
+        // Connected above not connected
+        comparison = (another.isConnected() ? 1 : 0) - (isConnected() ? 1 : 0);
+        if (comparison != 0) return comparison;
+
+        // Paired above not paired
+        comparison = (another.getBondState() == BluetoothDevice.BOND_BONDED ? 1 : 0) -
+            (getBondState() == BluetoothDevice.BOND_BONDED ? 1 : 0);
+        if (comparison != 0) return comparison;
+
+        // Visible above not visible
+        comparison = (another.mVisible ? 1 : 0) - (mVisible ? 1 : 0);
+        if (comparison != 0) return comparison;
+
+        // Stronger signal above weaker signal
+        comparison = another.mRssi - mRssi;
+        if (comparison != 0) return comparison;
+
+        // Fallback on name
+        return getName().compareTo(another.getName());
+    }
+
+    public interface Callback {
+        void onDeviceAttributesChanged(LocalBluetoothDevice device);
+    }
+}
diff --git a/src/com/android/settings/bluetooth/LocalBluetoothDeviceManager.java b/src/com/android/settings/bluetooth/LocalBluetoothDeviceManager.java
new file mode 100644
index 0000000..6bb2b4a
--- /dev/null
+++ b/src/com/android/settings/bluetooth/LocalBluetoothDeviceManager.java
@@ -0,0 +1,229 @@
+/*
+ * 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.settings.bluetooth;
+
+import android.app.AlertDialog;
+import android.bluetooth.BluetoothDevice;
+import android.util.Log;
+import android.widget.Toast;
+import android.content.Context;
+
+import com.android.settings.R;
+import com.android.settings.bluetooth.LocalBluetoothManager.Callback;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * LocalBluetoothDeviceManager manages the set of remote Bluetooth devices.
+ */
+public class LocalBluetoothDeviceManager {
+    private static final String TAG = "LocalBluetoothDeviceManager";
+
+    final LocalBluetoothManager mLocalManager;
+    final List<Callback> mCallbacks;
+    
+    final List<LocalBluetoothDevice> mDevices = new ArrayList<LocalBluetoothDevice>();
+
+    public LocalBluetoothDeviceManager(LocalBluetoothManager localManager) {
+        mLocalManager = localManager;
+        mCallbacks = localManager.getCallbacks();
+        readPairedDevices();
+    }
+
+    private synchronized boolean readPairedDevices() {
+        BluetoothDevice manager = mLocalManager.getBluetoothManager();
+        String[] bondedAddresses = manager.listBonds();
+        if (bondedAddresses == null) return false;
+        
+        boolean deviceAdded = false;
+        for (String address : bondedAddresses) {
+            LocalBluetoothDevice device = findDevice(address);
+            if (device == null) {
+                device = new LocalBluetoothDevice(mLocalManager.getContext(), address);
+                mDevices.add(device);
+                dispatchDeviceAdded(device);
+                deviceAdded = true;
+            }
+        }
+        
+        return deviceAdded;
+    }
+    
+    public synchronized List<LocalBluetoothDevice> getDevicesCopy() {
+        return new ArrayList<LocalBluetoothDevice>(mDevices);
+    }
+    
+    void onBluetoothStateChanged(boolean enabled) {
+        if (enabled) {
+            readPairedDevices();
+        }
+    }
+
+    public synchronized void onDeviceAppeared(String address, short rssi) {
+        boolean deviceAdded = false;
+        
+        LocalBluetoothDevice device = findDevice(address);
+        if (device == null) {
+            device = new LocalBluetoothDevice(mLocalManager.getContext(), address);
+            mDevices.add(device);
+            deviceAdded = true;
+        }
+        
+        device.setRssi(rssi);
+        device.setVisible(true);
+        
+        if (deviceAdded) {
+            dispatchDeviceAdded(device);
+        }
+    }
+    
+    public synchronized void onDeviceDisappeared(String address) {
+        LocalBluetoothDevice device = findDevice(address);
+        if (device == null) return;
+        
+        device.setVisible(false);
+        checkForDeviceRemoval(device);
+    }
+    
+    private void checkForDeviceRemoval(LocalBluetoothDevice device) {
+        if (device.getBondState() == BluetoothDevice.BOND_NOT_BONDED &&
+                !device.isVisible()) {
+            // If device isn't paired, remove it altogether
+            mDevices.remove(device);
+            dispatchDeviceDeleted(device);
+        }            
+    }
+    
+    public synchronized void onDeviceNameUpdated(String address) {
+        LocalBluetoothDevice device = findDevice(address);
+        if (device != null) {
+            device.refreshName();
+        }
+    }
+
+    public synchronized LocalBluetoothDevice findDevice(String address) {
+        
+        for (int i = mDevices.size() - 1; i >= 0; i--) {
+            LocalBluetoothDevice device = mDevices.get(i);
+            
+            if (device.getAddress().equals(address)) {
+                return device;
+            }
+        }
+        
+        return null;
+    }
+    
+    /**
+     * Attempts to get the name of a remote device, otherwise returns the address.
+     * 
+     * @param address The address.
+     * @return The name, or if unavailable, the address.
+     */
+    public String getName(String address) {
+        LocalBluetoothDevice device = findDevice(address);
+        return device != null ? device.getName() : address;
+    }
+    
+    private void dispatchDeviceAdded(LocalBluetoothDevice device) {
+        synchronized (mCallbacks) {
+            for (Callback callback : mCallbacks) {
+                callback.onDeviceAdded(device);
+            }
+        }
+        
+        // TODO: divider between prev paired/connected and scanned
+    }
+    
+    private void dispatchDeviceDeleted(LocalBluetoothDevice device) {
+        synchronized (mCallbacks) {
+            for (Callback callback : mCallbacks) {
+                callback.onDeviceDeleted(device);
+            }
+        }
+    }
+
+    public synchronized void onBondingStateChanged(String address, int bondState) {
+        LocalBluetoothDevice device = findDevice(address);
+        if (device == null) {
+            if (!readPairedDevices()) {
+                Log.e(TAG, "Got bonding state changed for " + address +
+                        ", but we have no record of that device.");
+            }
+            return;
+        }
+
+        device.refresh();
+
+        if (bondState == BluetoothDevice.BOND_BONDED) {
+            // Auto-connect after pairing
+            device.connect();
+        }
+    }
+
+    /**
+     * Called when there is a bonding error.
+     * 
+     * @param address The address of the remote device.
+     * @param reason The reason, one of the error reasons from
+     *            BluetoothDevice.UNBOND_REASON_*
+     */
+    public synchronized void onBondingError(String address, int reason) {
+        mLocalManager.showError(address, R.string.bluetooth_error_title,
+                (reason == BluetoothDevice.UNBOND_REASON_AUTH_FAILED) ?
+                        R.string.bluetooth_pairing_pin_error_message :
+                        R.string.bluetooth_pairing_error_message);
+    }
+    
+    public synchronized void onProfileStateChanged(String address) {
+        LocalBluetoothDevice device = findDevice(address);
+        if (device == null) return;
+        
+        device.refresh();
+    }
+    
+    public synchronized void onConnectingError(String address) {
+        LocalBluetoothDevice device = findDevice(address);
+        if (device == null) return;
+        
+        /*
+         * Go through the device's delegate so we don't spam the user with
+         * errors connecting to different profiles, and instead make sure the
+         * user sees a single error for his single 'connect' action.
+         */
+        device.showConnectingError();
+    }
+    
+    public synchronized void onScanningStateChanged(boolean started) {
+        if (!started) return;
+        
+        // If starting a new scan, clear old visibility
+        for (int i = mDevices.size() - 1; i >= 0; i--) {
+            LocalBluetoothDevice device = mDevices.get(i);
+            device.setVisible(false);
+            checkForDeviceRemoval(device);
+        }
+    }
+    
+    public synchronized void onBtClassChanged(String address) {
+        LocalBluetoothDevice device = findDevice(address);
+        if (device != null) {
+            device.refreshBtClass();
+        }
+    }
+}
diff --git a/src/com/android/settings/bluetooth/LocalBluetoothManager.java b/src/com/android/settings/bluetooth/LocalBluetoothManager.java
new file mode 100644
index 0000000..4671fac
--- /dev/null
+++ b/src/com/android/settings/bluetooth/LocalBluetoothManager.java
@@ -0,0 +1,279 @@
+/*
+ * 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.settings.bluetooth;
+
+import com.android.settings.R;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.bluetooth.BluetoothA2dp;
+import android.bluetooth.BluetoothDevice;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.util.Log;
+import android.widget.Toast;
+
+// TODO: have some notion of shutting down.  Maybe a minute after they leave BT settings?
+/**
+ * LocalBluetoothManager provides a simplified interface on top of a subset of
+ * the Bluetooth API.
+ */
+public class LocalBluetoothManager {
+    private static final String TAG = "LocalBluetoothManager";
+    static final boolean V = true;
+    
+    public static final String EXTENDED_BLUETOOTH_STATE_CHANGED_ACTION =
+        "com.android.settings.bluetooth.intent.action.EXTENDED_BLUETOOTH_STATE_CHANGED";
+    private static final String SHARED_PREFERENCES_NAME = "bluetooth_settings";
+    
+    private static LocalBluetoothManager INSTANCE;
+    /** Used when obtaining a reference to the singleton instance. */
+    private static Object INSTANCE_LOCK = new Object();
+    private boolean mInitialized;
+    
+    private Context mContext;
+    /** If a BT-related activity is in the foreground, this will be it. */
+    private Activity mForegroundActivity;
+    private AlertDialog mErrorDialog = null;
+
+    private BluetoothDevice mManager;
+
+    private LocalBluetoothDeviceManager mLocalDeviceManager;
+    private BluetoothEventRedirector mEventRedirector;
+    private BluetoothA2dp mBluetoothA2dp;
+    
+    public static enum ExtendedBluetoothState { ENABLED, ENABLING, DISABLED, DISABLING, UNKNOWN }
+    private ExtendedBluetoothState mState = ExtendedBluetoothState.UNKNOWN;
+
+    private List<Callback> mCallbacks = new ArrayList<Callback>();
+    
+    private static final int SCAN_EXPIRATION_MS = 5 * 60 * 1000; // 5 mins
+    private long mLastScan;
+    
+    public static LocalBluetoothManager getInstance(Context context) {
+        synchronized (INSTANCE_LOCK) {
+            if (INSTANCE == null) {
+                INSTANCE = new LocalBluetoothManager();
+            }
+            
+            if (!INSTANCE.init(context)) {
+                return null;
+            }
+            
+            return INSTANCE;
+        }
+    }
+
+    private boolean init(Context context) {
+        if (mInitialized) return true;
+        mInitialized = true;
+        
+        // This will be around as long as this process is
+        mContext = context.getApplicationContext();
+        
+        mManager = (BluetoothDevice) context.getSystemService(Context.BLUETOOTH_SERVICE);
+        if (mManager == null) {
+            return false;
+        }
+        
+        mLocalDeviceManager = new LocalBluetoothDeviceManager(this);
+
+        mEventRedirector = new BluetoothEventRedirector(this);
+        mEventRedirector.start();
+
+        mBluetoothA2dp = new BluetoothA2dp(context);
+
+        return true;
+    }
+    
+    public BluetoothDevice getBluetoothManager() {
+        return mManager;
+    }
+    
+    public Context getContext() {
+        return mContext;
+    }
+
+    public Activity getForegroundActivity() {
+        return mForegroundActivity;
+    }
+    
+    public void setForegroundActivity(Activity activity) {
+        if (mErrorDialog != null) {
+            mErrorDialog.dismiss();
+            mErrorDialog = null;
+        }
+        mForegroundActivity = activity;
+    }
+    
+    public SharedPreferences getSharedPreferences() {
+        return mContext.getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE);
+    }
+    
+    public LocalBluetoothDeviceManager getLocalDeviceManager() {
+        return mLocalDeviceManager;
+    }
+    
+    List<Callback> getCallbacks() {
+        return mCallbacks;
+    }
+    
+    public void registerCallback(Callback callback) {
+        synchronized (mCallbacks) {
+            mCallbacks.add(callback);
+        }
+    }
+    
+    public void unregisterCallback(Callback callback) {
+        synchronized (mCallbacks) {
+            mCallbacks.remove(callback);
+        }
+    }
+    
+    public void startScanning(boolean force) {
+        if (mManager.isDiscovering()) {
+            /*
+             * Already discovering, but give the callback that information.
+             * Note: we only call the callbacks, not the same path as if the
+             * scanning state had really changed (in that case the device
+             * manager would clear its list of unpaired scanned devices).
+             */ 
+            dispatchScanningStateChanged(true);
+        } else {
+            if (!force) {
+                // Don't scan more than frequently than SCAN_EXPIRATION_MS,
+                // unless forced
+                if (mLastScan + SCAN_EXPIRATION_MS > System.currentTimeMillis()) {
+                    return;
+                }
+
+                // If we are playing music, don't scan unless forced.
+                List<String> sinks = mBluetoothA2dp.listConnectedSinks();
+                if (sinks != null) {
+                    for (String address : sinks) {
+                        if (mBluetoothA2dp.getSinkState(address) == BluetoothA2dp.STATE_PLAYING) {
+                            return;
+                        }
+                    }
+                }
+            }
+            
+            if (mManager.startDiscovery(true)) {
+                mLastScan = System.currentTimeMillis();
+            }
+        }
+    }
+    
+    public ExtendedBluetoothState getBluetoothState() {
+        
+        if (mState == ExtendedBluetoothState.UNKNOWN) {
+            syncBluetoothState();
+        }
+            
+        return mState;
+    }
+    
+    void setBluetoothStateInt(ExtendedBluetoothState state) {
+        mState = state;
+        
+        /*
+         * TODO: change to callback method. originally it was broadcast to
+         * parallel the framework's method, but it just complicates things here.
+         */
+        // If this were a real API, I'd add as an extra
+        mContext.sendBroadcast(new Intent(EXTENDED_BLUETOOTH_STATE_CHANGED_ACTION));
+        
+        if (state == ExtendedBluetoothState.ENABLED || state == ExtendedBluetoothState.DISABLED) {
+            mLocalDeviceManager.onBluetoothStateChanged(state == ExtendedBluetoothState.ENABLED);
+        }
+    }
+    
+    private void syncBluetoothState() {
+        setBluetoothStateInt(mManager.isEnabled()
+                ? ExtendedBluetoothState.ENABLED
+                : ExtendedBluetoothState.DISABLED);
+    }
+
+    public void setBluetoothEnabled(boolean enabled) {
+        boolean wasSetStateSuccessful = enabled
+                ? mManager.enable()
+                : mManager.disable();
+                
+        if (wasSetStateSuccessful) {
+            setBluetoothStateInt(enabled
+                    ? ExtendedBluetoothState.ENABLING
+                    : ExtendedBluetoothState.DISABLING);
+        } else {
+            if (V) {
+                Log.v(TAG,
+                        "setBluetoothEnabled call, manager didn't return success for enabled: "
+                                + enabled);
+            }
+            
+            syncBluetoothState();
+        }
+    }
+    
+    /**
+     * @param started True if scanning started, false if scanning finished.
+     */
+    void onScanningStateChanged(boolean started) {
+        // TODO: have it be a callback (once we switch bluetooth state changed to callback)
+        mLocalDeviceManager.onScanningStateChanged(started);
+        dispatchScanningStateChanged(started);
+    }
+    
+    private void dispatchScanningStateChanged(boolean started) {
+        synchronized (mCallbacks) {
+            for (Callback callback : mCallbacks) {
+                callback.onScanningStateChanged(started);
+            }
+        }
+    }
+
+    public void showError(String address, int titleResId, int messageResId) {
+        LocalBluetoothDevice device = mLocalDeviceManager.findDevice(address);
+        if (device == null) return;
+
+        String name = device.getName();
+        String message = mContext.getString(messageResId, name);
+
+        if (mForegroundActivity != null) {
+            // Need an activity context to show a dialog
+            mErrorDialog = new AlertDialog.Builder(mForegroundActivity)
+                .setIcon(android.R.drawable.ic_dialog_alert)
+                .setTitle(titleResId)
+                .setMessage(message)
+                .setPositiveButton(android.R.string.ok, null)
+                .show();
+        } else {
+            // Fallback on a toast 
+            Toast.makeText(mContext, message, Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    public interface Callback {
+        void onScanningStateChanged(boolean started);
+        void onDeviceAdded(LocalBluetoothDevice device);
+        void onDeviceDeleted(LocalBluetoothDevice device);
+    }
+    
+}
diff --git a/src/com/android/settings/bluetooth/LocalBluetoothProfileManager.java b/src/com/android/settings/bluetooth/LocalBluetoothProfileManager.java
new file mode 100644
index 0000000..a1a2af6
--- /dev/null
+++ b/src/com/android/settings/bluetooth/LocalBluetoothProfileManager.java
@@ -0,0 +1,280 @@
+/*
+ * 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.settings.bluetooth;
+
+import com.android.settings.R;
+
+import android.bluetooth.BluetoothA2dp;
+import android.bluetooth.BluetoothError;
+import android.bluetooth.BluetoothHeadset;
+import android.bluetooth.BluetoothClass;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Handler;
+import android.text.TextUtils;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * LocalBluetoothProfileManager is an abstract class defining the basic
+ * functionality related to a profile.
+ */
+public abstract class LocalBluetoothProfileManager {
+
+    // TODO: close profiles when we're shutting down
+    private static Map<Profile, LocalBluetoothProfileManager> sProfileMap =
+            new HashMap<Profile, LocalBluetoothProfileManager>(); 
+    
+    protected LocalBluetoothManager mLocalManager;
+    
+    public static LocalBluetoothProfileManager getProfileManager(LocalBluetoothManager localManager,
+            Profile profile) {
+        
+        LocalBluetoothProfileManager profileManager;
+        
+        synchronized (sProfileMap) {
+            profileManager = sProfileMap.get(profile);
+            
+            if (profileManager == null) {
+                switch (profile) {
+                case A2DP:
+                    profileManager = new A2dpProfileManager(localManager);
+                    break;
+                    
+                case HEADSET:
+                    profileManager = new HeadsetProfileManager(localManager);
+                    break;
+                }
+                
+                sProfileMap.put(profile, profileManager);    
+            }
+        }
+        
+        return profileManager;
+    }
+
+    /**
+     * Temporary method to fill profiles based on a device's class.
+     * 
+     * @param btClass The class
+     * @param profiles The list of profiles to fill
+     */
+    public static void fill(int btClass, List<Profile> profiles) {
+        profiles.clear();
+
+        if (BluetoothA2dp.doesClassMatchSink(btClass)) {
+            profiles.add(Profile.A2DP);
+        }
+        
+        if (BluetoothHeadset.doesClassMatch(btClass)) {
+            profiles.add(Profile.HEADSET);
+        }
+    }
+
+    protected LocalBluetoothProfileManager(LocalBluetoothManager localManager) {
+        mLocalManager = localManager;
+    }
+    
+    public abstract int connect(String address);
+    
+    public abstract int disconnect(String address);
+    
+    public abstract int getConnectionStatus(String address);
+
+    public abstract int getSummary(String address);
+
+    public abstract boolean isPreferred(String address);
+
+    public abstract void setPreferred(String address, boolean preferred);
+
+    public boolean isConnected(String address) {
+        return SettingsBtStatus.isConnectionStatusConnected(getConnectionStatus(address));
+    }
+    
+    // TODO: int instead of enum
+    public enum Profile {
+        HEADSET(R.string.bluetooth_profile_headset),
+        A2DP(R.string.bluetooth_profile_a2dp);
+        
+        public final int localizedString;
+        
+        private Profile(int localizedString) {
+            this.localizedString = localizedString;
+        }
+    }
+
+    /**
+     * A2dpProfileManager is an abstraction for the {@link BluetoothA2dp} service. 
+     */
+    private static class A2dpProfileManager extends LocalBluetoothProfileManager {
+        private BluetoothA2dp mService;
+        
+        public A2dpProfileManager(LocalBluetoothManager localManager) {
+            super(localManager);
+            mService = new BluetoothA2dp(localManager.getContext());
+        }
+
+        @Override
+        public int connect(String address) {
+            return mService.connectSink(address);
+        }
+
+        @Override
+        public int disconnect(String address) {
+            return mService.disconnectSink(address);
+        }
+        
+        @Override
+        public int getConnectionStatus(String address) {
+            return convertState(mService.getSinkState(address));
+        }
+        
+        @Override
+        public int getSummary(String address) {
+            int connectionStatus = getConnectionStatus(address);
+
+            if (SettingsBtStatus.isConnectionStatusConnected(connectionStatus)) {
+                return R.string.bluetooth_a2dp_profile_summary_connected;
+            } else {
+                return SettingsBtStatus.getConnectionStatusSummary(connectionStatus);
+            }
+        }
+
+        @Override
+        public boolean isPreferred(String address) {
+            return mService.getSinkPriority(address) > BluetoothA2dp.PRIORITY_OFF;
+        }
+
+        @Override
+        public void setPreferred(String address, boolean preferred) {
+            mService.setSinkPriority(address,
+                    preferred ? BluetoothA2dp.PRIORITY_AUTO : BluetoothA2dp.PRIORITY_OFF);
+        }
+
+        private static int convertState(int a2dpState) {
+            switch (a2dpState) {
+            case BluetoothA2dp.STATE_CONNECTED:
+                return SettingsBtStatus.CONNECTION_STATUS_CONNECTED;
+            case BluetoothA2dp.STATE_CONNECTING:
+                return SettingsBtStatus.CONNECTION_STATUS_CONNECTING;
+            case BluetoothA2dp.STATE_DISCONNECTED:
+                return SettingsBtStatus.CONNECTION_STATUS_DISCONNECTED;
+            case BluetoothA2dp.STATE_DISCONNECTING:
+                return SettingsBtStatus.CONNECTION_STATUS_DISCONNECTING;
+            case BluetoothA2dp.STATE_PLAYING:
+                return SettingsBtStatus.CONNECTION_STATUS_ACTIVE;
+            default:
+                return SettingsBtStatus.CONNECTION_STATUS_UNKNOWN;
+            }
+        }
+    }
+    
+    /**
+     * HeadsetProfileManager is an abstraction for the {@link BluetoothHeadset} service. 
+     */
+    private static class HeadsetProfileManager extends LocalBluetoothProfileManager
+            implements BluetoothHeadset.ServiceListener {
+        private BluetoothHeadset mService;
+        private Handler mUiHandler = new Handler();
+        
+        public HeadsetProfileManager(LocalBluetoothManager localManager) {
+            super(localManager);
+            mService = new BluetoothHeadset(localManager.getContext(), this);
+        }
+
+        public void onServiceConnected() {
+            // This could be called on a non-UI thread, funnel to UI thread.
+            mUiHandler.post(new Runnable() {
+                public void run() {
+                    /*
+                     * We just bound to the service, so refresh the UI of the
+                     * headset device.
+                     */
+                    String address = mService.getHeadsetAddress();
+                    if (TextUtils.isEmpty(address)) return;
+                    mLocalManager.getLocalDeviceManager().onProfileStateChanged(address);
+                }
+            });
+        }
+
+        public void onServiceDisconnected() {
+        }
+
+        @Override
+        public int connect(String address) {
+            // Since connectHeadset fails if already connected to a headset, we
+            // disconnect from any headset first
+            mService.disconnectHeadset();
+            return mService.connectHeadset(address)
+                    ? BluetoothError.SUCCESS : BluetoothError.ERROR;
+        }
+
+        @Override
+        public int disconnect(String address) {
+            if (mService.getHeadsetAddress().equals(address)) {
+                return mService.disconnectHeadset() ? BluetoothError.SUCCESS : BluetoothError.ERROR;
+            } else {
+                return BluetoothError.SUCCESS;
+            }
+        }
+        
+        @Override
+        public int getConnectionStatus(String address) {
+            String headsetAddress = mService.getHeadsetAddress();
+            return headsetAddress != null && headsetAddress.equals(address)
+                    ? convertState(mService.getState())
+                    : SettingsBtStatus.CONNECTION_STATUS_DISCONNECTED;
+        }
+        
+        @Override
+        public int getSummary(String address) {
+            int connectionStatus = getConnectionStatus(address);
+            
+            if (SettingsBtStatus.isConnectionStatusConnected(connectionStatus)) {
+                return R.string.bluetooth_headset_profile_summary_connected;
+            } else {
+                return SettingsBtStatus.getConnectionStatusSummary(connectionStatus);
+            }
+        }
+
+        @Override
+        public boolean isPreferred(String address) {
+            return mService.getPriority(address) > BluetoothHeadset.PRIORITY_OFF;
+        }
+
+        @Override
+        public void setPreferred(String address, boolean preferred) {
+            mService.setPriority(address,
+                    preferred ? BluetoothHeadset.PRIORITY_AUTO : BluetoothHeadset.PRIORITY_OFF);
+        }
+
+        private static int convertState(int headsetState) {
+            switch (headsetState) {
+            case BluetoothHeadset.STATE_CONNECTED:
+                return SettingsBtStatus.CONNECTION_STATUS_CONNECTED;
+            case BluetoothHeadset.STATE_CONNECTING:
+                return SettingsBtStatus.CONNECTION_STATUS_CONNECTING;
+            case BluetoothHeadset.STATE_DISCONNECTED:
+                return SettingsBtStatus.CONNECTION_STATUS_DISCONNECTED;
+            default:
+                return SettingsBtStatus.CONNECTION_STATUS_UNKNOWN;
+            }
+        }
+    }
+}
diff --git a/src/com/android/settings/bluetooth/SettingsBtStatus.java b/src/com/android/settings/bluetooth/SettingsBtStatus.java
new file mode 100644
index 0000000..d2cbef5
--- /dev/null
+++ b/src/com/android/settings/bluetooth/SettingsBtStatus.java
@@ -0,0 +1,81 @@
+/*
+ * 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.settings.bluetooth;
+
+import android.bluetooth.BluetoothDevice;
+
+import com.android.settings.R;
+
+/**
+ * SettingsBtStatus is a helper class that contains constants for various status
+ * codes.
+ */
+public class SettingsBtStatus {
+    private static final String TAG = "SettingsBtStatus";
+   
+    // Connection status
+    
+    public static final int CONNECTION_STATUS_UNKNOWN = 0;
+    public static final int CONNECTION_STATUS_ACTIVE = 1;
+    /** Use {@link #isConnected} to check for the connected state */
+    public static final int CONNECTION_STATUS_CONNECTED = 2;
+    public static final int CONNECTION_STATUS_CONNECTING = 3;
+    public static final int CONNECTION_STATUS_DISCONNECTED = 4;
+    public static final int CONNECTION_STATUS_DISCONNECTING = 5;
+
+    public static final int getConnectionStatusSummary(int connectionStatus) {
+        switch (connectionStatus) {
+        case CONNECTION_STATUS_ACTIVE:
+            return R.string.bluetooth_connected;
+        case CONNECTION_STATUS_CONNECTED:
+            return R.string.bluetooth_connected;
+        case CONNECTION_STATUS_CONNECTING:
+            return R.string.bluetooth_connecting;
+        case CONNECTION_STATUS_DISCONNECTED:
+            return R.string.bluetooth_disconnected;
+        case CONNECTION_STATUS_DISCONNECTING:
+            return R.string.bluetooth_disconnecting;
+        case CONNECTION_STATUS_UNKNOWN:
+            return R.string.bluetooth_unknown;
+        default:
+            return 0;
+        }
+    }
+    
+    public static final boolean isConnectionStatusConnected(int connectionStatus) {
+        return connectionStatus == CONNECTION_STATUS_ACTIVE
+                || connectionStatus == CONNECTION_STATUS_CONNECTED;
+    }
+    
+    public static final boolean isConnectionStatusBusy(int connectionStatus) {
+        return connectionStatus == CONNECTION_STATUS_CONNECTING
+                || connectionStatus == CONNECTION_STATUS_DISCONNECTING;
+    }
+    
+    public static final int getPairingStatusSummary(int bondState) {
+        switch (bondState) {
+        case BluetoothDevice.BOND_BONDED:
+            return R.string.bluetooth_paired;
+        case BluetoothDevice.BOND_BONDING:
+            return R.string.bluetooth_pairing;
+        case BluetoothDevice.BOND_NOT_BONDED:
+            return R.string.bluetooth_not_connected;
+        default:
+            return 0;
+        }
+    }
+}
diff --git a/src/com/android/settings/deviceinfo/Memory.java b/src/com/android/settings/deviceinfo/Memory.java
new file mode 100644
index 0000000..75a84b7
--- /dev/null
+++ b/src/com/android/settings/deviceinfo/Memory.java
@@ -0,0 +1,218 @@
+/*
+ * 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.settings.deviceinfo;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.os.Environment;
+import android.os.IMountService;
+import android.os.ServiceManager;
+import android.os.StatFs;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceScreen;
+import android.util.Log;
+
+import com.android.settings.R;
+
+import java.io.File;
+import java.text.DecimalFormat;
+
+public class Memory extends PreferenceActivity {
+    
+    private static final String TAG = "Memory";
+
+    private static final String MEMORY_SD_SIZE = "memory_sd_size";
+
+    private static final String MEMORY_SD_AVAIL = "memory_sd_avail";
+
+    private static final String MEMORY_SD_UNMOUNT = "memory_sd_unmount";
+
+    private static final String MEMORY_SD_FORMAT = "memory_sd_format";
+    private Resources mRes;
+
+    private Preference mSdSize;
+    private Preference mSdAvail;
+    private Preference mSdUnmount;
+    private Preference mSdFormat;
+    
+    // Access using getMountService()
+    private IMountService mMountService = null;
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        
+        addPreferencesFromResource(R.xml.device_info_memory);
+        
+        mRes = getResources();
+        mSdSize = findPreference(MEMORY_SD_SIZE);
+        mSdAvail = findPreference(MEMORY_SD_AVAIL);
+        mSdUnmount = findPreference(MEMORY_SD_UNMOUNT);
+        mSdFormat = findPreference(MEMORY_SD_FORMAT);
+    }
+    
+    @Override
+    protected void onResume() {
+        super.onResume();
+        
+        IntentFilter intentFilter = new IntentFilter(Intent.ACTION_MEDIA_REMOVED);
+        intentFilter.addAction(Intent.ACTION_MEDIA_UNMOUNTED);
+        intentFilter.addAction(Intent.ACTION_MEDIA_MOUNTED);
+        intentFilter.addAction(Intent.ACTION_MEDIA_SHARED);
+        intentFilter.addAction(Intent.ACTION_MEDIA_BAD_REMOVAL);
+        intentFilter.addAction(Intent.ACTION_MEDIA_UNMOUNTABLE);
+        intentFilter.addAction(Intent.ACTION_MEDIA_NOFS);
+        intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_STARTED);
+        intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_FINISHED);
+        intentFilter.addDataScheme("file");
+        registerReceiver(mReceiver, intentFilter);
+
+        updateMemoryStatus();
+    }
+    
+    @Override
+    protected void onPause() {
+        super.onPause();
+        unregisterReceiver(mReceiver);
+    }
+    
+    private synchronized IMountService getMountService() {
+       if (mMountService == null) {
+           IBinder service = ServiceManager.getService("mount");
+           if (service != null) {
+               mMountService = IMountService.Stub.asInterface(service);
+           } else {
+               Log.e(TAG, "Can't get mount service");
+           }
+       }
+       return mMountService;
+    }
+    
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
+        if (preference == mSdUnmount) {
+            unmount();
+            return true;
+        } else if (preference == mSdFormat) {
+            Intent intent = new Intent(Intent.ACTION_VIEW);
+            intent.setClass(this, com.android.settings.MediaFormat.class);
+            startActivity(intent);
+            return true;
+        }
+        
+        return false;
+    }
+     
+    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            updateMemoryStatus();
+        }
+    };
+
+    private void unmount() {
+        IMountService mountService = getMountService();
+        try {
+            if (mountService != null) {
+                mountService.unmountMedia(Environment.getExternalStorageDirectory().toString());
+            } else {
+                Log.e(TAG, "Mount service is null, can't unmount");
+            }
+        } catch (RemoteException ex) {
+            // Failed for some reason, try to update UI to actual state
+            updateMemoryStatus();
+        }
+    }
+
+    private void updateMemoryStatus() {
+        String status = Environment.getExternalStorageState();
+        String readOnly = "";
+        if (status.equals(Environment.MEDIA_MOUNTED_READ_ONLY)) {
+            status = Environment.MEDIA_MOUNTED;
+            readOnly = mRes.getString(R.string.read_only);
+        }
+ 
+        mSdFormat.setEnabled(false);
+
+        if (status.equals(Environment.MEDIA_MOUNTED)) {
+            try {
+                File path = Environment.getExternalStorageDirectory();
+                StatFs stat = new StatFs(path.getPath());
+                long blockSize = stat.getBlockSize();
+                long totalBlocks = stat.getBlockCount();
+                long availableBlocks = stat.getAvailableBlocks();
+                
+                mSdSize.setSummary(formatSize(totalBlocks * blockSize));
+                mSdAvail.setSummary(formatSize(availableBlocks * blockSize) + readOnly);
+                mSdUnmount.setEnabled(true);
+            } catch (IllegalArgumentException e) {
+                // this can occur if the SD card is removed, but we haven't received the 
+                // ACTION_MEDIA_REMOVED Intent yet.
+                status = Environment.MEDIA_REMOVED;
+            }
+            
+        } else {
+            mSdSize.setSummary(mRes.getString(R.string.sd_unavailable));
+            mSdAvail.setSummary(mRes.getString(R.string.sd_unavailable));
+            mSdUnmount.setEnabled(false);
+
+            if (status.equals(Environment.MEDIA_UNMOUNTED) ||
+                status.equals(Environment.MEDIA_NOFS) ||
+                status.equals(Environment.MEDIA_UNMOUNTABLE) ) {
+                mSdFormat.setEnabled(true);
+            }
+
+            
+        }
+
+        File path = Environment.getDataDirectory();
+        StatFs stat = new StatFs(path.getPath());
+        long blockSize = stat.getBlockSize();
+        long availableBlocks = stat.getAvailableBlocks();
+        findPreference("memory_internal_avail").setSummary(formatSize(availableBlocks * blockSize));
+    }
+    
+    private String formatSize(long size) {
+        String suffix = null;
+        
+        // add KB or MB suffix if size is greater than 1K or 1M
+        if (size >= 1024) {
+            suffix = " KB";
+            size /= 1024;
+            if (size >= 1024) {
+                suffix = " MB";
+                size /= 1024;
+            }
+        }
+        
+        DecimalFormat formatter = new DecimalFormat();
+        formatter.setGroupingSize(3);
+        String result = formatter.format(size);
+                
+        if (suffix != null)
+            result = result + suffix;
+        return result;
+    }
+    
+}
diff --git a/src/com/android/settings/deviceinfo/Status.java b/src/com/android/settings/deviceinfo/Status.java
new file mode 100644
index 0000000..4132ed5
--- /dev/null
+++ b/src/com/android/settings/deviceinfo/Status.java
@@ -0,0 +1,392 @@
+/*
+ * 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.settings.deviceinfo;
+
+import android.bluetooth.BluetoothDevice;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.res.Resources;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.os.BatteryManager;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.os.SystemClock;
+import android.os.SystemProperties;
+import android.os.NetStat;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.telephony.PhoneStateListener;
+import android.telephony.ServiceState;
+import android.telephony.TelephonyManager;
+import android.text.TextUtils;
+
+import com.android.internal.telephony.Phone;
+import com.android.internal.telephony.PhoneFactory;
+import com.android.internal.telephony.PhoneStateIntentReceiver;
+import com.android.internal.telephony.TelephonyProperties;
+import com.android.settings.R;
+
+import java.lang.ref.WeakReference;
+
+/**
+ * Display the following information
+ * # Phone Number
+ * # Network
+ * # Roaming
+ * # IMEI
+ * # Network type
+ * # Signal Strength
+ * # Battery Strength  : TODO
+ * # Uptime
+ * # Awake Time
+ * # XMPP/buzz/tickle status : TODO
+ *
+ */
+public class Status extends PreferenceActivity {
+
+    private static final String KEY_WIFI_MAC_ADDRESS = "wifi_mac_address";
+    private static final String KEY_BT_ADDRESS = "bt_address";
+    private static final String KEY_NETWORK_TRAFFIC_STATS = "network_traffic_stats";
+    private static final int EVENT_SIGNAL_STRENGTH_CHANGED = 200;
+    private static final int EVENT_SERVICE_STATE_CHANGED = 300;
+
+    private static final int EVENT_UPDATE_STATS = 500;
+
+    private TelephonyManager mTelephonyManager;
+    private Phone mPhone = null;
+    private PhoneStateIntentReceiver mPhoneStateReceiver;
+    private Resources mRes;
+    private Preference mSignalStrength;
+    private Preference mUptime;
+    private Preference mAwakeTime;
+
+    private static String sUnknown;
+    
+    private Preference mBatteryStatus;
+    private Preference mBatteryLevel;
+
+    private Handler mHandler;
+
+    private static class MyHandler extends Handler {
+        private WeakReference<Status> mStatus;
+
+        public MyHandler(Status activity) {
+            mStatus = new WeakReference<Status>(activity);
+        }
+
+        @Override
+        public void handleMessage(Message msg) {
+            Status status = mStatus.get();
+            if (status == null) {
+                return;
+            }
+
+            switch (msg.what) {
+                case EVENT_SIGNAL_STRENGTH_CHANGED:
+                    status.updateSignalStrength();
+                    break;
+
+                case EVENT_SERVICE_STATE_CHANGED:
+                    ServiceState serviceState = status.mPhoneStateReceiver.getServiceState();
+                    status.updateServiceState(serviceState);
+                    break;
+
+                case EVENT_UPDATE_STATS:
+                    status.updateTimes();
+                    status.setNetworkTrafficStats();
+                    sendEmptyMessageDelayed(EVENT_UPDATE_STATS, 1000);
+                    break;
+            }
+        }
+    }
+
+    private BroadcastReceiver mBatteryInfoReceiver = new BroadcastReceiver() {
+        
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            if (Intent.ACTION_BATTERY_CHANGED.equals(action)) {
+
+                int level = intent.getIntExtra("level", 0);
+                int scale = intent.getIntExtra("scale", 100);
+                
+                mBatteryLevel.setSummary(String.valueOf(level * 100 / scale) + "%");
+                
+                int plugType = intent.getIntExtra("plugged", 0);
+                int status = intent.getIntExtra("status", BatteryManager.BATTERY_STATUS_UNKNOWN);
+                String statusString;
+                if (status == BatteryManager.BATTERY_STATUS_CHARGING) {
+                    statusString = getString(R.string.battery_info_status_charging);
+                    if (plugType > 0) {
+                        statusString = statusString + " " + getString(
+                                (plugType == BatteryManager.BATTERY_PLUGGED_AC)
+                                        ? R.string.battery_info_status_charging_ac
+                                        : R.string.battery_info_status_charging_usb);
+                    }
+                } else if (status == BatteryManager.BATTERY_STATUS_DISCHARGING) {
+                    statusString = getString(R.string.battery_info_status_discharging);
+                } else if (status == BatteryManager.BATTERY_STATUS_NOT_CHARGING) {
+                    statusString = getString(R.string.battery_info_status_not_charging);
+                } else if (status == BatteryManager.BATTERY_STATUS_FULL) {
+                    statusString = getString(R.string.battery_info_status_full);
+                } else {
+                    statusString = getString(R.string.battery_info_status_unknown);
+                }
+                mBatteryStatus.setSummary(statusString);
+            }
+        }
+    };
+
+    private PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
+        @Override
+        public void onDataConnectionStateChanged(int state) {
+            updateDataState();
+            updateNetworkType();
+        }
+    };
+    
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        mHandler = new MyHandler(this);
+        
+        mTelephonyManager = (TelephonyManager)getSystemService(TELEPHONY_SERVICE);
+
+        addPreferencesFromResource(R.xml.device_info_status);
+        mBatteryLevel = findPreference("battery_level");
+        mBatteryStatus = findPreference("battery_status");
+        
+        mRes = getResources();
+        if (sUnknown == null) {
+            sUnknown = mRes.getString(R.string.device_info_default);
+        }
+        
+        mPhone = PhoneFactory.getDefaultPhone();
+        mSignalStrength = findPreference("signal_strength");
+        mUptime = findPreference("up_time");
+        mAwakeTime = findPreference("awake_time");
+        
+        setSummaryText("imei", mPhone.getDeviceId());
+        setSummaryText("imei_sv",
+                ((TelephonyManager) getSystemService(TELEPHONY_SERVICE))
+                        .getDeviceSoftwareVersion());
+        setSummaryText("number", mPhone.getLine1Number());
+
+        mPhoneStateReceiver = new PhoneStateIntentReceiver(this, mHandler);
+        mPhoneStateReceiver.notifySignalStrength(EVENT_SIGNAL_STRENGTH_CHANGED);
+        mPhoneStateReceiver.notifyServiceState(EVENT_SERVICE_STATE_CHANGED);
+        
+        setWifiStatus();
+        setBtStatus();
+    }
+    
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        mPhoneStateReceiver.registerIntent();
+        registerReceiver(mBatteryInfoReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
+        
+        updateSignalStrength();
+        updateServiceState(mPhone.getServiceState());
+        updateDataState();
+        
+        mTelephonyManager.listen(mPhoneStateListener,
+                  PhoneStateListener.LISTEN_DATA_CONNECTION_STATE);
+
+        mHandler.sendEmptyMessage(EVENT_UPDATE_STATS);
+    }
+    
+    @Override
+    public void onPause() {
+        super.onPause();
+
+        mPhoneStateReceiver.unregisterIntent();
+        mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
+        unregisterReceiver(mBatteryInfoReceiver);
+        mHandler.removeMessages(EVENT_UPDATE_STATS);
+    }
+
+    /**
+     * @param preference The key for the Preference item
+     * @param property The system property to fetch
+     * @param alt The default value, if the property doesn't exist
+     */
+    private void setSummary(String preference, String property, String alt) {
+        try {
+            findPreference(preference).setSummary(
+                    SystemProperties.get(property, alt));
+        } catch (RuntimeException e) {
+            
+        }
+    }
+
+    private void setSummaryText(String preference, String text) {
+        if (TextUtils.isEmpty(text)) {
+            text = sUnknown;
+        }
+        
+        findPreference(preference).setSummary(text);
+    }
+    
+    private void updateNetworkType() {
+        // Whether EDGE, UMTS, etc...
+        setSummary("network_type", TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE, sUnknown);
+    }
+    
+    private void updateDataState() {
+        int state = mTelephonyManager.getDataState();
+        String display = mRes.getString(R.string.radioInfo_unknown);
+
+        switch (state) {
+            case TelephonyManager.DATA_CONNECTED:
+                display = mRes.getString(R.string.radioInfo_data_connected);
+                break;
+            case TelephonyManager.DATA_SUSPENDED:
+                display = mRes.getString(R.string.radioInfo_data_suspended);
+                break;
+            case TelephonyManager.DATA_CONNECTING:
+                display = mRes.getString(R.string.radioInfo_data_connecting);
+                break;
+            case TelephonyManager.DATA_DISCONNECTED:
+                display = mRes.getString(R.string.radioInfo_data_disconnected);
+                break;
+        }
+        
+        setSummaryText("data_state", display);
+    }
+
+    private void updateServiceState(ServiceState serviceState) {
+        int state = serviceState.getState();
+        String display = mRes.getString(R.string.radioInfo_unknown);
+        
+        switch (state) {
+            case ServiceState.STATE_IN_SERVICE:
+                display = mRes.getString(R.string.radioInfo_service_in);
+                break;
+            case ServiceState.STATE_OUT_OF_SERVICE:
+            case ServiceState.STATE_EMERGENCY_ONLY:
+                display = mRes.getString(R.string.radioInfo_service_out);
+                break;
+            case ServiceState.STATE_POWER_OFF:
+                display = mRes.getString(R.string.radioInfo_service_off);
+                break;
+        }
+        
+        setSummaryText("service_state", display);
+        
+        if (serviceState.getRoaming()) {
+            setSummaryText("roaming_state", mRes.getString(R.string.radioInfo_roaming_in));
+        } else {
+            setSummaryText("roaming_state", mRes.getString(R.string.radioInfo_roaming_not));
+        }
+        setSummaryText("operator_name", serviceState.getOperatorAlphaLong());
+    }
+    
+    void updateSignalStrength() {
+        int state =
+                mPhoneStateReceiver.getServiceState().getState();
+        Resources r = getResources();
+
+        if ((ServiceState.STATE_OUT_OF_SERVICE == state) ||
+                (ServiceState.STATE_POWER_OFF == state)) {
+            mSignalStrength.setSummary("0");
+        }
+        
+        int signalDbm = mPhoneStateReceiver.getSignalStrengthDbm();
+        
+        if (-1 == signalDbm) signalDbm = 0;
+
+        int signalAsu = mPhoneStateReceiver.getSignalStrength();
+
+        if (-1 == signalAsu) signalAsu = 0;
+
+        mSignalStrength.setSummary(String.valueOf(signalDbm) + " "
+                    + r.getString(R.string.radioInfo_display_dbm) + "   "
+                    + String.valueOf(signalAsu) + " "
+                    + r.getString(R.string.radioInfo_display_asu));
+    }
+    
+    private void setWifiStatus() {
+        WifiManager wifiManager = (WifiManager) getSystemService(WIFI_SERVICE);
+        WifiInfo wifiInfo = wifiManager.getConnectionInfo();
+
+        Preference wifiMacAddressPref = findPreference(KEY_WIFI_MAC_ADDRESS);
+        String macAddress = wifiInfo == null ? null : wifiInfo.getMacAddress();
+        wifiMacAddressPref.setSummary(!TextUtils.isEmpty(macAddress) ? macAddress 
+                : getString(R.string.status_unavailable));
+    }
+
+    private void setBtStatus() {
+        BluetoothDevice bluetooth = (BluetoothDevice) getSystemService(BLUETOOTH_SERVICE);
+        Preference btAddressPref = findPreference(KEY_BT_ADDRESS);
+
+        if (bluetooth == null) {
+            // device not BT capable
+            getPreferenceScreen().removePreference(btAddressPref);
+        } else {
+            String address = bluetooth.isEnabled() ? bluetooth.getAddress() : null;
+            btAddressPref.setSummary(!TextUtils.isEmpty(address) ? address
+                    : getString(R.string.status_unavailable));
+        }
+    }
+
+    private void setNetworkTrafficStats() {
+        long txPkts = NetStat.getTotalTxPkts();
+        long txBytes = NetStat.getTotalTxBytes();
+        long rxPkts = NetStat.getTotalRxPkts();
+        long rxBytes = NetStat.getTotalRxBytes();
+
+        Preference netStatsPref = findPreference(KEY_NETWORK_TRAFFIC_STATS);
+        netStatsPref.setSummary(getString(R.string.status_network_traffic_summary,
+                txPkts, txBytes, rxPkts, rxBytes));
+    }
+
+    void updateTimes() {
+        long at = SystemClock.uptimeMillis() / 1000;
+        long ut = SystemClock.elapsedRealtime() / 1000;
+        long st = ut - at;
+
+        if (ut == 0) {
+            ut = 1;
+        }
+
+        mUptime.setSummary(convert(ut));
+        mAwakeTime.setSummary(convert(at) + " (" + (((1000 * at / ut) + 5) / 10) + "%)");
+    }
+    
+    private String pad(int n) {
+        if (n >= 10) {
+            return String.valueOf(n);
+        } else {
+            return "0" + String.valueOf(n);
+        }
+    }
+
+    private String convert(long t) {
+        int s = (int)(t % 60);
+        int m = (int)((t / 60) % 60);
+        int h = (int)((t / 3600));
+
+        return h + ":" + pad(m) + ":" + pad(s);
+    }
+}
diff --git a/src/com/android/settings/quicklaunch/BookmarkPicker.java b/src/com/android/settings/quicklaunch/BookmarkPicker.java
new file mode 100644
index 0000000..7152abb
--- /dev/null
+++ b/src/com/android/settings/quicklaunch/BookmarkPicker.java
@@ -0,0 +1,331 @@
+/*
+ * Copyright (C) 2007 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.settings.quicklaunch;
+
+import com.android.settings.R;
+
+import android.app.ListActivity;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.os.Handler;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.ListView;
+import android.widget.SimpleAdapter;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * Activity to pick a bookmark that will be returned to the caller.
+ * <p>
+ * Currently, bookmarks are either:
+ * <li> Activities that are in the launcher
+ * <li> Activities that are within an app that is capable of being launched with
+ * the {@link Intent#ACTION_CREATE_SHORTCUT}.
+ */
+public class BookmarkPicker extends ListActivity implements SimpleAdapter.ViewBinder {
+
+    private static final String TAG = "BookmarkPicker";
+
+    /** Extra in the returned intent from this activity. */
+    public static final String EXTRA_TITLE = "com.android.settings.quicklaunch.TITLE";
+    
+    /** Extra that should be provided, and will be returned. */
+    public static final String EXTRA_SHORTCUT = "com.android.settings.quicklaunch.SHORTCUT";
+
+    /**
+     * The request code for the screen to create a bookmark that is WITHIN an
+     * application. For example, Gmail can return a bookmark for the inbox
+     * folder.
+     */
+    private static final int REQUEST_CREATE_SHORTCUT = 1;
+
+    /** Intent used to get all the activities that are launch-able */
+    private static Intent sLaunchIntent;
+    /** Intent used to get all the activities that are {@link #REQUEST_CREATE_SHORTCUT}-able */
+    private static Intent sShortcutIntent;
+    
+    /**
+     * List of ResolveInfo for activities that we can bookmark (either directly
+     * to the activity, or by launching the activity and it returning a bookmark
+     * WITHIN that application).
+     */
+    private List<ResolveInfo> mResolveList;
+    
+    // List adapter stuff
+    private static final String KEY_TITLE = "TITLE";
+    private static final String KEY_RESOLVE_INFO = "RESOLVE_INFO";
+    private static final String sKeys[] = new String[] { KEY_TITLE, KEY_RESOLVE_INFO };
+    private static final int sResourceIds[] = new int[] { R.id.title, R.id.icon };
+    private SimpleAdapter mMyAdapter;
+
+    /** Display those activities that are launch-able */
+    private static final int DISPLAY_MODE_LAUNCH = 0;
+    /** Display those activities that are able to have bookmarks WITHIN the application */
+    private static final int DISPLAY_MODE_SHORTCUT = 1;
+    private int mDisplayMode = DISPLAY_MODE_LAUNCH;
+    
+    private Handler mUiHandler = new Handler();
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        updateListAndAdapter();
+    }
+    
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        menu.add(0, DISPLAY_MODE_LAUNCH, 0, R.string.quick_launch_display_mode_applications)
+                .setIcon(com.android.internal.R.drawable.ic_menu_archive);
+        menu.add(0, DISPLAY_MODE_SHORTCUT, 0, R.string.quick_launch_display_mode_shortcuts)
+                .setIcon(com.android.internal.R.drawable.ic_menu_goto);
+        return true;
+    }
+    
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        menu.findItem(DISPLAY_MODE_LAUNCH).setVisible(mDisplayMode != DISPLAY_MODE_LAUNCH);
+        menu.findItem(DISPLAY_MODE_SHORTCUT).setVisible(mDisplayMode != DISPLAY_MODE_SHORTCUT);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        
+        switch (item.getItemId()) {
+
+            case DISPLAY_MODE_LAUNCH: 
+                mDisplayMode = DISPLAY_MODE_LAUNCH;
+                break;
+            
+            case DISPLAY_MODE_SHORTCUT:
+                mDisplayMode = DISPLAY_MODE_SHORTCUT;
+                break;
+            
+            default:
+                return false;
+        }
+        
+        updateListAndAdapter();
+        return true;
+    }
+
+    private void ensureIntents() {
+        if (sLaunchIntent == null) {
+            sLaunchIntent = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_LAUNCHER);
+            sShortcutIntent = new Intent(Intent.ACTION_CREATE_SHORTCUT);
+        }
+    }
+
+    /**
+     * This should be called from the UI thread.
+     */
+    private void updateListAndAdapter() {
+        // Get the activities in a separate thread
+        new Thread("data updater") {
+            @Override
+            public void run() {
+                synchronized (BookmarkPicker.this) {
+                    /*
+                     * Don't touch any of the lists that are being used by the
+                     * adapter in this thread!
+                     */
+                    ArrayList<ResolveInfo> newResolveList = new ArrayList<ResolveInfo>();
+                    ArrayList<Map<String, ?>> newAdapterList = new ArrayList<Map<String, ?>>();
+
+                    fillResolveList(newResolveList);
+                    Collections.sort(newResolveList,
+                            new ResolveInfo.DisplayNameComparator(getPackageManager()));
+                    
+                    fillAdapterList(newAdapterList, newResolveList);
+                    
+                    updateAdapterToUseNewLists(newAdapterList, newResolveList);
+                }
+            }
+        }.start();  
+    }
+    
+    private void updateAdapterToUseNewLists(final ArrayList<Map<String, ?>> newAdapterList,
+            final ArrayList<ResolveInfo> newResolveList) {
+        // Post this back on the UI thread
+        mUiHandler.post(new Runnable() {
+            public void run() {
+                /*
+                 * SimpleAdapter does not support changing the lists after it
+                 * has been created. We just create a new instance.
+                 */
+                mMyAdapter = createResolveAdapter(newAdapterList);
+                mResolveList = newResolveList;
+                setListAdapter(mMyAdapter);
+            }
+        });
+    }
+    
+    /**
+     * Gets all activities matching our current display mode.
+     * 
+     * @param list The list to fill.
+     */
+    private void fillResolveList(List<ResolveInfo> list) {
+        ensureIntents();
+        PackageManager pm = getPackageManager();
+        list.clear();
+        
+        if (mDisplayMode == DISPLAY_MODE_LAUNCH) {
+            list.addAll(pm.queryIntentActivities(sLaunchIntent, 0));
+        } else if (mDisplayMode == DISPLAY_MODE_SHORTCUT) {
+            list.addAll(pm.queryIntentActivities(sShortcutIntent, 0)); 
+        }
+    }
+    
+    private SimpleAdapter createResolveAdapter(List<Map<String, ?>> list) {
+        SimpleAdapter adapter = new SimpleAdapter(this, list,
+                R.layout.bookmark_picker_item, sKeys, sResourceIds);
+        adapter.setViewBinder(this);
+        return adapter;
+    }
+
+    private void fillAdapterList(List<Map<String, ?>> list,
+            List<ResolveInfo> resolveList) {
+        list.clear();
+        int resolveListSize = resolveList.size();
+        for (int i = 0; i < resolveListSize; i++) {
+            ResolveInfo info = resolveList.get(i);
+            /*
+             * Simple adapter craziness. For each item, we need to create a map
+             * from a key to its value (the value can be any object--the view
+             * binder will take care of filling the View with a representation
+             * of that object).
+             */
+            Map<String, Object> map = new TreeMap<String, Object>();
+            map.put(KEY_TITLE, getResolveInfoTitle(info));
+            map.put(KEY_RESOLVE_INFO, info);
+            list.add(map);
+        }
+    }
+
+    /** Get the title for a resolve info. */
+    private String getResolveInfoTitle(ResolveInfo info) {
+        CharSequence label = info.loadLabel(getPackageManager());
+        if (label == null) label = info.activityInfo.name;
+        return label != null ? label.toString() : null;
+    }
+
+    @Override
+    protected void onListItemClick(ListView l, View v, int position, long id) {
+        if (position >= mResolveList.size()) return;
+
+        ResolveInfo info = mResolveList.get(position);
+        
+        switch (mDisplayMode) {
+
+            case DISPLAY_MODE_LAUNCH: 
+                // We can go ahead and return the clicked info's intent
+                Intent intent = getIntentForResolveInfo(info, Intent.ACTION_MAIN);
+                intent.addCategory(Intent.CATEGORY_LAUNCHER);
+                finish(intent, getResolveInfoTitle(info));
+                break;
+
+            case DISPLAY_MODE_SHORTCUT:
+                // Start the shortcut activity so the user can pick the actual intent
+                // (example: Gmail's shortcut activity shows a list of mailboxes)
+                startShortcutActivity(info);
+                break;
+        }
+        
+    }
+    
+    private static Intent getIntentForResolveInfo(ResolveInfo info, String action) {
+        Intent intent = new Intent(action);
+        ActivityInfo ai = info.activityInfo;
+        intent.setClassName(ai.packageName, ai.name);
+        return intent;
+    }
+
+    /**
+     * Starts an activity to get a shortcut.
+     * <p>
+     * For example, Gmail has an activity that lists the available labels. It
+     * returns a shortcut intent for going directly to this label.
+     */
+    private void startShortcutActivity(ResolveInfo info) {
+        Intent intent = getIntentForResolveInfo(info, Intent.ACTION_CREATE_SHORTCUT);
+        startActivityForResult(intent, REQUEST_CREATE_SHORTCUT);
+        
+        // Will get a callback to onActivityResult
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (resultCode != RESULT_OK) {
+            return;
+        }
+        
+        switch (requestCode) {
+            
+            case REQUEST_CREATE_SHORTCUT:
+                if (data != null) {
+                    finish((Intent) data.getParcelableExtra(Intent.EXTRA_SHORTCUT_INTENT),
+                            data.getStringExtra(Intent.EXTRA_SHORTCUT_NAME));
+                }
+                break;
+                
+            default:
+                super.onActivityResult(requestCode, resultCode, data);
+                break;
+        }
+    }
+    
+    /**
+     * Finishes the activity and returns the given data.
+     */
+    private void finish(Intent intent, String title) {
+        // Give back what was given to us (it will have the shortcut, for example)
+        intent.putExtras(getIntent());
+        // Put our information
+        intent.putExtra(EXTRA_TITLE, title);
+        setResult(RESULT_OK, intent);
+        finish();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public boolean setViewValue(View view, Object data, String textRepresentation) {
+        if (view.getId() == R.id.icon) {
+            Drawable icon = ((ResolveInfo) data).loadIcon(getPackageManager());
+            if (icon != null) {
+                ((ImageView) view).setImageDrawable(icon);
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
+    
+}
diff --git a/src/com/android/settings/quicklaunch/QuickLaunchSettings.java b/src/com/android/settings/quicklaunch/QuickLaunchSettings.java
new file mode 100644
index 0000000..4d44524
--- /dev/null
+++ b/src/com/android/settings/quicklaunch/QuickLaunchSettings.java
@@ -0,0 +1,347 @@
+/*
+ * 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.settings.quicklaunch;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.database.ContentObserver;
+import android.database.Cursor;
+import android.os.Bundle;
+import android.os.Handler;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceGroup;
+import android.preference.PreferenceScreen;
+import android.provider.Settings.Bookmarks;
+import android.util.Log;
+import android.util.SparseArray;
+import android.util.SparseBooleanArray;
+import android.view.KeyCharacterMap;
+import android.view.KeyEvent;
+import android.view.View;
+import android.widget.AdapterView;
+
+import com.android.settings.R;
+
+/**
+ * Settings activity for quick launch.
+ * <p>
+ * Shows a list of possible shortcuts, the current application each is bound to,
+ * and allows choosing a new bookmark for a shortcut.
+ */
+public class QuickLaunchSettings extends PreferenceActivity implements
+        AdapterView.OnItemLongClickListener, DialogInterface.OnClickListener {
+
+    private static final String TAG = "QuickLaunchSettings";
+
+    private static final String KEY_SHORTCUT_CATEGORY = "shortcut_category";
+
+    private static final int DIALOG_CLEAR_SHORTCUT = 0;
+
+    private static final int REQUEST_PICK_BOOKMARK = 1;
+
+    private static final int COLUMN_SHORTCUT = 0;
+    private static final int COLUMN_TITLE = 1;
+    private static final int COLUMN_INTENT = 2;
+    private static final String[] sProjection = new String[] {
+            Bookmarks.SHORTCUT, Bookmarks.TITLE, Bookmarks.INTENT
+    };
+    private static final String sShortcutSelection = Bookmarks.SHORTCUT + "=?";
+    
+    private Handler mUiHandler = new Handler();
+    
+    private static final String DEFAULT_BOOKMARK_FOLDER = "@quicklaunch";
+    /** Cursor for Bookmarks provider. */
+    private Cursor mBookmarksCursor;
+    /** Listens for changes to Bookmarks provider. */
+    private BookmarksObserver mBookmarksObserver;
+    /** Used to keep track of which shortcuts have bookmarks. */
+    private SparseBooleanArray mBookmarkedShortcuts;
+    
+    /** Preference category to hold the shortcut preferences. */
+    private PreferenceGroup mShortcutGroup;
+    /** Mapping of a shortcut to its preference. */
+    private SparseArray<ShortcutPreference> mShortcutToPreference;
+
+    /** The bookmark title of the shortcut that is being cleared. */
+    private CharSequence mClearDialogBookmarkTitle;
+    private static final String CLEAR_DIALOG_BOOKMARK_TITLE = "CLEAR_DIALOG_BOOKMARK_TITLE";
+    /** The shortcut that is being cleared. */
+    private char mClearDialogShortcut;
+    private static final String CLEAR_DIALOG_SHORTCUT = "CLEAR_DIALOG_SHORTCUT";
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        
+        addPreferencesFromResource(R.xml.quick_launch_settings);
+        
+        mShortcutGroup = (PreferenceGroup) findPreference(KEY_SHORTCUT_CATEGORY);
+        mShortcutToPreference = new SparseArray<ShortcutPreference>();
+        mBookmarksObserver = new BookmarksObserver(mUiHandler);
+        initShortcutPreferences();
+        mBookmarksCursor = managedQuery(Bookmarks.CONTENT_URI, sProjection, null, null);
+        getListView().setOnItemLongClickListener(this);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        getContentResolver().registerContentObserver(Bookmarks.CONTENT_URI, true,
+                mBookmarksObserver);
+        refreshShortcuts();
+    }
+    
+    @Override
+    protected void onPause() {
+        super.onPause();
+        getContentResolver().unregisterContentObserver(mBookmarksObserver);
+    }
+
+    @Override
+    protected void onRestoreInstanceState(Bundle state) {
+        super.onRestoreInstanceState(state);
+        
+        // Restore the clear dialog's info
+        mClearDialogBookmarkTitle = state.getString(CLEAR_DIALOG_BOOKMARK_TITLE);
+        mClearDialogShortcut = (char) state.getInt(CLEAR_DIALOG_SHORTCUT, 0);
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        
+        // Save the clear dialog's info
+        outState.putCharSequence(CLEAR_DIALOG_BOOKMARK_TITLE, mClearDialogBookmarkTitle);
+        outState.putInt(CLEAR_DIALOG_SHORTCUT, mClearDialogShortcut);
+    }
+
+    @Override
+    protected Dialog onCreateDialog(int id) {
+        switch (id) {
+            
+            case DIALOG_CLEAR_SHORTCUT: {
+                // Create the dialog for clearing a shortcut
+                return new AlertDialog.Builder(this)
+                        .setTitle(getString(R.string.quick_launch_clear_dialog_title))
+                        .setIcon(android.R.drawable.ic_dialog_alert)
+                        .setMessage(getString(R.string.quick_launch_clear_dialog_message,
+                                mClearDialogShortcut, mClearDialogBookmarkTitle))
+                        .setPositiveButton(R.string.quick_launch_clear_ok_button, this)
+                        .setNegativeButton(R.string.quick_launch_clear_cancel_button, this)
+                        .create();
+            }
+        }
+        
+        return super.onCreateDialog(id);
+    }
+    
+    @Override
+    protected void onPrepareDialog(int id, Dialog dialog) {
+        switch (id) {
+            
+            case DIALOG_CLEAR_SHORTCUT: {
+                AlertDialog alertDialog = (AlertDialog) dialog;
+                alertDialog.setMessage(getString(R.string.quick_launch_clear_dialog_message,
+                        mClearDialogShortcut, mClearDialogBookmarkTitle));
+            }
+        }
+    }
+
+    private void showClearDialog(ShortcutPreference pref) {
+
+        if (!pref.hasBookmark()) return;
+        
+        mClearDialogBookmarkTitle = pref.getTitle();
+        mClearDialogShortcut = pref.getShortcut();
+        showDialog(DIALOG_CLEAR_SHORTCUT);
+    }
+    
+    public void onClick(DialogInterface dialog, int which) {
+        if (mClearDialogShortcut > 0 && which == AlertDialog.BUTTON1) {
+            // Clear the shortcut
+            clearShortcut(mClearDialogShortcut);
+        }
+        mClearDialogBookmarkTitle = null;
+        mClearDialogShortcut = 0;
+    }
+
+    private void clearShortcut(char shortcut) {
+        getContentResolver().delete(Bookmarks.CONTENT_URI, sShortcutSelection,
+                new String[] { String.valueOf((int) shortcut) });
+    }
+    
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
+        if (!(preference instanceof ShortcutPreference)) return false;
+
+        // Open the screen to pick a bookmark for this shortcut
+        ShortcutPreference pref = (ShortcutPreference) preference;
+        Intent intent = new Intent(this, BookmarkPicker.class);
+        intent.putExtra(BookmarkPicker.EXTRA_SHORTCUT, pref.getShortcut());
+        startActivityForResult(intent, REQUEST_PICK_BOOKMARK);
+        
+        return true;
+    }
+
+    public boolean onItemLongClick(AdapterView parent, View view, int position, long id) {
+        
+        // Open the clear shortcut dialog
+        Preference pref = (Preference) getPreferenceScreen().getRootAdapter().getItem(position);
+        if (!(pref instanceof ShortcutPreference)) return false;
+        showClearDialog((ShortcutPreference) pref);
+        return true;
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (resultCode != RESULT_OK) {
+            return;
+        }
+
+        if (requestCode == REQUEST_PICK_BOOKMARK) {
+            
+            // Returned from the 'pick bookmark for this shortcut' screen
+            if (data == null) {
+                Log.w(TAG, "Result from bookmark picker does not have an intent.");
+                return;
+            }
+            
+            String title = data.getStringExtra(BookmarkPicker.EXTRA_TITLE);
+            char shortcut = data.getCharExtra(BookmarkPicker.EXTRA_SHORTCUT, (char) 0);
+            updateShortcut(shortcut, data);
+            
+        } else {
+            super.onActivityResult(requestCode, resultCode, data);
+        }
+    }
+
+    private void updateShortcut(char shortcut, Intent intent) {
+        // Update the bookmark for a shortcut
+        // Pass an empty title so it gets resolved each time this bookmark is
+        // displayed (since the locale could change after we insert into the provider).
+        Bookmarks.add(getContentResolver(), intent, "", DEFAULT_BOOKMARK_FOLDER, shortcut, 0);
+    }
+    
+    private ShortcutPreference getOrCreatePreference(char shortcut) {
+        ShortcutPreference pref = mShortcutToPreference.get(shortcut);
+        if (pref != null) {
+            return pref;
+        } else {
+            Log.w(TAG, "Unknown shortcut '" + shortcut + "', creating preference anyway");
+            return createPreference(shortcut);
+        }
+    }
+    
+    private ShortcutPreference createPreference(char shortcut) {
+        ShortcutPreference pref = new ShortcutPreference(QuickLaunchSettings.this, shortcut);
+        mShortcutGroup.addPreference(pref);
+        mShortcutToPreference.put(shortcut, pref);
+        return pref;
+    }
+
+    private void initShortcutPreferences() {
+        
+        /** Whether the shortcut has been seen already.  The array index is the shortcut. */
+        SparseBooleanArray shortcutSeen = new SparseBooleanArray();
+        KeyCharacterMap keyMap = KeyCharacterMap.load(KeyCharacterMap.BUILT_IN_KEYBOARD);
+
+        // Go through all the key codes and create a preference for the appropriate keys
+        for (int keyCode = KeyEvent.getMaxKeyCode() - 1; keyCode >= 0; keyCode--) {
+            // Get the label for the primary char on the key that produces this key code
+            char shortcut = (char) Character.toLowerCase(keyMap.getDisplayLabel(keyCode));
+            if (shortcut == 0 || shortcutSeen.get(shortcut, false)) continue;
+            // TODO: need a to tell if the current keyboard can produce this key code, for now
+            // only allow the letter or digits
+            if (!Character.isLetterOrDigit(shortcut)) continue;
+            shortcutSeen.put(shortcut, true);
+            
+            createPreference(shortcut);
+        }
+    }
+    
+    private synchronized void refreshShortcuts() {
+        Cursor c = mBookmarksCursor;
+        if (c == null) {
+            // Haven't finished querying yet
+            return;
+        }
+        
+        if (!c.requery()) {
+            Log.e(TAG, "Could not requery cursor when refreshing shortcuts.");
+            return;
+        }
+        
+        /**
+         * We use the previous bookmarked shortcuts array to filter out those
+         * shortcuts that had bookmarks before this method call, and don't after
+         * (so we can set the preferences to be without bookmarks).
+         */
+        SparseBooleanArray noLongerBookmarkedShortcuts = mBookmarkedShortcuts;
+        SparseBooleanArray newBookmarkedShortcuts = new SparseBooleanArray(); 
+        while (c.moveToNext()) {
+            char shortcut = Character.toLowerCase((char) c.getInt(COLUMN_SHORTCUT));
+            if (shortcut == 0) continue;
+            
+            ShortcutPreference pref = getOrCreatePreference(shortcut);
+            pref.setTitle(Bookmarks.getTitle(this, c));
+            pref.setSummary(getString(R.string.quick_launch_shortcut,
+                    String.valueOf(shortcut)));
+            pref.setHasBookmark(true);
+            
+            newBookmarkedShortcuts.put(shortcut, true);
+            if (noLongerBookmarkedShortcuts != null) {
+                // After this loop, the shortcuts with value true in this array
+                // will no longer have bookmarks
+                noLongerBookmarkedShortcuts.put(shortcut, false);
+            }
+        }
+        
+        if (noLongerBookmarkedShortcuts != null) {
+            for (int i = noLongerBookmarkedShortcuts.size() - 1; i >= 0; i--) {
+                if (noLongerBookmarkedShortcuts.valueAt(i)) {
+                    // True, so there is no longer a bookmark for this shortcut
+                    char shortcut = (char) noLongerBookmarkedShortcuts.keyAt(i);
+                    ShortcutPreference pref = mShortcutToPreference.get(shortcut);
+                    if (pref != null) {
+                        pref.setHasBookmark(false);
+                    }
+                }
+            }
+        }
+        
+        mBookmarkedShortcuts = newBookmarkedShortcuts;
+        
+        c.deactivate();
+    }
+
+    private class BookmarksObserver extends ContentObserver {
+
+        public BookmarksObserver(Handler handler) {
+            super(handler);
+        }
+
+        @Override
+        public void onChange(boolean selfChange) {
+            super.onChange(selfChange);
+            
+            refreshShortcuts();
+        }
+    }
+}
diff --git a/src/com/android/settings/quicklaunch/ShortcutPreference.java b/src/com/android/settings/quicklaunch/ShortcutPreference.java
new file mode 100644
index 0000000..92efdeb
--- /dev/null
+++ b/src/com/android/settings/quicklaunch/ShortcutPreference.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2007 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.settings.quicklaunch;
+
+import com.android.settings.R;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.preference.Preference;
+import android.util.TypedValue;
+import android.view.View;
+import android.widget.TextView;
+
+/**
+ * Preference type for a shortcut in {@link QuickLaunchSettings}.
+ */
+public class ShortcutPreference extends Preference implements Comparable<Preference> {
+
+    private static Object sStaticVarsLock = new Object();
+    
+    // These static fields are used across all instances of ShortcutPreference.
+    // There will be many ShortcutPreference instances (~36 for US).
+    private static String STRING_ASSIGN_APPLICATION;
+    private static String STRING_NO_SHORTCUT;
+
+    private static int sDimAlpha;
+    private static ColorStateList sRegularTitleColor;
+    private static ColorStateList sDimTitleColor;
+    private static ColorStateList sRegularSummaryColor;
+    private static ColorStateList sDimSummaryColor;
+    
+    private char mShortcut;
+    private boolean mHasBookmark;
+    
+    public ShortcutPreference(Context context, char shortcut) {
+        super(context);
+
+        synchronized (sStaticVarsLock) {
+            // Init statics. This should only happen for the first ShortcutPreference created,
+            // the rest will already have them initialized.
+            if (STRING_ASSIGN_APPLICATION == null) {
+                STRING_ASSIGN_APPLICATION = context.getString(R.string.quick_launch_assign_application);
+                STRING_NO_SHORTCUT = context.getString(R.string.quick_launch_no_shortcut);
+    
+                TypedValue outValue = new TypedValue();
+                context.getTheme().resolveAttribute(android.R.attr.disabledAlpha, outValue, true);
+                sDimAlpha = (int) (outValue.getFloat() * 255);
+            }
+        }
+        
+        mShortcut = shortcut;
+
+        setWidgetLayoutResource(R.layout.preference_widget_shortcut);
+    }
+
+    public char getShortcut() {
+        return mShortcut;
+    }
+
+    public void setShortcut(char shortcut) {
+        if (shortcut != mShortcut) {
+            mShortcut = shortcut;
+            notifyChanged();
+        }
+    }
+
+    public boolean hasBookmark() {
+        return mHasBookmark;
+    }
+
+    public void setHasBookmark(boolean hasBookmark) {
+        if (hasBookmark != mHasBookmark) {
+            mHasBookmark = hasBookmark;
+            notifyChanged();
+        }
+    }
+
+    @Override
+    public CharSequence getTitle() {
+        return mHasBookmark ? super.getTitle() : STRING_ASSIGN_APPLICATION;
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        return mHasBookmark ? super.getSummary() : STRING_NO_SHORTCUT;
+    }
+
+    @Override
+    protected void onBindView(View view) {
+        super.onBindView(view);
+        
+        TextView shortcutView = (TextView) view.findViewById(R.id.shortcut);
+        if (shortcutView != null) {
+            shortcutView.setText(String.valueOf(mShortcut));
+        }
+    
+        TextView titleView = (TextView) view.findViewById(android.R.id.title);
+
+        synchronized (sStaticVarsLock) {
+            if (sRegularTitleColor == null) {
+                sRegularTitleColor = titleView.getTextColors();
+                sDimTitleColor = sRegularTitleColor.withAlpha(sDimAlpha);
+            }
+        }
+        
+        ColorStateList color = mHasBookmark ? sRegularTitleColor : sDimTitleColor;
+        if (color != null) {
+            titleView.setTextColor(color);
+        }
+        
+        TextView summaryView = (TextView) view.findViewById(android.R.id.summary);
+
+        synchronized (sStaticVarsLock) {
+            if (sRegularSummaryColor == null) {
+                sRegularSummaryColor = summaryView.getTextColors();
+                sDimSummaryColor = sRegularSummaryColor.withAlpha(sDimAlpha);
+            }
+        }
+        
+        color = mHasBookmark ? sRegularSummaryColor : sDimSummaryColor;
+        if (color != null) {
+            summaryView.setTextColor(color);
+        }
+        
+    }
+
+    public int compareTo(Preference another) {
+        if (!(another instanceof ShortcutPreference)) return super.compareTo(another);
+
+        // Letters before digits
+        char other = ((ShortcutPreference) another).mShortcut;
+        if (Character.isDigit(mShortcut) && Character.isLetter(other)) return 1;
+        else if (Character.isDigit(other) && Character.isLetter(mShortcut)) return -1;
+        else return mShortcut - other;
+    }
+    
+}
diff --git a/src/com/android/settings/wifi/AccessPointDialog.java b/src/com/android/settings/wifi/AccessPointDialog.java
new file mode 100644
index 0000000..917ed96
--- /dev/null
+++ b/src/com/android/settings/wifi/AccessPointDialog.java
@@ -0,0 +1,600 @@
+/*
+ * Copyright (C) 2007 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.settings.wifi;
+
+import com.android.settings.R;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.text.format.Formatter;
+import android.text.method.PasswordTransformationMethod;
+import android.text.method.TransformationMethod;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.CheckBox;
+import android.widget.EditText;
+import android.widget.Spinner;
+import android.widget.TableLayout;
+import android.widget.TextView;
+
+public class AccessPointDialog extends AlertDialog implements DialogInterface.OnClickListener,
+        AdapterView.OnItemSelectedListener, View.OnClickListener {
+
+    private static final String TAG = "AccessPointDialog";
+    private static final String INSTANCE_KEY_ACCESS_POINT_STATE =
+            "com.android.settings.wifi.AccessPointDialog:accessPointState";
+    private static final String INSTANCE_KEY_MODE =
+            "com.android.settings.wifi.AccessPointDialog:mode";
+    private static final String INSTANCE_KEY_CUSTOM_TITLE =
+            "com.android.settings.wifi.AccessPointDialog:customTitle";
+    private static final String INSTANCE_KEY_AUTO_SECURITY_ALLOWED =
+            "com.android.settings.wifi.AccessPointDialog:autoSecurityAllowed";
+    
+    private static final int POSITIVE_BUTTON = BUTTON1;
+    private static final int NEGATIVE_BUTTON = BUTTON2;
+    private static final int NEUTRAL_BUTTON = BUTTON3;
+    
+    /** The dialog should show info connectivity functionality */
+    public static final int MODE_INFO = 0;
+    /** The dialog should configure the detailed AP properties */
+    public static final int MODE_CONFIGURE = 1;
+    /** The dialog should have the password field and connect/cancel */
+    public static final int MODE_RETRY_PASSWORD = 2;
+    
+    // These should be matched with the XML. Both arrays in XML depend on this
+    // ordering!
+    private static final int SECURITY_AUTO = 0;
+    private static final int SECURITY_NONE = 1;
+    private static final int SECURITY_WEP = 2;
+    private static final int SECURITY_WPA_PERSONAL = 3;
+    private static final int SECURITY_WPA2_PERSONAL = 4;
+
+    private static final int[] WEP_TYPE_VALUES = {
+            AccessPointState.WEP_PASSWORD_AUTO, AccessPointState.WEP_PASSWORD_ASCII,
+            AccessPointState.WEP_PASSWORD_HEX
+    };
+    
+    // Button positions, default to impossible values
+    private int mConnectButtonPos = Integer.MAX_VALUE; 
+    private int mForgetButtonPos = Integer.MAX_VALUE;
+    private int mSaveButtonPos = Integer.MAX_VALUE;
+
+    // Client configurable items. Generally, these should be saved in instance state
+    private int mMode = MODE_INFO;
+    private boolean mAutoSecurityAllowed = true;
+    private CharSequence mCustomTitle;
+    // This does not need to be saved in instance state.
+    private WifiLayer mWifiLayer;
+    private AccessPointState mState;
+    
+    // General views
+    private View mView;
+    private TextView mPasswordText;
+    private EditText mPasswordEdit;
+    private CheckBox mShowPasswordCheckBox;
+    
+    // Info-specific views
+    private ViewGroup mTable;
+    
+    // Configure-specific views
+    private EditText mSsidEdit;
+    private Spinner mSecuritySpinner;
+    private Spinner mWepTypeSpinner;
+    
+    public AccessPointDialog(Context context, WifiLayer wifiLayer) {
+        super(context);
+
+        mWifiLayer = wifiLayer;
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        onLayout();
+        onFill();
+
+        super.onCreate(savedInstanceState);
+    }
+    
+    @Override
+    public void onRestoreInstanceState(Bundle savedInstanceState) {
+        // Set to a class loader that can find AccessPointState
+        savedInstanceState.setClassLoader(getClass().getClassLoader());
+        
+        mState = savedInstanceState.getParcelable(INSTANCE_KEY_ACCESS_POINT_STATE);
+        mState.setContext(getContext());
+        
+        mMode = savedInstanceState.getInt(INSTANCE_KEY_MODE, mMode);
+        mAutoSecurityAllowed = savedInstanceState.getBoolean(INSTANCE_KEY_AUTO_SECURITY_ALLOWED,
+                mAutoSecurityAllowed);
+        mCustomTitle = savedInstanceState.getCharSequence(INSTANCE_KEY_CUSTOM_TITLE);
+        if (mCustomTitle != null) {
+            setTitle(mCustomTitle);
+        }
+
+        // This is called last since it depends on the above values 
+        super.onRestoreInstanceState(savedInstanceState);
+        
+        if (mShowPasswordCheckBox != null) {
+            // Restore the show-password-state on the edit text
+            setShowPassword(mShowPasswordCheckBox.isChecked());
+        }
+    }
+
+    @Override
+    public Bundle onSaveInstanceState() {
+        Bundle bundle = super.onSaveInstanceState();
+        bundle.putParcelable(INSTANCE_KEY_ACCESS_POINT_STATE, mState);
+        bundle.putInt(INSTANCE_KEY_MODE, mMode);
+        bundle.putBoolean(INSTANCE_KEY_AUTO_SECURITY_ALLOWED, mAutoSecurityAllowed);
+        bundle.putCharSequence(INSTANCE_KEY_CUSTOM_TITLE, mCustomTitle);
+        return bundle;
+    }
+
+    /**
+     * Sets state to show in this dialog.
+     * 
+     * @param state The state.
+     */
+    public void setState(AccessPointState state) {
+        mState = state;
+    }
+
+    /**
+     * Sets the dialog mode.
+     * @param mode One of {@link #MODE_CONFIGURE} or {@link #MODE_INFO}
+     */
+    public void setMode(int mode) {
+        mMode = mode;
+    }
+
+    public void setAutoSecurityAllowed(boolean autoSecurityAllowed) {
+        mAutoSecurityAllowed = autoSecurityAllowed;
+    }
+
+    @Override
+    public void setTitle(CharSequence title) {
+        super.setTitle(title);
+        mCustomTitle = title;
+    }
+
+    @Override
+    public void setTitle(int titleId) {
+        setTitle(getContext().getString(titleId));
+    }
+
+    /** Called after flags are set, the dialog's layout/etc should be set up here */
+    private void onLayout() {
+        final Context context = getContext();
+        final String ssid = mState.getHumanReadableSsid();
+        
+        int positiveButtonResId = 0;
+        int negativeButtonResId = R.string.cancel;
+        int neutralButtonResId = 0;
+
+        if (mCustomTitle == null) {
+            // Generic title is the SSID
+            // We don't want to trigger this as a custom title, so call super's
+            super.setTitle(ssid);
+        }
+        setInverseBackgroundForced(true);
+
+        boolean defaultPasswordVisibility = true;
+        
+        if (mMode == MODE_CONFIGURE) {
+            setLayout(R.layout.wifi_ap_configure);
+
+            positiveButtonResId = R.string.wifi_save_config;
+            mSaveButtonPos = POSITIVE_BUTTON;
+            
+        } else if (mMode == MODE_INFO) {
+            setLayout(R.layout.wifi_ap_info);
+
+            if (mState.isConnectable()) {
+                if (mCustomTitle == null) {
+                    // We don't want to trigger this as a custom title, so call super's
+                    super.setTitle(context.getString(R.string.connect_to_blank, ssid));
+                }
+                positiveButtonResId = R.string.connect;
+                mConnectButtonPos = POSITIVE_BUTTON;
+            }
+
+            if (mState.isForgetable()) {
+                if (positiveButtonResId == 0) {
+                    positiveButtonResId = R.string.forget_network;
+                    mForgetButtonPos = POSITIVE_BUTTON;
+                } else {
+                    neutralButtonResId = R.string.forget_network;
+                    mForgetButtonPos = NEUTRAL_BUTTON;
+                }
+            }
+        } else if (mMode == MODE_RETRY_PASSWORD) {
+            setLayout(R.layout.wifi_ap_retry_password);
+            
+            positiveButtonResId = R.string.connect;
+            mConnectButtonPos = POSITIVE_BUTTON;
+            
+            setGenericPasswordVisible(true);
+            defaultPasswordVisibility = false;
+        }
+
+        if (defaultPasswordVisibility) {
+            if (!mState.configured && mState.seen && mState.hasSecurity()) {
+                setGenericPasswordVisible(true);
+            } else {
+                setGenericPasswordVisible(false);
+            }
+        }
+        
+        setButtons(positiveButtonResId, negativeButtonResId, neutralButtonResId);
+    }
+
+    /** Called when we need to set our member variables to point to the views. */
+    private void onReferenceViews(View view) {
+        mPasswordText = (TextView) view.findViewById(R.id.password_text);
+        mPasswordEdit = (EditText) view.findViewById(R.id.password_edit);
+        
+        mShowPasswordCheckBox = (CheckBox) view.findViewById(R.id.show_password_checkbox);
+        if (mShowPasswordCheckBox != null) {
+            mShowPasswordCheckBox.setOnClickListener(this);
+        }
+        
+        if (mMode == MODE_CONFIGURE) {
+            mSsidEdit = (EditText) view.findViewById(R.id.ssid_edit);
+            mSecuritySpinner = (Spinner) view.findViewById(R.id.security_spinner);
+            mSecuritySpinner.setOnItemSelectedListener(this);
+            setSecuritySpinnerAdapter();
+            mWepTypeSpinner = (Spinner) view.findViewById(R.id.wep_type_spinner);
+            
+        } else if (mMode == MODE_INFO) {
+            mTable = (ViewGroup) view.findViewById(R.id.table);
+        }
+        
+    }
+    
+    private void setSecuritySpinnerAdapter() {
+        Context context = getContext();
+        int arrayResId = mAutoSecurityAllowed ? R.array.wifi_security_entries
+                : R.array.wifi_security_without_auto_entries;         
+
+        ArrayAdapter<CharSequence> adapter = new ArrayAdapter<CharSequence>(context,
+                android.R.layout.simple_spinner_item,
+                context.getResources().getStringArray(arrayResId));
+        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+        mSecuritySpinner.setAdapter(adapter);
+    }
+    
+    /** Called when the widgets are in-place waiting to be filled with data */
+    private void onFill() {
+
+        // Appears in the order added
+        if (mMode == MODE_INFO) {
+            if (mState.primary) {
+                addInfoRow(R.string.wifi_status, mState.getSummarizedStatus());
+                addInfoRow(R.string.wifi_link_speed, mState.linkSpeed + WifiInfo.LINK_SPEED_UNITS);
+            }
+    
+            if (mState.seen) {
+                addInfoRow(R.string.signal, getSignalResId(mState.signal));
+            }
+            
+            if (mState.security != null) {
+                addInfoRow(R.string.security, mState.getHumanReadableSecurity());
+            }
+    
+            if (mState.primary && mState.ipAddress != 0) {
+                addInfoRow(R.string.ip_address, Formatter.formatIpAddress(mState.ipAddress));
+            }
+            
+        } else if (mMode == MODE_CONFIGURE) {
+            String ssid = mState.getHumanReadableSsid();
+            if (!TextUtils.isEmpty(ssid)) {
+                mSsidEdit.setText(ssid);
+            }
+            
+            mPasswordEdit.setHint(R.string.wifi_password_unchanged);
+        }
+
+        updatePasswordCaption(mState.security);
+    }
+
+    private void updatePasswordCaption(String security) {
+        
+        if (mPasswordText != null && security != null
+                && security.equals(AccessPointState.WEP)) {
+            mPasswordText.setText(R.string.please_type_hex_key);
+        } else {
+            mPasswordText.setText(R.string.please_type_passphrase);
+        }
+    }
+    
+    private void addInfoRow(int nameResId, String value) {
+        View rowView = getLayoutInflater().inflate(R.layout.wifi_ap_info_row, mTable, false);
+        ((TextView) rowView.findViewById(R.id.name)).setText(nameResId);
+        ((TextView) rowView.findViewById(R.id.value)).setText(value);
+        mTable.addView(rowView);
+    }
+        
+    private void addInfoRow(int nameResId, int valueResId) {
+        addInfoRow(nameResId, getContext().getString(valueResId));
+    }
+    
+    private void setButtons(int positiveResId, int negativeResId, int neutralResId) {
+        final Context context = getContext();
+        
+        if (positiveResId > 0) {
+            setButton(context.getString(positiveResId), this);
+        }
+        
+        if (negativeResId > 0) {
+            setButton2(context.getString(negativeResId), this);
+        }
+
+        if (neutralResId > 0) {
+            setButton3(context.getString(neutralResId), this);
+        }
+    }
+    
+    private void setLayout(int layoutResId) {
+        setView(mView = getLayoutInflater().inflate(layoutResId, null));
+        onReferenceViews(mView);
+    }
+    
+    public void onClick(DialogInterface dialog, int which) {
+        if (which == mForgetButtonPos) {
+            handleForget();
+        } else if (which == mConnectButtonPos) {
+            handleConnect();
+        } else if (which == mSaveButtonPos) {
+            handleSave();
+        }
+    }
+    
+    private void handleForget() {
+        if (!replaceStateWithWifiLayerInstance()) return;
+        mWifiLayer.forgetNetwork(mState);
+    }
+    
+    private void handleConnect() {
+        if (!replaceStateWithWifiLayerInstance()) {
+            Log.w(TAG, "Assuming connecting to a new network.");
+        }
+        
+        /*
+         * If the network is secured and they haven't entered a password, popup
+         * an error. Allow empty passwords if the state already has a password
+         * set (since in that scenario, an empty password means keep the old
+         * password).
+         */
+        String password = getEnteredPassword();
+        boolean passwordIsEmpty = TextUtils.isEmpty(password);
+        
+        /*
+         * When 'retry password', they can not enter a blank password. In any
+         * other mode, we let them enter a blank password if the state already
+         * has a password.
+         */
+        if (passwordIsEmpty && (!mState.hasPassword() || mMode == MODE_RETRY_PASSWORD)
+                && (mState.security != null) && !mState.security.equals(AccessPointState.OPEN)) {
+            new AlertDialog.Builder(getContext())
+                    .setTitle(R.string.error_title)
+                    .setIcon(android.R.drawable.ic_dialog_alert)
+                    .setMessage(R.string.wifi_password_incorrect_error)
+                    .setPositiveButton(android.R.string.ok, null)
+                    .show();
+            return;
+        }
+        
+        if (!passwordIsEmpty) { 
+            mState.setPassword(password);
+        }
+        
+        mWifiLayer.connectToNetwork(mState);            
+    }
+    
+    private void handleSave() {
+        replaceStateWithWifiLayerInstance();
+
+        String ssid = mSsidEdit.getText().toString();
+        String password = mPasswordEdit.getText().toString();
+        
+        mState.setSsid(ssid);
+        
+        int securityType = getSecurityTypeFromSpinner();
+        
+        if (!TextUtils.isEmpty(password)) {
+            switch (securityType) {
+             
+                case SECURITY_WPA_PERSONAL: {
+                    mState.setSecurity(AccessPointState.WPA);
+                    mState.setPassword(password);
+                    break;
+                }
+                    
+                case SECURITY_WPA2_PERSONAL: {
+                    mState.setSecurity(AccessPointState.WPA2);
+                    mState.setPassword(password);
+                    break;
+                }
+                
+                case SECURITY_AUTO: {
+                    mState.setPassword(password);
+                    break;
+                }
+                    
+                case SECURITY_WEP: {
+                    mState.setSecurity(AccessPointState.WEP);
+                    mState.setPassword(password,
+                            WEP_TYPE_VALUES[mWepTypeSpinner.getSelectedItemPosition()]);
+                    break;
+                }
+                
+            }
+        } else {
+            mState.setSecurity(AccessPointState.OPEN);
+        }
+        
+        if (securityType == SECURITY_NONE) {
+            mState.setSecurity(AccessPointState.OPEN);
+        }
+            
+        if (!mWifiLayer.saveNetwork(mState)) {
+            return;
+        }
+        
+        // Connect right away if they've touched it
+        if (!mWifiLayer.connectToNetwork(mState)) {
+            return;
+        }
+        
+    }
+    
+    /**
+     * Replaces our {@link #mState} with the equal WifiLayer instance.  This is useful after
+     * we unparceled the state previously and before we are calling methods on {@link #mWifiLayer}.
+     * 
+     * @return Whether WifiLayer was able to find an equal state in its set.
+     */
+    private boolean replaceStateWithWifiLayerInstance() {
+        AccessPointState state = mWifiLayer.getWifiLayerApInstance(mState);
+        if (state == null) {
+            return false;
+        }
+        
+        mState = state;
+        return true;
+    }
+    
+    private int getSecurityTypeFromSpinner() {
+        int position = mSecuritySpinner.getSelectedItemPosition();
+        // If there is no AUTO choice, the position needs 1 added to get
+        // to the proper spinner position -> security constants mapping
+        return mAutoSecurityAllowed ? position : position + 1;
+    }
+    
+    private String getEnteredPassword() {
+        return mPasswordEdit != null ? mPasswordEdit.getText().toString() : null;
+    }
+    
+    /**
+     * Call the one you want to hide first.
+     */
+    private void setWepVisible(boolean visible) {
+        setGenericPasswordVisible(visible);
+        int visibility = visible ? View.VISIBLE : View.GONE;
+        mWepTypeSpinner.setVisibility(visibility);
+    }
+    
+    /**
+     * @see #setWepVisible(boolean)
+     */
+    private void setGenericPasswordVisible(boolean visible) {
+        int visibility = visible ? View.VISIBLE : View.GONE;
+        mPasswordText.setVisibility(visibility);
+        mPasswordEdit.setVisibility(visibility);
+        mShowPasswordCheckBox.setVisibility(visibility);
+    }
+    
+    public void onItemSelected(AdapterView parent, View view, int position, long id) {
+        if (parent == mSecuritySpinner) {
+            handleSecurityChange(getSecurityTypeFromSpinner());
+        }
+    }
+
+    public void onNothingSelected(AdapterView parent) {
+    }
+
+    private void handleSecurityChange(int security) {
+        
+        switch (security) {
+            
+            case SECURITY_NONE: {
+                setWepVisible(false);
+                setGenericPasswordVisible(false);
+                break;
+            }
+            
+            case SECURITY_WEP: {
+                setGenericPasswordVisible(false);
+                setWepVisible(true);
+                updatePasswordCaption(AccessPointState.WEP);
+                break;
+            }
+            
+            case SECURITY_AUTO: {
+                setWepVisible(false);
+                setGenericPasswordVisible(mState.hasSecurity());
+                // Shows the generic 'wireless password'
+                updatePasswordCaption(AccessPointState.WPA);
+                break;
+            }
+            
+            case SECURITY_WPA_PERSONAL:
+            case SECURITY_WPA2_PERSONAL: {
+                setWepVisible(false);
+                setGenericPasswordVisible(true);
+                // Both WPA and WPA2 show the same caption, so either is ok
+                updatePasswordCaption(AccessPointState.WPA);
+                break;
+            }
+        }
+    }
+
+    private static int getSignalResId(int signal) {
+        switch (WifiManager.calculateSignalLevel(signal, 4)) {
+            case 0: {
+                return R.string.wifi_signal_0;
+            }
+            case 1: {
+                return R.string.wifi_signal_1;
+            }
+            case 2: {
+                return R.string.wifi_signal_2;
+            }
+            case 3: {
+                return R.string.wifi_signal_3;
+            }
+        }
+        
+        return 0;
+    }
+    
+
+    public void onClick(View v) {
+        if (v == mShowPasswordCheckBox) {
+            setShowPassword(mShowPasswordCheckBox.isChecked());
+        }
+    }
+    
+    private void setShowPassword(boolean showPassword) {
+        if (mPasswordEdit != null) {
+            // Toggle password
+            mPasswordEdit.setTransformationMethod(
+                    showPassword ?
+                            null :
+                            PasswordTransformationMethod.getInstance());
+        }
+    }
+    
+}
diff --git a/src/com/android/settings/wifi/AccessPointPreference.java b/src/com/android/settings/wifi/AccessPointPreference.java
new file mode 100644
index 0000000..10e0947
--- /dev/null
+++ b/src/com/android/settings/wifi/AccessPointPreference.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2007 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.settings.wifi;
+
+import com.android.settings.R;
+
+import android.net.wifi.WifiManager;
+import android.preference.Preference;
+import android.view.View;
+import android.widget.ImageView;
+
+public class AccessPointPreference extends Preference implements
+        AccessPointState.AccessPointStateCallback {
+    
+    // UI states
+    private static final int[] STATE_ENCRYPTED = { R.attr.state_encrypted };
+    private static final int[] STATE_EMPTY = { };
+    
+    // Signal strength indicator
+    private static final int UI_SIGNAL_LEVELS = 4;
+
+    private WifiSettings mWifiSettings;
+    
+    private AccessPointState mState;
+
+    public AccessPointPreference(WifiSettings wifiSettings, AccessPointState state) {
+        super(wifiSettings, null);
+        
+        mWifiSettings = wifiSettings;
+        mState = state;
+        
+        setWidgetLayoutResource(R.layout.preference_widget_wifi_signal);
+        
+        state.setCallback(this);
+        
+        refresh();
+    }
+    
+    public void refresh() {
+        setTitle(mState.getHumanReadableSsid());
+        setSummary(mState.getSummarizedStatus());
+
+        notifyChanged();
+    }
+    
+    public void refreshAccessPointState() {
+        refresh();
+        
+        // The ordering of access points could have changed due to the state change, so
+        // re-evaluate ordering
+        notifyHierarchyChanged();
+    }
+
+    @Override
+    protected void onBindView(View view) {
+        super.onBindView(view);
+
+        ImageView signal = (ImageView) view.findViewById(R.id.signal);
+        if (mState.seen) {
+            signal.setImageResource(R.drawable.wifi_signal);
+            signal.setImageState(mState.hasSecurity() ? STATE_ENCRYPTED : STATE_EMPTY, true);
+            signal.setImageLevel(getUiSignalLevel());
+        } else {
+            signal.setImageDrawable(null);
+        }
+    }
+
+    private int getUiSignalLevel() {
+        return mState != null ? WifiManager.calculateSignalLevel(mState.signal, UI_SIGNAL_LEVELS)
+                : 0; 
+    }
+
+    /**
+     * Returns the {@link AccessPointState} associated with this preference.
+     * @return The {@link AccessPointState}.
+     */
+    public AccessPointState getAccessPointState() {
+        return mState;
+    }
+    
+    @Override
+    public int compareTo(Preference another) {
+        if (!(another instanceof AccessPointPreference)) {
+            // Let normal preferences go before us.
+            // NOTE: we should only be compared to Preference in our
+            //       category.
+            return 1;
+        }
+        
+        return mState.compareTo(((AccessPointPreference) another).mState);
+    }
+    
+}
+
diff --git a/src/com/android/settings/wifi/AccessPointState.java b/src/com/android/settings/wifi/AccessPointState.java
new file mode 100644
index 0000000..c224954
--- /dev/null
+++ b/src/com/android/settings/wifi/AccessPointState.java
@@ -0,0 +1,879 @@
+/*
+ * Copyright (C) 2007 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.settings.wifi;
+
+import com.android.settings.R;
+
+import android.content.Context;
+import android.net.NetworkInfo;
+import android.net.wifi.ScanResult;
+import android.net.wifi.WifiConfiguration;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiConfiguration.AuthAlgorithm;
+import android.net.wifi.WifiConfiguration.GroupCipher;
+import android.net.wifi.WifiConfiguration.KeyMgmt;
+import android.net.wifi.WifiConfiguration.PairwiseCipher;
+import android.net.wifi.WifiConfiguration.Protocol;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.text.TextUtils;
+import android.util.Log;
+
+public final class AccessPointState implements Comparable<AccessPointState>, Parcelable {
+
+    private static final String TAG = "AccessPointState";
+    
+    // Constants used for different security types
+    public static final String WPA2 = "WPA2";
+    public static final String WPA = "WPA";
+    public static final String WEP = "WEP";
+    public static final String OPEN = "Open";
+
+    /** String present in capabilities if the scan result is ad-hoc */
+    private static final String ADHOC_CAPABILITY = "[IBSS]";
+    /** String present in capabilities if the scan result is enterprise secured */
+    private static final String ENTERPRISE_CAPABILITY = "-EAP-";
+    
+    // Localized strings for different security types
+    private static String LOCALIZED_WPA2;
+    private static String LOCALIZED_WPA;
+    private static String LOCALIZED_WEP;
+    private static String LOCALIZED_OPEN;
+    private static String LOCALIZED_UNKNOWN;
+    private static String LOCALIZED_VERBOSE_WPA2;
+    private static String LOCALIZED_VERBOSE_WPA;
+    private static String LOCALIZED_VERBOSE_WEP;
+    private static String LOCALIZED_VERBOSE_OPEN;
+
+    
+    // Localized strings for various messages
+    private static String SUMMARY_NOT_IN_RANGE;
+    private static String SUMMARY_REMEMBERED;
+    private static String SUMMARY_CONNECTION_FAILED;
+    
+    public static final String BSSID_ANY = "any";
+    public static final int NETWORK_ID_NOT_SET = -1;
+    /** This should be used with care! */
+    static final int NETWORK_ID_ANY = -2;
+    
+    public static final int MATCH_NONE = 0;
+    public static final int MATCH_WEAK = 1;
+    public static final int MATCH_STRONG = 2;
+    public static final int MATCH_EXACT = 3;
+    
+    // Don't set these directly, use the setters.
+    public int networkId;
+    public int priority;
+    public boolean hiddenSsid;
+    public int linkSpeed;
+    public int ipAddress;
+    public String bssid;
+    public String ssid;
+    public int signal;
+    public boolean primary;
+    public boolean seen;
+    public boolean configured;
+    public NetworkInfo.DetailedState status;
+    public String security;
+    public boolean disabled;
+    
+    /**
+     * Use this for sorting based on signal strength. It is a heavily-damped
+     * time-averaged weighted signal.
+     */
+    private float signalForSorting = Float.MIN_VALUE;
+    
+    private static final float DAMPING_FACTOR = 0.2f;
+    
+    /**
+     * This will be a user entered password, and NOT taken from wpa_supplicant
+     * (since it would give us *)
+     */
+    private String mPassword; 
+    private boolean mConfigHadPassword;
+    
+    public static final int WEP_PASSWORD_AUTO = 0;
+    public static final int WEP_PASSWORD_ASCII = 1;
+    public static final int WEP_PASSWORD_HEX = 2;
+    private int mWepPasswordType;
+    
+    private Context mContext;
+
+    /**
+     * If > 0, don't refresh (changes are being batched), use
+     * {@link #blockRefresh()} and {@link #unblockRefresh()} only.
+     */
+    private int mBlockRefresh;
+    /**
+     * This will be set by {@link #requestRefresh} and shouldn't be written to
+     * elsewhere.
+     */
+    private boolean mNeedsRefresh;    
+    
+    private AccessPointStateCallback mCallback;
+    
+    private StringBuilder mSummaryBuilder = new StringBuilder();
+    
+    interface AccessPointStateCallback {
+        void refreshAccessPointState();
+    }
+    
+    public AccessPointState(Context context) {
+        this();
+        
+        setContext(context);
+    }
+
+    private AccessPointState() {
+        bssid = BSSID_ANY;
+        ssid = "";
+        networkId = NETWORK_ID_NOT_SET;
+        hiddenSsid = false;
+    }
+
+    void setContext(Context context) {
+        mContext = context;
+        setStrings();
+    }
+
+    private void setStrings() {
+        final Context c = mContext;
+
+        if (SUMMARY_NOT_IN_RANGE == null && c != null) {
+            SUMMARY_NOT_IN_RANGE = c.getString(R.string.summary_not_in_range);
+            SUMMARY_REMEMBERED = c.getString(R.string.summary_remembered);
+            SUMMARY_CONNECTION_FAILED = c.getString(R.string.summary_connection_failed);
+            
+            LOCALIZED_OPEN = c.getString(R.string.wifi_security_open);
+            LOCALIZED_WEP = c.getString(R.string.wifi_security_wep);
+            LOCALIZED_WPA = c.getString(R.string.wifi_security_wpa);
+            LOCALIZED_WPA2 = c.getString(R.string.wifi_security_wpa2);
+
+            LOCALIZED_VERBOSE_OPEN = c.getString(R.string.wifi_security_verbose_open);
+            LOCALIZED_VERBOSE_WEP = c.getString(R.string.wifi_security_verbose_wep);
+            LOCALIZED_VERBOSE_WPA = c.getString(R.string.wifi_security_verbose_wpa);
+            LOCALIZED_VERBOSE_WPA2 = c.getString(R.string.wifi_security_verbose_wpa2);
+
+            LOCALIZED_UNKNOWN = c.getString(R.string.wifi_security_unknown);
+        }
+    }
+    
+    public void setNetworkId(int networkId) {
+        this.networkId = networkId;
+    }
+    
+    public void setBssid(String bssid) {
+        if (bssid != null) {
+            // If the BSSID is a wildcard, do NOT let a specific BSSID replace it
+            if (!this.bssid.equals(BSSID_ANY)) {
+                this.bssid = bssid;
+            }
+        }
+    }
+
+    private String getWpaSupplicantBssid() {
+        return bssid.equals(BSSID_ANY) ? null : bssid;
+    }
+    
+    public static String convertToQuotedString(String string) {
+        if (TextUtils.isEmpty(string)) {
+            return "";
+        }
+        
+        final int lastPos = string.length() - 1;
+        if (lastPos < 0 || (string.charAt(0) == '"' && string.charAt(lastPos) == '"')) {
+            return string;
+        }
+        
+        return "\"" + string + "\"";
+    }
+    
+    public void setPrimary(boolean primary) {
+        if (this.primary != primary) {
+            this.primary = primary;
+            requestRefresh();
+        }
+    }
+    
+    public void setSeen(boolean seen) {
+        if (this.seen != seen) {
+            this.seen = seen;
+            requestRefresh();
+        }
+    }
+    
+    public void setDisabled(boolean disabled) {
+        if (this.disabled != disabled) {
+            this.disabled = disabled;
+            requestRefresh();
+        }
+    }
+    
+    public void setSignal(int signal) {
+
+        if (signalForSorting == Float.MIN_VALUE) {
+            signalForSorting = signal;
+        } else {
+            signalForSorting = (DAMPING_FACTOR * signal) + ((1-DAMPING_FACTOR) * signalForSorting);
+        }
+
+        if (this.signal != signal) {
+            this.signal = signal;
+            requestRefresh();
+        }
+    }
+    
+    public String getHumanReadableSsid() {
+        if (TextUtils.isEmpty(ssid)) {
+            return "";
+        }
+        
+        final int lastPos = ssid.length() - 1;
+        if (ssid.charAt(0) == '"' && ssid.charAt(lastPos) == '"') {
+            return ssid.substring(1, lastPos);
+        }
+        
+        return ssid;
+    }
+    
+    public void setSsid(String ssid) {
+        if (ssid != null) {
+            this.ssid = convertToQuotedString(ssid);
+            requestRefresh();
+        }
+    }
+    
+    public void setPriority(int priority) {
+        if (this.priority != priority) {
+            this.priority = priority;
+            requestRefresh();
+        }
+    }
+
+    public void setHiddenSsid(boolean hiddenSsid) {
+        if (this.hiddenSsid != hiddenSsid) {
+            this.hiddenSsid = hiddenSsid;
+            requestRefresh();
+        }
+    }
+
+    public void setLinkSpeed(int linkSpeed) {
+        if (this.linkSpeed != linkSpeed) {
+            this.linkSpeed = linkSpeed;
+            requestRefresh();
+        }
+    }
+    
+    public void setIpAddress(int address) {
+        if (ipAddress != address) {
+            ipAddress = address;
+            requestRefresh();
+        }
+    }
+    
+    public void setConfigured(boolean configured) {
+        if (this.configured != configured) {
+            this.configured = configured;
+            requestRefresh();
+        }
+    }
+    
+    public void setStatus(NetworkInfo.DetailedState status) {
+        if (this.status != status) {
+            this.status = status;
+            requestRefresh();
+        }
+    }
+    
+    public void setSecurity(String security) {
+        if (TextUtils.isEmpty(this.security) || !this.security.equals(security)) {
+            this.security = security;
+            requestRefresh();
+        }
+    }
+
+    public boolean hasSecurity() {
+        return security != null && !security.contains(OPEN);
+    }
+    
+    public String getHumanReadableSecurity() {
+        if (security.equals(OPEN)) return LOCALIZED_OPEN;
+        else if (security.equals(WEP)) return LOCALIZED_WEP;
+        else if (security.equals(WPA)) return LOCALIZED_WPA;
+        else if (security.equals(WPA2)) return LOCALIZED_WPA2;
+        
+        return LOCALIZED_UNKNOWN;
+    }
+    
+    public void updateFromScanResult(ScanResult scanResult) {
+        blockRefresh();
+        
+        // We don't keep specific AP BSSIDs and instead leave that as wildcard
+        
+        setSeen(true);
+        setSsid(scanResult.SSID);
+        if (networkId == NETWORK_ID_NOT_SET) {
+            // Since ScanResults don't cross-reference network ID, we set it as a wildcard
+            setNetworkId(NETWORK_ID_ANY);
+        }
+        setSignal(scanResult.level);
+        setSecurity(getScanResultSecurity(scanResult));
+        unblockRefresh();
+    }
+    
+    /**
+     * @return The security of a given {@link ScanResult}.
+     */
+    public static String getScanResultSecurity(ScanResult scanResult) {
+        final String cap = scanResult.capabilities;
+        final String[] securityModes = { WEP, WPA, WPA2 }; 
+        for (int i = securityModes.length - 1; i >= 0; i--) {
+            if (cap.contains(securityModes[i])) {
+                return securityModes[i];
+            }
+        }
+        
+        return OPEN;
+    }
+    
+    /**
+     * @return Whether the given ScanResult represents an adhoc network.
+     */
+    public static boolean isAdhoc(ScanResult scanResult) {
+        return scanResult.capabilities.contains(ADHOC_CAPABILITY);
+    }
+    
+    /**
+     * @return Whether the given ScanResult has enterprise security.
+     */
+    public static boolean isEnterprise(ScanResult scanResult) {
+        return scanResult.capabilities.contains(ENTERPRISE_CAPABILITY);
+    }
+    
+    public void updateFromWifiConfiguration(WifiConfiguration wifiConfig) {
+        if (wifiConfig != null) {
+            blockRefresh();
+            setBssid(wifiConfig.BSSID);
+            setNetworkId(wifiConfig.networkId);
+            setPriority(wifiConfig.priority);
+            setHiddenSsid(wifiConfig.hiddenSSID);
+            setSsid(wifiConfig.SSID);
+            setConfigured(true);
+            setDisabled(wifiConfig.status == WifiConfiguration.Status.DISABLED);
+            parseWifiConfigurationSecurity(wifiConfig);
+            unblockRefresh();
+        }
+    }
+    
+    public void setPassword(String password) {
+        setPassword(password, WEP_PASSWORD_AUTO);
+    }
+    
+    public void setPassword(String password, int wepPasswordType) {
+        mPassword = password;
+        mWepPasswordType = wepPasswordType;
+    }
+    
+    public boolean hasPassword() {
+        return !TextUtils.isEmpty(mPassword) || mConfigHadPassword; 
+    }
+    
+    private static boolean hasPassword(WifiConfiguration wifiConfig) {
+        return !TextUtils.isEmpty(wifiConfig.preSharedKey)
+                || !TextUtils.isEmpty(wifiConfig.wepKeys[0])
+                || !TextUtils.isEmpty(wifiConfig.wepKeys[1])
+                || !TextUtils.isEmpty(wifiConfig.wepKeys[2])
+                || !TextUtils.isEmpty(wifiConfig.wepKeys[3]);        
+    }
+    
+    private void parseWifiConfigurationSecurity(WifiConfiguration wifiConfig) {
+        setSecurity(getWifiConfigurationSecurity(wifiConfig));
+        mConfigHadPassword = hasPassword(wifiConfig);
+    }
+    
+    /**
+     * @return The security of a given {@link WifiConfiguration}.
+     */
+    public static String getWifiConfigurationSecurity(WifiConfiguration wifiConfig) {
+
+        if (wifiConfig.allowedKeyManagement.get(KeyMgmt.NONE)) {
+            // If we never set group ciphers, wpa_supplicant puts all of them.
+            // For open, we don't set group ciphers.
+            // For WEP, we specifically only set WEP40 and WEP104, so CCMP
+            // and TKIP should not be there.
+            if (!wifiConfig.allowedGroupCiphers.get(GroupCipher.CCMP)
+                    && (wifiConfig.allowedGroupCiphers.get(GroupCipher.WEP40)
+                            || wifiConfig.allowedGroupCiphers.get(GroupCipher.WEP104))) {
+                return WEP;
+            } else {
+                return OPEN;
+            }
+        } else if (wifiConfig.allowedProtocols.get(Protocol.RSN)) {
+            return WPA2;
+        } else if (wifiConfig.allowedProtocols.get(Protocol.WPA)) {
+            return WPA;
+        } else {
+            Log.w(TAG, "Unknown security type from WifiConfiguration, falling back on open.");
+            return OPEN;
+        }
+    }
+    
+    public void updateFromWifiInfo(WifiInfo wifiInfo, NetworkInfo.DetailedState state) {
+        if (wifiInfo != null) {
+            blockRefresh();
+            setBssid(wifiInfo.getBSSID());
+            setLinkSpeed(wifiInfo.getLinkSpeed());
+            setNetworkId(wifiInfo.getNetworkId());
+            setIpAddress(wifiInfo.getIpAddress());
+            setSsid(wifiInfo.getSSID());
+            if (state != null) {
+                setStatus(state);
+            }
+            setHiddenSsid(wifiInfo.getHiddenSSID());
+            unblockRefresh();
+        }
+    }
+    
+    /**
+     * @return Whether this AP can be connected to at the moment.
+     */
+    public boolean isConnectable() {
+        return !primary && seen;
+    }
+
+    /**
+     * @return Whether this AP can be forgotten at the moment.
+     */
+    public boolean isForgetable() {
+        return configured;
+    }
+    
+    /**
+     * Updates the state as if it were never configured.
+     * <p>
+     * Note: This will not pass the forget call to the Wi-Fi API.
+     */
+    public void forget() {
+        blockRefresh();
+        setConfigured(false);
+        setNetworkId(NETWORK_ID_NOT_SET);
+        setPrimary(false);
+        setStatus(null);
+        setDisabled(false);
+        unblockRefresh();
+    }
+    
+    public void updateWifiConfiguration(WifiConfiguration config) {
+        config.BSSID = getWpaSupplicantBssid();
+        config.priority = priority;
+        config.hiddenSSID = hiddenSsid;
+        config.SSID = convertToQuotedString(ssid);
+        
+        setupSecurity(config);
+    }
+    
+    private void setupSecurity(WifiConfiguration config) {
+        config.allowedAuthAlgorithms.clear();
+        config.allowedGroupCiphers.clear();
+        config.allowedKeyManagement.clear();
+        config.allowedPairwiseCiphers.clear();
+        config.allowedProtocols.clear();
+        
+        if (TextUtils.isEmpty(security)) {
+            security = OPEN;
+            Log.w(TAG, "Empty security, assuming open");
+        }
+        
+        if (security.equals(WEP)) {
+            
+            // If password is empty, it should be left untouched
+            if (!TextUtils.isEmpty(mPassword)) {
+                if (mWepPasswordType == WEP_PASSWORD_AUTO) {
+                    if (isHexWepKey(mPassword)) {
+                        config.wepKeys[0] = mPassword;
+                    } else {
+                        config.wepKeys[0] = convertToQuotedString(mPassword);
+                    }
+                } else {
+                    config.wepKeys[0] = mWepPasswordType == WEP_PASSWORD_ASCII
+                            ? convertToQuotedString(mPassword)
+                            : mPassword;
+                }
+            }
+            
+            config.wepTxKeyIndex = 0;
+            
+            config.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN);
+            config.allowedAuthAlgorithms.set(AuthAlgorithm.SHARED);
+
+            config.allowedKeyManagement.set(KeyMgmt.NONE);
+            
+            config.allowedGroupCiphers.set(GroupCipher.WEP40);
+            config.allowedGroupCiphers.set(GroupCipher.WEP104);
+            
+        } else if (security.equals(WPA) || security.equals(WPA2)){
+            config.allowedGroupCiphers.set(GroupCipher.TKIP);
+            config.allowedGroupCiphers.set(GroupCipher.CCMP);
+            
+            config.allowedKeyManagement.set(KeyMgmt.WPA_PSK);
+            
+            config.allowedPairwiseCiphers.set(PairwiseCipher.CCMP);
+            config.allowedPairwiseCiphers.set(PairwiseCipher.TKIP);
+
+            config.allowedProtocols.set(security.equals(WPA2) ? Protocol.RSN : Protocol.WPA);
+            
+            // If password is empty, it should be left untouched
+            if (!TextUtils.isEmpty(mPassword)) {
+                if (mPassword.length() == 64 && isHex(mPassword)) {
+                    // Goes unquoted as hex
+                    config.preSharedKey = mPassword;
+                } else {
+                    // Goes quoted as ASCII
+                    config.preSharedKey = convertToQuotedString(mPassword);
+                }
+            }
+            
+        } else if (security.equals(OPEN)) {
+            config.allowedKeyManagement.set(KeyMgmt.NONE);
+        }
+    }
+    
+    private static boolean isHexWepKey(String wepKey) {
+        final int len = wepKey.length();
+        
+        // WEP-40, WEP-104, and some vendors using 256-bit WEP (WEP-232?)
+        if (len != 10 && len != 26 && len != 58) {
+            return false;
+        }
+        
+        return isHex(wepKey);
+    }
+    
+    private static boolean isHex(String key) {
+        for (int i = key.length() - 1; i >= 0; i--) {
+            final char c = key.charAt(i);
+            if (!(c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'a' && c <= 'f')) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+    
+    public void setCallback(AccessPointStateCallback callback) {
+        mCallback = callback;
+    }
+    
+    void blockRefresh() {
+        mBlockRefresh++;
+    }
+    
+    void unblockRefresh() {
+        if (--mBlockRefresh == 0 && mNeedsRefresh) {
+            requestRefresh();
+        }
+    }
+    
+    private void requestRefresh() {
+        if (mBlockRefresh > 0) {
+            mNeedsRefresh = true;
+            return;
+        }
+        
+        if (mCallback != null) {
+            mCallback.refreshAccessPointState();
+        }
+        
+        mNeedsRefresh = false;
+    }
+    
+    /**
+     * {@inheritDoc}
+     * @see #hashCode()
+     * @see #equals(Object)
+     */
+    public int matches(int otherNetworkId, String otherBssid, String otherSsid,
+            String otherSecurity) {
+        
+        // Whenever this method is touched, please ensure #equals and #hashCode
+        // still work with the changes here!
+        
+        if (otherSsid == null) {
+            if (WifiLayer.LOGV) {
+                Log.w(TAG, "BSSID: " + otherBssid + ", SSID: " + otherSsid);
+            }
+            return MATCH_NONE;
+        }
+
+        /*
+         * If we both have 'security' set, it must match (an open network still
+         * has 'security' set to OPEN)
+         */
+        if (security != null && otherSecurity != null) {
+            if (!security.equals(otherSecurity)) {
+                return MATCH_NONE;
+            }
+        }
+        
+        // WifiConfiguration gives an empty bssid as a BSSID wildcard
+        if (TextUtils.isEmpty(otherBssid)) {
+            otherBssid = AccessPointState.BSSID_ANY;
+        }
+
+        final boolean networkIdMatches = networkId == otherNetworkId;
+        if (!networkIdMatches && networkId != NETWORK_ID_ANY && otherNetworkId != NETWORK_ID_ANY) {
+            // Network IDs don't match (e.g., 1 & 2 or unset & 1) and neither is a wildcard
+            return MATCH_NONE;
+        }
+        
+        if (networkIdMatches && otherNetworkId != NETWORK_ID_NOT_SET
+                && otherNetworkId != NETWORK_ID_ANY) {
+            // Network ID matches (they're set to the same ID)
+            return MATCH_EXACT;
+        }
+        
+        // So now, network IDs aren't set or at least one is a wildcard 
+        
+        final boolean bssidMatches = bssid.equals(otherBssid);
+        final boolean otherBssidIsWildcard = otherBssid.equals(BSSID_ANY);
+        if (bssidMatches && !otherBssidIsWildcard) {
+            // BSSID matches (and neither is a wildcard)
+            return MATCH_STRONG;
+        }
+
+        if (!bssidMatches && !bssid.equals(BSSID_ANY) && !otherBssidIsWildcard) {
+            // BSSIDs don't match (e.g., 00:24:21:21:42:12 & 42:12:44:21:22:52)
+            // and neither is a wildcard
+            return MATCH_NONE;
+        }
+        
+        // So now, BSSIDs are both wildcards
+        
+        final boolean ssidMatches = ssid.equals(otherSsid); 
+        if (ssidMatches) {
+            // SSID matches
+            return MATCH_WEAK;
+        }
+
+        return MATCH_NONE;
+    }
+    
+    /**
+     * {@inheritDoc}
+     * @see #matches(int, String, String)
+     * @see #equals(Object)
+     */
+    @Override
+    public int hashCode() {
+        // Two equal() objects must have same hashCode.
+        // With Wi-Fi, the broadest match is if two SSIDs are the same.  The finer-grained matches
+        // imply this (for example, the same network IDs means the same WifiConfiguration which
+        // means the same SSID).
+        // See #matches for the exact matching algorithm we use.
+        return ssid != null ? ssid.hashCode() : 0;
+    }
+
+    /**
+     * {@inheritDoc}
+     * @see #matches(int, String, String)
+     * @see #hashCode()
+     */
+    @Override
+    public boolean equals(Object o) {
+        if (!o.getClass().equals(getClass())) {
+            return false;
+        }
+        
+        final AccessPointState other = (AccessPointState) o;
+
+        // To see which conditions cause two AccessPointStates to be equal, see
+        // where #matches returns MATCH_WEAK or greater.
+        
+        return matches(other.networkId, other.bssid, other.ssid, other.security) >= MATCH_WEAK;
+    }
+
+    public int matchesWifiConfiguration(WifiConfiguration wifiConfig) {
+        String security = getWifiConfigurationSecurity(wifiConfig);
+        return matches(wifiConfig.networkId, wifiConfig.BSSID, wifiConfig.SSID, security);
+    }
+    
+    String getSummarizedStatus() {
+        StringBuilder sb = mSummaryBuilder;
+        sb.delete(0, sb.length());
+        
+        if (primary && status != null) {
+            buildSummary(sb, WifiStatus.getPrintable(mContext, status), true);
+            
+        } else if (!seen) {
+            buildSummary(sb, SUMMARY_NOT_IN_RANGE, true);
+
+            // Remembered comes second in this case
+            if (!primary && configured) {
+                buildSummary(sb, SUMMARY_REMEMBERED, true);
+            }
+            
+        } else {
+            if (configured && disabled) {
+                // The connection failure overrides all in this case
+                return SUMMARY_CONNECTION_FAILED;
+            }
+
+            // Remembered comes first in this case
+            if (!primary && configured) {
+                buildSummary(sb, SUMMARY_REMEMBERED, true);
+            }
+            
+            // If it is seen (and not the primary), show the security type
+            String verboseSecurity = getVerboseSecurity();
+            if (verboseSecurity != null) {
+                buildSummary(sb, verboseSecurity, true);
+            }
+        }
+        
+        return sb.toString();
+    }
+    
+    private String getVerboseSecurity() {
+        if (WEP.equals(security)) {
+            return LOCALIZED_VERBOSE_WEP;
+        } else if (WPA.equals(security)) {
+            return LOCALIZED_VERBOSE_WPA;
+        } else if (WPA2.equals(security)) {
+            return LOCALIZED_VERBOSE_WPA2;
+        } else if (OPEN.equals(security)) {
+            return LOCALIZED_VERBOSE_OPEN;
+        } else {
+            return null;
+        }
+    }
+    
+    private void buildSummary(StringBuilder sb, String string, boolean autoLowerCaseFirstLetter) {
+        if (sb.length() == 0) {
+            sb.append(string);
+        } else {
+            sb.append(", ");
+            if (autoLowerCaseFirstLetter) {
+                // Convert first letter to lowercase
+                sb.append(Character.toLowerCase(string.charAt(0))).append(string, 1,
+                        string.length());
+            } else {
+                sb.append(string);
+            }
+        }
+    }
+    
+    public int compareTo(AccessPointState other) {
+        // This ranks the states for displaying in the AP list, not for
+        // connecting to (wpa_supplicant does that using the WifiConfiguration's
+        // priority field).
+        
+        // Clarity > efficiency, of this logic:
+        int comparison;
+        
+        // Primary
+        comparison = (other.primary ? 1 : 0) - (primary ? 1 : 0);
+        if (comparison != 0) return comparison;
+        
+        // Currently seen (similar to, but not always the same as within range)
+        comparison = (other.seen ? 1 : 0) - (seen ? 1 : 0);
+        if (comparison != 0) return comparison;
+
+        // Configured
+        comparison = (other.configured ? 1 : 0) - (configured ? 1 : 0);
+        if (comparison != 0) return comparison;
+
+        if (!configured) {
+            // Neither are configured
+
+            // Open network
+            comparison = (hasSecurity() ? 1 : 0) - (other.hasSecurity() ? 1 : 0);
+            if (comparison != 0) return comparison;
+        }
+
+        // Signal strength
+        comparison = (int) (other.signalForSorting - signalForSorting);
+        if (comparison != 0) return comparison;
+
+        // Alphabetical
+        return ssid.compareToIgnoreCase(other.ssid);
+    }
+
+    public String toString() {
+        return ssid + " (" + bssid + ", " + networkId + ", " + super.toString() + ")";
+    }
+    
+    /** Implement the Parcelable interface */
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeString(bssid);
+        dest.writeInt(configured ? 1 : 0);
+        dest.writeInt(ipAddress);
+        dest.writeInt(linkSpeed);
+        dest.writeInt(networkId);
+        dest.writeInt(primary ? 1 : 0);
+        dest.writeInt(priority);
+        dest.writeInt(hiddenSsid ? 1 : 0);
+        dest.writeString(security);
+        dest.writeInt(seen ? 1 : 0);
+        dest.writeInt(disabled ? 1 : 0);
+        dest.writeInt(signal);
+        dest.writeString(ssid);
+        dest.writeString(status != null ? status.toString() : null);
+        dest.writeString(mPassword);
+        dest.writeInt(mConfigHadPassword ? 1 : 0);
+        dest.writeInt(mWepPasswordType);
+    }
+
+    /** Implement the Parcelable interface */
+    public int describeContents() {
+        return 0;
+    }
+
+    /** Implement the Parcelable interface */
+    public static final Creator<AccessPointState> CREATOR =
+        new Creator<AccessPointState>() {
+            public AccessPointState createFromParcel(Parcel in) {
+                AccessPointState state = new AccessPointState();
+                state.bssid = in.readString();
+                state.configured = in.readInt() == 1;
+                state.ipAddress = in.readInt();
+                state.linkSpeed = in.readInt();
+                state.networkId = in.readInt();
+                state.primary = in.readInt() == 1;
+                state.priority = in.readInt();
+                state.hiddenSsid = in.readInt() == 1;
+                state.security = in.readString();
+                state.seen = in.readInt() == 1;
+                state.disabled = in.readInt() == 1;
+                state.signal = in.readInt();
+                state.ssid = in.readString();
+                String statusStr = in.readString();
+                if (statusStr != null) {
+                    state.status = NetworkInfo.DetailedState.valueOf(statusStr);
+                }
+                state.mPassword = in.readString();
+                state.mConfigHadPassword = in.readInt() == 1;
+                state.mWepPasswordType = in.readInt();
+                return state;
+            }
+
+            public AccessPointState[] newArray(int size) {
+                return new AccessPointState[size];
+            }
+        };
+
+        
+}
diff --git a/src/com/android/settings/wifi/AdvancedSettings.java b/src/com/android/settings/wifi/AdvancedSettings.java
new file mode 100644
index 0000000..323d5c7
--- /dev/null
+++ b/src/com/android/settings/wifi/AdvancedSettings.java
@@ -0,0 +1,274 @@
+/*
+ * Copyright (C) 2007 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.settings.wifi;
+
+import com.android.settings.R;
+
+import android.content.ContentResolver;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.EditTextPreference;
+import android.preference.ListPreference;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.provider.Settings;
+import android.provider.Settings.System;
+import android.text.TextUtils;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.widget.Toast;
+
+public class AdvancedSettings extends PreferenceActivity
+        implements Preference.OnPreferenceChangeListener {
+
+    private static final String KEY_MAC_ADDRESS = "mac_address";
+    private static final String KEY_USE_STATIC_IP = "use_static_ip";
+    private static final String KEY_NUM_CHANNELS = "num_channels";
+    private static final String KEY_SLEEP_POLICY = "sleep_policy";
+    
+    private String[] mSettingNames = {
+            System.WIFI_STATIC_IP, System.WIFI_STATIC_GATEWAY, System.WIFI_STATIC_NETMASK,
+            System.WIFI_STATIC_DNS1, System.WIFI_STATIC_DNS2
+    };
+    
+    private String[] mPreferenceKeys = {
+            "ip_address", "gateway", "netmask", "dns1", "dns2"
+    };
+    
+    private CheckBoxPreference mUseStaticIpCheckBox;
+    
+    private static final int MENU_ITEM_SAVE = Menu.FIRST;
+    private static final int MENU_ITEM_CANCEL = Menu.FIRST + 1;
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        
+        addPreferencesFromResource(R.xml.wifi_advanced_settings);
+        
+        mUseStaticIpCheckBox = (CheckBoxPreference) findPreference(KEY_USE_STATIC_IP);
+
+        for (int i = 0; i < mPreferenceKeys.length; i++) {
+            Preference preference = findPreference(mPreferenceKeys[i]);
+            preference.setOnPreferenceChangeListener(this);
+        }
+    }
+    
+    @Override
+    protected void onResume() {
+        super.onResume();
+        
+        updateUi();
+        initNumChannelsPreference();
+        initSleepPolicyPreference();
+        refreshMacAddress();
+    }
+
+    private void initNumChannelsPreference() {
+        ListPreference pref = (ListPreference) findPreference(KEY_NUM_CHANNELS);
+        pref.setOnPreferenceChangeListener(this);
+
+        WifiManager wifiManager = (WifiManager) getSystemService(WIFI_SERVICE);
+        /*
+         * Generate the list of valid channel counts to show in the ListPreference.
+         * The values are numerical, so the only text to be localized is the
+         * "channel_word" resource.
+         */
+        int[] validChannelCounts = wifiManager.getValidChannelCounts();
+        if (validChannelCounts == null) {
+            Toast.makeText(this, R.string.wifi_setting_num_channels_error,
+                           Toast.LENGTH_SHORT).show();
+            pref.setEnabled(false);
+            return;
+        }
+        String[] entries = new String[validChannelCounts.length];
+        String[] entryValues = new String[validChannelCounts.length];
+
+        for (int i = 0; i < validChannelCounts.length; i++) {
+            entryValues[i] = String.valueOf(validChannelCounts[i]);
+            entries[i] = getString(R.string.wifi_setting_num_channels_channel_phrase,
+                                   validChannelCounts[i]);
+        }
+        pref.setEntries(entries);
+        pref.setEntryValues(entryValues);
+        pref.setEnabled(true);
+        int numChannels = wifiManager.getNumAllowedChannels();
+        if (numChannels >= 0) {
+            pref.setValue(String.valueOf(numChannels));
+        }
+    }
+    
+    private void initSleepPolicyPreference() {
+        ListPreference pref = (ListPreference) findPreference(KEY_SLEEP_POLICY);
+        pref.setOnPreferenceChangeListener(this);
+        int value = Settings.System.getInt(getContentResolver(),
+                Settings.System.WIFI_SLEEP_POLICY,Settings. System.WIFI_SLEEP_POLICY_DEFAULT);
+        pref.setValue(String.valueOf(value));
+    }
+
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+    
+        if (keyCode == KeyEvent.KEYCODE_BACK) {
+            updateSettingsProvider();
+        }
+    
+        return super.onKeyDown(keyCode, event);
+    }
+
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        String key = preference.getKey();
+        if (key == null) return true;
+
+        if (key.equals(KEY_NUM_CHANNELS)) {
+            try {
+                int numChannels = Integer.parseInt((String) newValue);
+                WifiManager wifiManager = (WifiManager) getSystemService(WIFI_SERVICE);
+                if (!wifiManager.setNumAllowedChannels(numChannels)) {
+                    Toast.makeText(this, R.string.wifi_setting_num_channels_error,
+                            Toast.LENGTH_SHORT).show();
+                }
+            } catch (NumberFormatException e) {
+                Toast.makeText(this, R.string.wifi_setting_num_channels_error,
+                        Toast.LENGTH_SHORT).show();
+                return false;
+            }
+            
+        } else if (key.equals(KEY_SLEEP_POLICY)) {
+            try {
+                Settings.System.putInt(getContentResolver(),
+                        Settings.System.WIFI_SLEEP_POLICY, Integer.parseInt(((String) newValue)));
+            } catch (NumberFormatException e) {
+                Toast.makeText(this, R.string.wifi_setting_sleep_policy_error,
+                        Toast.LENGTH_SHORT).show();
+                return false;
+            }
+                
+        } else {
+            String value = (String) newValue;
+            
+            if (!isIpAddress(value)) {
+                Toast.makeText(this, R.string.wifi_ip_settings_invalid_ip, Toast.LENGTH_LONG).show();
+                return false;
+            }
+            
+            preference.setSummary(value);
+        }
+        
+        return true;
+    }
+
+    private boolean isIpAddress(String value) {
+        
+        int start = 0;
+        int end = value.indexOf('.');
+        int numBlocks = 0;
+        
+        while (start < value.length()) {
+            
+            if (end == -1) {
+                end = value.length();
+            }
+
+            try {
+                int block = Integer.parseInt(value.substring(start, end));
+                if ((block > 255) || (block < 0)) {
+                    return false;
+                }
+            } catch (NumberFormatException e) {
+                return false;
+            }
+            
+            numBlocks++;
+            
+            start = end + 1;
+            end = value.indexOf('.', start);
+        }
+        
+        return numBlocks == 4;
+    }
+    
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        
+        menu.add(0, MENU_ITEM_SAVE, 0, R.string.wifi_ip_settings_menu_save)
+                .setIcon(android.R.drawable.ic_menu_save);
+
+        menu.add(0, MENU_ITEM_CANCEL, 0, R.string.wifi_ip_settings_menu_cancel)
+                .setIcon(android.R.drawable.ic_menu_close_clear_cancel);
+
+        return super.onCreateOptionsMenu(menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+
+        switch (item.getItemId()) {
+        
+            case MENU_ITEM_SAVE:
+                updateSettingsProvider();
+                finish();
+                return true;
+                
+            case MENU_ITEM_CANCEL:
+                finish();
+                return true;
+        }
+        
+        return super.onOptionsItemSelected(item);
+    }
+
+    private void updateUi() {
+        ContentResolver contentResolver = getContentResolver();
+        
+        mUseStaticIpCheckBox.setChecked(System.getInt(contentResolver,
+                System.WIFI_USE_STATIC_IP, 0) != 0);
+        
+        for (int i = 0; i < mSettingNames.length; i++) {
+            EditTextPreference preference = (EditTextPreference) findPreference(mPreferenceKeys[i]);
+            String settingValue = System.getString(contentResolver, mSettingNames[i]);
+            preference.setText(settingValue);
+            preference.setSummary(settingValue);
+        }
+    }
+    
+    private void updateSettingsProvider() {
+        ContentResolver contentResolver = getContentResolver();
+
+        System.putInt(contentResolver, System.WIFI_USE_STATIC_IP,
+                mUseStaticIpCheckBox.isChecked() ? 1 : 0);
+        
+        for (int i = 0; i < mSettingNames.length; i++) {
+            EditTextPreference preference = (EditTextPreference) findPreference(mPreferenceKeys[i]);
+            System.putString(contentResolver, mSettingNames[i], preference.getText());
+        }
+    }
+    
+    private void refreshMacAddress() {
+        WifiManager wifiManager = (WifiManager) getSystemService(WIFI_SERVICE);
+        WifiInfo wifiInfo = wifiManager.getConnectionInfo();
+
+        Preference wifiMacAddressPref = findPreference(KEY_MAC_ADDRESS);
+        String macAddress = wifiInfo == null ? null : wifiInfo.getMacAddress();
+        wifiMacAddressPref.setSummary(!TextUtils.isEmpty(macAddress) ? macAddress 
+                : getString(R.string.status_unavailable));
+    }
+    
+}
diff --git a/src/com/android/settings/wifi/WifiEnabler.java b/src/com/android/settings/wifi/WifiEnabler.java
new file mode 100644
index 0000000..88cfe06
--- /dev/null
+++ b/src/com/android/settings/wifi/WifiEnabler.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2007 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.settings.wifi;
+
+import static android.net.wifi.WifiManager.WIFI_STATE_DISABLED;
+import static android.net.wifi.WifiManager.WIFI_STATE_DISABLING;
+import static android.net.wifi.WifiManager.WIFI_STATE_ENABLED;
+import static android.net.wifi.WifiManager.WIFI_STATE_ENABLING;
+import static android.net.wifi.WifiManager.WIFI_STATE_UNKNOWN;
+
+import com.android.settings.R;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.NetworkInfo;
+import android.net.wifi.WifiManager;
+import android.preference.Preference;
+import android.preference.CheckBoxPreference;
+import android.text.TextUtils;
+import android.util.Config;
+import android.util.Log;
+
+public class WifiEnabler implements Preference.OnPreferenceChangeListener {
+    
+    private static final boolean LOCAL_LOGD = Config.LOGD || WifiLayer.LOGV;
+    private static final String TAG = "SettingsWifiEnabler";
+    
+    private final Context mContext; 
+    private final WifiManager mWifiManager;
+    private final CheckBoxPreference mWifiCheckBoxPref;
+    private final CharSequence mOriginalSummary;
+    
+    private final IntentFilter mWifiStateFilter;
+    private final BroadcastReceiver mWifiStateReceiver = new BroadcastReceiver() {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (intent.getAction().equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
+                handleWifiStateChanged(
+                        intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, WIFI_STATE_UNKNOWN),
+                        intent.getIntExtra(WifiManager.EXTRA_PREVIOUS_WIFI_STATE,
+                                WIFI_STATE_UNKNOWN));
+            } else if (intent.getAction().equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
+                handleNetworkStateChanged(
+                        (NetworkInfo) intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO));
+            }
+        }
+    };
+    
+    public WifiEnabler(Context context, WifiManager wifiManager,
+            CheckBoxPreference wifiCheckBoxPreference) {
+        mContext = context;
+        mWifiCheckBoxPref = wifiCheckBoxPreference;
+        mWifiManager = wifiManager;
+        
+        mOriginalSummary = wifiCheckBoxPreference.getSummary();
+        wifiCheckBoxPreference.setPersistent(false);
+        
+        mWifiStateFilter = new IntentFilter(WifiManager.WIFI_STATE_CHANGED_ACTION);
+        mWifiStateFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
+    }
+
+    public void resume() {
+        int state = mWifiManager.getWifiState();
+        // This is the widget enabled state, not the preference toggled state
+        mWifiCheckBoxPref.setEnabled(state == WIFI_STATE_ENABLED || state == WIFI_STATE_DISABLED
+                || state == WIFI_STATE_UNKNOWN);
+
+        mContext.registerReceiver(mWifiStateReceiver, mWifiStateFilter);
+        mWifiCheckBoxPref.setOnPreferenceChangeListener(this);
+    }
+    
+    public void pause() {
+        mContext.unregisterReceiver(mWifiStateReceiver);
+        mWifiCheckBoxPref.setOnPreferenceChangeListener(null);
+    }
+    
+    public boolean onPreferenceChange(Preference preference, Object value) {
+        // Turn on/off Wi-Fi
+        setWifiEnabled((Boolean) value);
+        
+        // Don't update UI to opposite state until we're sure
+        return false;
+    }
+    
+    private void setWifiEnabled(final boolean enable) {
+        // Disable button
+        mWifiCheckBoxPref.setEnabled(false);
+        
+        if (!mWifiManager.setWifiEnabled(enable)) {
+            mWifiCheckBoxPref.setSummary(enable ? R.string.error_starting : R.string.error_stopping);
+        }
+    }
+    
+    private void handleWifiStateChanged(int wifiState, int previousWifiState) {
+
+        if (LOCAL_LOGD) {
+            Log.d(TAG, "Received wifi state changed from "
+                    + getHumanReadableWifiState(previousWifiState) + " to "
+                    + getHumanReadableWifiState(wifiState));
+        }
+        
+        if (wifiState == WIFI_STATE_DISABLED || wifiState == WIFI_STATE_ENABLED) {
+            mWifiCheckBoxPref.setChecked(wifiState == WIFI_STATE_ENABLED);
+            mWifiCheckBoxPref
+                    .setSummary(wifiState == WIFI_STATE_DISABLED ? mOriginalSummary : null);
+            
+            mWifiCheckBoxPref.setEnabled(isEnabledByDependency());
+            
+        } else if (wifiState == WIFI_STATE_DISABLING || wifiState == WIFI_STATE_ENABLING) {
+            mWifiCheckBoxPref.setSummary(wifiState == WIFI_STATE_ENABLING ? R.string.wifi_starting
+                    : R.string.wifi_stopping);
+            
+        } else if (wifiState == WIFI_STATE_UNKNOWN) {
+            int message = R.string.wifi_error;
+            if (previousWifiState == WIFI_STATE_ENABLING) message = R.string.error_starting;
+            else if (previousWifiState == WIFI_STATE_DISABLING) message = R.string.error_stopping;
+            
+            mWifiCheckBoxPref.setChecked(false);
+            mWifiCheckBoxPref.setSummary(message);
+            mWifiCheckBoxPref.setEnabled(true);
+        }
+    }
+
+    private void handleNetworkStateChanged(NetworkInfo networkInfo) {
+
+        if (LOCAL_LOGD) {
+            Log.d(TAG, "Received network state changed to " + networkInfo);
+        }
+        
+        if (mWifiManager.isWifiEnabled()) {
+            String summary = WifiStatus.getStatus(mContext, 
+                    mWifiManager.getConnectionInfo().getSSID(), networkInfo.getDetailedState());
+            mWifiCheckBoxPref.setSummary(summary);
+        }
+    }
+
+    private boolean isEnabledByDependency() {
+        Preference dep = getDependencyPreference();
+        if (dep == null) {
+            return true;
+        }
+        
+        return !dep.shouldDisableDependents();
+    }
+    
+    private Preference getDependencyPreference() {
+        String depKey = mWifiCheckBoxPref.getDependency();
+        if (TextUtils.isEmpty(depKey)) {
+            return null;
+        }
+        
+        return mWifiCheckBoxPref.getPreferenceManager().findPreference(depKey);
+    }
+    
+    private static String getHumanReadableWifiState(int wifiState) {
+        switch (wifiState) {
+            case WIFI_STATE_DISABLED:
+                return "Disabled";
+            case WIFI_STATE_DISABLING:
+                return "Disabling";
+            case WIFI_STATE_ENABLED:
+                return "Enabled";
+            case WIFI_STATE_ENABLING:
+                return "Enabling";
+            case WIFI_STATE_UNKNOWN:
+                return "Unknown";
+            default:
+                return "Some other state!";    
+        }
+    }
+}
diff --git a/src/com/android/settings/wifi/WifiLayer.java b/src/com/android/settings/wifi/WifiLayer.java
new file mode 100644
index 0000000..b0857d2
--- /dev/null
+++ b/src/com/android/settings/wifi/WifiLayer.java
@@ -0,0 +1,1302 @@
+/*
+ * Copyright (C) 2007 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.settings.wifi;
+
+import static android.net.wifi.WifiManager.WIFI_STATE_DISABLED;
+import static android.net.wifi.WifiManager.WIFI_STATE_ENABLED;
+
+import com.android.settings.R;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.NetworkInfo;
+import android.net.NetworkInfo.DetailedState;
+import android.net.NetworkInfo.State;
+import android.net.wifi.ScanResult;
+import android.net.wifi.SupplicantState;
+import android.net.wifi.WifiConfiguration;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.os.Handler;
+import android.os.Message;
+import android.provider.Settings;
+import android.text.TextUtils;
+import android.util.Config;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * Helper class for abstracting Wi-Fi.
+ * <p>
+ * Client must call {@link #onCreate()}, {@link #onCreatedCallback()},
+ * {@link #onPause()}, {@link #onResume()}.
+ */
+public class WifiLayer {
+    
+    private static final String TAG = "SettingsWifiLayer";
+    static final boolean LOGV = false || Config.LOGV;
+    
+    //============================
+    // Other member variables
+    //============================
+    
+    private Context mContext;
+    private Callback mCallback;
+
+    static final int MESSAGE_ATTEMPT_SCAN = 1;
+    private Handler mHandler = new MyHandler();
+    
+    //============================
+    // Wifi member variables
+    //============================
+    
+    private WifiManager mWifiManager;
+    private IntentFilter mIntentFilter;
+    private List<AccessPointState> mApScanList = new ArrayList<AccessPointState>();
+    private List<AccessPointState> mApOtherList = new ArrayList<AccessPointState>();
+    private AccessPointState mCurrentPrimaryAp;
+    
+    /** The last access point that we were authenticating with. */
+    private AccessPointState mLastAuthenticatingAp;
+    
+    /** The delay between scans when we're continually scanning. */
+    private static final int CONTINUOUS_SCAN_DELAY_MS = 6000; 
+    /** On failure, the maximum retries for scanning. */
+    private static final int SCAN_MAX_RETRY = 5;
+    /** On failure, the delay between each scan retry. */
+    private static final int SCAN_RETRY_DELAY_MS = 1000;
+    /** On failure, the number of retries so far. */
+    private int mScanRetryCount = 0;
+    /**
+     * Whether we're currently obtaining an address. Continuous scanning will be
+     * disabled in this state.
+     */
+    private boolean mIsObtainingAddress;
+
+    /**
+     * See {@link android.provider.Settings.Secure#WIFI_NUM_OPEN_NETWORKS_KEPT}.
+     */
+    private int WIFI_NUM_OPEN_NETWORKS_KEPT;
+    /**
+     * Once the highest priority exceeds this value, all networks will be
+     * wrapped around starting at 0. This is so another client of the Wi-Fi
+     * API can have access points that aren't managed by us. (If the other
+     * client wants lower-priority access points than ours, it can use negative
+     * priority.)
+     */
+    private static final int HIGHEST_PRIORITY_MAX_VALUE = 99999;
+    /**
+     * Never access directly, only the related methods should.
+     */
+    private int mNextHighestPriority;
+    
+    /**
+     * This is used to track when the user wants to connect to a specific AP. We
+     * disable all other APs, set this to true, and let wpa_supplicant connect.
+     * Once we get a network state change, we re-enable the rest of them.
+     */
+    private boolean mReenableApsOnNetworkStateChange = false;
+
+    /**
+     * The current supplicant state, as broadcasted.
+     */
+    private SupplicantState mCurrentSupplicantState;
+    
+    //============================
+    // Inner classes
+    //============================
+    
+    interface Callback {
+        void onError(int messageResId);
+        
+        /**
+         * Called when an AP is added or removed.
+         * 
+         * @param ap The AP.
+         * @param added {@code true} if added, {@code false} if removed.
+         */
+        void onAccessPointSetChanged(AccessPointState ap, boolean added);
+        
+        /**
+         * Called when the scanning status changes.
+         * 
+         * @param started {@code true} if the scanning just started,
+         *            {@code false} if it just ended.
+         */
+        void onScanningStatusChanged(boolean started);
+
+        /**
+         * Called when the access points should be enabled or disabled. This is
+         * called from both wpa_supplicant being connected/disconnected and Wi-Fi
+         * being enabled/disabled.
+         * 
+         * @param enabled {@code true} if they should be enabled, {@code false}
+         *            if they should be disabled.
+         */
+        void onAccessPointsStateChanged(boolean enabled);   
+        
+        /**
+         * Called when there is trouble authenticating and the retry-password
+         * dialog should be shown.
+         * 
+         * @param ap The access point.
+         */
+        void onRetryPassword(AccessPointState ap);
+    }
+    
+    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            final String action = intent.getAction();
+            if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
+                handleNetworkStateChanged(
+                        (NetworkInfo) intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO),
+                        intent.getStringExtra(WifiManager.EXTRA_BSSID));
+            } else if (action.equals(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) {
+                handleScanResultsAvailable();
+            } else if (action.equals(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION)) {
+                handleSupplicantConnectionChanged(
+                        intent.getBooleanExtra(WifiManager.EXTRA_SUPPLICANT_CONNECTED, false));
+            } else if (action.equals(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION)) {
+                handleSupplicantStateChanged(
+                        (SupplicantState) intent.getParcelableExtra(WifiManager.EXTRA_NEW_STATE),
+                        intent.hasExtra(WifiManager.EXTRA_SUPPLICANT_ERROR),
+                        intent.getIntExtra(WifiManager.EXTRA_SUPPLICANT_ERROR, 0));
+            } else if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
+                handleWifiStateChanged(intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
+                        WifiManager.WIFI_STATE_UNKNOWN));
+            } else if (action.equals(WifiManager.RSSI_CHANGED_ACTION)) {
+                handleSignalChanged(intent.getIntExtra(WifiManager.EXTRA_NEW_RSSI, 0));
+            } else if (action.equals(WifiManager.NETWORK_IDS_CHANGED_ACTION)) {
+                handleNetworkIdsChanged();
+            }
+        }
+    };
+    
+    /**
+     * If using this class, make sure to call the callbacks of this class, such
+     * as {@link #onCreate()}, {@link #onCreatedCallback()},
+     * {@link #onPause()}, {@link #onResume()}.
+     * 
+     * @param context The context.
+     * @param callback The interface that will be invoked when events from this
+     *            class are generated.
+     */
+    public WifiLayer(Context context, Callback callback) {
+        mContext = context;
+        mCallback = callback;
+    }
+    
+    //============================
+    // Lifecycle
+    //============================
+
+    /**
+     * The client MUST call this.
+     * <p>
+     * This shouldn't have any dependency on the callback.
+     */
+    public void onCreate() {
+        mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
+        
+        mIntentFilter = new IntentFilter();
+        mIntentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
+        mIntentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
+        mIntentFilter.addAction(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION);
+        mIntentFilter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
+        mIntentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
+        mIntentFilter.addAction(WifiManager.RSSI_CHANGED_ACTION);
+        mIntentFilter.addAction(WifiManager.NETWORK_IDS_CHANGED_ACTION);
+        
+        WIFI_NUM_OPEN_NETWORKS_KEPT = Settings.Secure.getInt(mContext.getContentResolver(),
+            Settings.Secure.WIFI_NUM_OPEN_NETWORKS_KEPT, 10);
+    }
+    
+    /**
+     * The client MUST call this.
+     * <p>
+     * Callback is ready, this can do whatever it wants with it.
+     */
+    public void onCreatedCallback() {
+        if (isWifiEnabled()) {
+            refreshAll(false);
+        }
+    }
+    
+    /**
+     * The client MUST call this.
+     * 
+     * @see android.app.Activity#onResume
+     */
+    public void onResume() {
+        mContext.registerReceiver(mReceiver, mIntentFilter);
+        
+        if (isWifiEnabled()) {
+            // Kick start the continual scan
+            queueContinuousScan();
+        }
+    }
+
+    /**
+     * The client MUST call this.
+     * 
+     * @see android.app.Activity#onPause
+     */
+    public void onPause() {
+        mContext.unregisterReceiver(mReceiver);
+        
+        attemptReenableAllAps();
+        
+        removeFutureScans();
+    }
+    
+    //============================
+    // "Public" API
+    //============================
+
+    /**
+     * Returns an AccessPointState instance (that we track locally in WifiLayer)
+     * for the given state. First, we check if we track the given instance. If
+     * not, we find an equal AccessPointState instance that we track.
+     * 
+     * @param state An AccessPointState instance that does not necessarily have
+     *            to be one that this WifiLayer class tracks. For example, it
+     *            could be the result of unparceling.
+     * @return An AccessPointState instance that this WifiLayer class tracks.
+     */
+    public AccessPointState getWifiLayerApInstance(AccessPointState state) {
+        synchronized (this) {
+            
+            if (hasApInstanceLocked(state)) {
+                return state;
+            }
+            
+            return findApLocked(state.networkId, state.bssid, state.ssid, state.security);
+        }
+    }
+    
+    /**
+     * Connects to the network, and creates the Wi-Fi API config if necessary.
+     * 
+     * @param state The state of the network to connect to. This MUST be an
+     *            instance that was given to you by this class. If you
+     *            constructed the instance yourself (for example, after
+     *            unparceling it), you should use
+     *            {@link #getWifiLayerApInstance(AccessPointState)}.
+     * @return Whether the operation was successful.
+     */
+    public boolean connectToNetwork(AccessPointState state) {
+        if (LOGV) {
+            Log.v(TAG, "Connecting to " + state);
+        }
+        
+        // Need WifiConfiguration for the AP
+        WifiConfiguration config = findConfiguredNetwork(state);
+
+        if (LOGV) {
+            Log.v(TAG, " Found configured network " + config);
+        }
+        
+        if (config == null) {
+            /*
+             * Connecting for the first time, need to create it. We will enable
+             * and save it below (when we set priority).
+             */
+            config = addConfiguration(state, 0);
+
+            if (config == null) {
+                Log.e(TAG, "Config is still null, even after attempting to add it.");
+                error(R.string.error_connecting);
+                return false;
+            }
+
+            /*
+             * We could reload the configured networks, but instead just
+             * shortcut and add this state to our list in memory.
+             */
+            ensureTrackingState(state);
+        } else {
+            // Make sure the configuration has the latest from the state
+            state.updateWifiConfiguration(config);
+        }
+
+        // Enable this network before we save to storage
+        if (!managerEnableNetwork(state, false)) {
+            Log.e(TAG, "Could not enable network ID " + state.networkId);
+            error(R.string.error_connecting);
+            return false;
+        }
+        
+        /*
+         * Give it highest priority, this could cause a network ID change, so do
+         * it after any modifications to the network we're connecting to
+         */
+        setHighestPriorityStateAndSave(state, config);
+        
+        /*
+         * We force supplicant to connect to this network by disabling the
+         * others. We do this AFTER we save above so this disabled flag isn't
+         * persisted.
+         */
+        mReenableApsOnNetworkStateChange = true;
+        if (!managerEnableNetwork(state, true)) {
+            Log.e(TAG, "Could not enable network ID " + state.networkId);
+            error(R.string.error_connecting);
+            return false;
+        }
+
+        if (LOGV) {
+            Log.v(TAG, " Enabled network " + state.networkId);
+        }
+
+        if (mCurrentSupplicantState == SupplicantState.DISCONNECTED ||
+                mCurrentSupplicantState == SupplicantState.SCANNING) {
+            mWifiManager.reconnect();
+        }
+        
+        // Check for too many configured open networks
+        if (!state.hasSecurity()) {
+            checkForExcessOpenNetworks();
+        }
+        
+        return true;
+    }
+    
+    /**
+     * Saves a network, and creates the Wi-Fi API config if necessary.
+     * 
+     * @param state The state of the network to save. If you constructed the
+     *            instance yourself (for example, after unparceling it), you
+     *            should use {@link #getWifiLayerApInstance(AccessPointState)}.
+     * @return Whether the operation was successful.
+     */
+    public boolean saveNetwork(AccessPointState state) {
+        WifiConfiguration config = findConfiguredNetwork(state);
+        
+        if (config == null) {
+            // if the user is adding a new network, assume that it is hidden
+            state.setHiddenSsid(true);
+
+            config = addConfiguration(state, ADD_CONFIGURATION_ENABLE);
+
+            if (config == null) {
+                Log.e(TAG, "Could not save configuration, call to addConfiguration failed.");
+                error(R.string.error_saving);
+                return false;
+            }
+            
+        } else {
+            state.updateWifiConfiguration(config);
+            if (mWifiManager.updateNetwork(config) == -1) {
+                Log.e(TAG, "Could not update configuration, call to WifiManager failed.");
+                error(R.string.error_saving);
+                return false;
+            }
+        }
+        
+        // Successfully added network, go ahead and persist
+        if (!managerSaveConfiguration()) {
+            Log.e(TAG, "Could not save configuration, call to WifiManager failed.");
+            error(R.string.error_saving);
+            return false;
+        }
+        
+        /*
+         * We could reload the configured networks, but instead just shortcut
+         * and add this state to our list in memory
+         */
+        ensureTrackingState(state);
+        
+        return true;
+    }
+    
+    /**
+     * Forgets a network.
+     * 
+     * @param state The state of the network to forget. If you constructed the
+     *            instance yourself (for example, after unparceling it), you
+     *            should use {@link #getWifiLayerApInstance(AccessPointState)}.
+     * @return Whether the operation was succesful.
+     */
+    public boolean forgetNetwork(AccessPointState state) {
+        if (!state.configured) {
+            Log.w(TAG, "Inconsistent state:  Forgetting a network that is not configured.");
+            return true;
+        }
+        
+        int oldNetworkId = state.networkId;
+        state.forget();
+        
+        if (!state.seen) {
+            // If it is not seen, it should be removed from the UI
+            removeApFromUi(state);
+        }
+                    
+        synchronized (this) {
+            mApOtherList.remove(state);
+            // It should not be removed from the scan list, since if it was
+            // there that means it's still seen
+        }
+
+        if (!mWifiManager.removeNetwork(oldNetworkId)) {
+            Log.e(TAG, "Removing network " + state.ssid + " (network ID " + oldNetworkId +
+                    ") failed.");
+            return false;
+        }
+        
+        if (!managerSaveConfiguration()) {
+            error(R.string.error_saving);
+            return false;
+        }
+
+        return true;
+    }
+    
+    /**
+     * This ensures this class is tracking the given state. This means it is in
+     * our list of access points, either in the scanned list or in the
+     * remembered list.
+     * 
+     * @param state The state that will be checked for tracking, and if not
+     *            tracking will be added to the remembered list in memory.
+     */
+    private void ensureTrackingState(AccessPointState state) {
+        synchronized (this) {
+            if (hasApInstanceLocked(state)) {
+                return;
+            }
+            
+            mApOtherList.add(state);
+        }
+    }
+    
+    /**
+     * Attempts to scan networks.  This has a retry mechanism.
+     */
+    public void attemptScan() {
+        
+        // Remove any future scans since we're scanning right now
+        removeFutureScans();
+        
+        if (!mWifiManager.isWifiEnabled()) return;
+        
+        if (!mWifiManager.startScan()) {
+            postAttemptScan();
+        } else {
+            mScanRetryCount = 0;
+        }
+    }
+
+    private void queueContinuousScan() {
+        mHandler.removeMessages(MESSAGE_ATTEMPT_SCAN);
+        
+        if (!mIsObtainingAddress) {
+            // Don't do continuous scan while in obtaining IP state
+            mHandler.sendEmptyMessageDelayed(MESSAGE_ATTEMPT_SCAN, CONTINUOUS_SCAN_DELAY_MS);
+        }
+    }
+    
+    private void removeFutureScans() {
+        mHandler.removeMessages(MESSAGE_ATTEMPT_SCAN);
+    }
+    
+    public boolean isWifiEnabled() {
+        return mWifiManager.isWifiEnabled();
+    }
+    
+    public void error(int messageResId) {
+        Log.e(TAG, mContext.getResources().getString(messageResId));
+        
+        if (mCallback != null) {
+            mCallback.onError(messageResId);
+        }
+    }
+    
+    //============================
+    // Wifi logic
+    //============================
+
+    private void refreshAll(boolean attemptScan) {
+        loadConfiguredAccessPoints();
+        refreshStatus();
+        
+        if (attemptScan) {
+            attemptScan();
+        }
+    }
+    
+    private void postAttemptScan() {
+        onScanningStarted();
+
+        if (++mScanRetryCount < SCAN_MAX_RETRY) {
+            // Just in case, remove previous ones first
+            removeFutureScans();
+            mHandler.sendEmptyMessageDelayed(MESSAGE_ATTEMPT_SCAN, SCAN_RETRY_DELAY_MS);
+        } else {
+            // Show an error once we run out of attempts
+            error(R.string.error_scanning);
+            onScanningEnded();
+        }
+    }
+    
+    private void onScanningStarted() {
+        if (mCallback != null) {
+            mCallback.onScanningStatusChanged(true);
+        }
+    }
+    
+    private void onScanningEnded() {
+        queueContinuousScan();
+        
+        if (mCallback != null) {
+            mCallback.onScanningStatusChanged(false);
+        }
+    }
+    
+    private void clearApLists() {
+        List<AccessPointState> accessPoints = new ArrayList<AccessPointState>();
+        
+        synchronized(this) {
+            // Clear the logic's list of access points
+            accessPoints.addAll(mApScanList);
+            accessPoints.addAll(mApOtherList);
+            mApScanList.clear();
+            mApOtherList.clear();
+        }
+        
+        for (int i = accessPoints.size() - 1; i >= 0; i--) {
+            removeApFromUi(accessPoints.get(i));
+        }
+    }
+    
+    private boolean managerSaveConfiguration() {
+        boolean retValue = mWifiManager.saveConfiguration();
+        
+        /*
+         * We need to assume the network IDs have changed, so handle this. Note:
+         * we also have a receiver on the broadcast intent in case another wifi
+         * framework client caused the change. In this case, we will handle the
+         * possible network ID change twice (but it's not too costly).
+         */
+        handleNetworkIdsChanged();
+        
+        return retValue;
+    }
+    
+    private boolean managerEnableNetwork(AccessPointState state, boolean disableOthers) {
+        if (!mWifiManager.enableNetwork(state.networkId, disableOthers)) {
+            return false;
+        }
+        
+        // Enabling was successful, make sure the state is not disabled
+        state.setDisabled(false);
+        
+        return true;
+    }
+    
+    private static final int ADD_CONFIGURATION_ENABLE = 1;
+    private static final int ADD_CONFIGURATION_SAVE = 2;
+    private WifiConfiguration addConfiguration(AccessPointState state, int flags) {
+        // Create and add
+        WifiConfiguration config = new WifiConfiguration();
+        
+        state.updateWifiConfiguration(config);
+        
+        final int networkId = mWifiManager.addNetwork(config);
+        if (networkId == -1) {
+            return null;
+        }
+        
+        state.setNetworkId(networkId);
+        state.setConfigured(true);
+        
+        // If we should, then enable it, since it comes disabled by default
+        if ((flags & ADD_CONFIGURATION_ENABLE) != 0
+                && !managerEnableNetwork(state, false)) {
+            return null;
+        }
+
+        // If we should, then save it
+        if ((flags & ADD_CONFIGURATION_SAVE) != 0 && !managerSaveConfiguration()) {
+            return null;
+        }
+
+        if (mCallback != null) {
+            mCallback.onAccessPointSetChanged(state, true);
+        }
+
+        return config;
+    }
+    
+    private WifiConfiguration findConfiguredNetwork(AccessPointState state) {
+        final List<WifiConfiguration> wifiConfigs = getConfiguredNetworks();
+        
+        for (int i = wifiConfigs.size() - 1; i >= 0; i--) {
+            final WifiConfiguration wifiConfig = wifiConfigs.get(i); 
+            if (state.matchesWifiConfiguration(wifiConfig) >= AccessPointState.MATCH_WEAK) {
+                return wifiConfig;
+            }
+        }
+        
+        return null;
+    }
+    
+    private List<WifiConfiguration> getConfiguredNetworks() {
+        final List<WifiConfiguration> wifiConfigs = mWifiManager.getConfiguredNetworks();
+        return wifiConfigs;
+    }
+    
+    /**
+     * Must call while holding the lock for the list, which is usually the
+     * WifiLayer instance.
+     */
+    private static AccessPointState findApLocked(List<AccessPointState> list, int networkId,
+            String bssid, String ssid, String security) {
+        AccessPointState ap;
+        for (int i = list.size() - 1; i >= 0; i--) {
+            ap = list.get(i);
+            if (ap.matches(networkId, bssid, ssid, security) >= AccessPointState.MATCH_WEAK) {
+                return ap;
+            }
+        }
+
+        return null;
+    }
+    
+    /**
+     * Must call while holding the lock for the lists, which is usually this
+     * WifiLayer instance.
+     */
+    private AccessPointState findApLocked(int networkId, String bssid, String ssid,
+            String security) {
+        AccessPointState ap = findApLocked(mApScanList, networkId, bssid, ssid, security);
+        if (ap == null) {
+            ap = findApLocked(mApOtherList, networkId, bssid, ssid, security);
+        }
+        return ap;
+    }
+
+    /**
+     * Returns whether we have the exact instance of the access point state
+     * given. This is useful in cases where an AccessPointState has been
+     * parceled by the client and the client is attempting to use it to
+     * connect/forget/save.
+     * <p>
+     * Must call while holding the lock for the lists, which is usually this
+     * WifiLayer instance.
+     */
+    private boolean hasApInstanceLocked(AccessPointState state) {
+        
+        for (int i = mApScanList.size() - 1; i >= 0; i--) {
+            if (mApScanList.get(i) == state) {
+                return true;
+            }
+        }
+
+        for (int i = mApOtherList.size() - 1; i >= 0; i--) {
+            if (mApOtherList.get(i) == state) {
+                return true;
+            }
+        }
+        
+        return false;
+    }
+    
+    private void loadConfiguredAccessPoints() {
+        final List<WifiConfiguration> configs = getConfiguredNetworks();
+        
+        for (int i = configs.size() - 1; i >= 0; i--) {
+            final WifiConfiguration config = configs.get(i);
+            
+            AccessPointState ap;
+            synchronized(this) {
+                ap = findApLocked(config.networkId, config.BSSID, config.SSID,
+                        AccessPointState.getWifiConfigurationSecurity(config));
+                
+                if (ap != null) {
+                    // We already know about this one
+                    continue;
+                }
+    
+                ap = new AccessPointState(mContext);
+                ap.updateFromWifiConfiguration(config);
+                if (LOGV) Log.v(TAG, "Created " + ap + " in loadConfiguredAccessPoints");
+                mApOtherList.add(ap);
+            }
+
+            // Make sure our next highest priority is greater than this
+            checkNextHighestPriority(ap.priority);
+            
+            if (mCallback != null) {
+                mCallback.onAccessPointSetChanged(ap, true);
+            }
+        }
+    }
+
+    private AccessPointState getCurrentAp() {
+        final WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
+        
+        String ssid = wifiInfo.getSSID();
+        if (ssid != null) {
+            /*
+             * We pass null for security since we have a network ID (i.e., it's
+             * not a wildcard), and rely on it matching.
+             */
+            return findApLocked(wifiInfo.getNetworkId(), wifiInfo.getBSSID(), ssid, null);
+        } else {
+            return null;
+        }
+    }
+    
+    private void setPrimaryAp(AccessPointState ap) {
+        synchronized (this) {
+            // Unset other
+            if (mCurrentPrimaryAp != null) {
+                mCurrentPrimaryAp.setPrimary(false);
+            }
+
+            mCurrentPrimaryAp = ap;
+        }
+
+        if (ap != null) {
+            ap.setPrimary(true);
+        }
+    }
+
+    private void attemptReenableAllAps() {
+        if (mReenableApsOnNetworkStateChange) {
+            mReenableApsOnNetworkStateChange = false;
+            enableAllAps();
+        }
+    }
+    
+    private void enableAllAps() {
+        synchronized(this) {
+            if (LOGV) {
+                Log.v(TAG, " Enabling all APs");
+            }
+            
+            enableApsLocked(mApOtherList);
+            enableApsLocked(mApScanList);
+        }
+    }
+    
+    private void enableApsLocked(List<AccessPointState> apList) {
+        for (int i = apList.size() - 1; i >= 0; i--) {
+            AccessPointState state = apList.get(i);
+            int networkId = state.networkId;
+            if (networkId != AccessPointState.NETWORK_ID_NOT_SET &&
+                    networkId != AccessPointState.NETWORK_ID_ANY) {
+                managerEnableNetwork(state, false);
+            }
+        }
+    }
+    
+    private void removeApFromUi(AccessPointState ap) {
+        if (mCallback != null) {
+            mCallback.onAccessPointSetChanged(ap, false);
+        }
+    }
+    
+    /**
+     * Sets the access point state to the highest priority.
+     * <p>
+     * If you have a list of configured networks from WifiManager, you probably
+     * shouldn't call this until you're done traversing the list.
+     * 
+     * @param state The state to set as the highest priority.
+     * @param reusableConfiguration An optional WifiConfiguration that will be
+     *            given to the WifiManager as updated data for the network ID.
+     *            This will be filled with the new priority.
+     * @return Whether the operation was successful.
+     */
+    private boolean setHighestPriorityStateAndSave(AccessPointState state,
+            WifiConfiguration reusableConfiguration) {
+
+        if (!isConsideredForHighestPriority(state)) {
+            Log.e(TAG,
+                    "Could not set highest priority on state because state is not being considered.");
+            return false;
+        }
+        
+        if (reusableConfiguration == null) {
+            reusableConfiguration = new WifiConfiguration();
+        }
+        
+        int oldPriority = reusableConfiguration.priority;
+        reusableConfiguration.priority = getNextHighestPriority();
+        reusableConfiguration.networkId = state.networkId;
+        
+        if (mWifiManager.updateNetwork(reusableConfiguration) == -1) {
+            // Rollback priority
+            reusableConfiguration.priority = oldPriority;
+            Log.e(TAG,
+                    "Could not set highest priority on state because updating the supplicant network failed.");
+            return false;
+        }
+
+        if (!managerSaveConfiguration()) {
+            reusableConfiguration.priority = oldPriority;
+            Log.e(TAG,
+                    "Could not set highest priority on state because saving config failed.");
+            return false;
+        }
+        
+        state.priority = reusableConfiguration.priority;
+        
+        if (LOGV) {
+            Log.v(TAG, " Set highest priority to "
+                    + state.priority + " from " + oldPriority);
+        }
+        
+        return true;
+    }
+
+    /**
+     * Makes sure the next highest priority is larger than the given priority.
+     */
+    private void checkNextHighestPriority(int priority) {
+        if (priority > HIGHEST_PRIORITY_MAX_VALUE || priority < 0) {
+            // This is a priority that we aren't managing
+            return;
+        }
+        
+        if (mNextHighestPriority <= priority) {
+            mNextHighestPriority = priority + 1;
+        }
+    }
+
+    /**
+     * Checks if there are too many open networks, and removes the excess ones.
+     */
+    private void checkForExcessOpenNetworks() {
+        synchronized(this) {
+            ArrayList<AccessPointState> allAps = getApsSortedByPriorityLocked();
+
+            // Walk from highest to lowest priority
+            int openConfiguredCount = 0;
+            for (int i = allAps.size() - 1; i >= 0; i--) {
+                AccessPointState state = allAps.get(i);
+                if (state.configured && !state.hasSecurity()) {
+                    openConfiguredCount++;
+                    if (openConfiguredCount > WIFI_NUM_OPEN_NETWORKS_KEPT) {
+                        // Remove this network
+                        forgetNetwork(state);
+                    }
+                }
+            }
+        }
+    }
+    
+    private boolean isConsideredForHighestPriority(AccessPointState state) {
+        return state.configured && state.networkId != AccessPointState.NETWORK_ID_ANY &&
+                state.networkId != AccessPointState.NETWORK_ID_NOT_SET;
+    }
+    
+    /**
+     * Gets the next highest priority. If this value is larger than the max,
+     * shift all the priorities so the lowest starts at 0.
+     * <p>
+     * Only
+     * {@link #setHighestPriorityStateAndSave(AccessPointState, WifiConfiguration)}
+     * should call this.
+     * 
+     * @return The next highest priority to use.
+     */
+    private int getNextHighestPriority() {
+        if (mNextHighestPriority > HIGHEST_PRIORITY_MAX_VALUE) {
+            shiftPriorities();
+        }
+        
+        return mNextHighestPriority++;
+    }
+
+    /**
+     * Shift all the priorities so the lowest starts at 0.
+     * 
+     * @return Whether the operation was successful.
+     */
+    private boolean shiftPriorities() {
+        synchronized(this) {
+
+            ArrayList<AccessPointState> allAps = getApsSortedByPriorityLocked();
+
+            // Re-usable WifiConfiguration for setting priority
+            WifiConfiguration updatePriorityConfig = new WifiConfiguration();
+            
+            // Set new priorities
+            mNextHighestPriority = 0;
+            int size = allAps.size();
+            for (int i = 0; i < size; i++) {
+                AccessPointState state = allAps.get(i);
+                
+                if (!isConsideredForHighestPriority(state)) {
+                    continue;
+                }
+                
+                if (!setHighestPriorityStateAndSave(state, updatePriorityConfig)) {
+                    Log.e(TAG,
+                            "Could not shift priorities because setting the new priority failed.");
+                    return false;
+                }
+            }
+            
+            return true;
+        }
+    }
+
+    private ArrayList<AccessPointState> getApsSortedByPriorityLocked() {
+        // Get all of the access points we have
+        ArrayList<AccessPointState> allAps = new ArrayList<AccessPointState>(mApScanList.size()
+                + mApOtherList.size());
+        allAps.addAll(mApScanList);
+        allAps.addAll(mApOtherList);
+        
+        // Sort them based on priority
+        Collections.sort(allAps, new Comparator<AccessPointState>() {
+            public int compare(AccessPointState object1, AccessPointState object2) {
+                return object1.priority - object2.priority;
+            }
+        });
+
+        return allAps;
+    }
+    
+    //============================
+    // Status related
+    //============================
+
+    private void refreshStatus() {
+        refreshStatus(null, null);
+    }
+    
+    private void refreshStatus(AccessPointState ap, NetworkInfo.DetailedState detailedState) {
+        final WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
+        if (detailedState == null) {
+            detailedState = WifiInfo.getDetailedStateOf(wifiInfo.getSupplicantState());
+        }
+
+        if (ap == null && WifiStatus.isLiveConnection(detailedState)) {
+            /*
+             * We pass null for security since we have a network ID (i.e., it's
+             * not a wildcard), and rely on it matching.
+             */
+            ap = findApLocked(wifiInfo.getNetworkId(), wifiInfo.getBSSID(), wifiInfo
+                    .getSSID(), null);
+        }
+
+        if (ap != null) {
+            ap.blockRefresh();
+
+            // Let the AP get the latest info from the WifiInfo 
+            ap.updateFromWifiInfo(wifiInfo, detailedState);
+
+            // The detailed state from the Intent has more states than the WifiInfo's detailed
+            // state can have (for example, DHCP completion).  Set the status using
+            // the Intent's detailed state.
+            ap.setStatus(detailedState);
+            ap.unblockRefresh();
+        }
+    }
+    
+    //============================
+    // Wifi callbacks
+    //============================
+    
+    private void handleNetworkStateChanged(NetworkInfo info, String bssid) {
+        final AccessPointState ap = getCurrentAp();
+        NetworkInfo.DetailedState detailedState = info.getDetailedState(); 
+
+        if (LOGV) {
+            Log.v(TAG, "State change received " + info.toString() + ", or "
+                    + detailedState + " on " + bssid + " matched to " + ap);
+        }
+
+        handleDisablingScanWhileObtainingAddress(detailedState);
+        
+        // This will update the AP with its new info
+        refreshStatus(ap, detailedState);
+        
+        boolean isDisconnected = info.getState().equals(State.DISCONNECTED);
+        if (ap != null && info.isConnectedOrConnecting()) {
+            setPrimaryAp(ap);
+
+            if (LOGV) {
+                Log.v(TAG, " Updated " + ap + " to be primary");
+            }
+            
+        } else if (isDisconnected) {
+            
+            /*
+             * When we drop off a network (for example, the router is powered
+             * down when we were connected), we received a DISCONNECT event
+             * without a BSSID. We should not have a primary AP anymore.
+             */
+            setPrimaryAp(null);
+            
+            if (LOGV) {
+                Log.v(TAG, " Cleared primary");
+            }
+            
+        } else if (detailedState.equals(DetailedState.FAILED)) {
+
+            /*
+             * Doh, failed for whatever reason. Unset the primary AP, but set
+             * failed status on the AP that failed.
+             */
+            setPrimaryAp(null);
+            ap.setStatus(DetailedState.FAILED);
+            
+            // Bring up error dialog
+            error(R.string.wifi_generic_connection_error);
+            
+        } else if (LOGV) {
+            Log.v(TAG, " Did not update any AP to primary, could have updated "
+                    + ap + " but we aren't connected or connecting");
+        }
+
+        if ((ap != null) && (info.isConnected()
+                    || (detailedState == DetailedState.OBTAINING_IPADDR))) {
+            /*
+             * Sometimes the scan results do not contain the AP even though it's
+             * clearly connected. This may be because we do passive background
+             * scanning that isn't as 'strong' as active scanning, so even
+             * though a network is nearby, it won't be seen by the passive
+             * scanning. If we are connected (or obtaining IP) then we know it
+             * is seen.
+             */
+            ap.setSeen(true);
+        }
+
+        attemptReenableAllAps();
+    }
+
+    private void handleDisablingScanWhileObtainingAddress(DetailedState detailedState) {
+        
+        if (detailedState == DetailedState.OBTAINING_IPADDR) {
+            mIsObtainingAddress = true;
+
+            // We will not scan while obtaining an IP address
+            removeFutureScans();
+            
+        } else {
+            mIsObtainingAddress = false;
+            
+            // Start continuous scan
+            queueContinuousScan();
+        }
+    }
+    
+    private void handleScanResultsAvailable() {
+        synchronized(this) {
+            // In the end, we'll moved the ones no longer seen into the mApOtherList
+            List<AccessPointState> oldScanList = mApScanList;
+            List<AccessPointState> newScanList =
+                    new ArrayList<AccessPointState>(oldScanList.size());
+
+            List<ScanResult> list = mWifiManager.getScanResults();
+            if (list != null) {
+                for (int i = list.size() - 1; i >= 0; i--) {
+                    final ScanResult scanResult = list.get(i);
+                    
+                    if (LOGV) {
+//                        Log.v(TAG, "    " + scanResult);
+                    }
+                    
+                    if (scanResult == null) {
+                        continue;
+                    }
+                    
+                    /*
+                     * Ignore adhoc, enterprise-secured, or hidden networks.
+                     * Hidden networks show up with empty SSID.
+                     */
+                    if (AccessPointState.isAdhoc(scanResult)
+                            || AccessPointState.isEnterprise(scanResult)
+                            || TextUtils.isEmpty(scanResult.SSID)) {
+                        continue;
+                    }
+                    
+                    final String ssid = AccessPointState.convertToQuotedString(scanResult.SSID);
+                    String security = AccessPointState.getScanResultSecurity(scanResult);
+                    
+                    // See if this AP is part of a group of APs (e.g., any large
+                    // wifi network has many APs, we'll only show one) that we've
+                    // seen in this scan
+                    AccessPointState ap = findApLocked(newScanList, AccessPointState.NETWORK_ID_ANY,
+                                                 AccessPointState.BSSID_ANY, ssid, security);
+
+                    // Yup, we've seen this network.
+                    if (ap != null) {
+                        // Use the better signal
+                        if (WifiManager.compareSignalLevel(scanResult.level, ap.signal) > 0) {
+                            ap.setSignal(scanResult.level);
+                        }
+                        
+                        if (LOGV) {
+//                            Log.v(TAG, "         Already seen, continuing..");
+                        }
+                        
+                        continue;
+                    }
+
+                    // Find the AP in either our old scan list, or our non-seen
+                    // configured networks list
+                    ap = findApLocked(AccessPointState.NETWORK_ID_ANY, AccessPointState.BSSID_ANY,
+                                ssid, security);
+
+                    if (ap != null) {
+                        // Remove the AP from both (no harm if one doesn't contain it)
+                        oldScanList.remove(ap);
+                        mApOtherList.remove(ap);
+                    } else {
+                        ap = new AccessPointState(mContext);
+//                        if (LOGV) Log.v(TAG, "Created " + ap);
+                    }
+
+                    // Give it the latest state
+                    ap.updateFromScanResult(scanResult);
+
+                    if (mCallback != null) {
+                        mCallback.onAccessPointSetChanged(ap, true);
+                    }
+
+                    newScanList.add(ap);
+                }
+            }
+            
+            // oldScanList contains the ones no longer seen
+            List<AccessPointState> otherList = mApOtherList;
+            for (int i = oldScanList.size() - 1; i >= 0; i--) {
+                final AccessPointState ap = oldScanList.get(i);
+                
+                if (ap.configured) {
+                    
+                    // Keep it around, since it is configured
+                    ap.setSeen(false);
+                    otherList.add(ap);
+                    
+                } else {
+                    
+                    // Remove it since it is not configured and not seen
+                    removeApFromUi(ap);
+                }
+            }
+            
+            mApScanList = newScanList;
+        }
+
+        onScanningEnded();
+    }
+    
+    private void handleSupplicantConnectionChanged(boolean connected) {
+        if (mCallback != null) {
+            mCallback.onAccessPointsStateChanged(connected);
+        }
+        
+        if (connected) {
+            refreshAll(true);
+        }
+    }
+
+    private void handleWifiStateChanged(int wifiState) {
+        
+        if (wifiState == WIFI_STATE_ENABLED) {
+            loadConfiguredAccessPoints();
+            attemptScan();
+
+        } else if (wifiState == WIFI_STATE_DISABLED) {
+            removeFutureScans();
+            if (LOGV) Log.v(TAG, "Clearing AP lists because wifi is disabled");
+            clearApLists();
+        }
+        
+        if (mCallback != null) {
+            mCallback.onAccessPointsStateChanged(wifiState == WIFI_STATE_ENABLED);
+        }
+    }
+    
+    private void handleSignalChanged(int rssi) {
+        
+        if (mCurrentPrimaryAp != null) {
+            mCurrentPrimaryAp.setSignal(rssi);
+        }
+    }
+
+    private void handleSupplicantStateChanged(SupplicantState state, boolean hasError, int error) {
+        mCurrentSupplicantState = state;
+        
+        if (SupplicantState.FOUR_WAY_HANDSHAKE.equals(state)) {
+            mLastAuthenticatingAp = getCurrentAp();
+        }
+        
+        if (hasError) {
+            handleSupplicantStateError(error);
+        }
+    }
+    
+    private void handleSupplicantStateError(int supplicantError) {
+        if (supplicantError == WifiManager.ERROR_AUTHENTICATING) {
+            if (mCallback != null) {
+                if (mLastAuthenticatingAp != null) {
+                    mCallback.onRetryPassword(mLastAuthenticatingAp);
+                }
+            }
+        }
+    }
+    
+    private void handleNetworkIdsChanged() {
+        synchronized (this) {
+            final List<WifiConfiguration> configs = getConfiguredNetworks();
+            
+            for (int i = configs.size() - 1; i >= 0; i--) {
+                final WifiConfiguration config = configs.get(i);
+                
+                AccessPointState ap;
+                // Since network IDs have changed, we can't use it to find our previous AP state
+                ap = findApLocked(AccessPointState.NETWORK_ID_ANY, config.BSSID, config.SSID,
+                        AccessPointState.getWifiConfigurationSecurity(config));
+                
+                if (ap == null) {
+                    continue;
+                }
+
+                ap.setNetworkId(config.networkId);
+            }
+        }
+    }
+    
+    private class MyHandler extends Handler {
+
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case MESSAGE_ATTEMPT_SCAN:
+                    attemptScan();
+                    break;
+            }
+        }
+    }
+    
+}
diff --git a/src/com/android/settings/wifi/WifiSettings.java b/src/com/android/settings/wifi/WifiSettings.java
new file mode 100644
index 0000000..d2683c0
--- /dev/null
+++ b/src/com/android/settings/wifi/WifiSettings.java
@@ -0,0 +1,438 @@
+/*
+ * Copyright (C) 2007 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.settings.wifi;
+
+import com.android.settings.ProgressCategory;
+import com.android.settings.R;
+
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.net.wifi.WifiManager;
+import android.os.Bundle;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceScreen;
+import android.preference.CheckBoxPreference;
+import android.provider.Settings;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.widget.AdapterView;
+import android.widget.Toast;
+import android.widget.AdapterView.AdapterContextMenuInfo;
+
+import java.util.Set;
+import java.util.WeakHashMap;
+
+/**
+ * Settings screen for WiFi. This will be launched from the main system settings.
+ */
+public class WifiSettings extends PreferenceActivity implements WifiLayer.Callback,
+        DialogInterface.OnDismissListener {
+
+    private static final String TAG = "WifiSettings";
+    
+    //============================
+    // Preference/activity member variables
+    //============================
+    
+    private static final String INSTANCE_KEY_DIALOG_BUNDLE =
+            "com.android.settings.wifi.WifiSettings:dialogBundle";
+    /*
+     * We don't use Activity's dialog management because AlertDialog isn't fully
+     * able to change many of its features after it's been created, and the
+     * dialog management only creates once.
+     */
+    private Dialog mDialog;
+    
+    private static final String KEY_ADD_OTHER_NETWORK = "add_other_network";
+
+    private static final int CONTEXT_MENU_ID_CONNECT = Menu.FIRST;
+    private static final int CONTEXT_MENU_ID_FORGET = Menu.FIRST + 1;
+    private static final int CONTEXT_MENU_ID_CHANGE_PASSWORD = Menu.FIRST + 2;
+
+    private static final int MENU_ID_SCAN = Menu.FIRST; 
+    private static final int MENU_ID_ADVANCED = Menu.FIRST + 1; 
+    
+    private static final String KEY_WIFI_ENABLED = "wifi_enabled";
+    private static final String KEY_OPEN_NETWORK_NOTIFICATIONS_ENABLED =
+            "open_network_notifications_enabled";
+    private static final String KEY_ACCESS_POINTS = "access_points";
+    
+    private ProgressCategory mApCategory;
+    private CheckBoxPreference mWifiEnabled;
+    private WifiEnabler mWifiEnabler;
+    private CheckBoxPreference mOpenNetworkNotificationsEnabled; 
+    private Preference mAddOtherNetwork;
+    
+    private WeakHashMap<AccessPointState, AccessPointPreference> mAps;
+    
+    //============================
+    // Wifi member variables
+    //============================
+    
+    private WifiLayer mWifiLayer;
+        
+    //============================
+    // Activity lifecycle
+    //============================
+    
+    public WifiSettings() {
+        mAps = new WeakHashMap<AccessPointState, AccessPointPreference>();
+        mWifiLayer = new WifiLayer(this, this);
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        onCreatePreferences();
+        mWifiLayer.onCreate();
+
+        onCreatedWifi();
+        mWifiLayer.onCreatedCallback();
+    }
+    
+    /**
+     * Shouldn't have any dependency on the wifi layer.
+     */
+    private void onCreatePreferences() {
+        addPreferencesFromResource(R.xml.wifi_settings);
+        
+        final PreferenceScreen preferenceScreen = getPreferenceScreen();
+        
+        mApCategory = (ProgressCategory) preferenceScreen.findPreference(KEY_ACCESS_POINTS);
+        // We don't want the ordering to be the order preferences are added,
+        // instead we want*:
+        //   1) preferred, visible APs
+        //   2) visible APs
+        //   3) preferred, APs out of range
+        //   * this ordering logic is in AccessPointPreference's compareTo
+        mApCategory.setOrderingAsAdded(false);
+        
+        mWifiEnabled = (CheckBoxPreference) preferenceScreen.findPreference(KEY_WIFI_ENABLED);
+        mWifiEnabler = new WifiEnabler(this, (WifiManager) getSystemService(WIFI_SERVICE),
+                mWifiEnabled);
+        
+        mOpenNetworkNotificationsEnabled = (CheckBoxPreference) preferenceScreen
+                .findPreference(KEY_OPEN_NETWORK_NOTIFICATIONS_ENABLED);
+        mOpenNetworkNotificationsEnabled.setChecked(Settings.Secure.getInt(getContentResolver(),
+            Settings.Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 0) == 1);        
+        
+        mAddOtherNetwork = preferenceScreen.findPreference(KEY_ADD_OTHER_NETWORK);
+        
+        registerForContextMenu(getListView());
+    }
+
+    private void onCreatedWifi() {
+    }
+    
+    @Override
+    protected void onResume() {
+        super.onResume();
+        mWifiLayer.onResume();
+        mWifiEnabler.resume();
+    }
+    
+    @Override
+    protected void onPause() {
+        super.onPause();
+        mWifiLayer.onPause();
+        mWifiEnabler.pause();
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        
+        if (mDialog != null) {
+            mDialog.dismiss();
+        }
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        super.onCreateOptionsMenu(menu);
+        
+        menu.add(0, MENU_ID_SCAN, 0, R.string.scan_wifi)
+            .setIcon(R.drawable.ic_menu_scan_network);
+        
+        menu.add(0, MENU_ID_ADVANCED, 0, R.string.wifi_menu_advanced)
+            .setIcon(android.R.drawable.ic_menu_manage);
+        
+        return true;
+    }
+    
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        super.onOptionsItemSelected(item);
+        
+        switch (item.getItemId()) {
+
+            case MENU_ID_SCAN:
+                mWifiLayer.attemptScan();
+                return true;
+                
+            case MENU_ID_ADVANCED:
+                Intent intent = new Intent(this, AdvancedSettings.class);
+                startActivity(intent);
+                return true;
+                
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        
+        if (mDialog != null) {
+            Bundle dialogBundle = mDialog.onSaveInstanceState();
+            outState.putBundle(INSTANCE_KEY_DIALOG_BUNDLE, dialogBundle);
+        }
+    }
+
+    @Override
+    protected void onRestoreInstanceState(Bundle state) {
+        super.onRestoreInstanceState(state);
+        
+        Bundle dialogBundle = state.getBundle(INSTANCE_KEY_DIALOG_BUNDLE);
+        if (dialogBundle != null) {
+            mDialog = new AccessPointDialog(this, mWifiLayer);
+            mDialog.onRestoreInstanceState(dialogBundle);
+            showDialog(mDialog);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void onDismiss(DialogInterface dialog) {
+        if (dialog == mDialog) {
+            mDialog = null;
+        }
+    }
+
+    @Override
+    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+        super.onCreateContextMenu(menu, v, menuInfo);
+     
+        AccessPointState state = getStateFromMenuInfo(menuInfo);
+        if (state == null) {
+            return;
+        }
+     
+        menu.setHeaderTitle(state.getHumanReadableSsid());
+        
+        if (state.isConnectable()) {
+            menu.add(0, CONTEXT_MENU_ID_CONNECT, 0, R.string.wifi_context_menu_connect);
+        }
+        
+        if (state.isForgetable()) {
+            menu.add(0, CONTEXT_MENU_ID_FORGET, 1, R.string.wifi_context_menu_forget);
+            
+            if (state.hasPassword()) {
+                menu.add(0, CONTEXT_MENU_ID_CHANGE_PASSWORD, 2,
+                        R.string.wifi_context_menu_change_password);
+            }
+        }
+    }
+
+    @Override
+    public boolean onContextItemSelected(MenuItem item) {
+        
+        AccessPointState state = getStateFromMenuInfo(item.getMenuInfo());
+        if (state == null) {
+            return false;
+        }
+
+        switch (item.getItemId()) {
+            
+            case CONTEXT_MENU_ID_CONNECT:
+                connectToNetwork(state);
+                return true;
+                
+            case CONTEXT_MENU_ID_FORGET:
+                mWifiLayer.forgetNetwork(state);
+                return true;
+                
+            case CONTEXT_MENU_ID_CHANGE_PASSWORD:
+                showAccessPointDialog(state, AccessPointDialog.MODE_CONFIGURE);
+                return true;
+                
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * Decides what needs to happen to connect to a particular access point. If
+     * it is secured and doesn't already have a password, it will bring up a
+     * password box. Otherwise it will just connect.
+     */
+    private void connectToNetwork(AccessPointState state) {
+        if (state.hasSecurity() && !state.hasPassword()) {
+            showAccessPointDialog(state, AccessPointDialog.MODE_INFO);
+        } else {
+            mWifiLayer.connectToNetwork(state);
+        }
+    }
+    
+    private AccessPointState getStateFromMenuInfo(ContextMenuInfo menuInfo) {
+        if ((menuInfo == null) || !(menuInfo instanceof AdapterContextMenuInfo)) {
+            return null;
+        }
+        
+        AdapterContextMenuInfo adapterMenuInfo = (AdapterContextMenuInfo) menuInfo;
+        Preference pref = (Preference) getPreferenceScreen().getRootAdapter().getItem(
+                adapterMenuInfo.position);
+        if (pref == null || !(pref instanceof AccessPointPreference)) {
+            return null;
+        }
+
+        return ((AccessPointPreference) pref).getAccessPointState();
+    }
+    
+    //============================
+    // Preference callbacks
+    //============================
+    
+    @Override
+    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
+        super.onPreferenceTreeClick(preferenceScreen, preference);
+
+        if (preference == mAddOtherNetwork) {
+            showAddOtherNetworkDialog();
+        } else if (preference == mOpenNetworkNotificationsEnabled) {
+            Settings.Secure.putInt(getContentResolver(),
+                Settings.Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON,
+                mOpenNetworkNotificationsEnabled.isChecked() ? 1 : 0);
+        } else if (preference instanceof AccessPointPreference) {
+            AccessPointState state = ((AccessPointPreference) preference).getAccessPointState();
+            showAccessPointDialog(state, AccessPointDialog.MODE_INFO);
+        }
+        
+        return false;
+    }
+    
+    //============================
+    // Wifi-related
+    //============================
+
+    public WifiLayer getWifiLayer() {
+        return mWifiLayer;
+    }
+
+    private void showAddOtherNetworkDialog() {
+        AccessPointDialog dialog = new AccessPointDialog(this, mWifiLayer);
+        dialog.setState(new AccessPointState(this));
+        dialog.setMode(AccessPointDialog.MODE_CONFIGURE);
+        dialog.setTitle(R.string.wifi_add_other_network);
+        dialog.setAutoSecurityAllowed(false);
+        showDialog(dialog);
+    }
+    
+    public void showAccessPointDialog(AccessPointState state, int mode) {
+        AccessPointDialog dialog = new AccessPointDialog(this, mWifiLayer);
+        dialog.setMode(mode);
+        dialog.setState(state);
+        showDialog(dialog);
+    }
+
+    private void showDialog(Dialog dialog) {
+        // Have only one dialog open at a time
+        if (mDialog != null) {
+            mDialog.dismiss();
+        }
+        
+        mDialog = dialog;
+        dialog.setOnDismissListener(this);
+        if (dialog != null) {
+            dialog.show();
+        }
+    }
+    
+    //============================
+    // Wifi callbacks
+    //============================
+
+    public void onError(int messageResId) {
+        Toast.makeText(this, messageResId, Toast.LENGTH_LONG).show();
+    }
+
+    public void onScanningStatusChanged(boolean started) {
+        mApCategory.setProgress(started);
+    }    
+
+    public void onAccessPointSetChanged(AccessPointState ap, boolean added) {
+
+        AccessPointPreference pref = mAps.get(ap);
+        
+        if (WifiLayer.LOGV) {
+            Log.v(TAG, "onAccessPointSetChanged with " + ap + " and "
+                    + (added ? "added" : "removed") + ", found pref " + pref);
+        }
+        
+        if (added) {
+            
+            if (pref == null) {
+                pref = new AccessPointPreference(this, ap);
+                mAps.put(ap, pref);
+            } else {
+                pref.setEnabled(true);
+            }
+            
+            mApCategory.addPreference(pref);
+            
+        } else {
+
+            mAps.remove(ap);
+            
+            if (pref != null) {
+                mApCategory.removePreference(pref);
+            }
+            
+        }
+    }
+
+    public void onAccessPointsStateChanged(boolean enabled) {
+        if (enabled) {
+            mApCategory.setEnabled(true);
+        } else {
+            mApCategory.removeAll();
+            mAps.clear();
+        }
+
+        mAddOtherNetwork.setEnabled(enabled);
+    }
+
+    public void onRetryPassword(AccessPointState ap) {
+
+        if ((mDialog != null) && mDialog.isShowing()) {
+            // If we're already showing a dialog, ignore this request
+            return;
+        }
+        
+        showAccessPointDialog(ap, AccessPointDialog.MODE_RETRY_PASSWORD);
+    }
+    
+}
diff --git a/src/com/android/settings/wifi/WifiStatus.java b/src/com/android/settings/wifi/WifiStatus.java
new file mode 100644
index 0000000..d4b6431
--- /dev/null
+++ b/src/com/android/settings/wifi/WifiStatus.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2007 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.settings.wifi;
+
+import com.android.settings.R;
+
+import android.content.Context;
+import android.net.NetworkInfo;
+import android.net.wifi.WifiInfo;
+import android.text.TextUtils;
+
+public class WifiStatus {
+
+    // e.g., "Connecting"
+    public static String sScanning;
+    public static String sConnecting;
+    public static String sAuthenticating;
+    public static String sObtainingIp;
+    public static String sConnected;
+    public static String sDisconnecting;
+    public static String sDisconnected;
+    public static String sFailed;    
+
+    // e.g., "Connecting to %1$s"
+    public static String sScanningFragment;
+    public static String sConnectingFragment;
+    public static String sAuthenticatingFragment;
+    public static String sObtainingIpFragment;
+    public static String sConnectedFragment;
+    public static String sDisconnectingFragment;
+    public static String sDisconnectedFragment;
+    public static String sFailedFragment;    
+
+    private static void fillStrings(Context context) {
+        sScanning = context.getString(R.string.status_scanning);
+        sConnecting = context.getString(R.string.status_connecting);
+        sAuthenticating = context.getString(R.string.status_authenticating);
+        sObtainingIp = context.getString(R.string.status_obtaining_ip);
+        sConnected = context.getString(R.string.status_connected);
+        sDisconnecting = context.getString(R.string.status_disconnecting);
+        sDisconnected = context.getString(R.string.status_disconnected);
+        sFailed = context.getString(R.string.status_failed);
+
+        sScanningFragment = context.getString(R.string.fragment_status_scanning);
+        sConnectingFragment = context.getString(R.string.fragment_status_connecting);
+        sAuthenticatingFragment = context.getString(R.string.fragment_status_authenticating);
+        sObtainingIpFragment = context.getString(R.string.fragment_status_obtaining_ip);
+        sConnectedFragment = context.getString(R.string.fragment_status_connected);
+        sDisconnectingFragment = context.getString(R.string.fragment_status_disconnecting);
+        sDisconnectedFragment = context.getString(R.string.fragment_status_disconnected);
+        sFailedFragment = context.getString(R.string.fragment_status_failed);
+    }
+    
+    public static String getStatus(Context context, String ssid,
+            NetworkInfo.DetailedState detailedState) {
+        
+        if (!TextUtils.isEmpty(ssid) && isLiveConnection(detailedState)) {
+            return getPrintableFragment(context, detailedState, ssid);
+        } else {
+            return getPrintable(context, detailedState);
+        }
+    }
+    
+    public static boolean isLiveConnection(NetworkInfo.DetailedState detailedState) {
+        return detailedState != NetworkInfo.DetailedState.DISCONNECTED
+                && detailedState != NetworkInfo.DetailedState.FAILED
+                && detailedState != NetworkInfo.DetailedState.IDLE
+                && detailedState != NetworkInfo.DetailedState.SCANNING;
+    }
+    
+    public static String getPrintable(Context context,
+            NetworkInfo.DetailedState detailedState) {
+        
+        if (sScanning == null) {
+            fillStrings(context);
+        }
+        
+        switch (detailedState) {
+            case AUTHENTICATING:
+                return sAuthenticating;
+            case CONNECTED:
+                return sConnected;
+            case CONNECTING:
+                return sConnecting;
+            case DISCONNECTED:
+                return sDisconnected;
+            case DISCONNECTING:
+                return sDisconnecting;
+            case FAILED:
+                return sFailed;
+            case OBTAINING_IPADDR:
+                return sObtainingIp;
+            case SCANNING:
+                return sScanning;
+            default:
+                return null;
+        }
+    }
+    
+    public static String getPrintableFragment(Context context,
+            NetworkInfo.DetailedState detailedState, String apName) {
+        
+        if (sScanningFragment == null) {
+            fillStrings(context);
+        }
+
+        String fragment = null;
+        switch (detailedState) {
+            case AUTHENTICATING:
+                fragment = sAuthenticatingFragment;
+                break;
+            case CONNECTED:
+                fragment = sConnectedFragment;
+                break;
+            case CONNECTING:
+                fragment = sConnectingFragment;
+                break;
+            case DISCONNECTED:
+                fragment = sDisconnectedFragment;
+                break;
+            case DISCONNECTING:
+                fragment = sDisconnectingFragment;
+                break;
+            case FAILED:
+                fragment = sFailedFragment;
+                break;
+            case OBTAINING_IPADDR:
+                fragment = sObtainingIpFragment;
+                break;
+            case SCANNING:
+                fragment = sScanningFragment;
+                break;
+        }
+        
+        return String.format(fragment, apName);
+    }
+    
+}