CPPSDK: static code + template changes

rdkcentral · Sep 29, 2023 · 1a31e9d · 1a31e9d
1 parent fd66f37
commit 1a31e9d
Show file tree

Hide file tree

Showing 31 changed files with 389 additions and 442 deletions.
diff --git a/languages/cpp/src/shared/include/error.h b/languages/cpp/src/shared/include/error.h
@@ -16,26 +16,24 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#ifndef FIREBOLT_ERROR_H
-#define FIREBOLT_ERROR_H
+#pragma once
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+namespace Firebolt {
 
-typedef enum FireboltSDKError {
-    FireboltSDKErrorNone = 0,
-    FireboltSDKErrorGeneral = 1,
-    FireboltSDKErrorUnavailable = 2,
-    FireboltSDKErrorTimedout = 3,
-    FireboltSDKErrorNotSubscribed = 4,
-    FireboltSDKErrorUnknown = 5,
-    FireboltSDKErrorInUse = 6,
-    FireboltSDKErrorNotSupported = 7
-} FireboltSDKError_t;
+    enum class Error : int32_t {
+        None = 0,
+        General = 1,
+        Timedout = 2,
+        NotConnected = 3,
+        AlreadyConnected = 4,
+        //AuthenticationError, ?
+        InvalidRequest = -32600,
+        MethodNotFound = -32601,
+        InvalidParams = -32602,
+        CapabilityNotAvaialbale = -50300,
+        CapabilityNotSupported = -50100,
+        CapabilityGet = -50200,
+        CapabilityNotPermitted = -40300,
+    };
 
-#ifdef __cplusplus
 }
-#endif
-
-#endif // FIREBOLT_ERROR_H
diff --git a/languages/cpp/src/shared/src/Accessor/Accessor.cpp b/languages/cpp/src/shared/src/Accessor/Accessor.cpp
@@ -27,69 +27,63 @@ namespace FireboltSDK {
         , _transport(nullptr)
         , _config()
     {
+        ASSERT(_singleton == nullptr);
         _singleton = this;
         _config.FromString(configLine);
 
         Logger::SetLogLevel(WPEFramework::Core::EnumerateType<Logger::LogLevel>(_config.LogLevel.Value().c_str()).Value());
 
         FIREBOLT_LOG_INFO(Logger::Category::OpenRPC, Logger::Module<Accessor>(), "Url = %s", _config.WsUrl.Value().c_str());
-        CreateTransport(_config.WsUrl.Value().c_str(), _config.WaitTime.Value());
-        CreateEventHandler();
-
         _workerPool = WPEFramework::Core::ProxyType<WorkerPoolImplementation>::Create(_config.WorkerPool.ThreadCount.Value(), _config.WorkerPool.StackSize.Value(), _config.WorkerPool.QueueSize.Value());
         WPEFramework::Core::WorkerPool::Assign(&(*_workerPool));
         _workerPool->Run();
     }
 
     Accessor::~Accessor()
     {
-        DestroyTransport();
-        DestroyEventHandler();
         WPEFramework::Core::IWorkerPool::Assign(nullptr);
         _workerPool->Stop();
+
+        ASSERT(_singleton != nullptr);
         _singleton = nullptr;
     }
 
-    int32_t Accessor::CreateEventHandler()
+    Firebolt::Error Accessor::CreateEventHandler()
     {
          Event::Instance().Configure(_transport);
-         return FireboltSDKErrorNone;
+         return Firebolt::Error::None;
     }
 
-    int32_t Accessor::DestroyEventHandler()
+    Firebolt::Error Accessor::DestroyEventHandler()
     {
          Event::Dispose();
-         return FireboltSDKErrorNone;
+         return Firebolt::Error::None;
     }
 
     Event& Accessor::GetEventManager()
     {
         return Event::Instance();
     }
 
-    int32_t Accessor::CreateTransport(const string& url, const uint32_t waitTime = DefaultWaitTime)
+    Firebolt::Error Accessor::CreateTransport(const string& url, const Transport<WPEFramework::Core::JSON::IElement>::Listener& listener, const uint32_t waitTime = DefaultWaitTime)
     {
         if (_transport != nullptr) {
             delete _transport;
         }
 
-        _transport = new Transport<WPEFramework::Core::JSON::IElement>(static_cast<WPEFramework::Core::URL>(url), waitTime);
-        if (WaitForLinkReady(_transport, waitTime) != FireboltSDKErrorNone) {
-            delete _transport;
-            _transport = nullptr;
-        }
+        _transport = new Transport<WPEFramework::Core::JSON::IElement>(static_cast<WPEFramework::Core::URL>(url), waitTime, listener);
 
         ASSERT(_transport != nullptr);
-        return ((_transport != nullptr) ? FireboltSDKErrorNone : FireboltSDKErrorUnavailable);
+        return ((_transport != nullptr) ? Firebolt::Error::None : Firebolt::Error::Timedout);
     }
 
-    int32_t Accessor::DestroyTransport()
+    Firebolt::Error Accessor::DestroyTransport()
     {
         if (_transport != nullptr) {
             delete _transport;
             _transport = nullptr;
         }
-        return FireboltSDKErrorNone;
+        return Firebolt::Error::None;
     }
 
     Transport<WPEFramework::Core::JSON::IElement>* Accessor::GetTransport()
@@ -98,20 +92,4 @@ namespace FireboltSDK {
         return _transport;
     }
 
-    int32_t Accessor::WaitForLinkReady(Transport<WPEFramework::Core::JSON::IElement>* transport, const uint32_t waitTime = DefaultWaitTime) {
-        uint32_t waiting = (waitTime == WPEFramework::Core::infinite ? WPEFramework::Core::infinite : waitTime);
-        static constexpr uint32_t SLEEPSLOT_TIME = 100;
-
-        // Right, a wait till connection is closed is requested..
-        while ((waiting > 0) && (transport->IsOpen() == false)) {
-
-            uint32_t sleepSlot = (waiting > SLEEPSLOT_TIME ? SLEEPSLOT_TIME : waiting);
-
-            // Right, lets sleep in slices of 100 ms
-            SleepMs(sleepSlot);
-
-            waiting -= (waiting == WPEFramework::Core::infinite ? 0 : sleepSlot);
-        }
-        return (((waiting == 0) || (transport->IsOpen() == true)) ? FireboltSDKErrorNone : FireboltSDKErrorTimedout);
-    }
 }
