UserTracker.h

#ifndef NUITRACK_USERTRACKER_H_
#define NUITRACK_USERTRACKER_H_

#include <functional>

#include "nuitrack/modules/HeaderOnlyAPI_Module.h"
#include "nuitrack/types/Export.h"
#include "nuitrack/types/UserFrame.h"
#include "nuitrack/capi/UserTracker_CAPI.h"
#include "nuitrack/capi/Nuitrack_CAPI.h"
#include "nuitrack/utils/ExceptionTranslator.h"
#include "nuitrack/utils/CallbackStruct.h"


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

    typedef std::function<void (UserFrame::Ptr)> OnUpdate;

    typedef void (*OnUpdateRawFunctionPtr)(UserFrame*, UserTracker*);

    typedef std::function<void (int)> OnNewUser;

    typedef void (*OnNewUserRawFunctionPtr)(int, UserTracker*);

    typedef std::function<void (int)> OnLostUser;

    typedef void (*OnLostUserRawFunctionPtr)(int, UserTracker*);

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

    UserTracker(NuitrackModule* pimpl)
    {
        _pimpl = pimpl;

        _onUpdateCallbackStruct = new CallbackStruct<UserFrame::Ptr>();
        _onNewUserCallbackStruct = new CallbackStruct<int>();
        _onLostUserCallbackStruct = new CallbackStruct<int>();

        _callbackWrapper.setUserTracker(this);
        _callbackWrapper.setOnUpdateAddress(&onUpdateCallback);
        _callbackWrapper.setOnNewUserAddress(&onNewUserCallback);
        _callbackWrapper.setOnLostUserAddress(&onLostUserCallback);

        nuitrack_registerUserTrackerCallback(_pimpl, &_callbackWrapper);
    }

    virtual ~UserTracker()
    {
        nuitrack_DestroyUserTracker(_pimpl);
        destroyUserTracker();
    }

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

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

    uint64_t connectOnNewUser(const OnNewUser& callback)
    {
        return _onNewUserCallbackStruct->addCallback(callback);
    }

    void disconnectOnNewUser(uint64_t handler)
    {
        _onNewUserCallbackStruct->deleteCallback(handler);
    }

    uint64_t connectOnLostUser(const OnLostUser& callback)
    {
        return _onLostUserCallbackStruct->addCallback(callback);
    }

    void disconnectOnLostUser(uint64_t handler)
    {
        _onLostUserCallbackStruct->deleteCallback(handler);
    }

    UserFrame::Ptr getUserFrame()
    {
        UserTrackerDataPtr data = nuitrack_GetUserTrackerData(_pimpl);
        UserFrame::Ptr newFrame(new UserFrame(data));
        return newFrame;
    }

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

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

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

private:

    static void onUpdateCallback(UserTrackerData* userFrameImpl, UserTracker* tracker)
    {
        UserFrame::Ptr newFrame(new UserFrame(userFrameImpl));
        tracker->_onUpdateCallbackStruct->executeAllCallbacks(newFrame);
    }

    static void onNewUserCallback(int usedID, UserTracker* tracker)
    {
        tracker->_onNewUserCallbackStruct->executeAllCallbacks(usedID);
    }
    static void onLostUserCallback(int usedID, UserTracker* tracker)
    {
        tracker->_onLostUserCallbackStruct->executeAllCallbacks(usedID);
    }

    void destroyUserTracker()
    {
        if(_onUpdateCallbackStruct)
            delete _onUpdateCallbackStruct;
        if(_onNewUserCallbackStruct)
            delete _onNewUserCallbackStruct;
        if(_onLostUserCallbackStruct)
            delete _onLostUserCallbackStruct;
    }

    NuitrackModule* _pimpl;

    UserTrackerCallbackWrapper _callbackWrapper;

    CallbackStruct<UserFrame::Ptr>* _onUpdateCallbackStruct;
    CallbackStruct<int>* _onNewUserCallbackStruct;
    CallbackStruct<int>* _onLostUserCallbackStruct;
};

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


#endif /* NUITRACK_USERTRACKER_H_ */