SSensor.h

#ifndef _SENSOR_H_
#define _SENSOR_H_
 
#include <scolPlugin.h>
#include <boost/thread/thread.hpp>
#include <boost/bind/bind.hpp>
 
#include <set>
#include "tools/Quaternion.h"
#include "orientationTracker.h"
 
//Tickcount function
#ifndef _WIN32
#include <time.h>
 
int64_t GetTickCountNano();
#else
#include "Windows.h"
int64_t GetTickCountNano();
#endif
 
 
typedef struct
{
  Vector3d vec3;
  float fval;
  double delta;
} SSensorData;
 
enum SSensorType{
  SSENSOR_TYPE_UNKNOWN,
  SSENSOR_TYPE_ACCELEROMETER,
  SSENSOR_TYPE_MAGNETIC_FIELD,
  SSENSOR_TYPE_GYROSCOPE,
  SSENSOR_TYPE_LIGHT,
  SSENSOR_TYPE_PROXIMITY,
  SSENSOR_TYPE_ORIENTATION
};
 
//Update global mutex
static boost::shared_mutex mGlobalMutex;
 
class SSensorCb
{
public:
protected:
  SSensorType mType;
private:
public:
  SSensorCb(SSensorType type);
  ~SSensorCb();
  SSensorType GetType();
};
 
/*  CLASS NAME: Sensor
 *  \brief Represents a sensor.
 
 *  Used to store sensor datas received by events. The purpose if to get datas synchronously (by a simple 'get' method)
 */
class SSensor
{
  /* * * * * * * * * * * * * FRIENDS * * * * * * * * * * * * */
 
  /* * * * * * * * * * * * * ATTRIBUTES * * * * * * * * * * * * */
  public:
  protected:
    SSensorType mType;
    bool mEnabled;
    bool mPaused;
    int64_t mLastTimeStamp;
    std::list<SSensorCb*> mAxisCallbacks;
  private:
 
  /* * * * * * * * * * * * * CONSTRUCTORS * * * * * * * * * * * * */
  public:
    SSensor();
    SSensor(SSensorType type);
    ~SSensor();
  protected:
  private:
 
  /* * * * * * * * * * * * * METHODS * * * * * * * * * * * * */
  public:
    SSensorType GetType();
    bool IsEnabled();
    void SetEnabled(bool enabled);
    bool IsPaused();
    void SetPaused(bool paused);
    SSensorCb* AddCallBack();
    void RemoveCallBack(SSensorCb* sensorCb);
    void CallSensorCb(SSensorData data);
    double GetElapsedTime(int64_t timeStamp);
 
    virtual SSensorData GetData() = 0;
  protected:
  private:
};
 
/*  CLASS NAME: SensorManager
 *  \brief Manager sensors.
 
 *  Used to list sensor objects. It is possible to manage them through this class (enable/disable, ...).
 */
class SSensorManager
{
  /* * * * * * * * * * * * * FRIENDS * * * * * * * * * * * * */
 
  /* * * * * * * * * * * * * ATTRIBUTES * * * * * * * * * * * * */
  public:
  protected:
    std::set<SSensor*> mSensorList;
    OrientationTracker* mOrientationTracker;
    static SSensorManager* mSingletonInstance;
  private:
 
  /* * * * * * * * * * * * * CONSTRUCTORS * * * * * * * * * * * * */
  public:
    SSensorManager();
    virtual ~SSensorManager();
  protected:
  private:
 
  /* * * * * * * * * * * * * METHODS * * * * * * * * * * * * */
  public:
    static SSensorManager* GetInstance();
    static void Kill();
 
    SSensor* GetSensorByType(SSensorType sensorType);
    std::set<SSensor*> GetSensorList();
 
    bool IsAvailable(SSensorType sensorType);
    bool IsEnabled(SSensorType sensorType);
 
    SSensorCb* AddSensorCallBack(SSensorType sensorType);
    void RemoveSensorCallBack(SSensorCb* sensorCb);
 
    virtual int SetSensorEnable(SSensorType sensorType, bool state) = 0;
    virtual void Vibrate(long millis) = 0;
    virtual void StartVibration() = 0;
    virtual void StopVibration() = 0;
    virtual void VibratePattern(std::vector<int> pattern, bool loop) = 0;
 
    virtual void StartLocationService() = 0;
    virtual void StopLocationService() = 0;
    virtual bool GetLocation(float &longitude, float &latitude, float &altitude) = 0;
 
    void PauseSensorManager();
    void ResumeSensorManager();
 
    OrientationTracker* GetOrientationTracker();
    Quaternion GetDeviceOrientation(double timeOffsetInSeconds);
 
  protected:
  private:
};
 
#endif