Data Passing Between Screens

Data Passing Between Screens is an essential concept in Android app development. Applications often need to transfer information from one screen to another, such as user details, product information, order data, settings, or search results. Android provides several methods for passing data between Activities and Fragments, allowing developers to create dynamic and interactive applications.

Understanding data transfer techniques helps developers build connected applications where different screens can communicate efficiently.

What is Data Passing Between Screens?

Data Passing Between Screens refers to the process of sending information from one Activity or Fragment to another.

For example:

  • Login screen sends user information to Home screen
  • Product list sends product details to Product screen
  • Registration form sends entered data to a confirmation page
  • Profile screen sends user data to an edit profile page

Without data passing, screens would work independently and could not share information.

Why is Data Passing Important?

Data passing is important because it:

  • Connects application screens
  • Supports user workflows
  • Improves user experience
  • Enables dynamic content
  • Reduces duplicate data entry
  • Supports application functionality

Most Android applications rely heavily on data sharing between screens.

Methods of Passing Data

Android provides several methods for transferring data.

Common methods include:

  • Intents
  • Bundles
  • Fragment Arguments
  • Shared Preferences
  • Serializable Objects
  • Parcelable Objects
  • ViewModel
  • Database Storage

The appropriate method depends on the application’s requirements.

Passing Data Between Activities Using Intents

The most common approach is using Intent Extras.

Sending Data

Example:

Intent intent =
        new Intent(
                MainActivity.this,
                ProfileActivity.class);

intent.putExtra(
        "username",
        "Ali");

startActivity(intent);

The value is attached to the Intent before launching the next Activity.

Receiving Data in Another Activity

Example:

String username =
        getIntent()
        .getStringExtra(
                "username");

The receiving Activity retrieves the data using the same key.

Complete Example

MainActivity

Button btnNext =
        findViewById(R.id.btnNext);

btnNext.setOnClickListener(v -> {

    Intent intent =
            new Intent(
                    MainActivity.this,
                    SecondActivity.class);

    intent.putExtra(
            "name",
            "Ahmed");

    startActivity(intent);

});

SecondActivity

TextView txtName =
        findViewById(R.id.txtName);

String name =
        getIntent()
        .getStringExtra(
                "name");

txtName.setText(name);

The user’s name is transferred and displayed on the second screen.

Passing Multiple Values

Intents can transfer multiple pieces of information.

Sending Data

Intent intent =
        new Intent(
                MainActivity.this,
                ProfileActivity.class);

intent.putExtra(
        "name",
        "Sara");

intent.putExtra(
        "age",
        22);

intent.putExtra(
        "city",
        "Lahore");

startActivity(intent);

Receiving Data

String name =
        getIntent()
        .getStringExtra("name");

int age =
        getIntent()
        .getIntExtra(
                "age",
                0);

String city =
        getIntent()
        .getStringExtra("city");

Multiple values can be transferred within a single Intent.

Using Bundle for Data Passing

A Bundle is a collection of key-value pairs used to store data.

Sending Data

Intent intent =
        new Intent(
                MainActivity.this,
                ProfileActivity.class);

Bundle bundle =
        new Bundle();

bundle.putString(
        "name",
        "Ali");

bundle.putInt(
        "age",
        25);

intent.putExtras(bundle);

startActivity(intent);

Receiving Data

Bundle bundle =
        getIntent().getExtras();

String name =
        bundle.getString("name");

int age =
        bundle.getInt("age");

Bundles are useful when passing multiple values.

Passing Data Back to Previous Activity

Sometimes an Activity must return information to the screen that launched it.

Example:

Returning Data

Intent resultIntent =
        new Intent();

resultIntent.putExtra(
        "result",
        "Success");

setResult(
        RESULT_OK,
        resultIntent);

finish();

The previous Activity can receive the returned data and update its interface.

Passing Data Between Fragments

Fragments commonly exchange information through Bundles.

Sending Data to a Fragment

