/*

* Copyright (c) 2008 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:  Accelerometer sensor implementation

*

*/

// INTERNAL INCLUDES

#include "cacceleratorsensor.h"

#include "csensorproperties.h"

#include "sensorlistener.h"

#include "sensornativeconstants.h"

#include "logger.h"

#include <e32debug.h>

#include <sensrvtypes.h>

_LIT(KSeparator, "#");

_LIT(KDescription, "description=");

_LIT(KModel, "#model=Nokia#");

_LIT(KConnectionTypeNotSpecified, "connectiontype=0");

_LIT(KContextTypeUser, "user#");

_LIT(KDataTypeDouble, "1#");

_LIT(KValueScale, "0#");

_LIT(KMeasureRangeCount, "1#");

_LIT(KChannelTerminator, "#@ch_end#");

const TInt KChannels = 3;

const TInt KDataListening = 1;

const TInt KConditionListening = 2;

const TInt KGetDataListening = 4;

const TReal KStandardGravityValue = 9.812865328; // in m/s^2

CAcceleratorSensor::CAcceleratorSensor(const TSensrvChannelInfo& aChannelInfo) :

        iChannelInfo(aChannelInfo), iStartTime(KErrNotFound)

{

    JELOG2(ESensor);

    // No implementation needed

}

CAcceleratorSensor::~CAcceleratorSensor()

{

    JELOG2(ESensor);

    if (iChannel)

    {

        iChannel->StopDataListening();

        iChannel->CloseChannel();

    }

    delete iChannel;

}

CAcceleratorSensor* CAcceleratorSensor::NewLC(const TSensrvChannelInfo& aChannelInfo)

{

    JELOG2(ESensor);

    CAcceleratorSensor* self = new(ELeave) CAcceleratorSensor(aChannelInfo);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

}

CAcceleratorSensor* CAcceleratorSensor::NewL(const TSensrvChannelInfo& aChannelInfo)

{

    JELOG2(ESensor);

    CAcceleratorSensor* self = CAcceleratorSensor::NewLC(aChannelInfo);

    CleanupStack::Pop(); // self;

    return self;

}

void CAcceleratorSensor::ConstructL()

{

    JELOG2(ESensor);

    CSensorBase::ConstructL();

    iChannel = CSensrvChannel::NewL(iChannelInfo);

}

void CAcceleratorSensor::GetProperty(const RSensrvPropertyList aList,

                                     const TSensrvPropertyId aPropertyId,

                                     const TInt aItemIndex,

                                     TSensrvProperty& aProperty)

{

    JELOG2(ESensor);

    TInt propCount = aList.Count();

    for (int i = 0; i < propCount; i++)

    {

        aProperty = aList[i];

        if (aProperty.GetPropertyId() == aPropertyId &&

                aProperty.PropertyItemIndex() == aItemIndex)

        {

            return;

        }

    }

    TSensrvProperty prop;

    aProperty = prop;

}

// newcode for querying for the property using arrayindex also

void CAcceleratorSensor::GetProperty(const RSensrvPropertyList aList,

                                     const TSensrvPropertyId aPropertyId,

                                     const TInt aItemIndex,

                                     const TInt aArrayIndex,

                                     TSensrvProperty& aProperty)

{

    JELOG2(ESensor);

    TInt propCount = aList.Count();

    for (int i = 0; i < propCount; i++)

    {

        aProperty = aList[i];

        if (aProperty.GetPropertyId() == aPropertyId &&

                aProperty.PropertyItemIndex() == aItemIndex&&

                aProperty.GetArrayIndex()==aArrayIndex)

        {

            return;

        }

    }

    TSensrvProperty prop;

    aProperty = prop;

}

HBufC* CAcceleratorSensor::CreateDescriptionLC()

