Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/inloop/AndroidViewModel
Separating data and state handling from Fragments or Activities without lots of boilerplate-code.
https://github.com/inloop/AndroidViewModel
android android-library architecture java mvvm
Last synced: about 2 months ago
JSON representation
Separating data and state handling from Fragments or Activities without lots of boilerplate-code.
- Host: GitHub
- URL: https://github.com/inloop/AndroidViewModel
- Owner: inloop
- License: apache-2.0
- Created: 2014-09-23T19:39:06.000Z (about 10 years ago)
- Default Branch: master
- Last Pushed: 2019-02-13T17:31:59.000Z (almost 6 years ago)
- Last Synced: 2024-08-01T03:25:03.280Z (5 months ago)
- Topics: android, android-library, architecture, java, mvvm
- Language: Java
- Homepage:
- Size: 961 KB
- Stars: 815
- Watchers: 55
- Forks: 111
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
- awesome-android-architecture - AndroidViewModel - code. (Table of content / Repos)
README
AndroidViewModel
================
Important notice: Deprecated
--------
This library served it's purpose for over 3 years. We believe that Google's Android [Architecture Components](https://developer.android.com/topic/libraries/architecture/index.html) are the preferred setup now for new projects.
[INLOOPX](http://www.inloopx.com) is dedicated to continue maintaining this library (no deadline on support end). So rest assured that your existing projects don't need be migrated from AndroidViewModel because of this deprecation. We are only stopping new feature development and don't recommend using it for new projects.
Separating data and state handling from Fragments or Activities without lots of boilerplate-code. Reducing them to simple dumb views.
Basic idea behind this library.
An instance of a ViewModel class is assigned to your Fragment or Activity during the first creation and is kept during it's life cycle, even between display orientation changes. The ViewModel instance is removed after the Fragment or Activity is completely gone (finished, popped from backstack, replaced without keeping it in backstack).
You can execute asynchronous tasks in this ViewModel instance and this class is not destroyed during orientation change. All data handling and state logic should be placed inside this class. The Fragment or Activity is just a "dumb" view.
How to implement
--------
1. Create an interface for your View by extending [IView](library/src/main/java/eu/inloop/viewmodel/IView.java). We will call it IUserListView for this example.
```java
public interface IUserListView extends IView {
public void showUsers(List users);
}
```
2. Create your ViewModel class by extending [AbstractViewModel](library/src/main/java/eu/inloop/viewmodel/AbstractViewModel.java). For example:
```java
public class UserListViewModel extends AbstractViewModel {
....
}
```
3. Each Fragment or Activity that you would like to associate with a ViewModel will need either to extend [ViewModelActivityBase](library/src/main/java/eu/inloop/viewmodel/base/ViewModelBaseActivity.java)/[ViewModelBaseFragment](library/src/main/java/eu/inloop/viewmodel/base/ViewModelBaseFragment.java) or copy the implementation from these classes to your base activity/fragment class (in case you can't inherit directly). For example:
```java
public class UserListFragment extends ViewModelBaseFragment
implements IUserListView {
}
```
4. Also each Fragment or Activity has to call ```setModelView()``` after the View (Fragment/Activity) was created and initialized. This is usually on the end of onViewCreated (or onCreate in case of an Activity)
```java
@Override
public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
ButterKnife.inject(this, view);
setModelView(this);
}
```
How to use
--------
You can forward user interaction from the View into the ViewModel simply by calling:
```java
getViewModel().onDeleteUserClicked(userId);
```
The same goes for the opposite direction, when your asynchronous operation in the ViewModel finished and you would like to forward data to the View to show a list for example:
```java
getViewOptional().showUsers(userList);
```
The ```getViewOptional()``` method will never return null. It will return a dummy implementation in case the View is null at the moment (e.g. Fragment already destroyed, or between orientation change).
You can also check if the View is not null in case you need to:
```java
if (getView() != null) {
getView().showUsers(userList);
}
```
Your Fragment argument Bundle and Activity intent Bundle is forwarded to the ViewModel's onCreate method, which you can override to read the initial arguments for the ViewModel.
```java
public void onCreate(Bundle arguments, Bundle savedInstanceState) {
long userId = arguments.getInt("user_id", -1);
}
```
Data binding support
--------
Data binding is supported - extend [ViewModelBaseBindingFragment.java](library/src/main/java/eu/inloop/viewmodel/binding/ViewModelBaseBindingFragment.java) instead of ViewModelBaseFragment and implement ```getViewModelBindingConfig()``` in your Fragment.
``` java
@Override
public ViewModelBindingConfig getViewModelBindingConfig() {
return new ViewModelBindingConfig(R.layout.fragment_sample_binding, requireActivity());
}
```
That's it. You can then directly use ObservableField in your ViewModels. See [example](sample/src/main/java/eu/inloop/viewmodel/sample/viewmodel/SampleBindingViewModel.java).
Special handling for FragmentStatePagerAdapter
--------
The Android implementation of [FragmentStatePagerAdapter](https://developer.android.com/reference/android/support/v4/app/FragmentStatePagerAdapter.html) is removing Fragments and storing their state. This is in contrast with [FragmentPagerAdapter](https://developer.android.com/reference/android/support/v4/app/FragmentPagerAdapter.html) where the Fragments are just detached but not removed.
We should be also removing ViewModels and storing their state to be consistent with this behaviour.
Use [ViewModelStatePagerAdapter](library/src/main/java/eu/inloop/viewmodel/support/ViewModelStatePagerAdapter.java) instead of the default FragmentStatePagerAdapter. This class is only overriding the ```destroyItem()``` method and making sure that ViewModel is removed. The state is stored/restored automatically.
You can also use the standard FragmentStatePagerAdapter - in that case ViewModels will be kept in memory and removed only when you leave the screen (Activity finished or Fragment removed).
How does it work?
--------
A unique global ID is generated for the first time your Fragment or Activity is shown. This ID is passed on during orientation changes. Opening another instance of the same Fragment or Activity will result in a different ID. The ID is unique screen identifier. A ViewModel class is created and bound to this ID. The corresponding ViewModel instance is attached to your Fragment or Activity after an orientation change or if you return to the fragment in the back stack.
The ViewModel is discarded once the Fragment/Activity is not reachable anymore (activity is finished or fragment permanently removed).
Download
--------
```groovy
compile 'eu.inloop:androidviewmodel:1.4.0'
```
## Android Studio Template
For faster creating new screens, you can use [Android Studio Template](/template/AVM_Inloop)
### Install template
#### Manually:
Copy the template folder to Android Studio templates folder (`/Applications/Android Studio.app/Contents/plugins/android/lib/templates/others` on Mac)
#### Automatically:
Run the following command to download and install the template automatically (Mac only)
```
curl -o androidviewmodel.zip -Lk https://github.com/inloop/AndroidViewModel/archive/master.zip && unzip androidviewmodel.zip && cp -af AndroidViewModel-master/template/AVM_Inloop/. "/Applications/Android Studio.app/Contents/plugins/android/lib/templates/other/AVM_Inloop" && rm -r AndroidViewModel-master && rm androidviewmodel.zip
```
Don't forget to restart the Android Studio.
### Usage
In the Android Studio right click inside the Projet window and select `File > New > AndroidViewModel Inloop > AVM Fragment`
