/*

* Copyright (c) 2006-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:    Abstract socket sender

*

*/

#include "cncmsender.h"

#include "ncmconnectionmultiplexerlogs.h"

#include "mncmreceiversenderobserver.h"

#include "mncmsenderobserver.h"

#include "cncmsenditem.h"

const TInt KFirstInBuffer  = 0;

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

// CNcmSender::CNcmSender

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

//

CNcmSender::CNcmSender( RSocket& aSocket,

    MNcmReceiverSenderObserver& aObserver ) :

    CActive( EPriorityUserInput ),

    iSocket( aSocket ),

    iObserver( aObserver )

    {

    CActiveScheduler::Add( this );

    }

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

// CNcmSender::~CNcmSender

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

//

CNcmSender::~CNcmSender()

    {

    __CONNECTIONMULTIPLEXER( "CNcmSender::~CNcmSender" )

    Cancel();

    iSendItemArray.ResetAndDestroy();

    }

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

// CNcmSender::Send

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

//

void CNcmSender::Send( const TDesC8& aMessage,

    MNcmSenderObserver* aSenderObserver )

    {

    __CONNECTIONMULTIPLEXER_INT1( 

        "CNcmSender::Send - Send item count: ", iSendItemArray.Count() )

    CNcmSendItem* item( NULL );

    TRAPD( error, item = CNcmSendItem::NewL( aMessage, aSenderObserver ) )

    if ( item )

        {

        error = iSendItemArray.Append( item );        

        }  

    if ( KErrNone != error )

        {  

        if ( aSenderObserver )

            {

            aSenderObserver->MessageSentFailure( error );

            aSenderObserver = NULL;

            }

        else

            {

            iObserver.Error( error );

            }    

        __CONNECTIONMULTIPLEXER_INT1( 

            "CNcmSender::Send - ERRRO: ", error )

        delete item;

        return;

        }

    // start sending

    DoSend();

    }

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

// CNcmSender::CancelMessageSendL

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

//

void CNcmSender::CancelMessageSendL(

    const MNcmSenderObserver* aSenderObserver )

    {

    __CONNECTIONMULTIPLEXER( "CNcmSender::CancelMessageSendL ")

    TInt ind( iSendItemArray.Count() );

    while ( ind-- )

        {

        if ( aSenderObserver == iSendItemArray[ind]->Observer() )

            {

            __CONNECTIONMULTIPLEXER_INT1(

                "CNcmSender::CancelMessageSendL - Delete: ind ", ind)

            if ( KFirstInBuffer  == ind )

                {

                iSocket.CancelSend();

                }

            delete iSendItemArray[ind];

            iSendItemArray.Remove( ind );

            }

        }

    }

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

// From class CActive

//

// CNcmSender::RunL

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

//

void CNcmSender::RunL()

    {

    __CONNECTIONMULTIPLEXER_INT1( "CNcmSender::RunL STATUS: ", iStatus.Int() )

    if ( iSendItemArray.Count() )

        {     

        TInt status( iStatus.Int() );

        MNcmSenderObserver* senderObserver =

            iSendItemArray.Count()

            ? iSendItemArray[KFirstInBuffer]->Observer()

            : NULL;

        if ( KErrNone != status )

            {

            if ( senderObserver )

                {

                senderObserver->MessageSentFailure( iStatus.Int() );

                }

            else

                {

                iObserver.Error( iStatus.Int() );

                } 

            }

        else

            {

            if ( senderObserver )

                {

                senderObserver->MessageSent();

                }   

            }

        if ( iSendItemArray.Count() )

            {

            if ( iSendItemArray[KFirstInBuffer]->SendInProgress() )

                {

                senderObserver = NULL;       

                delete iSendItemArray[KFirstInBuffer];

                iSendItemArray.Remove( KFirstInBuffer );

                }

            DoSend();

            }     

        }

    }

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

// From class CActive

//

// CNcmSender::DoCancel

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

//

void CNcmSender::DoCancel()

    {

    __CONNECTIONMULTIPLEXER( "CNcmSender::DoCancel" )

    iSocket.CancelSend();

    }

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

// CNcmSender::Activate

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

//

void CNcmSender::Activate() const

    {

    }

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

// CNcmSender::Deactivate

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

//

void CNcmSender::Deactivate()

    {

    Cancel();

    }