/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Contains SSY Reference's channel configuration data

*

*/

#ifndef SSYREFERENCECONFIG_H

#define SSYREFERENCECONFIG_H

//  INCLUDES

#include <e32base.h>

#include <f32file.h>

#include <sensrvtypes.h>

#include <sensrvchannelinfo.h>

#include <gmxmlparser.h>

#include <sensrvchanneldatatypes.h>

#include <sensrvproximitysensor.h>

#include <sensrvilluminationsensor.h>

// CONSTANTS

// Data item sizes

const TInt KSsyRefAxisDataItemSize = sizeof( TSensrvAccelerometerAxisData );

const TInt KSsyRefTappingDataItemSize = sizeof( TSensrvTappingData );

const TInt KSsyRefProximityDataItemSize = sizeof( TSensrvProximityData );

const TInt KSsyRefAmbientLightDataItemSize = sizeof( TSensrvAmbientLightData );

const TInt KSsyRefMagneticAxisDataItemSize = sizeof( TSensrvMagnetometerAxisData );

// ENUMS

enum TSsyReferenceFunctions

    {

    ESsyReferenceOpenChannel,

    ESsyReferenceOpenChannelResp,

    ESsyReferenceDataItemReceived,

    ESsyReferenceCloseChannel,

    ESsyReferenceCloseChannelResp,

    ESsyReferenceStartChannelData,

    ESsyReferenceStopChannelData

    };

/**

 * Base class for Channel data types. Contains iChannelDataType which is set

 * by derived classes on construction.

 */

class TSsyRefChannelDataBase

    {

    public:

    /**

     * Enumeration for possible channel data types

     */

    enum TSsyRefChannelDataType

        {

        ESsyRefChannelTypeTapping = 5000,

        ESsyRefChannelTypeAxis,

        ESsyRefChannelTypeProximity,

        ESsyRefChannelTypeAmbientLight,

        ESsyRefChannelTypeMagneticAxis

        };

    TInt  ChannelDataType() const { return iChannelDataType; }

    TInt  Interval() const { return iInterval; }

    void SetTimestamp( const TTime aTimestamp ) { iTimestamp = aTimestamp; }

    TTime Timestamp() const { return iTimestamp; }

    TInt  Size() const { return iSize; }

    protected:

    /**

     * Protected constructor as this class is not supposed to be instantiate

     * directly.

     */

    TSsyRefChannelDataBase() {}

    protected: // data

    /**

     * Identifies the type of data type class derived from this base class

     */

    TInt iChannelDataType;

    /**

     * Interval. Indicates time in ms from previous item until next item is produced

     */

    TInt iInterval;

    /**

     * Timestamp. Time when this data item is generated.

     */

    TTime iTimestamp;

    /**

     * Size of one data item. This is filled by derived class

     */

    TInt iSize;

    /**

     * Axis data item values. 

     * Accessible from TSsyRefChannelDataAxis/TSsyRefChannelDataMagneticAxis classes

     */

    TInt iXAxis;

    TInt iYAxis;

    TInt iZAxis;

    /**

     * Axis data calibrated values. 

     * Accessible from TSsyRefChannelDataMagneticAxis classes

     */

    TInt iXAxisCalib;

    TInt iYAxisCalib;

    TInt iZAxisCalib;

    /**

     * Proximity data item values.

     * Accessible only from TSsyRefChannelProximity class

     */    

    TInt iProximityState;

    /**

     * AmbientLight data item values.

     * Accessible only from TSsyRefChannelAmbientLight class

     */    

    TInt iAmbientLightState;

    /**

     * Tapping data item values. Difrection of the tapping.

     * Accessible only from TSsyRefChannelDataTapping class

     */

    TInt iDirection;

    };

// Type definition array for Data item base class

typedef RArray<TSsyRefChannelDataBase> TSsyRefDataItemArray;

