Intents: Navigating Between Activities in Android Development

In Android development, Activities are the building blocks of your application's user interface. To create a dynamic and interactive user experience, you often need to navigate between different Activities. This is where Intents come into play. Intents are messaging objects used to request an action from another app component, most commonly to start another Activity.

What is an Intent?

An Intent is a fundamental Android component that facilitates communication between Activities, Services, and Broadcast Receivers. It acts as a messenger, carrying information and instructions between these components. For navigation between Activities, we primarily use Explicit Intents, which specify the target component by its class name.

Intents are messages that allow Android components to communicate and trigger actions.

Think of an Intent as a 'to-do' list item passed between different parts of your Android app. For navigating between screens (Activities), it's like telling the system, 'Please open this specific screen.'

An Intent is an abstract description of an operation to be performed. It's a powerful mechanism that allows you to decouple components, enabling them to communicate without direct knowledge of each other. When navigating between Activities, an Intent specifies which Activity to start and can also carry data to be used by the new Activity.

Creating and Launching an Explicit Intent

To navigate from one Activity to another, you'll create an Intent object. This object will contain the context of the current Activity and the class of the Activity you want to start. The <code>startActivity()</code> method is then used to launch the new Activity.

What is the primary method used to start a new Activity using an Intent?

The startActivity() method.

Here's a typical code snippet in Kotlin:

// In your current Activity (e.g., MainActivity)
val intent = Intent(this, SecondActivity::class.java)
startActivity(intent)

This code snippet demonstrates the creation of an Explicit Intent. The this keyword refers to the current Context (the MainActivity itself), and SecondActivity::class.java specifies the target Activity class to be launched. The startActivity(intent) call then initiates the transition to SecondActivity.

📚

Text-based content

Library pages focus on text content

Passing Data Between Activities

Intents are not just for navigation; they can also carry data. This is achieved using Extras, which are key-value pairs. You can put data into an Intent using the <code>putExtra()</code> method and retrieve it in the destination Activity using the <code>get...Extra()</code> methods.

Operation	Method	Purpose
Adding Data	<code>intent.putExtra(key, value)</code>	Stores data within the Intent object.
Retrieving Data	<code>intent.getStringExtra(key)</code>, <code>intent.getIntExtra(key, defaultValue)</code>, etc.	Retrieves data from the Intent object in the receiving Activity.

For example, to pass a String message:

Sending Activity (e.g., MainActivity):

kotlin

val message = "Hello from MainActivity!"
val intent = Intent(this, SecondActivity::class.java)
intent.putExtra("USER_MESSAGE", message)
startActivity(intent)

Receiving Activity (e.g., SecondActivity):

kotlin

val receivedMessage = intent.getStringExtra("USER_MESSAGE")
// Now you can use receivedMessage in SecondActivity

When retrieving data with get...Extra(), always provide a default value. This prevents crashes if the extra is not found in the Intent.

Implicit Intents

While Explicit Intents are used for navigating within your own app, Implicit Intents are used to request an action that another app can perform. For example, you might use an implicit intent to open a web browser, send an email, or dial a phone number. The Android system resolves these intents by finding an app that can handle the requested action.

What type of Intent is used to request an action that another app can perform, like opening a web browser?

Implicit Intent.

Intent Filters

For implicit intents, components declare their capabilities using Intent Filters in the

code

AndroidManifest.xml

file. This tells the system what types of intents a component can respond to. For example, an Activity that can display web pages would have an intent filter for the

code

ACTION_VIEW

action and the

code

http

scheme.

Returning Data from an Activity

Sometimes, you need to get a result back from an Activity that you started. For instance, if you start a camera Activity to take a photo, you'll want to get the photo back. This is done using <code>startActivityForResult()</code> and handling the result in <code>onActivityResult()</code> (though

code

ActivityResultLauncher

is the modern, recommended approach).

Loading diagram...

The process involves starting the target Activity with <code>startActivityForResult()</code>, and then in the target Activity, you set a result using <code>setResult()</code> before finishing. The original Activity receives this result in its callback method.

Learning Resources

Android Developers - Intents and Intent Filters(documentation)

The official Android documentation provides a comprehensive overview of Intents, including explicit and implicit intents, and how to use intent filters.

Android Developers - Navigating Between Screens(documentation)

This guide from Android Developers explains navigation principles, including the role of Intents in moving between different screens (Activities) in an application.

Kotlin for Android Developers - Intents(tutorial)

While this is a general Kotlin for Android guide, it often includes sections on fundamental concepts like Intents and Activity navigation.

Udemy: Android App Development Masterclass using Kotlin(video)

A popular course that covers Android development with Kotlin, including detailed explanations and practical examples of using Intents for navigation.

Medium: Understanding Android Intents(blog)

A blog post from Android Developers explaining the core concepts of Intents and their various uses in Android applications.

Stack Overflow: How to pass data between activities in Android using Kotlin(wikipedia)

A collection of questions and answers on Stack Overflow specifically related to passing data between Android Activities using Kotlin, offering practical solutions to common problems.

Ray Wenderlich: Android Intents Tutorial(tutorial)

Ray Wenderlich provides high-quality tutorials, and this one likely covers Intents in detail with practical code examples for Android development.

YouTube: Android Intents Explained (Kotlin)(video)

A video tutorial that visually explains how Intents work in Android development using Kotlin, often with live coding demonstrations.

Android Developers Blog: Kotlin Coroutines for Async Operations(blog)

While not directly about Intents, understanding asynchronous operations is crucial for smooth UI navigation, and this blog post covers Kotlin Coroutines, a key tool for managing background tasks.

Android Developers - Activity Lifecycle(documentation)

Understanding the Activity lifecycle is essential when navigating between Activities, as it dictates how Activities are created, started, resumed, and destroyed.