{

    JELOG2(ESensor);

    HBufC* description = HBufC::NewLC(KMaxSensorDescriptionLength);

    TPtr desPtr = description->Des();

    CSensrvChannel* channel = CSensrvChannel::NewL(iChannelInfo);

    CleanupStack::PushL(channel);

    channel->OpenChannelL();

    RSensrvPropertyList propList;

    CleanupClosePushL(propList);

    channel->GetAllPropertiesL(propList);

    channel->CloseChannel();

    // Quantity

    desPtr.Append(SensorProperties::GetPropertyString(

                      KQuantity, iChannelInfo.iQuantity));

    desPtr.Append(KSeparator);

    // ContextType

    desPtr.Append(KContextTypeUser);

    // Location

    TBuf<KSensrvLocationLength> location;

    location.Copy(iChannelInfo.iLocation);

    desPtr.Append(location);

    desPtr.Append(KSeparator);

    // Vendor

    TBuf<KSensrvVendorIdLength> vendor;

    vendor.Copy(iChannelInfo.iVendorId);

    desPtr.Append(vendor);

    desPtr.Append(KSeparator);

    // Description and Model

    desPtr.Append(KDescription);

    desPtr.Append(SensorProperties::GetPropertyString(KSensorDescription,

                  SensorDescriptionId()));

    Model(&desPtr);

    TSensrvProperty property;

    TInt intValue(0);

    // Connection type

    GetProperty(propList, KSensrvSensorConnectionType,    KSensrvItemIndexNone,

                property);

    if (property.PropertyType() == ESensrvIntProperty)

    {

        property.GetValue(intValue);

        desPtr.Append(SensorProperties::GetPropertyString(

                          KConnectionType, intValue));

    }

    else

    {

        desPtr.Append(KConnectionTypeNotSpecified);

    }

    desPtr.Append(KSeparator);

    // Availability

    GetProperty(propList, KSensrvPropIdAvailability, KSensrvItemIndexNone,

                property);

    if (property.PropertyType() == ESensrvIntProperty)

    {

        property.GetValue(intValue);

        desPtr.AppendNum(intValue);

    }

    else

    {

        desPtr.AppendNum(0);

    }

    desPtr.Append(KSeparator);

    //number of channels

    desPtr.AppendNum(KChannels);

    desPtr.Append(KSeparator);

    DescriptorAppendChannel(&desPtr, propList,

                            TSensrvAccelerometerAxisData::EAxisX);

    DescriptorAppendChannel(&desPtr, propList,

                            TSensrvAccelerometerAxisData::EAxisY);

    DescriptorAppendChannel(&desPtr, propList,

                            TSensrvAccelerometerAxisData::EAxisZ);

    CleanupStack::PopAndDestroy();

    CleanupStack::PopAndDestroy(channel);

    return description;

}

void CAcceleratorSensor::DescriptorAppendChannel(TPtr* aPtr,

        const RSensrvPropertyList aList,

        TInt aItemIndex)

{

    JELOG2(ESensor);

    TRealFormat realFormat;

    realFormat.iTriLen = 0;

    realFormat.iPoint = '.';

    TSensrvProperty property;

    TReal realValue(0);

    // name

    aPtr->Append(SensorProperties::GetPropertyString(

                     KAcceleratorChannelName, aItemIndex));

    aPtr->Append(KSeparator);

    // accuracy

    GetProperty(aList, KSensrvPropIdChannelAccuracy,

                KSensrvItemIndexNone, property);

    if (property.PropertyType() == ESensrvRealProperty)

    {

        property.GetValue(realValue);

        aPtr->AppendNum(realValue / 100, realFormat);

    }

    // the checking for int property was introduced for 9.2

    else if (property.PropertyType() == ESensrvIntProperty)

    {

        TInt intValue(0);

        property.GetValue(intValue);

        aPtr->AppendNum(intValue, realFormat);

    }

    else

    {

        aPtr->AppendNum(-1);

    }

    aPtr->Append(KSeparator);

    // data type

    DataType(aPtr);

    // scale

    aPtr->Append(KValueScale);

    // data unit

    DataUnit(aList, aPtr);

    aPtr->Append(KSeparator);

    // range count and range

    DataRange(aList, aPtr);

    aPtr->Append(KChannelTerminator);

}

CSensorBase* CAcceleratorSensor::DuplicateL()

{

    JELOG2(ESensor);

    return NewL(iChannelInfo);

}

TReal CAcceleratorSensor::InterpretValue(TReal aValue)

{

    JELOG2(ESensor);

    return iScaleFactor * aValue;

}

int CAcceleratorSensor::OpenChannel(SensorListener *aListener)

{

    JELOG2(ESensor);

    iSensorListener = aListener;

    TRAPD(err, OpenChannelL(););

    return err==KErrNotFound? KErrNone : err;

}

void CAcceleratorSensor::OpenChannelL()

