Retain viewmodels within activity

Daniel Novak · Daniel Novak · commit 807a57954f1c · 2016-01-19T15:33:43.000+01:00
diff --git a/library/src/main/java/eu/inloop/viewmodel/IViewModelProvider.java b/library/src/main/java/eu/inloop/viewmodel/IViewModelProvider.java
@@ -0,0 +1,14 @@
+package eu.inloop.viewmodel;
+
+/**
+ * Your {@link android.app.Activity} must implement this interface if
+ * any of the contained Fragments the {@link eu.inloop.viewmodel.ViewModelHelper}
+ */
+public interface IViewModelProvider {
+
+    /**
+     * See {@link eu.inloop.viewmodel.base.ViewModelBaseActivity} on how to implement.
+     * @return
+     */
+    public ViewModelProvider getViewModelProvider();
+}
diff --git a/library/src/main/java/eu/inloop/viewmodel/ViewModelHelper.java b/library/src/main/java/eu/inloop/viewmodel/ViewModelHelper.java
@@ -20,13 +20,15 @@ public class ViewModelHelper<T extends IView, R extends AbstractViewModel<T>> {
     /**
      * Call from {@link android.app.Activity#onCreate(android.os.Bundle)} or
      * {@link android.support.v4.app.Fragment#onCreate(android.os.Bundle)}
+     * @param activity parent activity
      * @param savedInstanceState savedInstance state from {@link Activity#onCreate(Bundle)} or
      *                           {@link Fragment#onCreate(Bundle)}
      * @param viewModelClass the {@link Class} of your ViewModel
      * @param arguments pass {@link Fragment#getArguments()}  or
      *                  {@link Activity#getIntent()}.{@link Intent#getExtras() getExtras()}
      */
-    public void onCreate(@Nullable Bundle savedInstanceState,
+    public void onCreate(@NonNull Activity activity,
+                         @Nullable Bundle savedInstanceState,
                          @Nullable Class<? extends AbstractViewModel<T>> viewModelClass,
                          @Nullable Bundle arguments) {
         // no viewmodel for this fragment
@@ -44,7 +46,7 @@ public void onCreate(@Nullable Bundle savedInstanceState,
         }
 
         // get model instance for this screen
-        final ViewModelProvider.ViewModelWrapper<T> viewModelWrapper = ViewModelProvider.getInstance().getViewModel(mScreenId, viewModelClass);
+        final ViewModelProvider.ViewModelWrapper<T> viewModelWrapper = getViewModelProvider(activity).getViewModelProvider().getViewModel(mScreenId, viewModelClass);
         //noinspection unchecked
         mViewModel = (R) viewModelWrapper.viewModel;
 
@@ -83,7 +85,7 @@ public void onDestroyView(@NonNull Fragment fragment) {
         }
         mViewModel.clearView();
         if (fragment.getActivity() != null && fragment.getActivity().isFinishing()) {
-            removeViewModel();
+            removeViewModel(fragment.getActivity());
         }
     }
 
@@ -98,14 +100,14 @@ public void onDestroy(@NonNull Fragment fragment) {
             return;
         }
         if (fragment.getActivity().isFinishing()) {
-            removeViewModel();
+            removeViewModel(fragment.getActivity());
         } else if (fragment.isRemoving() && !mOnSaveInstanceCalled) {
             // The fragment can be still in backstack even if isRemoving() is true.
             // We check mOnSaveInstanceCalled - if this was not called then the fragment is totally removed.
             if (BuildConfig.DEBUG) {
                 Log.d("mode", "Removing viewmodel - fragment replaced");
             }
-            removeViewModel();
+            removeViewModel(fragment.getActivity());
         }
     }
 
@@ -121,7 +123,7 @@ public void onDestroy(@NonNull Activity activity) {
         }
         mViewModel.clearView();
         if (activity.isFinishing()) {
-            removeViewModel();
+            removeViewModel(activity);
         }
     }
 
@@ -167,11 +169,18 @@ public void onSaveInstanceState(@NonNull Bundle bundle) {
         }
     }
 
-    private void removeViewModel() {
+    private void removeViewModel(@NonNull final Activity activity) {
         if (!mModelRemoved) {
-            ViewModelProvider.getInstance().remove(mScreenId);
+            getViewModelProvider(activity).getViewModelProvider().remove(mScreenId);
             mViewModel.onModelRemoved();
             mModelRemoved = true;
         }
     }
+
+    private IViewModelProvider getViewModelProvider(@NonNull Activity activity) {
+        if (!(activity instanceof IViewModelProvider)) {
+            throw new IllegalStateException("Your activity must implement IViewModelProvider");
+        }
+        return ((IViewModelProvider) activity);
+    }
 }
