Android: Add facilities to handle more content URIs operations

Use DocumentFile and DocumentsContract to support more operations
on content URIs, such as:
* listing files and subdirectories with usable content uris
* mkdir, rmdir
* creating non-existing files under a tree uri
* remove

And since dealing with content URIs require some level of user
interation, manual tests were added to cover what's been implemented.

Note: parts of the code were from from BogDan Vatra <bogdan@kdab.com>.

Task-number: QTBUG-98974
Task-number: QTBUG-104776
Change-Id: I3d64958ef26d0155210905b65daae2efa3db31c1
Reviewed-by: Ville Voutilainen <ville.voutilainen@qt.io>
(cherry picked from commit e5d591a0d09032d1870e47d1bf59c9069ea0a943)

6 files changed, 923 insertions, 261 deletions

diff --git a/src/android/jar/src/org/qtproject/qt5/android/QtNative.java b/src/android/jar/src/org/qtproject/qt5/android/QtNative.java
index 6cd091aab6..41ba50e964 100644
--- a/src/android/jar/src/org/qtproject/qt5/android/QtNative.java
+++ b/src/android/jar/src/org/qtproject/qt5/android/QtNative.java
@@ -45,8 +45,6 @@ import java.io.FileNotFoundException;
 import java.util.ArrayList;
 import java.util.Objects;
 import java.util.concurrent.Semaphore;
-import java.io.IOException;
-import java.util.HashMap;
 
 import android.app.Activity;
 import android.app.Service;
@@ -115,9 +113,6 @@ public class QtNative
     private static Boolean m_tabletEventSupported = null;
     private static boolean m_usePrimaryClip = false;
     public static QtThread m_qtThread = new QtThread();
-    private static HashMap<String, Uri> m_cachedUris = new HashMap<String, Uri>();
-    private static ArrayList<String> m_knownDirs = new ArrayList<String>();
-    private static final String NoPermissionErrorMessage = "No permissions to open Uri";
 
     private static final Runnable runPendingCppRunnablesRunnable = new Runnable() {
         @Override
@@ -244,190 +239,6 @@ public class QtNative
         }
     }
 
