/*

* 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:  Configuration implementation of this SSY

*

*/

#include <sensrvsensorchannels.h>

#include <sensrvchanneldatatypes.h>

#include <sensrvtypes.h>

#include <f32file.h>

#include <gmxmldocument.h>

#include <gmxmlelement.h>

#include "ssyreferencecontrol.h"

#include "ssyreferenceconfig.h"

#include "ssyreferencetrace.h"

// ======== CONSTANTS =======

_LIT( KSsyReferenceCfgFileOrig, "Z:\\private\\1020507E\\reference\\SsyReferenceConfig.xml" );

_LIT( KSsyReferenceCfgFileExt, "C:\\ssyreference\\SsyReferenceConfig.xml" );

// Config file definitions

// Maximum attribute lenghth

const TInt KSsyRefMaxAttribLength = 20;

// TAG DEFINITIONS

_LIT( KSsyRefRootTag, "SsyReferenceConfig" );                   // Ssy general information tag

_LIT( KSsyRefGeneralInfoTag, "SsyGeneralInformation" );         // Ssy general information tag

_LIT( KSsyRefChannelInfoGroupTag, "ChannelInformationGroup" );  // Channel information group tag

_LIT( KSsyRefChannelItemTag, "ChannelItem" );                   // Channel item tag

_LIT( KSsyRefChannelDataTag, "ChannelData" );                   // Channel data tag

_LIT( KSsyRefChannelDataItemTag, "ChannelDataItem" );           // Channel data item tag

_LIT( KSsyRefProperties, "Properties" );                        // Properties tag

_LIT( KSsyRefPropertyItem, "PropertyItem" );                    // PropertyItem tag

// Data item definitions

_LIT( KSsyRefAxisDataItemTag, "SsyRefChannelDataAxis" );        // SsyRefChannelDataAxis data item tag

_LIT( KSsyRefXAxis, "XAxis" );                                  // XAxis from SsyRefChannelDataAxis

_LIT( KSsyRefYAxis, "YAxis" );                                  // YAxis from SsyRefChannelDataAxis

_LIT( KSsyRefZAxis, "ZAxis" );                                  // ZAxis from SsyRefChannelDataAxis

_LIT( KSsyRefTappingDataItemTag, "SsyRefChannelDataTapping" );  // SsyRefChannelDataTapping data item tag

_LIT( KSsyRefDirection, "Direction" );                          // Direction from SsyRefChannelDataTapping

_LIT( KSsyRefProximityDataItemTag, "SsyRefChannelDataProximity" );  // SsyRefChannelDataProximity data item tag

_LIT( KSsyRefProximityState, "ProximityState" );                                   // ProximityStatus from SsyRefChannelDataProximity

_LIT( KSsyRefAmbientLightDataItemTag, "SsyRefChannelDataAmbientLight" );  // SsyRefChannelDataAmbientLight data item tag

_LIT( KSsyRefAmbientLightState, "AmbientLightState" );                                   // AmbientLightStatus from SsyRefChannelDataAmbientLight

_LIT( KSsyRefMagneticAxisDataItemTag, "SsyRefChannelDataMagneticAxis" );        // SsyRefChannelDataMagneticAxis data item tag

_LIT( KSsyRefXAxisCalib, "XAxisCalib" );                        // XAxis from SsyRefChannelDataMagneticAxis

_LIT( KSsyRefYAxisCalib, "YAxisCalib" );                        // YAxis from SsyRefChannelDataMagneticAxis

_LIT( KSsyRefZAxisCalib, "ZAxisCalib" );                        // ZAxis from SsyRefChannelDataMagneticAxis

// ATTRIBUTE DEFINITIONS

_LIT( KSsyRefChannelCount, "ChannelCount" );    // Channel count from ChannelInformationGroup

_LIT( KSsyRefChannelId, "ChannelId" );          // Channel ID from ChannelItem

_LIT( KSsyRefContextType, "ContextType" );      // Context type from ChannelItem

_LIT( KSsyRefQuantity, "Quantity" );            // Quantity from ChannelItem

_LIT( KSsyRefChannelType, "ChannelType" );      // ChannelType from ChannelItem

_LIT( KSsyRefLocation, "Location" );            // Location from ChannelItem

_LIT( KSsyRefVendorId, "Vendor" );              // Vendor from ChannelItem

// Channel data item specific attribute definitions

_LIT( KSsyRefStartInterval, "StartIntervalMs" );              // StartInterval from ChannelData

_LIT( KSsyRefDataItemCount, "count" );                        // count from ChannelDataItem

_LIT( KSsyRefDataTypeID, "DataTypeId" );                      // DataTypeId from ChannelDataItem

_LIT( KSsyRefInterval, "IntervalMs" );                        // IntervalMs from ChannelDataItem

