Sharing Data Between Fragments Using ViewModel Architecture Component: Principles, Implementation, and Best Practices

Overview of ViewModel Architecture Component

In Android application development, data communication between Fragments has always been a complex issue. Traditional approaches require Fragments to define interfaces, implemented and coordinated by the Activity, which not only increases code coupling but also requires handling edge cases of inconsistent Fragment lifecycles. The ViewModel architecture component introduced by Google at I/O 2017 provides an elegant solution to this problem.

Core Advantages of ViewModel

The core design philosophy of ViewModel is to decouple UI-related data from Fragments and Activities. By associating ViewModel instances with Activity lifecycle, multiple Fragments can share the same ViewModel instance, enabling data synchronization. This design offers the following advantages:

• Lifecycle Awareness: ViewModel preserves data during configuration changes (such as screen rotation), avoiding reinitialization
• Data Consistency: All Fragments access the same data source, ensuring state synchronization
• Code Simplification: Eliminates complex interface definitions and callback chains

Master-Detail Fragment Communication Implementation

The following code example demonstrates how to use ViewModel to implement typical Master-Detail Fragment communication. First, define the shared ViewModel class:

public class SharedViewModel extends ViewModel {
    private final SavedStateHandle state;
    
    public SharedViewModel(SavedStateHandle state) {
        this.state = state;
    }
    
    private final MutableLiveData<Item> selected = state.getLiveData("selected");
    
    public void select(Item item) {
        selected.setValue(item);
    }
    
    public LiveData<Item> getSelected() {
        return selected;
    }
}

In the MasterFragment, obtain the ViewModel instance through Activity scope and set the selected item:

public class MasterFragment extends Fragment {
    private SharedViewModel model;
    
    @Override
    protected void onViewCreated(View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        model = new ViewModelProvider(getActivity()).get(SharedViewModel.class);
        itemSelector.setOnClickListener(item -> {
            model.select(item);
        });
    }
}

In the DetailFragment, observe data changes and update the UI:

public class DetailFragment extends Fragment {
    @Override
    protected void onViewCreated(View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        SharedViewModel model = new ViewModelProvider(getActivity()).get(SharedViewModel.class);
        model.getSelected().observe(this, { item ->
           // Update UI to display selected item details
        });
    }
}

ViewModel Initialization and Scope Management

Proper ViewModel initialization is crucial. Initializing ViewModel uniformly in the Activity ensures all Fragments access the same instance:

public class PagerActivity extends AppCompatActivity {
    private PagerAgentViewModel pagerAgentViewModel;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_pager);
        
        pagerAgentViewModel = new ViewModelProvider(this).get(PagerAgentViewModel.class);
        pagerAgentViewModel.init();
    }
}

Using ViewModelProvider(getActivity()) ensures ViewModel is bound to the Activity lifecycle, not individual Fragments. This design keeps ViewModel alive as long as the Activity exists, even when Fragments are replaced or recreated.

LiveData and State Observation

LiveData, as an observable data holder, is the core of ViewModel communication mechanism. The following example demonstrates bidirectional communication ViewModel implementation:

public class PagerAgentViewModel extends ViewModel {
    private final SavedStateHandle state;
    private final MutableLiveData<String> messageContainerA;
    private final MutableLiveData<String> messageContainerB;
    
    public PagerAgentViewModel(SavedStateHandle state) {
        this.state = state;
        messageContainerA = state.getLiveData("Default Message");
        messageContainerB = state.getLiveData("Default Message");
    }
    
    public void sendMessageToB(String msg) {
        messageContainerB.setValue(msg);
    }
    
    public LiveData<String> getMessageContainerA() {
        return messageContainerA;
    }
}

Fragments respond to data changes by observing LiveData:

public class BlankFragmentA extends Fragment {
    private PagerAgentViewModel viewModel;
    
    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        viewModel = new ViewModelProvider(getActivity()).get(PagerAgentViewModel.class);
        
        viewModel.getMessageContainerA().observe(getViewLifecycleOwner(), new Observer<String>() {
            @Override
            public void onChanged(@Nullable String msg) {
                textView.setText(msg);
            }
        });
    }
}

Simplified Kotlin Extension Approach

For Kotlin projects, the fragment-ktx library provides property delegates to further simplify code:

// Use 'by activityViewModels()' Kotlin property delegate
private val model: SharedViewModel by activityViewModels()

This approach automatically handles ViewModel acquisition and lifecycle binding, reducing boilerplate code.

Best Practices and Considerations

1. Data Flow Design: ViewModel should contain only UI-related data; business logic should reside in Repository layer
2. Lifecycle Management: Use getViewLifecycleOwner() instead of getActivity() for observing LiveData to avoid memory leaks
3. State Preservation: Use SavedStateHandle to save and restore state, supporting process recreation
4. Testability: ViewModel doesn't depend on Android framework classes, facilitating unit testing
5. Avoid Overuse: Simple data passing can use Fragment arguments directly; reserve ViewModel for complex scenarios

Comparison with Traditional Approaches

Compared with traditional interface callback patterns, the ViewModel solution offers significant advantages:

Extended Practical Application Scenarios

Beyond Master-Detail Fragment communication, ViewModel can be applied to the following scenarios:

• Fragment Communication in ViewPager: Multiple tabs sharing data state
• Dialog-Host Fragment Communication: DialogFragment passing user selections via ViewModel
• State Preservation During Configuration Changes: Maintaining user input data during screen rotation
• Multi-Activity Data Sharing: Implementation through Application-scoped ViewModel

Dependency Configuration and Version Compatibility

Add necessary dependencies in build.gradle:

dependencies {
    def lifecycle_version = "2.5.0"
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
    implementation "androidx.fragment:fragment-ktx:1.5.0"
}

Ensure using the latest stable versions for optimal features and performance.

Conclusion

The ViewModel architecture component provides a modern solution for Android Fragment communication. By separating data from UI and combining with LiveData's observer pattern, developers can build cleaner, more maintainable, and test-friendly application architectures. While ViewModel simplifies data sharing, Fragment navigation (such as calling fragmentManager.replace()) still requires coordination through the Activity, which is a reasonable separation of concerns design. As Android architecture components continue to mature, ViewModel has become one of the core tools in modern Android development.