An activity is a class that represents a single screen. It is like a Frame in AWT.
A view is the UI element such as button, label, text field etc. Anything that you see is a view.
Intent is used to invoke components. It is mainly used to:
- Start the service
- Launch an activity
- Display a web page
- Display a list of contacts
- Broadcast a message
- Dial a phone call etc.
Service is a background process that can run for a long time.
There are two types of services local and remote.
Local service is accessed from within the application whereas remote service is accessed remotely from other applications running on the same device.
Content Providers are used to share data between the applications.
ContentProvider manages access to a structured set of data. It encapsulates the data and provide mechanisms for defining data security.
ContentProvider is the standard interface that connects data in one process with code running in another process.
Fragments are like parts of activity. An activity can display one or more fragments on the screen at the same time.
It contains informations about activities, content providers, permissions etc. It is like the web.xml file in Java EE.
Android Virtual Device (AVD)
It is used to test the android application without the need for mobile or tablet etc. It can be created in different configurations to emulate different types of real devices.
2) About Activity LifeCycle
Activity is visible and interacts with the user.
Activity is still visible but partially obscured, instance is running but might be killed by the system.
Activity is not visible, instance is running but might be killed by the system.
Activity has been terminated by the system of by a call to its
Called then the activity is created.
Used to initialize the activity, for example create the user interface.
Called if the activity get visible again and the user starts interacting with the activity again.
Used to initialize fields, register listeners, bind to services, etc.
Called once another activity gets into the foreground. Always called before the activity is not visible anymore.
Used to release resources or save application data. For example you unregister listeners, intent receivers, unbind from services or remove system service listeners.
Called once the activity is no longer visible.
Time or CPU intensive shut-down operations, such as writing information to a database should be down in the
This method is guaranteed to be called as of API 11.
3) Saving and restoring Activity Instance State
Instance state of an activity which is required to restore the activity to the state in which the user left it. This is non-persistent application data that needs to be passed between activities restarts during a configuration change to restore user selections. The application is responsible for restoring its instance state.
Assume for example the user scrolled through a
ListView with thousands of items and the activity is recreated. Loosing the position in the list is annoying for the user, hence the position should be restored.
onSaveInstanceState() can be used to store this instance state as a
Bundle . A
Bundle can contain primitive data types, arrays, String and objects which are of the
Bundle data is passed at restart of the activity to the
onCreate() method and
onRestoreInstanceState() as parameter.
If you override
onRestoreInstanceState() you should call the super implementation of it, because the default views of Android store their data via a call to
View.onSaveInstanceState from the
onSaveInstanceState() method of the activity. For example
EditText stores its content via the default call of this method.
onRestoreInstanceState() or the
onCreate() methods can be used to recreate the instance scope of an activity if it is restarted.
Prefer using the
onRestoreInstanceState() method for restoring the instance state. This approach separates the initial setup from restoring the state.
If the user interacts with an activity and presses the Back button or if the
finish() method of an activity is called, the activity is removed from the current activity stack and recycled. In this case there is no instance state to save and the
onSaveInstanceState() method is not called.
If the user interacts with an activity and presses the Home button, the activity instance state must be saved. The
onSaveInstanceState() method is called. If the user restarts the application it will resume or restart the last running activity. If it restarts the activity it provides the bundle with the save data to the
onSaveInstanceState() method is not called if the user presses the back button. Don’t use this approach to save the data which needs to get persisted.