{

    JELOG2(ESensor);

    LOG(ESensor,EInfo,"Creating Open Channel");

    iChannel->OpenChannelL();

    LOG(ESensor,EInfo,"Channel Created");

    // Check if the sensor data is scaled and set the scale factor

    iScaleFactor = 1;

    TInt format(ESensrvChannelDataFormatAbsolute);

    TSensrvProperty property;

    if (property.PropertyType() == ESensrvIntProperty)

    {

        property.GetValue(format);

        LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::GetValue()::KSensrvPropIdChannelDataFormat format = %d",format);

    }

    else

    {

        LOG(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::KSensrvPropIdChannelDataFormat::Propety Type must be Integer");

        //KSensrvPropIdChannelDataFormat::Propety Type must be Integer

        __ASSERT_DEBUG(EFalse,User::Invariant());

    }

    if (format == ESensrvChannelDataFormatScaled)

    {

        LOG(ESensor,EInfo," format is equal to ESensrvChannelDataFormatScaled");

        // Scaled value maximum

        TSensrvProperty property_scaled;

        TInt maxScaled(0);

        if (property_scaled.GetArrayIndex() == ESensrvArrayPropertyInfo)

        {

            LOG(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::If");

            //for 2G Accelerometer Sensor index value is 0.

            TInt rangeIndex(0);

            property_scaled.GetMaxValue(maxScaled);

            LOG1(ESensor,EInfo,"property_scaled::maxValue = %d",maxScaled);

        }

        else

        {

            LOG(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::else");

            property_scaled.GetMaxValue(maxScaled);

            LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::maxScaled = %d",maxScaled);

        }

        // MeasureRange can be an array property

        TReal maxMeasure;

        TSensrvProperty property_Measured;

        {

        }

        iScaleFactor = maxMeasure / maxScaled ;

        LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::iScaleFactor = %f",iScaleFactor);

    }

    // this checking was introduced for 9.2

    else if (format == ESensrvChannelDataFormatAbsolute)

    {

        iScaleFactor = 2 * KStandardGravityValue / 127;

        // no need to calculate the scale factor

    }

}

void CAcceleratorSensor::CloseChannelL()

{

    JELOG2(ESensor);

    TInt err = iChannel->CloseChannel();

}

void CAcceleratorSensor::StartDataListeningL()

{

    JELOG2(ESensor);

    if (iStartTime == KErrNotFound)

    {

        iStartTime.UniversalTime();

    }

    iChannelXData = iData[ 0 ];

    iChannelYData = iData[ 1 ];

    iChannelZData = iData[ 2 ];

    if (!iListeningType)

    {

        iChannel->StartDataListeningL(this, iBufferSize, iBufferSize,

                                      iBufferingPeriod/1000);

    }

    if (iIsOneShot)

    {

        iListeningType = iListeningType | KGetDataListening;

    }

    else

    {

        iListeningType = iListeningType | KDataListening;

    }

}

void CAcceleratorSensor::CancelDataListeningL()

{

    JELOG2(ESensor);

    if (iListeningType & KDataListening)

    {

        iListeningType = iListeningType ^ KDataListening;

    }

    if (!iListeningType)

    {

        User::LeaveIfError(iChannel->StopDataListening());

    }

}

void CAcceleratorSensor::StopConditionListeningL()

{

    JELOG2(ESensor);

    if (iListeningType & KConditionListening)

    {

        iListeningType = iListeningType ^ KConditionListening;

        User::LeaveIfError(iChannel->StopDataListening());

        if (iListeningType)

        {

            iChannel->StartDataListeningL(this, iBufferSize, iBufferSize,

                                          iBufferingPeriod/1000);

        }

    }

}

void CAcceleratorSensor::StartConditionListeningL()

{

    JELOG2(ESensor);

    if (iListeningType & (KDataListening | KGetDataListening))

    {

        iChannel->StopDataListening();

    }

    if (!(iListeningType & KConditionListening))

    {

        // changing -1 to 0 for buffering period since -1 throws KErrArgument in 9.2

        iChannel->StartDataListeningL(this, 1, 1 /* listen every value*/, 0);

    }

    iListeningType = iListeningType | KConditionListening;

}

void CAcceleratorSensor::DataReceived(CSensrvChannel& aChannel,

                                      TInt aCount,

                                      TInt aDataLost)

{

    JELOG2(ESensor);

    TSensrvAccelerometerAxisData data;

    TPckgBuf<TSensrvAccelerometerAxisData> dataBuf;

    TBool dataFetched = EFalse;

    TTime currentTime;

    currentTime.UniversalTime();

    // no need for data preparation if only listening conditions

    if (iListeningType & (KDataListening | KGetDataListening))

    {

        // Do not go over buffer count

        if (iChannelXData->iNumOfValues + aCount > iBufferSize)

        {

            aCount = iBufferSize - iChannelXData->iNumOfValues;

        }

        // Prepare own data

        for (TInt i = iChannelXData->iNumOfValues; i < aCount + iChannelXData->iNumOfValues; i++)

        {

            aChannel.GetData(dataBuf);

            data = dataBuf();

            dataFetched = ETrue;

            CopyData(data, i);

            // add timestamps, if needed

            if (iChannelXData->iTimeStampsIncluded)

            {

                // Sensrv api returns timestams in localtime java requires UTC

                iChannelXData->iTimeStamps[ i ] = TimeStamp(currentTime);

                iChannelYData->iTimeStamps[ i ] = TimeStamp(currentTime);

                iChannelZData->iTimeStamps[ i ] = TimeStamp(currentTime);

            }

        }

        iChannelXData->iNumOfValues += aCount;

        iChannelYData->iNumOfValues += aCount;

        iChannelZData->iNumOfValues += aCount;

        if (iChannelXData->iNumOfValues == iBufferSize || iBufferingPeriod > 0

                || (iListeningType & KConditionListening

                    && currentTime.MicroSecondsFrom(iStartTime)

                    >= iBufferingPeriod))

        {

            if (iListeningType & KGetDataListening)

            {

                iListeningType = iListeningType ^ KGetDataListening;

                if (!(iListeningType & KConditionListening))

                {

                    iChannel->StopDataListening();

                }