// Property spesific attributes

_LIT( KSsyRefPropertyId, "PropertyId" );              // PropertyId from PropertyItem

_LIT( KSsyRefArrayIndex, "ArrayIndex" );              // ArrayIndex from PropertyItem

_LIT( KSsyRefItemIndex, "ItemIndex" );                // ItemIndex from PropertyItem

_LIT( KSsyRefPropertyValue, "PropertyValue" );        // PropertyValue from PorpertyItem

_LIT( KSsyRefPropertyType, "PropertyType" );          // PropertyType from PropertyItem

_LIT( KSsyRefMaxValue, "MaxValue" );                  // MaxValue from PropertyItem

_LIT( KSsyRefMinValue, "MinValue" );                  // MinValue from PorpertyItem

_LIT( KSsyRefReadOnly, "ReadOnly" );                  // ReadOnly from PropertyItem

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// CSsyReferenceConfig C++ constructor

// ---------------------------------------------------------------------------

//

CSsyReferenceConfig::CSsyReferenceConfig() :

    CActive( EPriorityMuchLess )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::CSsyReferenceConfig()" ) ) );

    CActiveScheduler::Add( this );

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::CSsyReferenceConfig() - return" ) ) );

    }

// ---------------------------------------------------------------------------

// Symbian 2nd phase constructor

// ---------------------------------------------------------------------------

//

void CSsyReferenceConfig::ConstructL()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::ConstructL()" ) ) );

    // Create config file parser

    iConfigParser = CMDXMLParser::NewL( this );

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::ConstructL() - return" ) ) );

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::NewL

// ---------------------------------------------------------------------------

//

CSsyReferenceConfig* CSsyReferenceConfig::NewL()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::NewL()" ) ) );

    CSsyReferenceConfig* self = new ( ELeave ) CSsyReferenceConfig();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::NewL() - return" ) ) );

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CSsyReferenceConfig::~CSsyReferenceConfig()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::~CSsyReferenceConfig()" ) ) );

    if ( iConfigParser )

        {

        delete iConfigParser;

        iConfigParser = NULL;

        }

    if ( iGenralInfoElement )

        {

        delete iGenralInfoElement;

        iGenralInfoElement = NULL;

        }

    if ( iChannelGroupElement )

        {

        delete iChannelGroupElement;

        iChannelGroupElement = NULL;

        }

    if ( iSsyReferenceConfig )

        {

        delete iSsyReferenceConfig;

        iSsyReferenceConfig = NULL;

        }

    if ( iConfigFile )

        {

        delete iConfigFile;

        iConfigFile = NULL;

        }

    iChannelPairArray.Reset();

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::~CSsyReferenceConfig() - return" ) ) );

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::InitConfig

// ---------------------------------------------------------------------------

//

void CSsyReferenceConfig::InitConfigL()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::InitConfig()" ) ) );

    // Open config file

    RFs fileSession;

    User::LeaveIfError( fileSession.Connect() );

    // Locate extrenal file... 

    RFile file;

    TInt err( file.Open( fileSession, KSsyReferenceCfgFileExt, EFileRead ) );

    file.Close();

    // Check is external file found

    if ( KErrNone == err )

        {

        // Use SSY with external configuration

        iConfigParser->ParseFile( fileSession, KSsyReferenceCfgFileExt );

        }

    else

        {

        // Use SSY with original configuration

        // Start parsing file and wait notification to ParseFileCompleteL

        // XML Parser takes ownership of the RFs and closes it when file is parsed

        iConfigParser->ParseFile( fileSession, KSsyReferenceCfgFileOrig );

        }

    iConfigFileParsed = EFalse;

    // This active object has very low priority since XML parser uses Active objects also, 

    // so it is mandatory to let XML parser to complete sooner than this active object

    IssueRequest();

    iSchedulerWait.Start(); // Blocks until file is parsed

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::InitConfig() - return" ) ) );

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::IssueRequest

// ---------------------------------------------------------------------------

//

void CSsyReferenceConfig::IssueRequest( TInt aError )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::IssueRequest()" ) ) );

    // Provides synchronous function calls to be handled as asynchronous

    if ( !IsActive() )

        {

        SetActive();

        TRequestStatus *s = &iStatus;

	    User::RequestComplete( s, aError );

        }

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::IssueRequest() - return" ) ) );

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::RunL

// ---------------------------------------------------------------------------

//

void CSsyReferenceConfig::RunL()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::RunL() - %i" ), iStatus.Int() ) );

    if ( iConfigFileParsed )

        {

        // Stop blocking

        iSchedulerWait.AsyncStop();

        }

    else

        {

        // Continue RunL loop

        IssueRequest();

        }

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::RunL() - return" ) ) );

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::DoCancel

