/*

 * 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 <AudioPreference.h>

#include "tmsutility.h"

#include "tmsclientserver.h"

#include "tmsshared.h"

#include "tmscallipadpt.h"

using namespace TMS;

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

// TMSCallIPAdpt::NewL

// Symbian constructor.

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

//

TMSCallIPAdpt* TMSCallIPAdpt::NewL()

    {

    TMSCallIPAdpt* self = new (ELeave) TMSCallIPAdpt();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// TMSCallIPAdpt::ConstructL

// 2-nd phase constructor.

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

//

void TMSCallIPAdpt::ConstructL()

    {

    TRACE_PRN_FN_ENT;

    iIPDownlink = NULL;

    iIPUplink = NULL;

    iDTMFDnlinkPlayer = NULL;

    iDTMFUplinkPlayer = NULL;

    iDTMFNotifier = NULL;

    TRACE_PRN_FN_EXT;

    }

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

// TMSCallIPAdpt::TMSCallIPAdpt

//

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

//

TMSCallIPAdpt::TMSCallIPAdpt()

    {

    }

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

// TMSCallIPAdpt::~TMSCallIPAdpt

//

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

//

TMSCallIPAdpt::~TMSCallIPAdpt()

    {

    TRACE_PRN_FN_ENT;

    iCodecs.Reset();

    iCodecs.Close();

    iArrBitrates.Reset();

    delete iDTMFUplinkPlayer;

    delete iDTMFDnlinkPlayer;

    delete iDTMFNotifier;

    delete iIPUplink;

    delete iIPDownlink;

    if (iMsgQueueUp.Handle() > 0)

        {

        iMsgQueueUp.Close();

        }

    if (iMsgQueueDn.Handle() > 0)

        {

        iMsgQueueDn.Close();

        }

    TRACE_PRN_FN_EXT;

    }

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

// TMSCallIPAdpt::PostConstruct

//

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

//

gint TMSCallIPAdpt::PostConstruct()

    {

    TRACE_PRN_FN_ENT;

    gint status(TMS_RESULT_SUCCESS);

    iNextStreamId = 1;

    iUplinkInitialized = FALSE;

    iDnlinkInitialized = FALSE;

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSCallIPAdpt::CreateStream

//

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

//

gint TMSCallIPAdpt::CreateStream(const TMSCallType /*callType*/,

        const TMSStreamType strmType, gint& outStrmId)

    {

    TRACE_PRN_FN_ENT;

    gint status(TMS_RESULT_SUCCESS);

    switch (strmType)

        {

        case TMS_STREAM_UPLINK:

            {

            status = TMS_RESULT_ALREADY_EXIST;

            if (!iUplinkInitialized)

                {

                iUplinkStreamId = iNextStreamId;

                outStrmId = iUplinkStreamId;

                iNextStreamId++;

                //iUplinkInitialized = TRUE; //not initialized yet!

                status = TMS_RESULT_SUCCESS;

                }

            break;

            }

        case TMS_STREAM_DOWNLINK:

            {

            status = TMS_RESULT_ALREADY_EXIST;

            if (!iDnlinkInitialized)

                {

                iDnlinkStreamId = iNextStreamId;

                outStrmId = iDnlinkStreamId;

                iNextStreamId++;

                //iDnlinkInitialized = TRUE; //not initialized yet!

                status = TMS_RESULT_SUCCESS;

                }

            break;

            }

        default:

            {

            status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

            break;

            }

        }

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSCallIPAdpt::InitStream

//

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

//

gint TMSCallIPAdpt::InitStream(const TMSCallType /*callType*/,

        const TMSStreamType strmType, const gint strmId,

        const TMSFormatType frmtType, const gint retrytime,

        const RMessage2& message)

    {

    TRACE_PRN_FN_ENT;

    gint status(TMS_RESULT_SUCCESS);

    guint32 fourCC = TOFOURCC(frmtType);

    if (fourCC == NULL)

        {

        return TMS_RESULT_INVALID_ARGUMENT;

        }

    switch (strmType)

        {

        case TMS_STREAM_UPLINK:

            {

            status = TMS_RESULT_DOES_NOT_EXIST;

            if (strmId == iUplinkStreamId)

                {

                SetFormat(iUplinkStreamId, fourCC);

                status = OpenUplink(message, retrytime);

                if (status == TMS_RESULT_SUCCESS)

                    {

                    status = InitDTMF(TMS_STREAM_UPLINK);

                    }

                }

            break;

            }

        case TMS_STREAM_DOWNLINK:

            {

            status = TMS_RESULT_DOES_NOT_EXIST;

            if (strmId == iDnlinkStreamId)

                {

                SetFormat(iDnlinkStreamId, fourCC);

                status = OpenDownlink(message, retrytime);

                if (status == TMS_RESULT_SUCCESS)

                    {

                    status = InitDTMF(TMS_STREAM_DOWNLINK);

                    }

                }

            break;

            }

        default:

            {

            status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

            break;

            }

        }

    TRACE_PRN_IF_ERR(status);

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSCallIPAdpt::StartStream

//

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

//

gint TMSCallIPAdpt::StartStream(const TMSCallType /*callType*/,

        const TMSStreamType strmType, const gint strmId, const gint retrytime)

    {

    TRACE_PRN_FN_ENT;

    gint status(TMS_RESULT_INVALID_STATE);

    switch (strmType)

        {

        case TMS_STREAM_UPLINK:

            {

            if (iIPUplink && strmId == iUplinkStreamId)

                {

                iIPUplink->Start(retrytime);

                status = TMS_RESULT_SUCCESS;

                NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status);

                }

            break;

            }

        case TMS_STREAM_DOWNLINK:

            {

            if (iIPDownlink && strmId == iDnlinkStreamId)

                {

                iIPDownlink->Start(retrytime);

                status = TMS_RESULT_SUCCESS;

                NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status);

                }

            break;

            }

        default:

            {

            status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

            break;

            }

        }

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSCallIPAdpt::PauseStream

//

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

//

gint TMSCallIPAdpt::PauseStream(const TMSCallType /*callType*/,

        const TMSStreamType strmType, const gint strmId)

    {

    TRACE_PRN_FN_ENT;

    gint status(TMS_RESULT_INVALID_STATE);

    switch (strmType)

        {

        case TMS_STREAM_UPLINK:

            {

            if (strmId == iUplinkStreamId && iIPUplink)

                {

                iIPUplink->Stop();

                status = TMS_RESULT_SUCCESS;

                NotifyClient(iUplinkStreamId, ECmdUplinkPaused, status);

                }

            break;

            }

        case TMS_STREAM_DOWNLINK:

            {

            if (strmId == iDnlinkStreamId && iIPDownlink)

                {

                iIPDownlink->Stop();

                status = TMS_RESULT_SUCCESS;

                NotifyClient(iDnlinkStreamId, ECmdDownlinkPaused, status);

                }

            break;

            }

        default:

            {

            status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

            break;

            }

        }

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSCallIPAdpt::StopStream

//

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

//

gint TMSCallIPAdpt::StopStream(const TMSCallType /*callType*/,

        const TMSStreamType strmType, const gint strmId)

    {

    TRACE_PRN_FN_ENT;

    gint status(TMS_RESULT_INVALID_STATE);

    switch (strmType)

        {

        case TMS_STREAM_UPLINK:

            {

            if (iIPUplink && strmId == iUplinkStreamId)

                {

                iIPUplink->Stop();

                status = TMS_RESULT_SUCCESS;

                NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);

                }

            break;

            }

        case TMS_STREAM_DOWNLINK:

            {

            if (iIPDownlink && strmId == iDnlinkStreamId)

                {

                iIPDownlink->Stop();

                status = TMS_RESULT_SUCCESS;

                NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);

                }

            break;

            }

        default:

            {

            status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

            break;

            }

        }

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSCallIPAdpt::DeinitStream

//

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

//

gint TMSCallIPAdpt::DeinitStream(const TMSCallType /*callType*/,

        const TMSStreamType strmType, const gint strmId)

    {

    TRACE_PRN_FN_ENT;

    gint status(TMS_RESULT_INVALID_STATE);

    switch (strmType)

        {

        case TMS_STREAM_UPLINK:

            {

            if (iIPUplink && strmId == iUplinkStreamId)

                {

                iIPUplink->Stop();

                //iUplinkStreamId = -1;

                iUplinkInitialized = FALSE;

                status = TMS_RESULT_SUCCESS;

                NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status);

                }

            break;

            }

        case TMS_STREAM_DOWNLINK:

            {

            if (iIPDownlink && strmId == iDnlinkStreamId)

                {

                iIPDownlink->Stop();

                //iDnlinkStreamId = -1;

                iDnlinkInitialized = FALSE;

                status = TMS_RESULT_SUCCESS;

                NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete,

                        status);

                }

            break;

            }

        default:

            {

            status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

            break;

            }

        }

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSCallIPAdpt::DeleteStream

