Android Passing Data Between Screens Complete Guide

Top 10 Questions and Answers on Android Passing Data Between Screens

1. How can you pass simple data types (e.g., Strings, Integers) from one Activity to another?

Answer: To pass simple data types between activities, you can use an Intent with putExtra() to add the data you want to send, and getIntent().getExtras() to retrieve it in the target activity.

Example:

// Sending data
Intent intent = new Intent(SourceActivity.this, DestinationActivity.class);
intent.putExtra("key_string", "Hello World");
intent.putExtra("key_int", 100);
startActivity(intent);

// Retrieving data
String receivedString = getIntent().getStringExtra("key_string");
int receivedInt = getIntent().getIntExtra("key_int", 0); // Default value is 0 if no data is found

2. How do you pass complex objects (e.g., a custom class) between activities?

Answer: For passing complex objects, the class needs to implement Serializable or Parcelable interfaces. Parcelable is more efficient and recommended.

Example: Implementing Parcelable:

public class MyData implements Parcelable {
    private String name;
    private int age;

    public MyData(String name, int age) {
        this.name = name;
        this.age = age;
    }

    protected MyData(Parcel in) {
        name = in.readString();
        age = in.readInt();
    }

    public static final Creator<MyData> CREATOR = new Creator<MyData>() {
        @Override
        public MyData createFromParcel(Parcel in) {
            return new MyData(in);
        }

        @Override
        public MyData[] newArray(int size) {
            return new MyData[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel parcel, int i) {
        parcel.writeString(name);
        parcel.writeInt(age);
    }
}

// Sending MyData object
Intent intent = new Intent(SourceActivity.this, DestinationActivity.class);
intent.putExtra("key_mydata", new MyData("John Doe", 25));
startActivity(intent);

// Retrieving data
MyData receivedData = getIntent().getParcelableExtra("key_mydata");

3. What is the difference between startActivityForResult() and startActivity()?

Answer: startActivity() is used to start an activity and does not wait for a result. startActivityForResult() starts an activity and returns a result to the activity that started it, using onActivityResult() method to handle the result.

Example:

// Starting an activity for result
Intent intent = new Intent(SourceActivity.this, DestinationActivity.class);
startActivityForResult(intent, REQUEST_CODE); // REQUEST_CODE can be any int

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == REQUEST_CODE && resultCode == RESULT_OK) {
        // Handle the returned data
        String result = data.getStringExtra("result_key");
    }
}

// In DestinationActivity, you can send data back:
Intent resultIntent = new Intent();
resultIntent.putExtra("result_key", "Result from Destination");
setResult(RESULT_OK, resultIntent);
finish();

4. How can you pass data between fragments?

Answer: To pass data between fragments, you can use setArguments() and getArguments() methods with a Bundle.

Example:

// Creating arguments for the fragment
Bundle args = new Bundle();
args.putString("key_string", "Fragment Data");
args.putInt("key_int", 200);

DestinationFragment fragment = new DestinationFragment();
fragment.setArguments(args);

// In DestinationFragment
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (getArguments() != null) {
        String receivedString = getArguments().getString("key_string");
        int receivedInt = getArguments().getInt("key_int");
    }
}

5. How do you pass data from a Fragment to an Activity?

Answer: There are multiple ways to do this—using an Interface, ViewModel, or by calling methods on the Activity directly (usually not recommended due to tight coupling).

Example using Interface:

// Interface to define callback
public interface DataCallback {
    void onDataReceived(String data);
}

// In the Fragment
private DataCallback callback;

@Override
public void onAttach(Context context) {
    super.onAttach(context);
    callback = (DataCallback) context;   // assuming Activity implements DataCallback
}

private void sendDataToActivity() {
    callback.onDataReceived("Data from Fragment");
}

// In the Activity
public class MainActivity extends AppCompatActivity implements DataCallback {

    @Override
    public void onDataReceived(String data) {
        // Handle the data
    }
}

6. How can you pass data using intents and flags?

Answer: You can use different Intent flags to alter the behavior of the activity launch. For example, FLAG_ACTIVITY_NEW_TASK, FLAG_ACTIVITY_CLEAR_TOP, etc.

Example with FLAG_ACTIVITY_NEW_TASK:

Intent intent = new Intent(SourceActivity.this, DestinationActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);

7. Can you pass data between dialogs and activities?

Answer: Yes, dialogs can also receive data via intents if shown from an Activity. Custom DialogFragments can use Bundle for passing data similar to passing data between fragments.

Example for a Custom DialogFragment:

public class MyDialogFragment extends DialogFragment {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Bundle arguments = getArguments();
        if (arguments != null) {
            String data = arguments.getString("key_dialog");
            // Use the data
        }
    }

    @NonNull
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setMessage("Data received: " + getArguments().getString("key_dialog"));
        return builder.create();
    }

    public static MyDialogFragment newInstance(String data) {
        MyDialogFragment fragment = new MyDialogFragment();
        Bundle args = new Bundle();
        args.putString("key_dialog", data);
        fragment.setArguments(args);
        return fragment;
    }
}

// Showing dialog from an Activity
MyDialogFragment dialogFragment = MyDialogFragment.newInstance("Hello from Activity");
dialogFragment.show(getSupportFragmentManager(), "MyDialog");

8. How do you pass data using ViewModel?

Answer: Using ViewModel from Android Architecture Components is a recommended way to manage data that needs to be shared between different components and survive configuration changes. Data is stored in a LiveData object within the ViewModel.

Example:

// ViewModel class
public class SharedDataViewModel extends ViewModel {
    private MutableLiveData<String> data;

    public LiveData<String> getData() {
        if (data == null) {
            data = new MutableLiveData<>();
        }
        return data;
    }

    public void setData(String value) {
        data.setValue(value);
    }
}

// In the first Activity
SharedDataViewModel model = new ViewModelProvider(this).get(SharedDataViewModel.class);
model.setData("Data to be shared");

// In the second Activity
SharedDataViewModel model = new ViewModelProvider(this).get(SharedDataViewModel.class);
model.getData().observe(this, new Observer<String>() {
    @Override
    public void onChanged(@Nullable String s) {
        // Update the UI
    }
});

9. What are the drawbacks of using startActivityForResult()?

Answer: The main drawbacks include:

• It leads to tightly coupled code.
• Complex flows can get difficult to manage.
• onActivityResult() gets called for every result, so managing multiple requests can become complex.

10. How can you pass large data sets between activities?

Answer: For large data sets, passing data through intents can hit the TransactionTooLargeException due to the limit on the size of data that can be passed. In such cases, use other storage alternatives like SQLite, SharedPreferences, or storing the data temporarily in a ViewModel and passing only an identifier between activities.

Example: