/*

#include <voipaudiocommon.h>

#include <voipuplinkstream.h>

#include <voipdownlinkstream.h>

#include <voipdtmftoneplayer.h>

#include <voipringtoneplayer.h>

#include "debugtracemacros.h"

#include "VoIPSharedData.h"

#include "VoIPDataBufferImpl.h"

#include "VoIPQueueHandler.h"

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

// CQueueHandler::NewL

// Symbian constructor

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

//

CQueueHandler* CQueueHandler::NewL(MQueueHandlerObserver* aObserver,

    {

    CQueueHandler* self = new (ELeave) CQueueHandler(aMsgQueue);

    CleanupStack::PushL(self);

    self->ConstructL(aObserver, aBufferLen);

    CleanupStack::Pop(self);

    return self;

    }

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

// CQueueHandler::ConstructL

// Second phase constructor.

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

//

void CQueueHandler::ConstructL(MQueueHandlerObserver* aObserver,

    {

    iObserver = aObserver;

    // aBufferLen == 0 for MsgCom queue

    if (aBufferLen > 0)

        {

        iBuffer = CVoIPDataBufferImpl::NewL(aBufferLen);

        }

    }

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

// CQueueHandler::~CQueueHandler

// Destructor.

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

//

CQueueHandler::~CQueueHandler()

    {

    Cancel();

    iChunk.Close();

    delete iBuffer;

    }

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

// CQueueHandler::CQueueHandler

// Constructor.

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

//

CQueueHandler::CQueueHandler(RMsgQueue<TVoIPMsgBuf>* aMsgQueue) :

    CActive(CActive::EPriorityStandard),

    iMsgQueue(aMsgQueue),

    {

    CActiveScheduler::Add(this);

    }

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

// CQueueHandler::Start

// Start listening for events on queue 0.

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

//

void CQueueHandler::Start()

    {

    if (!IsActive())

        {

        iMsgQueue->NotifyDataAvailable(iStatus);

        SetActive();

        }

    }

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

// CQueueHandler::DoCancel

// Cancel outstanding request

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

//

void CQueueHandler::DoCancel()

    {

    iMsgQueue->CancelDataAvailable();

    }

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

// CQueueHandler::RunL

// Process requests.

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

//

void CQueueHandler::RunL()

    {

    TVoIPMsgBuf msgBuf;

    TInt err = iMsgQueue->Receive(msgBuf);

    // Start monitoring for more events before calling the observer as client

    // may decide to destroy us before this RunL completes executing.

    Start();

    if (err == KErrNone)

        {

        switch (msgBuf.iRequest)

            {

            case ECmdDownlinkInitComplete:

                {

                iObserver->Event(MVoIPDownlinkObserver::KOpenComplete,

                break;

                }

            case ECmdUplinkInitComplete:

                {

                iObserver->Event(MVoIPUplinkObserver::KOpenComplete,

                break;

                }

            case ECmdFillBuffer:

                {

                DoFillBuffer(msgBuf.iInt, msgBuf.iStatus);

                break;

                }

            case ECmdEmptyBuffer:

                {

                DoEmptyBuffer(msgBuf.iInt, msgBuf.iStatus);

                break;

                }

            case ECmdDownlinkThreadClosed:

                {

                iChunk.Close();

                iObserver->Event(MVoIPDownlinkObserver::KDownlinkClosed,

                break;

                }

            case ECmdUplinkThreadClosed:

                {

                iChunk.Close();

                iObserver->Event(MVoIPUplinkObserver::KUplinkClosed,

                break;

                }

            case ECmdRingToneOpenComplete:

                {

                iObserver->Event(MRingToneObserver::KOpenComplete,

                break;

                }

            case ECmdRingTonePlayComplete:

                {

                iObserver->Event(MRingToneObserver::KPlaybackComplete,

                break;

                }

            case ECmdDnLinkError:

            case ECmdDnLinkJBError:

                {

                iObserver->Event(MVoIPDownlinkObserver::KDownlinkError,

                break;

                }

            case ECmdUpLinkError:

                {

                iObserver->Event(MVoIPUplinkObserver::KUplinkError,

                break;

                }

            case ECmdDTMFOpenDnlinkComplete:

                {

                iObserver->Event(MDTMFToneObserver::KOpenCompleteDNL,

                break;

                }

            case ECmdDTMFOpenUplinkComplete:

                {

                iObserver->Event(MDTMFToneObserver::KOpenCompleteUPL,

                break;

                }

            case ECmdDTMFTonePlayFinished:

                {

                TRACE_PRN_N1(_L("VoIP->TonePlayFinished [%d]"), msgBuf.iStatus);

                break;

                }

            default:

                break;

            }

        }

    }

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

// CQueueHandler::DoFillBuffer

//

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

//

void CQueueHandler::DoFillBuffer(TInt aBufLen, TInt aStatus)

    {

    TInt err = KErrNone;

    if (iChunk.Handle() == 0)

        {

        // aStatus is either RChunk handle or an error

        err = iChunk.OpenGlobal(KChunkDNL, EFalse);

        }

    if (err == KErrNone)

        {

        iChunkDataPtr.Set(iChunk.Base(), 0, aBufLen);

        iBuffer->SetPayloadPtr(iChunkDataPtr);

        iObserver->FillBuffer(iBuffer);

        }

    else

        {

        // returned error

        iObserver->Event(MVoIPDownlinkObserver::KDownlinkError, aStatus);

        }

    }

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

// CQueueHandler::DoEmptyBuffer

//

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

//

void CQueueHandler::DoEmptyBuffer(TInt aBufLen, TInt aStatus)

    {

    TInt err = KErrNone;

    if (iChunk.Handle() == 0)

        {

        // aStatus is either RChunk handle or an error

        err = iChunk.OpenGlobal(KChunkUPL, EFalse);

        }

    if (err == KErrNone)

        {

        iChunkDataPtr.Set(iChunk.Base(), aBufLen, aBufLen);

        iBuffer->SetPayloadPtr(iChunkDataPtr);

        iObserver->EmptyBuffer(iBuffer);

        }

    else

        {

        iObserver->Event(MVoIPUplinkObserver::KUplinkError, aStatus);

        }

    }

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

// CQueueHandler::RunError

// Process requests.

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

//

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

    {

    // Current implementation of RunL does not leave

    return 0;

    }

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

// CQueueHandler::Status

// Return request status.

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

//

TRequestStatus* CQueueHandler::Status()

    {

    return &iStatus;

    }

// End of File