/**

 * Message item for SSY <--> Sensor communications

 * Contains Channel ID for which the message belongs to,

 * Function ID that identifies the command and

 * error for error cases. 

 */

class TSsyReferenceMsg

    {

    public:

    /**

    * Constructor of the TSsyReferenceMsg

    *

    * @since S60 5.0

    * @param[in] aChannelId Channel identifier

    * @param[in] aFunction See TSsyReferenceFunctions

    */  

    TSsyReferenceMsg( TInt aChannelId, TInt aFunction ) : 

        iChannelId( aChannelId ), 

        iFunction( aFunction ),

        iError( KErrNone )

        {}

    /**

     * Copy constructor of the TSsyReferenceMsg

     *

     * @since S60 5.0

     * @param[in] aMsg Object to be copied to constructed object

     */    

    TSsyReferenceMsg( const TSsyReferenceMsg& aMsg ) :

        iChannelId( aMsg.iChannelId ),

        iFunction( aMsg.iFunction ),

        iError( aMsg.iError )

        {}

    TInt ChannelId() { return iChannelId; }

    void SetFunction( TInt aFunction ) { iFunction = aFunction; }

    TInt Function()  { return iFunction; }

    void SetError( TInt aError ) { iError = aError; }

    TInt Error()     { return iError; }

    void SetDataItem( TSsyRefChannelDataBase* aDataItem ) { iDataItem = aDataItem; }

    TSsyRefChannelDataBase* DataItem() const { return iDataItem; }

    private: // data

    TInt iChannelId; // Identifies the channel

    TInt iFunction;  // Identifies the command

    TInt iError;     // Error is passed to response handler

    // Data item for received data. This is casted to correct data item 

    // class implementation according to ChannelDataType

    TSsyRefChannelDataBase* iDataItem;

    };

/**

 * Tapping data type class implementation.

 */

class TSsyRefChannelDataTapping : public TSsyRefChannelDataBase

    {

    public:

    TSsyRefChannelDataTapping( TInt aDirection, TInt aInterval  )

        { 

        iChannelDataType = ESsyRefChannelTypeTapping;

        iSize = KSsyRefTappingDataItemSize;

        iInterval = aInterval;

        iDirection = aDirection;

        }

    TInt Direction() const { return iDirection; }

    };

/**

 * XYZ Axis data type class implementation.

 */

class TSsyRefChannelDataAxis : public TSsyRefChannelDataBase

    {

    public:

    TSsyRefChannelDataAxis( TInt aXAxis, TInt aYAxis, TInt aZAxis, 

                            TInt aInterval )

        { 

        iChannelDataType = ESsyRefChannelTypeAxis;

        iSize = KSsyRefAxisDataItemSize;

        iInterval = aInterval; 

        iXAxis = aXAxis;

        iYAxis = aYAxis;

        iZAxis = aZAxis;

        }

    TInt XAxis() const { return iXAxis; }

    TInt YAxis() const { return iYAxis; }

    TInt ZAxis() const { return iZAxis; }

    };

/**

 * Proximity data type class implementation.

 */

class TSsyRefChannelDataProximity : public TSsyRefChannelDataBase

    {

    public:

    TSsyRefChannelDataProximity( TInt aProximityState, TInt aInterval )

        { 

        iChannelDataType = ESsyRefChannelTypeProximity;

        iSize = KSsyRefProximityDataItemSize;

        iInterval = aInterval; 

        iProximityState = aProximityState;

        }

    TInt ProximityState() const { return iProximityState; }

    };

/**

 * AmbientLight data type class implementation.

 */

class TSsyRefChannelDataAmbientLight : public TSsyRefChannelDataBase

    {

    public:

    TSsyRefChannelDataAmbientLight( TInt aAmbientLightState, TInt aInterval )

        { 

        iChannelDataType = ESsyRefChannelTypeAmbientLight;

        iSize = KSsyRefAmbientLightDataItemSize;

        iInterval = aInterval; 

        iAmbientLightState = aAmbientLightState;

        }

    TInt AmbientLightState() const { return iAmbientLightState; }

    };

