1 files changed, 77 insertions, 54 deletions

diff --git a/src/plugins/platforms/android/qandroidassetsfileenginehandler.cpp b/src/plugins/platforms/android/qandroidassetsfileenginehandler.cpp
index a25aa673d3..4ea6536cef 100644
--- a/src/plugins/platforms/android/qandroidassetsfileenginehandler.cpp
+++ b/src/plugins/platforms/android/qandroidassetsfileenginehandler.cpp
@@ -54,6 +54,7 @@ struct AssetItem {
     }
     Type type = Type::File;
     QString name;
+    qint64 size = -1;
 };
 
 using AssetItemList = QList<AssetItem>;
@@ -107,6 +108,8 @@ public:
     FolderIterator(const QString &path)
         : m_path(path)
     {
+        // Note that empty dirs in the assets dir before the build are not going to be
+        // included in the final apk, so no empty folders should expected to be listed.
         QJniObject files = QJniObject::callStaticObjectMethod(QtAndroid::applicationClass(),
                                                                             "listAssetContent",
                                                                             "(Landroid/content/res/AssetManager;Ljava/lang/String;)[Ljava/lang/String;",
@@ -139,17 +142,13 @@ public:
         return m_path + at(m_index).name;
     }
 
-    bool hasNext() const
+    bool advance()
     {
-        return !empty() && m_index + 1 < size();
-    }
-
-    std::optional<std::pair<QString, AssetItem>> next()
-    {
-        if (!hasNext())
-            return {};
-        ++m_index;
-        return std::pair<QString, AssetItem>(currentFileName(), at(m_index));
+        if (!empty() && m_index + 1 < size()) {
+            ++m_index;
+            return true;
+        }
+        return false;
     }
 
 private:
@@ -160,7 +159,7 @@ private:
 };
 
 QCache<QString, QSharedPointer<FolderIterator>> FolderIterator::m_assetsCache(std::max(50, qEnvironmentVariableIntValue("QT_ANDROID_MAX_ASSETS_CACHE_SIZE")));
-QMutex FolderIterator::m_assetsCacheMutex;
+Q_CONSTINIT QMutex FolderIterator::m_assetsCacheMutex;
 
 class AndroidAbstractFileEngineIterator: public QAbstractFileEngineIterator
 {
@@ -168,7 +167,7 @@ public:
     AndroidAbstractFileEngineIterator(QDir::Filters filters,
                                       const QStringList &nameFilters,
                                       const QString &path)
-        : QAbstractFileEngineIterator(filters, nameFilters)
+        : QAbstractFileEngineIterator(path, filters, nameFilters)
     {
         m_currentIterator = FolderIterator::fromCache(cleanedAssetPath(path), true);
     }
@@ -185,28 +184,16 @@ public:
         return m_currentIterator->currentFileName();
     }
 
-    virtual QString currentFilePath() const
+    QString currentFilePath() const override
     {
         if (!m_currentIterator)
             return {};
         return m_currentIterator->currentFilePath();
     }
 
-    bool hasNext() const override
+    bool advance() override
     {
-        if (!m_currentIterator)
-            return false;
-        return m_currentIterator->hasNext();
-    }
-
-    QString next() override
-    {
-        if (!m_currentIterator)
-            return {};
-        auto res = m_currentIterator->next();
-        if (!res)
-            return {};
-        return res->first;
+        return m_currentIterator ? m_currentIterator->advance() : false;
     }
 
 private:
@@ -231,7 +218,7 @@ public:
     {
         Q_UNUSED(permissions);
 
-        if (m_isFolder || (openMode & QIODevice::WriteOnly))
+        if (!m_assetInfo || m_assetInfo->type != AssetItem::Type::File || (openMode & QIODevice::WriteOnly))
             return false;
         close();
         m_assetFile = AAssetManager_open(m_assetManager, m_fileName.toUtf8(), AASSET_MODE_BUFFER);
@@ -245,14 +232,13 @@ public:
             m_assetFile = 0;
             return true;
         }
-        m_isFolder = false;
         return false;
     }
 
     qint64 size() const override
     {
-        if (m_assetFile)
-            return AAsset_getLength(m_assetFile);
+        if (m_assetInfo)
+            return m_assetInfo->size;
         return -1;
     }
 
@@ -286,10 +272,12 @@ public:
     {
         FileFlags commonFlags(ReadOwnerPerm|ReadUserPerm|ReadGroupPerm|ReadOtherPerm|ExistsFlag);
         FileFlags flags;
-        if (m_assetFile)
-            flags = FileType | commonFlags;
-        else if (m_isFolder)
-            flags = DirectoryType | commonFlags;
+        if (m_assetInfo) {
+            if (m_assetInfo->type == AssetItem::Type::File)
+                flags = FileType | commonFlags;
+            else if (m_assetInfo->type == AssetItem::Type::Folder)
+                flags = DirectoryType | commonFlags;
+        }
         return type & flags;
     }
 
@@ -303,9 +291,9 @@ public:
                 return prefixedPath(m_fileName);
         case BaseName:
             if ((pos = m_fileName.lastIndexOf(u'/')) != -1)
