/*
 * Copyright (c) 2009 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: Telephony Multimedia Service
 *
 */

#include <tms.h>
#include <tmsbuffer.h>
#include "tmsutility.h"
#include "tmsshared.h"
#include "tmsqueuehandler.h"
#include "tmsmembuffer.h"
#include "tmsglobalcontext.h"
#include "tmscallproxy.h"

using namespace TMS;

// ----------------------------------------------------------------------------
// CQueueHandler::NewL
// Symbian constructor
// ----------------------------------------------------------------------------
//
CQueueHandler* CQueueHandler::NewL(RMsgQueue<TmsMsgBuf>* aMsgQueue,
        TMSGlobalContext* glblCtx)
    {
    CQueueHandler* self = new (ELeave) CQueueHandler(aMsgQueue, glblCtx);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// ----------------------------------------------------------------------------
// CQueueHandler::ConstructL
// Second phase constructor.
// ----------------------------------------------------------------------------
//
void CQueueHandler::ConstructL()
    {
    }

// ----------------------------------------------------------------------------
// CQueueHandler::~CQueueHandler
// Destructor.
// ----------------------------------------------------------------------------
//
CQueueHandler::~CQueueHandler()
    {
    Cancel();
    iObserversList.Reset();
    iClientList.Reset();
    iChunk.Close();
    delete iBuffer;
    }

// ----------------------------------------------------------------------------
// CQueueHandler::CQueueHandler
// Constructor.
// ----------------------------------------------------------------------------
//
CQueueHandler::CQueueHandler(RMsgQueue<TmsMsgBuf>* aMsgQueue,
        TMSGlobalContext* glblCtx) :
    CActive(CActive::EPriorityStandard),
    iMsgQueue(aMsgQueue),
    iChunkDataPtr(0, 0, 0)
    {
    CActiveScheduler::Add(this);
    iTMSGlobalContext = glblCtx;
    }

// ----------------------------------------------------------------------------
// CQueueHandler::Start
// Start listening for events on queue 0.
// ----------------------------------------------------------------------------
//
void CQueueHandler::Start()
    {
    if (!IsActive() && iMsgQueue)
        {
        iMsgQueue->NotifyDataAvailable(iStatus);
        SetActive();
        }
    }

TInt CQueueHandler::AddObserver(MQueueHandlerObserver& aObserver,
        TInt aClientId)
    {
    // Add to list if observer is not already added
    TInt status = iObserversList.Find(&aObserver);
    if (status == KErrNotFound)
        {
        status = iObserversList.Append(&aObserver);
        status = iClientList.Append(aClientId);
        }
    else
        {
        status = KErrAlreadyExists;
        }
    return status;
    }

// Marks observer as inactive in the list
TInt CQueueHandler::RemoveObserver(MQueueHandlerObserver& aObserver)
    {
    TInt status(KErrNone);
    TInt index = iObserversList.Find(&aObserver);
    // If found status has index to observer in the array
    // else it would contain KErrNotFound
    if (index >= 0)
        {
        iObserversList.Remove(index);
        iClientList.Remove(index);
        status = KErrNone;
        }
    else
        {
        status = KErrNotFound;
        }
    return status;
    }

// ----------------------------------------------------------------------------
// CQueueHandler::DoCancel
// Cancel outstanding request
// ----------------------------------------------------------------------------
//
void CQueueHandler::DoCancel()
    {
    if (iMsgQueue)
        {
        iMsgQueue->CancelDataAvailable();
        }
    }

// ----------------------------------------------------------------------------
// CQueueHandler::RunL
// Process requests.
// ----------------------------------------------------------------------------
//
void CQueueHandler::RunL()
    {
    TmsMsgBuf msgBuf;
    TInt err = KErrNone;

    if (iMsgQueue)
        {
        iMsgQueue->Receive(msgBuf);
        }
    else
        {
        err = KErrGeneral;
        }

    // 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:
            case ECmdUplinkInitComplete:
            case ECmdDownlinkDeInitComplete:
            case ECmdUplinkDeInitComplete:
            case ECmdDownlinkStarted:
            case ECmdUplinkStarted:
            case ECmdDownlinkPaused:
            case ECmdUplinkPaused:
                {
                TInt index = FindStreamInList();
                if (index != KErrNotFound)
                    {
                    TMSStreamState streamstate = ConvertToStreamState(
                            msgBuf.iRequest);
                    iObserversList[index]->QueueEvent(streamstate,
                            msgBuf.iStatus, NULL);
                    }
                else
                    {
                    // This should never happen
                    err = KErrNotFound;
                    }
                break;
                }
            case ECmdFillBuffer:
                {
                DoFillBuffer(msgBuf.iInt, msgBuf.iStatus, msgBuf.iBool,
                        msgBuf.iUint32);
                break;
                }
            case ECmdEmptyBuffer:
                {
                DoEmptyBuffer(msgBuf.iInt, msgBuf.iStatus, msgBuf.iBool,
                        msgBuf.iUint32);
                break;
                }
            case ECmdDownlinkClosed:
                {
                iChunk.Close();
                break;
                }
            case ECmdUplinkClosed:
                {
                iChunk.Close();
                break;
                }
            case ECmdDnLinkError:
                {
                break;
                }
            case ECmdUpLinkError:
                {
                break;
                }
            case ECmdSetGain:
                {
                TInt index = FindGainEffectInList();
                if (index != KErrNotFound)
                    {
                    iObserversList[index]->QueueEvent(TMS_EVENT_EFFECT_GAIN_CHANGED,
                            msgBuf.iStatus, NULL);
                    }
                }
                break;
            case ECmdSetVolume:
                {
                TInt index = FindVolEffectInList();
                if (index != KErrNotFound)
                    {
                    iObserversList[index]->QueueEvent(TMS_EVENT_EFFECT_VOL_CHANGED,
                            msgBuf.iStatus, NULL);
                    }
                }
                break;
            default:
                break;
            }
        }
    }

