/*
* 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 "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:  VOIP Audio Services  CMsgQueueHandler class implementation.
*
*/


#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,
                                   RMsgQueue<TVoIPMsgBuf>* aMsgQueue,
                                   TInt aBufferLen)
    {
    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,
                               TInt aBufferLen)
    {
    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),
//  CActive(CActive::EPriorityHigh),
    iMsgQueue(aMsgQueue),
    iChunkDataPtr(0,0,0)
    {
    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,
                                 msgBuf.iStatus);
                break;
                }
            case ECmdUplinkInitComplete:
                {
                iObserver->Event(MVoIPUplinkObserver::KOpenComplete,
                                 msgBuf.iStatus);
                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,
                                 msgBuf.iStatus);
                break;
                }
            case ECmdUplinkThreadClosed:
                {
                iChunk.Close();
                iObserver->Event(MVoIPUplinkObserver::KUplinkClosed,
                                 msgBuf.iStatus);
                break;
                }
            case ECmdRingToneOpenComplete:
                {
                iObserver->Event(MRingToneObserver::KOpenComplete,
                                 msgBuf.iStatus);
                break;
                }
            case ECmdRingTonePlayComplete:
                {
                iObserver->Event(MRingToneObserver::KPlaybackComplete,
                                 msgBuf.iStatus);
                break;
                }
            case ECmdDnLinkError:
            case ECmdDnLinkJBError:
                {
                iObserver->Event(MVoIPDownlinkObserver::KDownlinkError,
                                 msgBuf.iStatus);
                break;
                }
            case ECmdUpLinkError:
                {
                iObserver->Event(MVoIPUplinkObserver::KUplinkError,
                                 msgBuf.iStatus);
                break;
                }
            case ECmdDTMFOpenDnlinkComplete:
                {
                iObserver->Event(MDTMFToneObserver::KOpenCompleteDNL,
                                 msgBuf.iStatus);
                break;
                }
            case ECmdDTMFOpenUplinkComplete:
                {
                iObserver->Event(MDTMFToneObserver::KOpenCompleteUPL,
                                 msgBuf.iStatus);
                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