//

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

//

gint TMSCallIPAdpt::DeleteStream(const TMSCallType /*callType*/,

        const TMSStreamType strmType, const gint strmId)

    {

    TRACE_PRN_FN_ENT;

    gint status(TMS_RESULT_SUCCESS);

    switch (strmType)

        {

        case TMS_STREAM_UPLINK:

            {

            if (strmId == iUplinkStreamId)

                {

                iUplinkStreamId = -1;

                iUplinkInitialized = FALSE;

                }

            break;

            }

        case TMS_STREAM_DOWNLINK:

            {

            if (strmId == iDnlinkStreamId)

                {

                iDnlinkStreamId = -1;

                iDnlinkInitialized = FALSE;

                }

            break;

            }

        default:

            {

            status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

            break;

            }

        }

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSCallIPAdpt::DataXferBufferEmptied

//

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

//

gint TMSCallIPAdpt::DataXferBufferEmptied(const TMSCallType /*callType*/,

        const TMSStreamType strmType, const gint strmId)

    {

    TRACE_PRN_FN_ENT;

    gint status(TMS_RESULT_SUCCESS);

    switch (strmType)

        {

        case TMS_STREAM_UPLINK:

            {

            if (strmId == iUplinkStreamId)

                {

                TRAP(status, BufferEmptiedL());

                }

            break;

            }

        case TMS_STREAM_DOWNLINK:

            status = TMS_RESULT_ILLEGAL_OPERATION;

            break;

        default:

            status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

            break;

        }

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSCallIPAdpt::DataXferBufferFilled

//

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

//

gint TMSCallIPAdpt::DataXferBufferFilled(const TMSCallType /*callType*/,

        const TMSStreamType strmType, const gint strmId, const guint datasize)

    {

    TRACE_PRN_FN_ENT;

    gint status(TMS_RESULT_SUCCESS);

    switch (strmType)

        {

        case TMS_STREAM_DOWNLINK:

            if (strmId == iDnlinkStreamId)

                {

                TRAP(status, BufferFilledL(datasize));

                }

            break;

        case TMS_STREAM_UPLINK:

            status = TMS_RESULT_ILLEGAL_OPERATION;

            break;

        default:

            status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

            break;

        }

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSCallIPAdpt::GetDataXferBufferHndl

//

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

//

gint TMSCallIPAdpt::GetDataXferBufferHndl(const TMSCallType /*callType*/,

        const TMSStreamType strmType, const gint strmId, const guint32 key,

        RChunk& chunk)

    {

    TRACE_PRN_FN_ENT;

    gint status(TMS_RESULT_SUCCESS);

    switch (strmType)

        {

        case TMS_STREAM_DOWNLINK:

            {

            if (strmId == iDnlinkStreamId)

                {

                TRAP(status, GetDataXferChunkHndl(strmType, key, chunk));

                }

            break;

            }

        case TMS_STREAM_UPLINK:

            {

            if (strmId == iUplinkStreamId)

                {

                TRAP(status, GetDataXferChunkHndl(strmType, key, chunk));

                }

            break;