/*

* Copyright (c) 2006-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:  CSensrvChannelImpl implementation

*

*/

#include "sensrvpropertylistener.h"

#include "sensrvchannelimpl.h"

#include "sensrvdatahandler.h"

#include "sensrvpropertyhandler.h"

#include "sensrvtrace.h"

#include "sensrvtypes.h"

#include "sensrvdatalistener.h"

#include "sensrvchannelconditionlistener.h"

#include "sensrvconditionhandler.h"

#include "sensrvchannelconditionimpl.h"

#include "sensrvchannelconditionsetimpl.h"

const TInt KDefaultPropertyCount = 40;

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

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

// C++ constructor

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

//

CSensrvChannelImpl::CSensrvChannelImpl( const TSensrvChannelInfo& aChannelInfo )

    : iChannelInfo( aChannelInfo ),

      iConditionSetList(_FOFF(CSensrvChannelConditionSetImpl,iLink)),

      iConditionSetIter(iConditionSetList)

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::CSensrvChannelImpl()" ) ) );

    }

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

// 2nd phase of construction

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

//

void CSensrvChannelImpl::ConstructL()

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::ConstructL() - Start" ) ) );

    // Nothing to do

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::ConstructL() - Return" ) ) );

    }

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

// Destructor

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

//

CSensrvChannelImpl::~CSensrvChannelImpl()

    {

    delete iDataHandler;

    delete iChannelPropertyHandler;

    delete iConditionHandler;

    iSensrvClient.Close();

    iConditionSetList.Reset();

    }

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

// CSensrvChannelImpl::OpenChannelL

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

//

void CSensrvChannelImpl::OpenChannelL()

    {

    // Open Channel and reset listeners

    DoOpenChannelL( ETrue );

    }

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

// CSensrvChannelImpl::DoOpenChannelL

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

//

void CSensrvChannelImpl::DoOpenChannelL( TBool aResetListeners )

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::DoOpenChannelL()" ) ) );

    if( iChannelOpen )

        {

        ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::DoOpenChannelL() -  ERROR: Channel is already open" ) ) );

        User::Leave( KErrAlreadyExists );

        }

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

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::DoOpenChannelL() - Client connected" ) ) );

    TInt maxBufferCount(0);

    TSensrvTIntPckgBuf intBuf( maxBufferCount );

    TInt dataItemSize(0);

    TSensrvTIntPckgBuf intBuf2( dataItemSize );

    User::LeaveIfError( iSensrvClient.SendReceiveSync( ESensrvSrvReqOpenChannel,

                                        TIpcArgs( iChannelInfo.iChannelId, &intBuf, &intBuf2 ) ) );

    iMaxBufferCount = intBuf();

    iChannelInfo.iDataItemSize = intBuf2(); // Store the actual data item size, known after SSY channel registration

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::DoOpenChannelL -  iMaxBufferSize: %d" ), iMaxBufferCount ) );

    iChannelOpen = ETrue;

    if( aResetListeners )

        {

        COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::DoOpenChannelL() - Reset listeners" ) ) );

        iDataListener = NULL;

        iChannelPropertyListener = NULL;

        iConditionListener = NULL;

        // Also reset conditions

        iConditionSetList.Reset();

        }

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::DoOpenChannelL() - Return" ) ) );

    }

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

// CSensrvChannelImpl::CloseChannel

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

//

TInt CSensrvChannelImpl::CloseChannel()

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::CloseChannel() - Start" ) ) );

    if( iChannelOpen )

        {

        // Cancel handlers handler

        if ( iDataHandler )

            {

            iDataHandler->Cancel();

            }

        if ( iChannelPropertyHandler )

            {

            iChannelPropertyHandler->Cancel();

            }

        if ( iConditionHandler )

            {

            iConditionHandler->Cancel();

            }

        iSensrvClient.SendReceiveSync( ESensrvSrvReqCloseChannel, TIpcArgs( iChannelInfo.iChannelId ) );

        iChannelOpen = EFalse;

        iSensrvClient.Close();

        COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::CloseChannel() - Client closed" ) ) );

        }

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::CloseChannel() - Return" ) ) );

    return KErrNone;

    }

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