/**

 * XYZ Axis data type class implementation.

 */

class TSsyRefChannelDataMagneticAxis : public TSsyRefChannelDataBase

    {

    public:

    TSsyRefChannelDataMagneticAxis( TInt aXAxis, TInt aYAxis, TInt aZAxis, 

        TInt aXAxisCalib, TInt aYAxisCalib, TInt aZAxisCalib, TInt aInterval )

        { 

        iChannelDataType = ESsyRefChannelTypeMagneticAxis;

        iSize = KSsyRefMagneticAxisDataItemSize;

        iInterval = aInterval; 

        iXAxis = aXAxis;

        iYAxis = aYAxis;

        iZAxis = aZAxis;

        iXAxisCalib = aXAxisCalib;

        iYAxisCalib = aYAxisCalib;

        iZAxisCalib = aZAxisCalib;

        }

    TInt XAxis() const { return iXAxis; }

    TInt YAxis() const { return iYAxis; }

    TInt ZAxis() const { return iZAxis; }

    TInt XAxisCalib() const { return iXAxisCalib; }

    TInt YAxisCalib() const { return iYAxisCalib; }

    TInt ZAxisCalib() const { return iZAxisCalib; }

    };

/**

 * Channel ID pair class for pairing config file channel id and

 * Sensor Server generated channel ID.

 *

 */

class TSsyRefChannelIdPair

    {

    public:

    /**

    * Constructor of the TSsyRefChannelIdPair

    *

    * @since S60 5.0

    * @param[in] aConfigChannelId Channel identifier from config file

    */  

    TSsyRefChannelIdPair( TInt aConfigChannelId ) : 

        iConfigChannelId( aConfigChannelId )

        {}

    TInt ConfigId() const { return iConfigChannelId; }

    TInt ServerId() const { return iSrvChannelId; }

    void SetServerId( const TInt aSrvId ) { iSrvChannelId = aSrvId; }

    private: // data

    TInt iConfigChannelId; // Config file ID of the channel

    TInt iSrvChannelId;    // Sensor server assigned ID of the channel

    };

typedef RArray<TSsyRefChannelIdPair> TSsyRefChannelIdArray;

// CONSTANTS

/**

 *  Configuration class for SSY reference plugin. Generates configured SSY channel information.

 *  This keeps reference SSY implementation independent from 'sensor' it uses. This class is fully

 *  modifiable regarding to the needs of this SSY. It may be for example accelerometer sensor 

 *  without any changes in the SSY reference implementation. Only this class is modified.

 *

 *  @lib ssyreferenceplugin.lib

 *  @since S60 5.0

 */

