hotplugmanager.h

Go to the documentation of this file.

/*
    Hot Plug Manager Class Header File
 
    Copyright (C) 2026 Jasem Mutlaq ([email protected])
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
 
#pragma once
 
#include "hotplugcapabledevice.h"
#include "inditimer.h"
#include <memory>
#include <vector>
#include <mutex>
#include <map>
#include <atomic>   // For std::atomic_bool
#include <chrono>   // For std::chrono::steady_clock::time_point
 
#ifdef HAVE_UDEV
#include <libudev.h> // For udev hotplugging
#endif
 
namespace INDI
{
 
class HotPlugManager
{
    private:
        HotPlugManager(); // Private constructor for singleton
        ~HotPlugManager(); // Private destructor
 
    public:
        // Delete copy constructor and assignment operator to prevent copying
        HotPlugManager(const HotPlugManager &) = delete;
        HotPlugManager &operator=(const HotPlugManager &) = delete;
 
        static HotPlugManager &getInstance();
 
        static const char* getDeviceName()
        {
            return "HotPlugManager";
        }
 
        void registerHandler(std::shared_ptr<HotPlugCapableDevice> handler);
 
        void unregisterHandler(std::shared_ptr<HotPlugCapableDevice> handler);
 
        void start(uint32_t intervalMs, bool oneShot = false);
 
        void stop();
 
        void setNonUdevPollingDuration(int seconds);
 
        void setInitialPollingDuration(int seconds);
 
    private:
        void checkHotPlugEvents();
        bool initUdev();
        void deinitUdev();
 
        void handleUdevEvent(int fd);
 
        static void udevCallbackWrapper(int fd, void* userdata);
 
        std::vector<std::shared_ptr<HotPlugCapableDevice>> registeredHandlers;
        INDI::Timer hotPlugTimer;
        std::recursive_mutex handlersMutex; // Mutex to protect access to registeredHandlers
 
#ifdef HAVE_UDEV
        udev* udevContext;
        udev_monitor* udevMonitor;
        int udevCallbackId;  // Callback ID for event loop
#endif
        std::atomic_int pollingCount;
        std::atomic_bool oneShotMode;
        std::chrono::steady_clock::time_point nonUdevPollingStartTime;
        std::atomic_int nonUdevPollingDurationSeconds;  // Configurable max duration for non-udev polling (-1 = default 60s, 0 = unlimited)
        std::atomic_int initialPollingDurationSeconds;  // Configurable max duration for initial polling with udev (-1 = default 5s)
        std::atomic_bool udevEventReceived;
        INDI::Timer mainThreadDebounceTimer;
};
 
} // namespace INDI