apiservice.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "apievent.h"
 
// External Includes
#include <nap/service.h>
#include <queue>
#include <mutex>
#include <nap/signalslot.h>
 
namespace nap
{
    // Forward Declares
    class APIComponentInstance;
 
    class NAPAPI APIService : public Service
    {
        friend class APIComponentInstance;
        RTTI_ENABLE(Service)
    public:
        APIService(ServiceConfiguration* configuration);
 
        ~APIService() override;
        
        bool sendFloat(const char* id, float value, utility::ErrorState* error);
        
        bool sendString(const char* id, const char* value, utility::ErrorState* error);
        
        bool sendInt(const char* id, int value, utility::ErrorState* error);
        
        bool sendByte(const char* id, nap::uint8 value, utility::ErrorState* error);
 
        bool sendBool(const char* id, bool value, utility::ErrorState* error);
 
        bool sendLong(const char* id, int64_t value, utility::ErrorState* error);
        
        bool sendChar(const char* id, char value, utility::ErrorState* error);
        
        bool send(const char* id, utility::ErrorState* error);
        
        bool sendEvent(APIEventPtr apiEvent, utility::ErrorState* error);
 
        bool sendMessage(const char* json, utility::ErrorState* error);
 
        bool sendIntArray(const char* id, int* array, int length, utility::ErrorState* error);
        
        bool sendFloatArray(const char* id, float* array, int length, utility::ErrorState* error);
        
        bool sendByteArray(const char* id, uint8_t* array, int length, utility::ErrorState* error);
        
        bool sendStringArray(const char* id, const char** array, int length, utility::ErrorState* error);
 
        void processEvents();
 
        void dispatchEvent(nap::APIEventPtr apiEvent);
 
        nap::Signal<const APIEvent&> eventDispatched;
 
    protected:
        virtual bool init(utility::ErrorState& error) override;
 
        virtual void shutdown() override;
 
        virtual void update(double deltaTime) override;
 
    private:
        void registerAPIComponent(APIComponentInstance& apicomponent);
 
        void removeAPIComponent(APIComponentInstance& apicomponent);
 
        bool forward(APIEventPtr apiEvent, utility::ErrorState& error);
 
        void consumeEvents(std::queue<APIEventPtr>& outEvents);
 
        // All the api components currently available to the system
        std::vector<APIComponentInstance*> mAPIComponents;
 
        // All the api events to process
        std::queue<APIEventPtr> mAPIEvents;
 
        // Mutex associated with setting / getting api events
        std::mutex mEventMutex;
 
        // Mutex associated with component registration and iteration
        std::mutex mComponentMutex;
    };
}