/*
* Copyright (c) 2002-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 service -
*
*/



// INCLUDE FILES
#include "VoIPAudioServicesTestClass.h"
#include "debug.h"





/************************************************************************************************************/

// ----------------------------------------------------------------------------
// CVoIPAudioServicesTestClass::FillBuffer
//
// Callback from MVoIPDownlinkObserver
// ----------------------------------------------------------------------------
//
void CVoIPAudioServicesTestClass::FillBuffer(const CVoIPAudioDownlinkStream& /*aSrc*/,
                                  CVoIPDataBuffer* aBuffer)
{

    iLog->Log(_L("CVoIPAudioServicesTestClass::FillBuffer"));
    ProcessEvent(EFillBuffer, KErrNone);

    // In JB mode we will only receive FillBuffer callback once after
    // ConfigureJB. We will simply reuse same buffer to send data to VAS.
    aBuffer->GetPayloadPtr(iPlayBufPtr);
    iPlayBufReady = ETrue; // always ready in JB mode

#ifndef __JITTER_BUFFER_TEST__
    // In JB mode, DoLoopback is only called when from EmptyBuffer
    if (iDnLinkStatus == EStreaming)
        {
        DoLoopback();
        }
#endif  //__JITTER_BUFFER_TEST__
}

// ----------------------------------------------------------------------------
// CVoIPAudioServicesTestClass::Event
//
// Callback from MVoIPDownlinkObserver
// ----------------------------------------------------------------------------
//
void CVoIPAudioServicesTestClass::Event(const CVoIPAudioDownlinkStream& /*aSrc*/,
                            TInt aEventType,
                            TInt aError)
{
    switch (aEventType)
        {
        case MVoIPDownlinkObserver::KOpenComplete:
            {
            if (aError == KErrNone)
                {
                // Now we can configure decoder and audio device
                iVoIPDnlink->GetMaxVolume(iMaxVolume);
                iVoIPDnlink->SetVolume(iMaxVolume / 2);
                //  ConfigureDecoder();

#ifdef __JITTER_BUFFER_TEST__
                if (iDnLinkCodec != EPCM16)
                    {
                    ConfigureJB(); // will trigger FillBuffer callback
                    }
#endif //__JITTER_BUFFER_TEST__

                iDnLinkStatus = EReady;
                iLog->Log(_L("MVoIPDownlinkObserver::KOpenComplete: aError = %d"), aError);
                ProcessEvent(EOpenDownlinkComplete, aError);
                }

            iLog->Log(_L("DNL Initialized: aError = %d"), aError);
            break;
            }
        case MVoIPDownlinkObserver::KDownlinkClosed:
            {
            iDnLinkStatus = ENotReady;
            iLog->Log(_L("MVoIPDownlinkObserver::KDownlinkClosed: aError = %d"), aError);
            ProcessEvent(EDownlinkClosed, aError);
            break;
            }
        case MVoIPDownlinkObserver::KDownlinkError:
            {
            iDnLinkStatus = EReady;
            iLog->Log(_L("DNL Error: aError = %d"), aError);
            break;
            }
/*        case KVoIPOpenDTMFComplete:
            {
            DisplayText(_L("DTMF (DNL) Open"), aError);
            break;
            }*/
/*
        case KVoIP_TEMP1:
            {
            DisplayText(_L("DTMF PLR Ready"), aError);
            break;
            }
        case KVoIP_TEMP2:
            {
            DisplayText(_L("DTMF PLR Ready"), aError);
            break;
            }
*/
        default:
            break;
        }
}

// ----------------------------------------------------------------------------
// CVoIPAudioServicesTestClass::EmptyBuffer
//
// Callback from MVoIPUplinkObserver
// ----------------------------------------------------------------------------
//
void CVoIPAudioServicesTestClass::EmptyBuffer(const CVoIPAudioUplinkStream& /*aSrc*/,
                                  CVoIPDataBuffer* aBuffer)
{
    iLog->Log(_L("CVoIPAudioServicesTestClass::EmptyBuffer"));
    ProcessEvent(EEmptyBuffer, KErrNone);

    aBuffer->GetPayloadPtr(iRecBufPtr);
    iRecBufReady = ETrue;

    if (iUpLinkStatus == EStreaming)
        {
        DoLoopback();
      //  iVoIPUplink->BufferEmptied(aBuffer);
      //  iUpLinkStatus = EReady;
        }
}

