SkeletonTracker.h

#ifndef NUITRACK_SKELETONTRACKER_H_
#define NUITRACK_SKELETONTRACKER_H_

#include <functional>

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

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

    typedef std::function<void (SkeletonData::Ptr)> OnUpdate;
    typedef void (*OnUpdateRawFunctionPtr)(SkeletonData*, SkeletonTracker*);

    typedef std::function<void (SkeletonTracker::Ptr, int)> OnNewUser;
    typedef void (*OnNewUserRawFunctionPtr)(SkeletonTracker*, int);

    typedef std::function<void (SkeletonTracker::Ptr, int)> OnLostUser;
    typedef void (*OnLostUserRawFunctionPtr)(SkeletonTracker*, int);

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

    SkeletonTracker(NuitrackModule* pimpl)
    {
        _pimpl = pimpl;
        _isCopy = 0;

        _onUpdateCallbackStruct = new CallbackStruct<SkeletonData::Ptr>();
        _onNewUserCallbackStruct = new CallbackStruct2p<SkeletonTracker::Ptr, int>();
        _onLostUserCallbackStruct = new CallbackStruct2p<SkeletonTracker::Ptr, int>();

        _callbackWrapper.setSkeletonTracker(this);
        _callbackWrapper.setOnUpdateAddress(&onUpdateCallback);
        _callbackWrapper.setOnNewUserAddress(&onNewUserCallback);
        _callbackWrapper.setOnLostUserAddress(&onLostUserCallback);
        nuitrack_registerSkeletonTrackerCallback(_pimpl, &_callbackWrapper);
    }

    SkeletonTracker(NuitrackModule* pimpl,  CallbackStruct<SkeletonData::Ptr>* onUpdateCallbackStruct,
                                    CallbackStruct2p<SkeletonTracker::Ptr, int>* onNewUserCallbackStruct,
                                    CallbackStruct2p<SkeletonTracker::Ptr, int>* onLostUserCallbackStruct)
    {
        _pimpl = pimpl;
        _isCopy = 1;

        _onUpdateCallbackStruct = onUpdateCallbackStruct;
        _onNewUserCallbackStruct = onNewUserCallbackStruct;
        _onLostUserCallbackStruct = onLostUserCallbackStruct;
    }

    virtual ~SkeletonTracker()
    {
        if(_isCopy == 0)
        {
            nuitrack_DestroySkeletonTracker(_pimpl);
            destroySkeletonTracker();
        }
    }

    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);
    }

    void setNumActiveUsers(int numUsers)
    {
        nuitrack_SetNumActiveUsers(_pimpl, numUsers);
    }

    bool isAutoTracking() const
    {
        return nuitrack_IsAutoTracking(_pimpl);
    }

    void setAutoTracking(bool tracking)
    {
        nuitrack_SetAutoTracking(_pimpl, tracking);
    }

    void startTracking(int userID)
    {
        nuitrack_StartTracking(_pimpl, userID);
    }

    void stopTracking(int userID)
    {
        nuitrack_StopTracking(_pimpl, userID);
    }

    bool isTracking(int userID)
    {
        return nuitrack_IsTracking(_pimpl, userID);
    }

    SkeletonData::Ptr getSkeletons()
    {
        SkeletonTrackerDataPtr data = nuitrack_GetSkeletonTrackerData(_pimpl);
        SkeletonData::Ptr newFrame = SkeletonData::Ptr(new SkeletonData(data));
        return newFrame;
    }

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

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

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

protected:
    static void onUpdateCallback(SkeletonTrackerData* frame, SkeletonTracker* tracker)
    {
        SkeletonData::Ptr newFrame = SkeletonData::Ptr(new SkeletonData(frame));

        tracker->_onUpdateCallbackStruct->executeAllCallbacks(newFrame);
    }

    static void onNewUserCallback(SkeletonTracker* tracker, int usedID)
    {

        SkeletonTracker::Ptr ptr = SkeletonTracker::Ptr(
                new SkeletonTracker(tracker->_pimpl, tracker->_onUpdateCallbackStruct,
                    tracker->_onNewUserCallbackStruct, tracker->_onLostUserCallbackStruct));

        tracker->_onNewUserCallbackStruct->executeAllCallbacks(ptr, usedID);
    }

    static void onLostUserCallback( SkeletonTracker* tracker, int usedID)
    {

        SkeletonTracker::Ptr ptr = SkeletonTracker::Ptr(
                new SkeletonTracker(tracker->_pimpl, tracker->_onUpdateCallbackStruct,
                    tracker->_onNewUserCallbackStruct, tracker->_onLostUserCallbackStruct));

        tracker->_onLostUserCallbackStruct->executeAllCallbacks(ptr, usedID);
    }

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

    NuitrackModule* _pimpl; 
    int8_t _isCopy; 

    CallbackStruct<SkeletonData::Ptr>* _onUpdateCallbackStruct; 
    CallbackStruct2p<SkeletonTracker::Ptr, int>* _onNewUserCallbackStruct; 
    CallbackStruct2p<SkeletonTracker::Ptr, int>* _onLostUserCallbackStruct; 

    SkeletonTrackerCallbackWrapper _callbackWrapper; 

};

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

#endif /* NUITRACK_SKELETONTRACKER_H_ */