ModuleRegistry.h

Go to the documentation of this file.

#pragma once
 
#include "cdc_core/IModule.h"
#include <cstdint>
#include <cstddef>
 
namespace cdc::core {

// Module initializer function type
using ModuleInitFunc = void(*)();

enum class ModuleStartFailure {
    SlotError,      
    UsbBudgetFull,  
    Generic,        
};
 
class ModuleRegistry {
public:
    static constexpr uint8_t MAX_MODULES = 16;
    static constexpr uint8_t MAX_MENU_ITEMS = 32;
    static constexpr uint8_t MAX_INITIALIZERS = 16;
 
    static ModuleRegistry& instance();

    void registerInitializer(ModuleInitFunc initFunc);

    void runAllInitializers();

    static constexpr const char* NVS_PREFIX = "mod_";

    bool registerModule(IModule* module);

    void unregisterModule(const char* name);

    IModule* getModule(const char* name);

    bool initAll();

    bool startAll();

    bool startModule(uint8_t index);

    ModuleStartFailure classifyStartFailure(uint8_t index) const;

    void stopAll();

    uint8_t getMenuItems(MenuLocation location, ModuleMenuItem* items, uint8_t maxItems);

    uint8_t getLockScreenContextItems(LockScreenContextItem* items, uint8_t maxItems);

    uint8_t getModuleCount() const { return count_; }

    IModule* getModuleAt(uint8_t index);
 
    // Event dispatch to all modules
    void dispatchUnlock();
    void dispatchLock();
    void dispatchUsbConnect();
    void dispatchUsbDisconnect();
    void dispatchTick(uint32_t nowMs);

    const char* getModuleStatusLabel(uint8_t index) const;

    bool isModuleEnabled(uint8_t index) const;

    bool isModuleEnabledByName(const char* name) const;

    void setModuleEnabled(uint8_t index, bool enabled);

    bool toggleModuleEnabled(uint8_t index);

    bool hasModuleSlotError(uint8_t index) const;

    const char* getModuleSlotError(uint8_t index) const;

    void reportModuleError(const char* name, const char* message);

    void clearModuleErrorByName(const char* name);

    bool retryModule(uint8_t index);
 
private:
    ModuleRegistry() = default;

    void cleanupOrphanedModuleData();

    void saveModuleList();
 
    IModule* modules_[MAX_MODULES] = {};
    uint8_t count_ = 0;
 
    ModuleInitFunc initializers_[MAX_INITIALIZERS] = {};
    uint8_t initCount_ = 0;
 
    struct ModuleError {
        bool hasError = false;
        char message[96] = {0};
    };
 
    ModuleError moduleErrors_[MAX_MODULES] = {};
 
    // Comma-separated list of disabled module names
    // Stored in NVS as string - robust against module order changes
    static constexpr size_t MAX_DISABLED_LIST_SIZE = 128;
    char disabledModules_[MAX_DISABLED_LIST_SIZE] = {0};

    void loadDisabledList();

    void saveDisabledList();
 
    void setModuleError(uint8_t index, const char* message);
    void clearModuleError(uint8_t index);
    bool applySlotRequest(IModule* module, uint8_t index);
 
    // Slot validation helpers for applySlotRequest
    bool validateSlotMap(const char* moduleName);
    bool validateEccRange(const char* mapName, const char* moduleName,
                          uint16_t minSlots, IModule::SlotRange& range,
                          uint8_t& moduleId);
    bool validateRmemRange(const char* mapName, const char* moduleName,
                           uint16_t minSlots, IModule::SlotRange& range,
                           uint8_t& moduleId);
    static void buildSlotErrorMessage(char* buffer, size_t bufSize,
                                      const char* errorType, const char* mapName);
};
 
// Convenience macro
#define CDC_MODULE(name) cdc::core::ModuleRegistry::instance().getModule(name)
 
} // namespace cdc::core