ViewModelProviders Deprecated: Evolution and Practice of ViewModel Acquisition in Android Architecture Components

Background and Clarification of ViewModelProviders Deprecation

In the evolution of Android Architecture Components, the ViewModelProviders class was once the standard way to obtain ViewModel instances. Developers typically used code like: val model = ViewModelProviders.of(this).get(MyViewModel::class.java). However, as architecture components continued to evolve, this approach was marked as deprecated at API level 1.1.0, sparking widespread discussion in the development community.

Clarifying Misconceptions in Official Documentation

Many developers noticed the comment in official documentation: "This class was deprecated in API level 1.1.0. Use ViewModelProvider.AndroidViewModelFactory". This statement is easily misunderstood; it actually refers specifically to the ViewModelProviders.DefaultFactory class, not the entire ViewModelProviders class. Practical testing confirms that when using the android.arch.lifecycle:extensions:1.1.1 dependency, the ViewModelProviders class still exists and remains usable.

Impact Analysis of Dependency Versions

Different versions of architecture component dependencies significantly affect ViewModel acquisition methods. In newer AndroidX architecture, it is recommended to use androidx.lifecycle:lifecycle-extensions:2.2.0 or higher. At this point, the ViewModelProviders class has indeed been removed, and developers need to adopt new APIs.

Modern ViewModel Acquisition Methods

In AndroidX architecture, the standard way to obtain ViewModels has evolved to directly use the ViewModelProvider constructor. The basic usage is as follows:

// Without ViewModelFactory
val viewModel = ViewModelProvider(this).get(YourViewModel::class.java)

// With custom ViewModelFactory
val viewModel = ViewModelProvider(this, YourViewModelFactory).get(YourViewModel::class.java)

Simplification with Android KTX

For Kotlin developers, Android KTX offers a more elegant solution. By adding the androidx.fragment:fragment-ktx:1.2.4 dependency, property delegation can simplify ViewModel acquisition:

// Basic usage
val viewmodel: MyViewModel by viewModels()

// With custom Factory
val viewmodel: MyViewModel by viewModels { myFactory }

This approach not only makes code more concise but also integrates better with modern Kotlin features like coroutines and Flow.

Adaptation for Java Projects

For Java projects, the migration path is equally straightforward. Developers can directly call the ViewModelProvider constructor:

// Without Factory
MyViewModel viewModel = new ViewModelProvider(this).get(MyViewModel.class);

// With Factory
MyViewModel viewModel = new ViewModelProvider(this, myViewModelFactory).get(MyViewModel.class);

Version Compatibility Considerations

In practical projects, developers need to consider compatibility across different Android versions. For projects still using Support Library, the ViewModelProviders class can continue to be used. For projects that have migrated to AndroidX, the new ViewModelProvider approach should be adopted. This gradual migration strategy ensures smooth project transitions.

Role and Implementation of ViewModelFactory

ViewModelFactory plays a crucial role in ViewModel instantiation, especially when ViewModels require dependency injection or special initialization logic. Custom factories need to implement the ViewModelProvider.Factory interface and provide ViewModel instantiation logic in the create method. This is fundamentally different from directly calling a create method to obtain new instances, as the latter cannot achieve proper ViewModel lifecycle management.

Best Practice Recommendations

Based on the above analysis, we propose the following best practices: First, update project dependencies to the latest AndroidX versions promptly; second, choose between Kotlin delegation or Java direct invocation based on project language; third, use ViewModelFactory appropriately for complex initialization scenarios; finally, stay informed about official documentation and API changes, adjusting implementation methods accordingly.

Conclusion and Future Outlook

The evolution of ViewModel acquisition methods reflects the trend of Android Architecture Components moving towards more modular and flexible designs. The transition from ViewModelProviders to ViewModelProvider not only simplifies API design but also provides better extensibility. As Jetpack components continue to improve, developers should embrace these changes to build more robust and maintainable Android applications.