/*

* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

// Include Files

#include "cmmdatautility.h"

#include "cmmdataporthandler.h"

#include "tsylogger.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmdatautilityTraces.h"

#endif

// EXTERNAL DATA STRUCTURES

    //None

// EXTERNAL FUNCTION PROTOTYPES

    //None

// CONSTANTS

    //None

// MACROS

    //None

// LOCAL CONSTANTS AND MACROS

    //None

// MODULE DATA STRUCTURES

    //None

// LOCAL FUNCTION PROTOTYPES

    //None

// FORWARD DECLARATIONS

    //None

// ==================== LOCAL FUNCTIONS =======================================

    //None

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

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

// CDataPortWriter::NewL

// Two-phased constructor.

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

//

CDataPortWriter* CDataPortWriter::NewL(

    CMmDataPortHandler* aMmDataPortHandler,

    const RComm& aDataPort )

    {

    TFLOGSTRING("TSY: CDataPortWriter::NewL");

    CDataPortWriter* writer = new ( ELeave ) CDataPortWriter();

    CleanupStack::PushL( writer );

    writer->iDataPortHandler = aMmDataPortHandler;

    writer->iDataPort = aDataPort;

    writer->ConstructL();

    CActiveScheduler::Add( writer );

    CleanupStack::Pop( writer );

    return writer;

    }

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

// CDataPortWriter::CDataPortWriter

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CDataPortWriter::CDataPortWriter()

    : CActive( EPriorityStandard ), iDataToDpPtr( NULL, 0 )

    {

    //None

    TFLOGSTRING("TSY: CDataPortWriter::CDataPortWriter");

    }

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

// CDataPortWriter::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDataPortWriter::ConstructL()

    {

    TFLOGSTRING("TSY: CDataPortWriter::ConstructL");

    // initialisation of menber variables

    iWriteCompleted = ETrue;

    iContinueWrite = ETrue;

    iWriteBuffer = new ( ELeave ) CArrayPtrSeg<HBufC8>(

        KSentAtCommandLimit );

    iAtCommandBuffer = new (ELeave) CArrayFixFlat<TUint>(

        KSentAtCommandLimit );

    }

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

// CDataPortWriter::~CDataPortWriter

// Destructor, deletes all allocated resources.

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

//

CDataPortWriter::~CDataPortWriter()

    {

    TFLOGSTRING("TSY: CDataPortWriter::~CDataPortWriter");

    Cancel();

    if ( iWriteBuffer )

        {

        iWriteBuffer->ResetAndDestroy();

        delete iWriteBuffer;

        }

    //no else

    if ( iAtCommandBuffer )

        {

        iAtCommandBuffer->Reset();

        delete iAtCommandBuffer;

        }

    //no else

    }

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

// CDataPortWriter::Init

// This method sends TSY init strings to modem.

// (other items were commented in a header).

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

//

void CDataPortWriter::Init()

    {

    TFLOGSTRING("TSY: CDataPortWriter::Init Modem initialisation");

    // Initalise modem

    TBuf8<KDataBufLength> ATString;

    // Common Initialisations

    ATString.Copy( KModemInitString );

    ATString.Append( KReturn );

    Write( ATString, EModemInit );

    // VT initialisation

    ATString.Copy( KHscsdMultimedia_64000 );

    Write( ATString, EModemInit );

    }

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

// CDataPortWriter::AppendCommandL

// This method appends enum for AT command to be sent into iAtCommandBuffer.

// (other items were commented in a header).

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

//

void CDataPortWriter::AppendCommandL(

    TLastAtCommandSent aCommand )

    {

    TFLOGSTRING("TSY: CDataPortWriter::AppendCommandL");

    iAtCommandBuffer->AppendL( aCommand );

    }

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

// CDataPortWriter::GetAtBuffer

// Returns iAtCommandBuffer.

// (other items were commented in a header).

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

//

CArrayFixFlat<TUint>* CDataPortWriter::GetAtBuffer()

    {

    TFLOGSTRING("TSY: CDataPortWriter::GetAtBuffer");

    return iAtCommandBuffer;

    }

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

// CDataPortWriter::Write

// Writes data into dataport.

// (other items were commented in a header).

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

//

void CDataPortWriter::Write(

    const TDesC8& aData,

    TLastAtCommandSent aCommand )

    {

    TFLOGSTRING("TSY: CDataPortWriter::Write");

    // We are writing data so set the flag to ETrue.

    iContinueWrite = ETrue;

#ifdef TF_LOGGING_ENABLED

    // If aData is longer than KDataBufLength, copy only KDataBufLength

    TBuf< KDataBufLength > data16bit;

    if ( KDataBufLength < aData.Length() )

        {

        data16bit.Copy( aData.Left( KDataBufLength ) );

        }

    else

        {

        data16bit.Copy( aData.Left( aData.Length() ) );

        }

    TFLOGSTRING2("TSY: CDataPortWriter::Write - Stored into FIFO buffer: %S", &data16bit );

#endif // TF_LOGGING_ENABLED

    HBufC8* tmp = NULL;

    TInt commandError( KErrNone );

    // Trap possible leave in AppendLs and AllocL.

    TRAPD( trapError,

        // Create tmp ptr for data, allocate heap and copy the aData parameter.

        tmp = aData.AllocL();

        // Append the ptr into buffer

        iWriteBuffer->AppendL( tmp );

        // Append AT command enum into buffer so that we know

        // what is the AT command.

        AppendCommandL( aCommand ) );

    // Check if allocation and appends were succesful.

    if ( ( KErrNone == trapError ) && ( KErrNone == commandError ) )

        {

        // If already sent data and pending for completition, continue to wait.

        // If the last write thas been already completed, write new data.

        if ( iWriteCompleted )

            {

            // Write the data.

            iStatus = KRequestPending;

            iWriteCompleted = EFalse;

            // As iWriteBuffer->AppendL() can reorganise the iWriteBuffer,

            // we need to use a separate iDataToDPPtr with Write.

            // Otherwise it is possible that the data written before

            // new CDataPortWriter::Write is called has wrong address.

            iDataToDpPtr.Set( iWriteBuffer->At( 0 )->Left(

                iWriteBuffer->At( 0 )->Length() ) );

            // Write the data to modem

            iDataPort.Write( iStatus, iDataToDpPtr );

            // DO NOT DELETE ALLOCATED DATA FROM HEAP AS IT IS DONE IN RUNL

#ifdef TF_LOGGING_ENABLED

            // If aData is longer than KDataBufLength, copy only KDataBufLength

            if ( KDataBufLength < aData.Length() )

                {

                data16bit.Copy( iDataToDpPtr.Left( iDataToDpPtr.Length() ) );

                }

            else

                {

                data16bit.Copy( aData.Left( aData.Length() ) );

                }

            TFLOGSTRING2("TSY: CDataPortWriter::Write - From FIFO buffer: %S", &data16bit);

#endif // TF_LOGGING_ENABLED

            if ( !IsActive() )

                {

                SetActive();

                }

            //no else

            }

        //no else

        }

    // If TRAP caught error, call line to handle the error.

    else

        {

        // If AllocL or AppendL left for the actual data string,

        // delete tmp if it exists.

        if ( NULL != tmp )

            {

            delete tmp;

            }

        // If AllocL or AppendL left, handle corresponding error.

        iDataPortHandler->HandleDataPortError( trapError );

        }

    }

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

// CDataPortWriter::RunL

// Activates active object when request is completed.

// (other items were commented in a header).

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

//

void CDataPortWriter::RunL()

    {

    TFLOGSTRING("TSY: CDataPortWriter::RunL");

#ifdef TF_LOGGING_ENABLED

    TBuf< KDataBufLength > data16bit;

    data16bit.AppendNum( iStatus.Int() );

    TFLOGSTRING2("TSY: CDataPortWriter::RunL - iStatus: %S", &data16bit);

#endif // TF_LOGGING_ENABLED

    if ( KRequestPending != iStatus.Int() )

        {

        // If write buffer has data, delete first element.

        if ( 0 < iWriteBuffer->Count() )

            {

#ifdef TF_LOGGING_ENABLED

            // If write buffer entry length is longer than KDataBufLength,

            // log only KDataBufLength bytes of data

            if ( KDataBufLength < iWriteBuffer->At( 0 )->Length() )

                {

                data16bit.Copy( iWriteBuffer->At( 0 )->

                    Left( KDataBufLength ) );

                }

            // Else log the whole buffer

            else

                {

                data16bit.Copy( iWriteBuffer->At( 0 )->Left(

                    iWriteBuffer->At( 0 )->Length() ) );

                }

            TFLOGSTRING2("TSY: CDataPortWriter::RunL - AT command deleted from FIFO buffer: %S", &data16bit);

#endif // TF_LOGGING_ENABLED

            if ( iWriteBuffer->At( 0 ) )

                {

                // Delete the data from heap

                delete iWriteBuffer->At( 0 );

                iWriteBuffer->At( 0 ) = NULL;

                }

            //no else

            // Delete and compress the buffer

            iWriteBuffer->Delete( 0 );

            iWriteBuffer->Compress();

            // Leave if error, will fall back to RunError.

            User::LeaveIfError( iStatus.Int() );

            }

        //no else

        }

    //no else

    }

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

// CDataPortWriter::RunError

// Called when RunL leaves.

// (other items were commented in a header).

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

//

TInt CDataPortWriter::RunError(

    TInt aError )

    {

    TFLOGSTRING2("TSY: CDataPortWriter::RunError %d", aError);

    // Line object completes client requests in case of an error.

    iDataPortHandler->HandleDataPortError( aError );

    // Cancel writes if active.

    Cancel();

    // If write buffer has data, delete it.

    TInt count( iWriteBuffer->Count() );

    if ( 0 < count )

        {

        // Loop through each element and delete data from heap.

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

            {

            if ( iWriteBuffer->At( 0 ) )

                {

                delete iWriteBuffer->At( 0 );

                iWriteBuffer->At( 0 ) = NULL;

                }

            //no else

            }

        }

    //no else

    // Delete elements and compress buffer.

    iWriteBuffer->Delete( 0, iWriteBuffer->Count() );

    iWriteBuffer->Compress();

    return KErrNone;

    }

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

// CDataPortWriter::WriteNextL

// Writes next AT command from iWriteBuffer.

// (other items were commented in a header).

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

//

void CDataPortWriter::WriteNextL()

    {

    TFLOGSTRING("TSY: CDataPortWriter::WriteNextL - Write next command from FIFO");

    if ( !IsActive() )

        {

        iWriteCompleted = ETrue;

        User::LeaveIfError( iStatus.Int() );

        // Check if we have AT commands waiting in the buffer and if we are

        // still supposed to write commands

        if ( ( 0 < iWriteBuffer->Count() ) &&

             ( EFalse != iContinueWrite ) )

            {

            iWriteCompleted = EFalse;

            // As iWriteBuffer->AppendL() can reorganise the iWriteBuffer,

            // we need to use a separate iDataToDPPtr with Write.

            // Otherwise it is possible that the data written before

            // new CDataPortWriter::Write is called has wrong address

            // because of the AppendL().

            iDataToDpPtr.Set( iWriteBuffer->At( 0 )->Left(

                iWriteBuffer->At( 0 )->Length() ) );

            iDataPort.Write( iStatus, iDataToDpPtr );

#ifdef TF_LOGGING_ENABLED

            TBuf<KDataBufLength> data16bit;

            // If write buffer entry length is longer than KDataBufLength,

            // log only KDataBufLength bytes of data

            if ( KDataBufLength < iDataToDpPtr.Length() )

                {

                data16bit.Copy( iDataToDpPtr.Left( KDataBufLength ) );

                }

            else

                {

                data16bit.Copy( iDataToDpPtr.Left( iDataToDpPtr.Length() ) );

                }

            TFLOGSTRING2("TSY: CDataPortWriter::WriteNextL - AT command: %S", &data16bit);

#endif //TF_LOGGING_ENABLED

            // Set active as write is pending

            if ( !IsActive() )

                {

                SetActive();

                }

            //no else

            }

        //no else

        }

    //no else

    }

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

// CDataPortWriter::DoCancel

// Cancels active object request.

// (other items were commented in a header).

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

//

void CDataPortWriter::DoCancel()

    {

    TFLOGSTRING("CDataPortWriter::DoCancel");

    // Stop writing into DP

    iContinueWrite = EFalse;

    iDataPort.WriteCancel();

    iWriteCompleted = ETrue;

    }

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

// CDataPortWriter::BlockWrite

// Blocks writing to dataport

// (other items were commented in a header).

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

//

void CDataPortWriter::BlockWrite()

    {

    TFLOGSTRING("TSY: CDataPortWriter::BlockWrite - Blocking writes to DP");

    // Stop writing into DP until DP reader has flushed RX buffer

    iContinueWrite = EFalse;

    iWriteCompleted = EFalse;

    }

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

// CDataPortReader::NewL

// Two-phased constructor.

// (other items were commented in a header).

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

//

CDataPortReader* CDataPortReader::NewL(

    CMmDataPortHandler* aDataPortHandler,