feat: add UAB file thumbnail support

1. Added UAB MIME type definition and thumbnail generation support
2. Implemented UAB thumbnail extraction from linglong.icon ELF section
using readelf
3. Enhanced MIME type support system with strategy-based checking
4. Added UAB to unconditional thumbnail support category (like AppImage)
5. Created utility function to skip thumbnail frame for specific file
types
6. Improved file validation logic in thumbnail creators
7. Fixed PPTX MIME type checking to include parent types

Log: Added thumbnail support for UAB files

Influence:
1. Test UAB file thumbnail generation with valid files containing
linglong.icon section
2. Verify UAB files without linglong.icon section show no thumbnail
3. Check that UAB files skip thumbnail frame display like AppImage
4. Test thumbnail generation with different UAB file sizes
5. Verify PPTX thumbnail generation still works correctly
6. Test that existing thumbnail functionality for other file types
remains unchanged
7. Check thumbnail support settings in preferences affect UAB files
appropriately

feat: 添加 UAB 文件缩略图支持

1. 添加 UAB MIME 类型定义和缩略图生成支持
2. 实现从 UAB 文件的 linglong.icon ELF 节提取缩略图，使用 readelf 工具
3. 增强 MIME 类型支持系统，采用基于策略的检查机制
4. 将 UAB 添加到无条件缩略图支持类别（与 AppImage 类似）
5. 创建工具函数用于跳过特定文件类型的缩略图底板
6. 改进缩略图生成器中的文件验证逻辑
7. 修复 PPTX MIME 类型检查以包含父类型

Log: 新增 UAB 文件缩略图支持功能

Influence:
1. 测试包含 linglong.icon 节的 UAB 文件缩略图生成
2. 验证没有 linglong.icon 节的 UAB 文件不显示缩略图
3. 检查 UAB 文件是否像 AppImage 一样跳过缩略图底板显示
4. 测试不同大小 UAB 文件的缩略图生成
5. 验证 PPTX 缩略图生成功能仍然正常工作
6. 测试其他文件类型的现有缩略图功能是否保持不变
7. 检查首选项中的缩略图支持设置是否正确影响 UAB 文件

Author: Johnson-zs

include/dfm-base/dfm_global_defines.h

@@ -152,6 +152,7 @@ inline constexpr char kTypeAppVMAsf[] { "application/vnd.ms-asf" };
 inline constexpr char kTypeAppCRRMedia[] { "application/cnd.rn-realmedia" };
 inline constexpr char kTypeAppVRRMedia[] { "application/vnd.rn-realmedia" };
 inline constexpr char kTypeAppAppimage[] { "application/vnd.appimage" };
+inline constexpr char kTypeAppUab[] { "application/vnd.linyaps.uab" };
 inline constexpr char kTypeTextHtml[] { "text/html" };
 inline constexpr char kTypeAppXhtmlXml[] { "application/xhtml+xml" };
 inline constexpr char kTypeTextXPython[] { "text/x-python" };

src/dfm-base/utils/iconutils.cpp

@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "iconutils.h"
 
+#include <dfm-base/dfm_global_defines.h>
+
 #include <QPainter>
 #include <QGraphicsDropShadowEffect>
 #include <QGraphicsScene>
@@ -108,3 +110,13 @@ QPixmap IconUtils::renderIconBackground(const QSizeF &size, const IconStyle &sty
     p.end();
     return pm;
 }
+
+bool IconUtils::shouldSkipThumbnailFrame(const QString &mimeType)
+{
+    // appimage, uab 不显示缩略图底板
+    static const QStringList kExcludedMimes = {
+        Global::Mime::kTypeAppAppimage,
+        Global::Mime::kTypeAppUab
+    };
+    return kExcludedMimes.contains(mimeType);
+}

src/dfm-base/utils/iconutils.h

