NyxSensorConnector.h

Go to the documentation of this file.

/* @@@LICENSE
*
*      Copyright (c) 2011-2012 Hewlett-Packard Development Company, L.P.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* LICENSE@@@ */



#ifndef __NYX_SENSOR_CONNECTOR_H__
#define __NYX_SENSOR_CONNECTOR_H__

#include <limits.h>
#include <QObject>
#include <QSocketNotifier>
#include <QEvent>
#include <vector>
#include <string>

#include <nyx/nyx_client.h>

#include "CustomEvents.h"

#define INVALID_ANGLE (INT_MIN)

// Forward declaration
struct json_object;
class NYXConnectorObserver;

class NYXConnectorBase : public QObject
{
    Q_OBJECT
public:
    typedef enum
    {
        SensorIllegal = 0,
        SensorFirst,
        SensorAcceleration = SensorFirst,
        SensorOrientation,
        SensorShake,
        SensorALS,
        SensorAngularVelocity,
        SensorBearing,
        SensorGravity,
        SensorLinearAcceleration,
        SensorMagneticField,
        SensorScreenProximity,
        SensorRotation,
        SensorLogicalAccelerometer,             
        SensorLogicalOrientation,               
        SensorLogicalDeviceOrientation,         
        SensorLogicalMotion,                    
        SensorLast = SensorLogicalMotion        
    }Sensor;


    typedef enum
    {
        SensorReportRateUnknown = NYX_REPORT_RATE_UNKNOWN,  
        SensorReportRateDefault = NYX_REPORT_RATE_DEFAULT,  
        SensorReportRateLow     = NYX_REPORT_RATE_LOW,      
        SensorReportRateMedium  = NYX_REPORT_RATE_MEDIUM,   
        SensorReportRateHigh    = NYX_REPORT_RATE_HIGH,     
        SensorReportRateHighest = NYX_REPORT_RATE_HIGHEST,  
        SensorReportRateCount   = NYX_REPORT_RATE_COUNT     
    }SensorReportRate;

    virtual ~NYXConnectorBase ();

    static std::vector<NYXConnectorBase::Sensor> getSupportedSensors();

    static std::string getSupportedSensors(bool bJson);

    static NYXConnectorBase* getSensor (Sensor aSensorType,
                                        NYXConnectorObserver *aObserver = 0,
                                        bool bCanPostEvent = true);

    virtual bool on();

    virtual bool off();

    virtual bool setRate(SensorReportRate aRate);

    virtual void setOrientationAngle(int aAngle)
    {
        if (INVALID_ANGLE != aAngle)
        {
            m_OrientationAngle = aAngle;
        }
    }

    virtual std::string toJSONString();

    virtual json_object* toJSONObject() = 0;

    virtual QEvent* getQSensorData() = 0;

    virtual inline nyx_device_handle_t getHandle()
    {
        return m_Handle;
    }

    inline Sensor type()
    {
        return m_SensorType;
    }

    virtual void scheduleDeletion();

protected:
    NYXConnectorBase (Sensor aSensorType, nyx_device_type_t aDevType, nyx_device_id_t aDevID, NYXConnectorObserver *aObserver, bool bCanPostEvent);

    virtual nyx_error_t openSensor ();

    virtual void connectSensorSignalToSlot();

    void callObserver(bool aShouldEmit = true);

    inline bool canPostEvent()
    {
        return m_CanPostEvent;
    }

private:
    static NYXConnectorBase::Sensor MapFromNYX(nyx_device_type_t aNYXDevType);

Q_SIGNALS:
    virtual void sensorDataAvailable();

protected Q_SLOTS:
    virtual void readSensorData(int aSocket) = 0;

protected:
    // Functions

    virtual void postProcessSensorData() {}

    // Data
    Sensor                      m_SensorType;
    QSocketNotifier*            m_NYXSensorNotifier;
    nyx_device_handle_t         m_Handle;
    nyx_device_type_t           m_NYXDeviceType;
    nyx_device_id_t             m_NYXDeviceId;
    NYXConnectorObserver       *m_Observer;
    int                         m_SensorFD;
    bool                        m_CanPostEvent;
    int                         m_OrientationAngle;
    bool                        m_Finished;
};

class NYXConnectorObserver
{
public:
    virtual void NYXDataAvailable (NYXConnectorBase::Sensor aSensorType) = 0;
};

class NYXAccelerationSensorConnector : public NYXConnectorBase
{
    Q_OBJECT
public:
    NYXAccelerationSensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    inline float X() const { return m_AccelerationData.x; }