// ---------------------------------------------------------------------------

//

void CSsyReferenceConfig::DoCancel()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::DoCancel()" ) ) );

    // Stop blocking

    iSchedulerWait.AsyncStop();

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::DoCancel() - return" ) ) );

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::RunError

// ---------------------------------------------------------------------------

//

TInt CSsyReferenceConfig::RunError( TInt /*aError*/ )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::RunError()" ) ) );

    // Handle possible errors here and return KErrNone to prevent SSY from panic

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::RunError() - return" ) ) );

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::ParseFileCompleteL

// ---------------------------------------------------------------------------

//

void CSsyReferenceConfig::ParseFileCompleteL()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::ParseFileCompleteL()" ) ) );

    ERROR_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::ParseFileCompleteL(): parse error=%d", iConfigParser->Error() ) ) );

    // if the parser fails with KErrNoMemory, increase the default heap size for SSY's (key 3) in the repository 1020507E.txt exported by this component

    __ASSERT_DEBUG( iConfigParser->ErrorSeverity() != EXMLFatal, User::Invariant() ); //  OK to continue if not a fatal error

    // First get document

    iConfigFile = iConfigParser->DetachXMLDoc();

    // Then get document element

    CMDXMLElement*  documentElement = iConfigFile->DocumentElement();

    // Get root element, 'SsyReferenceConfig'

    iSsyReferenceConfig = documentElement->FirstChildOfType( KSsyRefRootTag );

    // Get gereral information element 

    iGenralInfoElement = iSsyReferenceConfig->FirstChildOfType( KSsyRefGeneralInfoTag );

    // Get channel information group element

    iChannelGroupElement = iSsyReferenceConfig->FirstChildOfType( KSsyRefChannelInfoGroupTag );

    // Get channel count

    iChannelCount = GetAttributeIntValue( *iChannelGroupElement, KSsyRefChannelCount );

    // No need to delete documentElement, it is owned by iConfigFile.

    documentElement = NULL;

    iConfigFileParsed = ETrue;

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::ParseFileCompleteL() - return" ) ) );

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::GetAttributeIntValue

// ---------------------------------------------------------------------------

//

TInt CSsyReferenceConfig::GetAttributeIntValue( CMDXMLElement& aElement, const TDesC& aAttrib )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::GetAttributeIntValue()" ) ) );

    COMPONENT_TRACE( ( _L( "  Element: %s", aElement.NodeName() ) ) );

    COMPONENT_TRACE( ( _L( "  Attribute: %s", aAttrib ) ) );

    TInt intValue( 0 );

    // Check availability

    if ( aElement.IsAttributeSpecified( aAttrib ) )

        {

        // Buffer to where to read value

        TBufC<KSsyRefMaxAttribLength> buffer( KNullDesC );

        TPtrC ptr( buffer );

        // Read attribute value

        aElement.GetAttribute( aAttrib, ptr );

        // Cast literal value into TInt

        TLex lexValue( ptr );

        lexValue.Val( intValue );

        }

    COMPONENT_TRACE( ( _L( "  IntValue: %i", intValue ) ) );

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::GetAttributeIntValue() - return" ) ) );

    return intValue;

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::GetAttributeStrValue

// ---------------------------------------------------------------------------

//

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

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::GetAttributeStrValue()" ) ) );

    COMPONENT_TRACE( ( _L( "  Element: %s", aElement.NodeName() ) ) );

    COMPONENT_TRACE( ( _L( "  Attribute: %s", aAttrib ) ) );

    // Check availability

    if ( aElement.IsAttributeSpecified( aAttrib ) )

        {

        // Buffer to where to read value

        TBufC<KSsyRefMaxAttribLength> buffer( KNullDesC );

        TPtrC ptr( buffer );

        // Read attribute value

        aElement.GetAttribute( aAttrib, ptr );

        // Copy string from 16-bit descriptor to 8-bit descriptor

        aTarget.Copy( ptr );

        }

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::GetAttributeStrValue() - return" ) ) );

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::GetAttributeHexValue

// ---------------------------------------------------------------------------

//

TUint CSsyReferenceConfig::GetAttributeHexValue( CMDXMLElement& aElement, const TDesC& aAttrib )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::GetAttributeHexValue()" ) ) );

    COMPONENT_TRACE( ( _L( "  Element: %s", aElement.NodeName() ) ) );

    COMPONENT_TRACE( ( _L( "  Attribute: %s", aAttrib ) ) );

    TUint32 hexValue( 0 );

    // Check availability

    if ( aElement.IsAttributeSpecified( aAttrib ) )

        {

        // Buffer to where to read value

        TBufC<KSsyRefMaxAttribLength> buffer( KNullDesC );

        TPtrC ptr( buffer );

        // Read attribute value

        aElement.GetAttribute( aAttrib, ptr );

        // Get bounded value and cast it into TUint32 (hex)

        TRadix radix( EHex );

        TUint limit( 0xFFFFFFFF );

        // Append string into Lex and skip first two characters, 0x

        TLex lexValue( ptr );

        lexValue.Inc( 2 );

        // Read value

        lexValue.BoundedVal( hexValue, radix, limit );

        }

    COMPONENT_TRACE( ( _L( "  HexValue: %x", hexValue ) ) );

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::GetAttributeHexValue() - return" ) ) );

    return hexValue;

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::GetAttributeRealValue