-    public static int openFdForContentUrl(Context context, String contentUrl, String openMode)
-    {
-        Uri uri = m_cachedUris.get(contentUrl);
-        if (uri == null)
-            uri = getUriWithValidPermission(context, contentUrl, openMode);
-        int error = -1;
-
-        if (uri == null) {
-            Log.e(QtTAG, "openFdForContentUrl(): " + NoPermissionErrorMessage);
-            return error;
-        }
-
-        try {
-            ContentResolver resolver = context.getContentResolver();
-            ParcelFileDescriptor fdDesc = resolver.openFileDescriptor(uri, openMode);
-            return fdDesc.detachFd();
-        } catch (FileNotFoundException e) {
-            e.printStackTrace();
-        } catch (IllegalArgumentException e) {
-            Log.e(QtTAG, "openFdForContentUrl(): Invalid Uri");
-            e.printStackTrace();
-        } catch (SecurityException e) {
-            Log.e(QtTAG, NoPermissionErrorMessage);
-        }
-        return error;
-    }
-
-    public static long getSize(Context context, String contentUrl)
-    {
-        long size = -1;
-        Uri uri = m_cachedUris.get(contentUrl);
-        if (uri == null)
-            uri = getUriWithValidPermission(context, contentUrl, "r");
-
-        if (uri == null) {
-            Log.e(QtTAG, NoPermissionErrorMessage);
-            return size;
-        } else if (!m_cachedUris.containsKey(contentUrl)) {
-            m_cachedUris.put(contentUrl, uri);
-        }
-
-        try {
-            ContentResolver resolver = context.getContentResolver();
-            Cursor cur = resolver.query(uri, new String[] { DocumentsContract.Document.COLUMN_SIZE }, null, null, null);
-            if (cur != null) {
-                if (cur.moveToFirst())
-                    size = cur.getLong(0);
-                cur.close();
-            }
-            return size;
-        } catch (IllegalArgumentException e) {
-            Log.e(QtTAG, "getSize(): Invalid Uri");
-            e.printStackTrace();
-        }  catch (UnsupportedOperationException e) {
-            Log.e(QtTAG, "getSize(): Unsupported operation for given Uri");
-            e.printStackTrace();
-        } catch (SecurityException e) {
-            Log.e(QtTAG, NoPermissionErrorMessage);
-        }
-        return size;
-    }
-
-    public static boolean checkFileExists(Context context, String contentUrl)
-    {
-        boolean exists = false;
-        Uri uri = m_cachedUris.get(contentUrl);
-        if (uri == null)
-            uri = getUriWithValidPermission(context, contentUrl, "r");
-        if (uri == null) {
-            Log.e(QtTAG, NoPermissionErrorMessage);
-            return exists;
-        } else {
-            if (!m_cachedUris.containsKey(contentUrl))
-                m_cachedUris.put(contentUrl, uri);
-        }
-
-        try {
-            ContentResolver resolver = context.getContentResolver();
-            Cursor cur = resolver.query(uri, null, null, null, null);
-            if (cur != null) {
-                exists = true;
-                cur.close();
-            }
-            return exists;
-        } catch (IllegalArgumentException e) {
-            Log.e(QtTAG, "checkFileExists(): Invalid Uri");
-            e.printStackTrace();
-        } catch (UnsupportedOperationException e) {
-            Log.e(QtTAG, "checkFileExists(): Unsupported operation for given Uri");
-            e.printStackTrace();
-        } catch (SecurityException e) {
-            Log.e(QtTAG, NoPermissionErrorMessage);
-        }
-        return exists;
-    }
-
-    public static boolean checkIfWritable(Context context, String contentUrl)
-    {
-        return getUriWithValidPermission(context, contentUrl, "w") != null;
-    }
-
-    public static boolean checkIfDir(Context context, String contentUrl)
-    {
-        boolean isDir = false;
-        Uri uri = m_cachedUris.get(contentUrl);
-        if (m_knownDirs.contains(contentUrl))
-            return true;
-        if (uri == null) {
-            uri = getUriWithValidPermission(context, contentUrl, "r");
-        }
-        if (uri == null) {
-            Log.e(QtTAG, NoPermissionErrorMessage);
-            return isDir;
-        } else {
-            if (!m_cachedUris.containsKey(contentUrl))
-                m_cachedUris.put(contentUrl, uri);
-        }
-
-        try {
-            final List<String> paths = uri.getPathSegments();
-            // getTreeDocumentId will throw an exception if it is not a directory so check manually
-            if (!paths.get(0).equals("tree"))
-                return false;
-            ContentResolver resolver = context.getContentResolver();
-            Uri docUri = DocumentsContract.buildDocumentUriUsingTree(uri, DocumentsContract.getTreeDocumentId(uri));
-            if (!docUri.toString().startsWith(uri.toString()))
-                return false;
-            Cursor cur = resolver.query(docUri, new String[] { DocumentsContract.Document.COLUMN_MIME_TYPE }, null, null, null);
-            if (cur != null) {
-                if (cur.moveToFirst()) {
-                    final String dirStr = new String(DocumentsContract.Document.MIME_TYPE_DIR);
-                    isDir = cur.getString(0).equals(dirStr);
-                    if (isDir)
-                        m_knownDirs.add(contentUrl);
-                }
-                cur.close();
-            }
-            return isDir;
-        } catch (IllegalArgumentException e) {
-            Log.e(QtTAG, "checkIfDir(): Invalid Uri");
-            e.printStackTrace();
-        } catch (UnsupportedOperationException e) {
-            Log.e(QtTAG, "checkIfDir(): Unsupported operation for given Uri");
-            e.printStackTrace();
-        } catch (SecurityException e) {
-            Log.e(QtTAG, NoPermissionErrorMessage);
-        }
-        return false;
-    }
-    public static String[] listContentsFromTreeUri(Context context, String contentUrl)
-    {
-        Uri treeUri = Uri.parse(contentUrl);
-        final ArrayList<String> results = new ArrayList<String>();
-        if (treeUri == null) {
-            Log.e(QtTAG, "listContentsFromTreeUri(): Invalid uri");
-            return results.toArray(new String[results.size()]);
-        }
-        final ContentResolver resolver = context.getContentResolver();
-        final Uri docUri = DocumentsContract.buildDocumentUriUsingTree(treeUri,
-                DocumentsContract.getTreeDocumentId(treeUri));
-        final Uri childrenUri = DocumentsContract.buildChildDocumentsUriUsingTree(docUri,
-                                DocumentsContract.getDocumentId(docUri));
-        Cursor c = null;
-        final String dirStr = new String(DocumentsContract.Document.MIME_TYPE_DIR);
-        try {
-            c = resolver.query(childrenUri, new String[] {
-                    DocumentsContract.Document.COLUMN_DOCUMENT_ID, DocumentsContract.Document.COLUMN_DISPLAY_NAME, DocumentsContract.Document.COLUMN_MIME_TYPE }, null, null, null);
-            while (c.moveToNext()) {
-                final String fileString = c.getString(1);
-                if (!m_cachedUris.containsKey(contentUrl + "/" + fileString)) {
-                    m_cachedUris.put(contentUrl + "/" + fileString,
-                                     DocumentsContract.buildDocumentUriUsingTree(treeUri, c.getString(0)));
-                }
-                results.add(fileString);
-                if (c.getString(2).equals(dirStr))
-                    m_knownDirs.add(contentUrl + "/" + fileString);
-            }
-            c.close();
-        } catch (Exception e) {
-            Log.w(QtTAG, "Failed query: " + e);
-            return results.toArray(new String[results.size()]);
-        }
-        return results.toArray(new String[results.size()]);
-    }
     // this method loads full path libs
     public static void loadQtLibraries(final ArrayList<String> libraries)
     {
diff --git a/src/plugins/platforms/android/androidcontentfileengine.cpp b/src/plugins/platforms/android/androidcontentfileengine.cpp
index f273d27d28..a1027229ee 100644
--- a/src/plugins/platforms/android/androidcontentfileengine.cpp
+++ b/src/plugins/platforms/android/androidcontentfileengine.cpp
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2019 Volker Krause <vkrause@kde.org>
+** Copyright (C) 2022 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -39,15 +40,51 @@
 
 #include "androidcontentfileengine.h"
 
-#include <private/qjni_p.h>
 #include <private/qjnihelpers_p.h>
 
-#include <QDebug>
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qurl.h>
+#include <QtCore/qdatetime.h>
+#include <QtCore/qmimedatabase.h>
+#include <QtCore/qdebug.h>
 
-AndroidContentFileEngine::AndroidContentFileEngine(const QString &f)
-    : m_file(f)
+class JniExceptionCleaner
 {
-    setFileName(f);
+public:
+    JniExceptionCleaner() { clearException(); };
+    ~JniExceptionCleaner() { clearException(); }
+
+    bool clean() { return clearException(); };
+private:
+    bool clearException()
+    {
+        QJNIEnvironmentPrivate env;
+        if (Q_UNLIKELY(env->ExceptionCheck())) {
+            env->ExceptionDescribe();
+            env->ExceptionClear();
+            return true;
+        }
+        return false;
+    }
+};
+
+static QJNIObjectPrivate &contentResolverInstance()
+{
+    static QJNIObjectPrivate contentResolver;
+    if (!contentResolver.isValid()) {
+        JniExceptionCleaner cleaner;
+        contentResolver = QJNIObjectPrivate(QtAndroidPrivate::context())
+                .callObjectMethod("getContentResolver", "()Landroid/content/ContentResolver;");
+    }
+
+    return contentResolver;
+}
+
+AndroidContentFileEngine::AndroidContentFileEngine(const QString &filename)
+    : m_initialFile(filename),
+      m_documentFile(DocumentFile::parseFromAnyUri(filename))
+{
+    setFileName(filename);
 }
 
 bool AndroidContentFileEngine::open(QIODevice::OpenMode openMode)
@@ -58,6 +95,27 @@ bool AndroidContentFileEngine::open(QIODevice::OpenMode openMode)
     }
     if (openMode & QFileDevice::WriteOnly) {
         openModeStr += QLatin1Char('w');
+        if (!m_documentFile->exists()) {
+            if (QUrl(m_initialFile).path().startsWith(QLatin1String("/tree/"))) {
+                const int lastSeparatorIndex = m_initialFile.lastIndexOf(QLatin1Char('/'));
+                const QString fileName = m_initialFile.mid(lastSeparatorIndex + 1);
+
+                QString mimeType;
+                const auto mimeTypes = QMimeDatabase().mimeTypesForFileName(fileName);
+                if (!mimeTypes.empty())
+                    mimeType = mimeTypes.first().name();
+                else
+                    mimeType = QLatin1String("application/octet-stream");
+
+                if (m_documentFile->parent()) {
+                    auto createdFile = m_documentFile->parent()->createFile(mimeType, fileName);
+                    if (createdFile)
+                        m_documentFile = createdFile;
+                }
+            } else {
+                qWarning() << "open(): non-existent content URI with a document type provided";
+            }
+        }
     }
     if (openMode & QFileDevice::Truncate) {
         openModeStr += QLatin1Char('t');
@@ -65,53 +123,140 @@ bool AndroidContentFileEngine::open(QIODevice::OpenMode openMode)
         openModeStr += QLatin1Char('a');
     }
 
