diff --git a/src/plugins/platforms/android/qandroidassetsfileenginehandler.cpp b/src/plugins/platforms/android/qandroidassetsfileenginehandler.cpp
index 07776a4..7e1e689 100644
--- a/src/plugins/platforms/android/qandroidassetsfileenginehandler.cpp
+++ b/src/plugins/platforms/android/qandroidassetsfileenginehandler.cpp
@@ -254,35 +254,38 @@ public:
         setFileName(fileName);
     }
 
     ~AndroidAbstractFileEngine()
     {
         close();
     }
 
     bool open(QIODevice::OpenMode openMode) override
     {
-        if (m_isFolder || (openMode & QIODevice::WriteOnly))
+        if (!m_assetInfo || m_assetInfo->type != AssetItem::Type::File || (openMode & QIODevice::WriteOnly))
             return false;
-        close();
+
+        if (m_assetFile)
+            return true;
+
         m_assetFile = AAssetManager_open(m_assetManager, m_fileName.toUtf8(), AASSET_MODE_BUFFER);
         return m_assetFile;
     }
 
     bool close() override
     {
         if (m_assetFile) {
             AAsset_close(m_assetFile);
             m_assetFile = 0;
             return true;
         }
-        m_isFolder = false;
+        m_assetInfo.reset();
         return false;
     }
 
     qint64 size() const override
     {
         if (m_assetFile)
             return AAsset_getLength(m_assetFile);
         return -1;
     }
 
@@ -319,24 +322,26 @@ public:
 
     bool isRelativePath() const override
     {
         return false;
     }
 
     FileFlags fileFlags(FileFlags type = FileInfoAll) const override
     {
         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;
     }
 
     QString fileName(FileName file = DefaultName) const override
     {
         int pos;
         switch (file) {
         case DefaultName:
         case AbsoluteName:
         case CanonicalName:
@@ -357,47 +362,74 @@ public:
             return QString();
         }
     }
 
     void setFileName(const QString &file) override
     {
         if (m_fileName == cleanedAssetPath(file))
             return;
         close();
         m_fileName = cleanedAssetPath(file);
-        switch (FolderIterator::fileType(m_fileName)) {
-        case AssetItem::Type::File:
-            open(QIODevice::ReadOnly);
-            break;
-        case AssetItem::Type::Folder:
-            m_isFolder = true;
-            break;
-        case AssetItem::Type::Invalid:
-            break;
+
+        {
+            QMutexLocker lock(&m_assetsCacheMutex);
+            QSharedPointer<AssetItem> *assetInfoPtr = m_assetsCache.object(m_fileName);
+            if (assetInfoPtr) {
+                m_assetInfo = *assetInfoPtr;
+                return;
+            }
+        }
+
+        QSharedPointer<AssetItem> *assetInfoPtr = new QSharedPointer<AssetItem>(new AssetItem);
+
+        m_assetInfo = *assetInfoPtr;
+        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;
+        } else {
+            auto *assetDir = AAssetManager_openDir(m_assetManager, m_fileName.toUtf8());
+            if (assetDir) {
+                if (AAssetDir_getNextFileName(assetDir))
+                    m_assetInfo->type = AssetItem::Type::Folder;
+                AAssetDir_close(assetDir);
+            }
         }
+
+        QMutexLocker lock(&m_assetsCacheMutex);
+        m_assetsCache.insert(m_fileName, assetInfoPtr);
     }
 
     Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames) override
     {
-        if (m_isFolder)
+        if (m_assetInfo && m_assetInfo->type == AssetItem::Type::Folder)
             return new AndroidAbstractFileEngineIterator(filters, filterNames, m_fileName);
         return nullptr;
     }
 
 private:
     AAsset *m_assetFile = nullptr;
     AAssetManager *m_assetManager = nullptr;
     // initialize with a name that can't be used as a file name
     QString m_fileName = QLatin1String(".");
-    bool m_isFolder = false;
+    QSharedPointer<AssetItem> m_assetInfo;
+
+    static QCache<QString, QSharedPointer<AssetItem>> m_assetsCache;
+    static QMutex m_assetsCacheMutex;
 };
 
+QCache<QString, QSharedPointer<AssetItem>> AndroidAbstractFileEngine::m_assetsCache(std::max(50, qEnvironmentVariableIntValue("QT_ANDROID_MAX_ASSETS_CACHE_SIZE")));
+QMutex AndroidAbstractFileEngine::m_assetsCacheMutex;
+
 
 AndroidAssetsFileEngineHandler::AndroidAssetsFileEngineHandler()
 {
     m_assetManager = QtAndroid::assetManager();
 }
 
 QAbstractFileEngine * AndroidAssetsFileEngineHandler::create(const QString &fileName) const
 {
     if (fileName.isEmpty())
         return nullptr;