// ---------------------------------------------------------------------------

//

TReal CSsyReferenceConfig::GetAttributeRealValue( CMDXMLElement& aElement, const TDesC& aAttrib )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::GetAttributeRealValue()" ) ) );

    COMPONENT_TRACE( ( _L( "  Element: %s", aElement.NodeName() ) ) );

    COMPONENT_TRACE( ( _L( "  Attribute: %s", aAttrib ) ) );

    TReal realValue( 0 );

    // Check availability

    if ( aElement.IsAttributeSpecified( aAttrib ) )

        {

        // Buffer to where to read value

        TBufC<KSsyRefMaxAttribLength> buffer( KNullDesC );

        TPtrC ptr( buffer );

        // Read attribute value

        aElement.GetAttribute( aAttrib, ptr );

        // Cast literal value into TReal

        TLex lexValue( ptr );

        lexValue.Val( realValue );

        }

    COMPONENT_TRACE( ( _L( "  IntValue: %i", realValue ) ) );

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::GetAttributeRealValue() - return" ) ) );

    return realValue;

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::ChannelCount

// ---------------------------------------------------------------------------

//

TInt CSsyReferenceConfig::ChannelCount()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::ChannelCount() - %i" ), iChannelCount ) );

    return iChannelCount;

    }

// ---------------------------------------------------------------------------

// CSsyReferenceConfig::GenerateChannels

// ---------------------------------------------------------------------------

//

void CSsyReferenceConfig::GenerateChannels( RSensrvChannelInfoList& aChannelList )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceConfig::GenerateChannels()" ) ) );

    // Initialize channel pair array

    TSsyRefChannelIdArray tempArray( iChannelCount );

    iChannelPairArray = tempArray;

    // Go through Channel group element and get all information

    TSensrvChannelInfo channelInfo;

    CMDXMLElement* channelElement = iChannelGroupElement->FirstChildOfType( KSsyRefChannelItemTag );

    while( channelElement )

        {

        // check is element correct type of node

        if ( channelElement->NodeType() == CMDXMLNode::EElementNode )

            {

            // read channel identifier

            iChannelPairArray.Append( TSsyRefChannelIdPair( GetAttributeIntValue( *channelElement, KSsyRefChannelId ) ) );

            // Read attributes

            channelInfo.iContextType = ( TSensrvContextType ) GetAttributeIntValue( *channelElement, KSsyRefContextType );

            channelInfo.iQuantity = ( TSensrvQuantity ) GetAttributeIntValue( *channelElement, KSsyRefQuantity );

            channelInfo.iChannelType = ( TSensrvChannelTypeId ) GetAttributeHexValue( *channelElement, KSsyRefChannelType );

            GetAttributeStrValue( *channelElement, KSsyRefLocation, channelInfo.iLocation );

            GetAttributeStrValue( *channelElement, KSsyRefVendorId, channelInfo.iVendorId );

            channelInfo.iChannelDataTypeId = ( TSensrvChannelDataTypeId ) GetAttributeHexValue( *channelElement, KSsyRefDataTypeID );

            // Calculate data item size based on channel type

            switch ( channelInfo.iChannelType )

                {

                case KSensrvChannelTypeIdAccelerometerXYZAxisData:

                    {

                    channelInfo.iDataItemSize = KSsyRefAxisDataItemSize;

                    break;

                    }

                case KSensrvChannelTypeIdProximityMonitor:

                    {

                    channelInfo.iDataItemSize = KSsyRefProximityDataItemSize;

                    break;

                    }

                case KSensrvChannelTypeIdAmbientLightData:

                    {

                    channelInfo.iDataItemSize = KSsyRefAmbientLightDataItemSize;

                    break;

                    }

                case KSensrvChannelTypeIdAccelerometerWakeupData:

                case KSensrvChannelTypeIdAccelerometerDoubleTappingData:

                    {

                    channelInfo.iDataItemSize = KSsyRefTappingDataItemSize;

                    break;

                    }

                case KSensrvChannelTypeIdMagnetometerXYZAxisData:

                    {

                    channelInfo.iDataItemSize = KSsyRefMagneticAxisDataItemSize;

                    break;

                    }

                default: