Actual bidirectional unloading

Change-Id: Id78e7ceee80b670424de4c93a5be2e819aac6fbb

Author: samtstern

firestore/src/main/java/com/firebase/ui/firestore/FirestoreInfiniteArray.java

@@ -30,6 +30,7 @@ public class FirestoreInfiniteArray<T> extends ObservableSnapshotArray<T> {
 
     private List<Page> mPages = new ArrayList<>();
 
+    // TODO: I am not using reverse query at all
     public FirestoreInfiniteArray(Query forwardQuery, Query reverseQuery, SnapshotParser<T> parser) {
         super(parser);
 
@@ -59,13 +60,20 @@ public int getPagesLoaded() {
         return count;
     }
 
-    public void unloadPage() {
+    public void unloadTopPage() {
         // Find first loaded page
         int firstLoaded = findFirstOfState(PageState.LOADED);
         if (firstLoaded != -1) {
             mPages.get(firstLoaded).unload();
-            Log.d(TAG, "unloadPage: unloading page " + firstLoaded);
-            Log.d(TAG, "unloadPage: new size = " + size());
+            Log.d(TAG, "UNLOADING " + firstLoaded);
+        }
+    }
+
+    public void unloadBottomPage() {
+        int lastLoaded = findLastOfState(PageState.LOADED);
+        if (lastLoaded != -1) {
+            mPages.get(lastLoaded).unload();
+            Log.d(TAG, "UNLOADING " + lastLoaded);
         }
     }
 
@@ -74,37 +82,54 @@ public void loadPrevPage() {
             return;
         }
 
-        // Find first unloaded page
-        int lastUnloaded = findLastOfState(PageState.UNLOADED);
-        if (lastUnloaded != -1) {
-            Log.d(TAG, "loadPrevPage: loading " + lastUnloaded);
-            mPages.get(lastUnloaded).load();
-        }
+        // Load the last UNLOADED page before the middle "core" of LOADED pages
+        int firstLoaded = findFirstOfState(PageState.LOADED);
+        int lastUnloadedBefore = findLastOfState(PageState.UNLOADED, firstLoaded);
 
-        // TODO: What if we have to change the starting position of the next page
+        if (lastUnloadedBefore != -1) {
+            Log.d(TAG, "RELOADING " + lastUnloadedBefore);
+            mPages.get(lastUnloadedBefore).load();
+        }
     }
 
     public void loadNextPage() {
         if (countState(PageState.LOADING) > 0) {
             return;
         }
 
-        Page lastPage = getLastPage();
-        DocumentSnapshot lastSnapshot = lastPage.getLast();
+        // There are two cases here
+        //  1. Need to load a whole new page
+        //  2. Need to load an UNLOADED bottom page
 
-        if (lastSnapshot == null) {
-            Log.w(TAG, "Skipping load because last snapshot is null!");
-            return;
-        }
+        int lastLoaded = findLastOfState(PageState.LOADED);
 
-        Query nextQuery = queryAfter(lastSnapshot);
-        Log.d(TAG, "loadNextPage: loading page " + mPages.size());
+        if (lastLoaded == mPages.size() - 1) {
+            // Case 1: Load a new page at the bottom
+            Page lastPage = getLastPage();
+            DocumentSnapshot lastSnapshot = lastPage.getLast();
+
+            // Reached the end, no more items to show
+            if (lastSnapshot == null) {
+                return;
+            }
+
+            Query nextQuery = queryAfter(lastSnapshot);
+            Log.d(TAG, "LOADING " + mPages.size());
+
+            // Add and start loading
+            int nextPageIndex = mPages.size();
+            Page nextPage = new Page(nextPageIndex, nextQuery);
+            mPages.add(nextPage);
+            nextPage.load();
+        } else {
+            // Case 2: Need to load a previously unloaded page
+            // Find the first UNLOADED page after the middle "core" of loaded pages
+            int firstUnloadedAfter = findFirstOfState(PageState.UNLOADED, lastLoaded);
+
+            Log.d(TAG, "RELOADING " + firstUnloadedAfter);
+            mPages.get(firstUnloadedAfter).load();
+        }
 
-        // Add and start loading
-        int nextPageIndex = mPages.size();
-        Page nextPage = new Page(nextPageIndex, nextQuery);
-        mPages.add(nextPage);
-        nextPage.load();
     }
 
     private void onPageLoaded(int index, int size) {
@@ -126,7 +151,11 @@ private void onPageUnloaded(int index, int size) {
     }
 
     private int findFirstOfState(PageState state) {
-        for (int i = 0; i < mPages.size(); i++) {
+        return findFirstOfState(state, 0);
+    }
+
+    private int findFirstOfState(PageState state, int startingAt) {
+        for (int i = startingAt; i < mPages.size(); i++) {
             Page page = mPages.get(i);
             if (page.getState() == state) {
                 return i;
@@ -137,7 +166,11 @@ private int findFirstOfState(PageState state) {
     }
 
     private int findLastOfState(PageState state) {
-        for (int i = mPages.size() - 1; i >= 0; i--) {
+        return findLastOfState(state, mPages.size() - 1);
+    }
+
+    private int findLastOfState(PageState state, int endingAt) {
+        for (int i = endingAt; i >= 0; i--) {
             Page page = mPages.get(i);
             if (page.getState() == state) {
                 return i;
@@ -178,9 +211,8 @@ public DocumentSnapshot getSnapshot(int index) {
             remaining -= page.size();
         }
 
-        // TODO
-        Log.e(TAG, "Requested bad index: " + index);
-        return null;
+        throw new IllegalArgumentException(
+                "Requested non-existent index: " + index + ", size=" + size());
     }
 
     @NonNull
@@ -222,11 +254,10 @@ private enum PageState {
 
     private class Page implements OnCompleteListener<QuerySnapshot> {
 
-        // TODO: state
-
+        // TODO: Does the Page really need to track its own index?
         private PageState mState;
-        public final int mIndex;
-        public final Query mQuery;
+        private final int mIndex;
+        private final Query mQuery;
 
         private DocumentSnapshot mFirstInPage;
 
@@ -262,12 +293,11 @@ public void onComplete(@NonNull Task<QuerySnapshot> task) {
                 Log.w(TAG, "Failed to get page", task.getException());
             }
 
-            Log.d(TAG, "pageLoaded: " + mIndex);
+            Log.d(TAG, "LOADED " + mIndex);
 
             // Add all snapshots
             mSnapshots.addAll(task.getResult().getDocuments());
 
-            // TODO
             // Range insert
             onPageLoaded(mIndex, mSnapshots.size());
         }

firestore/src/main/java/com/firebase/ui/firestore/FirestoreInfiniteScrollListener.java

@@ -11,6 +11,7 @@ public class FirestoreInfiniteScrollListener extends RecyclerView.OnScrollListen
 
     private Handler mHandler = new Handler();
 
+    // TODO: This could take the same options as the Array
     public FirestoreInfiniteScrollListener(LinearLayoutManager manager,
                                            FirestoreInfiniteArray array) {
         mManager = manager;
@@ -31,8 +32,9 @@ public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
 
         int totalSize = mArray.size();
 
-        // TODO: configurable "closeness"
+        // TODO: configurable "closeness" and number of pages to keep
         boolean movingDown = dy > 0;
+        boolean movingUp = !movingDown;
         boolean closeToTop = (firstVisible <= 5);
         boolean closeToBottom = (totalSize - lastVisible) <= 5;
 
@@ -41,22 +43,28 @@ public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
             mHandler.post(new Runnable() {
                 @Override
                 public void run() {
+                    // Load one page down
                     mArray.loadNextPage();
 
                     // Unload top page.
                     if (mArray.getPagesLoaded() >= 3 ) {
-                        mArray.unloadPage();
+                        mArray.unloadTopPage();
                     }
                 }
             });
 
-        } else if (closeToTop && !movingDown) {
+        } else if (closeToTop && movingUp) {
 
             mHandler.post(new Runnable() {
                 @Override
                 public void run() {
                     // Load one page up
                     mArray.loadPrevPage();
+
+                    // Unload bottom page
+                    if (mArray.getPagesLoaded() >= 3) {
+                        mArray.unloadBottomPage();
+                    }
                 }
             });