GestureRecognizer.h

#ifndef NUITRACK_GESTURE_RECOGNIZER_H_
#define NUITRACK_GESTURE_RECOGNIZER_H_

#include <functional>

#include "nuitrack/modules/HeaderOnlyAPI_Module.h"
#include "nuitrack/ModuleFunctions.h"
#include "nuitrack/types/Export.h"
#include "nuitrack/types/GestureData.h"
#include "nuitrack/capi/GestureRecognizer_CAPI.h"
#include "nuitrack/utils/ExceptionTranslator.h"
#include "nuitrack/utils/CallbackStruct.h"

namespace tdv
{
namespace nuitrack
{

class GestureRecognizer :public tdv::nuitrack::HeaderOnlyAPI_Module
{
public:
    typedef std::shared_ptr<GestureRecognizer> Ptr;

    typedef std::function<void (GestureData::Ptr)> OnNewGestures;
    typedef void (*OnNewGesturesRawFunctionPtr)(GestureData*, GestureRecognizer*);

    typedef std::function<void (UserStateData::Ptr)> OnUserStateChange;
    typedef void (*OnUserStateChangeRawFunctionPtr)(UserStateData*, GestureRecognizer*);

    typedef std::function<void (UserGesturesStateData::Ptr)> OnUpdate;
    typedef void (*OnUpdateRawFunctionPtr)(UserGesturesStateData*, GestureRecognizer*);

    static GestureRecognizer::Ptr create()
    {
        NuitrackModule* pimpl = NULL;
    ExceptionType exception_code = nuitrack_CreateGestureRecognizer(&pimpl);
    ExceptionTranslator::generateExceptionByErrorCode(exception_code);
        return std::shared_ptr<GestureRecognizer>(new GestureRecognizer(pimpl));
    }

    GestureRecognizer(NuitrackModule* pimpl)
    {
        _pimpl = pimpl;

        _onNewGesturesCallbackStruct = new CallbackStruct<GestureData::Ptr>();
        _onUserStateChangeCallbackStruct = new CallbackStruct<UserStateData::Ptr>();
        _onUpdateCallbackStruct = new CallbackStruct<UserGesturesStateData::Ptr>();

        _callbackWrapper.setGestureRecognizer(this);
        _callbackWrapper.setOnNewGestureAddress(&onNewGesturesCallback);
        _callbackWrapper.setOnUserStateChangeAddress(&onUserStateChangeCallback);
        _callbackWrapper.setOnUpdateAddress(&onUpdateCallback);
        nuitrack_registerGestureRecognizerCallback(_pimpl, &_callbackWrapper);
    }

    virtual ~GestureRecognizer()
    {
        nuitrack_DestroyGestureRecognizer(_pimpl);
        destroyGestureRecognizer();
    }

    uint64_t connectOnNewGestures(const OnNewGestures& callback)
    {
        return _onNewGesturesCallbackStruct->addCallback(callback);
    }

    void disconnectOnNewGestures(uint64_t handler)
    {
        _onNewGesturesCallbackStruct->deleteCallback(handler);
    }

    uint64_t connectOnUserStateChange(const OnUserStateChange& callback)
    {
        return _onUserStateChangeCallbackStruct->addCallback(callback);
    }

    void disconnectOnUserStateChange(uint64_t handler)
    {
        _onUserStateChangeCallbackStruct->deleteCallback(handler);
    }

    uint64_t connectOnUpdate(const OnUpdate& callback)
    {
        return _onUpdateCallbackStruct->addCallback(callback);
    }

    void disconnectOnUpdate(uint64_t handler)
    {
        _onUpdateCallbackStruct->deleteCallback(handler);
    }

    float getProcessingTime() const
    {
        return nuitrack_GetGestureRecognizerProcessingTime(_pimpl);
    }

    void setControlGesturesStatus(bool status)
    {
        nuitrack_UserGesturesSetControlStatus(_pimpl, status);
    }

    void destroyGestureRecognizer()
    {
        if(_onNewGesturesCallbackStruct)
            delete _onNewGesturesCallbackStruct;
        if(_onUserStateChangeCallbackStruct)
            delete _onUserStateChangeCallbackStruct;
        if(_onUpdateCallbackStruct)
            delete _onUpdateCallbackStruct;
    }

    bool canUpdate() const
    {
        return nuitrack_GetNuitrackModuleCanUpdate(_pimpl);
    }

    virtual uint64_t getTimestamp()
    {
        return nuitrack_GetNuitrackModuleTimestamp(_pimpl);
    }

protected:
    static void onNewGesturesCallback(GestureRecognizerData* data, GestureRecognizer* tracker)
    {
        GestureData::Ptr newFrame = GestureData::Ptr(new GestureData(data));
        tracker->_onNewGesturesCallbackStruct->executeAllCallbacks(newFrame);
    }
    static void onUserStateChangeCallback(UsersStateChanges* data, GestureRecognizer* tracker)
    {
        UserStateData::Ptr newFrame = UserStateData::Ptr(new UserStateData(data));
        tracker->_onUserStateChangeCallbackStruct->executeAllCallbacks(newFrame);
    }
    static void onUpdateCallback(GestureRecognizerUserGesturesStateData* data, GestureRecognizer* tracker)
    {
        UserGesturesStateData::Ptr newFrame = UserGesturesStateData::Ptr(new UserGesturesStateData(data));
        tracker->_onUpdateCallbackStruct->executeAllCallbacks(newFrame);
    }
    NuitrackModule* _pimpl;
    GestureRecognizerCallbackWrapper _callbackWrapper;
    CallbackStruct<GestureData::Ptr>* _onNewGesturesCallbackStruct;
    CallbackStruct<UserStateData::Ptr>* _onUserStateChangeCallbackStruct;
    CallbackStruct<UserGesturesStateData::Ptr>* _onUpdateCallbackStruct;
};

} /* namespace nuitrack */
} /* namespace tdv */

#endif /* NUITRACK_GESTURE_RECOGNIZER_H_ */