Model cache lookup speed improved

Author: Daniel Novak

README.md

@@ -3,19 +3,21 @@ AndroidViewModel
 
 Separating data and state handling from Fragments or Activities without lots of boilerplate-code. Reducing them to simple <i>dumb views</i>.
 
-<b>Basic idea behind this library</b>
-
-An instance of a Model 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 Model instance is removed after the Fragment or Activity is completely gone (finished, poppped from backstack, replaced without keeping it in backstack).
+<b>Basic idea behind this library</b>.
+An instance of a Model 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 Model 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 Model 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.
 
-<b>How does it work?</b> </p>
-A unique global ID is generated for the first time your Fragment or Activity is shown. This ID is passed on during orientation changes. Openning 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 reachaeable anymore (activity is finished or fragment permanently removed).
+<b>How does it work?</b>
+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).
+
+<b>Why no controller layer?</b>
+This is not a strict MVC/MVP architecture - simply because we felt that having another layer between the "model" and the view does not bring enough advantages. So to further reduce the code this was simplified, where the Model is talking to the View over an interface. In mobile application most of the code is about interaction with the UI (getting data from API/DB, showing the data, manipulating, saving) so a more direct connection between the layers felt appropriate. 
 
 <b>Sample Workflow</b>:
 
-1. <small>Fragment is show to user. A ViewModel is assigned.</small>
+1. <small>Fragment is shown to user. A ViewModel is assigned.</small>
 2. Fragment notifies the View that it's ready. 
 3. ViewModel starts the async task to load data. Tells the view to show progress.
 4. User rotates the display. The ViewModel continues with the loading part.
@@ -36,7 +38,7 @@ or Maven:
 <dependency>
   <groupId>eu.inloop</groupId>
   <artifactId>androidviewmodel</artifactId>