@@ -23,6 +23,7 @@ QPixmap renderIconBackground(const QSize &size, const IconStyle &style = IconSty
 QPixmap renderIconBackground(const QSizeF &size, const IconStyle &style = IconStyle {});
 QPixmap addShadowToPixmap(const QPixmap &originalPixmap, int shadowOffsetY, qreal blurRadius, qreal shadowOpacity);
 IconStyle getIconStyle(int size);
+bool shouldSkipThumbnailFrame(const QString &mimeType);
 }   // end namespace IconUtils
 
 DFMBASE_END_NAMESPACE

src/dfm-base/utils/thumbnail/thumbnailcreators.cpp

@@ -497,16 +497,14 @@ QImage ThumbnailCreators::appimageThumbnailCreator(const QString &filePath, Thum
     qCDebug(logDFMBase) << "thumbnail: creating AppImage thumbnail for:" << filePath << "size:" << size;
 
     // 1. Check if AppImage exists
-    if (!QFile::exists(filePath)) {
+    auto info = InfoFactory::create<FileInfo>(QUrl::fromLocalFile(filePath));
+    if (!info || !info->exists()) {
         qCWarning(logDFMBase) << "thumbnail: AppImage file not found:" << filePath;
         return QImage();
     }
 
     // 2. Check if file is AppImage type and has executable permission
-    auto info = InfoFactory::create<FileInfo>(QUrl::fromLocalFile(filePath),
-                                              Global::CreateFileInfoType::kCreateFileInfoSync);
-    if (!info
-        || info->nameOf(NameInfoType::kMimeTypeName) != Global::Mime::kTypeAppAppimage
+    if (info->nameOf(NameInfoType::kMimeTypeName) != Global::Mime::kTypeAppAppimage
         || !info->isAttributes(FileInfo::FileIsType::kIsExecutable)) {
         qCWarning(logDFMBase) << "thumbnail: file is not a valid AppImage or lacks executable permission:" << filePath
                               << "mimeType:" << (info ? info->nameOf(NameInfoType::kMimeTypeName) : "null")
@@ -520,11 +518,10 @@ QImage ThumbnailCreators::appimageThumbnailCreator(const QString &filePath, Thum
 
     // Read .DirIcon file from AppImage without extraction
     bool success = appimage_read_file_into_buffer_following_symlinks(
-        filePath.toUtf8().constData(),
-        ".DirIcon",
-        &iconBuffer,
-        &iconSize
-    );
+            filePath.toUtf8().constData(),
+            ".DirIcon",
+            &iconBuffer,
+            &iconSize);
 
     // Use RAII to ensure buffer cleanup
     QScopedPointer<char, QScopedPointerPodDeleter> bufferCleanup(iconBuffer);
@@ -557,18 +554,19 @@ QImage ThumbnailCreators::pptxThumbnailCreator(const QString &filePath, Thumbnai
 {
     qCInfo(logDFMBase) << "thumbnail: creating PPTX thumbnail for:" << filePath << "size:" << size;
 
-    // 1. Verify file exists
-    if (!QFile::exists(filePath)) {
+    auto info = InfoFactory::create<FileInfo>(QUrl::fromLocalFile(filePath));
+    if (!info || !info->exists()) {
         qCWarning(logDFMBase) << "thumbnail: PPTX file not found:" << filePath;
         return QImage();
     }
 
     // 2. Verify file type
-    auto info = InfoFactory::create<FileInfo>(QUrl::fromLocalFile(filePath),
-                                              Global::CreateFileInfoType::kCreateFileInfoSync);
-    if (!info || info->nameOf(NameInfoType::kMimeTypeName) != Global::Mime::kTypeAppPptx) {
+    const QMimeType &mime = info->fileMimeType();
+    QStringList candidateTypes { info->nameOf(NameInfoType::kMimeTypeName) };
+    candidateTypes.append(mime.parentMimeTypes());
+    if (!candidateTypes.contains(Global::Mime::kTypeAppPptx)) {
         qCWarning(logDFMBase) << "thumbnail: file is not a valid PPTX file:" << filePath
-                              << "mimeType:" << (info ? info->nameOf(NameInfoType::kMimeTypeName) : "null");
+                              << "mimeTypes:" << candidateTypes;
         return QImage();
     }
 
@@ -618,3 +616,121 @@ QImage ThumbnailCreators::pptxThumbnailCreator(const QString &filePath, Thumbnai
     qCDebug(logDFMBase) << "thumbnail: no thumbnail available for PPTX file:" << filePath;
     return QImage();
 }
+
+QImage ThumbnailCreators::uabThumbnailCreator(const QString &filePath, ThumbnailSize size)
+{
+    qCDebug(logDFMBase) << "thumbnail: creating UAB thumbnail for:" << filePath << "size:" << size;
+
+    // 1. Validate file existence
+    auto info = InfoFactory::create<FileInfo>(QUrl::fromLocalFile(filePath));
+    if (!info || !info->exists()) {
+        qCWarning(logDFMBase) << "thumbnail: UAB file not found:" << filePath;
+        return QImage();
+    }
+
+    // 2. Verify file type
+    if (!info || info->nameOf(NameInfoType::kMimeTypeName) != Global::Mime::kTypeAppUab) {
+        qCWarning(logDFMBase) << "thumbnail: file is not a valid UAB file:" << filePath
+                              << "mimeType:" << (info ? info->nameOf(NameInfoType::kMimeTypeName) : "null");
+        return QImage();
+    }
+
+    // 3. Query ELF section information using readelf (read-only, no file modification)
+    QProcess readelfProcess;
+    readelfProcess.start("readelf", { "-W", "-S", filePath });
+
+    if (!readelfProcess.waitForFinished(5000)) {
+        qCWarning(logDFMBase) << "thumbnail: readelf timeout for UAB file:" << filePath;
+        readelfProcess.kill();
+        return QImage();
+    }
+
+    if (readelfProcess.exitCode() != 0) {
+        qCWarning(logDFMBase) << "thumbnail: readelf failed for UAB file:" << filePath
+                              << "stderr:" << readelfProcess.readAllStandardError();
+        return QImage();
+    }
+
+    // 4. Parse readelf output to locate linglong.icon section
+    QString readelfOutput = readelfProcess.readAllStandardOutput();
+    QStringList lines = readelfOutput.split('\n');
+
+    qint64 sectionOffset = -1;
+    qint64 sectionSize = -1;
+    bool sectionFound = false;
+
+    for (const QString &line : lines) {
+        if (line.contains("linglong.icon")) {
+            // Parse section header line format:
+            // [Nr] Name          Type     Address          Off    Size   ES Flg Lk Inf Al
+            // [26] linglong.icon PROGBITS 0000000000000000 002e30 004e20 00   0   0  1
+            QString normalizedLine = line.simplified();
+            QStringList parts = normalizedLine.split(' ', Qt::SkipEmptyParts);
+
+            // Validate column count (need at least 7 columns)
+            if (parts.size() >= 7) {
+                bool offsetOk = false, sizeOk = false;
+                sectionOffset = parts[4].toLongLong(&offsetOk, 16);   // Column 5: Offset (hex)
+                sectionSize = parts[5].toLongLong(&sizeOk, 16);   // Column 6: Size (hex)
+
+                if (offsetOk && sizeOk && sectionOffset > 0 && sectionSize > 0) {
+                    sectionFound = true;
+                    qCDebug(logDFMBase) << "thumbnail: found linglong.icon section - offset:"
+                                        << QString("0x%1").arg(sectionOffset, 0, 16)
+                                        << "size:" << sectionSize << "bytes";
+                    break;
+                }
+            }
+        }
+    }
+
+    if (!sectionFound) {
+        qCWarning(logDFMBase) << "thumbnail: linglong.icon section not found in UAB file:" << filePath;
+        return QImage();
+    }
+
+    // 5. Extract section data using QFile (read-only mode, no file modification)
+    QFile uabFile(filePath);
+    if (!uabFile.open(QIODevice::ReadOnly)) {
+        qCWarning(logDFMBase) << "thumbnail: failed to open UAB file for reading:" << filePath
+                              << "error:" << uabFile.errorString();
+        return QImage();
+    }
+
+    if (!uabFile.seek(sectionOffset)) {
+        qCWarning(logDFMBase) << "thumbnail: failed to seek to section offset:" << sectionOffset
+                              << "in file:" << filePath
+                              << "error:" << uabFile.errorString();
+        uabFile.close();
+        return QImage();
+    }
+
+    QByteArray iconData = uabFile.read(sectionSize);
+    uabFile.close();   // Close immediately to release file handle
+
+    if (iconData.size() != sectionSize) {
+        qCWarning(logDFMBase) << "thumbnail: incomplete section data read - expected:" << sectionSize
+                              << "bytes, got:" << iconData.size() << "bytes for:" << filePath;
+        return QImage();
+    }
+
+    qCDebug(logDFMBase) << "thumbnail: successfully extracted" << iconData.size()
+                        << "bytes of icon data from UAB file:" << filePath;
+
+    // 6. Load image directly from extracted data (no temporary file needed)
+    QImage icon;
+    if (!icon.loadFromData(iconData)) {
+        qCWarning(logDFMBase) << "thumbnail: failed to decode image from extracted icon data for:" << filePath;
+        return QImage();
+    }
+
+    // 7. Scale image to requested thumbnail size
+    if (icon.width() > size || icon.height() > size) {
+        icon = icon.scaled(size, size, Qt::KeepAspectRatio, Qt::SmoothTransformation);
+        qCDebug(logDFMBase) << "thumbnail: scaled UAB icon from"
+                            << icon.size() << "to fit size:" << size;
+    }
+
+    qCDebug(logDFMBase) << "thumbnail: UAB thumbnail created successfully for:" << filePath;
+    return icon;
+}

src/dfm-base/utils/thumbnail/thumbnailcreators.h

@@ -21,6 +21,7 @@ QImage imageThumbnailCreator(const QString &filePath, DFMGLOBAL_NAMESPACE::Thumb
 QImage djvuThumbnailCreator(const QString &filePath, DFMGLOBAL_NAMESPACE::ThumbnailSize size);
 QImage pdfThumbnailCreator(const QString &filePath, DFMGLOBAL_NAMESPACE::ThumbnailSize size);
 QImage appimageThumbnailCreator(const QString &filePath, DFMGLOBAL_NAMESPACE::ThumbnailSize size);
+QImage uabThumbnailCreator(const QString &filePath, DFMGLOBAL_NAMESPACE::ThumbnailSize size);
 QImage pptxThumbnailCreator(const QString &filePath, DFMGLOBAL_NAMESPACE::ThumbnailSize size);
 }   // namespace ThumbnailCreators
 }   // namespace dfmbase

src/dfm-base/utils/thumbnail/thumbnailfactory.cpp

@@ -35,6 +35,7 @@ ThumbnailFactory::ThumbnailFactory(QObject *parent)
     registerThumbnailCreator("audio/*", ThumbnailCreators::audioThumbnailCreator);
     registerThumbnailCreator("video/*", ThumbnailCreators::videoThumbnailCreator);
     registerThumbnailCreator(Mime::kTypeAppAppimage, ThumbnailCreators::appimageThumbnailCreator);
+    registerThumbnailCreator(Mime::kTypeAppUab, ThumbnailCreators::uabThumbnailCreator);
     registerThumbnailCreator(Mime::kTypeAppPptx, ThumbnailCreators::pptxThumbnailCreator);
 
     init();

src/dfm-base/utils/thumbnail/thumbnailhelper.cpp

@@ -31,6 +31,37 @@ DFMGLOBAL_USE_NAMESPACE
 
 ThumbnailHelper::ThumbnailHelper()
 {
+    initMimeTypeSupport();
+}
+
+void ThumbnailHelper::initMimeTypeSupport()
+{
+    using Strategy = SupportCheckStrategy;
+
+    // === Image types ===
+    mimeTypeSupportStrategy.insert("image/*", Strategy::kCheckImage);
+
+    // === Audio types ===
+    mimeTypeSupportStrategy.insert("audio/*", Strategy::kCheckAudio);
+
+    // === Video types ===
+    mimeTypeSupportStrategy.insert("video/*", Strategy::kCheckVideo);
+
+    // === Text types ===
+    mimeTypeSupportStrategy.insert(Mime::kTypeTextPlain, Strategy::kCheckText);
+
+    // === Document types ===
+    mimeTypeSupportStrategy.insert(Mime::kTypeAppPdf, Strategy::kCheckDocument);
+    mimeTypeSupportStrategy.insert(Mime::kTypeAppCRRMedia, Strategy::kCheckDocument);
+    mimeTypeSupportStrategy.insert(Mime::kTypeAppMxf, Strategy::kCheckDocument);
+    mimeTypeSupportStrategy.insert(Mime::kTypeAppPptx, Strategy::kCheckDocument);
+
+    // === Executable package types (unconditional icon display) ===
+    mimeTypeSupportStrategy.insert(Mime::kTypeAppAppimage, Strategy::kUnconditional);
+    mimeTypeSupportStrategy.insert(Mime::kTypeAppUab, Strategy::kUnconditional);
+
+    qCInfo(logDFMBase) << "thumbnail: initialized MIME type support strategies for"
+                       << mimeTypeSupportStrategy.size() << "types";
 }
 
 void ThumbnailHelper::initSizeLimit()
@@ -41,7 +72,7 @@ void ThumbnailHelper::initSizeLimit()
     sizeLimitHash.insert(mimeDatabase.mimeTypeForName(DFMGLOBAL_NAMESPACE::Mime::kTypeAppVRRMedia), INT64_MAX);
     sizeLimitHash.insert(mimeDatabase.mimeTypeForName(DFMGLOBAL_NAMESPACE::Mime::kTypeAppVMAsf), INT64_MAX);
     sizeLimitHash.insert(mimeDatabase.mimeTypeForName(DFMGLOBAL_NAMESPACE::Mime::kTypeAppMxf), INT64_MAX);
-    sizeLimitHash.insert(mimeDatabase.mimeTypeForName(DFMGLOBAL_NAMESPACE::Mime::kTypeAppPptx), INT64_MAX);
+    sizeLimitHash.insert(mimeDatabase.mimeTypeForName(DFMGLOBAL_NAMESPACE::Mime::kTypeAppPptx), 1024 * 1024 * 80);
 
     // images
     sizeLimitHash.insert(mimeDatabase.mimeTypeForName(DFMGLOBAL_NAMESPACE::Mime::kTypeImageIef), 1024 * 1024 * 80);
@@ -54,8 +85,8 @@ void ThumbnailHelper::initSizeLimit()
     sizeLimitHash.insert(mimeDatabase.mimeTypeForName(DFMGLOBAL_NAMESPACE::Mime::kTypeImagePipeg), 1024 * 1024 * 30);
     // High file limit size only for FLAC files.
     sizeLimitHash.insert(mimeDatabase.mimeTypeForName(DFMGLOBAL_NAMESPACE::Mime::kTypeAudioFlac), INT64_MAX);
-
     sizeLimitHash.insert(mimeDatabase.mimeTypeForName(DFMGLOBAL_NAMESPACE::Mime::kTypeAppAppimage), INT64_MAX);
+    sizeLimitHash.insert(mimeDatabase.mimeTypeForName(DFMGLOBAL_NAMESPACE::Mime::kTypeAppUab), INT64_MAX);
 
     qCInfo(logDFMBase) << "thumbnail: initialized size limits for" << sizeLimitHash.size() << "mime types";
 }
@@ -98,49 +129,71 @@ bool ThumbnailHelper::canGenerateThumbnail(const QUrl &url)
 bool ThumbnailHelper::checkMimeTypeSupport(const QMimeType &mime)
 {
     const QString &mimeName = mime.name();
-    QStringList mimeList = { mimeName };
-    mimeList.append(mime.parentMimeTypes());
-
-    auto checkStatus = [](Application::GenericAttribute attr) {
-        return Application::instance()->genericAttribute(attr).toBool();
-    };
+    QStringList candidateTypes { mimeName };
+    candidateTypes.append(mime.parentMimeTypes());
 
-    if (mimeName.startsWith("image")) {
-        bool supported = checkStatus(Application::kPreviewImage);
-        return supported;
+    // === Special check: MimeTypeDisplayManager audio/video types ===
+    // These types may not start with "audio/" or "video/" prefix
+    if (MimeTypeDisplayManager::instance()->supportAudioMimeTypes().contains(mimeName)) {
+        return Application::instance()->genericAttribute(Application::kPreviewAudio).toBool();
     }
 
-    if (mimeName.startsWith("audio")
-        || MimeTypeDisplayManager::instance()->supportAudioMimeTypes().contains(mimeName)) {
-        bool supported = checkStatus(Application::kPreviewAudio);
-        return supported;
+    if (MimeTypeDisplayManager::instance()->supportVideoMimeTypes().contains(mimeName)) {
+        return Application::instance()->genericAttribute(Application::kPreviewVideo).toBool();
     }
 
-    if (mimeName.startsWith("video")
-        || MimeTypeDisplayManager::instance()->supportVideoMimeTypes().contains(mimeName)) {
-        bool supported = checkStatus(Application::kPreviewVideo);
-        return supported;
-    }
+    // === Find matching strategy ===
+    SupportCheckStrategy strategy;
+    bool found = false;
+
+    for (const QString &type : candidateTypes) {
+        // 1. Exact match
+        if (mimeTypeSupportStrategy.contains(type)) {
+            strategy = mimeTypeSupportStrategy.value(type);
+            found = true;
+            break;
+        }
 
-    if (mimeName == Mime::kTypeTextPlain) {
-        bool supported = checkStatus(Application::kPreviewTextFile);
-        return supported;
+        // 2. Wildcard match (e.g., image/*, audio/*, video/*)
+        QString prefix = type.section('/', 0, 0);
+        QString wildcardPattern = prefix + "/*";
+        if (mimeTypeSupportStrategy.contains(wildcardPattern)) {
+            strategy = mimeTypeSupportStrategy.value(wildcardPattern);
+            found = true;
+            break;
+        }
     }
 
-    if (Q_LIKELY(mimeList.contains(Mime::kTypeAppPdf)
-                 || mimeName == Mime::kTypeAppCRRMedia
-                 || mimeName == Mime::kTypeAppMxf)
-        || mimeList.contains(Mime::kTypeAppPptx)) {
-        bool supported = checkStatus(Application::kPreviewDocumentFile);
-        return supported;
+    if (!found) {
+        return false;
     }
 
-    // appimage is executable package, should display icon
-    if (mimeName == Mime::kTypeAppAppimage) {
+    // === Evaluate strategy ===
+    return evaluateStrategy(strategy);
+}
+
+bool ThumbnailHelper::evaluateStrategy(SupportCheckStrategy strategy)
+{
+    auto checkAttribute = [](Application::GenericAttribute attr) {
+        return Application::instance()->genericAttribute(attr).toBool();
+    };
+
+    switch (strategy) {
+    case SupportCheckStrategy::kUnconditional:
         return true;
+    case SupportCheckStrategy::kCheckImage:
+        return checkAttribute(Application::kPreviewImage);
+    case SupportCheckStrategy::kCheckAudio:
+        return checkAttribute(Application::kPreviewAudio);
+    case SupportCheckStrategy::kCheckVideo:
+        return checkAttribute(Application::kPreviewVideo);
+    case SupportCheckStrategy::kCheckText:
+        return checkAttribute(Application::kPreviewTextFile);
+    case SupportCheckStrategy::kCheckDocument:
+        return checkAttribute(Application::kPreviewDocumentFile);
+    default:
+        return false;
     }
-
-    return false;
 }
 
 void ThumbnailHelper::makePath(const QString &path)