Bundle bundle =
        new Bundle();

bundle.putString(
        "username",
        "Ahmed");

HomeFragment fragment =
        new HomeFragment();

fragment.setArguments(bundle);

Receiving Data

String username =
        getArguments()
        .getString(
                "username");

This is the recommended way to initialize Fragment data.

What is Serializable?

Serializable is a Java interface that allows objects to be converted into a format suitable for transfer.

Example:

public class Student
        implements Serializable {

    String name;
    int age;

}

Sending Object

intent.putExtra(
        "student",
        studentObject);

Receiving Object

Student student =
        (Student) getIntent()
        .getSerializableExtra(
                "student");

Serializable is simple but less efficient for Android applications.

What is Parcelable?

Parcelable is Android’s preferred method for transferring complex objects.

It is faster and more efficient than Serializable.

Example:

public class Student
        implements Parcelable {

}

Parcelable is commonly used in professional Android applications.

Using SharedPreferences

SharedPreferences store small amounts of data permanently.

Saving Data

SharedPreferences prefs =
        getSharedPreferences(
                "UserData",
                MODE_PRIVATE);

prefs.edit()
        .putString(
                "username",
                "Ali")
        .apply();

Reading Data

String username =
        prefs.getString(
                "username",
                "");

This method is useful for settings and user preferences.

Using ViewModel for Data Sharing

Modern Android applications often use ViewModel to share data between Fragments.

Benefits include:

  • Lifecycle awareness
  • Better architecture
  • Improved maintainability
  • Shared state management

ViewModel is part of Android Jetpack architecture components.

Using Database Storage

Large amounts of information can be shared through databases.

Examples:

  • SQLite
  • Room Database
  • Firebase Firestore

Data is stored centrally and accessed by multiple screens when needed.

Real-World Example

Consider an e-commerce application:

Product List Screen

Displays products.

When a product is selected:

Intent intent =
        new Intent(
                ProductListActivity.this,
                ProductDetailActivity.class);

intent.putExtra(
        "productId",
        101);

startActivity(intent);

Product Detail Screen

Receives product ID:

int productId =
        getIntent()
        .getIntExtra(
                "productId",
                0);

The application then loads product details based on the received ID.

Real-World Applications

Data passing is used in:

  • Login systems
  • Registration forms
  • Shopping applications
  • Banking systems
  • Social media apps
  • Healthcare applications
  • Educational platforms
  • Enterprise software

Every modern Android application transfers data between screens.

Common Beginner Mistakes

Mismatched Keys

Incorrect:

intent.putExtra(
        "user",
        "Ali");

Receiving:

getStringExtra(
        "username");

The keys must match exactly.

Null Values

Always check whether received data is null before using it.

Wrong Data Types

Use matching methods:

getStringExtra()
getIntExtra()
getBooleanExtra()

Large Object Transfers

Avoid transferring very large objects through Intents.

Use databases or ViewModels when appropriate.

Best Practices

When passing data between screens:

  • Use descriptive keys
  • Validate received data
  • Use Parcelable for complex objects
  • Use ViewModel for shared Fragment data
  • Avoid unnecessary data duplication
  • Handle null values safely

These practices improve application reliability and performance.

Importance of Data Passing

Data passing is important because it:

  • Connects application screens
  • Supports workflow continuity
  • Enables personalized experiences
  • Improves user interaction
  • Facilitates information sharing
  • Forms a core part of Android development

Understanding data transfer is essential for building professional Android applications.

Conclusion

Data Passing Between Screens enables Android applications to share information between Activities and Fragments efficiently. Through Intents, Bundles, Parcelable objects, SharedPreferences, ViewModels, and databases, developers can create connected and interactive applications that provide smooth user experiences. Mastering these techniques is essential for developing modern Android apps that manage data effectively and support complex workflows.

Home » Java for Android Apps > App Logic with Java > Data Passing Between Screens
← Previous Page Activities and Fragments
Next Page → Shared Preferences