Intent for activity navigation in Android Kotlin - Deep Dive

Overview - Intent for activity navigation

What is it?

An Intent in Android is a message object used to request an action from another app component. For activity navigation, it tells the system to start a new screen (activity). It carries information about what to do and can also pass data between screens. This helps apps move smoothly from one screen to another.

Why it matters

Without Intents, Android apps would not be able to switch between screens or communicate between components easily. This would make apps clunky and hard to use, as users expect to tap buttons and see new pages instantly. Intents solve the problem of navigation and data sharing inside apps and across apps.

Where it fits

Before learning Intents, you should understand what an Activity is and how Android apps have multiple screens. After mastering Intents, you can learn about passing data between activities, implicit Intents for system actions, and advanced navigation patterns like navigation components.

Mental Model

Core Idea

An Intent is like a letter you send inside your app to ask the system to open a new screen and optionally carry some information with it.

Think of it like...

Imagine you want to visit a friend’s house. You write a note (Intent) telling them you’re coming and maybe what you’re bringing. You hand it to a messenger (Android system), who delivers it and makes sure you get to your friend’s door (new activity).

┌─────────────┐      ┌─────────────┐
│ Current     │      │ Target      │
│ Activity    │─────▶│ Activity    │
│ (Sender)    │      │ (Receiver)  │
└─────────────┘      └─────────────┘
       │
       │ Intent (message with action & data)
       ▼
 Android System handles navigation

Build-Up - 6 Steps

1

Foundation

What is an Intent in Android

Concept: Introduce the basic idea of an Intent as a message object for communication.

In Android, an Intent is a simple object that describes an action to perform. It can start a new screen (activity), start a service, or deliver a broadcast. For navigation, we use Intents to tell the system which screen to open next.

Result

You understand that Intents are the way Android apps move between screens.

Understanding Intents as messages helps you see navigation as communication, not just screen switching.

2

Foundation

Basic Intent Syntax for Navigation

Concept: Learn how to create and use an Intent to start another activity.

To navigate, you create an Intent with the current context and the target activity class. Then call startActivity() with this Intent. Example: val intent = Intent(this, SecondActivity::class.java) startActivity(intent)

Result

The app opens the SecondActivity screen when this code runs.

Knowing the minimal code to navigate lets you build multi-screen apps quickly.

3

Intermediate

Passing Data Between Activities

🤔Before reading on: do you think Intents can carry information like a message? Commit to yes or no.

Concept: Intents can carry extra data to the new activity using key-value pairs.

You can add data to an Intent using putExtra() method. The receiving activity reads this data from its Intent. Example sending: intent.putExtra("username", "Alice") startActivity(intent) Example receiving: val username = intent.getStringExtra("username")

Result

The new activity receives the username and can use it to personalize the screen.

Understanding data passing with Intents unlocks dynamic and interactive app flows.

4

Intermediate

Explicit vs Implicit Intents

🤔Quick: Do you think implicit Intents specify the exact screen to open or just the action? Commit to your answer.

Concept: Explicit Intents name the exact activity to open; implicit Intents describe an action to be handled by any app that can do it.

Explicit Intent example: Intent(this, DetailActivity::class.java) Implicit Intent example: Intent(Intent.ACTION_VIEW, Uri.parse("https://example.com")) The system finds an app that can handle the action (like a browser).

Result

Explicit Intents navigate inside your app; implicit Intents can open other apps or system features.

Knowing the difference helps you choose the right Intent type for your navigation needs.

5

Advanced

Intent Flags and Task Management

🤔Before reading on: Do you think starting an activity always creates a new screen instance? Commit to yes or no.

Concept: Intent flags control how activities are launched and how they behave in the back stack (history).

Flags like FLAG_ACTIVITY_CLEAR_TOP or FLAG_ACTIVITY_NEW_TASK change navigation behavior. Example: intent.flags = Intent.FLAG_ACTIVITY_CLEAR_TOP startActivity(intent) This clears other activities on top of the target, avoiding multiple copies.

Result

You control how users return to previous screens and avoid duplicate activities.

Understanding flags prevents navigation bugs and improves user experience with back navigation.

6

Expert

How Intents Work Internally in Android

🤔Quick: Do you think Intents directly start activities or go through a system service? Commit your guess.

Concept: Intents are passed to the Android system's Activity Manager Service, which manages activity lifecycles and navigation stacks.

When you call startActivity(intent), the system checks the Intent, finds the target activity, and manages the activity stack. It creates or reuses activity instances based on flags and launches the UI thread for the new screen.

Result

You realize navigation is a system-managed process, not just a simple function call.

Knowing the system's role helps debug complex navigation issues and optimize app flow.

