Working on adding a friendlier post hoc interface for accessing the files based on the paths selected by the user

Author: maxieds

AndroidFilePickerLightLibrary/build.gradle

@@ -26,13 +26,13 @@ def getGitCommitDate() {
 android {
 
     compileSdkVersion 30
-    buildToolsVersion "30.0.0"
+    buildToolsVersion "30.0.1"
 
     defaultConfig {
         minSdkVersion 29
         targetSdkVersion 30
-        versionCode 11
-        versionName "1.1.0"
+        versionCode 12
+        versionName "1.1.1"
     }
 
     compileOptions {

AndroidFilePickerLightLibrary/src/main/AndroidManifest.xml

@@ -71,7 +71,6 @@
             android:permission="android.permission.MANAGE_DOCUMENTS"
             android:initOrder="100"
             >
-            <!--"com.maxieds.androidfilepickerlightlibrary.FileChooserActivity"-->
 
             <intent-filter>
                 <action android:name="android.content.action.DOCUMENTS_PROVIDER" />

AndroidFilePickerLightLibrary/src/main/java/com/maxieds/androidfilepickerlightlibrary/BasicFileProvider.java

@@ -145,7 +145,7 @@ private boolean setLegacyBaseFolderByName(String namedSubFolder) {
         return true;
     }
 
-    public void selectBaseDirectoryByType(FileChooserBuilder.BaseFolderPathType baseFolderType) {
+    public boolean selectBaseDirectoryByType(FileChooserBuilder.BaseFolderPathType baseFolderType) {
         Context appCtx = FileChooserActivity.getInstance();
         switch(baseFolderType) {
             case BASE_PATH_TYPE_FILES_DIR:
@@ -189,8 +189,9 @@ public void selectBaseDirectoryByType(FileChooserBuilder.BaseFolderPathType base
             case BASE_PATH_TYPE_MEDIA_STORE:
             case BASE_PATH_EXTERNAL_PROVIDER:
             default:
-                return;
+                break;
         }
+        return baseDirPath != null;
     }
 
     public String getCWD() {
@@ -400,6 +401,7 @@ public AssetFileDescriptor openDocumentThumbnail(String documentId, Point sizeHi
         if(extDocsProviderStaticInst != null) {
             return extDocsProviderStaticInst.openDocumentThumbnail(documentId, sizeHint, signal);
         }
+        // The document needs to have the flag: FLAG_SUPPORTS_THUMBNAIL ???
 
         final File file = getFileForDocId(documentId);
         final ParcelFileDescriptor pfd =
@@ -668,17 +670,21 @@ private File getFileForDocId(String docId) throws FileNotFoundException {
         } else {
             final String path = docId.substring(splitIndex + 1);
             target = new File(target, path);
-            //Log.i(LOGTAG, "DOCID effective path -> " + target.getAbsolutePath());
             if (!target.exists()) {
                 throw new FileNotFoundException("Missing file for " + docId + " at " + target);
             }
             return target;
         }
     }
 
+    private long getDocumentSize(String docId) throws FileNotFoundException {
+        File docFileRef = getFileForDocId(docId);
+        return docFileRef.length();
+    }
+
     public static final boolean CURSOR_TYPE_IS_ROOT = true;
 
-    public static String getDocumentIdForCursorType(MatrixCursor mcResult, boolean cursorType) {
+    private static String getDocumentIdForCursorType(MatrixCursor mcResult, boolean cursorType) {
         if(mcResult.getCount() == 0) {
             return null;
         }
@@ -766,18 +772,22 @@ public String[] getPropertiesOfCurrentRow(MatrixCursor mcResult, boolean cursorT
 
     private static final int BYTE_BUFFER_SIZE = 128;
 
-    public StringBuilder readFileContentsAsString(final String documentId) {
+    public StringBuilder readFileContentsAsString(final String documentId, int offset, int maxBytes) {
+        if(offset < 0 || maxBytes <= 0) {
+            return null;
+        }
         try {
             ParcelFileDescriptor docDesc = openDocument(documentId, "r+", null);
             FileDescriptor fd = docDesc.getFileDescriptor();
             FileInputStream inputStream = new FileInputStream(fd);
             StringBuilder sbuilder = new StringBuilder();
             byte[] byteBuf = new byte[BYTE_BUFFER_SIZE];
-            int bytesRead = inputStream.read(byteBuf, 0, BYTE_BUFFER_SIZE);
+            int bytesRead = inputStream.read(byteBuf, offset, Math.min(maxBytes, BYTE_BUFFER_SIZE));
             while(bytesRead > 0) {
+                maxBytes -= bytesRead;
                 byte[] bytesReadBuf = Arrays.copyOf(byteBuf, bytesRead);
                 sbuilder.append(new String(bytesReadBuf));
-                bytesRead = inputStream.read(byteBuf, 0, BYTE_BUFFER_SIZE);
+                bytesRead = inputStream.read(byteBuf, 0, Math.min(maxBytes, BYTE_BUFFER_SIZE));
             }
             inputStream.close();
             docDesc.close();
@@ -791,15 +801,19 @@ public StringBuilder readFileContentsAsString(final String documentId) {
         }
     }
 
-    public byte[] readFileContentsAsBytesArray(final String documentId) {
+    public byte[] readFileContentsAsByteArray(final String documentId, int offset, int maxBytes) {
+        if(offset < 0 || maxBytes <= 0) {
+            return null;
+        }
         try {
             ParcelFileDescriptor docDesc = openDocument(documentId, "r+", null);
             FileDescriptor fd = docDesc.getFileDescriptor();
             FileInputStream inputStream = new FileInputStream(fd);
             int actualSize = 0, bufCapacity = BYTE_BUFFER_SIZE;
             byte[] returnBuf = new byte[BYTE_BUFFER_SIZE], byteBuf = new byte[BYTE_BUFFER_SIZE];
-            int bytesRead = inputStream.read(byteBuf, 0, BYTE_BUFFER_SIZE);
+            int bytesRead = inputStream.read(byteBuf, offset, Math.min(maxBytes, BYTE_BUFFER_SIZE));
             while(bytesRead > 0) {
+                maxBytes -= bytesRead;
                 byte[] bytesReadBuf = Arrays.copyOf(byteBuf, bytesRead);
                 System.arraycopy(returnBuf, actualSize, bytesReadBuf, 0, bytesRead);
                 actualSize += bytesRead;
@@ -809,7 +823,7 @@ public byte[] readFileContentsAsBytesArray(final String documentId) {
                     System.arraycopy(nextReturnBuf, 0, returnBuf, 0, actualSize);
                     returnBuf = nextReturnBuf;
                 }
-                bytesRead = inputStream.read(byteBuf, 0, BYTE_BUFFER_SIZE);
+                bytesRead = inputStream.read(byteBuf, 0, Math.min(maxBytes, BYTE_BUFFER_SIZE));
             }
             inputStream.close();
             docDesc.close();
@@ -823,4 +837,108 @@ public byte[] readFileContentsAsBytesArray(final String documentId) {
         }
     }
 
+    /* More robust DocumentsProvider functionality:
+     * -> Support document creation: https://developer.android.com/guide/topics/providers/create-document-provider#creating
+     * -> Support document management features: (delete, rename, copy, move, remove)
+     *    https://developer.android.com/guide/topics/providers/create-document-provider#browsing
+     */
+
+    class DocumentPointer {
+
+        private BasicFileProvider fpInst;
+        private boolean isValid;
+        private FileChooserBuilder.BaseFolderPathType baseFolderType;
+        private String relativeFolderPathOffset;
+        private String absFolderPathOffset;
+        private String filePath;            // Should be trimmed relative to the initial base folders
+        private String documentId;
+        private Cursor documentCursorEntry; // Of size one
+
+        private void initializeDefaults() {
+            fpInst = BasicFileProvider.getInstance();
+            if(fpInst == null) {
+                throw new FileChooserException.BasicFileProviderException();
+            }
+            isValid = false;
+            baseFolderType = null;
+            relativeFolderPathOffset = null;
+            absFolderPathOffset = null;
+            filePath = null;
+            documentId = null;
+            documentCursorEntry = null;
+        }
+
+        DocumentPointer(FileChooserBuilder.BaseFolderPathType baseFolderType) {
+            initializeDefaults();
+            fpInst.resetBaseDirectory();
+            isValid = fpInst.selectBaseDirectoryByType(baseFolderType);
+            this.baseFolderType = baseFolderType;
+        }
+
+        DocumentPointer(FileChooserBuilder.BaseFolderPathType baseFolderType, String relativeOffsetPath) {
+            initializeDefaults();
+            fpInst.resetBaseDirectory();
+            isValid = fpInst.selectBaseDirectoryByType(baseFolderType);
+            isValid = isValid && fpInst.enterNextSubfolder(relativeOffsetPath);
+            this.baseFolderType = baseFolderType;
+            this.relativeFolderPathOffset = relativeOffsetPath;
+        }
+
+        DocumentPointer(String absInitFolderPath) {
+            initializeDefaults();
+            fpInst.resetBaseDirectory();
+            isValid = fpInst.enterNextSubfolder(absInitFolderPath);
+            this.absFolderPathOffset = absInitFolderPath;
+        }
+
+        public boolean isValid() { return isValid; }
+
+        public boolean locateDocument(String documentPath) throws FileNotFoundException {
+            if(!isValid()) {
+                return false;
+            }
+            this.filePath = documentPath.replaceFirst(fpInst.getCWD(), "");
+            File docFile = new File(fpInst.getCWD(), filePath);
+            documentId = fpInst.getDocIdForFile(docFile);
+            return true;
+        }
+
+        public boolean deleteDocument() throws FileNotFoundException {
+            if(!isValid() || documentId == null) {
+                return false;
+            }
+            fpInst.deleteDocument(documentId);
+            return true;
+        }
+
+        public String getDocumentType() throws FileNotFoundException {
+            if(!isValid() || documentId == null) {
+                return null;
+            }
+            return fpInst.getDocumentType(documentId);
+        }
+
+        public long getDocumentSize() throws FileNotFoundException {
+            if(!isValid() || documentId == null) {
+                return 0;
+            }
+            return fpInst.getDocumentSize(documentId);
+        }
+
+        public StringBuilder readFileContentsAsString(int offset, int maxBytes) {
+            if(!isValid() || documentId == null) {
+                return null;
+            }
+            return fpInst.readFileContentsAsString(documentId, offset, maxBytes);
+        }
+
+        public byte[] readFileContentsAsByteArray(int offset, int maxBytes) {
+            if(!isValid() || documentId == null) {
+                return null;
+            }
+            return fpInst.readFileContentsAsByteArray(documentId, offset, maxBytes);
+        }
+
+    }
+
 }

AndroidFilePickerLightLibrary/src/main/java/com/maxieds/androidfilepickerlightlibrary/FileChooserException.java

@@ -341,6 +341,22 @@ public InvalidActivityContextException() {
 
     }
 
+    public static class BasicFileProviderException extends AndroidFilePickerLightException {
+
+        private static int UNIQUE_ERROR_CODE = claimNextUniqueErrorCode();
+
+        protected static BasicFileProviderException getNewInstance() {
+            return new BasicFileProviderException();
+        }
+
+        public BasicFileProviderException() {
+            configureExceptionParams(UNIQUE_ERROR_CODE,
+                    "The BasicFileProvider is not initialized or has reached an illegal state",
+                    true, DEFAULT_DATA_ITEMS_TYPE, null);
+        }
+
+    }
+
     public static class UnsupportedTypeException extends AndroidFilePickerLightException {
 
         private static int UNIQUE_ERROR_CODE = claimNextUniqueErrorCode();

WorkingItems.md

@@ -1,6 +1,25 @@
 # TODO: A working tabulation of items that still need to get fixed for the next release of the library (TBD)
 
 * Ability for users to create / specify icon types for custom file types (see ``FileChooserBuilder.DefaultFileTypes`` enum).
+* Moving forward (especially with the restrictive upcoming Android 11 permissions settings), are going to need a way to
+  translate an obtained chosen path, and then read from it without having to tag the returned results with
+  FileProvider docIds that the user doesn't need to know about. Create a handy utils interface for this ???
+
+* A working question of mine is why we need all of this abstraction just to access files on the local disks?
+  I get that more abstract file types (e.g., from over the network) or interfaces can be desirable in complicated setups,
+  but why when the stock Java ``File`` interfaces work already are we having to go through this convoluted way of
+  confusing the user's access by standard file paths as IDs? The inner implementation suggested by Google just
+  transforms the ``File`` back and forth from that object type to the document ID, or ``root:pathData`` format.
+  1. NOTE: It is not always possible to set Posix file permissions on external storage in recent Android APIs.
+  2. The system also does not like to always honor returning genuine properties back to the user about the document,
+     even if it just corresponds to a (correct) path on disk obtained legitimately by the working ``DocumentsProvider` instance.
+  3. In this case (just working off of the default file system on your Droid device), is the difference that the system
+     gives some magic credence to interfaces derived from ``DocumentsProvider``? E.g., so that it will allow an
+     instance of that interface to magically grok FS data and properties, but deny the same access to users that are only
+     working within stock Java ``File`` I/O contexts?
+  4. If (3) is true, I repeat my confusion and distaste for this scheme and added bits of convolution rather than
+     useful abstraction to a generalized more powerful interface.
+     I need more information, but the documentation for this is still very missing in a lot of places.
 
 ## Documentation and approach to handling files internally within the picker library