Add new sample for multi-pane PreferenceActivity.

Also re-arrange all preference API demos to go in their own
package, since the preferfence APIs themselves are in their own package.

Change-Id: I305f77dc09748bb60d1de8a23d063db64c11bb1e

samples/ApiDemos/src/com/example/android/apis/preference/AdvancedPreferences.java

@@ -0,0 +1,94 @@
+/*
+ * 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.example.android.apis.preference;
+
+import com.example.android.apis.R;
+
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.os.Bundle;
+import android.os.Handler;
+import android.preference.PreferenceActivity;
+import android.preference.CheckBoxPreference;
+import android.widget.Toast;
+
+/**
+ * Example that shows finding a preference from the hierarchy and a custom preference type.
+ */
+public class AdvancedPreferences extends PreferenceActivity implements OnSharedPreferenceChangeListener {
+    public static final String KEY_MY_PREFERENCE = "my_preference";
+    public static final String KEY_ADVANCED_CHECKBOX_PREFERENCE = "advanced_checkbox_preference";
+
+    private CheckBoxPreference mCheckBoxPreference;
+    private Handler mHandler = new Handler();
+
+    /**
+     * This is a simple example of controlling a preference from code.
+     */
+    private Runnable mForceCheckBoxRunnable = new Runnable() {
+        public void run() {
+            if (mCheckBoxPreference != null) {
+                mCheckBoxPreference.setChecked(!mCheckBoxPreference.isChecked());
+            }
+
+            // Force toggle again in a second
+            mHandler.postDelayed(this, 1000);
+        }
+    };
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // Load the XML preferences file
+        addPreferencesFromResource(R.xml.advanced_preferences);
+
+        // Get a reference to the checkbox preference
+        mCheckBoxPreference = (CheckBoxPreference)getPreferenceScreen().findPreference(
+                KEY_ADVANCED_CHECKBOX_PREFERENCE);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        // Start the force toggle
+        mForceCheckBoxRunnable.run();
+
+        // Set up a listener whenever a key changes
+        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        // Unregister the listener whenever a key changes
+        getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this);
+
+        mHandler.removeCallbacks(mForceCheckBoxRunnable);
+    }
+
+    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+        // Let's do something when my counter preference value changes
+        if (key.equals(KEY_MY_PREFERENCE)) {
+            Toast.makeText(this, "Thanks! You increased my count to "
+                    + sharedPreferences.getInt(key, 0), Toast.LENGTH_SHORT).show();
+        }
+    }
+
+}

samples/ApiDemos/src/com/example/android/apis/preference/DefaultValues.java

@@ -0,0 +1,53 @@
+/*
+ * 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.example.android.apis.preference;
+
+import com.example.android.apis.ApiDemosApplication;
+import com.example.android.apis.R;
+
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceManager;
+
+/**
+ * This activity is an example of a simple settings screen that has default
+ * values.
+ * <p>
+ * In order for the default values to be populated into the
+ * {@link SharedPreferences} (from the preferences XML file), the client must
+ * call
+ * {@link PreferenceManager#setDefaultValues(android.content.Context, int, boolean)}.
+ * <p>
+ * This should be called early, typically when the application is first created.
+ * This ensures any of the application's activities, services, etc. will have
+ * the default values present, even if the user has not wandered into the
+ * application's settings. For ApiDemos, this is {@link ApiDemosApplication},
+ * and you can find the call to
+ * {@link PreferenceManager#setDefaultValues(android.content.Context, int, boolean)}
+ * in its {@link ApiDemosApplication#onCreate() onCreate}.
+ */
+public class DefaultValues extends PreferenceActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        addPreferencesFromResource(R.xml.default_values);
+    }
+
+}

