PluginManager.h

Go to the documentation of this file.

 
#pragma once
 
#include "plugin_manager/Plugin.h"
#include "plugin_manager/PluginManifest.h"
#include "plugin_manager/PluginStorage.h"
 
#include <atomic>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace cdc::plugin_manager {
 
enum class StartResult {
    Ok,
    PluginAlreadyRunning,
    ManifestMissing,
    ManifestInvalid,
    CapabilityRejected,
    WamrLoadFailed,
    WamrInstantiateFailed,
    PluginInitFailed,
    PrerequisiteFailed,
    PluginOnEnterFailed,
    Busy,
    PluginDisabled,
};
 
class PluginManager {
public:
    [[nodiscard]] static PluginManager& instance() noexcept;
 
    [[nodiscard]] bool init();
    void deinit();
 
    [[nodiscard]] std::vector<std::string>     listInstalledIds() const;
    [[nodiscard]] std::optional<PluginManifest> getManifest(const std::string& id) const;

    [[nodiscard]] bool messageTypeInstalled(const char* mime) const;
    bool activateForMessageType(const char* mime);
    [[nodiscard]] bool featureInstalled(const char* feature) const;
    [[nodiscard]] std::string featureProviderId(const char* feature) const;
    [[nodiscard]] bool                         isPluginDisabled(const std::string& id) const;
    bool                                       setPluginDisabled(const std::string& id,
                                                                 bool disabled);
 
    [[nodiscard]] StartResult startPlugin(const std::string& id);
    bool                      stopActivePlugin();
    bool                      unloadFromRam(const std::string& id);
    bool                      uninstallPlugin(const std::string& id);
    void                      unloadAllFromRam();
    bool                      reloadBackgroundPlugin(const std::string& id);
    void                      requestStopActivePlugin();
    [[nodiscard]] bool        hasActivePlugin() const noexcept;
    [[nodiscard]] std::string activePluginId()  const;
    [[nodiscard]] uint8_t     pluginBaseDepth() const noexcept { return plugin_base_depth_; }
    [[nodiscard]] bool        isLoaded(const std::string& id) const;
    [[nodiscard]] bool        isRunningInBackground(const std::string& id) const;
    [[nodiscard]] bool        hasBackgroundPlugin() const noexcept;
    [[nodiscard]] bool        activePluginIsBackground() const;
    [[nodiscard]] bool        activePluginPreventsSleep() const;
 
    void dispatchButton(uint32_t button_code);
    void dispatchAction(uint32_t action_id, uint32_t idx, uint32_t user_data);
    void dispatchActionTo(Plugin* plugin, uint32_t action_id, uint32_t idx, uint32_t user_data);
    void dispatchTick(uint64_t uptime_ms);

    bool dispatchCmd(const std::string& id, const char* cmd, size_t len);

    int  consumeCmd(char* out, size_t out_size);

    void dispatchEventAll(uint32_t event_type, uint32_t value);

    void forEachPlugin(const std::function<bool(Plugin&)>& visitor);

    struct LockscreenItem {
        Plugin*  plugin;
        char     label[40];
        uint32_t action_id;
    };

    uint8_t getLockscreenItems(LockscreenItem* out, uint8_t max) const;

    void triggerLockscreenItem(const LockscreenItem& item);

    void reloadActiveLangOverlay();
 
private:
    PluginManager();
    ~PluginManager();
    PluginManager(const PluginManager&) = delete;
    PluginManager& operator=(const PluginManager&) = delete;
 
    void startTickTask();
    void stopTickTask();
    static void tickTaskTrampoline(void* arg);
    void tickTaskLoop();

    void teardownPlugin(Plugin& p, bool runWasmDeinit);

    void handleTrap(Plugin& p, const char* fn);

    bool loadIntoBackground(const std::string& id, const PluginManifest& mf);

    void loadAutoloadPlugins();

    void rebuildMessageIndex();
    void maybeRefreshMessageIndex();
 
    std::unique_ptr<Plugin>              active_;       // foreground (user-visible)
    std::vector<std::unique_ptr<Plugin>> background_;   // manually-started resident plugins
    std::string                          pending_cmd_;  // buffered for plugin_on_cmd pull
    void*                                tick_task_  = nullptr;  // FreeRTOS TaskHandle_t
    void*                                call_mutex_ = nullptr;  // FreeRTOS SemaphoreHandle_t
    volatile bool                        tick_stop_  = false;
    std::atomic<bool>                    pending_stop_{false};
    bool initialised_ = false;
    uint8_t                              plugin_base_depth_ = 0;
 
    // MIME-type -> plugin-id index for auto-starting handler plugins on demand.
    // Guarded by msg_index_mutex_ (read from the BLE host task). Parallel arrays.
    void*                    msg_index_mutex_ = nullptr;  // FreeRTOS SemaphoreHandle_t
    std::vector<std::string> msg_index_mime_;
    std::vector<std::string> msg_index_id_;
    // External-feature -> plugin-id index, rebuilt together with the MIME index
    // and guarded by the same mutex. Parallel arrays.
    std::vector<std::string> feat_index_name_;
    std::vector<std::string> feat_index_id_;
    std::string              installed_sig_;
    uint32_t                 last_index_refresh_ms_ = 0;
};
 
}  // namespace cdc::plugin_manager