// CSensrvChannelImpl::GetChannelInfo

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

//

const TSensrvChannelInfo& CSensrvChannelImpl::GetChannelInfo() const

    {

    return iChannelInfo;

    }

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

// CSensrvChannelImpl::StartDataListeningL

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

//

void CSensrvChannelImpl::StartDataListeningL( MSensrvDataListener* aDataListener,

                                      const TInt aDesiredCount,

                                      const TInt aMaximumCount,

                                      const TInt aBufferingPeriod )

    {

    COMPONENT_TRACE( (

    _L( "Sensrv Client - CSensrvChannelImpl::StartDataListening() - Start: aDataListener=%x, aDesiredCount=%d, aMaximumCount =%d, aBufferingPeriod=%d" ),

     aDataListener, aDesiredCount, aMaximumCount, aBufferingPeriod ) );

    if( aDesiredCount < 0 || aMaximumCount < 0 || aBufferingPeriod < 0 )

        {

        ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::StartDataListening() -  ERROR: Negative argument: leaving KErrArgument" ) ) );

        User::Leave( KErrArgument );

        }

    if ( !aDataListener )

        {

        ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::StartDataListening() -  ERROR: NULL listener: leaving KErrArgument" ) ) );

        User::Leave( KErrArgument );

        }

    if( !iChannelOpen )

        {

        ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::StartDataListening() -  ERROR: Channel is not open: leaving KErrNotFound" ) ) );

        User::Leave( KErrNotFound );

        }

    TSensrvStartListeningParameters listeningParams;

    listeningParams.iDesiredBufferingCount = aDesiredCount;

    listeningParams.iMaximumBufferingCount = aMaximumCount;

    listeningParams.iBufferingPeriod = aBufferingPeriod;

    // Data and condition listening use same parameters for desired count and buffering period,

    // so use lowest value specified, if both are active at the same time

    if ( iConditionListener )

        {

        if (iDataListeningParameters.iDesiredBufferingCount < aDesiredCount)

            {

            listeningParams.iDesiredBufferingCount = iDataListeningParameters.iDesiredBufferingCount;

            }

        if ( iDataListeningParameters.iBufferingPeriod < aBufferingPeriod )

            {

            listeningParams.iBufferingPeriod = iDataListeningParameters.iBufferingPeriod;

            }

        }

    TSensrvStartListeningParametersPckgBuf startListeningPckg( listeningParams );

    TInt startErr = iSensrvClient.SendReceiveSync( ESensrvSrvReqStartListening,

        TIpcArgs( iChannelInfo.iChannelId, &startListeningPckg ) );

    if ( startErr == KErrAlreadyExists )

        {

        ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::StartDataListening() -  ERROR: Already listening: return KErrAlreadyExists" ) ) );

        User::Leave( startErr );

        }

    if ( startErr )

        {

        // Try start

        startErr = iSensrvClient.SendReceiveSync( ESensrvSrvReqStartListening,

                                TIpcArgs( iChannelInfo.iChannelId, &startListeningPckg ) );

        if ( startErr )

            {

            ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::StartDataListening() -  ERROR: restart failed %d" ), startErr ) );

            // Open channel

            TRAPD( err, ReopenChannelForListeningL(EStartDataListening) );

            if ( !err )

                {

                // try startListening again

                startErr = iSensrvClient.SendReceiveSync( ESensrvSrvReqStartListening,

                                TIpcArgs( iChannelInfo.iChannelId, &startListeningPckg ) );

                }

            else

                {

                // Note: Channel can be left closed if reopen fails, depending at which

                //       point it fails.

                ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::StartDataListening() -  ERROR: Reopening channel failed %d" ), err ) );

                }

            }

        }

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::StartDataListening() -  error code: %d" ), startErr ) );

    User::LeaveIfError( startErr );

    // If first time, create datahandler

    if (!iDataHandler)

        {

        TRAP( startErr, iDataHandler = CSensrvDataHandler::NewL( iSensrvClient, iChannelInfo ) );

        }

    if ( startErr == KErrNone )

        {

        TRAP( startErr, iDataHandler->StartListeningL( this, listeningParams, iMaxBufferCount ) );

        }

    if ( startErr )

        {

        // Stop listening

        iSensrvClient.SendReceiveSync( ESensrvSrvReqStopListening, TIpcArgs( iChannelInfo.iChannelId ) );

        ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::StartDataListening() - ERROR: Starting listening failed, leave: %d" ), startErr ) );

        User::Leave( startErr );

        }

    // Now that we have successfully started, store parameters

    iDataListener = aDataListener;

    iDataListeningParameters.iDesiredBufferingCount = listeningParams.iDesiredBufferingCount;

    iDataListeningParameters.iMaximumBufferingCount = listeningParams.iMaximumBufferingCount;

    iDataListeningParameters.iBufferingPeriod = listeningParams.iBufferingPeriod;

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::StartDataListening() - Return" ) ) );

    }

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