samples/ApiDemos/src/com/example/android/apis/preference/FragmentPreferences.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2010 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.example.android.apis.preference;
+
+import com.example.android.apis.R;
+
+import android.app.Activity;
+import android.app.Fragment;
+import android.app.ListFragment;
+import android.os.Bundle;
+import android.preference.PreferenceFragment;
+import android.view.View;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+
+/**
+ * Demonstration of PreferenceFragment, splitting the activity into a
+ * list categories and preferences.
+ */
+//BEGIN_INCLUDE(activity)
+public class FragmentPreferences extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // The content for this activity places CategoriesFragment to one
+        // side, and leaves the rest to dynamically add the prefs fragment.
+        setContentView(R.layout.fragment_preferences);
+    }
+
+    /**
+     * This fragment shows a list of categories the user can pick.  When they
+     * pick one, the corresponding preferences fragment is created and shown.
+     */
+    public static class CategoriesFragment extends ListFragment {
+        @Override
+        public void onActivityCreated(Bundle savedInstanceState) {
+            super.onActivityCreated(savedInstanceState);
+            setListAdapter(new ArrayAdapter<String>(getActivity(),
+                    android.R.layout.simple_list_item_1,
+                    new String[] { "Prefs 1", "Prefs 2" }));
+            switchPreferences(0);
+        }
+
+        @Override
+        public void onListItemClick(ListView l, View v, int position, long id) {
+            switchPreferences(position);
+        }
+
+        /**
+         * Show the given preferences, replacing whatever was last shown.
+         */
+        void switchPreferences(int which) {
+            Fragment f = which == 0 ? new Prefs1Fragment() : new Prefs2Fragment();
+            getActivity().openFragmentTransaction().replace(R.id.prefs, f).commit();
+        }
+    }
+
+//BEGIN_INCLUDE(fragment)
+    public static class Prefs1Fragment extends PreferenceFragment {
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            // Load the preferences from an XML resource
+            addPreferencesFromResource(R.xml.preferences);
+        }
+    }
+//END_INCLUDE(fragment)
+
+    public static class Prefs2Fragment extends PreferenceFragment {
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            // Load the preferences from an XML resource
+            addPreferencesFromResource(R.xml.preference_dependencies);
+        }
+    }
+}
+//END_INCLUDE(activity)

samples/ApiDemos/src/com/example/android/apis/preference/LaunchingPreferences.java

@@ -0,0 +1,103 @@
+/*
+ * 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.example.android.apis.preference;
+
+import com.example.android.apis.R;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import android.widget.LinearLayout.LayoutParams;
+
+/**
+ * Demonstrates launching a PreferenceActivity and grabbing a value it saved.
+ */
+public class LaunchingPreferences extends Activity implements OnClickListener {
+
+    private static final int REQUEST_CODE_PREFERENCES = 1;
+
+    private TextView mCounterText;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        /*
+         * If this were my app's main activity, I would load the default values
+         * so they're set even if the user does not go into the preferences
+         * screen. Another good place to call this method would be from a
+         * subclass of Application, so your default values would be loaded
+         * regardless of entry into your application (for example, a service or
+         * activity).
+         */
+        PreferenceManager.setDefaultValues(this, R.xml.advanced_preferences, false);
+
+        // Simple layout
+        LinearLayout layout = new LinearLayout(this);
+        layout.setOrientation(LinearLayout.VERTICAL);
+        setContentView(layout);
+
+        // Create a simple button that will launch the preferences
+        Button launchPreferences = new Button(this);
+        launchPreferences.setText(getString(R.string.launch_preference_activity));
+        launchPreferences.setOnClickListener(this);
+        layout.addView(launchPreferences, new LayoutParams(LayoutParams.MATCH_PARENT,
+                LayoutParams.WRAP_CONTENT));
+
+        mCounterText = new TextView(this);
+        layout.addView(mCounterText, new LayoutParams(LayoutParams.MATCH_PARENT,
+                LayoutParams.WRAP_CONTENT));
+
+        updateCounterText();
+    }
+
+    public void onClick(View v) {
+
+        // When the button is clicked, launch an activity through this intent
+        Intent launchPreferencesIntent = new Intent().setClass(this, AdvancedPreferences.class);
+
+        // Make it a subactivity so we know when it returns
+        startActivityForResult(launchPreferencesIntent, REQUEST_CODE_PREFERENCES);
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+
+        // The preferences returned if the request code is what we had given
+        // earlier in startSubActivity
+        if (requestCode == REQUEST_CODE_PREFERENCES) {
+            // Read a sample value they have set
+            updateCounterText();
+        }
+    }
+
+    private void updateCounterText() {
+        // Since we're in the same package, we can use this context to get
+        // the default shared preferences
+        SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
+        final int counter = sharedPref.getInt(AdvancedPreferences.KEY_MY_PREFERENCE, 0);
+        mCounterText.setText(getString(R.string.counter_value_is) + " " + counter);
+    }
+}

