mvvm-设计模式框架.zip

# mv²m Android MVVM lightweight library based on Android Data Binding [](https://circleci.com/gh/fabioCollini/mv2m/tree/master)  [](http://android-arsenal.com/details/1/2524) The goal of mv²m is to simplify JVM testing of an Android application. The [demo module](/demo) contains a simple example of usage of mv²m library. The [official app](https://github.com/commit-non-javisti/CoseNonJavisteAndroidApp) of the Italian blog [cosenonjaviste.it](http://cosenonjaviste.it) is a more complex example (built using Dagger and RxJava). This [repository](https://github.com/fabioCollini/android-testing/tree/final) contains the mv²m porting of [android-testing codelab](https://github.com/googlecodelabs/android-testing) repository. Mv2m is available on [JitPack](https://jitpack.io/#fabioCollini/mv2m/), add the JitPack repository in your build.gradle (in top level dir): ```gradle repositories { jcenter() maven { url "https://jitpack.io" } } ``` and the dependency in the build.gradle of the module: ```gradle dependencies { //core module compile 'com.github.fabioCollini.mv2m:mv2m:0.4.1' //RxJava support compile 'com.github.fabioCollini.mv2m:mv2mrx:0.4.1' //RecyclerView support compile 'com.github.fabioCollini.mv2m:mv2mrecycler:0.4.1' } ``` ## Components of mv²m ##### Model A Model class contains the data used to populate the user interface using Data Binding library. It's saved automatically in Actvity/Fragment state, for this reason it must implement Parcelable interface. ##### View The View is an Activity or a Fragment, the user interface is managed using Android Data Binding. You need to extend ViewModelActivity or ViewModelFragment class and implement createViewModel method returning a new ViewModel object. ##### ViewModel The ViewModel is a subclass of ViewModel class, it is automatically saved in a retained fragment to avoid the creation of a new object on every configuration change. The ViewModel is usually the object bound to the layout using the Data Binding framework. It manages the background tasks and all the business logic of the application.  ## JUnit tests The ViewModel is not connected to the View, for this reason it's easily testable using a JVM test. The demo module contains [some](https://github.com/fabioCollini/mv2m/blob/master/demo/src/test/java/it/cosenonjaviste/demomv2m/core/detail/NoteViewModelTest.java) [JUnit tests](https://github.com/fabioCollini/mv2m/blob/master/demo/src/test/java/it/cosenonjaviste/demomv2m/core/list/NoteListViewModelTest.java) for ViewModel classes. ## Activity Sometimes an Activity object is required to perform some operations, for example you need an Activity object to show a SnackBar message or to start another Activity. In this case you can create a new class with some methods with an ActivityHolder parameter: ```java public class SnackbarMessageManager { @Override public void showMessage(ActivityHolder activityHolder, int message) { if (activityHolder != null) { Snackbar.make(activityHolder.getActivity().findViewById(android.R.id.content), message, Snackbar.LENGTH_LONG).show(); } } } ``` An implementation of this class can be referenced from a ViewModel object. ViewModel class contains a protected ActivityHolder field containing a reference to the current Activity that can be used as parameter (it's automatically updated every configuration change). In this way it's easy to show a SnackBar from a ViewModel. In a JVM test SnackbarMessageManager object can be mocked to avoid dependencies on Android framework. ## ViewModel argument ViewModel class has two generic parameters: the type of the argument and the type of the Model class. The argument can be used when the ViewModel needs an argument, for example in a detail ViewModel the argument is the id of the object you have to show. The argument must be an object that can be written in a Bundle (a primitive type, a Serializable or a Parcelable). Using an ActivityHolder object you can start a new Activity passing an argument: ```java activityHolder.startActivity(NoteActivity.class, noteId); ``` ViewModel class contains a protected field argument that can be used to load the model data based on the argument. In case you use Fragments as View objects you can use ArgumentManager.instantiateFragment method to create a new Fragment and set the argument on it. ## Work in progress This library (and the Android Data Binding library) is still a beta version; feedbacks, bug reports and pull requests are welcome! ## Talk is cheap. Show me the code. Let's see how to use mv²m to implement a simple example: a currency converter Activity.  The Model class contains two fields, one is bound with the input EditText and the other with the output TextField: ```java public class CurrencyConverterModel implements Parcelable { public ObservableString input = new ObservableString(); public ObservableString output = new ObservableString(); //Parcelable implementation... } ``` Using RateLoader class it's possible to load a rate from an external source (for example a REST service), in this first implementation it executes everything synchronously: ```java public class RateLoader { private static RateLoader INSTANCE = new RateLoader(); private RateLoader() { } public static RateLoader instance() { return INSTANCE; } public float loadRate() { //... } } ``` All the business logic is in the CurrencyConverterViewModel class, it extends ViewModel class defining two generic parameters: Void (we don't need any argument) and the Model class. ```java public class CurrencyConverterViewModel extends ViewModel<Void, CurrencyConverterModel> { private RateLoader rateLoader; public CurrencyConverterViewModel(RateLoader rateLoader) { this.rateLoader = rateLoader; } @NonNull @Override public CurrencyConverterModel createModel() { return new CurrencyConverterModel(); } public void calculate() { String inputString = model.input.get(); float input = Float.parseFloat(inputString); model.output.set(new DecimalFormat("0.00").format(input * rateLoader.loadRate())); } } ``` We use the dependency injection on the constructor to manage a reference to a RateLoader object. The createModel method is overridden to create and return a new Model object. The ViewModel class has no Android dependencies, it can be tested easily using a JUnit test: ```java @RunWith(MockitoJUnitRunner.class) public class CurrencyConverterViewModelTest { @Mock RateLoader rateLoader; @InjectMocks CurrencyConverterViewModel viewModel; @Test public void testConvertCurrency() { when(rateLoader.loadRate()).thenReturn(2f); CurrencyConverterModel model = viewModel.initAndResume(); model.input.set("123"); viewModel.calculate(); assertThat(model.output.get()).isEqualTo("246.00"); } } ``` In this JUnit test we use Mockito to create a mock of RateLoader object, in this way the test is repeatable because it's not dependent on external sources. Data binding library is used to bind ViewModel object to the layout: ```xml <layout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto"> <data> <variable name="viewModel" type="it.cosenonjaviste.demomv2m.core.currencyconverter1.CurrencyConverterViewModel"/> </data> <LinearLayout android:layout_width="match_parent"