-    const auto fd = QJNIObjectPrivate::callStaticMethod<jint>("org/qtproject/qt5/android/QtNative",
-        "openFdForContentUrl",
-        "(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;)I",
-        QtAndroidPrivate::context(),
-        QJNIObjectPrivate::fromString(fileName(DefaultName)).object(),
-        QJNIObjectPrivate::fromString(openModeStr).object());
+    JniExceptionCleaner cleaner;
+    m_pfd = contentResolverInstance().callObjectMethod("openFileDescriptor",
+                        "(Landroid/net/Uri;Ljava/lang/String;)Landroid/os/ParcelFileDescriptor;",
+                        m_documentFile->uri().object(),
+                        QJNIObjectPrivate::fromString(openModeStr).object());
+
+    if (!m_pfd.isValid())
+        return false;
+
+    const auto fd = m_pfd.callMethod<jint>("getFd", "()I");
 
     if (fd < 0) {
+        closeNativeFileDescriptor();
         return false;
     }
 
-    return QFSFileEngine::open(openMode, fd, QFile::AutoCloseHandle);
+    return QFSFileEngine::open(openMode, fd, QFile::DontCloseHandle);
+}
+
+bool AndroidContentFileEngine::close()
+{
+    closeNativeFileDescriptor();
+    return QFSFileEngine::close();
+}
+
+void AndroidContentFileEngine::closeNativeFileDescriptor()
+{
+    if (m_pfd.isValid()) {
+        JniExceptionCleaner cleaner;
+        m_pfd.callMethod<void>("close", "()V");
+        m_pfd = QJNIObjectPrivate();
+    }
 }
 
 qint64 AndroidContentFileEngine::size() const
 {
-    const jlong size = QJNIObjectPrivate::callStaticMethod<jlong>(
-            "org/qtproject/qt5/android/QtNative", "getSize",
-            "(Landroid/content/Context;Ljava/lang/String;)J", QtAndroidPrivate::context(),
-            QJNIObjectPrivate::fromString(fileName(DefaultName)).object());
-    return (qint64)size;
+    return m_documentFile->length();
+}
+
+bool AndroidContentFileEngine::remove()
+{
+    return m_documentFile->remove();
+}
+
+bool AndroidContentFileEngine::mkdir(const QString &dirName, bool createParentDirectories) const
+{
+    QString tmp = dirName;
+    tmp.remove(m_initialFile);
+
+    QStringList dirParts = tmp.split(QLatin1Char('/'));
+    dirParts.removeAll("");
+
+    if (dirParts.isEmpty())
+        return false;
+
+    auto createdDir = m_documentFile;
+    bool allDirsCreated = true;
+    for (const auto &dir : dirParts) {
+        // Find if the sub-dir already exists and then don't re-create it
+        bool subDirExists = false;
+        for (const DocumentFilePtr &subDir : m_documentFile->listFiles()) {
+            if (dir == subDir->name() && subDir->isDirectory()) {
+                createdDir = subDir;
+                subDirExists = true;
+            }
+        }
+
+        if (!subDirExists) {
+            createdDir = createdDir->createDirectory(dir);
+            if (!createdDir) {
+                allDirsCreated = false;
+                break;
+            }
+        }
+
+        if (!createParentDirectories)
+            break;
+    }
+
+    return allDirsCreated;
+}
+
+bool AndroidContentFileEngine::rmdir(const QString &dirName, bool recurseParentDirectories) const
+{
+    if (recurseParentDirectories)
+        qWarning() << "rmpath(): Unsupported for Content URIs";
+
+    const QString dirFileName = QUrl(dirName).fileName();
+    bool deleted = false;
+    for (const DocumentFilePtr &dir : m_documentFile->listFiles()) {
+        if (dirFileName == dir->name() && dir->isDirectory()) {
+            deleted = dir->remove();
+            break;
+        }
+    }
+
+    return deleted;
+}
+
+QByteArray AndroidContentFileEngine::id() const
+{
+    return m_documentFile->id().toUtf8();
+}
+
+QDateTime AndroidContentFileEngine::fileTime(FileTime time) const
+{
+    switch (time) {
+    case FileTime::ModificationTime:
+        return m_documentFile->lastModified();
+        break;
+    default:
+        break;
+    }
+
+    return QDateTime();
 }
 
 AndroidContentFileEngine::FileFlags AndroidContentFileEngine::fileFlags(FileFlags type) const
 {
-    FileFlags commonFlags(ReadOwnerPerm|ReadUserPerm|ReadGroupPerm|ReadOtherPerm|ExistsFlag);
     FileFlags flags;
-    const bool isDir = QJNIObjectPrivate::callStaticMethod<jboolean>(
-            "org/qtproject/qt5/android/QtNative", "checkIfDir",
-            "(Landroid/content/Context;Ljava/lang/String;)Z", QtAndroidPrivate::context(),
-            QJNIObjectPrivate::fromString(fileName(DefaultName)).object());
-    // If it is a directory then we know it exists so there is no reason to explicitly check
-    const bool exists = isDir ? true : QJNIObjectPrivate::callStaticMethod<jboolean>(
-            "org/qtproject/qt5/android/QtNative", "checkFileExists",
-            "(Landroid/content/Context;Ljava/lang/String;)Z", QtAndroidPrivate::context(),
-            QJNIObjectPrivate::fromString(fileName(DefaultName)).object());
-    if (!exists && !isDir)
+    if (!m_documentFile->exists())
         return flags;
-    if (isDir) {
-        flags = DirectoryType | commonFlags;
+
+    flags = ExistsFlag;
+    if (!m_documentFile->canRead())
+        return flags;
+
+    flags |= ReadOwnerPerm|ReadUserPerm|ReadGroupPerm|ReadOtherPerm;
+
+    if (m_documentFile->isDirectory()) {
+        flags |= DirectoryType;
     } else {
-        flags = FileType | commonFlags;
-        const bool writable = QJNIObjectPrivate::callStaticMethod<jboolean>(
-            "org/qtproject/qt5/android/QtNative", "checkIfWritable",
-            "(Landroid/content/Context;Ljava/lang/String;)Z", QtAndroidPrivate::context(),
-            QJNIObjectPrivate::fromString(fileName(DefaultName)).object());
-        if (writable)
+        flags |= FileType;
+        if (m_documentFile->canWrite())
             flags |= WriteOwnerPerm|WriteUserPerm|WriteGroupPerm|WriteOtherPerm;
     }
     return type & flags;
@@ -126,18 +271,18 @@ QString AndroidContentFileEngine::fileName(FileName f) const
         case DefaultName:
         case AbsoluteName:
         case CanonicalName:
-            return m_file;
+            return m_documentFile->uri().toString();
         case BaseName:
-        {
-            const int pos = m_file.lastIndexOf(QChar(QLatin1Char('/')));
-            return m_file.mid(pos);
-        }
+            return m_documentFile->name();
         default:
-            return QString();
+            break;
     }
+
+    return QString();
 }
 
