Introduction

Passing data from one Android activity to another is usually done with intent extras. For simple values that means strings and primitives, and for custom models the normal Android choice is Parcelable, because it is designed for Android component communication and is a better fit than falling back to general Java serialization.

Make the Model Parcelable

In Kotlin, @Parcelize keeps Parcelable practical enough for routine screen-to-screen data transfer.

1import android.os.Parcelable
2import kotlinx.parcelize.Parcelize
3
4@Parcelize
5data class UserProfile(
6    val id: Long,
7    val name: String,
8    val email: String
9) : Parcelable

This is the standard approach for small, screen-specific payloads. It avoids the manual writeToParcel boilerplate that older Android examples often show.

Put the Object into the Intent

The sending activity should use a shared key constant and call putExtra.

1private const val EXTRA_USER = "extra_user"
2
3fun openDetails(user: UserProfile) {
4    val intent = Intent(this, DetailsActivity::class.java)
5    intent.putExtra(EXTRA_USER, user)
6    startActivity(intent)
7}

Centralizing the key matters. A large fraction of intent bugs are not parceling bugs at all; they are mismatched extra names between sender and receiver.

Read It Back Safely in the Destination Activity

Modern Android provides a type-safer retrieval API on newer platform versions, and AndroidX also offers IntentCompat helpers for compatibility across API levels.

1import androidx.core.content.IntentCompat
2
3private const val EXTRA_USER = "extra_user"
4
5class DetailsActivity : AppCompatActivity() {
6    override fun onCreate(savedInstanceState: Bundle?) {
7        super.onCreate(savedInstanceState)
8        setContentView(R.layout.activity_details)
9
10        val user = IntentCompat.getParcelableExtra(intent, EXTRA_USER, UserProfile::class.java)
11        if (user == null) {
12            finish()
13            return
14        }
15
16        findViewById<TextView>(R.id.nameText).text = user.name
17        findViewById<TextView>(R.id.emailText).text = user.email
18    }
19}

Reading extras defensively is important because activities can be launched from tests, notifications, deep links, or process recreation paths where the expected extra may be absent.

Passing Lists of Objects

If you need multiple models, putParcelableArrayListExtra is the usual choice.

1import androidx.core.content.IntentCompat
2
3private const val EXTRA_USERS = "extra_users"
4
5val users = arrayListOf(
6    UserProfile(1, "Ana", "[email protected]"),
7    UserProfile(2, "Ben", "[email protected]")
8)
9
10val intent = Intent(this, TeamActivity::class.java)
11intent.putParcelableArrayListExtra(EXTRA_USERS, users)
12startActivity(intent)

And in the receiving activity:

1val users = IntentCompat.getParcelableArrayListExtra(
2    intent,
3    EXTRA_USERS,
4    UserProfile::class.java
5).orEmpty()

This is fine for small collections. It is not the right transport for large graphs of state.

Pass an ID Instead of a Large Object

Android's own guidance on parcelables and bundles warns about oversized extras. Large payloads can trigger TransactionTooLargeException, and even smaller payloads become awkward when the same object is already stored in a database or repository.

1private const val EXTRA_USER_ID = "extra_user_id"
2
3val intent = Intent(this, DetailsActivity::class.java)
4intent.putExtra(EXTRA_USER_ID, user.id)
5startActivity(intent)

Then let the destination screen load the full object from Room, a repository, or a ViewModel. This is usually more robust than shipping a large object through the intent boundary.

Return an Updated Object with the Activity Result API

If the second activity edits the object and returns a result, use the Activity Result API rather than older callback patterns.

1private const val EXTRA_USER = "extra_user"
2
3val launcher = registerForActivityResult(
4    ActivityResultContracts.StartActivityForResult()
5) { result ->
6    if (result.resultCode == Activity.RESULT_OK) {
7        val updated = result.data?.let {
8            IntentCompat.getParcelableExtra(it, EXTRA_USER, UserProfile::class.java)
9        }
10        if (updated != null) {
11            println(updated)
12        }
13    }
14}

This keeps navigation contracts explicit and easier to maintain.

Common Pitfalls

• Using different extra keys in the sender and receiver.
• Reading extras without null checks in the destination activity.
• Passing large or shared object graphs instead of passing an identifier and reloading data.
• Using older unsafe parcelable retrieval methods when type-safe alternatives are available.
• Forgetting that changing a parcelable model means retesting every screen contract that uses it.

Summary

• Use intent extras for small, screen-specific data passed between activities.
• Prefer Parcelable for custom Android models, especially with Kotlin @Parcelize.
• Use type-safe parcelable retrieval APIs such as IntentCompat.getParcelableExtra.
• Pass IDs instead of large objects when the payload is big or already stored elsewhere.
• Handle extras defensively because activities can be launched through many entry points.