-  <version>0.1</version>
+  <version>0.2</version>
 </dependency>
 ```
 

library/src/main/java/eu/inloop/viewmodel/AbstractViewModel.java

@@ -8,13 +8,12 @@
 
 public abstract class AbstractViewModel<T extends IView> {
 
-    @NonNull
-    private String mUniqueIdentifier;
+    private int mUniqueIdentifier;
 
     @Nullable
     private T mView;
 
-    void setUniqueIdentifier(String uniqueIdentifier) {
+    void setUniqueIdentifier(int uniqueIdentifier) {
         mUniqueIdentifier = uniqueIdentifier;
     }
 
@@ -23,7 +22,7 @@ void setUniqueIdentifier(String uniqueIdentifier) {
      * @return An app unique identifier for the current viewmodel instance (will be kept during orientation
      * change). This identifier will be reset in case the corresponding activity is killed.
      */
-    public String getUniqueIdentifier() {
+    public int getUniqueIdentifier() {
         return mUniqueIdentifier;
     }
 

library/src/main/java/eu/inloop/viewmodel/ViewModelHelper.java

@@ -5,17 +5,17 @@
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.v4.app.Fragment;
-import android.support.v4.app.FragmentManager;
 import android.util.Log;
 
-import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class ViewModelHelper<T extends IView, R extends AbstractViewModel<T>> {
 
-    private String mScreenId;
+    private int mScreenId;
     private R mViewModel;
     private boolean mModelRemoved;
     private boolean mOnSaveInstanceCalled;
+    private static AtomicInteger sModelIndex = new AtomicInteger(0);
 
     /**
      * Call from {@link android.app.Activity#onCreate(android.os.Bundle)} or
@@ -33,9 +33,9 @@ public void onCreate(@Nullable Bundle savedInstanceState,
 
         // screen (activity/fragment) created for first time, attach unique ID
         if (savedInstanceState == null) {
-            mScreenId = UUID.randomUUID().toString();
+            mScreenId = sModelIndex.incrementAndGet();
         } else {
-            mScreenId = savedInstanceState.getString("identifier");
+            mScreenId = savedInstanceState.getInt("identifier");
             mOnSaveInstanceCalled = false;
         }
 
@@ -151,21 +151,18 @@ public R getViewModel() {
      * @param bundle
      */
     public void onSaveInstanceState(@NonNull Bundle bundle) {
-        bundle.putString("identifier", mScreenId);
+        bundle.putInt("identifier", mScreenId);
         if (mViewModel != null) {
             mViewModel.saveState(bundle);
             mOnSaveInstanceCalled = true;
         }
     }
 
-    private boolean removeViewModel() {
+    private void removeViewModel() {
         if (!mModelRemoved) {
-            boolean removed = ViewModelProvider.getInstance().remove(mScreenId);
+            ViewModelProvider.getInstance().remove(mScreenId);
             mViewModel.onModelRemoved();
             mModelRemoved = true;
-            return removed;
-        } else {
-            return false;
         }
     }
 }

library/src/main/java/eu/inloop/viewmodel/ViewModelProvider.java

@@ -1,5 +1,6 @@
 package eu.inloop.viewmodel;
 import android.support.annotation.NonNull;
+import android.util.SparseArray;
 
 import java.util.HashMap;
 
@@ -13,54 +14,53 @@ public class ViewModelProvider {
 
     private static final ViewModelProvider sInstance = new ViewModelProvider();
 
-    private final HashMap<String, AbstractViewModel<? extends IView>> mViewModelCache;
+    private final SparseArray<AbstractViewModel<? extends IView>> mViewModelCache;
 
     private ViewModelProvider() {
-        mViewModelCache = new HashMap<>();
+        mViewModelCache = new SparseArray<>();
     }
 
     public static ViewModelProvider getInstance() {
         return sInstance;
     }
 
-    public boolean remove(@NonNull String key) {
-        return mViewModelCache.remove(key) != null;
-    }
-
-    public static class ViewModelWrapper<T extends IView> {
-        @NonNull
-        public final AbstractViewModel<T> viewModel;
-        public final boolean wasCreated;
-
-        private ViewModelWrapper(@NonNull AbstractViewModel<T> mViewModel, boolean mWasCreated) {
-            this.viewModel = mViewModel;
-            this.wasCreated = mWasCreated;
-        }
+    public synchronized void remove(int modelIndex) {
+        mViewModelCache.remove(modelIndex);
     }
 
     /**
      * Call this in {@link android.app.Activity#onStop()} if {@link android.app.Activity#isFinishing()}
      */
-    public void removeAllViewModels() {
+    public synchronized void removeAllViewModels() {
         mViewModelCache.clear();
     }
 
     @SuppressWarnings("unchecked")
     @NonNull
-    public synchronized <T extends IView> ViewModelWrapper<T> getViewModel(@NonNull String key, @NonNull Class<? extends AbstractViewModel<T>> viewModelClass) {
-        AbstractViewModel<T> instance = (AbstractViewModel<T>) mViewModelCache.get(key);
+    public synchronized <T extends IView> ViewModelWrapper<T> getViewModel(int modelIndex, @NonNull Class<? extends AbstractViewModel<T>> viewModelClass) {
+        AbstractViewModel<T> instance = (AbstractViewModel<T>) mViewModelCache.get(modelIndex);
         if (instance != null) {
             return new ViewModelWrapper<>(instance, false);
         }
 
         try {
             instance = viewModelClass.newInstance();
-            instance.setUniqueIdentifier(key);
-            mViewModelCache.put(key, instance);
+            instance.setUniqueIdentifier(modelIndex);
+            mViewModelCache.put(modelIndex, instance);
             return new ViewModelWrapper<>(instance, true);
         } catch (InstantiationException | IllegalAccessException e) {
             throw new RuntimeException(e);
         }
     }
 
+    public static class ViewModelWrapper<T extends IView> {
+        @NonNull
+        public final AbstractViewModel<T> viewModel;
+        public final boolean wasCreated;
+
+        private ViewModelWrapper(@NonNull AbstractViewModel<T> mViewModel, boolean mWasCreated) {
+            this.viewModel = mViewModel;
+            this.wasCreated = mWasCreated;
+        }
+    }
 }