diff --git a/library/src/main/java/eu/inloop/viewmodel/ViewModelProvider.java b/library/src/main/java/eu/inloop/viewmodel/ViewModelProvider.java
@@ -1,5 +1,7 @@
 package eu.inloop.viewmodel;
+import android.app.Activity;
 import android.support.annotation.NonNull;
+import android.support.v4.app.FragmentActivity;
 import android.util.SparseArray;
 
 import java.util.HashMap;
@@ -12,22 +14,37 @@
  */
 public class ViewModelProvider {
 
-    private static final ViewModelProvider sInstance = new ViewModelProvider();
-
     private final HashMap<String, AbstractViewModel<? extends IView>> mViewModelCache;
 
-    private ViewModelProvider() {
-        mViewModelCache = new HashMap<>();
+    public static ViewModelProvider newInstance(@NonNull final FragmentActivity activity) {
+        if (activity.getLastCustomNonConfigurationInstance() == null) {
+            return new ViewModelProvider();
+        } else {
+            return  (ViewModelProvider) activity.getLastCustomNonConfigurationInstance();
+        }
     }
 
-    public static ViewModelProvider getInstance() {
-        return sInstance;
+    @Deprecated
+    public static ViewModelProvider newInstance(@NonNull final Activity activity) {
+        if (activity.getLastNonConfigurationInstance() == null) {
+            return new ViewModelProvider();
+        } else {
+            return  (ViewModelProvider) activity.getLastNonConfigurationInstance();
+        }
+    }
+
+    private ViewModelProvider() {
+        mViewModelCache = new HashMap<>();
     }
 
     public synchronized void remove(String modeIdentifier) {
         mViewModelCache.remove(modeIdentifier);
     }
 
+    public synchronized void removeAllViewModels() {
+        mViewModelCache.clear();
+    }
+
     @SuppressWarnings("unchecked")
     @NonNull
     public synchronized <T extends IView> ViewModelWrapper<T> getViewModel(String modelIdentifier, @NonNull Class<? extends AbstractViewModel<T>> viewModelClass) {
diff --git a/library/src/main/java/eu/inloop/viewmodel/base/ViewModelBaseActivity.java b/library/src/main/java/eu/inloop/viewmodel/base/ViewModelBaseActivity.java
@@ -6,16 +6,21 @@
 
 import eu.inloop.viewmodel.AbstractViewModel;
 import eu.inloop.viewmodel.IView;
+import eu.inloop.viewmodel.IViewModelProvider;
 import eu.inloop.viewmodel.ViewModelHelper;
+import eu.inloop.viewmodel.ViewModelProvider;
 
-public abstract class ViewModelBaseActivity<T extends IView, R extends AbstractViewModel<T>> extends AppCompatActivity implements IView {
+public abstract class ViewModelBaseActivity<T extends IView, R extends AbstractViewModel<T>> extends AppCompatActivity implements IView, IViewModelProvider {
 
     private final ViewModelHelper<T, R> mViewModeHelper = new ViewModelHelper<>();
+    private ViewModelProvider mViewModelProvider;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
+        //This code must be execute prior to super.onCreate()
+        mViewModelProvider = ViewModelProvider.newInstance(this);
         super.onCreate(savedInstanceState);
-        mViewModeHelper.onCreate(savedInstanceState, getViewModelClass(), getIntent().getExtras());
+        mViewModeHelper.onCreate(this, savedInstanceState, getViewModelClass(), getIntent().getExtras());
     }
 
     /**
@@ -28,6 +33,11 @@ public void setModelView(@NonNull T view) {
 
     public abstract Class<R> getViewModelClass();
 
+    @Override
+    public Object onRetainCustomNonConfigurationInstance() {
+        return mViewModelProvider;
+    }
+
     @Override
     public void onSaveInstanceState(Bundle outState) {
         super.onSaveInstanceState(outState);
@@ -44,6 +54,9 @@ public void onStart() {
     public void onStop() {
         super.onStop();
         mViewModeHelper.onStop();
+        if (isFinishing()) {
+            mViewModelProvider.removeAllViewModels();
+        }
     }
 
     @Override
@@ -56,4 +69,9 @@ public void onDestroy() {
     public R getViewModel() {
         return mViewModeHelper.getViewModel();
     }
+
+    @Override
+    public ViewModelProvider getViewModelProvider() {
+        return mViewModelProvider;
+    }
 }
diff --git a/library/src/main/java/eu/inloop/viewmodel/base/ViewModelBaseFragment.java b/library/src/main/java/eu/inloop/viewmodel/base/ViewModelBaseFragment.java
@@ -2,7 +2,6 @@
 
 import android.os.Bundle;
 import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
 import android.support.v4.app.Fragment;
 import android.view.View;
 
@@ -17,7 +16,7 @@ public abstract class ViewModelBaseFragment<T extends IView, R extends AbstractV
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        mViewModeHelper.onCreate(savedInstanceState, getViewModelClass(), getArguments());
+        mViewModeHelper.onCreate(getActivity(), savedInstanceState, getViewModelClass(), getArguments());
     }
 
     public abstract Class<R> getViewModelClass();
@@ -64,5 +63,4 @@ public void onDestroy() {
     public R getViewModel() {
        return mViewModeHelper.getViewModel();
     }
-
 }
diff --git a/sample/src/main/java/eu/inloop/viewmodel/sample/activity/ViewPagerActivity.java b/sample/src/main/java/eu/inloop/viewmodel/sample/activity/ViewPagerActivity.java
@@ -5,12 +5,12 @@
 import android.support.v4.app.FragmentManager;
 import android.support.v4.app.FragmentStatePagerAdapter;
 import android.support.v4.view.ViewPager;
-import android.support.v7.app.AppCompatActivity;
 
+import eu.inloop.viewmodel.base.ViewModelBaseActivity;
 import eu.inloop.viewmodel.sample.R;
 import eu.inloop.viewmodel.sample.fragment.PagerFragment;
 
-public class ViewPagerActivity extends AppCompatActivity {
+public class ViewPagerActivity extends ViewModelBaseActivity {
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -20,7 +20,12 @@ protected void onCreate(Bundle savedInstanceState) {
         final ViewPager viewPager = (ViewPager) findViewById(R.id.pager);
         viewPager.setAdapter(new TestPagerAdapter(getSupportFragmentManager()));
     }
-    
+
+    @Override
+    public Class getViewModelClass() {
+        return null;
+    }
+
     private final static class TestPagerAdapter extends FragmentStatePagerAdapter {
         public TestPagerAdapter(FragmentManager fm) {
             super(fm);

Original file line number	Diff line number	Diff line change
`@@ -20,13 +20,15 @@ public class ViewModelHelper<T extends IView, R extends AbstractViewModel<T>> {`
`20`	`20`	`/**`
`21`	`21`	`* Call from {@link android.app.Activity#onCreate(android.os.Bundle)} or`
`22`	`22`	`* {@link android.support.v4.app.Fragment#onCreate(android.os.Bundle)}`
	`23`	`+ * @param activity parent activity`
`23`	`24`	`* @param savedInstanceState savedInstance state from {@link Activity#onCreate(Bundle)} or`
`24`	`25`	`* {@link Fragment#onCreate(Bundle)}`
`25`	`26`	`* @param viewModelClass the {@link Class} of your ViewModel`
`26`	`27`	`* @param arguments pass {@link Fragment#getArguments()} or`
`27`	`28`	`* {@link Activity#getIntent()}.{@link Intent#getExtras() getExtras()}`
`28`	`29`	`*/`
`29`		`- public void onCreate(@Nullable Bundle savedInstanceState,`
	`30`	`+ public void onCreate(@NonNull Activity activity,`
	`31`	`+ @Nullable Bundle savedInstanceState,`
`30`	`32`	`@Nullable Class<? extends AbstractViewModel<T>> viewModelClass,`
`31`	`33`	`@Nullable Bundle arguments) {`
`32`	`34`	`// no viewmodel for this fragment`
`@@ -44,7 +46,7 @@ public void onCreate(@Nullable Bundle savedInstanceState,`
`44`	`46`	`}`
`45`	`47`
`46`	`48`	`// get model instance for this screen`
`47`		`- final ViewModelProvider.ViewModelWrapper<T> viewModelWrapper = ViewModelProvider.getInstance().getViewModel(mScreenId, viewModelClass);`
	`49`	`+ final ViewModelProvider.ViewModelWrapper<T> viewModelWrapper = getViewModelProvider(activity).getViewModelProvider().getViewModel(mScreenId, viewModelClass);`
`48`	`50`	`//noinspection unchecked`
`49`	`51`	`mViewModel = (R) viewModelWrapper.viewModel;`
`50`	`52`
`@@ -83,7 +85,7 @@ public void onDestroyView(@NonNull Fragment fragment) {`
`83`	`85`	`}`
`84`	`86`	`mViewModel.clearView();`
`85`	`87`	`if (fragment.getActivity() != null && fragment.getActivity().isFinishing()) {`
`86`		`- removeViewModel();`
	`88`	`+ removeViewModel(fragment.getActivity());`
`87`	`89`	`}`
`88`	`90`	`}`
`89`	`91`
`@@ -98,14 +100,14 @@ public void onDestroy(@NonNull Fragment fragment) {`
`98`	`100`	`return;`
`99`	`101`	`}`
`100`	`102`	`if (fragment.getActivity().isFinishing()) {`
`101`		`- removeViewModel();`
	`103`	`+ removeViewModel(fragment.getActivity());`
`102`	`104`	`} else if (fragment.isRemoving() && !mOnSaveInstanceCalled) {`
`103`	`105`	`// The fragment can be still in backstack even if isRemoving() is true.`
`104`	`106`	`// We check mOnSaveInstanceCalled - if this was not called then the fragment is totally removed.`
`105`	`107`	`if (BuildConfig.DEBUG) {`
`106`	`108`	`Log.d("mode", "Removing viewmodel - fragment replaced");`
`107`	`109`	`}`
`108`		`- removeViewModel();`
	`110`	`+ removeViewModel(fragment.getActivity());`
`109`	`111`	`}`
`110`	`112`	`}`
`111`	`113`
`@@ -121,7 +123,7 @@ public void onDestroy(@NonNull Activity activity) {`
`121`	`123`	`}`
`122`	`124`	`mViewModel.clearView();`
`123`	`125`	`if (activity.isFinishing()) {`
`124`		`- removeViewModel();`
	`126`	`+ removeViewModel(activity);`
`125`	`127`	`}`
`126`	`128`	`}`
`127`	`129`
`@@ -167,11 +169,18 @@ public void onSaveInstanceState(@NonNull Bundle bundle) {`
`167`	`169`	`}`
`168`	`170`	`}`
`169`	`171`
`170`		`- private void removeViewModel() {`
	`172`	`+ private void removeViewModel(@NonNull final Activity activity) {`
`171`	`173`	`if (!mModelRemoved) {`
`172`		`- ViewModelProvider.getInstance().remove(mScreenId);`
	`174`	`+ getViewModelProvider(activity).getViewModelProvider().remove(mScreenId);`
`173`	`175`	`mViewModel.onModelRemoved();`
`174`	`176`	`mModelRemoved = true;`
`175`	`177`	`}`
`176`	`178`	`}`
	`179`	`+`
	`180`	`+ private IViewModelProvider getViewModelProvider(@NonNull Activity activity) {`
	`181`	`+ if (!(activity instanceof IViewModelProvider)) {`
	`182`	`+ throw new IllegalStateException("Your activity must implement IViewModelProvider");`
	`183`	`+ }`
	`184`	`+ return ((IViewModelProvider) activity);`
	`185`	`+ }`
`177`	`186`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`
`3`	`3`	`import android.os.Bundle;`
`4`	`4`	`import android.support.annotation.NonNull;`
`5`		`-import android.support.annotation.Nullable;`
`6`	`5`	`import android.support.v4.app.Fragment;`
`7`	`6`	`import android.view.View;`
`8`	`7`
`@@ -17,7 +16,7 @@ public abstract class ViewModelBaseFragment<T extends IView, R extends AbstractV`
`17`	`16`	`@Override`
`18`	`17`	`public void onCreate(Bundle savedInstanceState) {`
`19`	`18`	`super.onCreate(savedInstanceState);`
`20`		`- mViewModeHelper.onCreate(savedInstanceState, getViewModelClass(), getArguments());`
	`19`	`+ mViewModeHelper.onCreate(getActivity(), savedInstanceState, getViewModelClass(), getArguments());`
`21`	`20`	`}`
`22`	`21`
`23`	`22`	`public abstract Class<R> getViewModelClass();`
`@@ -64,5 +63,4 @@ public void onDestroy() {`
`64`	`63`	`public R getViewModel() {`
`65`	`64`	`return mViewModeHelper.getViewModel();`
`66`	`65`	`}`
`67`		`-`
`68`	`66`	`}`