// CSensrvChannelImpl::StopDataListening

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

//

TInt CSensrvChannelImpl::StopDataListening()

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::StopDataListening() - Start" ) ) );

    TInt err( KErrNone );

    if ( iChannelOpen )

        {

        if ( iDataHandler && iDataHandler->IsActive() )

            {

            iDataHandler->Cancel();

            }

        else

            {

            err = iSensrvClient.SendReceiveSync( ESensrvSrvReqStopListening, TIpcArgs( iChannelInfo.iChannelId ) );

            }

        }

    iDataListener = NULL;

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::StopDataListening() - Return" ) ) );

    return err;

    }

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

// CSensrvChannelImpl::GetData

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

//

TInt CSensrvChannelImpl::GetData( TDes8& aDataPtr )

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetData() - Start" ) ) );

    TInt err( KErrNone );

    if ( !iChannelOpen )

        {

        ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetData() -  ERROR: Channel is not open: return KErrNotFound" ) ) );

        err = KErrNotFound;

        }

    else

        {

        if ( iDataHandler )

            {

            err = iDataHandler->GetData( aDataPtr );

            }

        else

            {

            err = KErrNotFound;

            }

        }

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetData() - Return %d" ), err ) );

    return err;

    }

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

// CSensrvChannelImpl::SetProperty

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

//

TInt CSensrvChannelImpl::SetProperty( const TSensrvProperty& aProperty )

    {

#ifdef COMPONENT_TRACE_DEBUG

    if ( ESensrvIntProperty == aProperty.PropertyType() )

        {

        TInt value( 0 );

        aProperty.GetValue( value );

        COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::SetProperty(PropertyId:0x%x value:%d)" ), aProperty.GetPropertyId(), value ) );

        }

    else if ( ESensrvRealProperty == aProperty.PropertyType() )

        {

        TReal value( 0 );

        aProperty.GetValue( value );

        COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::SetProperty(PropertyId:0x%x value:%f)" ), aProperty.GetPropertyId(), value ) );

        }

    else if ( ESensrvBufferProperty == aProperty.PropertyType() )

        {

        COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::SetProperty(PropertyId:0x%x value:%S)" ) , aProperty.GetPropertyId(), &const_cast<TSensrvProperty*>(&aProperty)->GetValueRef() ) );

        }

    else

        {

        COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::SetProperty(PropertyId:0x%x)" ), aProperty.GetPropertyId() ) );

        }

#endif//COMPONENT_TRACE_DEBUG

    TInt err( KErrNone );

    if ( !iChannelOpen )

        {

        ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::SetProperty() -  ERROR: Channel is not open: return KErrNotFound" ) ) );

        err = KErrNotFound;

        }

    else

        {

        TPropertyPckg propertyPckg( aProperty );

        err = iSensrvClient.SendReceiveSync( ESensrvSrvReqSetProperty, TIpcArgs( iChannelInfo.iChannelId, &propertyPckg ) );

        }

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::SetProperty - return %d" ), err ) );

    return err;

    }

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

// CSensrvChannelImpl::GetPropertyL

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

//

