Vienos veiklos būsena. Theory

Size: px

Start display at page:

Download "Vienos veiklos būsena. Theory"

Eugene Hunter
5 years ago
Views:

1 Vienos veiklos būsena Theory While application is running, we create new Activities and close old ones, hide the application and open it again and so on, and Activity can process all these events. It is required, for example, to free resources or to save data. It is described in detail in documentation. Activity, created in a running application can be in one of three states: Resumed - Activity is visible on the screen, it is focused and the user can interact with it. This state is sometimes called Running Paused - Activity is not focused, user cannot interact with it, but it is visible (it is covered by another Activity, which doesn t cover the whole screen or is transparent) Stopped - Activity is not visible (is completely covered by another Activity), that is, it is not focused and user cannot interact with it When Activity goes from one state to another, the system invokes its different methods, which we can fill in with our code. This can be illustrated as a diagram: 1

2 To simplify understanding I ve given a brief state description in brackets below the state names. Cross means that Activity does not exist. So we have the following methods that are invoked by the system: oncreate() - invoked when Activity is created for the first time onstart() - invoked before Activity is shown to the user onresume() - invoked before Activity becomes available for user interaction onpause() - invoked before another Activity is shown onstop() - invoked when Activity is not visible to the user ondestroy() - invoked before Activity is destroyed That is, these methods do NOT cause state changes. But vice-versa, state change of an Activity is a trigger which invokes these methods. We are informed about state changes in this way, so we can react accordingly. Let s see in which order are these methods invoked in practice. Practice In this lesson we will have to emulate screen orientation changes. But Android emulator 2.3 does it wrong, so we will use 2.2 version in this project. To do so, we need to create a new AVD version 2.2 2