-QAbstractFileEngine::Iterator *AndroidContentFileEngine::beginEntryList(QDir::Filters filters, const QStringList &filterNames)
+QAbstractFileEngine::Iterator *AndroidContentFileEngine::beginEntryList(QDir::Filters filters,
+                                                                    const QStringList &filterNames)
 {
     return new AndroidContentFileEngineIterator(filters, filterNames);
 }
@@ -179,42 +324,484 @@ QString AndroidContentFileEngineIterator::next()
 
 bool AndroidContentFileEngineIterator::hasNext() const
 {
-    if (m_index == -1) {
-        if (path().isEmpty())
+    if (m_index == -1 && m_files.isEmpty()) {
+        const auto currentPath = path();
+        if (currentPath.isEmpty())
             return false;
-        const bool isDir = QJNIObjectPrivate::callStaticMethod<jboolean>(
-                             "org/qtproject/qt5/android/QtNative", "checkIfDir",
-                             "(Landroid/content/Context;Ljava/lang/String;)Z",
-                             QtAndroidPrivate::context(),
-                             QJNIObjectPrivate::fromString(path()).object());
-        if (isDir) {
-            QJNIObjectPrivate objArray = QJNIObjectPrivate::callStaticObjectMethod("org/qtproject/qt5/android/QtNative",
-                                           "listContentsFromTreeUri",
-                                           "(Landroid/content/Context;Ljava/lang/String;)[Ljava/lang/String;",
-                                           QtAndroidPrivate::context(),
-                                           QJNIObjectPrivate::fromString(path()).object());
-            if (objArray.isValid()) {
-                QJNIEnvironmentPrivate env;
-                const jsize length = env->GetArrayLength(static_cast<jarray>(objArray.object()));
-                for (int i = 0; i != length; ++i) {
-                    m_entries << QJNIObjectPrivate(env->GetObjectArrayElement(
-                                static_cast<jobjectArray>(objArray.object()), i)).toString();
-                }
-            }
-        }
-        m_index = 0;
+
+        const auto iterDoc = DocumentFile::parseFromAnyUri(currentPath);
+        if (iterDoc->isDirectory())
+            for (const auto &doc : iterDoc->listFiles())
+                m_files.append(doc);
     }
-    return m_index < m_entries.size();
+
+    return m_index < (m_files.size() - 1);
 }
 
 QString AndroidContentFileEngineIterator::currentFileName() const
 {
-    if (m_index <= 0 || m_index > m_entries.size())
+    if (m_index < 0 || m_index > m_files.size())
         return QString();
-    return m_entries.at(m_index - 1);
+    // Returns a full path since contstructing a content path from the file name
+    // and a tree URI only will not point to a valid file URI.
+    return m_files.at(m_index)->uri().toString();
 }
 
 QString AndroidContentFileEngineIterator::currentFilePath() const
 {
     return currentFileName();
 }
+
+// Start of Cursor
+
+class Cursor
+{
+public:
+    explicit Cursor(const QJNIObjectPrivate &object)
+        : m_object{object} { }
+
+    ~Cursor()
+    {
+        if (m_object.isValid()) {
+            JniExceptionCleaner cleaner;
+            m_object.callMethod<void>("close");
+        }
+    }
+
+    enum Type {
+        FIELD_TYPE_NULL       = 0x00000000,
+        FIELD_TYPE_INTEGER    = 0x00000001,
+        FIELD_TYPE_FLOAT      = 0x00000002,
+        FIELD_TYPE_STRING     = 0x00000003,
+        FIELD_TYPE_BLOB       = 0x00000004
+    };
+
+    QVariant data(int columnIndex) const
+    {
+        JniExceptionCleaner cleaner;
+        int type = m_object.callMethod<jint>("getType", "(I)I", columnIndex);
+        switch (type) {
+        case FIELD_TYPE_NULL:
+            return {};
+        case FIELD_TYPE_INTEGER:
+            return QVariant::fromValue(m_object.callMethod<jlong>("getLong",  "(I)J", columnIndex));
+        case FIELD_TYPE_FLOAT:
+            return QVariant::fromValue(m_object.callMethod<jdouble>("getDouble",  "(I)D",
+                                                                    columnIndex));
+        case FIELD_TYPE_STRING:
+            return QVariant::fromValue(m_object.callObjectMethod("getString",
+                                                                 "(I)Ljava/lang/String;",
+                                                                 columnIndex).toString());
+        case FIELD_TYPE_BLOB: {
+            auto blob = m_object.callObjectMethod("getBlob",  "(I)[B", columnIndex);
+            QJNIEnvironmentPrivate env;
+            const auto blobArray = static_cast<jbyteArray>(blob.object());
+            const int size = env->GetArrayLength(blobArray);
+            const auto byteArray = env->GetByteArrayElements(blobArray, nullptr);
+            QByteArray data{reinterpret_cast<const char *>(byteArray), size};
+            env->ReleaseByteArrayElements(blobArray, byteArray, 0);
+            return QVariant::fromValue(data);
+        }
+        }
+        return {};
+    }
+
+    static std::unique_ptr<Cursor> queryUri(const QJNIObjectPrivate &uri,
+                                            const QStringList &projection = {},
+                                            const QString &selection = {},
+                                            const QStringList &selectionArgs = {},
+                                            const QString &sortOrder = {})
+    {
+        JniExceptionCleaner cleaner;
+        auto cursor = contentResolverInstance().callObjectMethod("query",
+                        "(Landroid/net/Uri;[Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)Landroid/database/Cursor;",
+                        uri.object(),
+                        projection.isEmpty() ? nullptr : fromStringList(projection).object(),
+                        selection.isEmpty() ? nullptr : QJNIObjectPrivate::fromString(selection).object(),
+                        selectionArgs.isEmpty() ? nullptr : fromStringList(selectionArgs).object(),
+                        sortOrder.isEmpty() ? nullptr : QJNIObjectPrivate::fromString(sortOrder).object());
+        if (!cursor.isValid())
+            return {};
+        return std::make_unique<Cursor>(cursor);
+    }
+
+    static QVariant queryColumn(const QJNIObjectPrivate &uri, const QString &column)
+    {
+        const auto query = queryUri(uri, {column});
+        if (!query)
+            return {};
+
+        if (query->rowCount() != 1 || query->columnCount() != 1)
+            return {};
+        query->moveToFirst();
+        return query->data(0);
+    }
+
+    bool isNull(int columnIndex) const
+    {
+        return m_object.callMethod<jboolean>("isNull", "(I)Z", columnIndex);
+    }
+
+    int columnCount() const { return m_object.callMethod<jint>("getColumnCount"); }
+    int rowCount() const { return m_object.callMethod<jint>("getCount"); }
+    int row() const { return m_object.callMethod<jint>("getPosition"); }
+    bool isFirst() const { return m_object.callMethod<jboolean>("isFirst"); }
+    bool isLast() const { return m_object.callMethod<jboolean>("isLast"); }
+    bool moveToFirst() { return m_object.callMethod<jboolean>("moveToFirst"); }
+    bool moveToLast() { return m_object.callMethod<jboolean>("moveToLast"); }
+    bool moveToNext() { return m_object.callMethod<jboolean>("moveToNext"); }
+
+private:
+    static QJNIObjectPrivate fromStringList(const QStringList &list)
+    {
+        QJNIEnvironmentPrivate env;
+        JniExceptionCleaner cleaner;
+        auto array = env->NewObjectArray(list.size(), env->FindClass("java/lang/String"), nullptr);
+        for (int i = 0; i < list.size(); ++i)
+            env->SetObjectArrayElement(array, i, QJNIObjectPrivate::fromString(list[i]).object());
+        return QJNIObjectPrivate::fromLocalRef(array);
+    }
+
+    QJNIObjectPrivate m_object;
+};
+
+// End of Cursor
+
+// Start of DocumentsContract
+
+/*!
+ *
+ * DocumentsContract Api.
+ * Check https://developer.android.com/reference/android/provider/DocumentsContract
+ * for more information.
+ *
+ * \note This does not implement all facilities of the native API.
+ *
+ */
+namespace DocumentsContract
+{
+
+namespace Document {
+const QLatin1String COLUMN_DISPLAY_NAME("_display_name");
+const QLatin1String COLUMN_DOCUMENT_ID("document_id");
+const QLatin1String COLUMN_FLAGS("flags");
+const QLatin1String COLUMN_LAST_MODIFIED("last_modified");
+const QLatin1String COLUMN_MIME_TYPE("mime_type");
+const QLatin1String COLUMN_SIZE("_size");
+
+constexpr int FLAG_DIR_SUPPORTS_CREATE = 0x00000008;
+constexpr int FLAG_SUPPORTS_DELETE = 0x00000004;
+constexpr int FLAG_SUPPORTS_WRITE = 0x00000002;
+constexpr int FLAG_VIRTUAL_DOCUMENT = 0x00000200;
+
+const QLatin1String MIME_TYPE_DIR("vnd.android.document/directory");
+} // namespace Document
+
+QString documentId(const QJNIObjectPrivate &uri)
+{
+    JniExceptionCleaner cleaner;
+    return QJNIObjectPrivate::callStaticObjectMethod("android/provider/DocumentsContract",
+                                              "getDocumentId",
+                                              "(Landroid/net/Uri;)Ljava/lang/String;",
+                                              uri.object()).toString();
+}
+
+QString treeDocumentId(const QJNIObjectPrivate &uri)
+{
+    JniExceptionCleaner cleaner;
+    return QJNIObjectPrivate::callStaticObjectMethod("android/provider/DocumentsContract",
+                                              "getTreeDocumentId",
+                                              "(Landroid/net/Uri;)Ljava/lang/String;",
+                                              uri.object()).toString();
+}
+
+QJNIObjectPrivate buildChildDocumentsUriUsingTree(const QJNIObjectPrivate &uri, const QString &parentDocumentId)
+{
+    JniExceptionCleaner cleaner;
+    return QJNIObjectPrivate::callStaticObjectMethod("android/provider/DocumentsContract",
+                                              "buildChildDocumentsUriUsingTree",
+                                              "(Landroid/net/Uri;Ljava/lang/String;)Landroid/net/Uri;",
+                                              uri.object(),
+                                              QJNIObjectPrivate::fromString(parentDocumentId).object());
+
+}
+
+QJNIObjectPrivate buildDocumentUriUsingTree(const QJNIObjectPrivate &treeUri, const QString &documentId)
+{
+    JniExceptionCleaner cleaner;
+    return QJNIObjectPrivate::callStaticObjectMethod("android/provider/DocumentsContract",
+                                              "buildDocumentUriUsingTree",
+                                              "(Landroid/net/Uri;Ljava/lang/String;)Landroid/net/Uri;",
+                                              treeUri.object(),
+                                              QJNIObjectPrivate::fromString(documentId).object());
+}
+
+bool isDocumentUri(const QJNIObjectPrivate &uri)
+{
+    JniExceptionCleaner cleaner;
+    return QJNIObjectPrivate::callStaticMethod<jboolean>("android/provider/DocumentsContract",
+                                                  "isDocumentUri",
+                                                  "(Landroid/content/Context;Landroid/net/Uri;)Z",
+                                                  QtAndroidPrivate::context(),
+                                                  uri.object());
+}
+
+bool isTreeUri(const QJNIObjectPrivate &uri)
+{
+    JniExceptionCleaner cleaner;
+    return QJNIObjectPrivate::callStaticMethod<jboolean>("android/provider/DocumentsContract",
+                                                  "isTreeUri",
+                                                  "(Landroid/net/Uri;)Z",
+                                                  uri.object());
+}
+
+QJNIObjectPrivate createDocument(const QJNIObjectPrivate &parentDocumentUri, const QString &mimeType,
+                          const QString &displayName)
+{
+    JniExceptionCleaner cleaner;
+    return QJNIObjectPrivate::callStaticObjectMethod("android/provider/DocumentsContract",
+                                              "createDocument",
+                                              "(Landroid/content/ContentResolver;Landroid/net/Uri;Ljava/lang/String;Ljava/lang/String;)Landroid/net/Uri;",
+                                              contentResolverInstance().object(),
+                                              parentDocumentUri.object(),
+                                              QJNIObjectPrivate::fromString(mimeType).object(),
+                                              QJNIObjectPrivate::fromString(displayName).object());
+}
+
+bool deleteDocument(const QJNIObjectPrivate &documentUri)
+{
+    const int flags = Cursor::queryColumn(documentUri, Document::COLUMN_FLAGS).toInt();
+    if (!(flags & Document::FLAG_SUPPORTS_DELETE))
+        return {};
+
+    JniExceptionCleaner cleaner;
+    return QJNIObjectPrivate::callStaticMethod<jboolean>("android/provider/DocumentsContract",
+                                                  "deleteDocument",
+                                                  "(Landroid/content/ContentResolver;Landroid/net/Uri;)Z",
+                                                  contentResolverInstance().object(),
+                                                  documentUri.object());
+}
+
+} // End DocumentsContract namespace
+
+// Start of DocumentFile
+
+using namespace DocumentsContract;
+
+namespace {
+class MakeableDocumentFile : public DocumentFile
+{
+public:
+    MakeableDocumentFile(const QJNIObjectPrivate &uri, const DocumentFilePtr &parent = {})
+        : DocumentFile(uri, parent)
+    {}
+};
+}
+
+DocumentFile::DocumentFile(const QJNIObjectPrivate &uri,
+                           const DocumentFilePtr &parent)
+    : m_uri{uri}
+    , m_parent{parent}
+{}
+
+QJNIObjectPrivate parseUri(const QString &uri)
+{
+    JniExceptionCleaner cleaner;
+    return QJNIObjectPrivate::callStaticObjectMethod("android/net/Uri",
+                                              "parse",
+                                              "(Ljava/lang/String;)Landroid/net/Uri;",
+                                              QJNIObjectPrivate::fromString(uri).object());
+}
+
+DocumentFilePtr DocumentFile::parseFromAnyUri(const QString &fileName)
+{
+    const QJNIObjectPrivate uri = parseUri(fileName);
+
+    if (DocumentsContract::isDocumentUri(uri))
+        return fromSingleUri(uri);
+
+    const QString documentType = QLatin1String("/document/");
+    const QString treeType = QLatin1String("/tree/");
+
+    const int treeIndex = fileName.indexOf(treeType);
+    const int documentIndex = fileName.indexOf(documentType);
+    const int index = fileName.lastIndexOf(QLatin1Char('/'));
+
+    if (index <= treeIndex + treeType.size() || index <= documentIndex + documentType.size())
+        return fromTreeUri(uri);
+
+    const QString parentUrl = fileName.left(index);
+    DocumentFilePtr parentDocFile = fromTreeUri(parseUri(parentUrl));
+
+    const QString baseName = fileName.mid(index);
+    const QString fileUrl = parentUrl + QUrl::toPercentEncoding(baseName);
+
+    DocumentFilePtr docFile = std::make_shared<MakeableDocumentFile>(parseUri(fileUrl));
+    if (parentDocFile && parentDocFile->isDirectory())
+        docFile->m_parent = parentDocFile;
+
+    return docFile;
+}
+
+DocumentFilePtr DocumentFile::fromSingleUri(const QJNIObjectPrivate &uri)
+{
+    return std::make_shared<MakeableDocumentFile>(uri);
+}
+
+DocumentFilePtr DocumentFile::fromTreeUri(const QJNIObjectPrivate &treeUri)
+{
+    QString docId;
+    if (isDocumentUri(treeUri))
+        docId = documentId(treeUri);
+    else
+        docId = treeDocumentId(treeUri);
+
+    return std::make_shared<MakeableDocumentFile>(buildDocumentUriUsingTree(treeUri, docId));
+}
+
+DocumentFilePtr DocumentFile::createFile(const QString &mimeType, const QString &displayName)
+{
+    if (isDirectory()) {
+        return std::make_shared<MakeableDocumentFile>(
+                    createDocument(m_uri, mimeType, displayName),
+                    shared_from_this());
+    }
+    return {};
+}
+
+DocumentFilePtr DocumentFile::createDirectory(const QString &displayName)
+{
+    if (isDirectory()) {
+        return std::make_shared<MakeableDocumentFile>(
+                    createDocument(m_uri, Document::MIME_TYPE_DIR, displayName),
+                    shared_from_this());
+    }
+    return {};
+}
+
+const QJNIObjectPrivate &DocumentFile::uri() const
+{
+    return m_uri;
+}
+
+const DocumentFilePtr &DocumentFile::parent() const
+{
+    return m_parent;
+}
+
+QString DocumentFile::name() const
+{
+    return Cursor::queryColumn(m_uri, Document::COLUMN_DISPLAY_NAME).toString();
+}
+
+QString DocumentFile::id() const
+{
+    return DocumentsContract::documentId(uri());
+}
+
+QString DocumentFile::mimeType() const
+{
+    return Cursor::queryColumn(m_uri, Document::COLUMN_MIME_TYPE).toString();
+}
+
+bool DocumentFile::isDirectory() const
+{
+    return mimeType() == Document::MIME_TYPE_DIR;
+}
+
+bool DocumentFile::isFile() const
+{
+    const QString type = mimeType();
+    return  type != Document::MIME_TYPE_DIR && !type.isEmpty();
+}
+
+bool DocumentFile::isVirtual() const
+{
+    return isDocumentUri(m_uri) && (Cursor::queryColumn(m_uri,
+                                Document::COLUMN_FLAGS).toInt() & Document::FLAG_VIRTUAL_DOCUMENT);
+}
+
+QDateTime DocumentFile::lastModified() const
+{
+    const auto timeVariant = Cursor::queryColumn(m_uri, Document::COLUMN_LAST_MODIFIED);
+    if (timeVariant.isValid())
+        return QDateTime::fromMSecsSinceEpoch(timeVariant.toLongLong());
+    return {};
+}
+
+int64_t DocumentFile::length() const
+{
+    return Cursor::queryColumn(m_uri, Document::COLUMN_SIZE).toLongLong();
+}
+
+namespace {
+constexpr int FLAG_GRANT_READ_URI_PERMISSION = 0x00000001;
+constexpr int FLAG_GRANT_WRITE_URI_PERMISSION = 0x00000002;
+}
+
+bool DocumentFile::canRead() const
+{
+    JniExceptionCleaner cleaner;
+    const auto context = QJNIObjectPrivate(QtAndroidPrivate::context());
+    const bool selfUriPermission = context.callMethod<jint>("checkCallingOrSelfUriPermission",
+                                                            "(Landroid/net/Uri;I)I",
+                                                            m_uri.object(),
+                                                            FLAG_GRANT_READ_URI_PERMISSION);
+    if (selfUriPermission != 0)
+        return false;
+
+    return !mimeType().isEmpty();
+}
+
+bool DocumentFile::canWrite() const
+{
+    JniExceptionCleaner cleaner;
+    const auto context = QJNIObjectPrivate(QtAndroidPrivate::context());
+    const bool selfUriPermission = context.callMethod<jint>("checkCallingOrSelfUriPermission",
+                                                            "(Landroid/net/Uri;I)I",
+                                                            m_uri.object(),
+                                                            FLAG_GRANT_WRITE_URI_PERMISSION);
+    if (selfUriPermission != 0)
+        return false;
+
+    const QString type = mimeType();
+    if (type.isEmpty())
+        return false;
+
+    const int flags = Cursor::queryColumn(m_uri, Document::COLUMN_FLAGS).toInt();
+    if (flags & Document::FLAG_SUPPORTS_DELETE)
+        return true;
+
+    const bool supportsWrite = (flags & Document::FLAG_SUPPORTS_WRITE);
+    const bool isDir = (type == Document::MIME_TYPE_DIR);
+    const bool dirSupportsCreate = (isDir && (flags & Document::FLAG_DIR_SUPPORTS_CREATE));
+
+    return  dirSupportsCreate || supportsWrite;
+}
+
+bool DocumentFile::remove()
+{
+    return deleteDocument(m_uri);
+}
+
+bool DocumentFile::exists() const
+{
+    return !name().isEmpty();
+}
+
+std::vector<DocumentFilePtr> DocumentFile::listFiles()
+{
+    std::vector<DocumentFilePtr> res;
+    const auto childrenUri = buildChildDocumentsUriUsingTree(m_uri, documentId(m_uri));
+    const auto query = Cursor::queryUri(childrenUri, {Document::COLUMN_DOCUMENT_ID});
+    if (!query)
+        return res;
+
+    while (query->moveToNext()) {
+        const auto uri = buildDocumentUriUsingTree(m_uri, query->data(0).toString());
+        res.push_back(std::make_shared<MakeableDocumentFile>(uri, shared_from_this()));
+    }
+    return res;
+}
+
+// End of DocumentFile
diff --git a/src/plugins/platforms/android/androidcontentfileengine.h b/src/plugins/platforms/android/androidcontentfileengine.h
index f92e437fab..e6457bc56d 100644
--- a/src/plugins/platforms/android/androidcontentfileengine.h
+++ b/src/plugins/platforms/android/androidcontentfileengine.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2019 Volker Krause <vkrause@kde.org>
+** Copyright (C) 2022 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -41,20 +42,36 @@
 #define ANDROIDCONTENTFILEENGINE_H
 
 #include <private/qfsfileengine_p.h>
+#include <private/qjni_p.h>
+#include <QtCore/qlist.h>
+
+
+using DocumentFilePtr = std::shared_ptr<class DocumentFile>;
 
 class AndroidContentFileEngine : public QFSFileEngine
 {
 public:
     AndroidContentFileEngine(const QString &fileName);
     bool open(QIODevice::OpenMode openMode) override;
+    bool close() override;
     qint64 size() const override;
+    bool remove() override;
+    bool mkdir(const QString &dirName, bool createParentDirectories) const override;
+    bool rmdir(const QString &dirName, bool recurseParentDirectories) const override;
+    QByteArray id() const override;
+    bool caseSensitive() const override { return true; }
+    QDateTime fileTime(FileTime time) const override;
     FileFlags fileFlags(FileFlags type = FileInfoAll) const override;
     QString fileName(FileName file = DefaultName) const override;
     QAbstractFileEngine::Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames) override;
     QAbstractFileEngine::Iterator *endEntryList() override;
+
 private:
-    QString m_file;
+    void closeNativeFileDescriptor();
 
+    QString m_initialFile;
+    QJNIObjectPrivate m_pfd;
+    DocumentFilePtr m_documentFile;
 };
 
 class AndroidContentFileEngineHandler : public QAbstractFileEngineHandler
