/*

* Copyright (c) 2007 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:  CTCChannelTilt class implementation.

*

*/

#include <ssycallback.h>

#include <sensrvsensorchannels.h>

#include <sensrvchanneldatatypes.h>

#include <sensrvmagnetometersensor.h>

#include <sensordatacompensator.h>

#include "tcchanneltilt.h"

#include "tcstatetiltidle.h"

#include "tcstatetiltopen.h"

#include "tcstatetiltlistendata.h"

#include "tcstatetiltbufferfull.h"

#include "tcstatetiltclosing.h"

#include "tceventaccelerometer.h"

#include "tceventmagnetometer.h"

#include "tceventproperty.h"

#include "tctransactionflushbuffer.h"

#include "tcutil.h"

#include "configuration.h"

#include "common.h"

#include "trace.h"

// LOCAL DEFINITIONS

const TInt KDesiredCount = 1;

const TInt KMaximumCount = 1;

const TInt KBufferingPeriod = 0;

const TInt KMaximumDataRate = 10;

CTCChannelTilt* CTCChannelTilt::NewL( MSsyCallback& aCallback )

    {

    FUNC_LOG;

    CTCChannelTilt* self = CTCChannelTilt::NewLC( aCallback );

    CleanupStack::Pop( self );

    return self;

    }

