File indexing completed on 2024-04-28 03:54:38

 /* This file is part of the KDE libraries
    SPDX-FileCopyrightText: 2009 Dario Freddi <drf at kde.org>
 
    SPDX-License-Identifier: LGPL-2.1-or-later
 */
 
 // Exceptionnally, include QCoreApplication before our own header, because that one includes X11 headers (#define None...)
 #include <QCoreApplication>
 
 #include "xsync_logging.h"
 
 #include "xsyncbasedpoller.h"
 
 #include <QAbstractNativeEventFilter>
 #include <QGuiApplication>
 
 #include <X11/Xlib-xcb.h> // XGetXCBConnection
 #include <xcb/sync.h>
 
 class XSyncBasedPollerHelper : public QAbstractNativeEventFilter
 {
 public:
     XSyncBasedPollerHelper()
         : q(nullptr)
         , isActive(false)
     {
     }
     ~XSyncBasedPollerHelper() override
     {
         delete q;
     }
     bool nativeEventFilter(const QByteArray &eventType, void *message, qintptr *result) override
     {
         Q_UNUSED(result);
         if (isActive && eventType == "xcb_generic_event_t") {
             q->xcbEvent(reinterpret_cast<xcb_generic_event_t *>(message));
         }
         return false;
     }
     XSyncBasedPoller *q;
     bool isActive;
 };
 
 Q_GLOBAL_STATIC(XSyncBasedPollerHelper, s_globalXSyncBasedPoller)
 
 XSyncBasedPoller *XSyncBasedPoller::instance()
 {
     if (!s_globalXSyncBasedPoller()->q) {
         new XSyncBasedPoller;
     }
 
     return s_globalXSyncBasedPoller()->q;
 }
 
 XSyncBasedPoller::XSyncBasedPoller(QObject *parent)
     : KAbstractIdleTimePoller(parent)
     , m_display(qGuiApp->nativeInterface<QNativeInterface::QX11Application>()->display())
     , m_xcb_connection(nullptr)
     , m_sync_event(0)
     , m_idleCounter(None)
     , m_resetAlarm(None)
     , m_available(true)
 {
     Q_ASSERT(!s_globalXSyncBasedPoller()->q);
     s_globalXSyncBasedPoller()->q = this;
 
     if (Q_UNLIKELY(!m_display)) {
         m_available = false;
         qCWarning(KIDLETIME_XSYNC_PLUGIN) << "xcb sync could not find display";
         return;
     }
     m_xcb_connection = XGetXCBConnection(m_display);
 
     QCoreApplication::instance()->installNativeEventFilter(s_globalXSyncBasedPoller());
 
     const xcb_query_extension_reply_t *sync_reply = xcb_get_extension_data(m_xcb_connection, &xcb_sync_id);
     if (!sync_reply || !sync_reply->present) {
         qCWarning(KIDLETIME_XSYNC_PLUGIN) << "xcb sync extension not found";
         m_available = false;
         return;
     }
     m_sync_event = sync_reply->first_event;
 
 #if 0
 
     // Workaround for https://bugs.freedesktop.org/show_bug.cgi?id=23403
 #define xcb_sync_systemcounter_name(sc) (((char *)&(sc)->name_len) + 2)
 
     xcb_sync_list_system_counters_cookie_t cookie = xcb_sync_list_system_counters(m_xcb_connection);
     xcb_sync_list_system_counters_reply_t *reply = xcb_sync_list_system_counters_reply(m_xcb_connection, cookie, NULL);
 
     xcb_sync_systemcounter_iterator_t iter;
     for (iter = xcb_sync_list_system_counters_counters_iterator(reply);
             iter.rem; xcb_sync_systemcounter_next(&iter)) {
         printf("%d: %.*s\n", iter.data->counter,
                iter.data->name_len, xcb_sync_systemcounter_name(iter.data));
         /* Extra info for debugging: */
         printf("  Actual name: %.*s\n", iter.data->name_len,
                ((char *) &iter.data->name_len) + 2);
     }
 
     int xcbcounters = xcb_sync_list_system_counters_counters_length(reply);
     xcb_sync_systemcounter_iterator_t it = xcb_sync_list_system_counters_counters_iterator(reply);
     for (int i = 0; i < xcbcounters; ++i) {
         qCDebug(KIDLETIME_XSYNC_PLUGIN) << it.data->counter << it.rem << it.index;
         qCDebug(KIDLETIME_XSYNC_PLUGIN) << "name length" << xcb_sync_systemcounter_name_length(it.data);
         QByteArray name(xcb_sync_systemcounter_name(it.data), xcb_sync_systemcounter_name_length(it.data));
         qCDebug(KIDLETIME_XSYNC_PLUGIN) << name;
         xcb_sync_systemcounter_next(&it);
     }
     delete reply;
 #endif
 
     int sync_major;
     int sync_minor;
     int old_sync_event;
     int old_sync_error;
     if (!XSyncQueryExtension(m_display, &old_sync_event, &old_sync_error)) {
         m_available = false;
         return;
     }
 
     if (!XSyncInitialize(m_display, &sync_major, &sync_minor)) {
         m_available = false;
         return;
     }
 
     int ncounters;
     XSyncSystemCounter *counters = XSyncListSystemCounters(m_display, &ncounters);
 
     bool idleFound = false;
 
     qCDebug(KIDLETIME_XSYNC_PLUGIN) << ncounters << "counters";
     for (int i = 0; i < ncounters; ++i) {
         qCDebug(KIDLETIME_XSYNC_PLUGIN) << counters[i].name << counters[i].counter;
         if (!strcmp(counters[i].name, "IDLETIME")) {
             m_idleCounter = counters[i].counter;
             idleFound = true;
             break;
         }
     }
 
     XSyncFreeSystemCounterList(counters);
 
     if (!idleFound) {
         m_available = false;
     }
 
     if (m_available) {
         qCDebug(KIDLETIME_XSYNC_PLUGIN) << "XSync seems available and ready";
     } else {
         qCDebug(KIDLETIME_XSYNC_PLUGIN) << "XSync seems not available";
     }
 }
 
 XSyncBasedPoller::~XSyncBasedPoller()
 {
 }
 
 bool XSyncBasedPoller::isAvailable()
 {
     return m_available;
 }
 
 bool XSyncBasedPoller::setUpPoller()
 {
     if (!isAvailable()) {
         return false;
     }
 
     qCDebug(KIDLETIME_XSYNC_PLUGIN) << "XSync Inited";
 
     s_globalXSyncBasedPoller()->isActive = true;
 
     qCDebug(KIDLETIME_XSYNC_PLUGIN) << "Supported, init completed";
 
     return true;
 }
 
 void XSyncBasedPoller::unloadPoller()
 {
     s_globalXSyncBasedPoller()->isActive = false;
 }
 
 void XSyncBasedPoller::addTimeout(int nextTimeout)
 {
     /* We need to set the counter to the idle time + the value
      * requested for next timeout
      */
 
     // If there's already an alarm for the requested timeout, skip
     if (m_timeoutAlarm.contains(nextTimeout)) {
         return;
     }
 
     XSyncValue timeout;
     XSyncAlarm newalarm = None;
 
     XSyncIntToValue(&timeout, nextTimeout);
 
     setAlarm(m_display, &newalarm, m_idleCounter, XSyncPositiveComparison, timeout);
 
     m_timeoutAlarm.insert(nextTimeout, newalarm);
 }
 
 int XSyncBasedPoller::forcePollRequest()
 {
     return poll();
 }
 
 int XSyncBasedPoller::poll()
 {
     XSyncValue idleTime;
     XSyncQueryCounter(m_display, m_idleCounter, &idleTime);
 
     return XSyncValueLow32(idleTime);
 }
 
 void XSyncBasedPoller::removeTimeout(int timeout)
 {
     if (m_timeoutAlarm.contains(timeout)) {
         XSyncAlarm a = m_timeoutAlarm[timeout];
         XSyncDestroyAlarm(m_display, a);
         m_timeoutAlarm.remove(timeout);
     }
 }
 
 QList<int> XSyncBasedPoller::timeouts() const
 {
     return m_timeoutAlarm.keys();
 }
 
 void XSyncBasedPoller::stopCatchingIdleEvents()
 {
     if (m_resetAlarm != None) {
         XSyncDestroyAlarm(m_display, m_resetAlarm);
         m_resetAlarm = None;
     }
 }
 
 void XSyncBasedPoller::catchIdleEvent()
 {
     XSyncValue idleTime;
 
     XSyncQueryCounter(m_display, m_idleCounter, &idleTime);
 
     /* Set the reset alarm to fire the next time idleCounter < the
      * current counter value. XSyncNegativeComparison means <= so
      * we have to subtract 1 from the counter value
      */
 
     // NOTE: this must be a int, else compilation might fail
     int overflow;
     XSyncValue add;
     XSyncValue plusone;
     XSyncIntToValue(&add, -1);
     XSyncValueAdd(&plusone, idleTime, add, &overflow);
     setAlarm(m_display, &m_resetAlarm, m_idleCounter, XSyncNegativeComparison, plusone);
 }
 
 void XSyncBasedPoller::reloadAlarms()
 {
     XSyncValue timeout;
 
     for (QHash<int, XSyncAlarm>::iterator i = m_timeoutAlarm.begin(); i != m_timeoutAlarm.end(); ++i) {
         XSyncIntToValue(&timeout, i.key());
 
         setAlarm(m_display, &(i.value()), m_idleCounter, XSyncPositiveComparison, timeout);
     }
 }
 
 bool XSyncBasedPoller::xcbEvent(xcb_generic_event_t *event)
 {
     // qCDebug(KIDLETIME_XSYNC_PLUGIN) << event->response_type << "waiting for" << m_sync_event+XCB_SYNC_ALARM_NOTIFY;
     if (event->response_type != m_sync_event + XCB_SYNC_ALARM_NOTIFY) {
         return false;
     }
 
     xcb_sync_alarm_notify_event_t *alarmEvent = reinterpret_cast<xcb_sync_alarm_notify_event_t *>(event);
 
     if (alarmEvent->state == XCB_SYNC_ALARMSTATE_DESTROYED) {
         return false;
     }
 
     for (QHash<int, XSyncAlarm>::const_iterator i = m_timeoutAlarm.constBegin(); i != m_timeoutAlarm.constEnd(); ++i) {
         if (alarmEvent->alarm == i.value()) {
             /* Bling! Caught! */
             Q_EMIT timeoutReached(i.key());
             // Update the alarm to fire back if the system gets inactive for the same time
             catchIdleEvent();
             return false;
         }
     }
 
     if (alarmEvent->alarm == m_resetAlarm) {
         /* Resuming from idle here! */
         stopCatchingIdleEvents();
         reloadAlarms();
         Q_EMIT resumingFromIdle();
     }
 
     return false;
 }
 
 void XSyncBasedPoller::setAlarm(Display *dpy, XSyncAlarm *alarm, XSyncCounter counter, XSyncTestType test, XSyncValue value)
 {
     XSyncAlarmAttributes attr;
     XSyncValue delta;
     unsigned int flags;
 
     XSyncIntToValue(&delta, 0);
 
     attr.trigger.counter = counter;
     attr.trigger.value_type = XSyncAbsolute;
     attr.trigger.test_type = test;
     attr.trigger.wait_value = value;
     attr.delta = delta;
 
     flags = XSyncCACounter | XSyncCAValueType | XSyncCATestType | XSyncCAValue | XSyncCADelta;
 
     if (*alarm) {
         // xcb_sync_change_alarm_checked(m_xcb_connection, alarmId,  ...
         XSyncChangeAlarm(dpy, *alarm, flags, &attr);
     } else {
         *alarm = XSyncCreateAlarm(dpy, flags, &attr);
         qCDebug(KIDLETIME_XSYNC_PLUGIN) << "Created alarm" << *alarm;
     }
 
     XFlush(m_display);
 }
 
 void XSyncBasedPoller::simulateUserActivity()
 {
     XResetScreenSaver(m_display);
     XFlush(m_display);
 }
 
 #include "moc_xsyncbasedpoller.cpp"