Android 开发指南 翻译7 Application Resources: Handling Runtime Changes
应用资源:处理运行时改变
Some device configurations can change during runtime (such as screen orientation, keyboard availability, and language). When such a change occurs, Android restarts the running Activity
(onDestroy()
is called, followed by onCreate()
). The restart behavior is designed to help your application adapt to new configurations by automatically reloading your application with alternative resources that match the new device configuration.
一些设备配置可以在运行期间改变。当改变发生时,Android会重启运行的Activity。重新启动是为了帮助应用自动载入匹配新的设备配置的可选资源。
To properly handle a restart, it is important that your activity restores its previous state through the normal Activity lifecycle, in which Android calls onSaveInstanceState()
before it destroys your activity so that you can save data about the application state. You can then restore the state during onCreate()
or onRestoreInstanceState()
.
To test that your application restarts itself with the application state intact, you should invoke configuration changes (such as changing the screen orientation) while performing various tasks in your application. Your application should be able to restart at any time without loss of user data or state in order to handle events such as configuration changes or when the user receives an incoming phone call and then returns to your application much later after your application process may have been destroyed. To learn how you can restore your activity state, read about the Activity lifecycle.
However, you might encounter a situation in which restarting your application and restoring significant amounts of data can be costly and create a poor user experience. In such a situation, you have two other options:
然而,你可能会遇到一种情况:重启应用装载大量数据代价很大,用户体验不好。这时,你有2中选择:
-
Retain an object during a configuration change
Allow your activity to restart when a configuration changes, but carry a stateful
Object
to the new instance of your activity.允许重新启动,但传递一个状态对象给新Activity。
-
Handle the configuration change yourself
Prevent the system from restarting your activity during certain configuration changes, but receive a callback when the configurations do change, so that you can manually update your activity as necessary.
禁止某些配置改变引起的重启,单改变发生时,接收的一个回调方法,自己来手动处理。
Retaining an Object During a Configuration Change
配置改变时,保留对象If restarting your activity requires that you recover large sets of data, re-establish a network connection, or perform other intensive operations, then a full restart due to a configuration change might be a slow user experience. Also, it might not be possible for you to completely restore your activity state with the Bundle
that the system saves for you with the onSaveInstanceState()
callback—it is not designed to carry large objects (such as bitmaps) and the data within it must be serialized then deserialized, which can consume a lot of memory and make the configuration change slow. In such a situation, you can alleviate the burden of reinitializing your activity by retaining a stateful Object
when your activity is restarted due to a configuration change.
To retain an object during a runtime configuration change:
- Override the
onRetainNonConfigurationInstance()
method to return the object you would like to retain. - When your activity is created again, call
getLastNonConfigurationInstance()
to recover your object.
When the Android system shuts down your activity due to a configuration change, it calls onRetainNonConfigurationInstance()
between the onStop()
andonDestroy()
callbacks. In your implementation of onRetainNonConfigurationInstance()
, you can return any Object
that you need in order to efficiently restore your state after the configuration change.
A scenario in which this can be valuable is if your application loads a lot of data from the web. If the user changes the orientation of the device and the activity restarts, your application must re-fetch the data, which could be slow. What you can do instead is implement onRetainNonConfigurationInstance()
to return an object carrying your data and then retrieve the data when your activity starts again with getLastNonConfigurationInstance()
. For example:
@Override
public Object onRetainNonConfigurationInstance() {
final MyDataObject data = collectMyLoadedData();
return data;
}
Caution: While you can return any object, you should never pass an object that is tied to the Activity
, such as a Drawable
, an Adapter
, a View
or any other object that's associated with a Context
. If you do, it will leak all the views and resources of the original activity instance. (Leaking resources means that your application maintains a hold on them and they cannot be garbage-collected, so lots of memory can be lost.)
Then retrieve the data when your activity starts again:
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
final MyDataObject data = (MyDataObject) getLastNonConfigurationInstance();
if (data == null) {
data = loadMyData();
}
...
}
In this case, getLastNonConfigurationInstance()
returns the data saved by onRetainNonConfigurationInstance()
. If data
is null (which happens when the activity starts due to any reason other than a configuration change) then this code loads the data object from the original source.
Handling the Configuration Change Yourself
自己处理配置改变If your application doesn't need to update resources during a specific configuration change and you have a performance limitation that requires you to avoid the activity restart, then you can declare that your activity handles the configuration change itself, which prevents the system from restarting your activity.
Note: Handling the configuration change yourself can make it much more difficult to use alternative resources, because the system does not automatically apply them for you. This technique should be considered a last resort when you must avoid restarts due to a configuration change and is not recommended for most applications.
To declare that your activity handles a configuration change, edit the appropriate <activity>
element in your manifest file to include the android:configChanges
attribute with a value that represents the configuration you want to handle. Possible values are listed in the documentation for the android:configChanges
attribute (the most commonly used values are "orientation"
to prevent restarts when the screen orientation changes and "keyboardHidden"
to prevent restarts when the keyboard availability changes). You can declare multiple configuration values in the attribute by separating them with a pipe |
character.
For example, the following manifest code declares an activity that handles both the screen orientation change and keyboard availability change:
<activity android:name=".MyActivity"
android:configChanges="orientation|keyboardHidden"
android:label="@string/app_name">
Now, when one of these configurations change, MyActivity
does not restart. Instead, the MyActivity
receives a call to onConfigurationChanged()
. This method is passed a Configuration
object that specifies the new device configuration. By reading fields in the Configuration
, you can determine the new configuration and make appropriate changes by updating the resources used in your interface. At the time this method is called, your activity's Resources
object is updated to return resources based on the new configuration, so you can easily reset elements of your UI without the system restarting your activity.
Caution: Beginning with Android 3.2 (API level 13), the "screen size" also changes when the device switches between portrait and landscape orientation. Thus, if you want to prevent runtime restarts due to orientation change when developing for API level 13 or higher (as declared by theminSdkVersion
and targetSdkVersion
attributes), you must include the "screenSize"
value in addition to the "orientation"
value. That is, you must decalare android:configChanges="orientation|screenSize"
. However, if your application targets API level 12 or lower, then your activity always handles this configuration change itself (this configuration change does not restart your activity, even when running on an Android 3.2 or higher device).
For example, the following onConfigurationChanged()
implementation checks the current device orientation:
@Override
public void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
// Checks the orientation of the screen
if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
Toast.makeText(this, "landscape", Toast.LENGTH_SHORT).show();
} else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT){
Toast.makeText(this, "portrait", Toast.LENGTH_SHORT).show();
}
}
The Configuration
object represents all of the current configurations, not just the ones that have changed. Most of the time, you won't care exactly how the configuration has changed and can simply re-assign all your resources that provide alternatives to the configuration that you're handling. For example, because the Resources
object is now updated, you can reset any ImageView
s with setImageResource()
and the appropriate resource for the new configuration is used (as described in Providing Resources).
Configuration对象代表当前所有的配置,不只是改变的。大多数情况下,你不必关心配置如何改变,只是重新分配适合配置信息的资源。Resouces对象已经更新,你可以使用setImageResource()使用合适的资源重置ImageView.
Notice that the values from the Configuration
fields are integers that are matched to specific constants from the Configuration
class. For documentation about which constants to use with each field, refer to the appropriate field in the Configuration
reference.
Remember: When you declare your activity to handle a configuration change, you are responsible for resetting any elements for which you provide alternatives. If you declare your activity to handle the orientation change and have images that should change between landscape and portrait, you must re-assign each resource to each element during onConfigurationChanged()
.
If you don't need to update your application based on these configuration changes, you can instead not implement onConfigurationChanged()
. In which case, all of the resources used before the configuration change are still used and you've only avoided the restart of your activity. However, your application should always be able to shutdown and restart with its previous state intact, so you should not consider this technique an escape from retaining your state during normal activity lifecycle. Not only because there are other configuration changes that you cannot prevent from restarting your application, but also because you should handle events such as when the user leaves your application and it gets destroyed before the user returns to it.
For more about which configuration changes you can handle in your activity, see the android:configChanges
documentation and the Configuration
class.