活动何时可见？ 在 onStart() 或 onResume() 之后？

Question

Docs say:

The visible lifetime of an activity happens between a call to onStart() until a corresponding call to onStop() .

Also in this one you can see:

The onStart() call makes the activity visible to the user...

So I thought the UI of Activity must be visible after returning from onStart() .

Recently, for testing purpose, I put an infinite loop in onResume() and guessed that the UI of Activity must be visible. But the result of starting Activity was a white window without any UI.

So it seems that UI of Activity will be visible after returning from onResume() instead of returning from onStart() . Is this true? If yes, why docs do say such misleading statements?

Edit:

You may think like Công Hải which says :

I think the documents mention about window visible not view visible.

But I do not think that "visibility" means above mentioned "white window"; because if you put an infinite loop in onCreate() , result of starting Activity again will be a white window, while as docs say the onCreate() is not in "visible lifetime" of Activity. So "visibility of Activity" must mean another thing than "white window".

Edit2

Alongside official docs, many tutorials say the Activity will be visible by calling onStart() and interactive by calling onResume() . Are they all say incorrect thing without testing?

Answer 1

Take a closer look at the docs that you linked . It states:

If an activity has lost focus but is still presented to the user, it is visible. It is possible if a new non-full-sized or transparent activity has focus on top of your activity, another activity has higher position in multi-window mode, or the activity itself is not focusable in current windowing mode. Such activity is completely alive (it maintains all state and member information and remains attached to the window manager).

If an activity is completely obscured by another activity, it is stopped or hidden. It still retains all state and member information, however, it is no longer visible to the user so its window is hidden and it will often be killed by the system when memory is needed elsewhere.

[...]

The visible lifetime of an activity happens between a call to onStart() until a corresponding call to onStop(). During this time the user can see the activity on-screen, though it may not be in the foreground and interacting with the user. Between these two methods you can maintain resources that are needed to show the activity to the user. For example, you can register a BroadcastReceiver in onStart() to monitor for changes that impact your UI, and unregister it in onStop() when the user no longer sees what you are displaying. The onStart() and onStop() methods can be called multiple times, as the activity becomes visible and hidden to the user.

This paints a pretty clear picture of what is meant by "visible": Your activity controls at least a part of what is shown on the screen.

With blocking onResume you have prevented your activity from launching as normal and/or rendering your content but it is still visible to the user (the white screen) and obscuring a previously visible activity.

Answer 2

Putting an infinite loop in onResume() is not really going to tell you the whole story. There are a lot of activities that are queued to the main (UI) thread (like painting the screen) and since onResume() is called on the main (UI) thread you are preventing Android from doing any work on the main (UI) thread. This is why you see a white (or black) screen in this case.

To answer your question, Activity will be visible after onResume() .

Answer 3

Please look at the activity life-cycle.

The activity is visible and running between onResume() and onPause() . For more info refer this docs .

Now coming back to why you see white screen.

Views are drawn asynchronously - meaning that execution of your code does not wait until views are drawn. If onResume() is called before all the views are rendered and your infinity loop starts - it will eat up all the computing power and your UI will not be rendered.

Let me make it more clear. Why you ask about views not showing when placing infinite loop in onResume ? why don't you ask why views are not created even though infinite loop comes after setContentView in onCreate itself?

To further point-out the source of your misunderstanding -- you think that onStart and onResume are called only after views are created. This is not true . onStart and onResume can be called even before drawing of views is not completed. So, the situation could be that your views may exist in memory but are not yet rendered.

One more things worth noting

1. It is not mandatory to call setContentView() in onCreate , you can call it even in onStart or onResume

If for some reason you want to wait for a particulate view to be drawn before doing something, you must run your code in postRunnable

yourView.post(new Runnable({
   public void run(){
   // do your stuff
   }
}));