![\"https:\/\/i.stack.imgur.com\/kChdb.png\"](\"https:\/\/i.stack.imgur.com\/kChdb.png\")
<\/h2>\n<\/h2>\n<\/p>\n
\nonCreate()<\/h3>\n<\/blockquote>\n
You must implement this callback, which fires when the system first creates the activity. On activity creation, the activity enters the Created<\/em> state. In the
onCreate()<\/a><\/code> method, you perform basic application startup logic that should happen only once for the entire life of the activity. For example, your implementation ofonCreate()<\/a><\/code> might bind data to lists, initialize background threads, and instantiate some class-scope variables. This method receives the parametersavedInstanceState<\/code>, which is aBundle<\/a><\/code> object containing the activity’s previously saved state. If the activity has never existed before, the value of theBundle<\/a><\/code> object is null.<\/p>\nThe following example of the
onCreate()<\/a><\/code> method shows fundamental setup for the activity, such as declaring the user interface (defined in an XML layout file), defining member variables, and configuring some of the UI. In this example, the XML layout file is specified by passing file\u2019s resource IDR.layout.main_activity<\/code> tosetContentView()<\/a><\/code>.<\/p>\nTextView<\/span> mTextView<\/span>;<\/span>\n\n\/\/ some transient state for the activity instance<\/span>\nString<\/span> mGameState<\/span>;<\/span>\n\n@Override<\/span>\npublic<\/span> void<\/span> onCreate<\/span>(<\/span>Bundle<\/span> savedInstanceState<\/span>)<\/span> {<\/span>\n <\/span>\/\/ call the super class onCreate to complete the creation of activity like<\/span>\n <\/span>\/\/ the view hierarchy<\/span>\n <\/span>super<\/span>.<\/span>onCreate<\/span>(<\/span>savedInstanceState<\/span>);<\/span>\n\n <\/span>\/\/ recovering the instance state<\/span>\n <\/span>if<\/span> (<\/span>savedInstanceState <\/span>!=<\/span> null<\/span>)<\/span> {<\/span>\n mGameState <\/span>=<\/span> savedInstanceState<\/span>.<\/span>getString<\/span>(<\/span>GAME_STATE_KEY<\/span>);<\/span>\n <\/span>}<\/span>\n\n <\/span>\/\/ set the user interface layout for this Activity<\/span>\n <\/span>\/\/ the layout file is defined in the project res\/layout\/main_activity.xml file<\/span>\n setContentView<\/span>(<\/span>R<\/span>.<\/span>layout<\/span>.<\/span>main_activity<\/span>);<\/span>\n\n <\/span>\/\/ initialize member TextView so we can manipulate it later<\/span>\n mTextView <\/span>=<\/span> (<\/span>TextView<\/span>)<\/span> findViewById<\/span>(<\/span>R<\/span>.<\/span>id<\/span>.<\/span>text_view<\/span>);<\/span>\n}<\/span>\n\n\/\/ This callback is called only when there is a saved instance previously saved using<\/span>\n\/\/ onSaveInstanceState(). We restore some state in onCreate() while we can optionally restore<\/span>\n\/\/ other state here, possibly usable after onStart() has completed.<\/span>\n\/\/ The savedInstanceState Bundle is same as the one used in onCreate().<\/span>\n@Override<\/span>\npublic<\/span> void<\/span> onRestoreInstanceState<\/span>(<\/span>Bundle<\/span> savedInstanceState<\/span>)<\/span> {<\/span>\n mTextView<\/span>.<\/span>setText<\/span>(<\/span>savedInstanceState<\/span>.<\/span>getString<\/span>(<\/span>TEXT_VIEW_KEY<\/span>));<\/span>\n}<\/span>\n\n\/\/ invoked when the activity may be temporarily destroyed, save the instance state here<\/span>\n@Override<\/span>\npublic<\/span> void<\/span> onSaveInstanceState<\/span>(<\/span>Bundle<\/span> outState<\/span>)<\/span> {<\/span>\n outState<\/span>.<\/span>putString<\/span>(<\/span>GAME_STATE_KEY<\/span>,<\/span> mGameState<\/span>);<\/span>\n outState<\/span>.<\/span>putString<\/span>(<\/span>TEXT_VIEW_KEY<\/span>,<\/span> mTextView<\/span>.<\/span>getText<\/span>());<\/span>\n\n <\/span>\/\/ call superclass to save any view hierarchy<\/span>\n <\/span>super<\/span>.<\/span>onSaveInstanceState<\/span>(<\/span>outState<\/span>);<\/span>\n}<\/span><\/pre>\nAs an alternative to defining the XML file and passing it to
setContentView()<\/a><\/code>, you can create newView<\/a><\/code> objects in your activity code and build a view hierarchy by inserting newView<\/a><\/code>s into aViewGroup<\/a><\/code>. You then use that layout by passing the rootViewGroup<\/a><\/code> tosetContentView()<\/a><\/code>. For more information about creating a user interface, see the User Interface<\/a> documentation.<\/p>\nYour activity does not reside in the Created state. After the
onCreate()<\/a><\/code> method finishes execution, the activity enters the Started<\/em> state, and the system calls theonStart()<\/a><\/code> andonResume()<\/a><\/code> methods in quick succession. The next section explains theonStart()<\/a><\/code> callback.<\/p>\n
\nonStart()<\/h3>\n<\/blockquote>\n
When the activity enters the Started state, the system invokes this callback. The
onStart()<\/a><\/code> call makes the activity visible to the user, as the app prepares for the activity to enter the foreground and become interactive. For example, this method is where the app initializes the code that maintains the UI. It might also register aBroadcastReceiver<\/a><\/code> that monitors changes that are reflected in the UI.<\/p>\nThe
onStart()<\/a><\/code> method completes very quickly and, as with the Created state, the activity does not stay resident in the Started state. Once this callback finishes, the activity enters the Resumed<\/em> state, and the system invokes theonResume()<\/a><\/code> method.<\/p>\n
\nonResume()<\/h3>\n<\/blockquote>\n
When the activity enters the Resumed state, it comes to the foreground, and then the system invokes the
onResume()<\/a><\/code> callback. This is the state in which the app interacts with the user. The app stays in this state until something happens to take focus away from the app. Such an event might be, for instance, receiving a phone call, the user\u2019s navigating to another activity, or the device screen\u2019s turning off.<\/p>\nWhen an interruptive event occurs, the activity enters the Paused<\/em> state, and the system invokes the
onPause()<\/a><\/code> callback.<\/p>\nIf the activity returns to the Resumed state from the Paused state, the system once again calls
onResume()<\/a><\/code> method. For this reason, you should implementonResume()<\/a><\/code> to initialize components that you release duringonPause()<\/a><\/code>. For example, you may initialize the camera as follows:<\/p>\n@Override<\/span>\npublic<\/span> void<\/span> onResume<\/span>()<\/span> {<\/span>\n <\/span>super<\/span>.<\/span>onResume<\/span>();<\/span> <\/span>\/\/ Always call the superclass method first<\/span>\n\n\n <\/span>\/\/ Get the Camera instance as the activity achieves full user focus<\/span>\n <\/span>if<\/span> (<\/span>mCamera <\/span>==<\/span> null<\/span>)<\/span> {<\/span>\n initializeCamera<\/span>();<\/span> \/\/ Local method to handle camera init<\/span>\n <\/span>}<\/span>\n}<\/span>\n <\/span><\/pre>\nBe aware that the system calls this method every time your activity comes into the foreground, including when it’s created for the first time. As such, you should implement
onResume()<\/a><\/code> to initialize components that you release duringonPause()<\/a><\/code>, and perform any other initializations that must occur each time the activity enters the Resumed state. For example, you should begin animations and initialize components that the activity only uses when it has user focus.<\/p>\n
\nonPause()<\/h3>\n<\/blockquote>\n
The system calls this method as the first indication that the user is leaving your activity (though it does not always mean the activity is being destroyed). Use the
onPause()<\/a><\/code> method to pause operations such animations and music playback that should not continue while theActivity<\/a><\/code> is in the Paused state, and that you expect to resume shortly. There are several reasons why an activity may enter this state. For example:<\/p>\n\n
- Some event interrupts app execution, as described in the onResume()<\/a> section. This is the most common case.<\/li>\n