// ----------------------------------------------------------------------------
// CQueueHandler::DoFillBuffer
//
// ----------------------------------------------------------------------------
//
void CQueueHandler::DoFillBuffer(TInt aBufLen, TInt aStatus,
        TBool aOpenChunk, TUint32 key)
    {
    TInt err = KErrNone;

    // See if chunk needs to be opened
    if (aOpenChunk)
        {
        if (iChunk.Handle())
            {
            iChunk.Close();
            }
        delete iBuffer;
        iBuffer = NULL;

        // Get handle to chunk from proxy
        TInt hndl(0);
        err = KErrNotReady;
        if (iTMSGlobalContext->CallProxy)
            {
            hndl = (iTMSGlobalContext->CallProxy)->GetDataXferChunkHandle(
                    iTMSGlobalContext->CallType,
                    iTMSGlobalContext->StreamType,
                    iTMSGlobalContext->StreamId,
                    key);
            err = iChunk.SetReturnedHandle(hndl);
            }
        }

    if (err == KErrNone)
        {
        iChunkDataPtr.Set(iChunk.Base(), 0, aBufLen);
        if (!iBuffer)
            {
            TMSMemBuffer::Create((guint) aBufLen,
                    const_cast<guint8*> (iChunkDataPtr.Ptr()), iBuffer);
            }
        iBuffer->SetDataSize(aBufLen);

        TInt index = iClientList.Find(TMS_SOURCE_CLIENT);
        if (index != KErrNotFound)
            {
            iObserversList[index]->QueueEvent(
                    TMS_EVENT_SOURCE_FILL_BUFFER, aStatus, iBuffer);
            }
        else
            {
            err = KErrNotFound;
            }
        }
    else
        {
        // TODO handle error here
        }
    }