3 Let s create a project (Note that we use Android 2.2 version): Project name: P0231_OneActivityState Build Target: Android 2.2 Application name: OneActivityState Package name: ru.startandroid.develop.p0231oneactivitystate Create Activity: MainActivity Do not change the layout. It is not important for now. Open MainActivity.java. There is some code by default as usual: package ru.startandroid.develop.p0231oneactivitystate; import android.app.activity; import android.os.bundle; public class MainActivity extends Activity { /** Called when the activity is first created. */ public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.main); We can see, that already familiar for us oncreate method is already implemented. I will repeat once again, it is important to understand that this method does NOT create an Activity. Creation is the system business. That is, the system creates an Activity and gives us an opportunity to participate in it and run our own code inside oncreate() method. We use this opportunity and tell the system that Activity should display the screen from R.layout.main. Let s add all the remaining methods from the diagram and add log entry to each of them. package ru.startandroid.develop.p0231oneactivitystate; import android.app.activity; import android.os.bundle; import android.util.log; public class MainActivity extends Activity { final String TAG = "States"; /** Called when the activity is first created. */ public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.main); Log.d(TAG, "MainActivity: oncreate()"); protected void onstart() { super.onstart(); Log.d(TAG, "MainActivity: onstart()"); protected void onresume() { 3

super.onresume(); Log.d(TAG, "MainActivity: onresume()"); protected void onpause() { super.onpause(); Log.d(TAG, "MainActivity: onpause()"); protected void onstop() { super.onstop(); Log.

4 super.onresume(); Log.d(TAG, "MainActivity: onresume()"); protected void onpause() { super.onpause(); Log.d(TAG, "MainActivity: onpause()"); protected void onstop() { super.onstop(); Log.d(TAG, "MainActivity: onstop()"); protected void ondestroy() { super.ondestroy(); Log.d(TAG, "MainActivity: ondestroy()"); While implementing these methods always invoke the corresponding superclass methods and always before your code. See the code above. Each method contains superclass method invocation and our own code is located after it. Now, when the methods will be invoked we will see it in logs. Configure filter for the "States" tag, to not look for your messages in the pile of other logs. We ve learnt how it is done in the lesson 12 Save everything and run the application. After running see the log: MainActivity: oncreate() MainActivity: onstart() MainActivity: onresume() Activity has been created, passed two states (Stopped, Paused) and now is in the third state - Resumed. It means it was created (oncreate), displayed (onstart) and gained the ability to interact with the user (onresume). Now press the Back button in the emulators. Activity has closed. See the log: 4

5 MainActivity: onpause() MainActivity: onstop() MainActivity: ondestroy() Activity does the opposite to its creation. At first, the focus is lost (onpause ), than it disappears from the screen (onstop), then destroyed completely (ondestroy). Screen orientation change Let s see how will Activity behave when we change our screen orientation. Run the application again (or find it in the list of running applications on the emulator or press CTRL + F11 in Eclipse). Three methods that were invoked on creation are displayed. Now press CTRL + F12 in the emulator, the orientation has changed. It looks like nothing special has happened, but have a look at the logs and see: MainActivity: onpause() MainActivity: onstop() MainActivity: ondestroy() MainActivity: oncreate() MainActivity: onstart() MainActivity: onresume() Activity is completely destroyed and created again. During this process, procedures of saving and restoring data usually occur, not to lose data and for application to save its appearance. We will talk in the next lessons about how it is done. There is also onrestart method. It is invoked before onstart if Activity is not created from scratch but is restored from the Stopped state. We will have look at this method in the next lesson. Usually in books this topic is presented a little bit different. But as for me, this template explanation seems not very clear, that s why I ve written my own. As usual, I hope that I ve managed to explain the subject well ) My advice for you is, after this lesson - to read documentation, link to which I ve provided in the beginning of the lesson. Everything is written very well there. And you will remember everything better. But for now, the most important thing is to understand in which moment each method is invoked. And later we will look through how we can use it and what to code there. 5

6 Dviejų veiklų būsena Let s create a project: Project name: P0241_TwoActivityState Build Target: Android Application name: TwoActivityState Package name: ru.startandroid.develop.p0241twoactivitystate Create Activity: MainActivity Write the following in main.xml: <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android=" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent"> <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="hello World, MainActivity!"> </TextView> <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="go to Activity Two" android:id="@+id/btnacttwo"> </Button> </LinearLayout> "Go to Activity Two" button will invoke the second Activity. Open MainActivity.java and write there all methods, including onrestart this time, and write log entries inside these methods. We also find and define the button and assign alistener to it. Do not write anything inside onclick method for now. package ru.startandroid.develop.p0241twoactivitystate; import android.app.activity; import android.content.intent; import android.os.bundle; import android.util.log; import android.view.view; import android.view.view.onclicklistener; import android.widget.button; public class MainActivity extends Activity implements OnClickListener { final String TAG = "States"; Button btnacttwo; 6

7 public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.main); btnacttwo = (Button) findviewbyid(r.id.btnacttwo); btnacttwo.setonclicklistener(this); Log.d(TAG, "MainActivity: oncreate()"); protected void onrestart() { super.onrestart(); Log.d(TAG, "MainActivity: onrestart()"); protected void onstart() { super.onstart(); Log.d(TAG, "MainActivity: onstart()"); protected void onresume() { super.onresume(); Log.d(TAG, "MainActivity: onresume()"); protected void onpause() { super.onpause(); Log.d(TAG, "MainActivity: onpause()"); protected void onstop() { super.onstop(); Log.d(TAG, "MainActivity: onstop()"); protected void ondestroy() { super.ondestroy(); Log.d(TAG, "MainActivity: ondestroy()"); public void onclick(view v) { 7

8 In the previous lesson we have seen which methods and in which order are invoked while working with one Activity. Now we are interested in behaviour having two Activities, that s why we create the second Activity. Let s name it ActivityTwo. Remember the previous lessons: we have to create a class with the same name which is a subclass of android.app.activity and register the new Activity inside the manifest-file. We also need to create a layout-file, name it two.xml and fill it in with the following code: <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android=" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent"> <TextView android:id="@+id/textview1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="this is Activity Two"> </TextView> </LinearLayout> We have just a TextView with some text to be clear that this is ActivityTwo. Create a class. ActivityTwo.java code: package ru.startandroid.develop.p0241twoactivitystate; import android.app.activity; import android.os.bundle; import android.util.log; public class ActivityTwo extends Activity { final String TAG = "States"; public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.two); Log.d(TAG, "ActivityTwo: oncreate()"); protected void onrestart() { super.onrestart(); Log.d(TAG, "ActivityTwo: onrestart()"); protected void onstart() { super.onstart(); Log.d(TAG, "ActivityTwo: onstart()"); 8

9 protected void onresume() { super.onresume(); Log.d(TAG, "ActivityTwo: onresume()"); protected void onpause() { super.onpause(); Log.d(TAG, "ActivityTwo: onpause()"); protected void onstop() { super.onstop(); Log.d(TAG, "ActivityTwo: onstop()"); protected void ondestroy() { super.ondestroy(); Log.d(TAG, "ActivityTwo: ondestroy()"); Don t forget to add the record about ActivityTwo to the manifest. And now we can add the onclick method code to MainActivity.java, invoking ActivityTwo there public void onclick(view v) { Intent intent = new Intent(this, ActivityTwo.class); startactivity(intent); (add only the underlined code). Log filter should remain from the previous lesson. We will use it. If not, create the filter by the tag States. Save everything and run the application. Step 1. Run the application. MainActivity appeared. 9

10 Logs: MainActivity: oncreate() MainActivity: onstart() MainActivity: onresume() Everything as the previous time - three methods are invoked. Activity goes through Stopped, Paused states and remains in the Resumed state. Step 2. Press "Go to Activity Two" button and ActivityTwo will appear. Logs: MainActivity: onpause() ActivityTwo: oncreate() ActivityTwo: onstart() ActivityTwo: onresume() MainActivity: onstop() Let s look through it. MainActivty.onPause invocation means that MainActivity loses its focus and goes to Pause state. After this, ActivityTwo is created (oncreate), displayed (onstart) and receives focus (onresume). After this MainActivity is not visible any more (onstop). Note, that ondestroy is not invoked for MainActivity and it means it is not destroyed. MainActivity remains in memory in the Stopped state. And ActivityTwo - is in the Resumed state. It is visible and focused, we can interact with it. 10

11 Step 3. Press the Back button on the emulator. We ve returned to the MainActivity. Logs: ActivityTwo: onpause() MainActivity: onrestart() MainActivity: onstart() MainActivity: onresume() ActivityTwo: onstop() ActivityTwo: ondestroy() ActivityTwo.onPause means that ActivityTwo loses its focus and goes to the Paused state. MainActivity now has to be restored from the Stopped state. In the end of the previous lesson I ve written: "onrestart method is invoked before the onstart method, if Activity is not created from scratch, but restored from the Stopped state" - this is exactly our case, MainActivity hasn t been killed by the system, it was still in memory. That is why MainActivity.onRestart is invoked. After this MainActivity.onStart and MainActivity.onResume are invoked - it means MainActivity went to Paused state (was displayed) and Resumed state (gained focus). And onstop and ondestroy methods invocation means that ActivityTwo changed its state to Stopped (was not visible any more) and has been destroyed. Step 4. Press back once again and the application is closed. 11

12 Logs: MainActivity: onpause() MainActivity: onstop() MainActivity: ondestroy() Logs show that MainActivity changed its state to Paused, Stopped and has been destroyed. If it is not clear from the fis time, try to repeat the algorithm for several times and check it with the diagram from the previous lesson. It is quite obvious and it will help you to get through. Try to draw the whole diagram on the sheet of paper and changes of the Activity state. I will also display the sequence of steps here to make it obvious. We found out that Activity is not necessarily destroyed when it is not visible and can be stored in RAM. Looking through this, I guess a question has appeared: why in the step 2 MainActivity disappeared from the screen, but was left in memory and was not destroyed? But in the step 3 ActivityTwo was destroyed just after it disappeared from the screen. And in the step 4 in the end MainActivity was destroyed. Why is step 2 exceptional? We will talk about this in the next lesson, as this lesson is already quite complicated. But the topic is extremely important and is one of the key concepts of the Android operating system. 12

UNDERSTANDING ACTIVITIES

UNDERSTANDING ACTIVITIES Activities Activity is a window that contains the user interface of your application. An Android activity is both a unit of user interaction - typically filling the whole screen of an Android mobile device