@@ -75,8 +92,48 @@ public:
     QString currentFileName() const override;
     QString currentFilePath() const override;
 private:
-    mutable QStringList m_entries;
-    mutable int m_index = -1;
+    mutable QList<DocumentFilePtr> m_files;
+    mutable qsizetype m_index = -1;
+};
+
+/*!
+ *
+ * DocumentFile Api.
+ * Check https://developer.android.com/reference/androidx/documentfile/provider/DocumentFile
+ * for more information.
+ *
+ */
+class DocumentFile : public std::enable_shared_from_this<DocumentFile>
+{
+public:
+    static DocumentFilePtr parseFromAnyUri(const QString &filename);
+    static DocumentFilePtr fromSingleUri(const QJNIObjectPrivate &uri);
+    static DocumentFilePtr fromTreeUri(const QJNIObjectPrivate &treeUri);
+
+    DocumentFilePtr createFile(const QString &mimeType, const QString &displayName);
+    DocumentFilePtr createDirectory(const QString &displayName);
+    const QJNIObjectPrivate &uri() const;
+    const DocumentFilePtr &parent() const;
+    QString name() const;
+    QString id() const;
+    QString mimeType() const;
+    bool isDirectory() const;
+    bool isFile() const;
+    bool isVirtual() const;
+    QDateTime lastModified() const;
+    int64_t length() const;
+    bool canRead() const;
+    bool canWrite() const;
+    bool remove();
+    bool exists() const;
+    std::vector<DocumentFilePtr> listFiles();
+
+protected:
+    DocumentFile(const QJNIObjectPrivate &uri, const std::shared_ptr<DocumentFile> &parent);
+
+protected:
+    QJNIObjectPrivate m_uri;
+    DocumentFilePtr m_parent;
 };
 
 #endif // ANDROIDCONTENTFILEENGINE_H