class CSsyReferenceConfig : public CActive, public MMDXMLParserObserver

    {

public:

    /**

     * Two-phase constructor

     *

     * @since S60 5.0

     * @return CSsyReferenceConfig* Pointer to created CSsyReferenceControl object

     */

    static CSsyReferenceConfig* NewL();

    /**

     * Virtual destructor

     *

     * @since S60 5.0

     */

    virtual ~CSsyReferenceConfig();

    /**

     * From CActive

     */

    void RunL();

    /**

     * From CActive

     */

    void DoCancel();

    /**

     * From CActive

     */

    TInt RunError( TInt aError );

    /**

     * From MMDXMLParserObserver

     *

	 * Call back function used to inform a client of the Parser when a parsing operation completes.

     * @since S60 5.0

	 */

	void ParseFileCompleteL();

    /**

	 * Starts parsing config file. This function blocks until file is parsed

     * @since S60 5.0

	 */

	void InitConfigL();

    /**

     * Total number of channels this SSY provides

     *

     * @since S60 5.0

     * @return TInt Count of channels this SSY is configured to provide

     */

    TInt ChannelCount();

    /**

     * Generates channels this SSY is configured to provide

     *

     * @since S60 5.0

     * @param[in,out] aChannnelList Filled with generated channels by this configurator

     */

    void GenerateChannels( RSensrvChannelInfoList& aChannelList );

    /**

     * Updates Sensor server's generated channel Ids

     *

     * @since S60 5.0

     * @param[in] aChannnelList Same list as GenerateChannels produces but 

     *                this contains channel identifiers

     */

    void UpdateChannelIds( RSensrvChannelInfoList aChannelList );

    /**

     * Reads all channel data information from config file and fills

     * parameters with information

     *

     * @since S60 5.0

     * @param[in]     aSrvChannelId Sensor server generated channel id of the target channel

     * @param[in,out] aDataItemList Contains data item objects defined in config file. Each

     *                Data item is presented as Data Item class derived from TSsyRefChannelDataBase.

     *                List can contain only one type of derived channel data items

     * @param[in,out] aStartInterval Contains start interval to start producing data items

     */

    void GetChannelDataInformationL( const TInt aSrvChannelId, 

                                     TSsyRefDataItemArray& aDataItemList, 

                                     TInt& aStartInterval );

    /**

     * Reads sensor properties from config file and adds them to list

     *

     * @since S60 5.0

     * @param[out] aPropertyList List where to append properties

     */

    void GetSensorPropertiesL( RSensrvPropertyList& aPropertyList );

    /**

     * Reads channel properties from config file and adds them to list

     *

     * @since S60 5.0

     * @param[in] aSenSrvChannelId Sensor server generated channel id

     * @param[out] aPropertyList List where to append properties

     */

    void GetChannelPropertiesL( const TInt aSrvChannelId, 

                                RSensrvPropertyList& aPropertyList );

private:

    /**

     * C++ constructor.

     */

    CSsyReferenceConfig();

    /**

     * Symbian 2nd phase constructor.

     */

    void ConstructL();

    /**

     * Makes synchronous calls asynchronous

     */

    void IssueRequest( TInt aError = KErrNone );

    /**

     * Reads attribute value from element and casts it into TInt value

     * 

     * @since S60 5.0

     * @param[in] aElement Element from where to read attribute

     * @param[in] aAttrib Attribute name which to read

     * @return TInt Integer value of read value

     */

    TInt GetAttributeIntValue( CMDXMLElement& aElement, const TDesC& aAttrib );

    /**

     * Reads attribute value from element and casts it into literal value

     * 

     * @since S60 5.0

     * @param[in] aElement Element from where to read attribute

     * @param[in] aAttrib Attribute name which to read

     * @param[in/out] aTarget Target descriptor where to copy read literal

     */

    void GetAttributeStrValue( CMDXMLElement& aElement, const TDesC& aAttrib, TDes8& aTarget );

    /**

     * Reads attribute value from element and casts it into TReal value

     * 

     * @since S60 5.0

     * @param[in] aElement Element from where to read attribute

     * @param[in] aAttrib Attribute name which to read

     * @return TReal value of the attribute

     */

    TReal GetAttributeRealValue( CMDXMLElement& aElement, const TDesC& aAttrib );

    /**

     * Reads Hexadesimal attribute value from element and casts it into Integer value

     * 

     * @since S60 5.0

     * @param[in] aElement Element from where to read attribute

     * @param[in] aAttrib Attribute name which to read

     * @return TUint Unsigned integer value of read Hexadesimal value

     */

    TUint GetAttributeHexValue( CMDXMLElement& aElement, const TDesC& aAttrib );

    /**

     * Compares Sensor server generated channel IDs and return corresponding 

     * ConfigFile channel id

     * 

     * @since S60 5.0

     * @param[in] aSrvChannelId SenServer generated channel ID for which pair is needed

     * @return TInt ConfigFile channel ID that is paired with aSrvChannelId

     */

    TInt ConfigChannelId( const TInt aSrvChannelId ) const;