samples/ApiDemos/src/com/example/android/apis/preference/PreferenceDependencies.java

@@ -0,0 +1,33 @@
+/*
+ * 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.example.android.apis.preference;
+
+import com.example.android.apis.R;
+
+import android.os.Bundle;
+import android.preference.PreferenceActivity;
+
+public class PreferenceDependencies extends PreferenceActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        addPreferencesFromResource(R.xml.preference_dependencies);
+    }
+
+}

samples/ApiDemos/src/com/example/android/apis/preference/PreferenceWithHeaders.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2010 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.example.android.apis.preference;
+
+import com.example.android.apis.R;
+
+import android.os.Bundle;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceFragment;
+
+import java.util.List;
+
+/**
+ * Demonstration of PreferenceActivity to make a top-level preference
+ * panel with headers.
+ */
+//BEGIN_INCLUDE(activity)
+public class PreferenceWithHeaders extends PreferenceActivity {
+    @Override
+    public void onBuildHeaders(List<Header> target) {
+        loadHeadersFromResource(R.xml.preference_headers, target);
+    }
+
+    public static class Prefs1Fragment extends PreferenceFragment {
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            // Load the preferences from an XML resource
+            addPreferencesFromResource(R.xml.preferences);
+        }
+    }
+
+    public static class Prefs2Fragment extends PreferenceFragment {
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            // Load the preferences from an XML resource
+            addPreferencesFromResource(R.xml.preference_dependencies);
+        }
+    }
+}
+//END_INCLUDE(activity)

samples/ApiDemos/src/com/example/android/apis/preference/PreferencesFromCode.java