diff --git a/tests/manual/android_content_uri/android_content_uri.pro b/tests/manual/android_content_uri/android_content_uri.pro
new file mode 100644
index 0000000000..76109e6351
--- /dev/null
+++ b/tests/manual/android_content_uri/android_content_uri.pro
@@ -0,0 +1,4 @@
+TEMPLATE = app
+QT = core testlib widgets
+
+SOURCES += tst_content_uris.cpp
diff --git a/tests/manual/android_content_uri/tst_content_uris.cpp b/tests/manual/android_content_uri/tst_content_uris.cpp
new file mode 100644
index 0000000000..1fea742af7
--- /dev/null
+++ b/tests/manual/android_content_uri/tst_content_uris.cpp
@@ -0,0 +1,201 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <QTest>
+#include <QDirIterator>
+#include <QFileDialog>
+#include <QMessageBox>
+
+class tst_ContentUris: public QObject
+{
+    Q_OBJECT
+private slots:
+    void dirFacilities();
+    void readWriteFile();
+    void readWriteNonExistingFile_data();
+    void readWriteNonExistingFile();
+    void createFileFromDirUrl_data();
+    void createFileFromDirUrl();
+    void fileOperations();
+};
+
+static QStringList listFiles(const QDir &dir, QDirIterator::IteratorFlag flag = {})
+{
+    QDirIterator it(dir, flag);
+    QStringList dirs;
+    while (it.hasNext())
+        dirs << it.next();
+    return dirs;
+}
+
+void showInstructionsDialog(const QString &message)
+{
+    QMessageBox::information(nullptr, QLatin1String("Instructions"), message);
+}
+
+void tst_ContentUris::dirFacilities()
+{
+    showInstructionsDialog(QLatin1String("Choose a folder with no content/files/subdirs"));
+
+    auto url = QFileDialog::getExistingDirectory();
+    QVERIFY(url.startsWith(QLatin1String("content")));
+    QDir dir(url);
+
+    QVERIFY(dir.exists());
+    QVERIFY(!dir.dirName().isEmpty());
+    QVERIFY(listFiles(dir).isEmpty());
+
+    QVERIFY(dir.mkdir(QLatin1String("Sub")));
+    const auto dirList = listFiles(dir);
+    QVERIFY(dirList.size() == 1);
+    const QDir subDir = dirList.first();
+
+    QVERIFY(subDir.dirName() == QLatin1String("Sub"));
+    QEXPECT_FAIL("", "absolutePath() is returning wrong path, cutting from 'primary' onward", Continue);
+    qWarning() << "subDir.absolutePath()" << subDir.absolutePath() << dirList.first();
+    QVERIFY(subDir.absolutePath() == dirList.first());
+    QVERIFY(subDir.path() == dirList.first());
+
+    QVERIFY(listFiles(dir, QDirIterator::Subdirectories).size() == 1);
+    QVERIFY(dir.mkdir(QLatin1String("Sub"))); // Create an existing dir
+    QVERIFY(dir.rmdir(QLatin1String("Sub")));
+
+    QVERIFY(dir.mkpath(QLatin1String("Sub/Sub2/Sub3")));
+    QVERIFY(listFiles(dir).size() == 1);
+    QVERIFY(listFiles(dir, QDirIterator::Subdirectories).size() == 3);
+    QVERIFY(dir.mkpath(QLatin1String("Sub/Sub2/Sub3")));  // Create an existing dir hierarchy
+    QVERIFY(dir.rmdir(QLatin1String("Sub")));
+
+}
+
+void tst_ContentUris::readWriteFile()
+{
+    const QByteArray content = "Written to file";
+    const QString fileName = QLatin1String("new_file.txt");
+
+    {
+        showInstructionsDialog(QLatin1String("Choose a name for new file to create"));
+
+        auto url = QFileDialog::getSaveFileName(nullptr, tr("Save File"), fileName);
+        QFile file(url);
+        QVERIFY(file.exists());
+        QVERIFY(file.size() == 0);
+        QVERIFY(file.fileName() == url);
+        QVERIFY(QFileInfo(url).baseName() == fileName);
+
+        QVERIFY(file.open(QFile::WriteOnly));
+        QVERIFY(file.isOpen());
+        QVERIFY(file.isWritable());
+        QVERIFY(file.fileTime(QFileDevice::FileModificationTime) != QDateTime());
+        QVERIFY(file.write(content) > 0);
+        QVERIFY(file.size() == content.size());
+        file.close();
+
+        // NOTE: The native file cursor is not returning an updated time or it takes long
+        // for it to get updated, for now just check that we actually received a valid QDateTime
+        QVERIFY(file.fileTime(QFileDevice::FileModificationTime) != QDateTime());
+    }
+
+    {
+        showInstructionsDialog(QLatin1String("Choose the file that was created"));
+
+        auto url = QFileDialog::getOpenFileName(nullptr, tr("Open File"), fileName);
+        QFile file(url);
+        QVERIFY(file.exists());
+
+        QVERIFY(file.open(QFile::ReadOnly));
+        QVERIFY(file.isOpen());
+        QVERIFY(file.isReadable());
+        QVERIFY(file.readAll() == content);
+
+        QVERIFY(file.remove());
+    }
+}
+
+void tst_ContentUris::readWriteNonExistingFile_data()
+{
+    QTest::addColumn<QString>("path");
+
+    const QString fileName = "non-existing-file.txt";
+    const QString uriSchemeAuthority = "content://com.android.externalstorage.documents";
+    const QString id = "primary%3APictures";
+    const QString encSlash = QUrl::toPercentEncoding(QLatin1String("/"));
+
+    const QString docSlash = uriSchemeAuthority + QLatin1String("/document/") + id + QLatin1String("/") + fileName;
+    const QString docEncodedSlash = uriSchemeAuthority + QLatin1String("/document/") + id + encSlash + fileName;
+
+    QTest::newRow("document_with_slash") << docSlash;
+    QTest::newRow("document_with_encoded_slash") << docEncodedSlash;
+}
+
+void tst_ContentUris::readWriteNonExistingFile()
+{
+    QFETCH(QString, path);
+
+    QFile file(path);
+    QVERIFY(!file.exists());
+    QVERIFY(file.size() == 0);
+
+    QVERIFY(!file.open(QFile::WriteOnly));
+    QVERIFY(!file.isOpen());
+    QVERIFY(!file.isWritable());
+}
+
+void tst_ContentUris::createFileFromDirUrl_data()
+{
+    QTest::addColumn<QString>("path");
+
+    showInstructionsDialog("Choose a folder with no content/files/subdirs");
+
+    const QString treeUrl = QFileDialog::getExistingDirectory();
+    const QString fileName = "text.txt";
+    const QString treeSlash = treeUrl + QLatin1String("/") + fileName;
+    QTest::newRow("tree_with_slash") << treeSlash;
+
+    // TODO: This is not handled at the moment
+    // const QString encSlash = QUrl::toPercentEncoding("/"_L1);
+    // const QString treeEncodedSlash = treeUrl + encSlash + fileName;
+    // QTest::newRow("tree_with_encoded_slash") << treeEncodedSlash;
+}
+
+void tst_ContentUris::createFileFromDirUrl()
+{
+    QFETCH(QString, path);
+
+    const QByteArray content = "Written to file";
+
+    QFile file(path);
+    QVERIFY(!file.exists());
+    QVERIFY(file.size() == 0);
+
+    QVERIFY(file.open(QFile::WriteOnly));
+    QVERIFY(file.isOpen());
+    QVERIFY(file.isWritable());
+    QVERIFY(file.exists());
+    QVERIFY(file.write(content));
+    QVERIFY(file.size() == content.size());
+    file.close();
+
+    QVERIFY(file.open(QFile::ReadOnly));
+    QVERIFY(file.isOpen());
+    QVERIFY(file.isReadable());
+    QVERIFY(file.readAll() == content);
+
+    QVERIFY(file.remove());
+}
+
+void tst_ContentUris::fileOperations()
+{
+    showInstructionsDialog("Choose a name for new file to create");
+
+    const QString fileName = "new_file.txt";
+    auto url = QFileDialog::getSaveFileName(nullptr, tr("Save File"), fileName);
+    QFile file(url);
+    QVERIFY(file.exists());
+
+    QVERIFY(file.remove());
+    QVERIFY(!file.exists());
+}
+
+QTEST_MAIN(tst_ContentUris)
+#include "tst_content_uris.moc"
diff --git a/tests/manual/manual.pro b/tests/manual/manual.pro
index 42f9878e44..bb6c33acb2 100644
--- a/tests/manual/manual.pro
+++ b/tests/manual/manual.pro
@@ -58,6 +58,8 @@ unc \
 qtabbar \
 rhi
 
+android: SUBDIRS += android_content_uri
+
 !qtConfig(openssl): SUBDIRS -= qssloptions
 
 qtConfig(opengl) {