refactor: pagination

Signed-off-by: alperozturk <[email protected]>

app/src/main/java/com/nextcloud/utils/FileHelper.kt

@@ -12,57 +12,47 @@ import java.io.File
 import java.io.IOException
 import java.nio.file.Files
 import java.nio.file.Path
+import java.util.stream.Collectors
 import kotlin.io.path.pathString
 
 @Suppress("NestedBlockDepth")
 object FileHelper {
     private const val TAG = "FileHelper"
 
-    fun fetchFiles(folder: File?, offset: Int, limit: Int): List<File> {
-        val files = mutableListOf<File>()
-        if (folder == null || !folder.exists() || !folder.isDirectory) return files
+    fun listDirectoryEntries(
+        directory: File?,
+        startIndex: Int,
+        maxItems: Int,
+        fetchFolders: Boolean
+    ): List<File> {
+        if (directory == null || !directory.exists() || !directory.isDirectory) return emptyList()
 
-        val dir = folder.toPath()
-        var skipped = 0
-        try {
-            Files.newDirectoryStream(dir).use { stream ->
-                for (entry in stream) {
-                    if (skipped < offset) {
-                        skipped++
-                        continue
-                    }
-                    files.add(entry.toFile())
-                    if (files.size >= limit) break
-                }
-            }
-        } catch (e: IOException) {
-            Log_OC.d(TAG, "fetchFiles: $e")
-        }
-        return files
-    }
+        return try {
+            val allEntries = Files.list(directory.toPath())
+                .map { it.toFile() }
+                .collect(Collectors.toList())
 
-    fun fetchFolders(folder: File?, offset: Int, limit: Int): List<File> {
-        val folders = mutableListOf<File>()
-        if (folder == null || !folder.exists() || !folder.isDirectory) return folders
+            val result = mutableListOf<File>()
+            var skipped = 0
 
-        val dir = folder.toPath()
-        var skipped = 0
-        try {
-            Files.newDirectoryStream(dir).use { stream ->
-                for (entry in stream) {
-                    if (!entry.toFile().isDirectory) continue
-                    if (skipped < offset) {
+            for (file in allEntries) {
+                val shouldInclude = if (fetchFolders) file.isDirectory else true
+
+                if (shouldInclude) {
+                    if (skipped < startIndex) {
                         skipped++
                         continue
                     }
-                    folders.add(entry.toFile())
-                    if (folders.size >= limit) break
+                    result.add(file)
+                    if (result.size >= maxItems) break
                 }
             }
+
+            result
         } catch (e: IOException) {
-            Log_OC.d(TAG, "fetchFolders: $e")
+            Log_OC.d(TAG, "listDirectoryEntries: $e")
+            emptyList()
         }
-        return folders
     }
 
     fun listFilesRecursive(files: Collection<File>): List<String> {

app/src/main/java/com/owncloud/android/ui/adapter/LocalFileListAdapter.java

@@ -71,7 +71,6 @@ public class LocalFileListAdapter extends RecyclerView.Adapter<RecyclerView.View
 
     private static final int PAGE_SIZE = 50;
     private int currentOffset = 0;
-    private File currentDirectory = null;
 
     public LocalFileListAdapter(boolean localFolderPickerMode,
                                 File directory,
@@ -305,100 +304,73 @@ public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int
      *
      * @param directory New file to adapt. Can be NULL, meaning "no content to adapt".
      */
-    @SuppressLint("NotifyDataSetChanged")
     public void swapDirectory(final File directory) {
         localFileListFragmentInterface.setLoading(true);
-        currentDirectory = directory;
         currentOffset = 0; // reset offset
 
         Executors.newSingleThreadExecutor().execute(() -> {
-            List<File> firstPage;
-            if (directory == null) {
-                firstPage = new ArrayList<>();
-            } else {
-                if (mLocalFolderPicker) {
-                    firstPage = FileHelper.INSTANCE.fetchFolders(directory, currentOffset, PAGE_SIZE);
-                } else {
-                    firstPage = FileHelper.INSTANCE.fetchFiles(directory, currentOffset, PAGE_SIZE);
-                }
-            }
+            List<File> firstPage = FileHelper.INSTANCE.listDirectoryEntries(directory, currentOffset, PAGE_SIZE, mLocalFolderPicker);
 
-            // sort and filter
             if (!firstPage.isEmpty()) {
-                FileSortOrder sortOrder = preferences.getSortOrderByType(FileSortOrder.Type.localFileListView);
-                firstPage = sortOrder.sortLocalFiles(firstPage);
-
-                boolean showHiddenFiles = preferences.isShowHiddenFilesEnabled();
-                if (!showHiddenFiles) {
-                    firstPage = filterHiddenFiles(firstPage);
-                }
+                firstPage = sortAndFilterHiddenEntries(firstPage);
             }
 
-            final List<File> initialFiles = firstPage;
-            if (!mLocalFolderPicker) {
-                currentOffset += initialFiles.size();
-            }
+            // first set the currentOffset to PAGE_SIZE
+            currentOffset += PAGE_SIZE;
+            updateUIForFirstPage(firstPage);
 
-            // update UI immediately with first page
-            new Handler(Looper.getMainLooper()).post(() -> {
-                mFiles = new ArrayList<>(initialFiles);
-                mFilesAll = new ArrayList<>(initialFiles);
-                notifyDataSetChanged();
-                localFileListFragmentInterface.setLoading(false);
-            });
+            // load the rest silently in the background and updates the currentOffset by PAGE_SIZE for pagination
+            loadRemainingEntries(directory, mLocalFolderPicker);
+        });
+    }
 
-            // load the rest silently in the background
-            if(mLocalFolderPicker) {
-                loadRemainingFolders(directory);
-            } else {
-                loadRemainingFiles(directory);
-            }
+    @SuppressLint("NotifyDataSetChanged")
+    private void updateUIForFirstPage(List<File> firstPage) {
+        new Handler(Looper.getMainLooper()).post(() -> {
+            mFiles = new ArrayList<>(firstPage);
+            mFilesAll = new ArrayList<>(firstPage);
+            notifyDataSetChanged();
+            localFileListFragmentInterface.setLoading(false);
         });
     }
 
-    private void loadRemainingFolders(File directory) {
-        if (!mLocalFolderPicker) return;
+    private List<File> sortAndFilterHiddenEntries(List<File> nextPage) {
+        boolean showHiddenFiles = preferences.isShowHiddenFilesEnabled();
+        FileSortOrder sortOrder = preferences.getSortOrderByType(FileSortOrder.Type.localFileListView);
+
+        if (!showHiddenFiles) {
+            nextPage = filterHiddenFiles(nextPage);
+        }
 
+        return sortOrder.sortLocalFiles(nextPage);
+    }
+
+    private void loadRemainingEntries(File directory, boolean fetchFolders) {
         while (true) {
-            List<File> nextPage = FileHelper.INSTANCE.fetchFolders(directory, currentOffset, PAGE_SIZE);
-            if (nextPage.isEmpty()) break;
+            List<File> nextPage = FileHelper.INSTANCE.listDirectoryEntries(directory, currentOffset, PAGE_SIZE, fetchFolders);
+            if (nextPage.isEmpty()) {
+                break;
+            }
 
-            currentOffset += nextPage.size();
+            nextPage = sortAndFilterHiddenEntries(nextPage);
 
-            new Handler(Looper.getMainLooper()).post(() -> {
-                int positionStart = mFiles.size();
-                mFiles.addAll(nextPage);
-                mFilesAll.addAll(nextPage);
-                Log_OC.d(TAG, "loadRemainingFolders, next page loaded. Item size: " + mFilesAll.size());
-                notifyItemRangeInserted(positionStart, nextPage.size());
-            });
+            currentOffset += PAGE_SIZE;
+            notifyItemRange(nextPage);
         }
     }
 
-    private void loadRemainingFiles(File directory) {
-        if (mLocalFolderPicker) return;
+    private void notifyItemRange(List<File> updatedList) {
+        new Handler(Looper.getMainLooper()).post(() -> {
+            int from = mFiles.size();
+            int to = updatedList.size();
 
-        boolean showHiddenFiles = preferences.isShowHiddenFilesEnabled();
-        FileSortOrder sortOrder = preferences.getSortOrderByType(FileSortOrder.Type.localFileListView);
-
-        while (true) {
-            List<File> nextPage = FileHelper.INSTANCE.fetchFiles(directory, currentOffset, PAGE_SIZE);
-            if (nextPage.isEmpty()) break;
+            mFiles.addAll(updatedList);
+            mFilesAll.addAll(updatedList);
 
-            if (!showHiddenFiles) nextPage = filterHiddenFiles(nextPage);
-            nextPage = sortOrder.sortLocalFiles(nextPage);
+            Log_OC.d(TAG, "notifyItemRange, item size: " + mFilesAll.size());
 
-            currentOffset += nextPage.size();
-
-            List<File> finalNextPage = nextPage;
-            new Handler(Looper.getMainLooper()).post(() -> {
-                int positionStart = mFiles.size();
-                mFiles.addAll(finalNextPage);
-                mFilesAll.addAll(finalNextPage);
-                Log_OC.d(TAG, "loadRemainingFiles, next page loaded. Item size: " + mFilesAll.size());
-                notifyItemRangeInserted(positionStart, finalNextPage.size());
-            });
-        }
+            notifyItemRangeInserted(from, to);
+        });
     }
 
     @SuppressLint("NotifyDataSetChanged")