Make ResolverCompat an object for quick method access.

ItzNotABug · ItzNotABug · commit 489489d6f949 · 2023-05-03T20:47:41.000+05:30
diff --git a/dfc/src/main/java/com/lazygeniouz/dfc/controller/DocumentController.kt b/dfc/src/main/java/com/lazygeniouz/dfc/controller/DocumentController.kt
@@ -7,7 +7,6 @@ import android.content.pm.PackageManager
 import android.net.Uri
 import android.provider.DocumentsContract
 import android.provider.DocumentsContract.Document.MIME_TYPE_DIR
-import android.provider.DocumentsContract.isDocumentUri
 import com.lazygeniouz.dfc.file.DocumentFileCompat
 import com.lazygeniouz.dfc.resolver.ResolverCompat
 
@@ -26,32 +25,33 @@ internal class DocumentController(
     // DocumentsContract API level 24.
     private val flagVirtualDocument = 1 shl 9
 
-    // File Handler to call delegate functions.
-    private val resolverCompat by lazy { ResolverCompat(context, fileCompat.uri) }
+    // Uri of the given [DocumentFileCompat]
+    private val fileUri get() = fileCompat.uri
 
     /**
      * This will return a list of [DocumentFileCompat] with all the defined fields.
      */
     internal fun listFiles(): List<DocumentFileCompat> {
         return if (!isDirectory())
             throw UnsupportedOperationException("Selected document is not a Directory.")
-        else resolverCompat.queryAndMakeDocumentList()
+        else ResolverCompat.listFiles(context, fileUri)
     }
 
     /**
      * This will return the children count in the directory.
+     *
      * More optimised than using [List.size] via [listFiles].
      */
     internal fun count(): Int {
         return if (!isDirectory()) 0
-        else resolverCompat.count()
+        else ResolverCompat.count(context, fileUri)
     }
 
     /**
      * Returns True if the Document Folder / File exists, False otherwise.
      */
     internal fun exists(): Boolean {
-        return resolverCompat.exists()
+        return ResolverCompat.exists(context, fileUri)
     }
 
     /**
@@ -61,7 +61,7 @@ internal class DocumentController(
      * and doesn't have byte representation in the MIME type specified as COLUMN_MIME_TYPE.
      */
     internal fun isVirtual(): Boolean {
-        if (!isDocumentUri(context, fileCompat.uri)) return false
+        if (!DocumentsContract.isDocumentUri(context, fileUri)) return false
 
         return fileCompat.documentFlags and flagVirtualDocument != 0
     }
@@ -85,7 +85,7 @@ internal class DocumentController(
      */
     internal fun canRead(): Boolean {
         if (context.checkCallingOrSelfUriPermission(
-                fileCompat.uri, Intent.FLAG_GRANT_READ_URI_PERMISSION
+                fileUri, Intent.FLAG_GRANT_READ_URI_PERMISSION
             ) != PackageManager.PERMISSION_GRANTED
         ) return false
 
@@ -99,7 +99,7 @@ internal class DocumentController(
      */
     internal fun canWrite(): Boolean {
         if (context.checkCallingOrSelfUriPermission(
-                fileCompat.uri, Intent.FLAG_GRANT_WRITE_URI_PERMISSION
+                fileUri, Intent.FLAG_GRANT_WRITE_URI_PERMISSION
             ) != PackageManager.PERMISSION_GRANTED
         ) return false
 
@@ -111,6 +111,7 @@ internal class DocumentController(
         if (MIME_TYPE_DIR == fileCompat.documentMimeType &&
             fileCompat.documentFlags and DocumentsContract.Document.FLAG_DIR_SUPPORTS_CREATE != 0
         ) return true
+
         else if (fileCompat.documentMimeType.isNotEmpty() &&
             fileCompat.documentFlags and DocumentsContract.Document.FLAG_SUPPORTS_WRITE != 0
         ) return true
@@ -127,22 +128,22 @@ internal class DocumentController(
      * @return A Uri if file was created successfully, **null** otherwise.
      */
     internal fun createFile(mimeType: String, name: String): Uri? {
-        return resolverCompat.createFile(mimeType, name)
+        return ResolverCompat.createFile(context, fileUri, mimeType, name)
     }
 
     /**
      * Rename a Document File / Folder.
      *
      * Returns True if the rename was successful, False otherwise.
      */
-    internal fun renameTo(name: String): Boolean {
-        return resolverCompat.renameTo(name)
+    internal fun renameTo(name: String): Uri? {
+        return ResolverCompat.renameTo(context, fileUri, name)
     }
 
     /**
      * Delete a document.
      */
     internal fun delete(): Boolean {
-        return resolverCompat.deleteDocument()
+        return ResolverCompat.deleteDocument(context, fileUri)
     }
 }
diff --git a/dfc/src/main/java/com/lazygeniouz/dfc/resolver/ResolverCompat.kt b/dfc/src/main/java/com/lazygeniouz/dfc/resolver/ResolverCompat.kt
@@ -6,45 +6,35 @@ import android.database.Cursor
 import android.net.Uri
 import android.provider.DocumentsContract
 import com.lazygeniouz.dfc.file.DocumentFileCompat
-import com.lazygeniouz.dfc.file.internals.SingleDocumentFileCompat
 import com.lazygeniouz.dfc.file.internals.TreeDocumentFileCompat
-import com.lazygeniouz.dfc.logger.ErrorLogger.logError
+import com.lazygeniouz.dfc.logger.ErrorLogger
 
 /**
- * This class calls relevant queries on the [ContentResolver]
- *
- * @param context Required to access the underlying **ContentResolver**
+ * Helper class for calling relevant methods on [DocumentsContract] & queries via [ContentResolver].
  */
-internal class ResolverCompat(
-    private val context: Context,
-    private val uri: Uri,
-) {
+internal object ResolverCompat {
 
-    // Projections
-    private val _idProjection = DocumentsContract.Document.COLUMN_DOCUMENT_ID
-    private val documentIdProjection = arrayOf(_idProjection)
-    private val fullProjection = arrayOf(
-        _idProjection,
+    private val iconProjection = arrayOf(DocumentsContract.Document.COLUMN_ICON)
+    private val idProjection = arrayOf(DocumentsContract.Document.COLUMN_DOCUMENT_ID)
+    val fullProjection = arrayOf(
+        DocumentsContract.Document.COLUMN_DOCUMENT_ID,
         DocumentsContract.Document.COLUMN_DISPLAY_NAME,
         DocumentsContract.Document.COLUMN_SIZE,
         DocumentsContract.Document.COLUMN_LAST_MODIFIED,
         DocumentsContract.Document.COLUMN_MIME_TYPE,
         DocumentsContract.Document.COLUMN_FLAGS
     )
 
-    // The star of the show!
-    private val contentResolver by lazy { context.contentResolver }
-
     /**
      * Delete the file.
      *
      * @return True if deletion succeeded, False otherwise
      */
-    internal fun deleteDocument(): Boolean {
+    internal fun deleteDocument(context: Context, uri: Uri): Boolean {
         return try {
-            DocumentsContract.deleteDocument(contentResolver, uri)
+            DocumentsContract.deleteDocument(context.contentResolver, uri)
         } catch (exception: Exception) {
-            logError("Exception while deleting document", exception)
+            ErrorLogger.logError("Exception while deleting document", exception)
             false
         }
     }
@@ -54,12 +44,12 @@ internal class ResolverCompat(
      *
      * Returns True if the rename was successful, False otherwise.
      */
-    internal fun renameTo(name: String): Boolean {
+    internal fun renameTo(context: Context, uri: Uri, name: String): Uri? {
         return try {
-            (DocumentsContract.renameDocument(contentResolver, uri, name) != null)
+            return DocumentsContract.renameDocument(context.contentResolver, uri, name)
         } catch (exception: Exception) {
-            logError("Exception while renaming document", exception)
-            false
+            ErrorLogger.logError("Exception while renaming document", exception)
+            null
         }
     }
 
@@ -71,22 +61,15 @@ internal class ResolverCompat(
      *
      * @return A Uri if file was created successfully, **null** if any exception was caught.
      */
-    internal fun createFile(mimeType: String, name: String): Uri? {
+    internal fun createFile(context: Context, uri: Uri, mimeType: String, name: String): Uri? {
         return try {
-            DocumentsContract.createDocument(contentResolver, uri, mimeType, name)
+            DocumentsContract.createDocument(context.contentResolver, uri, mimeType, name)
         } catch (exception: Exception) {
-            logError("Exception while creating a document", exception)
+            ErrorLogger.logError("Exception while creating a document", exception)
             null
         }
     }
 
-    /**
-     * Queries the ContentResolver & builds a list of [DocumentFileCompat] with all the required fields.
-     */
-    internal fun queryAndMakeDocumentList(): List<DocumentFileCompat> {
-        return runTreeQuery()
-    }
-
     /**
      * Returns the children count without creating [DocumentFileCompat] objects.
      *
@@ -96,109 +79,63 @@ internal class ResolverCompat(
      * - Min: 0.275, Max: 0.613 (listFiles().size)
      * - Avg: 0.444, Diff: 0.338, % Change: 55.14
      */
-    internal fun count(): Int {
-        val childrenUri = buildChildDocumentsUriUsingTree()
-        val projection = arrayOf(DocumentsContract.Document.COLUMN_ICON)
-        getCursor(childrenUri, projection)?.use { cursor -> return cursor.count }
+    internal fun count(context: Context, uri: Uri): Int {
+        val childrenUri = createChildrenUri(uri)
+        getCursor(context, childrenUri, iconProjection)?.use { cursor -> return cursor.count }
         return 0
     }
 
-    // Returns True if the Uri is a Tree Uri, False otherwise.
-    private fun isTreeUri(): Boolean {
-        val paths = uri.pathSegments
-        return paths.size >= 2 && "tree" == paths[0]
-    }
-
-    // Create a child document uri from the tree uri.
-    private fun buildChildDocumentsUriUsingTree(): Uri {
-        return DocumentsContract.buildChildDocumentsUriUsingTree(
-            getTreeUri(), DocumentsContract.getDocumentId(getTreeUri())
-        )
-    }
-
-    // Build relevant Tree Uri.
-    private fun getTreeUri(): Uri {
-        val isDocument = DocumentsContract.isDocumentUri(context, uri)
-        return DocumentsContract.buildDocumentUriUsingTree(
-            uri, if (isDocument) DocumentsContract.getDocumentId(uri)
-            else DocumentsContract.getTreeDocumentId(uri)
-        )
-    }
-
-    /**
-     * Builds a complete [DocumentFileCompat] object
-     * when a first call to building a [TreeDocumentFileCompat] or a [SingleDocumentFileCompat] is made.
-     *
-     * @param isTree Returns a [TreeDocumentFileCompat] if True, [SingleDocumentFileCompat] otherwise.
-     *
-     * @throws UnsupportedOperationException If `isTree` is True but the Uri is not Tree based.
-     */
-    internal fun getInitialFileCompat(isTree: Boolean): DocumentFileCompat? {
-        if (isTree && !isTreeUri())
-            throw UnsupportedOperationException("Document Uri is not a Tree uri.")
-        return runInitialQuery(isTree)
-    }
-
     /**
      * Returns True if the Document Folder / File exists, False otherwise.
      */
-    internal fun exists(): Boolean {
-        getCursor(uri, documentIdProjection)?.use { cursor -> return (cursor.count > 0) }
+    internal fun exists(context: Context, uri: Uri): Boolean {
+        getCursor(context, uri, idProjection)?.use { cursor -> return (cursor.count > 0) }
         return false
     }
 
-    // Get a Cursor to query the given Uri against provided projection
-    private fun getCursor(uri: Uri, projection: Array<String>): Cursor? {
-        return contentResolver.query(uri, projection, null, null, null)
-    }
-
     /**
-     * Runs query to build initial [TreeDocumentFileCompat] or a [SingleDocumentFileCompat].
-     *
-     * @param isTree Returns a [TreeDocumentFileCompat] if True, [SingleDocumentFileCompat] otherwise.
+     * Queries the ContentResolver & builds a list of [DocumentFileCompat] with all the required fields.
      */
-    private fun runInitialQuery(isTree: Boolean): DocumentFileCompat? {
-        val uriToQuery = if (!isTree) uri
-        else DocumentsContract.buildDocumentUriUsingTree(
-            getTreeUri(), DocumentsContract.getDocumentId(getTreeUri())
-        )
-
-        var document: DocumentFileCompat? = null
+    internal fun listFiles(context: Context, uri: Uri): List<DocumentFileCompat> {
+        val childrenUri = createChildrenUri(uri)
+        // empty list
+        val listOfDocuments = arrayListOf<DocumentFileCompat>()
 
-        getCursor(uriToQuery, fullProjection)?.use { cursor ->
-            if (cursor.moveToFirst()) {
+        getCursor(context, childrenUri, fullProjection)?.use { cursor ->
+            while (cursor.moveToNext()) {
                 val documentId: String = cursor.getString(0)
-                val documentUri: Uri = if (!isTree) uri
-                else DocumentsContract.buildDocumentUriUsingTree(getTreeUri(), documentId)
-
-                // Same logic but moved to separate classes for easy readability & understanding.
-                document = if (!isTree) SingleDocumentFileCompat.make(context, cursor, documentUri)
-                else TreeDocumentFileCompat.make(context, cursor, documentUri)
+                val documentUri = DocumentsContract.buildDocumentUriUsingTree(uri, documentId)
+
+                val documentName: String = cursor.getString(1)
+                val documentSize: Long = cursor.getLong(2)
+                val documentLastModified: Long = cursor.getLong(3)
+                val documentMimeType: String = cursor.getString(4)
+                val documentFlags: Int = cursor.getLong(5).toInt()
+
+                TreeDocumentFileCompat(
+                    context, documentUri, documentName,
+                    documentSize, documentLastModified,
+                    documentMimeType, documentFlags
+                ).also { childFile -> listOfDocuments.add(childFile) }
             }
         }
 
-        return document
+        return listOfDocuments
     }
 
     /**
-     * Run query on the passed uri with full projections.
-     *
-     * @return A list of [DocumentFileCompat] with all fields.
+     * Get [Cursor] from [ContentResolver.query] with given [projection] on a given [uri].
      */
-    private fun runTreeQuery(): List<DocumentFileCompat> {
-        val childrenUri = buildChildDocumentsUriUsingTree()
-
-        // empty list
-        val listOfDocuments = arrayListOf<DocumentFileCompat>()
-
-        getCursor(childrenUri, fullProjection)?.use { cursor ->
-            while (cursor.moveToNext()) {
-                val docId: String = cursor.getString(0)
-                val docUri = DocumentsContract.buildDocumentUriUsingTree(getTreeUri(), docId)
-                listOfDocuments.add(TreeDocumentFileCompat.make(context, cursor, docUri))
-            }
-        }
+    fun getCursor(context: Context, uri: Uri, projection: Array<String>): Cursor? {
+        return context.contentResolver.query(
+            uri, projection, null, null, null
+        )
+    }
 
-        return listOfDocuments
+    // Make children uri for query.
+    private fun createChildrenUri(uri: Uri): Uri {
+        return DocumentsContract.buildChildDocumentsUriUsingTree(
+            uri, DocumentsContract.getDocumentId(uri)
+        )
     }
 }
