/*

* 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:  Base class for Publish & Subscripe -type Sensors

*

*/

#include "sensorlistener.h"

#include "cpssensorbase.h"

#include "logger.h"

const TInt KPSSensorChannel = 0;

const TInt KPSSensorInvalidValue = 0;

CPSSensorBase::CPSSensorBase(TTimeIntervalMicroSeconds32 aPollInterval)

        : iPollInterval(aPollInterval)

{

    JELOG2(ESensor);

}

CPSSensorBase::~CPSSensorBase()

{

    JELOG2(ESensor);

    iProperty.Close();

    if (iAsyncQuery)

    {

        iAsyncQuery->Cancel();

        delete iAsyncQuery;

    }

    if (iPollTimer)

    {

        iPollTimer->Cancel();

        delete iPollTimer;

    }

}

void CPSSensorBase::ConstructL(TUid aPropertyCategory, TInt aPropertyKey)

{

    JELOG2(ESensor);

    iPropertyCategory = aPropertyCategory;

    iPropertyKey = aPropertyKey;

    CSensorBase::ConstructL();

}

int CPSSensorBase::OpenChannel(SensorListener* aListener)

{

    JELOG2(ESensor);

    TRAPD(err, OpenChannelL(aListener));

    return err;

}

void CPSSensorBase::OpenChannelL(SensorListener* aListener)

{

    JELOG2(ESensor);

    iSensorListener = aListener;

    iPollTimer = CPSSensorDataListenTimer::NewL(*this);

    CActiveScheduler::Add(iPollTimer);

    iAsyncQuery = CPSSensorBaseAsyncQuery::NewL(*this, iPropertyCategory, iPropertyKey);

    CActiveScheduler::Add(iAsyncQuery);

    User::LeaveIfError(iProperty.Attach(iPropertyCategory, iPropertyKey));

}

void CPSSensorBase::StartDataListeningL()

{

    JELOG2(ESensor);

    if (iPollTimer->IsActive())

    {

        iPollTimer->Cancel();

    }

    ResetAccumulationData();

    AccumulateDataL();

}

void CPSSensorBase::CancelDataListeningL()

{

    JELOG2(ESensor);

    iPollTimer->Cancel();

}

void CPSSensorBase::CloseChannelL()

{

    JELOG2(ESensor);

    iSensorListener = NULL;

}

void CPSSensorBase::StartConditionListeningL()

{

    JELOG2(ESensor);

    // Evaluate current value right away to check if the current

    // value already matches

    PropertyValueChanged();

    // Request notification of property value change

    iAsyncQuery->NotifyOnChange();

}

void CPSSensorBase::StopConditionListeningL()

{

    JELOG2(ESensor);

    iAsyncQuery->Cancel();

}

TBool CPSSensorBase::EvaluateConditions(TInt aValue, TInt aChannelId)

{

    JELOG2(ESensor);

    // Values below zero are error codes; no condition listening callbacks

    // for invalid values.

    if (aValue < 0)

    {

        return EFalse;

    }

    return CSensorBase::EvaluateConditions(aValue, aChannelId);

}

void CPSSensorBase::AddConditionL(void** aHandle, int aChannelId,

                                  double aLowerLimit, double aUpperLimit, int aLowerOp,

                                  int aUpperOp)

{

    JELOG2(ESensor);

    CSensorBase::AddConditionL(aHandle, aChannelId, aLowerLimit,

                               aUpperLimit, aLowerOp, aUpperOp);

    // Check conditions right away for current value

    PropertyValueChanged();

}

void CPSSensorBase::ResetAccumulationData()

{

    JELOG2(ESensor);

    iData[ KPSSensorChannel ]->iNumOfValues = 0;

    iStartTime = KErrNotFound;

}

void CPSSensorBase::AccumulateDataL()

{

    JELOG2(ESensor);

    __ASSERT_DEBUG(iData != NULL, User::Invariant());

    SensorData* data = iData[ KPSSensorChannel ];

    // Request new data accumulation event

    iPollTimer->After(iPollInterval);

    TTime currentTime;

    if (data->iTimeStampsIncluded || (iBufferingPeriod > 0))

    {

        currentTime.UniversalTime();

        if (iStartTime == KErrNotFound)

        {

            iStartTime = currentTime;

        }

    }

    TInt currentValue = 0;

    TInt err = iProperty.Get(currentValue);

    __ASSERT_DEBUG(err == KErrNone, User::Invariant());

    // P&S sensors are assumed to have one channel only

    TInt interpretedValue = InterpretValue(currentValue);

    // Negative values are error codes and therefore marked

    // as invalid. Returned value for invalid values is zero.

    if (interpretedValue < 0)

    {

        data->iIntValues[ data->iNumOfValues ] = KPSSensorInvalidValue;

        if (data->iValiditiesIncluded)

        {

            data->iValidities[ data->iNumOfValues ] = EFalse;

        }

    }

    else

    {

        data->iIntValues[ data->iNumOfValues ] = interpretedValue;

        if (data->iValiditiesIncluded)

        {

            data->iValidities[ data->iNumOfValues ] = ETrue;

        }

    }

    if (data->iTimeStampsIncluded)

    {

        data->iTimeStamps[ data->iNumOfValues ] = TimeStamp(currentTime);

    }

    data->iNumOfValues++;

    TInt64 intervalFromStart = -1;

    if (iBufferingPeriod > 0)

    {

        intervalFromStart = currentTime.MicroSecondsFrom(iStartTime).Int64();

    }

    if ((data->iNumOfValues == iBufferSize) ||

            (iBufferingPeriod > 0 && intervalFromStart > iBufferingPeriod))

    {

        SendData();

    }

}

