refactor: use GCancellable for timer cancellation (#202)

* refactor: use GCancellable for timer cancellation

- Replace std::atomic<bool> stop_timer_ with GCancellable* cancellable_
- Add cancellable_wait helper function for polling cancellation with timeout
- Refactor timer_worker loop to use cancellable_wait instead of sleep loop
- Include necessary <gio/gio.h> header
- Adjust Qt header order in main.cpp for compilation error

This change improves cancellation responsiveness and reduces CPU usage
by leveraging GLib's cancellation mechanism.

Bug: https://pms.uniontech.com/bug-view-339241.html

* chore: Update version to 7.0.36

As title.

Log: Update version to 7.0.36

Author: wangrong1069

debian/changelog

@@ -1,3 +1,10 @@
+deepin-anything (7.0.36) unstable; urgency=medium
+
+  * fix: Fix sw64 gcc not support pie by default
+  * refactor: use GCancellable for timer cancellation
+
+ -- wangrong <wangrong@uniontech.com>  Tue, 06 Jan 2026 13:20:26 +0800
+
 deepin-anything (7.0.35) unstable; urgency=medium
 
   * refactor: Refactor and improve configuration loading and path handling

src/daemon/include/core/base_event_handler.h

@@ -8,6 +8,7 @@
 
 #include <filesystem>
 #include <glib.h>
+#include <gio/gio.h>
 
 #include "common/anything_fwd.hpp"
 #include "common/fs_event.h"
@@ -88,7 +89,7 @@ class base_event_handler
     std::vector<std::string> pending_paths_;
     std::vector<anything::index_job> jobs_;
     anything::thread_pool pool_;
-    std::atomic<bool> stop_timer_;
+    GCancellable *cancellable_;
     std::mutex jobs_mtx_;
     std::mutex pending_mtx_;
     std::thread timer_;

src/daemon/src/core/base_event_handler.cpp

@@ -17,7 +17,7 @@ base_event_handler::base_event_handler(const event_handler_config &config)
       index_manager_(config_.persistent_index_dir, config_.volatile_index_dir, config_.file_type_mapping),
       batch_size_(200),
       pool_(1),
-      stop_timer_(false),
+      cancellable_(g_cancellable_new()),
       delay_mode_(true/*index_manager_.indexed()*/),
       index_dirty_(false),
       volatile_index_dirty_(false),
@@ -34,10 +34,11 @@ base_event_handler::base_event_handler(const event_handler_config &config)
 }
 
 base_event_handler::~base_event_handler() {
+    g_object_unref(cancellable_);
 }
 
 void base_event_handler::terminate_processing() {
-    stop_timer_ = true;
+    g_cancellable_cancel(cancellable_);
     stop_scan_directory_ = true;
 
     if (timer_.joinable()) {
@@ -276,19 +277,54 @@ void base_event_handler::jobs_push(std::string src,
     }
 }
 
+// Returns: TRUE if the cancellable was cancelled, FALSE if it timed out.
+static gboolean
+cancellable_wait(GCancellable *cancellable, int cancellable_fd, gint timeout_ms)
+{
+    if (g_cancellable_is_cancelled(cancellable)) {
+        return TRUE;
+    }
+
+    if (cancellable_fd == -1) {
+        if (timeout_ms >= 0) {
+            g_usleep(timeout_ms * 1000);
+        }
+        return g_cancellable_is_cancelled(cancellable);
+    }
+
+    GPollFD pfd;
+    pfd.fd = cancellable_fd;
+    pfd.events = G_IO_IN;
+    pfd.revents = 0;
+
+    int ret = g_poll(&pfd, 1, timeout_ms);
+
+    if (ret > 0) {
+        // cancel event
+        if (pfd.revents & G_IO_IN) {
+            return TRUE;
+        }
+    } else if (ret == 0) {
+        // timeout
+        ;
+    } else {
+        // error
+        spdlog::warn("g_poll() returned an error: %s", g_strerror(errno));
+        if (timeout_ms >= 0) {
+            g_usleep(timeout_ms * 1000);
+        }
+    } 
+    
+    return g_cancellable_is_cancelled(cancellable);
+}
+
 void base_event_handler::timer_worker(int64_t interval) {
     // When pending_batch_size is small, CPU usage is low, but total indexing time is longer.
     // When pending_batch_size is large, CPU usage is high, but total indexing time is shorter.
     constexpr std::size_t pending_batch_size = 20000;
-    while(!stop_timer_) {
-        // {
-        //     std::lock_guard<std::mutex> lock(jobs_mtx_);
-        //     if (!jobs_.empty()) {
-        //         eat_jobs(jobs_, std::min(batch_size_, jobs_.size()));
-        //     }
-        // }
-        // std::this_thread::sleep_for(std::chrono::milliseconds(interval));
+    int cancellable_fd = g_cancellable_get_fd(cancellable_);
 
+    while(!cancellable_wait(cancellable_, cancellable_fd, (gint)interval)) {
         bool idle = false;
         {
             std::lock_guard<std::mutex> lock(jobs_mtx_);
@@ -379,8 +415,10 @@ void base_event_handler::timer_worker(int64_t interval) {
                 set_index_invalid_and_restart();
             }
         }
+    }
 
-        std::this_thread::sleep_for(std::chrono::milliseconds(interval));
+    if (cancellable_fd != -1) {
+        g_cancellable_release_fd(cancellable_);
     }
 }
 

src/daemon/src/main.cpp

@@ -5,12 +5,13 @@
 
 #include <unistd.h>
 #include <pwd.h>
-#include <QCoreApplication>
-#include <QTimer>
 
 #include "anything.hpp"
 #include "core/config.h"
 
+#include <QTimer>
+#include <QCoreApplication>
+
 using namespace anything;
 
 // 判断 uid 是否可登录