/*

* 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:  CSensrvDataHandler implementation

*

*/

#include "sensrvdatahandler.h"

#include "sensrvtrace.h"

#include "sensrvdatahandlerobserver.h"

#include "sensrvdefines.h"

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

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

// C++ constructor

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

//

CSensrvDataHandler::CSensrvDataHandler( RSensrvClient& aSensrvClient, 

                                        const TSensrvChannelInfo& aChannelInfo )

    : CActive( EPriorityStandard ), 

      iSensrvClient( aSensrvClient ), 

      iChannelInfo( aChannelInfo )

    {

    CActiveScheduler::Add( this );

    }

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

// 2nd phase of construction

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

//

void CSensrvDataHandler::ConstructL()

    {

    }

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

// 2-phase constructor

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

//

CSensrvDataHandler* CSensrvDataHandler::NewL( RSensrvClient& aSensrvClient, 

                                        const TSensrvChannelInfo& aChannelInfo )

    {

    CSensrvDataHandler* self = CSensrvDataHandler::NewLC( aSensrvClient, aChannelInfo );

    CleanupStack::Pop( self );

    return self;

    }

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

// 2-phase constructor

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

//

CSensrvDataHandler* CSensrvDataHandler::NewLC( RSensrvClient& aSensrvClient, 

                                        const TSensrvChannelInfo& aChannelInfo )

    {

    CSensrvDataHandler* self = new( ELeave ) CSensrvDataHandler( aSensrvClient, aChannelInfo );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CSensrvDataHandler::~CSensrvDataHandler()

    {

    Cancel();

    delete iWriteBuffer;

    delete iWriteBufferPtr;

    delete iReadBuffer;

    }

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

// From class CActive

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

//

void CSensrvDataHandler::DoCancel()

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvDataHandler::DoCancel()" ) ) );

    iSensrvClient.SendReceiveSync( ESensrvSrvReqStopListening, 

                                        TIpcArgs( iChannelInfo.iChannelId ) );

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvDataHandler::DoCancel - return void" ) ) );

    }

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

// From class CActive

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

//

void CSensrvDataHandler::RunL()

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvDataHandler::RunL - iStatus %d" ), iStatus.Int() ) );

	Deque();

	CActiveScheduler::Add(this);

    if( iStatus.Int() == KErrNone )

        {

        if( iErrorCount > 0 )

            {

            iErrorCount = 0;

            }

        HBufC8* temp = iReadBuffer;

        iReadBuffer = iWriteBuffer;

        iWriteBuffer = temp;    

        TSensrvAsyncChannelDataCountsRetval dataCounts = iDataCountsPckgBuf();

        COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvDataHandler::RunL - DataItemCount = %d, DataLostCount = %d "), dataCounts.iDataItemCount, dataCounts.iDataLostCount ) );

        TInt lostCount( dataCounts.iDataLostCount );

        lostCount += ( iReadBufferCount - iGetDataCount );

        // Reset buffer counts

        iReadBufferCount = dataCounts.iDataItemCount;

        iGetDataCount = 0; 

        CreateAndSendRequest();

        // Notify to listener

        iDataObserver->DataReceived( iReadBufferCount, lostCount );

        }

    else

        {

        if( iErrorCount == 0 )

            {

            iErrorCount++;

            CreateAndSendRequest();

            // Send minor error

            iDataObserver->DataError( ESensrvErrorSeverityMinor );

            }

        else if( iErrorCount == 1 )

            {

            iErrorCount++;

            // Reopen channel

            TInt maxBufferCount(0);

            iDataObserver->ReopenChannelForDataListeningL( maxBufferCount );

            TSensrvStartListeningParametersPckgBuf startListeningPckg( iListeningParameters );

            COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvDataHandler::RunL - Restart listening - iDesiredBufferingCount = %d, iMaximumBufferingCount = %d, iBufferingPeriod = %d "), 

                iListeningParameters.iDesiredBufferingCount, 

                iListeningParameters.iMaximumBufferingCount, 

                iListeningParameters.iBufferingPeriod ) );

            TInt err = iSensrvClient.SendReceiveSync( ESensrvSrvReqStartListening, 

                            TIpcArgs( iChannelInfo.iChannelId, &startListeningPckg ) );

            if( err )

                {

                // send fatal error

                iDataObserver->DataError( ESensrvErrorSeverityFatal );                    

                }

            else

                {

                TInt newMaxSize( maxBufferCount * iChannelInfo.iDataItemSize );

                if( iWriteBuffer->Length() > newMaxSize )

                    {

                    iWriteBuffer->ReAllocL( newMaxSize );

                    iReadBuffer->ReAllocL( newMaxSize );

                    delete iWriteBufferPtr;

                    iWriteBufferPtr = NULL;

                    iWriteBufferPtr = new (ELeave) TPtr8( const_cast<TUint8*>( iWriteBuffer->Des().Ptr() ), newMaxSize );

                    }

                // Start listening

                CreateAndSendRequest();

                }

            }

        else

            {

            // send fatal error

            iDataObserver->DataError( ESensrvErrorSeverityFatal );  

            }

        }

    }

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