    inline float Y() const { return m_AccelerationData.y; }

    inline float Z() const { return m_AccelerationData.z; }

    virtual json_object* toJSONObject();

    virtual QEvent* getQSensorData();

protected Q_SLOTS:
    virtual void readSensorData(int aSocket);

protected:
    virtual void postProcessSensorData();

private:
    // Data
    nyx_sensor_acceleration_event_item_t    m_AccelerationData;
};

class NYXAlsSensorConnector : public NYXConnectorBase
{
    Q_OBJECT
public:
    NYXAlsSensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    inline int getLightIntensity() { return m_LightIntensity; }

    virtual json_object* toJSONObject();

    virtual QEvent* getQSensorData();

protected Q_SLOTS:
    virtual void readSensorData(int aSocket);

private:
    int     m_LightIntensity;
};

class NYXAngularVelocitySensorConnector : public NYXConnectorBase
{
    Q_OBJECT
public:
    NYXAngularVelocitySensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    inline float X() const { return m_AngularVelocity.x; }

    inline float Y() const { return m_AngularVelocity.y; }

    inline float Z() const { return m_AngularVelocity.z; }

    virtual json_object* toJSONObject();

    virtual QEvent* getQSensorData();

protected Q_SLOTS:
    virtual void readSensorData(int aSocket);

private:
    nyx_sensor_angular_velocity_event_item_t  m_AngularVelocity;
};

class NYXBearingSensorConnector : public NYXConnectorBase
{
    Q_OBJECT
public:
    NYXBearingSensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    inline float bearingMagnitude() const { return m_Bearing.magnetic; }

    inline float trueBearing() const { return m_Bearing.true_bearing; }

    inline float confidence() const { return m_Bearing.confidence; }

    virtual json_object* toJSONObject();

    bool setLocation(double aLatitude, double aLongitude);

    virtual QEvent* getQSensorData();

protected Q_SLOTS:
    virtual void readSensorData(int aSocket);

private:
    nyx_sensor_bearing_event_item_t m_Bearing;
};

class NYXGravitySensorConnector : public NYXConnectorBase
{
    Q_OBJECT
public:
    NYXGravitySensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    inline float X() const { return m_Gravity.x; }

    inline float Y() const { return m_Gravity.y; }

    inline float Z() const { return m_Gravity.z; }

    virtual json_object* toJSONObject();

    virtual QEvent* getQSensorData();

protected Q_SLOTS:
    virtual void readSensorData(int aSocket);

private:
    nyx_sensor_gravity_event_item_t m_Gravity;
};

class NYXLinearAccelearationSensorConnector : public NYXConnectorBase
{
    Q_OBJECT
public:
    NYXLinearAccelearationSensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    inline float X() const { return m_LinearAcceleration.x; }

    inline float Y() const { return m_LinearAcceleration.y; }

    inline float Z() const { return m_LinearAcceleration.z; }

    inline float WorldX() const { return m_LinearAcceleration.world_x; }

    inline float WorldY() const { return m_LinearAcceleration.world_y; }

    inline float WorldZ() const { return m_LinearAcceleration.world_z; }

    virtual json_object* toJSONObject();

    virtual QEvent* getQSensorData();

protected Q_SLOTS:
    virtual void readSensorData(int aSocket);

private:
    nyx_sensor_linear_acceleration_event_item_t m_LinearAcceleration;
};

class NYXMagneticFieldSensorConnector : public NYXConnectorBase
{
    Q_OBJECT
public:
    NYXMagneticFieldSensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    inline int X() const { return m_MagneticField.x; }

    inline int Y() const { return m_MagneticField.y; }

    inline int Z() const { return m_MagneticField.z; }

    inline int rawX() const { return m_MagneticField.raw_x; }

    inline int rawY() const { return m_MagneticField.raw_y; }

    inline int rawZ() const { return m_MagneticField.raw_z; }

    virtual json_object* toJSONObject();

    virtual QEvent* getQSensorData();

protected Q_SLOTS:
    virtual void readSensorData(int aSocket);

private:
    nyx_sensor_magnetic_field_event_item_t  m_MagneticField;
};

class NYXOrientationSensorConnector : public NYXConnectorBase
{
    Q_OBJECT
public:
    NYXOrientationSensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    inline OrientationEvent::Orientation getOrientation()
    {
        return m_Orientation;
    }

    const char* toPositionString();

    virtual json_object* toJSONObject();