diff --git a/languages/cpp/src/shared/src/Accessor/Accessor.h b/languages/cpp/src/shared/src/Accessor/Accessor.h
@@ -103,15 +103,31 @@ namespace FireboltSDK {
                 delete _singleton;
             }
         }
+
+        void Connect(const Transport<WPEFramework::Core::JSON::IElement>::Listener& listener)
+        {
+            CreateTransport(_config.WsUrl.Value().c_str(), listener, _config.WaitTime.Value());
+            CreateEventHandler();
+        }
+
+        Firebolt::Error Disconnect()
+        {
+            Firebolt::Error status = Firebolt::Error::None;
+            status = DestroyTransport();
+            if (status == Firebolt::Error::None) {
+                status = DestroyEventHandler();
+            }
+            return status;
+        }
+
         Event& GetEventManager();
         Transport<WPEFramework::Core::JSON::IElement>* GetTransport();
 
     private:
-        int32_t CreateEventHandler();
-        int32_t DestroyEventHandler();
-        int32_t CreateTransport(const string& url, const uint32_t waitTime);
-        int32_t DestroyTransport();
-        int32_t WaitForLinkReady(Transport<WPEFramework::Core::JSON::IElement>* transport, const uint32_t waitTime);
+        Firebolt::Error CreateEventHandler();
+        Firebolt::Error DestroyEventHandler();
+        Firebolt::Error CreateTransport(const string& url, const Transport<WPEFramework::Core::JSON::IElement>::Listener& listener, const uint32_t waitTime);
+        Firebolt::Error DestroyTransport();
 
     private:
         WPEFramework::Core::ProxyType<WorkerPoolImplementation> _workerPool;

diff --git a/languages/cpp/src/shared/src/Event/Event.cpp b/languages/cpp/src/shared/src/Event/Event.cpp
@@ -60,33 +60,35 @@ namespace FireboltSDK {
         _transport->SetEventHandler(this);
     }
 
-    int32_t Event::Unsubscribe(const string& eventName, void* usercb)
+    Firebolt::Error Event::Unsubscribe(const string& eventName, void* usercb)
     {
-        int32_t status = Revoke(eventName, usercb);
+        Firebolt::Error status = Revoke(eventName, usercb);
 
-        if (status == FireboltSDKErrorNone) {
+        if (status == Firebolt::Error::None) {
             if (_transport != nullptr) {
 
                 const string parameters("{\"listen\":false}");
                 status = _transport->Unsubscribe(eventName, parameters);
             }
-        }
-        return ((status == FireboltSDKErrorInUse) ? FireboltSDKErrorNone: status);
+        } else {
+            status = Firebolt::Error::None;
+	    }
+        return status;
     }
 
