chore: enhance logging and error handling in file manager components

src/apps/dde-file-manager/dragmonitor.cpp

@@ -70,7 +70,6 @@ bool DragMoniter::eventFilter(QObject *watched, QEvent *event)
             }
 
             if (!str.isEmpty()) {
-                qCDebug(logAppFileManager) << "DragMoniter::eventFilter: Drag enter event with" << str.size() << "URLs";
                 QMetaObject::invokeMethod(this, "DragEnter", Qt::QueuedConnection, Q_ARG(QStringList, str));
             }
         }

src/plugins/filemanager/dfmplugin-workspace/menus/basesortmenuscene.cpp

@@ -29,6 +29,13 @@ BaseSortMenuScenePrivate::BaseSortMenuScenePrivate(BaseSortMenuScene *qq)
 
 void BaseSortMenuScenePrivate::sortMenuActions(QMenu *menu, const QStringList &sortRule, bool isFuzzy)
 {
+    if (!menu) {
+        fmWarning() << "Cannot sort menu actions: menu is null";
+        return;
+    }
+
+    fmDebug() << "Sorting menu actions with" << sortRule.size() << "rules, fuzzy matching:" << isFuzzy;
+
     auto findIndex = [&isFuzzy, &sortRule](const QString &property) {
         int index1 = -1;
         for (int i = 0, nEnd = sortRule.size(); i < nEnd; ++i) {
@@ -89,18 +96,29 @@ void BaseSortMenuScenePrivate::sortMenuActions(QMenu *menu, const QStringList &s
     }
 
     menu->addActions(actions);
+    fmDebug() << "Menu actions sorted successfully," << actions.size() << "actions added to menu";
 }
 
 void BaseSortMenuScenePrivate::sortPrimaryMenu(QMenu *menu)
 {
+    if (!menu) {
+        fmWarning() << "Cannot sort primary menu: menu is null";
+        return;
+    }
+
+    fmDebug() << "Sorting primary menu";
     const QStringList &sortRule = primaryMenuRule();
     sortMenuActions(menu, sortRule, false);
 }
 
 void BaseSortMenuScenePrivate::sortSecondaryMenu(QMenu *menu)
 {
-    const QMap<QString, QStringList> &sortRuleMap = secondaryMenuRule();
+    if (!menu) {
+        fmWarning() << "Cannot sort secondary menu: menu is null";
+        return;
+    }
 
+    const QMap<QString, QStringList> &sortRuleMap = secondaryMenuRule();
     auto actions = menu->actions();
     for (QAction *action : actions) {
         QMenu *secondaryMenu = action->menu();
@@ -145,6 +163,7 @@ QStringList BaseSortMenuScenePrivate::primaryMenuRule()
     static std::once_flag flag;
 
     std::call_once(flag, [&]() {
+        fmDebug() << "Initializing primary menu rules";
         // file
         ret.append("open");   // 打开
         ret.append("open-file-location");   // 打开文件所在位置
@@ -209,6 +228,7 @@ QStringList BaseSortMenuScenePrivate::primaryMenuRule()
         ret.append(ActionID::kSeparatorLine);
 
         ret.append("property");
+        fmDebug() << "Primary menu rules initialized with" << ret.size() << "rules";
     });
 
     return ret;
@@ -220,6 +240,7 @@ QMap<QString, QStringList> BaseSortMenuScenePrivate::secondaryMenuRule()
     static std::once_flag flag;
 
     std::call_once(flag, [&]() {
+        fmDebug() << "Initializing secondary menu rules";
         // file
         ret.insert("open-with",
                    QStringList { "open-with-app",
@@ -261,6 +282,7 @@ QMap<QString, QStringList> BaseSortMenuScenePrivate::secondaryMenuRule()
 
         ret.insert("send-to",
                    sendToList);   // 发送到
+        fmDebug() << "Secondary menu rules initialized with" << ret.size() << "rule groups";
     });
 
     return ret;
@@ -269,10 +291,12 @@ QMap<QString, QStringList> BaseSortMenuScenePrivate::secondaryMenuRule()
 BaseSortMenuScene::BaseSortMenuScene(QObject *parent)
     : AbstractMenuScene(parent), d(new BaseSortMenuScenePrivate(this))
 {
+    fmDebug() << "BaseSortMenuScene initialized";
 }
 
 BaseSortMenuScene::~BaseSortMenuScene()
 {
+    fmDebug() << "BaseSortMenuScene destroyed";
 }
 
 QString BaseSortMenuScene::name() const
@@ -292,13 +316,25 @@ bool BaseSortMenuScene::create(QMenu *parent)
 
 void BaseSortMenuScene::updateState(QMenu *parent)
 {
+    if (!parent) {
+        fmWarning() << "Cannot update state: parent menu is null";
+        return;
+    }
+
+    fmDebug() << "Updating BaseSortMenuScene state";
     d->sortPrimaryMenu(parent);
     d->sortSecondaryMenu(parent);
     AbstractMenuScene::updateState(parent);
+    fmDebug() << "BaseSortMenuScene state update completed";
 }
 
 bool BaseSortMenuScene::triggered(QAction *action)
 {
+    if (!action) {
+        fmWarning() << "Cannot trigger action: action is null";
+        return false;
+    }
+
     return AbstractMenuScene::triggered(action);
 }
 

src/plugins/filemanager/dfmplugin-workspace/menus/sortanddisplaymenuscene.cpp

@@ -7,12 +7,13 @@
 #include "workspacemenu_defines.h"
 #include "views/fileview.h"
 #include "models/fileviewmodel.h"
 #include "utils/workspacehelper.h"
 #include "events/workspaceeventcaller.h"
 
+#include <dfm-base/dfm_log_defines.h>
 #include <dfm-base/dfm_menu_defines.h>
 #include <dfm-base/dfm_global_defines.h>
 #include <dfm-base/dfm_event_defines.h>
 #include <dfm-base/base/configs/dconfig/dconfigmanager.h>
 
 #include <dfm-framework/dpf.h>
@@ -27,12 +28,14 @@
 
 AbstractMenuScene *SortAndDisplayMenuCreator::create()
 {
+    fmDebug() << "Creating SortAndDisplayMenuScene instance";
     return new SortAndDisplayMenuScene();
 }
 
 SortAndDisplayMenuScene::SortAndDisplayMenuScene(QObject *parent)
     : AbstractMenuScene(parent), d(new SortAndDisplayMenuScenePrivate(this))
 {
+    fmDebug() << "SortAndDisplayMenuScene initialized";
     d->predicateName[ActionID::kSortBy] = tr("Sort by");
     d->predicateName[ActionID::kDisplayAs] = tr("Display as");
 
@@ -51,6 +54,7 @@
 
 SortAndDisplayMenuScene::~SortAndDisplayMenuScene()
 {
+    fmDebug() << "SortAndDisplayMenuScene destroyed";
 }
 
 QString SortAndDisplayMenuScene::name() const
@@ -62,8 +66,16 @@
 {
     d->windowId = params.value(MenuParamKey::kWindowId).toULongLong();
     d->isEmptyArea = params.value(MenuParamKey::kIsEmptyArea).toBool();
-    if (d->isEmptyArea)
+
+    fmDebug() << "Initializing SortAndDisplayMenuScene - windowId:" << d->windowId
+              << "isEmptyArea:" << d->isEmptyArea;
+
+    if (d->isEmptyArea) {
+        fmDebug() << "SortAndDisplayMenuScene initialization successful for empty area";
         return AbstractMenuScene::initialize(params);
+    }
+
+    fmDebug() << "SortAndDisplayMenuScene initialization skipped - not empty area";
     return false;
 }
 
@@ -80,40 +92,59 @@
 
 bool SortAndDisplayMenuScene::create(QMenu *parent)
 {
+    if (!parent) {
+        fmWarning() << "Cannot create SortAndDisplayMenuScene: parent menu is null";
+        return false;
+    }
+
+    fmDebug() << "Creating sort and display menu";
     d->view = qobject_cast<FileView *>(parent->parent());
     d->createEmptyMenu(parent);
     return AbstractMenuScene::create(parent);
 }
 
 void SortAndDisplayMenuScene::updateState(QMenu *parent)
 {
+    fmDebug() << "Updating sort and display menu state";
     d->updateEmptyAreaActionState();
     AbstractMenuScene::updateState(parent);
 }
 
 bool SortAndDisplayMenuScene::triggered(QAction *action)
 {
-    if (!d->view)
+    if (!action) {
+        fmWarning() << "Cannot trigger action: action is null";
         return false;
+    }
+
+    if (!d->view) {
+        fmWarning() << "Cannot trigger action: view is null";
+        return false;
+    }
 
     const auto &actionId = action->property(ActionPropertyKey::kActionID).toString();
+    fmDebug() << "Action triggered in SortAndDisplayMenuScene:" << actionId;
+
     if (d->predicateAction.values().contains(action)) {
         // display as
         {
             // display as icon
             if (actionId == ActionID::kDisplayIcon) {
+                fmInfo() << "Switching to icon view mode";
                 WorkspaceEventCaller::sendViewModeChanged(d->windowId, DFMGLOBAL_NAMESPACE::ViewMode::kIconMode);
                 return true;
             }
 
             // display as list
             if (actionId == ActionID::kDisplayList) {
+                fmInfo() << "Switching to list view mode";
                 WorkspaceEventCaller::sendViewModeChanged(d->windowId, DFMGLOBAL_NAMESPACE::ViewMode::kListMode);
                 return true;
             }
 
             // display as tree
             if (actionId == ActionID::kDisplayTree) {
+                fmInfo() << "Switching to tree view mode";
                 WorkspaceEventCaller::sendViewModeChanged(d->windowId, DFMGLOBAL_NAMESPACE::ViewMode::kTreeMode);
                 return true;
             }
@@ -123,30 +154,35 @@
         {
             // sort by name
             if (actionId == ActionID::kSrtName) {
+                fmInfo() << "Sorting by name";
                 d->sortByRole(Global::ItemRoles::kItemFileDisplayNameRole);
                 return true;
             }
 
             // sort by time modified
             if (actionId == ActionID::kSrtTimeModified) {
+                fmInfo() << "Sorting by time modified";
                 d->sortByRole(Global::ItemRoles::kItemFileLastModifiedRole);
                 return true;
             }
 
             // sort by time created
             if (actionId == ActionID::kSrtTimeCreated) {
+                fmInfo() << "Sorting by time created";
                 d->sortByRole(Global::ItemRoles::kItemFileCreatedRole);
                 return true;
             }
 
             // sort by size
             if (actionId == ActionID::kSrtSize) {
+                fmInfo() << "Sorting by size";
                 d->sortByRole(Global::ItemRoles::kItemFileSizeRole);
                 return true;
             }
 
             // sort by type
             if (actionId == ActionID::kSrtType) {
+                fmInfo() << "Sorting by type";
                 d->sortByRole(Global::ItemRoles::kItemFileMimeTypeRole);
                 return true;
             }
@@ -163,6 +199,13 @@
 
 void SortAndDisplayMenuScenePrivate::createEmptyMenu(QMenu *parent)
 {
+    if (!parent) {
+        fmWarning() << "Cannot create empty menu: parent is null";
+        return;
+    }
+
+    fmDebug() << "Creating empty area menu with sort and display options";
+
     QAction *tempAction = parent->addAction(predicateName.value(ActionID::kDisplayAs));
     tempAction->setMenu(addDisplayAsActions(parent));
     predicateAction[ActionID::kDisplayAs] = tempAction;
@@ -172,10 +215,13 @@
     tempAction->setMenu(addSortByActions(parent));
     predicateAction[ActionID::kSortBy] = tempAction;
     tempAction->setProperty(ActionPropertyKey::kActionID, QString(ActionID::kSortBy));
+
+    fmDebug() << "Empty area menu created with" << predicateAction.size() << "main actions";
 }
 
 QMenu *SortAndDisplayMenuScenePrivate::addSortByActions(QMenu *menu)
 {
+    fmDebug() << "Adding sort by actions to submenu";
     QMenu *subMenu = new QMenu(menu);
 
     // SortBy
@@ -209,6 +255,7 @@
 
 QMenu *SortAndDisplayMenuScenePrivate::addDisplayAsActions(QMenu *menu)
 {
+    fmDebug() << "Adding display as actions to submenu";
     QMenu *subMenu = new QMenu(menu);
 
     // DisplayAs
@@ -242,14 +289,19 @@
             : order == Qt::AscendingOrder ? Qt::DescendingOrder
                                           : Qt::AscendingOrder;
 
+    fmDebug() << "Sorting by role:" << role << "order:" << (order == Qt::AscendingOrder ? "Ascending" : "Descending")
+              << "old role:" << oldRole;
+
     view->setSort(itemRole, order);
 }
 
 void SortAndDisplayMenuScenePrivate::updateEmptyAreaActionState()
 {
+    fmDebug() << "Updating empty area action state";
     using namespace Global;
     // sort  by
     auto role = static_cast<ItemRoles>(view->model()->sortRole());
+    fmDebug() << "Current sort role:" << role;
     switch (role) {
     case kItemFileDisplayNameRole:
         predicateAction[ActionID::kSrtName]->setChecked(true);
@@ -272,6 +324,7 @@
 
     // display as
     auto mode = view->currentViewMode();
+    fmDebug() << "Current view mode:" << static_cast<int>(mode);
     switch (mode) {
     case Global::ViewMode::kIconMode:
         predicateAction[ActionID::kDisplayIcon]->setChecked(true);