    virtual QEvent* getQSensorData();

protected:
    virtual void postProcessSensorData();

protected Q_SLOTS:
    virtual void readSensorData(int aSocket);

private:
    OrientationEvent::Orientation mapAccelerometerOrientation(int aValue);

    // Data
    OrientationEvent::Orientation         m_Orientation;
};

class NYXScreenProximitySensorConnector : public NYXConnectorBase
{
    Q_OBJECT
public:
    NYXScreenProximitySensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    inline bool Present() const { return (bool)m_Present; }

    virtual QEvent* getQSensorData();

    virtual json_object* toJSONObject() { return 0; }

protected Q_SLOTS:
    virtual void readSensorData(int aSocket);

private:
    int m_Present;
};

class NYXRotationSensorConnector : public NYXConnectorBase
{
    Q_OBJECT
public:
    NYXRotationSensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    inline float pitch() const { return m_RotationData.euler_angle.pitch; }

    inline float roll() const { return m_RotationData.euler_angle.roll; }

    inline float yaw() const { return m_RotationData.euler_angle.yaw; }

    inline float quaternionW() const { return m_RotationData.quaternion_vector.w; }
    inline float quaternionX() const { return m_RotationData.quaternion_vector.x; }
    inline float quaternionY() const { return m_RotationData.quaternion_vector.y; }
    inline float quaternionZ() const { return m_RotationData.quaternion_vector.z; }

    inline const float* rotationMatrix() const { return m_RotationData.matrix; }

    virtual json_object* toJSONObject();

    virtual QEvent* getQSensorData();

protected Q_SLOTS:
    virtual void readSensorData(int aSocket);

protected:
    virtual void postProcessSensorData();

private:
    nyx_sensor_rotation_event_item_t m_RotationData;
};

class NYXShakeSensorConnector : public NYXConnectorBase
{
    Q_OBJECT
public:
    NYXShakeSensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    inline ShakeEvent::Shake shakeState() const
    {
        return m_ShakeState;
    }

    inline float shakeMagnitude() const { return m_ShakeMagnitude; }

    virtual json_object* toJSONObject();

    virtual QEvent* getQSensorData();

protected Q_SLOTS:
    virtual void readSensorData(int aSocket);

private:
    ShakeEvent::Shake mapShakeSensorEvent(int aValue);

    const char* toShakeStateString();

    // Data
    ShakeEvent::Shake   m_ShakeState;
    float               m_ShakeMagnitude;
};

class NYXLogicalSensorConnectorBase : public NYXConnectorBase
{
    Q_OBJECT
public:
    virtual ~NYXLogicalSensorConnectorBase();

    virtual bool on();

    virtual bool off();

    virtual bool setRate(SensorReportRate aRate);

    virtual void setOrientationAngle(int aAngle);

    virtual void scheduleDeletion();

    virtual json_object* toJSONObject();

protected:
    NYXLogicalSensorConnectorBase (Sensor aSensorType, NYXConnectorObserver *aObserver, bool bCanPostEvent);

    virtual nyx_error_t openSensor () { return NYX_ERROR_NONE;}

    virtual void connectSensorSignalToSlot() { /* do nothing */ }

protected Q_SLOTS:
    virtual void readSensorData(int ) { /* do nothing. It's an logical sensor and not the physical one */ }

    void logicalSensorDataAvailable();

protected:
    std::vector<NYXConnectorBase *>          m_SensorList;
};

class NYXLogicalAccelerometerSensorConnector : public NYXLogicalSensorConnectorBase
{
    Q_OBJECT
public:
    NYXLogicalAccelerometerSensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    virtual QEvent* getQSensorData();

private:
    QEvent* readAllSensorData();
};

class NYXLogicalOrientationSensorConnector : public NYXLogicalSensorConnectorBase
{
    Q_OBJECT
public:
    NYXLogicalOrientationSensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    virtual QEvent* getQSensorData();

private:
    QEvent* readAllSensorData();
};

class NYXLogicalDeviceOrientationSensorConnector : public NYXLogicalSensorConnectorBase
{
    Q_OBJECT
public:
    NYXLogicalDeviceOrientationSensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    virtual QEvent* getQSensorData() { return 0; }
};

class NYXLogicalDeviceMotionSensorConnector : public NYXLogicalSensorConnectorBase
{
    Q_OBJECT
public:
    NYXLogicalDeviceMotionSensorConnector (NYXConnectorObserver *aObserver, bool bCanPostEvent = true);

    virtual QEvent* getQSensorData() { return 0; }
};

#endif /* __NYX_SENSOR_CONNECTOR_H__ */