CTCChannelTilt* CTCChannelTilt::NewLC( MSsyCallback& aCallback )

    {

    FUNC_LOG;

    CTCChannelTilt* self = new( ELeave ) CTCChannelTilt( aCallback );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CTCChannelTilt::~CTCChannelTilt()

    {

    FUNC_LOG;

    if( iAccelerometerChannel )

        {

        delete iAccelerometerChannel;

        iAccelerometerChannel = NULL;

        }

    if( iMagnetometerChannel )

        {

        delete iMagnetometerChannel;

        iMagnetometerChannel = NULL;

        }

    if( iCurrentTransaction )

        {

        delete iCurrentTransaction;

        iCurrentTransaction = NULL;

        }

    iProperties.Close();

    delete iMagnetometerCompensator;

    delete iAccelerometerCompensator;

    }

CTCChannelTilt::CTCChannelTilt( MSsyCallback& aCallback ):

    CTCChannel( aCallback )

    {

    FUNC_LOG;

    }

void CTCChannelTilt::ConstructL()

    {

    FUNC_LOG;

    iIsSetFromListened = EFalse;

    BaseConstructL();

    // Initialize properties

    for( TInt i = 0; i < EChannelPropertyTiltLast; i++ )

        {

        switch( KTiltSsyChannelProperties[ i ].iPropertyType )

            {

            case ESensrvIntProperty:

                {

                TSensrvProperty property( KTiltSsyChannelProperties[ i ].iPropertyId,

                    KTiltSsyChannelProperties[ i ].iItemIndex,

                    KTiltSsyChannelProperties[ i ].iIntValue,

                    KTiltSsyChannelProperties[ i ].iIntMaxValue,

                    KTiltSsyChannelProperties[ i ].iIntMinValue,

                    KTiltSsyChannelProperties[ i ].iReadOnly,

                    KTiltSsyChannelProperties[ i ].iPropertyType );

                iProperties.AppendL( property );

                break;

                }

            default:

                {

                break;

                }

            }

        }

    }

// METHODS

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

// CTCChannelTilt::RegisterChannelL

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

//

void CTCChannelTilt::RegisterChannelL( RSensrvChannelInfoList& aChannels )

    {

    FUNC_LOG;

    // Register tilt angle channel

    TChannelInfo infoStruct = KTiltSsyChannels[ EChannelTilt ];

    TSensrvChannelInfo info( infoStruct.iChannelId,

        infoStruct.iContextType,

        infoStruct.iQuantity,

        infoStruct.iChannelType,

        TPtrC8( infoStruct.iLocation ),

        TPtrC8( infoStruct.iVendorId ),

        infoStruct.iDataItemSize,

        infoStruct.iDataTypeId );

    aChannels.AppendL( info );

    // Store channel info

    iChannelInfo = info;

    }

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

// CTCChannelTilt::OpenChannelL

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

//

void CTCChannelTilt::OpenChannelL()

    {

    FUNC_LOG;

    // Find and create accelerometer and magnetometer channels

    FindAndCreateAccelerometerChannelL();

    FindAndCreateMagnetometerChannelL();

    // Get current state and send open channel event

    CTCState* current = CurrentState();

    if( current )

        {

        current->HandleEventL( EEventIdHandleOpenChannel );

        }

    }

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

// CTCChannelTilt::CloseChannel

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

//

void CTCChannelTilt::CloseChannelL()

    {

    FUNC_LOG;

    // Get current state and send close channel event

    CTCState* current = CurrentState();

    if( current )

        {

        current->HandleEventL( EEventIdHandleCloseChannel );

        }

    }

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

// CTCChannelTilt::RegisterStateL

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

//

void CTCChannelTilt::RegisterStateL( CTCState::TCStateId aStateId,

    RStateArray& aStateArray )

    {

    FUNC_LOG;

    switch( aStateId )

        {

        case CTCState::ETCStateIdle:

            {

            CTCStateTiltIdle* state = CTCStateTiltIdle::NewL( *this, *this );

            CleanupStack::PushL( state );

            aStateArray.AppendL( state );

            CleanupStack::Pop( state );

            break;

            }

        case CTCState::ETCStateOpen:

            {

            CTCStateTiltOpen* state = CTCStateTiltOpen::NewL( *this, *this );

            CleanupStack::PushL( state );

            aStateArray.AppendL( state );

            CleanupStack::Pop( state );

            break;

            }

        case CTCState::ETCStateListenData:

            {

            CTCStateTiltListenData* state = CTCStateTiltListenData::NewL( *this, *this );

            CleanupStack::PushL( state );

            aStateArray.AppendL( state );

            CleanupStack::Pop( state );

            break;

            }

        case CTCState::ETCStateBufferFull:

            {

            CTCStateTiltBufferFull* state = CTCStateTiltBufferFull::NewL( *this, *this );

            CleanupStack::PushL( state );

            aStateArray.AppendL( state );

            CleanupStack::Pop( state );

            break;

            }

        case CTCState::ETCStateClosing:

            {

            CTCStateTiltClosing* state = CTCStateTiltClosing::NewL( *this, *this );

            CleanupStack::PushL( state );

            aStateArray.AppendL( state );

            CleanupStack::Pop( state );

            break;

            }

        default:

            {

            ERROR_GEN( "Oops. Invalid state" );

            User::Leave( KErrGeneral );

            break;

            }

        }

    }

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

// CTCChannelTilt::RunL

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

//

void CTCChannelTilt::RunL()

    {

    FUNC_LOG;

    TInt status = iStatus.Int();

    INFO_2( "Transaction [%S] completed with code [%d]",

        &TCUtil::TransactionIdAsDesC( iCurrentTransactionId ), status );

    switch( iCurrentTransactionId )

        {

        case ETCTransactionIdOpenChannel:

            {

            // Channel opened, finnish request to sensor server

            iCallback.ChannelOpened( iChannelInfo.iChannelId, status, this, this );

            break;

            }

        case ETCTransactionIdCloseChannel:

            {

            // Channel closed, finnish request to sensor server

            iCallback.ChannelClosed( iChannelInfo.iChannelId );

            break;

            }

        case ETCTransactionIdStopChannelData:

            {

            // Reset data

            iData = NULL;

            iCount = 0;

            break;

            }

        case ETCTransactionIdFlushBuffer:

            {

            ASSERT_DEBUG_TRACE( iCurrentTransaction, ENullPointer );

            // Reset data

            iData = NULL;

            iCount = 0;

            // Buffer filled and needs to be flushed

            TTCTransactionFlushBuffer& transaction =

                static_cast<TTCTransactionFlushBuffer&>( *iCurrentTransaction );

            iCallback.BufferFilled( iChannelInfo.iChannelId,

                transaction.iDataCount,

                iData,

                iCount );

            INFO_2( "Received new data pointer [0x%x] and data count [%d]",

                iData,

                iCount );

            break;

            }

        default:

            {

            // Nothing to do

            ERROR_GEN( "Incorrect transaction ID" );

            break;

            }

        }

    // Clean up transaction

    if( iCurrentTransaction )

        {

        delete iCurrentTransaction;

        iCurrentTransaction = NULL;

        }

    // Inform current state that transaction has been completed

    CTCState* current = CurrentState();

    if( current )

        {

        TTCTransactionId currentTransactionId = iCurrentTransactionId;

        iCurrentTransactionId = ETCTransactionIdNull;

        current->HandleTransactionCompletedL( currentTransactionId, status );

        }

    }

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

// CTCChannelTilt::CheckPropertyDependenciesL

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

//

void CTCChannelTilt::CheckPropertyDependenciesL( const TSensrvChannelId /*aChannelId*/,

    const TSensrvProperty& /*aProperty*/,

    RSensrvChannelList& /*aAffectedChannels */)

    {

    FUNC_LOG;

    // No depencies to other channels

    }

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

// CTCChannelTilt::SetPropertyL

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

//

void CTCChannelTilt::SetPropertyL( const TSensrvChannelId aChannelId,

    const TSensrvProperty& aProperty )

    {

    FUNC_LOG;

    // Check that we have a correct channel ID

    if( aChannelId == iChannelInfo.iChannelId )

        {

        TInt err = KErrNotFound;

        TSensrvProperty* property = Property( aProperty.GetPropertyId() );

        if( property )

            {

            // Check that property is not read only

            INFO_1( "Property id [%d] found from supported properties list",

                property->GetPropertyId() );

            if( !property->ReadOnly() )

                {

                INFO_1( "Property id [%d] supports writing",

                    property->GetPropertyId() );

                // Check that value is correct

                switch( property->PropertyType() )

                    {

                    case ESensrvIntProperty:

                        {

                        INFO_1( "Maximum data rate for tilt channel [%d]",

                                iMaximumDataRate );

                        // Get new value

                        TInt value = 0;

                        aProperty.GetValue( value );

                        // Get allowed min and max

                        TInt min = 0;

                        TInt max = 0;

                        property->GetMinValue( min );

                        property->GetMaxValue( max );

                        if( value >= min && value <= max && value <= iMaximumDataRate )

                            {

                            property->SetValue( value );

                                INFO_2( "New value [%d] set for property id [%d]",

                                value,

                                property->GetPropertyId() );

                            err = KErrNone;

                            }

                        else

                            {

                            ERROR_GEN_2( "Value [%d] incorrect for property id [%d]",

                                value,

                                property->GetPropertyId() );

                            err = KErrArgument;

                            }

                        break;

                        }

                    case ESensrvRealProperty:

                    // Fall through

                    case ESensrvBufferProperty:

                    // Fall through

                    default:

                        {

                        // Other property types than Int not supported

                        err = KErrArgument;

                        break;

                        }

                    }

                }

            else

                {

                if( ( property->GetPropertyId() == KSensrvPropCalibrationLevel ) &&

                    iIsSetFromListened )

                    {

                    // Check that value is correct

                    switch( property->PropertyType() )

                        {

                        case ESensrvIntProperty:

                            {

                            // Get new value

                            TInt value = 0;

                            aProperty.GetValue( value );

                            // Get allowed min and max

                            property->SetValue( value );

                                    INFO_2( "New value [%d] set for property id [%d]",

                                    value,

                                    property->GetPropertyId() );

                            iIsSetFromListened = EFalse;

                            err = KErrNone;

                            break;

                            }

                        case ESensrvRealProperty:

                        // Fall through

                        case ESensrvBufferProperty:

                        // Fall through

                        default:

                            {

                            // Other property types than Int not supported

                            err = KErrArgument;

                            break;

                            }

                        }

                    }

                else

                    {

                    // Cannot modify read only property

                    ERROR_GEN_1( "Property id [%d] does not support writing",

                        property->GetPropertyId() );

                    err = KErrArgument;

                    }

                }

            }

        ERROR_1( err, "Property set for id [%d] failed", aProperty.GetPropertyId() );

        User::LeaveIfError( err );

        TSensrvProperty property1;

        property1.SetPropertyId( KSensrvPropCalibrationLevel );

        GetPropertyL( iChannelInfo.iChannelId, property1 );

        RSensrvChannelList affectedChannels;

        affectedChannels.AppendL( iChannelInfo.iChannelId );

        iCallback.PropertyChanged( iChannelInfo.iChannelId, affectedChannels, property1 );

        affectedChannels.Close();

        // Inform current state that property has changed

        CTCState* current = CurrentState();

        if( current )

            {

            TTCEventProperty event( aProperty );

            current->HandleEventL( event.Id(), &event );

            }

        }

    else

        {

        ERROR_GEN_1( "Incorrect channel id [%d]", aChannelId );

        User::Leave( KErrNotSupported );

        }

    }

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

// CTCChannelTilt::GetPropertyL

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

//

void CTCChannelTilt::GetPropertyL( const TSensrvChannelId aChannelId, 

    TSensrvProperty& aProperty )

    {

    FUNC_LOG;

    // Check that we have a correct channel ID

    if( aChannelId == iChannelInfo.iChannelId )

        {

        // Check if property exists

        TSensrvProperty* property = Property( aProperty.GetPropertyId() );

        if( property )

            {

            // Property found, set new values

            aProperty = *property;

            }

        else

            {

            ERROR_GEN_1( "Property id [%d] not supported", aProperty.GetPropertyId() );

            User::Leave( KErrNotFound );

            }

        }

    else

        {

        ERROR_GEN_1( "Incorrect channel ID: %d", aChannelId );

        User::Leave( KErrNotSupported );

        }

    }

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

// CTCChannelTilt::GetAllPropertiesL

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

//

void CTCChannelTilt::GetAllPropertiesL( const TSensrvChannelId aChannelId, 

    RSensrvPropertyList& aChannelPropertyList )

    {

    FUNC_LOG;