diff options
author | Assam Boudjelthia <assam.boudjelthia@qt.io> | 2022-11-23 14:30:50 +0200 |
---|---|---|
committer | Qt Cherry-pick Bot <cherrypick_bot@qt-project.org> | 2022-12-14 13:56:19 +0000 |
commit | 8dd90fc8aa57919b0f42b92e268ef936a4d23b97 (patch) | |
tree | 33e12c715a9c9f0020b7cc0871ae2e734f4a4770 /src/plugins | |
parent | cc295aac1ffa4c646bbbb0386a153c2dea73220a (diff) | |
download | qtbase-8dd90fc8aa57919b0f42b92e268ef936a4d23b97.tar.gz |
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)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>
Diffstat (limited to 'src/plugins')
-rw-r--r-- | src/plugins/platforms/android/androidcontentfileengine.cpp | 679 | ||||
-rw-r--r-- | src/plugins/platforms/android/androidcontentfileengine.h | 62 |
2 files changed, 663 insertions, 78 deletions
diff --git a/src/plugins/platforms/android/androidcontentfileengine.cpp b/src/plugins/platforms/android/androidcontentfileengine.cpp index 978dd5332b..0f06e2bee1 100644 --- a/src/plugins/platforms/android/androidcontentfileengine.cpp +++ b/src/plugins/platforms/android/androidcontentfileengine.cpp @@ -1,5 +1,5 @@ -// Copyright (C) 2019 Volker Krause <vkrause@kde.org> -// Copyright (C) 2021 The Qt Company Ltd. +// Copyright (C) 2019 Volker Krause <vkrause@kde.org> +// Copyright (C) 2022 The Qt Company Ltd. // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only #include "androidcontentfileengine.h" @@ -7,16 +7,29 @@ #include <QtCore/qcoreapplication.h> #include <QtCore/qjnienvironment.h> #include <QtCore/qjniobject.h> - -#include <QDebug> +#include <QtCore/qurl.h> +#include <QtCore/qdatetime.h> +#include <QtCore/qmimedatabase.h> using namespace QNativeInterface; using namespace Qt::StringLiterals; -AndroidContentFileEngine::AndroidContentFileEngine(const QString &f) - : m_file(f) +static QJniObject &contentResolverInstance() { - setFileName(f); + static QJniObject contentResolver; + if (!contentResolver.isValid()) { + contentResolver = QJniObject(QNativeInterface::QAndroidApplication::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, @@ -29,6 +42,27 @@ bool AndroidContentFileEngine::open(QIODevice::OpenMode openMode, } if (openMode & QFileDevice::WriteOnly) { openModeStr += u'w'; + if (!m_documentFile->exists()) { + if (QUrl(m_initialFile).path().startsWith("/tree/"_L1)) { + const int lastSeparatorIndex = m_initialFile.lastIndexOf('/'); + 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 = "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 += u't'; @@ -36,12 +70,10 @@ bool AndroidContentFileEngine::open(QIODevice::OpenMode openMode, openModeStr += u'a'; } - m_pfd = QJniObject::callStaticObjectMethod("org/qtproject/qt/android/QtNative", - "openParcelFdForContentUrl", - "(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;)Landroid/os/ParcelFileDescriptor;", - QAndroidApplication::context(), - QJniObject::fromString(fileName(DefaultName)).object(), - QJniObject::fromString(openModeStr).object()); + m_pfd = contentResolverInstance().callObjectMethod("openFileDescriptor", + "(Landroid/net/Uri;Ljava/lang/String;)Landroid/os/ParcelFileDescriptor;", + m_documentFile->uri().object(), + QJniObject::fromString(openModeStr).object()); if (!m_pfd.isValid()) return false; @@ -49,8 +81,7 @@ bool AndroidContentFileEngine::open(QIODevice::OpenMode openMode, const auto fd = m_pfd.callMethod<jint>("getFd", "()I"); if (fd < 0) { - m_pfd.callMethod<void>("close", "()V"); - m_pfd = QJniObject(); + closeNativeFileDescriptor(); return false; } @@ -59,47 +90,121 @@ bool AndroidContentFileEngine::open(QIODevice::OpenMode openMode, bool AndroidContentFileEngine::close() { + closeNativeFileDescriptor(); + return QFSFileEngine::close(); +} + +void AndroidContentFileEngine::closeNativeFileDescriptor() +{ if (m_pfd.isValid()) { m_pfd.callMethod<void>("close", "()V"); m_pfd = QJniObject(); } - - return QFSFileEngine::close(); } qint64 AndroidContentFileEngine::size() const { - const jlong size = QJniObject::callStaticMethod<jlong>( - "org/qtproject/qt/android/QtNative", "getSize", - "(Landroid/content/Context;Ljava/lang/String;)J", QAndroidApplication::context(), - QJniObject::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, + std::optional<QFileDevice::Permissions> permissions) const +{ + Q_UNUSED(permissions) + + QString tmp = dirName; + tmp.remove(m_initialFile); + + QStringList dirParts = tmp.split(u'/'); + 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 = QJniObject::callStaticMethod<jboolean>( - "org/qtproject/qt/android/QtNative", "checkIfDir", - "(Landroid/content/Context;Ljava/lang/String;)Z", QAndroidApplication::context(), - QJniObject::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 : QJniObject::callStaticMethod<jboolean>( - "org/qtproject/qt/android/QtNative", "checkFileExists", - "(Landroid/content/Context;Ljava/lang/String;)Z", QAndroidApplication::context(), - QJniObject::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 = QJniObject::callStaticMethod<jboolean>( - "org/qtproject/qt/android/QtNative", "checkIfWritable", - "(Landroid/content/Context;Ljava/lang/String;)Z", QAndroidApplication::context(), - QJniObject::fromString(fileName(DefaultName)).object()); - if (writable) + flags |= FileType; + if (m_documentFile->canWrite()) flags |= WriteOwnerPerm|WriteUserPerm|WriteGroupPerm|WriteOtherPerm; } return type & flags; @@ -114,18 +219,18 @@ QString AndroidContentFileEngine::fileName(FileName f) const case DefaultName: case AbsoluteName: case CanonicalName: - return m_file; + return m_documentFile->uri().toString(); case BaseName: - { - const qsizetype pos = m_file.lastIndexOf(u'/'); - 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); } @@ -166,42 +271,468 @@ 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 = QJniObject::callStaticMethod<jboolean>( - "org/qtproject/qt/android/QtNative", "checkIfDir", - "(Landroid/content/Context;Ljava/lang/String;)Z", - QAndroidApplication::context(), - QJniObject::fromString(path()).object()); - if (isDir) { - QJniObject objArray = QJniObject::callStaticObjectMethod("org/qtproject/qt/android/QtNative", - "listContentsFromTreeUri", - "(Landroid/content/Context;Ljava/lang/String;)[Ljava/lang/String;", - QAndroidApplication::context(), - QJniObject::fromString(path()).object()); - if (objArray.isValid()) { - QJniEnvironment env; - const jsize length = env->GetArrayLength(objArray.object<jarray>()); - for (int i = 0; i != length; ++i) { - m_entries << QJniObject(env->GetObjectArrayElement( - objArray.object<jobjectArray>(), 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 QJniObject &object) + : m_object{object} { } + + ~Cursor() + { + if (m_object.isValid()) + 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 + { + 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); + QJniEnvironment env; + const auto blobArray = blob.object<jbyteArray>(); + 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 QJniObject &uri, + const QStringList &projection = {}, + const QString &selection = {}, + const QStringList &selectionArgs = {}, + const QString &sortOrder = {}) + { + 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 : QJniObject::fromString(selection).object(), + selectionArgs.isEmpty() ? nullptr : fromStringList(selectionArgs).object(), + sortOrder.isEmpty() ? nullptr : QJniObject::fromString(sortOrder).object()); + if (!cursor.isValid()) + return {}; + return std::make_unique<Cursor>(cursor); + } + + static QVariant queryColumn(const QJniObject &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 QJniObject fromStringList(const QStringList &list) + { + QJniEnvironment env; + auto array = env->NewObjectArray(list.size(), env->FindClass("java/lang/String"), nullptr); + for (int i = 0; i < list.size(); ++i) + env->SetObjectArrayElement(array, i, QJniObject::fromString(list[i]).object()); + return QJniObject::fromLocalRef(array); + } + + QJniObject 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 QJniObject &uri) +{ + return QJniObject::callStaticObjectMethod("android/provider/DocumentsContract", + "getDocumentId", + "(Landroid/net/Uri;)Ljava/lang/String;", + uri.object()).toString(); +} + +QString treeDocumentId(const QJniObject &uri) +{ + return QJniObject::callStaticObjectMethod("android/provider/DocumentsContract", + "getTreeDocumentId", + "(Landroid/net/Uri;)Ljava/lang/String;", + uri.object()).toString(); +} + +QJniObject buildChildDocumentsUriUsingTree(const QJniObject &uri, const QString &parentDocumentId) +{ + return QJniObject::callStaticObjectMethod("android/provider/DocumentsContract", + "buildChildDocumentsUriUsingTree", + "(Landroid/net/Uri;Ljava/lang/String;)Landroid/net/Uri;", + uri.object(), + QJniObject::fromString(parentDocumentId).object()); + +} + +QJniObject buildDocumentUriUsingTree(const QJniObject &treeUri, const QString &documentId) +{ + return QJniObject::callStaticObjectMethod("android/provider/DocumentsContract", + "buildDocumentUriUsingTree", + "(Landroid/net/Uri;Ljava/lang/String;)Landroid/net/Uri;", + treeUri.object(), + QJniObject::fromString(documentId).object()); +} + +bool isDocumentUri(const QJniObject &uri) +{ + return QJniObject::callStaticMethod<jboolean>("android/provider/DocumentsContract", + "isDocumentUri", + "(Landroid/content/Context;Landroid/net/Uri;)Z", + QNativeInterface::QAndroidApplication::context(), + uri.object()); +} + +bool isTreeUri(const QJniObject &uri) +{ + return QJniObject::callStaticMethod<jboolean>("android/provider/DocumentsContract", + "isTreeUri", + "(Landroid/net/Uri;)Z", + uri.object()); +} + +QJniObject createDocument(const QJniObject &parentDocumentUri, const QString &mimeType, + const QString &displayName) +{ + return QJniObject::callStaticObjectMethod("android/provider/DocumentsContract", + "createDocument", + "(Landroid/content/ContentResolver;Landroid/net/Uri;Ljava/lang/String;Ljava/lang/String;)Landroid/net/Uri;", + contentResolverInstance().object(), + parentDocumentUri.object(), + QJniObject::fromString(mimeType).object(), + QJniObject::fromString(displayName).object()); +} + +bool deleteDocument(const QJniObject &documentUri) +{ + const int flags = Cursor::queryColumn(documentUri, Document::COLUMN_FLAGS).toInt(); + if (!(flags & Document::FLAG_SUPPORTS_DELETE)) + return {}; + + return QJniObject::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 QJniObject &uri, const DocumentFilePtr &parent = {}) + : DocumentFile(uri, parent) + {} +}; +} + +DocumentFile::DocumentFile(const QJniObject &uri, + const DocumentFilePtr &parent) + : m_uri{uri} + , m_parent{parent} +{} + +QJniObject parseUri(const QString &uri) +{ + return QJniObject::callStaticObjectMethod("android/net/Uri", + "parse", + "(Ljava/lang/String;)Landroid/net/Uri;", + QJniObject::fromString(uri).object()); +} + +DocumentFilePtr DocumentFile::parseFromAnyUri(const QString &fileName) +{ + const QJniObject uri = parseUri(fileName); + + if (DocumentsContract::isDocumentUri(uri)) + return fromSingleUri(uri); + + const QString documentType = "/document/"_L1; + const QString treeType = "/tree/"_L1; + + const int treeIndex = fileName.indexOf(treeType); + const int documentIndex = fileName.indexOf(documentType); + const int index = fileName.lastIndexOf("/"); + + 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 QJniObject &uri) +{ + return std::make_shared<MakeableDocumentFile>(uri); +} + +DocumentFilePtr DocumentFile::fromTreeUri(const QJniObject &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 QJniObject &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 +{ + const auto context = QJniObject(QNativeInterface::QAndroidApplication::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 +{ + const auto context = QJniObject(QNativeInterface::QAndroidApplication::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 124336038e..439a23a664 100644 --- a/src/plugins/platforms/android/androidcontentfileengine.h +++ b/src/plugins/platforms/android/androidcontentfileengine.h @@ -5,7 +5,11 @@ #define ANDROIDCONTENTFILEENGINE_H #include <private/qfsfileengine_p.h> + #include <QtCore/qjniobject.h> +#include <QtCore/qlist.h> + +using DocumentFilePtr = std::shared_ptr<class DocumentFile>; class AndroidContentFileEngine : public QFSFileEngine { @@ -14,14 +18,24 @@ public: bool open(QIODevice::OpenMode openMode, std::optional<QFile::Permissions> permissions) override; bool close() override; qint64 size() const override; + bool remove() override; + bool mkdir(const QString &dirName, bool createParentDirectories, + std::optional<QFile::Permissions> permissions = std::nullopt) 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; - QJniObject m_pfd; + void closeNativeFileDescriptor(); + QString m_initialFile; + QJniObject m_pfd; + DocumentFilePtr m_documentFile; }; class AndroidContentFileEngineHandler : public QAbstractFileEngineHandler @@ -42,8 +56,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 QJniObject &uri); + static DocumentFilePtr fromTreeUri(const QJniObject &treeUri); + + DocumentFilePtr createFile(const QString &mimeType, const QString &displayName); + DocumentFilePtr createDirectory(const QString &displayName); + const QJniObject &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 QJniObject &uri, const std::shared_ptr<DocumentFile> &parent); + +protected: + QJniObject m_uri; + DocumentFilePtr m_parent; }; #endif // ANDROIDCONTENTFILEENGINE_H |