/*

* Copyright (c) 2009-2010 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:

* MSRP Implementation

*

*/

// INCLUDES

// CLASS HEADER

#include "CMSRPWriter.h"

#include "MSRPCommon.h"

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

// CMSRPParser::NewL

// Static constructor

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

//

/*static*/MMSRPWriter* CMSRPWriter::NewL(RSocket& aSocket, MMSRPWriterErrorObserver& aConnection)

    {

    MSRPLOG( "CMSRPWriter::NewL enter" )

    CMSRPWriter* self = new (ELeave) CMSRPWriter( aSocket, aConnection );

    CleanupStack::PushL(self);

    //self->ConstructL();

    CleanupStack::Pop(self);

    MSRPLOG( "CMSRPWriter::NewL exit" )

    return self;

    }

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

// CMSRPWriter::CMSRPWriter

// Constructor

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

//

CMSRPWriter::CMSRPWriter(RSocket& aSocket, MMSRPWriterErrorObserver& aConnection)        

    : CActive(CActive::EPriorityStandard), iConnection( aConnection ), iSocket(aSocket)

    {  

    CActiveScheduler::Add(this);

    }

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

// CMSRPWriter::~CMSRPWriter

// Destructor

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

//

CMSRPWriter::~CMSRPWriter()

    {

    MSRPLOG( "CMSRPWriter::~CMSRPWriter enter" )

    Cancel();    

    iSendQueue.Reset();

    iSendQueue.Close();

    MSRPLOG( "CMSRPWriter::~CMSRPWriter exit" )

    }

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

// CMSRPWriter::ConstructL

// 2nd phase constructor

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

//

/*

void CMSRPWriter::ConstructL()

    {

    //iWriteIssued = FALSE;

    //iState = EIdle;

    }

*/

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

// CMSRPWriter::DoCancel

// Cancels outstanding request.

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

//

void CMSRPWriter::DoCancel()

    {

    MSRPLOG( "CMSRPWriter::DoCancel enter" )

    if(iWriteIssued)

        {

        MSRPLOG( "CMSRPWriter::write issued cancelled" )

        iSocket.CancelWrite();      

        }

    else

        {

        //MSRPLOG( "CMSRPWriter::self complete cancelled" )

        //TRequestStatus* status = &iStatus;

        //User::RequestComplete( status, KErrCancel );

        }

    MSRPLOG( "CMSRPWriter::DoCancel exit" )

    }

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

// CMSRPWriter::Parse

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

//

void CMSRPWriter::RequestSendL(MMSRPWriterObserver& aMsg)

    { 

    MSRPLOG( "CMSRPWriter::RequestSendL enter" )

    // making sure the msg is not already in queue

    for ( TInt i = 0; i < iSendQueue.Count(); i++ )

        {

        if ( iSendQueue[ i ] == &aMsg )

            {

            // already included

            return;

            }

        }

    iSendQueue.AppendL(&aMsg);

    if(!IsActive())

        {

        /*avoid invoking send in other active object context*/

        //SendL

        TRequestStatus* status = &iStatus;

        SetActive();

        User::RequestComplete( status, KErrNone );

        }

    MSRPLOG( "CMSRPWriter::RequestSendL exit" )

    }

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

// CMSRPWriter::CancelSendingL

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

//

void CMSRPWriter::CancelSendingL( const MMSRPWriterObserver* aMsg )

    {

    MSRPLOG( "CMSRPWriter::CancelSendingL enter" )

    if ( iSendQueue.Count() )

        {

        if ( iSendQueue[ 0 ] == aMsg )

            {

            if( iWriteIssued )

                {

                MSRPLOG( "CMSRPWriter::CancelSendingL Write Canceled" )

                iSocket.CancelWrite();      

                }

            }

        }

    }   

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

// CMSRPWriter::CancelReceiving

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

//

/*void CMSRPWriter::CancelReceiving()

    {

    Cancel();

    }*/

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

// CMSRPWriter::RunL

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

//

void CMSRPWriter::RunL()

    { 

    MSRPLOG( "CMSRPWriter::RunL enter" )    

    TInt status = iStatus.Int();

    if(status != KErrNone)

        {

        //socket error

        iConnection.WriteSocketError(status);

        return;

        }

    if(iWriteIssued)

        {

        iWriteIssued = FALSE;

        MMSRPWriterObserver::TMsgStatus msgState = MMSRPWriterObserver::EComplete;

        msgState = iSendQueue[0]->WriteDoneL(status); 

        if( msgState != MMSRPWriterObserver::EPending && 

                msgState != MMSRPWriterObserver::ESendingReport )    

            {

            MMSRPWriterObserver* obs = iSendQueue[0];

            iSendQueue.Remove(0);

            if(msgState == MMSRPWriterObserver::EInterrupted)

                iSendQueue.AppendL(obs);              

            }

        }

    SendL();

    MSRPLOG( "CMSRPWriter::RunL exit" )

    }

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

// CMSRPWriter::RunError

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

//

TInt CMSRPWriter::RunError(TInt aError)

    {

    MSRPLOG( "CMSRPWriter::RunError enter" )

    MSRPLOG( "CMSRPWriter::RunError exit" )

    /*get send buffer errors shud b handled in SendL 

     * by deleting msg obs from writer queue, if part of msg written to conn is 0 or complete

     * send failed msg error to client  in msghandler b4 getsend returns*/

    iConnection.WriteSocketError(aError);

    return KErrNone;    

    }

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

// CMSRPWriter::SendL

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

//

void CMSRPWriter::SendL()

    {

    TBool interruptSend = FALSE;

    if(iSendQueue.Count())        

        {

        MMSRPWriterObserver::TWriteStatus ret = MMSRPWriterObserver::EMsrpSocketWrite;

        if(iSendQueue.Count()>1)

            interruptSend = TRUE;

        const TDesC8& writeBuffer = iSendQueue[0]->GetSendBufferL( ret, interruptSend);

        Deque();

        CActiveScheduler::Add(this);

        SetActive();

        if( ret == MMSRPWriterObserver::EMsrpSocketWrite ) //KErrNone == 0

           {

           iSocket.Write( writeBuffer, iStatus );

           iWriteIssued = TRUE;           

           }   

        else if (ret == MMSRPWriterObserver::EMsrpAvoidSocketWrite)//EAvoidSocketWrite

            {

            TRequestStatus* status = &iStatus;                       

            User::RequestComplete( status, KErrNone );

            iWriteIssued = FALSE;        

            }

         /* check in run_error: getsendbufferl leaves are recoverable

          * if msg state equivalent to nothing written to connection

          * ,remove observer and try to recover

          * if writedone leaves, then we can be sure that msg state will reflect socket write issued

          * and so no attempt will be made to recover

          */

        //iSendQueue.Remove(0);

        }            

    }

// End of File