// CSensrvDataHandler::RunError

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

//

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

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvDataHandler::RunError" ) ) );

    // send fatal error

    iDataObserver->DataError( ESensrvErrorSeverityFatal );

    return KErrNone;

    }

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

// CSensrvDataHandler::StartListening

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

//

void CSensrvDataHandler::StartListeningL( MSensrvDataHandlerObserver* aDataObserver, 

                                TSensrvStartListeningParameters aListeningParameters,

                                TInt aMaxBufferCount )

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvDataHandler::StartListening - Start" ) ) );

    if( IsActive() )

        {

        COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvDataHandler::StartListening - Return" ) ) );

        return;

        }

    iDataObserver = aDataObserver;

    iListeningParameters = aListeningParameters;

    iErrorCount = 0;

    TInt size = iListeningParameters.iMaximumBufferingCount * iChannelInfo.iDataItemSize;

    // Check size

    if( size <= 0 || iListeningParameters.iMaximumBufferingCount > ( KMaxTInt / iChannelInfo.iDataItemSize )

        || iListeningParameters.iMaximumBufferingCount < iListeningParameters.iDesiredBufferingCount 

        || iListeningParameters.iMaximumBufferingCount > aMaxBufferCount )

        {

        size = aMaxBufferCount * iChannelInfo.iDataItemSize;

        }

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvDataHandler::StartListening - bufferSize: %d" ), size ) );

    delete iWriteBuffer;

    iWriteBuffer = NULL;

    iWriteBuffer = HBufC8::NewL( size );

    delete iReadBuffer;

    iReadBuffer = NULL;

    iReadBuffer = HBufC8::NewL( size );

    delete iWriteBufferPtr;

    iWriteBufferPtr = NULL;

    iWriteBufferPtr = new (ELeave) TPtr8( const_cast<TUint8*>( iWriteBuffer->Des().Ptr() ), size );

    CreateAndSendRequest();

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvDataHandler::StartListening - Return" ) ) );

    }

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

// CSensrvDataHandler::GetData

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

//

TInt CSensrvDataHandler::GetData( TDes8& aDataPtr )

    {

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

    TInt err( KErrNone );

    if( aDataPtr.Length() < iChannelInfo.iDataItemSize )

        {

        // aDataPtr is too small

        err = KErrOverflow;

        }

    else if( iGetDataCount >= iReadBufferCount || !iReadBuffer )

        {

        // data not found.

        err = KErrNotFound;

        }

    else

        {

        // set data

        TUint8* ptr = const_cast<TUint8*>( iReadBuffer->Des().Ptr() );

        ptr += ( iGetDataCount * iChannelInfo.iDataItemSize ); 

        aDataPtr.Copy( ptr, iChannelInfo.iDataItemSize );

        ++iGetDataCount;

        }

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

    return err;

    }

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

// CSensrvDataHandler::CreateAndSendRequestL

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

//

void CSensrvDataHandler::CreateAndSendRequest()

    {

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvDataHandler::CreateAndSendRequestL - Start" ) ) );

    iWriteBufferPtr->Set( iWriteBuffer->Des() );

    iSensrvClient.SendReceiveAsync( ESensrvSrvReqAsyncChannelData, 

            TIpcArgs( iChannelInfo.iChannelId, iWriteBufferPtr, &iDataCountsPckgBuf ), iStatus );

    SetActive();

    COMPONENT_TRACE( ( _L( "Sensrv Client - CSensrvDataHandler::CreateAndSendRequestL - Return" ) ) );

    }