SenseApis: Define descriptors exported by libs

hcore/include/senseApis/senseApiLib.h

@@ -0,0 +1,73 @@
+#ifndef SENSE_API_PROVIDER_DESC_H
+#define SENSE_API_PROVIDER_DESC_H
+
+#include <string>
+#include <memory>
+#include <vector>
+#include <dlfcn.h>
+#include <functional>
+#include <user/senseApiDesc.h>
+
+namespace hk {
+namespace sense_api {
+
+/* C++ version of the C struct above, which Harikoff uses to manage the 
+ * lib and connect implexors to it.
+ */
+class SenseApiDesc
+{
+public:
+    class ExportedImplexorApiDesc
+    {
+    public:
+        const std::string name;
+    };
+
+public:
+    SenseApiDesc(const CSenseApiDesc& cDesc)
+    :   cDescriptor(cDesc), name(cDesc.name)
+    {}
+
+    std::reference_wrapper<const CSenseApiDesc> cDescriptor;
+    std::string name;
+    // These options affect the sense api lib's behaviour globally.
+    std::vector<std::string> options;
+    // These are the implexors whose APIs this lib exports.
+    std::vector<ExportedImplexorApiDesc> exportedImplexorApis;
+};
+
+class SenseApiLib
+{
+public:
+    typedef const CSenseApiDesc *(SenseApiDescGetterFn)(void);
+
+public:
+    SenseApiLib(const std::string& path)
+    :   libraryPath(path), handle(nullptr, &dlclose)
+    {}
+
+public:
+    std::string libraryPath;
+    std::unique_ptr<void, decltype(&dlclose)> handle;
+
+    /**
+     * @brief Every sense API lib is required to provide a function that returns
+     * a CSenseApiDesc struct. This struct states which API the lib uses to
+     * connect Harikoff to the sense provider it supports.
+     *
+     * This getter function should be visible to dlsym() so that Harikoff can
+     * find it in the lib after loading it, and call it.
+     */
+    SenseApiDescGetterFn *getSenseApiDescriptor;
+
+    /**
+     * @brief Harikoff will call the `getSenseApiDescriptor` getter function and
+     * use the data it provides in order to fill out this descriptor.
+     */
+    std::unique_ptr<SenseApiDesc> apiDescriptor;
+};
+
+} // namespace sense_api
+} // namespace hk
+
+#endif // SENSE_API_PROVIDER_DESC_H

hcore/include/senseApis/senseApiManager.h

@@ -7,63 +7,35 @@
 #include <string>
 #include <optional>
 #include <functional>
+#include <senseApis/senseApiLib.h>
 
-struct SenseApiInstance {
-    int a;
-
-    bool operator==(const SenseApiInstance& other) const {
-        return a == other.a;
-    }
-};
-
-class SenseApiLib {
-public:
-    std::string libraryPath;
-    std::unique_ptr<void, decltype(&dlclose)> handle;
-
-    SenseApiLib(const std::string& path)
-        : libraryPath(path), handle(nullptr, &dlclose) {}
-};
+namespace hk {
+namespace sense_api {
 
 class SenseApiManager {
 public:
     static SenseApiManager& getInstance()
     {
-        static SenseApiManager instance
-        {
-#ifdef CONFIG_SENSEAPI_FOO
-            "builtinApi1",
-#endif
-#ifdef CONFIG_SENSEAPI_BAR
-            "builtinApi2",
-#endif
-            // X11 XCB is always built-in.
-            "x11-xcb"
-        };
-
+        static SenseApiManager instance;
         return instance;
     }
 
-    void registerSenseApi(const SenseApiInstance& apiInstance);
-    void unregisterSenseApi(const SenseApiInstance& apiInstance);
-
     SenseApiLib& loadSenseApiLib(const std::string& libraryPath);
     std::optional<std::reference_wrapper<SenseApiLib>> getSenseApiLib(
         const std::string& libraryPath);
     void unloadSenseApiLib(const std::string& libraryPath);
 
 private:
-    SenseApiManager() = delete;
-    SenseApiManager(std::initializer_list<std::string> builtinApis)
-        : builtinSenseApis(builtinApis) {}
+    SenseApiManager() = default;
     ~SenseApiManager() = default;
 
     SenseApiManager(const SenseApiManager&) = delete;
     SenseApiManager& operator=(const SenseApiManager&) = delete;
 
-    std::vector<std::unique_ptr<SenseApiInstance>> senseApiInstances;
     std::vector<std::unique_ptr<SenseApiLib>> senseApiLibs;
-    const std::vector<std::string> builtinSenseApis;
 };
 
+} // namespace sense_api
+} // namespace hk
+
 #endif // SENSE_API_MANAGER_H