[Andriod公式トレーニングチュートリアル]Activityのライフ活動の停止とActivityの再起動を管理
----------------------------------------------------------------------------------------------------------------------
Properly stopping and restarting your activity is an important process in the activity lifecycle that ensures your users perceive that your app is always alive and doesn't lose their progress. There are a few of key scenarios in which your activity is stopped and restarted:
activityのライフサイクルでは、activityを適切に停止して再起動することは非常に重要なプロセスであり、ユーザーがappがプロセスを失うのではなく、常に活発であることを感じることができることを保証します.次の場合、activityを停止または再起動する必要があります.
The
Activity class provides two lifecycle methods, onStop() and onRestart() , which allow you to specifically handle how your activity handles being stopped and restarted. Unlike the paused state, which identifies a partial UI obstruction, the stopped state guarantees that the UI is no longer visible and the user's focus is in a separate activity (or an entirely separate app). Activityクラスは、2つのライフサイクルメソッド、
onStop()およびonRestart()， activity 。 （ UI ） ， UI ， activity （ app）。を提供します.Note: Because the system retains your
Activity instance in system memory when it is stopped, it's possible that you don't need to implement the onStop() and onRestart() (or even onStart() methods at all. For most activities that are relatively simple, the activity will stop and restart just fine and you might only need to use onPause() to pause ongoing actions and disconnect from system resources. 注:Activityインスタンスが停止してもシステムがメモリに残っているため、
onStop()およびonRestart()（ onStart() 。 activity， ， onPause() を する はありません).
Figure 1. When the user leaves your activity, the system calls onStop() to stop the activity (1). If the user returns while the activity is stopped, the system calls onRestart() (2), quickly followed by onStart() (3) and onResume() (4). Notice that no matter what scenario causes the activity to stop, the system always calls onPause() before calling onStop() .
1.ユーザーがactivityを れると、システムはonStop() activity (1)。 activity ， onRestart() (2)， onStart()(3)とonResume()(4)を び します.いずれの もactivityを させると、システムはonPause()を び してからonStop()を び すことに してください.
Stop Your Activity-あなたの を します
When your activity receives a call to the onStop() method, it's no longer visible and should release almost all resources that aren't needed while the user is not using it. Once your activity is stopped, the system might destroy the instance if it needs to recover system memory. In extreme cases, the system might simply kill your app process without calling the activity's final onDestroy() callback, so it's important you use onStop() to release resources that might leak memory.
activityがonStop()メソッドの び しを すると、それは されなくなり、ほとんどのユーザーが しないで なリソースを する があります.activityが すると、システムがシステムメモリを する がある 、このインスタンスが される があります. な 、activityの のonDestroy() ， onStop() 。を び す がなく、appプロセスを す があります.
Although the onPause() method is called before onStop() , you should use onStop() to perform larger, more CPU intensive shut-down operations, such as writing information to a database.
onPause()メソッドはonStop() ， onStop() 、 CPU ， 。であるにもかかわらず
For example, here's an implementation of onStop() that saves the contents of a draft note to persistent storage:
えば、 のonStop() ：
@Override
protected void onStop() {
super.onStop(); // Always call the superclass method first
// Save the note's current draft, because the activity is stopping
// and we want to be sure the current note progress isn't lost.
ContentValues values = new ContentValues();
values.put(NotePad.Notes.COLUMN_NAME_NOTE, getCurrentNoteText());
values.put(NotePad.Notes.COLUMN_NAME_TITLE, getCurrentNoteTitle());
getContentResolver().update(
mUri, // The URI for the note to update.
values, // The map of column names and new values to apply to them.
null, // No SELECT criteria are used.
null // No WHERE columns are used.
);
}
When your activity is stopped, the Activity object is kept resident in memory and is recalled when the activity resumes. You don’t need to re-initialize components that were created during any of the callback methods leading up to the Resumed state. The system also keeps track of the current state for each View in the layout, so if the user entered text into an EditText widget, that content is retained so you don't need to save and restore it.
activityが するとActivity ， activity 。 。 View ， EditText ， 。Note: Even if the system destroys your activity while it's stopped, it still retains the state of the View objects (such as text in an EditText ) in a Bundle (a blob of key-value pairs) and restores them if the user navigates back to the same instance of the activity (thenext lesson talks more about using a Bundle to save other state data in case your activity is destroyed and recreated).
:activityが したときにシステムが したとしても、 じactivityインスタンスシステムにナビゲートすると ロードされます(next lessonでは、activityが および されたときにBundleを して の を する についてさらに します).
Start/Restart Your Activity-アクティビティの /
When your activity comes back to the foreground from the stopped state, it receives a call to Bundle . The system also calls the EditText method, which happens every time your activity becomes visible (whether being restarted or created for the first time). The onRestart() method, however, is called only when the activity resumes from the stopped state, so you can use it to perform special restoration work that might be necessary only if the activity was previously stopped, but not destroyed.
Activityが からフロントに るとonStart()が されます
It's uncommon that an app needs to use onRestart() to restore the activity's state, so there aren't any guidelines for this method that apply to the general population of apps. However, because your onRestart() 。 onStart() ， activity （ ）。 ，onRestart() activity ， （ activity ）。 method should essentially clean up all your activity's resources, you'll need to re-instantiate them when the activity restarts. Yet, you also need to instantiate them when your activity is created for the first time (when there's no existing instance of the activity). For this reason, you should usually use the onRestart() callback method as the counterpart to the onStop() method, because the system calls onStart() both when it creates your activity and when it restarts the activity from the stopped state.
1つのappがonRestart()を してactivityの を ロードする があるのは ではないため、この appに する には の もありません.しかし、onStop()メソッドは にactivityのすべてのリソースをクリアする があるため、activityが すると インスタンス する があります.しかし、activityが めて された ( するactivityインスタンスがない )、インスタンス する があります.このため、onStop()メソッドの バージョンとしてonStart()コールバック を する があります.なぜなら、システムはactivityの と にactivityを するとonStart()を び すからです.
For example, because the user might have been away from your app for a long time before coming back it, the onStop() method is a good place to verify that required system features are enabled:
たとえば、ユーザーが るとappから い れている があるため、onStart()メソッドはシステムのパフォーマンスが であることを する の です.@Override
protected void onStart() {
super.onStart(); // Always call the superclass method first
// The activity is either being restarted or started for the first time
// so this is where we should make sure that GPS is enabled
LocationManager locationManager =
(LocationManager) getSystemService(Context.LOCATION_SERVICE);
boolean gpsEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
if (!gpsEnabled) {
// Create a dialog here that requests the user to enable GPS, and use an intent
// with the android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS action
// to take the user to the Settings screen to enable GPS when they click "OK"
}
}
@Override
protected void onRestart() {
super.onRestart(); // Always call the superclass method first
// Activity being restarted from stopped state
}
When the system destroys your activity, it calls the onStart() method for your onStart() . Because you should generally have released most of your resources with onDestroy() , by the time you receive a call to Activity , there's not much that most apps need to do. This method is your last chance to clean out resources that could lead to a memory leak, so you should be sure that additional threads are destroyed and other long-running actions like method tracing are also stopped.
システムがactivityを すると、Activity()メソッドが び されます.onStop()でほとんどのリソースを する があるので、onDestroy()の び しを け るまで、ほとんどのappはあまり くのことをする はありません.この は、メモリの を き こすリソースを する の です.そのため、 のスレッドがすべて され、 などの な も していることを する があります.onStop() onDestroy()