Android偏好设置(7)自定义Preference,和PreferenceDialog
Building a Custom Preference
The Android framework includes a variety of Preference
subclasses that allow you to build a UI for several different types of settings. However, you might discover a setting you need for which there’s no built-in solution, such as a number picker or date picker. In such a case, you’ll need to create a custom preference by extending the Preference
class or one of the other subclasses.
When you extend the Preference
class, there are a few important things you need to do:
- Specify the user interface that appears when the user selects the settings.
- Save the setting's value when appropriate.
- Initialize the
Preference
with the current (or default) value when it comes into view. - Provide the default value when requested by the system.
- If the
Preference
provides its own UI (such as a dialog), save and restore the state to handle lifecycle changes (such as when the user rotates the screen).
The following sections describe how to accomplish each of these tasks.
Specifying the user interface
If you directly extend the Preference
class, you need to implement onClick()
to define the action that occurs when the user selects the item. However, most custom settings extend DialogPreference
to show a dialog, which simplifies the procedure. When you extend DialogPreference
, you must callsetDialogLayoutResourcs()
during in the class constructor to specify the layout for the dialog.
For example, here's the constructor for a custom DialogPreference
that declares the layout and specifies the text for the default positive and negative dialog buttons:
public class NumberPickerPreference extends DialogPreference {
public NumberPickerPreference(Context context, AttributeSet attrs) {
super(context, attrs); setDialogLayoutResource(R.layout.numberpicker_dialog);
setPositiveButtonText(android.R.string.ok);
setNegativeButtonText(android.R.string.cancel); setDialogIcon(null);
}
...
}
Saving the setting's value
You can save a value for the setting at any time by calling one of the Preference
class's persist*()
methods, such as persistInt()
if the setting's value is an integer or persistBoolean()
to save a boolean.
Note: Each Preference
can save only one data type, so you must use the persist*()
method appropriate for the data type used by your custom Preference
.
When you choose to persist the setting can depend on which Preference
class you extend. If you extendDialogPreference
, then you should persist the value only when the dialog closes due to a positive result (the user selects the "OK" button).
When a DialogPreference
closes, the system calls the onDialogClosed()
method. The method includes a boolean argument that specifies whether the user result is "positive"—if the value is true
, then the user selected the positive button and you should save the new value. For example:
@Override
protected void onDialogClosed(boolean positiveResult) {
// When the user selects "OK", persist the new value
if (positiveResult) {
persistInt(mNewValue);
}
}
In this example, mNewValue
is a class member that holds the setting's current value. Calling persistInt()
saves the value to the SharedPreferences
file (automatically using the key that's specified in the XML file for this Preference
).
Initializing the current value
When the system adds your Preference
to the screen, it calls onSetInitialValue()
to notify you whether the setting has a persisted value. If there is no persisted value, this call provides you the default value.
The onSetInitialValue()
method passes a boolean, restorePersistedValue
, to indicate whether a value has already been persisted for the setting. If it is true
, then you should retrieve the persisted value by calling one of the Preference
class's getPersisted*()
methods, such as getPersistedInt()
for an integer value. You'll usually want to retrieve the persisted value so you can properly update the UI to reflect the previously saved value.
If restorePersistedValue
is false
, then you should use the default value that is passed in the second argument.
@Override
protected void onSetInitialValue(boolean restorePersistedValue, Object defaultValue) {
if (restorePersistedValue) {
// Restore existing state
mCurrentValue = this.getPersistedInt(DEFAULT_VALUE);
} else {
// Set default state from the XML attribute
mCurrentValue = (Integer) defaultValue;
persistInt(mCurrentValue);
}
}
Each getPersisted*()
method takes an argument that specifies the default value to use in case there is actually no persisted value or the key does not exist. In the example above, a local constant is used to specify the default value in case getPersistedInt()
can't return a persisted value.
Caution: You cannot use the defaultValue
as the default value in the getPersisted*()
method, because its value is always null when restorePersistedValue
is true
.
Providing a default value
If the instance of your Preference
class specifies a default value (with the android:defaultValue
attribute), then the system calls onGetDefaultValue()
when it instantiates the object in order to retrieve the value. You must implement this method in order for the system to save the default value in the SharedPreferences
. For example:
@Override
protected Object onGetDefaultValue(TypedArray a, int index) {
return a.getInteger(index, DEFAULT_VALUE);
}
The method arguments provide everything you need: the array of attributes and the index position of theandroid:defaultValue
, which you must retrieve. The reason you must implement this method to extract the default value from the attribute is because you must specify a local default value for the attribute in case the value is undefined.
Saving and restoring the Preference's state
Just like a View
in a layout, your Preference
subclass is responsible for saving and restoring its state in case the activity or fragment is restarted (such as when the user rotates the screen). To properly save and restore the state of your Preference
class, you must implement the lifecycle callback methods onSaveInstanceState()
and onRestoreInstanceState()
.
The state of your Preference
is defined by an object that implements the Parcelable
interface. The Android framework provides such an object for you as a starting point to define your state object: thePreference.BaseSavedState
class.
To define how your Preference
class saves its state, you should extend the Preference.BaseSavedState
class. You need to override just a few methods and define the CREATOR
object.
For most apps, you can copy the following implementation and simply change the lines that handle the value
if your Preference
subclass saves a data type other than an integer.
private static class SavedState extends BaseSavedState {
// Member that holds the setting's value
// Change this data type to match the type saved by your Preference
int value; public SavedState(Parcelable superState) {
super(superState);
} public SavedState(Parcel source) {
super(source);
// Get the current preference's value
value = source.readInt(); // Change this to read the appropriate data type
} @Override
public void writeToParcel(Parcel dest, int flags) {
super.writeToParcel(dest, flags);
// Write the preference's value
dest.writeInt(value); // Change this to write the appropriate data type
} // Standard creator object using an instance of this class
public static final Parcelable.Creator<SavedState> CREATOR =
new Parcelable.Creator<SavedState>() { public SavedState createFromParcel(Parcel in) {
return new SavedState(in);
} public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
}
With the above implementation of Preference.BaseSavedState
added to your app (usually as a subclass of your Preference
subclass), you then need to implement the onSaveInstanceState()
andonRestoreInstanceState()
methods for your Preference
subclass.
For example:
@Override
protected Parcelable onSaveInstanceState() {
final Parcelable superState = super.onSaveInstanceState();
// Check whether this Preference is persistent (continually saved)
if (isPersistent()) {
// No need to save instance state since it's persistent,
// use superclass state
return superState;
} // Create instance of custom BaseSavedState
final SavedState myState = new SavedState(superState);
// Set the state's value with the class member that holds current
// setting value
myState.value = mNewValue;
return myState;
} @Override
protected void onRestoreInstanceState(Parcelable state) {
// Check whether we saved the state in onSaveInstanceState
if (state == null || !state.getClass().equals(SavedState.class)) {
// Didn't save the state, so call superclass
super.onRestoreInstanceState(state);
return;
} // Cast state to custom BaseSavedState and pass to superclass
SavedState myState = (SavedState) state;
super.onRestoreInstanceState(myState.getSuperState()); // Set this Preference's widget to reflect the restored state
mNumberPicker.setValue(myState.value);
}
Android偏好设置(7)自定义Preference,和PreferenceDialog的更多相关文章
- Android的设置界面及Preference使用
一般来说,我们的APP都会有自己的设置页面,那么其实我们有非常简单的制作方法.老样子,先看效果图. 然后就是看源代码了. 第一步,先在res文件夹中新建一个xml文件夹,用来存放preferences ...
- Android偏好设置(2)为应用定义一个偏好设置xml
1.Defining Preferences in XML Although you can instantiate new Preference objects at runtime, you sh ...
- Android偏好设置(1)概述和Preferences简介
1.Overview Instead of using View objects to build the user interface, settings are built using vario ...
- Android偏好设置(6)应用和监听各偏好参数
Reading Preferences By default, all your app's preferences are saved to a file that's accessible fro ...
- Android偏好设置(5)偏好设置界面显示多个分组,每个分组也有一个界面
1.Using Preference Headers In rare cases, you might want to design your settings such that the first ...
- Android偏好设置(4)设置默认值
Setting Default Values The preferences you create probably define some important behaviors for your ...
- Android偏好设置(3)启动偏好设置后显示的界面PreferenceActivity和PreferenceFragment
Creating a Preference Activity To display your settings in an activity, extend the PreferenceActivit ...
- 【起航计划 031】2015 起航计划 Android APIDemo的魔鬼步伐 30 App->Preferences->Advanced preferences 自定义preference OnPreferenceChangeListener
前篇文章Android ApiDemo示例解析(31):App->Preferences->Launching preferences 中用到了Advanced preferences 中 ...
- MongoDB 读偏好设置中增加最大有效延迟时间的参数
在某些情况下,将读请求发送给副本集的备份节点是合理的,例如,单个服务器无法处理应用的读压力,就可以把查询请求路由到可复制集中的多台服务器上.现在绝大部分MongoDB驱动支持读偏好设置(read pr ...
随机推荐
- CSS浮动通俗讲解
首先要知道,div是块级元素,在页面中独占一行,自上而下排列,也就是传说中的流.如下图: 可以看出,即使div1的宽度很小,页面中一行可以容下div1和div2,div2也不会排在div1后边,因为d ...
- MySQL学习系列之触发器
触发器简介 触发器作用: 监控某种事件并触发某种动作 触发语法: CREATE TRIGGER trigger_name trigger_event ON tbl_name FOR EACH ROW ...
- sql server 笔记1--case、WAITFOR、TRY CATCH
一.case 转自:http://blog.csdn.net/add8849/article/details/576424 深入使用:http://blog.csdn.net/akuoma/artic ...
- css3最新版中文参考手册在线浏览
对于CSS 3.0,它对于我们Web设计人员来说不只是新奇的技术,更重要的是这些全新概念的Web应用给我们的设计开发提高了效率以及更多的无限可能性,我们将不必再依赖图片或者 Javascript 去完 ...
- 理解static关键字
1.static 变量是类变量,通过类名引用. 2.static 方法不需要针对某个对象进行操作,其运行结果仅仅与输入的参数有关,调用时直接类名引用. 3.static 方法不能对非静态成员进行访问. ...
- Why Do Microservices Need an API Gateway?
Why Do Microservices Need an API Gateway? - DZone Integration https://dzone.com/articles/why-do-micr ...
- 计算机学院大学生程序设计竞赛(2015’11)1005 ACM组队安排
1005 ACM组队安排 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Pro ...
- js基础用法1
click() 对象.click() 使对象被点击.closed 对象.closed 对象窗口是否已封闭true/falseclearTimeout(对象) 清除已设置的setTimeout对象cle ...
- bzoj2809 [Apio2012]dispatching——左偏树(可并堆)
题目:https://www.lydsy.com/JudgeOnline/problem.php?id=2809 思路有点暴力和贪心,就是 dfs 枚举每个点作为管理者: 当然它的子树中派遣出去的忍者 ...
- vertical-align 和line-height 以及baseline的解析
line-height是相对于font-size来计算的,vertical-align的百分比值是相对于line-height来计算的,vertical-align的默认是baseline; demo ...