@@ -0,0 +1,143 @@
+/*
+ * 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.example.android.apis.preference;
+
+import android.content.Intent;
+import android.content.res.TypedArray;
+import android.net.Uri;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.EditTextPreference;
+import android.preference.ListPreference;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceCategory;
+import android.preference.PreferenceScreen;
+
+import com.example.android.apis.R;
+
+public class PreferencesFromCode extends PreferenceActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setPreferenceScreen(createPreferenceHierarchy());
+    }
+
+    private PreferenceScreen createPreferenceHierarchy() {
+        // Root
+        PreferenceScreen root = getPreferenceManager().createPreferenceScreen(this);
+
+        // Inline preferences
+        PreferenceCategory inlinePrefCat = new PreferenceCategory(this);
+        inlinePrefCat.setTitle(R.string.inline_preferences);
+        root.addPreference(inlinePrefCat);
+
+        // Toggle preference
+        CheckBoxPreference togglePref = new CheckBoxPreference(this);
+        togglePref.setKey("toggle_preference");
+        togglePref.setTitle(R.string.title_toggle_preference);
+        togglePref.setSummary(R.string.summary_toggle_preference);
+        inlinePrefCat.addPreference(togglePref);
+
+        // Dialog based preferences
+        PreferenceCategory dialogBasedPrefCat = new PreferenceCategory(this);
+        dialogBasedPrefCat.setTitle(R.string.dialog_based_preferences);
+        root.addPreference(dialogBasedPrefCat);
+
+        // Edit text preference
+        EditTextPreference editTextPref = new EditTextPreference(this);
+        editTextPref.setDialogTitle(R.string.dialog_title_edittext_preference);
+        editTextPref.setKey("edittext_preference");
+        editTextPref.setTitle(R.string.title_edittext_preference);
+        editTextPref.setSummary(R.string.summary_edittext_preference);
+        dialogBasedPrefCat.addPreference(editTextPref);
+
+        // List preference
+        ListPreference listPref = new ListPreference(this);
+        listPref.setEntries(R.array.entries_list_preference);
+        listPref.setEntryValues(R.array.entryvalues_list_preference);
+        listPref.setDialogTitle(R.string.dialog_title_list_preference);
+        listPref.setKey("list_preference");
+        listPref.setTitle(R.string.title_list_preference);
+        listPref.setSummary(R.string.summary_list_preference);
+        dialogBasedPrefCat.addPreference(listPref);
+
+        // Launch preferences
+        PreferenceCategory launchPrefCat = new PreferenceCategory(this);
+        launchPrefCat.setTitle(R.string.launch_preferences);
+        root.addPreference(launchPrefCat);
+
+        /*
+         * The Preferences screenPref serves as a screen break (similar to page
+         * break in word processing). Like for other preference types, we assign
+         * a key here so that it is able to save and restore its instance state.
+         */
+        // Screen preference
+        PreferenceScreen screenPref = getPreferenceManager().createPreferenceScreen(this);
+        screenPref.setKey("screen_preference");
+        screenPref.setTitle(R.string.title_screen_preference);
+        screenPref.setSummary(R.string.summary_screen_preference);
+        launchPrefCat.addPreference(screenPref);
+
+        /*
+         * You can add more preferences to screenPref that will be shown on the
+         * next screen.
+         */
+
+        // Example of next screen toggle preference
+        CheckBoxPreference nextScreenCheckBoxPref = new CheckBoxPreference(this);
+        nextScreenCheckBoxPref.setKey("next_screen_toggle_preference");
+        nextScreenCheckBoxPref.setTitle(R.string.title_next_screen_toggle_preference);
+        nextScreenCheckBoxPref.setSummary(R.string.summary_next_screen_toggle_preference);
+        screenPref.addPreference(nextScreenCheckBoxPref);
+
+        // Intent preference
+        PreferenceScreen intentPref = getPreferenceManager().createPreferenceScreen(this);
+        intentPref.setIntent(new Intent().setAction(Intent.ACTION_VIEW)
+                .setData(Uri.parse("http://www.android.com")));
+        intentPref.setTitle(R.string.title_intent_preference);
+        intentPref.setSummary(R.string.summary_intent_preference);
+        launchPrefCat.addPreference(intentPref);
+
+        // Preference attributes
+        PreferenceCategory prefAttrsCat = new PreferenceCategory(this);
+        prefAttrsCat.setTitle(R.string.preference_attributes);
+        root.addPreference(prefAttrsCat);
+
+        // Visual parent toggle preference
+        CheckBoxPreference parentCheckBoxPref = new CheckBoxPreference(this);
+        parentCheckBoxPref.setTitle(R.string.title_parent_preference);
+        parentCheckBoxPref.setSummary(R.string.summary_parent_preference);
+        prefAttrsCat.addPreference(parentCheckBoxPref);
+
+        // Visual child toggle preference
+        // See res/values/attrs.xml for the <declare-styleable> that defines
+        // TogglePrefAttrs.
+        TypedArray a = obtainStyledAttributes(R.styleable.TogglePrefAttrs);
+        CheckBoxPreference childCheckBoxPref = new CheckBoxPreference(this);
+        childCheckBoxPref.setTitle(R.string.title_child_preference);
+        childCheckBoxPref.setSummary(R.string.summary_child_preference);
+        childCheckBoxPref.setLayoutResource(
+                a.getResourceId(R.styleable.TogglePrefAttrs_android_preferenceLayoutChild,
+                        0));
+        prefAttrsCat.addPreference(childCheckBoxPref);
+        a.recycle();
+
+        return root;
+    }
+}

samples/ApiDemos/src/com/example/android/apis/preference/PreferencesFromXml.java

@@ -0,0 +1,34 @@
+/*
+ * 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.example.android.apis.preference;
+
+import com.example.android.apis.R;
+
+import android.os.Bundle;
+import android.preference.PreferenceActivity;
+
+public class PreferencesFromXml extends PreferenceActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // Load the preferences from an XML resource
+        addPreferencesFromResource(R.xml.preferences);
+    }
+
+}