// ----------------------------------------------------------------------------
// CQueueHandler::DoEmptyBuffer
//
// ----------------------------------------------------------------------------
//
void CQueueHandler::DoEmptyBuffer(TInt aBufLen, TInt aStatus,
        TBool aOpenChunk, TUint32 key)
    {
    TInt err(KErrNone);

    // See if chunk needs to be opened
    if (aOpenChunk)
        {
        if (iChunk.Handle())
            {
            iChunk.Close();
            }

        // Get handle to chunk from proxy
        TInt hndl(0);
        err = KErrNotReady;
        if (iTMSGlobalContext->CallProxy)
            {
            hndl = (iTMSGlobalContext->CallProxy)->GetDataXferChunkHandle(
                    iTMSGlobalContext->CallType,
                    iTMSGlobalContext->StreamType,
                    iTMSGlobalContext->StreamId,
                    key);
            err = iChunk.SetReturnedHandle(hndl);
            }
        // TODO handle error here
        delete iBuffer;
        iBuffer = NULL;
        }

    if (err == KErrNone)
        {
        iChunkDataPtr.Set(iChunk.Base(), aBufLen, aBufLen);
        if (!iBuffer)
            {
            TMSMemBuffer::Create((guint) aBufLen,
                    const_cast<guint8*> (iChunkDataPtr.Ptr()), iBuffer);
            }
        iBuffer->SetDataSize(aBufLen);
        TInt index = iClientList.Find(TMS_SINK_CLIENT);
        if (index != KErrNotFound)
            {
            iObserversList[index]->QueueEvent(
                    TMS_EVENT_SINK_PROCESS_BUFFER, aStatus, iBuffer);
            }
        else
            {
            err = KErrNotFound;
            }
        }
    else
        {
        //iObserver->Event(MVoIPUplinkObserver::KUplinkError, aStatus);
        }
    }

// ----------------------------------------------------------------------------
// CQueueHandler::ConvertToStreamState
//
// ----------------------------------------------------------------------------
//
TMSStreamState CQueueHandler::ConvertToStreamState(TInt request)
    {
    TMSStreamState state = TMS_STREAM_UNINITIALIZED;
    switch (request)
        {
        case ECmdDownlinkInitComplete:
        case ECmdUplinkInitComplete:
            state = TMS_STREAM_INITIALIZED;
            break;
        case ECmdDownlinkStarted:
        case ECmdUplinkStarted:
            state = TMS_STREAM_STARTED;
            break;
        case ECmdDownlinkPaused:
        case ECmdUplinkPaused:
            state = TMS_STREAM_PAUSED;
            break;
        case ECmdDownlinkDeInitComplete:
        case ECmdUplinkDeInitComplete:
            state = TMS_STREAM_UNINITIALIZED;
            break;
        default:
            break;
        }
    return state;
    }

// ----------------------------------------------------------------------------
// 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;
    }

// ----------------------------------------------------------------------------
// CQueueHandler::FindStreamInList
// Return stream index.
// ----------------------------------------------------------------------------
//
TInt CQueueHandler::FindStreamInList()
    {
    gint index(-1);
    index = iClientList.Find(TMS_STREAM_UPLINK);
    if (index == KErrNotFound)
        {
        index = iClientList.Find(TMS_STREAM_DOWNLINK);
        return index;
        }
    return index;
    }

// ----------------------------------------------------------------------------
// CQueueHandler::FindGainEffectInList
// Return effect index.
// ----------------------------------------------------------------------------
//
TInt CQueueHandler::FindGainEffectInList()
    {
    gint index(-1);
    index = iClientList.Find(TMS_EFFECT_GAIN);
    return index;
    }

// ----------------------------------------------------------------------------
// CQueueHandler::FindVolEffectInList
// Return effect index.
// ----------------------------------------------------------------------------
//
TInt CQueueHandler::FindVolEffectInList()
    {
    gint index(-1);
    index = iClientList.Find(TMS_EFFECT_VOLUME);
    return index;
    }

// End of File