// ----------------------------------------------------------------------------
// CVoIPAudioServicesTestClass::Event
//
// Callback from MVoIPUplinkObserver
// ----------------------------------------------------------------------------
//
void CVoIPAudioServicesTestClass::Event(const CVoIPAudioUplinkStream& /*aSrc*/,
                            TInt aEventType,
                            TInt aError)
{
    switch (aEventType)
        {
        case MVoIPUplinkObserver::KOpenComplete:
            {
            if (aError == KErrNone)
                {
                // Now we can configure encoder and audio device
                iVoIPUplink->GetMaxGain(iMaxGain);
                iVoIPUplink->SetGain(iMaxGain);

                iUpLinkStatus = EReady;
                iLog->Log(_L("MVoIPUplinkObserver::KOpenComplete: aError = %d"), aError);
                ProcessEvent(EOpenUplinkComplete, aError);
                }

            iLog->Log(_L("UPL Initialized: aError = %d"), aError);
            break;
            }
        case MVoIPUplinkObserver::KUplinkClosed:
            {
            iUpLinkStatus = ENotReady;
            iLog->Log(_L("MVoIPUplinkObserver::KUplinkClosed: aError = %d"), aError);
            ProcessEvent(EUplinkClosed, aError);
            break;
            }
        case MVoIPUplinkObserver::KUplinkError:
            {
            iUpLinkStatus = EReady;
            iLog->Log(_L("UPL Error: aError = %d"), aError);
            break;
            }

// TODO: Move to MDTMFToneObserver::Event handler
/*        case KVoIP_TEMP1:
            {
            DisplayText(_L("DTMF PLR Ready"), aError);
            break;
            }
        case KVoIP_TEMP2:
            {
            DisplayText(_L("DTMF PLR Ready"), aError);
            break;
            }
*/
        default:
            break;
        }
}

// ----------------------------------------------------------------------------
// CVoIPAudioServicesTestClass::Event
//
// Callback from MVoIPFormatObserver
// ----------------------------------------------------------------------------
//
void CVoIPAudioServicesTestClass::Event(const CVoIPFormatIntfc& /*aSrc*/, TInt aEventType)
{
    switch (aEventType)
        {
        case MVoIPFormatObserver::KSilenceBegin:
        case MVoIPFormatObserver::KSilenceUpdate:
        case MVoIPFormatObserver::KSilenceEnd:
        case MVoIPFormatObserver::KObserverEventMax:
        default:
            break;
        }
}

// ----------------------------------------------------------------------------
// CVoIPAudioServicesTestClass::Event
//
// Callback from MDTMFToneObserver
// ----------------------------------------------------------------------------
//
void CVoIPAudioServicesTestClass::Event(const CDTMFTonePlayer& /*aSrc*/,
                            TInt aEventType,
                            TInt aError)
{
    switch (aEventType)
        {
        case MDTMFToneObserver::KOpenCompleteDNL:
            iLog->Log(_L("MDTMFToneObserver:KOpenCompleteDNL:DTMF DNL-PLR Ready: aError = %d"), aError);
            ProcessEvent(EOpenCompleteDNL, aError);
            break;
        case MDTMFToneObserver::KOpenCompleteUPL:
            iLog->Log(_L("MDTMFToneObserver:KOpenCompleteUPL:DTMF UPL-PLR Ready: aError = %d"), aError);
            ProcessEvent(EOpenCompleteUPL, aError);
            break;
        default:
            break;
        }
}

// ----------------------------------------------------------------------------
// CVoIPAudioServicesTestClass::Event
//
// Callback from MRingToneObserver
// ----------------------------------------------------------------------------
//
void CVoIPAudioServicesTestClass::Event(const CRingTonePlayer& /*aSrc*/,
                            TInt aEventType,
                            TInt aError)
{
    switch (aEventType)
        {
        case MRingToneObserver::KOpenComplete:
            ProcessEvent(EOpenComplete, aError);
            iLog->Log(_L("RT PLR Ready: error = %d"), aError);
            break;
        case MRingToneObserver::KPlaybackComplete:
            ProcessEvent(EPlaybackComplete, aError);
            iLog->Log(_L("RT Play Complete: error = %d"), aError);
            break;
        default:
            break;
        }
}

#ifdef __JITTER_BUFFER_TEST__
// ----------------------------------------------------------------------------
// CVoIPAudioServicesTestClass::Event
//
// Callback from MVoIPJitterBufferObserver
// ----------------------------------------------------------------------------
//
void CVoIPAudioServicesTestClass::Event(const CVoIPJitterBufferIntfc& /*aSrc*/,
                            			TInt aEventType)
{
    switch (aEventType)
        {
        // Reserved for future use
		case MVoIPJitterBufferObserver::KJBReserved1:
		case MVoIPJitterBufferObserver::KJBReserved2:
		default:
            break;
        }
}

#endif //__JITTER_BUFFER_TEST__