void CSensrvChannelImpl::GetPropertyL( const TSensrvPropertyId aPropertyId,

                                       const TInt aItemIndex,

                                       TSensrvProperty& aProperty )

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetPropertyL(PropertyId:0x%x ItemIndex:%d)" ),aPropertyId, aItemIndex ) );

    if (aItemIndex < 0 && aItemIndex != KSensrvItemIndexNone)

        {

        ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetPropertyL() -  ERROR: Negative argument: leaving KErrArgument" ) ) );

        User::Leave( KErrArgument );

        }

    if ( !iChannelOpen )

        {

        ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetPropertyL() -  ERROR: Channel is not open: return KErrNotFound" ) ) );

        User::Leave( KErrNotFound );

        }

    TPropertyPckg propertyPckg( aProperty );

    //Set aPropertyId and aItemIndex to aProperty for server use

    aProperty.SetPropertyId(aPropertyId);

    aProperty.SetItemIndex(aItemIndex);

    User::LeaveIfError( iSensrvClient.SendReceiveSync(

        ESensrvSrvReqGetProperty, TIpcArgs( iChannelInfo.iChannelId, &propertyPckg ) ) );

#ifdef COMPONENT_TRACE_DEBUG

    if ( ESensrvIntProperty == aProperty.PropertyType() )

        {

        TInt value( 0 );

        aProperty.GetValue( value );

        COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetPropertyL() - Return property value=%d" ), value ) );

        }

    else if ( ESensrvRealProperty == aProperty.PropertyType() )

        {

        TReal value( 0 );

        aProperty.GetValue( value );

        COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetPropertyL() - Return property value=%f" ), value ) );

        }

    else if ( ESensrvBufferProperty == aProperty.PropertyType() )

        {

        COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetPropertyL() - Return property value=%S" ), &aProperty.GetValueRef() ) );

        }

    else

        {

        COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetPropertyL() - Return" ) ) );

        }

#endif//COMPONENT_TRACE_DEBUG

    }

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

// CSensrvChannelImpl::GetAllPropertiesL

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

//

void CSensrvChannelImpl::GetAllPropertiesL( RSensrvPropertyList& aChannelPropertyList )

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetAllPropertiesL()" ) ) );

    if ( !iChannelOpen )

        {

        ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetAllPropertiesL() -  ERROR: Channel is not open: return KErrNotFound" ) ) );

        User::Leave( KErrNotFound );

        }

    TSensrvTIntPckgBuf  countPckgBuf;

    TInt                err( KErrNone );

    RSensrvPropertyList channelPropertyList( KDefaultPropertyCount );

    CleanupClosePushL( channelPropertyList );

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

        {

        channelPropertyList.AppendL( TSensrvProperty() );

        }

    TInt  arraySize( ( sizeof( TSensrvProperty ) ) * KDefaultPropertyCount );

    TPtr8 arrayPtr( (TUint8*)&channelPropertyList[0], arraySize, arraySize );

    err = iSensrvClient.SendReceiveSync( ESensrvSrvReqGetAllProperties,

                                         TIpcArgs( iChannelInfo.iChannelId,

                                                   &arrayPtr,

                                                   &countPckgBuf ) );

    if ( err == KErrOverflow ) // buffer overflow. Allocate new buffer

        {

        for( TInt i=KDefaultPropertyCount; i<countPckgBuf(); i++ )

            {

            channelPropertyList.AppendL( TSensrvProperty() );

            }

        TInt  arraySize( ( sizeof( TSensrvProperty ) ) * countPckgBuf() );

        TPtr8 arrayPtr( (TUint8*)&channelPropertyList[0], arraySize, arraySize );

        err = iSensrvClient.SendReceiveSync( ESensrvSrvReqGetAllProperties,

                                             TIpcArgs( iChannelInfo.iChannelId,

                                                       &arrayPtr,

                                                       &countPckgBuf ) );

        }

    if ( err == KErrNone )

        {

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

            {

            aChannelPropertyList.AppendL( channelPropertyList[i] );

            }

        }

    else

        {

        ERROR_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetAllPropertiesL() -  ERROR: Failed to get properties" ) ) );

        User::Leave( err );

        }

    // Close the array and free all memory allocated to the array.

    CleanupStack::PopAndDestroy( &channelPropertyList );

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvChannelImpl::GetAllPropertiesL return void" ) ) );

    }

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