-                return prefixedPath(m_fileName.mid(pos));
+                return m_fileName.mid(pos + 1);
             else
-                return prefixedPath(m_fileName);
+                return m_fileName;
         case PathName:
         case AbsolutePathName:
         case CanonicalPathName:
@@ -324,22 +312,51 @@ public:
             return;
         close();
         m_fileName = cleanedAssetPath(file);
-        switch (FolderIterator::fileType(m_fileName)) {
-        case AssetItem::Type::File:
-            open(QIODevice::ReadOnly, std::nullopt);
-            break;
-        case AssetItem::Type::Folder:
-            m_isFolder = true;
-            break;
-        case AssetItem::Type::Invalid:
-            break;
+
+        {
+            QMutexLocker lock(&m_assetsInfoCacheMutex);
+            QSharedPointer<AssetItem> *assetInfoPtr = m_assetsInfoCache.object(m_fileName);
+            if (assetInfoPtr) {
+                m_assetInfo = *assetInfoPtr;
+                return;
+            }
+        }
+
+        QSharedPointer<AssetItem> *newAssetInfoPtr = new QSharedPointer<AssetItem>(new AssetItem);
+
+        m_assetInfo = *newAssetInfoPtr;
+        m_assetInfo->name = m_fileName;
+        m_assetInfo->type = AssetItem::Type::Invalid;
+
+        m_assetFile = AAssetManager_open(m_assetManager, m_fileName.toUtf8(), AASSET_MODE_BUFFER);
+
+        if (m_assetFile) {
+            m_assetInfo->type = AssetItem::Type::File;
+            m_assetInfo->size = AAsset_getLength(m_assetFile);
+        } else {
+            auto *assetDir = AAssetManager_openDir(m_assetManager, m_fileName.toUtf8());
+            if (assetDir) {
+                if (AAssetDir_getNextFileName(assetDir)
+                        || (!FolderIterator::fromCache(m_fileName, false)->empty())) {
+                    // If AAssetDir_getNextFileName is not valid, it still can be a directory that
+                    // contains only other directories (no files). FolderIterator will not be called
+                    // on the directory containing files so it should not be too time consuming now.
+                    m_assetInfo->type = AssetItem::Type::Folder;
+                }
+                AAssetDir_close(assetDir);
+            }
         }
+
+        QMutexLocker lock(&m_assetsInfoCacheMutex);
+        m_assetsInfoCache.insert(m_fileName, newAssetInfoPtr);
     }
 
-    Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames) override
+    IteratorUniquePtr
+    beginEntryList(const QString &, QDir::Filters filters, const QStringList &filterNames) override
     {
-        if (m_isFolder)
-            return new AndroidAbstractFileEngineIterator(filters, filterNames, m_fileName);
+        // AndroidAbstractFileEngineIterator use `m_fileName` as the path
+        if (m_assetInfo && m_assetInfo->type == AssetItem::Type::Folder)
+            return std::make_unique<AndroidAbstractFileEngineIterator>(filters, filterNames, m_fileName);
         return nullptr;
     }
 
@@ -348,22 +365,28 @@ private:
     AAssetManager *m_assetManager = nullptr;
     // initialize with a name that can't be used as a file name
     QString m_fileName = "."_L1;
-    bool m_isFolder = false;
+    QSharedPointer<AssetItem> m_assetInfo;
+
+    static QCache<QString, QSharedPointer<AssetItem>> m_assetsInfoCache;
+    static QMutex m_assetsInfoCacheMutex;
 };
 
+QCache<QString, QSharedPointer<AssetItem>> AndroidAbstractFileEngine::m_assetsInfoCache(std::max(200, qEnvironmentVariableIntValue("QT_ANDROID_MAX_FILEINFO_ASSETS_CACHE_SIZE")));
+Q_CONSTINIT QMutex AndroidAbstractFileEngine::m_assetsInfoCacheMutex;
 
 AndroidAssetsFileEngineHandler::AndroidAssetsFileEngineHandler()
 {
     m_assetManager = QtAndroid::assetManager();
 }
 
-QAbstractFileEngine * AndroidAssetsFileEngineHandler::create(const QString &fileName) const
+std::unique_ptr<QAbstractFileEngine>
+AndroidAssetsFileEngineHandler::create(const QString &fileName) const
 {
     if (fileName.isEmpty())
-        return nullptr;
+        return {};
 
     if (!fileName.startsWith(assetsPrefix))
-        return nullptr;
+        return {};
 
     QString path = fileName.mid(prefixSize);
     path.replace("//"_L1, "/"_L1);
@@ -371,7 +394,7 @@ QAbstractFileEngine * AndroidAssetsFileEngineHandler::create(const QString &file
         path.remove(0, 1);
     if (path.endsWith(u'/'))
         path.chop(1);
-    return new AndroidAbstractFileEngine(m_assetManager, path);
+    return std::make_unique<AndroidAbstractFileEngine>(m_assetManager, path);
 }
 
 QT_END_NAMESPACE