-    int32_t Event::ValidateResponse(const WPEFramework::Core::ProxyType<WPEFramework::Core::JSONRPC::Message>& jsonResponse, bool& enabled) /* override */
+    Firebolt::Error Event::ValidateResponse(const WPEFramework::Core::ProxyType<WPEFramework::Core::JSONRPC::Message>& jsonResponse, bool& enabled) /* override */
     {
-        int32_t result = FireboltSDKErrorGeneral;
+        Firebolt::Error result = Firebolt::Error::General;
         Response response;
         _transport->FromMessage((WPEFramework::Core::JSON::IElement*)&response, *jsonResponse);
         if (response.Listening.IsSet() == true) {
-            result = FireboltSDKErrorNone;
+            result = Firebolt::Error::None;
             enabled = response.Listening.Value();
         }
         return result;
     }
 
-    int32_t Event::Dispatch(const string& eventName, const WPEFramework::Core::ProxyType<WPEFramework::Core::JSONRPC::Message>& jsonResponse) /* override */
+    Firebolt::Error Event::Dispatch(const string& eventName, const WPEFramework::Core::ProxyType<WPEFramework::Core::JSONRPC::Message>& jsonResponse) /* override */
     {
         string response = jsonResponse->Result.Value();
         _adminLock.Lock();
@@ -117,12 +119,12 @@ namespace FireboltSDK {
         }
         _adminLock.Unlock();
 
-        return FireboltSDKErrorNone;;
+        return Firebolt::Error::None;;
     }
 