void CPSSensorBase::SendData()

{

    JELOG2(ESensor);

    if (iIsOneShot)

    {

        iPollTimer->Cancel();

    }

    iSensorListener->DataReceived(iData, EFalse);

    ResetAccumulationData();

}

void CPSSensorBase::PropertyValueChanged()

{

    JELOG2(ESensor);

    TInt value;

    TInt err = iProperty.Get(value);

    __ASSERT_DEBUG(err == KErrNone, User::Invariant());

    // Negative values are sensor value range

    if (err == KErrNone && value >= 0)

    {

        EvaluateConditions(value, KPSSensorChannel);

    }

}

// ***************************************************************************

// CPSSensorBaseAsyncQuery

// ***************************************************************************

CPSSensorBase::CPSSensorBaseAsyncQuery*

CPSSensorBase::CPSSensorBaseAsyncQuery::NewL(CPSSensorBase& aSensorBase,

        TUid aPropertyCategory, TInt aPropertyKey)

{

    JELOG2(ESensor);

    CPSSensorBaseAsyncQuery* self =

        new(ELeave)CPSSensorBaseAsyncQuery(aSensorBase);

    CleanupStack::PushL(self);

    self->ConstructL(aPropertyCategory, aPropertyKey);

    CleanupStack::Pop(); // self

    return self;

}

CPSSensorBase::CPSSensorBaseAsyncQuery::CPSSensorBaseAsyncQuery(CPSSensorBase& aSensorBase)

        : CActive(EPriorityStandard), iSensorBase(aSensorBase)

{

    JELOG2(ESensor);

}

void CPSSensorBase::CPSSensorBaseAsyncQuery::ConstructL(TUid aPropertyCategory, TInt aPropertyKey)

{

    JELOG2(ESensor);

    User::LeaveIfError(iProperty.Attach(aPropertyCategory, aPropertyKey));

}

CPSSensorBase::CPSSensorBaseAsyncQuery::~CPSSensorBaseAsyncQuery()

{

    JELOG2(ESensor);

    iProperty.Close();

}

void CPSSensorBase::CPSSensorBaseAsyncQuery::NotifyOnChange()

{

    JELOG2(ESensor);

    if (!IsActive())

    {

        iProperty.Subscribe(iStatus);

        SetActive();

    }

}

void CPSSensorBase::CPSSensorBaseAsyncQuery::RunL()

{

    JELOG2(ESensor);

    iProperty.Subscribe(iStatus);

    SetActive();

    iSensorBase.PropertyValueChanged();

}

void CPSSensorBase::CPSSensorBaseAsyncQuery::DoCancel()

{

    JELOG2(ESensor);

    iProperty.Cancel();

}

// ***************************************************************************

// CPSSensorDataListenTimer

// ***************************************************************************

CPSSensorBase::CPSSensorDataListenTimer*

CPSSensorBase::CPSSensorDataListenTimer::NewL(CPSSensorBase& aSensorBase)

{

    JELOG2(ESensor);

    CPSSensorDataListenTimer* self =

        new(ELeave)CPSSensorDataListenTimer(aSensorBase);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self

    return self;

}

CPSSensorBase::CPSSensorDataListenTimer::CPSSensorDataListenTimer(

    CPSSensorBase& aSensorBase)

        : CTimer(EPriorityNormal), iSensorBase(aSensorBase)

{

    JELOG2(ESensor);

}

CPSSensorBase::CPSSensorDataListenTimer::~CPSSensorDataListenTimer()

{

    JELOG2(ESensor);

}

void CPSSensorBase::CPSSensorDataListenTimer::RunL()

{

    JELOG2(ESensor);

    iSensorBase.AccumulateDataL();

}

void CPSSensorBase::CPSSensorDataListenTimer::DoCancel()

{

    JELOG2(ESensor);

}