What is activities in android

Launch your application, open some new Activity, do some work. Hit the Home button application will be in the background, in stopped state. Return back to your application launch from Recent apps. There are four main Android app components: activities , services , content providers , and broadcast receivers.

Whenever you create or use any of them, you must include elements in the project manifest. When an app is launched from the home screen on an Android device, the Android OS creates an instance of the activity in the application you have declared to be the launcher activity. An Intent object carries information that the Android system uses to determine which component to start such as the exact component name or component category that should receive the intent , plus information that the recipient component uses in order to properly perform the action such as the action to take and the ….

Called when the Activity is still partially visible, but the user is probably navigating away from your Activity entirely in which case onStop will be called next. For example, when the user taps the Home button, the system calls onPause and onStop in quick succession on your Activity.

Skip to content Android Windows Linux Apple. Home » Android. See also Why Do Androids have white blood? Related posts: What is meant by services in Android? How many activities can an Android app have? When the system calls onPause for your activity, it technically means your activity is still partially visible, but most often is an indication that the user is leaving the activity, and the activity will soon enter the Stopped or Resumed state. An activity in the Paused state may continue to update the UI if the user is expecting the UI to update.

Examples of such an activity include one showing a navigation map screen or a media player playing. Even if such activities lose focus, the user expects their UI to continue updating. You should not use onPause to save application or user data, make network calls, or execute database transactions. For information about saving data, see Saving and restoring activity state. Once onPause finishes executing, the next callback is either onStop or onResume , depending on what happens after the activity enters the Paused state.

The system calls onStop when the activity is no longer visible to the user. This may happen because the activity is being destroyed, a new activity is starting, or an existing activity is entering a Resumed state and is covering the stopped activity. In all of these cases, the stopped activity is no longer visible at all.

The next callback that the system calls is either onRestart , if the activity is coming back to interact with the user, or by onDestroy if this activity is completely terminating. The system invokes this callback when an activity in the Stopped state is about to restart.

This callback is always followed by onStart. This callback is the final one that the activity receives. This section provides only an introduction to this topic.

For a more detailed treatment of the activity lifecycle and its callbacks, see The Activity Lifecycle. Content and code samples on this page are subject to the licenses described in the Content License. App Basics. Build your first app. App resources. Resource types. App manifest file. Device compatibility. Multiple APK support. Tablets, large screens, and foldables. Build responsive UIs. Build for foldables. Getting started. Handling data.

User input. Watch Face Studio. Health services. Creating watch faces. Android TV. Build TV Apps. Build TV playback apps. Help users find content on TV. Recommend TV content. Watch Next. Build TV games. Build TV input services. TV Accessibility. Android for Cars. Build media apps for cars. Build navigation, parking, and charging apps for cars.

Android Things. Supported hardware. Advanced setup. Build apps. Create a Things app. Communicate with wireless devices. Configure devices. Interact with peripherals. Build user-space drivers. Manage devices. Create a build. Push an update. Chrome OS devices. App architecture. Architecture Components. UI layer libraries. View binding. Data binding library. Lifecycle-aware components. Paging Library.

Paging 2. Data layer libraries. How-To Guides. Advanced Concepts. Threading in WorkManager. App entry points. App shortcuts. App navigation. Navigation component. App links. Dependency injection. Core topics. App compatibility. Interact with other apps. Package visibility.

In addition to simply starting one activity from another, you also use intents to pass information between activities. The intent object you use to start an activity can include intent data the URI of an object to act on , or intent extras , which are bits of additional data the activity might need.

You can use either intent data and intent extras to pass data between the activities. There are several key differences between data and extras that determine which you should use. The intent data can hold only one piece of information. A URI representing the location of the data you want to operate on. Intent extras are for any other arbitrary data you want to pass to the started activity.

Intent extras are stored in a Bundle object as key and value pairs. Bundles are a map, optimized for Android, where the keys are strings, and the values can be any primitive or object type objects must implement the Parcelable interface. To put data into the intent extras you can use any of the Intent class's putExtra methods, or create your own bundle and put it into the intent with putExtras.

Intent data and extras are not exclusive; you can use data for a URI and extras for any additional information the started activity needs to process the data in that URI. To add data to an explicit intent from the originating activity, create the intent object as you did before:. Some examples of using setData with URIs:. Keep in mind that the data field can only contain a single URI; if you call setData multiple times only the last value is used. Use intent extras to include additional information including URIs.

For example, you could use Intent. You can also define your own intent extra keys. To guarantee that the key is unique, the string value for the key itself should be prefixed with your app's fully qualified class name. For example:. Use a putExtra method with a key to put data into the intent extras. The Intent class defines many putExtra methods for different kinds of data:. Alternately, you can create a new bundle and populate that bundle with your intent extras. Bundle defines many "put" methods for different kinds of primitive data as well as objects that implement Android's Parcelable interface or Java's Serializable.

After you've populated the bundle, add it to the intent with the putExtras method note the "s" in Extras :. When you start an activity with an intent, the started activity has access to the intent and the data it contains.

To retrieve the intent the activity or other component was started with, use the getIntent method:. You can use the standard Intent extras if you used those, or you can use the keys you defined in the originating activity if they were defined as public. Or you can get the entire extras bundle from the intent and extract the values with the various Bundle methods:.

When you start an activity with an intent, the originating activity is paused, and the new activity remains on the screen until the user clicks the back button, or you call the finish method in a click handler or other function that ends the user's involvement with this activity.

Sometimes when you send data to an activity with an intent, you would like to also get data back from that intent.

For example, you might start a photo gallery activity that lets the user pick a photo. In this case your original activity needs to receive information about the photo the user chose back from the launched activity. To launch a new activity and get a result back, do the following steps in your originating activity:.

To get data back from a launched activity, start that activity with the startActivityForResult method instead of startActivity. The startActivityForResult method, like startActivity , takes an intent argument that contains information about the activity to be launched and any data to send to that activity.

The startActivityForResult method, however, also needs a request code. The request code is an integer that identifies the request and can be used to differentiate between results when you process the return data. For example, if you launch one activity to take a photo and another to pick a photo from a gallery, you'll need different request codes to identify which request the returned data belongs to.

Use a different integer for each code. The response data from the launched activity back to the originating activity is sent in an intent, either in the data or the extras.

You construct this return intent and put the data into it in much the same way you do for the sending intent. Typically your launched activity will have an onClick or other user input callback method in which you process the user's action and close the activity. This is also where you construct the response. Return result intents do not need a class or component name to end up in the right place.

The Android system directs the response back to the originating activity for you. Add data or extras to the intent the same way you did with the original intent. You may need to define keys for the return intent extras at the start of your class. Then put your return data into the intent as usual. Now that the launched activity has sent data back to the originating activity with an intent, that first activity must handle that data.

To handle returned data in the originating activity, implement the onActivityResult callback method. Here is a simple example. The three arguments to the onActivityResult contain all the information you need to handle the return data.

The example method shown above shows the typical logic for handling the request and response codes. Inside the body of those tests you extract the return information out of the intent. Use getData to get the intent data, or getExtra to retrieve values out of the intent extras with a specific key.

Any app of any complexity that you build will include multiple activities, both designed and implemented by you, and potentially in other apps as well. As your users move around your app and between activities, consistent navigation becomes more important to the app's user experience.