Passing data between activities in Android Kotlin - Build, Publish & Deploy

Build & Publish - Passing data between activities

Performance Impact

Passing data between activities in Android using intents has minimal impact on frame rate and memory if the data size is small, such as strings or numbers. Large data objects or complex serializable data can increase memory usage and slow down activity transitions, potentially causing jank or dropped frames. Efficient data passing helps maintain smooth 60fps UI and conserves battery life by avoiding heavy processing during navigation.

Optimization Tips

• Pass only essential data using intent extras to keep the payload small.
• Use Parcelable instead of Serializable for custom objects to reduce serialization overhead.
• Avoid passing large bitmaps or files; instead, pass references like URIs or file paths.
• Consider using ViewModel or shared data repositories for complex data sharing to reduce intent size.
• Preload or cache data in the receiving activity to speed up UI rendering after navigation.

App Bundle Size and Startup Time

Passing data between activities does not directly affect the app bundle size. However, including large data classes or heavy serialization libraries can increase APK size. Efficient data passing keeps activity startup fast, reducing perceived load time. Avoid embedding large static data in intents to prevent slow activity launches.

iOS vs Android Differences

On Android, data is passed between activities using intents with extras. On iOS, data is passed between view controllers typically via segues or direct property setting. Android requires data to be Parcelable or Serializable for intents, while iOS uses native Swift types or Codable. Android's activity lifecycle and intent system differ from iOS's view controller navigation, so data passing patterns are platform-specific.

Store Review Guidelines

• Ensure data passed between activities does not expose sensitive user information unintentionally.
• Follow privacy policies by not passing personal data without user consent.
• Keep app responsive during navigation to meet user experience guidelines.
• Do not pass executable code or unsafe data that could cause crashes or security issues.
• Test on multiple devices to ensure smooth transitions and no memory leaks.

Self-Check Question

Your app takes 5 seconds to load this screen after navigation. What's likely wrong?

• Passing large or complex data objects via intent extras causing slow serialization.
• Loading heavy resources synchronously in the receiving activity's onCreate method.
• Not using Parcelable for custom objects, causing inefficient serialization.
• Passing bitmaps or large files directly instead of references.

Key Result

Passing data between activities using intents is lightweight when data is small and simple. Optimize by passing minimal data, using Parcelable, and avoiding large objects to maintain smooth 60fps UI and fast activity transitions.

Practice

1. What is the primary method to send data from one activity to another in Android Kotlin?

easy

A. Use an Intent with putExtra() to attach data.

B. Use a global variable to share data.

C. Call the other activity's method directly.

D. Use a database to pass data instantly.

Solution

1. Step 1: Understand Intent usage

   Intent is the standard way to start a new activity and can carry data with putExtra().

2. Step 2: Recognize data passing method

   putExtra() attaches key-value pairs to the Intent for the next activity to retrieve.

3. Final Answer:

   Use an Intent with putExtra() to attach data. -> Option A

4. Quick Check:

   Intent + putExtra() = Data passing [OK]

Hint: Remember: Intent carries data with putExtra() [OK]

Common Mistakes:

• Trying to call methods of another activity directly
• Using global variables which is not recommended
• Assuming database is needed for simple data passing

2. Which of the following is the correct syntax to add a String extra named "username" to an Intent in Kotlin?

easy

A. intent.setExtra("username", username)

B. intent.addExtra("username" to username)

C. intent.putExtra("username", username)

D. intent.putData("username", username)

Solution

1. Step 1: Recall Intent method for extras

   putExtra() is the correct method to add data to an Intent.

2. Step 2: Check syntax correctness

   putExtra() takes a key and a value as parameters, matching intent.putExtra("username", username).

3. Final Answer:

   intent.putExtra("username", username) -> Option C

4. Quick Check:

   putExtra() syntax correct = intent.putExtra("username", username) [OK]

Hint: Use putExtra(key, value) to add data to Intent [OK]

Common Mistakes:

• Using non-existent methods like addExtra or setExtra
• Confusing putExtra with putData
• Missing quotes around the key string

3. Given this code in Activity A:

val intent = Intent(this, ActivityB::class.java)
intent.putExtra("age", 25)
startActivity(intent)

What code correctly retrieves the "age" integer in Activity B?

medium

A. val age = intent.getIntExtra("age", 0)

B. val age = intent.getStringExtra("age")

C. val age = intent.getExtra("age") as Int

D. val age = intent.getInt("age")

Solution

1. Step 1: Identify the data type sent

   The value sent is an integer 25, so we must retrieve it as an Int.

2. Step 2: Use correct retrieval method

   getIntExtra() retrieves an Int extra with a default fallback value.

3. Final Answer:

   val age = intent.getIntExtra("age", 0) -> Option A

4. Quick Check:

   Integer extra retrieval = getIntExtra() [OK]

Hint: Use get<Type>Extra(key, default) matching sent data type [OK]

Common Mistakes:

• Using getStringExtra() for an integer value
• Trying to cast getExtra() without safe methods
• Using non-existent getInt() method

4. What is wrong with this code snippet in Activity B for retrieving a String extra named "email"?

val email = intent.getStringExtra("email")!!

medium

A. getStringExtra() does not exist for Intent.

B. Using !! can cause a crash if "email" extra is missing.

C. The key "email" should be an integer resource ID.

D. Intent extras cannot hold String values.

Solution

1. Step 1: Understand !! operator risk

   Using !! forces a non-null value and crashes if the extra is missing (null).

2. Step 2: Recognize safe retrieval practice

   It's safer to check for null or provide a default instead of forcing !!.

3. Final Answer:

   Using !! can cause a crash if "email" extra is missing. -> Option B

4. Quick Check:

   Unsafe !! usage risks crash [OK]

Hint: Avoid !! on extras; check for null safely [OK]

Common Mistakes:

• Assuming extras always exist without null checks
• Thinking getStringExtra() is invalid
• Confusing keys with resource IDs

5. You want to pass a list of user IDs (List<Int>) from Activity A to Activity B. Which approach correctly sends and retrieves this list?

hard

A. Store the list in a static variable and access it directly in Activity B

B. Use intent.putExtra("userIds", userIds) and retrieve with getIntExtra("userIds", 0)

C. Serialize the list to JSON string and send with putExtra("userIds", jsonString), then parse in Activity B

D. Use intent.putIntegerArrayListExtra("userIds", ArrayList(userIds)) and retrieve with getIntegerArrayListExtra("userIds")

Solution

1. Step 1: Identify correct method for List<Int>

   Intent supports ArrayList<Int> via putIntegerArrayListExtra() and getIntegerArrayListExtra().

2. Step 2: Confirm retrieval matches sending method

   Using these methods ensures type safety and proper data transfer.

3. Final Answer:

   Use intent.putIntegerArrayListExtra("userIds", ArrayList(userIds)) and retrieve with getIntegerArrayListExtra("userIds") -> Option D

4. Quick Check:

   Use put/getIntegerArrayListExtra for List<Int> [OK]

Hint: Use put/getIntegerArrayListExtra for List<Int> [OK]

Common Mistakes:

• Trying to send List<Int> directly with putExtra()
• Using getIntExtra() for a list
• Using static variables which breaks encapsulation