Under the Hood

Intents are serialized message objects containing action, data, and extras. When startActivity() is called, the Intent is sent to the Activity Manager Service (AMS). AMS resolves the Intent to an activity component, manages the activity stack, and launches or resumes the target activity. The system handles lifecycle transitions and UI rendering.

Why designed this way?

Android uses Intents to decouple components, allowing flexible communication and reuse. This design supports modular apps and inter-app communication. It also centralizes navigation control in the system for consistency and security.

┌───────────────┐
│ Your App      │
│ (startActivity)
└───────┬───────┘
        │ Intent
        ▼
┌───────────────┐
│ Activity      │
│ Manager       │
│ Service (AMS) │
└───────┬───────┘
        │ Resolve Intent
        ▼
┌───────────────┐
│ Target        │
│ Activity      │
│ Instance      │
└───────────────┘

Myth Busters - 3 Common Misconceptions

Quick: Do you think you can start any activity in any app with an explicit Intent? Commit yes or no.

Common Belief: You can start any activity in any app by naming its class in an explicit Intent.

Reality: Explicit Intents only work within your own app or exported activities. Other apps' activities are protected and cannot be started directly.

Why it matters: Trying to start protected activities causes crashes or security exceptions, breaking app stability.

Quick: Does adding data to an Intent guarantee the receiving activity will get it? Commit yes or no.

Common Belief: If you put data in an Intent, the receiving activity always receives it correctly.

Reality: If the receiving activity does not read the data properly or uses wrong keys, the data is lost or null.

Why it matters: Misreading Intent extras causes bugs where screens show wrong or missing information.

Quick: Does startActivity() always create a new instance of the target activity? Commit yes or no.

Common Belief: Every time you call startActivity(), a new activity instance is created.

Reality: Depending on Intent flags and launch modes, the system may reuse existing activity instances instead of creating new ones.

Why it matters: Misunderstanding this leads to unexpected behavior like multiple copies or lost state.

Expert Zone

1

Intent extras are limited in size; large data should be passed via shared storage or databases to avoid crashes.

2

Launch modes (singleTop, singleTask) combined with Intent flags create complex navigation flows that require careful design.

3

Implicit Intents rely on system Intent filters, so changes in other apps can affect your app's behavior unexpectedly.

When NOT to use

Avoid using Intents for navigation in complex apps with many screens; instead, use Android Jetpack Navigation Component for safer and easier navigation management. Also, do not use Intents to pass large objects; use ViewModel or persistent storage instead.

Production Patterns

In production, developers use explicit Intents for internal navigation and implicit Intents for system actions like opening a web page or sharing content. They combine Intent flags and launch modes to manage back stack behavior and prevent duplicate screens.

Connections

Message Passing in Distributed Systems

Both use messages to request actions between components.

Understanding Intents as messages helps grasp how distributed systems communicate asynchronously and decouple components.

URL Routing in Web Development

Intent navigation is like URL routing directing users to different pages.

Knowing web routing clarifies how Android maps Intents to activities, similar to URLs mapping to web pages.

Event-Driven Programming

Intents trigger actions based on events, similar to event handlers in UI programming.

Recognizing Intents as events helps understand reactive app design and user interaction flows.

Common Pitfalls

#1 Trying to start an activity without declaring it in the manifest.

Wrong approach:

val intent = Intent(this, HiddenActivity::class.java)
startActivity(intent)

Correct approach:

Declare HiddenActivity in AndroidManifest.xml before starting it:

Root cause:

Android requires all activities to be declared in the manifest for security and system awareness.

#2 Using wrong keys or forgetting to check for null when reading Intent extras.

Wrong approach:

val username = intent.getStringExtra("user")!! // crashes if null

Correct approach:

val username = intent.getStringExtra("username") ?: "Guest"

Root cause:

Mismatch in keys or missing null checks causes runtime crashes.

#3 Starting multiple instances of the same activity unintentionally.

Wrong approach:

val intent = Intent(this, DetailActivity::class.java)
startActivity(intent) // called repeatedly

Correct approach:

intent.flags = Intent.FLAG_ACTIVITY_SINGLE_TOP
startActivity(intent)

Root cause:

Not using Intent flags or launch modes leads to duplicate activities and confusing navigation.

Key Takeaways

Intents are the core way Android apps navigate between screens by sending messages to the system.

You can pass data between activities using Intent extras, enabling dynamic and personalized screens.

Explicit Intents specify exact screens; implicit Intents request actions handled by any capable app.

Intent flags and launch modes control how activities are created and managed in the navigation stack.

Understanding the system's role in handling Intents helps debug and design smooth user experiences.