-    int32_t Event::Revoke(const string& eventName, void* usercb)
+    Firebolt::Error Event::Revoke(const string& eventName, void* usercb)
     {
-        int32_t status = FireboltSDKErrorNone;
+        Firebolt::Error status = Firebolt::Error::None;
         _adminLock.Lock();
         EventMap::iterator eventIndex = _eventMap.find(eventName);
         if (eventIndex != _eventMap.end()) {
@@ -137,7 +139,7 @@ namespace FireboltSDK {
             if (eventIndex->second.size() == 0) {
                 _eventMap.erase(eventIndex);
             } else {
-                status = FireboltSDKErrorInUse;
+                status = Firebolt::Error::General;
             }
         }
         _adminLock.Unlock();

diff --git a/languages/cpp/src/shared/src/Event/Event.h b/languages/cpp/src/shared/src/Event/Event.h
@@ -26,7 +26,7 @@ namespace FireboltSDK {
 
     class Event : public IEventHandler {
     public:
-        typedef std::function<int32_t(void*, const void*, const string& parameters)> DispatchFunction;
+        typedef std::function<Firebolt::Error(void*, const void*, const string& parameters)> DispatchFunction;
     private:
         enum State : uint8_t {
             IDLE,
@@ -73,20 +73,20 @@ namespace FireboltSDK {
 
     public:
         template <typename RESULT, typename CALLBACK>
-        int32_t Subscribe(const string& eventName, const CALLBACK& callback, void* usercb, const void* userdata)
+        Firebolt::Error Subscribe(const string& eventName, const CALLBACK& callback, void* usercb, const void* userdata)
         {
             JsonObject jsonParameters;
             return Subscribe<RESULT, CALLBACK>(eventName, jsonParameters, callback, usercb, userdata);
         }
 
         template <typename RESULT, typename CALLBACK>
-        int32_t Subscribe(const string& eventName, JsonObject& jsonParameters, const CALLBACK& callback, void* usercb, const void* userdata)
+        Firebolt::Error Subscribe(const string& eventName, JsonObject& jsonParameters, const CALLBACK& callback, void* usercb, const void* userdata)
         {
-            int32_t status = FireboltSDKErrorUnavailable;
+            Firebolt::Error status = Firebolt::Error::General;
             if (_transport != nullptr) {
 
                 status = Assign<RESULT, CALLBACK>(eventName, callback, usercb, userdata);
-                if (status == FireboltSDKErrorNone) {
+                if (status == Firebolt::Error::None) {
                     Response response;
 
                     WPEFramework::Core::JSON::Variant Listen = true;
@@ -96,35 +96,33 @@ namespace FireboltSDK {
 
                     status = _transport->Subscribe<Response>(eventName, parameters, response);
 
-                    if (status != FireboltSDKErrorNone) {
+                    if (status != Firebolt::Error::None) {
                         Revoke(eventName, usercb);
                     } else if ((response.Listening.IsSet() == true) &&
                               (response.Listening.Value() == true)) {
-                        status = FireboltSDKErrorNone;
-                    } else {
-                        status = FireboltSDKErrorNotSubscribed;
+                        status = Firebolt::Error::None;
                     }
                 }
             }
 
             return status;
         }
 
-        int32_t Unsubscribe(const string& eventName, void* usercb);
+        Firebolt::Error Unsubscribe(const string& eventName, void* usercb);
 
     private:
         template <typename PARAMETERS, typename CALLBACK>
-        int32_t Assign(const string& eventName, const CALLBACK& callback, void* usercb, const void* userdata)
+        Firebolt::Error Assign(const string& eventName, const CALLBACK& callback, void* usercb, const void* userdata)
         {
-            int32_t status = FireboltSDKErrorNone;
+            Firebolt::Error status = Firebolt::Error::General;
             std::function<void(void* usercb, const void* userdata, void* parameters)> actualCallback = callback;
-            DispatchFunction implementation = [actualCallback](void* usercb, const void* userdata, const string& parameters) -> int32_t {
+            DispatchFunction implementation = [actualCallback](void* usercb, const void* userdata, const string& parameters) -> Firebolt::Error {
 
                 WPEFramework::Core::ProxyType<PARAMETERS>* inbound = new WPEFramework::Core::ProxyType<PARAMETERS>();
                 *inbound = WPEFramework::Core::ProxyType<PARAMETERS>::Create();
                 (*inbound)->FromString(parameters);
                 actualCallback(usercb, userdata, static_cast<void*>(inbound));
-                return (FireboltSDKErrorNone);
+                return (Firebolt::Error::None);
             };
             CallbackData callbackData = {implementation, userdata, State::IDLE};
 
@@ -134,26 +132,25 @@ namespace FireboltSDK {
                 CallbackMap::iterator callbackIndex = eventIndex->second.find(usercb);
                 if (callbackIndex == eventIndex->second.end()) {
                     eventIndex->second.emplace(std::piecewise_construct, std::forward_as_tuple(usercb), std::forward_as_tuple(callbackData));
-                } else {
-                    // Already registered, no need to register again;
-                    status = FireboltSDKErrorInUse;
+                    status = Firebolt::Error::None;
                 }
             } else {
 
                 CallbackMap callbackMap;
                 callbackMap.emplace(std::piecewise_construct, std::forward_as_tuple(usercb), std::forward_as_tuple(callbackData));
                 _eventMap.emplace(std::piecewise_construct, std::forward_as_tuple(eventName), std::forward_as_tuple(callbackMap));
+                status = Firebolt::Error::None;
 
             }
 
             _adminLock.Unlock();
             return status;
         }
-        int32_t Revoke(const string& eventName, void* usercb);
+        Firebolt::Error Revoke(const string& eventName, void* usercb);
 
     private:
-        int32_t ValidateResponse(const WPEFramework::Core::ProxyType<WPEFramework::Core::JSONRPC::Message>& jsonResponse, bool& enabled) override;
-        int32_t Dispatch(const string& eventName, const WPEFramework::Core::ProxyType<WPEFramework::Core::JSONRPC::Message>& jsonResponse) override;
+        Firebolt::Error ValidateResponse(const WPEFramework::Core::ProxyType<WPEFramework::Core::JSONRPC::Message>& jsonResponse, bool& enabled) override;
+        Firebolt::Error Dispatch(const string& eventName, const WPEFramework::Core::ProxyType<WPEFramework::Core::JSONRPC::Message>& jsonResponse) override;
 
     private:
         EventMap _eventMap;

diff --git a/languages/cpp/src/shared/src/Logger/Logger.cpp b/languages/cpp/src/shared/src/Logger/Logger.cpp
@@ -45,13 +45,13 @@ ENUM_CONVERSION_END(FireboltSDK::Logger::Category)
 namespace FireboltSDK {
     /* static */  Logger::LogLevel Logger::_logLevel = Logger::LogLevel::Error;
 
-    int32_t Logger::SetLogLevel(Logger::LogLevel logLevel)
+    Firebolt::Error Logger::SetLogLevel(Logger::LogLevel logLevel)
     {
         ASSERT(logLevel < Logger::LogLevel::MaxLevel);
-        int32_t status = FireboltSDKErrorNotSupported;
+        Firebolt::Error status = Firebolt::Error::General;
         if (logLevel < Logger::LogLevel::MaxLevel) {
             _logLevel = logLevel;
-            status = FireboltSDKErrorNone;
+            status = Firebolt::Error::None;
         }
         return status;
     }

diff --git a/languages/cpp/src/shared/src/Logger/Logger.h b/languages/cpp/src/shared/src/Logger/Logger.h
@@ -49,7 +49,7 @@ namespace FireboltSDK {
         ~Logger() = default;
 
     public:
-        static int32_t SetLogLevel(LogLevel logLevel);
+        static Firebolt::Error SetLogLevel(LogLevel logLevel);
         static void Log(LogLevel logLevel, Category category, const std::string& module, const std::string file, const std::string function, const uint16_t line, const std::string& format, ...);
 
     public: