/*

 * Copyright (c) 2010 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:  Starts and stops audio streams.

 *

 */

#include <tmsfactory.h>

#include <tmscall.h>

#include <tmsstream.h>

#include "tmshandler.h"

#include "csplogger.h"

#include "csptimer.h"

#include "csppanic.pan"

/**

 * Timeout initial value.

 */

const TInt KTimeoutInitial = 200000; // 0.2s

/**

 * Double the timeout for every retry.

 */

const TInt KTimeoutMultiplier = 2;

// ======== MEMBER FUNCTIONS ========

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

// Static constructor

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

//

TmsHandler* TmsHandler::NewL()

    {

    TmsHandler* self = TmsHandler::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

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

// Static constructor

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

//

TmsHandler* TmsHandler::NewLC()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

TmsHandler::~TmsHandler()

    {

    if (iTimer)

        {

        iTimer->CancelNotify();

        delete iTimer;

        }

    if (iTmsUplink && iTmsCall)

        {

        // CloseUplink();

        iTmsCall->DeleteStream(iTmsUplink);

        }

    if (iTmsDnlink && iTmsCall)

        {

        // CloseDownlink();

        iTmsCall->DeleteStream(iTmsDnlink);

        }

    if (iFactory && iTmsCall)

        {

        iFactory->DeleteCall(iTmsCall);

        }

    if (iFactory && iTmsMicSource)

        {

        iFactory->DeleteSource(iTmsMicSource);

        }

    if (iFactory && iTmsModemSource)

        {

        iFactory->DeleteSource(iTmsModemSource);

        }

    if (iFactory && iTmsSpeakerSink)

        {

        iFactory->DeleteSink(iTmsSpeakerSink);

        }

    if (iFactory && iTmsModemSink)

        {

        iFactory->DeleteSink(iTmsModemSink);

        }

    delete iFactory;

    }

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

// From class MCSPAudioStream

// Activates mic and speaker.

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

//

void TmsHandler::StartStreams()

    {

    CSPLOGSTRING(CSPINT, "TmsHandler::StartStreams");

    StartMicAndSpeaker();

    }

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

// From class MCSPAudioStream

// Deactivates mic and speaker if the streams are active or they are

// activating.

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

//

void TmsHandler::StopStreams()

    {

    CSPLOGSTRING(CSPINT, "TmsHandler::StopStreams");

    gint status(TMS_RESULT_SUCCESS);

    if (iTimer && IsMicAndSpeakerStarted())

        {

        CSPLOGSTRING(CSPINT, "TmsHandler::StopStreams Stopping");

        iTimer->CancelNotify();

        iTimeout = KTimeoutInitial;

        status = iTmsUplink->Stop();

        iUplinkStarted = FALSE;

        status |= iTmsDnlink->Stop();

        iDnlinkStarted = FALSE;

        if (status != TMS_RESULT_SUCCESS)

            {

            status = TMS_RESULT_GENERAL_ERROR;

            }

        }

    CSPLOGSTRING2(CSPINT, "TmsHandler::StopStreams status %d", status);

    }

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

// From class MCSPTimerObserver

// Notify from CSPTimer that timeout passed. Try to start mic and

// speaker again.

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

//

void TmsHandler::TimerEvent()

    {

    CSPLOGSTRING(CSPINT, "TmsHandler.TimerEvent" );

    iTimeout *= KTimeoutMultiplier;

    StartMicAndSpeaker();

    }

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

// Constructor

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

//

TmsHandler::TmsHandler() :

    iTimeout(KTimeoutInitial)

    {

    }

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

// Second phase constructor

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

//

void TmsHandler::ConstructL()

    {

    CSPLOGSTRING(CSPINT, "TmsHandler::ConstructL");

    iTimer = CSPTimer::NewL();

    if (CreateTMSCallControl())

        {

        User::LeaveIfError(TMS_RESULT_UNINITIALIZED_OBJECT);

        }

    }

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

// TmsHandler::CreateTMSCallControl()

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

//

gint TmsHandler::CreateTMSCallControl()

    {

    TMSVer* v = NULL;

    TInt status;

    status = TMSFactory::CreateFactory(iFactory, *v);

    __ASSERT_ALWAYS(iFactory, Panic( ECSPPanicBadHandle));

    status = iFactory->CreateCall(TMS_CALL_CS, iTmsCall, 0);

    status |= CreateUplink();

    status |= CreateDownlink();

    status |= CreateMicSource();

    status |= AddMicSourceToStream();

    status |= CreateModemSink();

    status |= AddModemSinkToStream();

    status |= CreateModemSource();

    status |= AddModemSourceToStream();

    status |= CreateSpeakerSink();

    status |= AddSpeakerSinkToStream();

    status |= OpenDownlink();

    return status;

    }

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

// Resets timer

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

//

void TmsHandler::AudioStreamsStarted()

    {

    CSPLOGSTRING(CSPINT, "TmsHandler::AudioStreamsStarted" );

    iTimeout = KTimeoutInitial;

    iTimer->CancelNotify();

    }

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

// Starts timer

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

//

void TmsHandler::StartTimer()

    {

    CSPLOGSTRING(CSPINT, "TmsHandler::StartTimer" );

    iTimer->NotifyAfter(iTimeout, *this);

    }

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

// Starts mic and speaker

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

//

void TmsHandler::StartMicAndSpeaker()

    {

    // if speaker and mic is active then activation does not cause any actions.

    gint status(TMS_RESULT_SUCCESS);

    if (iTmsUplink)

        {

        status = iTmsUplink->Start();

        }

    CSPLOGSTRING2( CSPINT, "TmsHandler::StartMicAndSpeaker status %d", status );

    }

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

// Indicated if mic and speaker are started or starting up.

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

//

TBool TmsHandler::IsMicAndSpeakerStarted()

    {

    return (iUplinkStarted || iDnlinkStarted);

    }

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

// CreateUplink

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

//

gint TmsHandler::CreateUplink()

    {

    CSPLOGSTRING(CSPINT, "TmsHandler::CreateUplink");

    gint status(TMS_RESULT_SUCCESS);

    if (iTmsCall)

        {

        status = iTmsCall->CreateStream(TMS_STREAM_UPLINK, iTmsUplink);

        }

    return status;

    }

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

// CreateDownlink

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

//

gint TmsHandler::CreateDownlink()

    {

    CSPLOGSTRING(CSPINT, "TmsHandler::CreateDownlink");

    gint status(TMS_RESULT_SUCCESS);

    if (iTmsCall)

        {

        status = iTmsCall->CreateStream(TMS_STREAM_DOWNLINK, iTmsDnlink);

        }

    return status;

    }

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

// OpenUplink

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

//

gint TmsHandler::OpenUplink()

    {

    CSPLOGSTRING(CSPINT, "TmsHandler::OpenUplink");

    gint status = TMS_RESULT_SUCCESS;

    if (iTmsUplink)

        {

        status = iTmsUplink->AddObserver(*this, NULL);

        if (status == TMS_RESULT_SUCCESS)

            {

            status = iTmsUplink->Init();

            }

        }

    return status;

    }

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

// OpenDownlink

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

//

gint TmsHandler::OpenDownlink()

    {

    CSPLOGSTRING(CSPINT, "TmsHandler::OpenDownlink");

    gint status = TMS_RESULT_SUCCESS;

    if (iTmsDnlink)

        {

        status = iTmsDnlink->AddObserver(*this, NULL);

        if (status == TMS_RESULT_SUCCESS)

            {

            status = iTmsDnlink->Init();

            }

        }

    return status;

    }

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

// CreateModemSource

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

//

gint TmsHandler::CreateModemSource()

    {

    gint status(TMS_RESULT_SUCCESS);

    if (iFactory && !iTmsModemSource)

        {

        status = iFactory->CreateSource(TMS_SOURCE_MODEM, iTmsModemSource);

        }

    return status;

    }

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

// AddModemSourceToStream

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

//

gint TmsHandler::AddModemSourceToStream()

    {

    gint status(TMS_RESULT_SUCCESS);

    if (iTmsDnlink && iTmsModemSource)

        {

        status = iTmsDnlink->AddSource(iTmsModemSource);

        }

    return status;

    }

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

// CreateModemSink

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

//

gint TmsHandler::CreateModemSink()

    {

    gint status(TMS_RESULT_SUCCESS);

    if (iFactory && !iTmsModemSink)

        {

        status = iFactory->CreateSink(TMS_SINK_MODEM, iTmsModemSink);

        }

    return status;

    }

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

// AddModemSinkToStream

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

//

gint TmsHandler::AddModemSinkToStream()

    {

    gint status(TMS_RESULT_SUCCESS);

    if (iTmsUplink && iTmsModemSink)

        {

        status = iTmsUplink->AddSink(iTmsModemSink);

        }

    return status;

    }

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

// CreateMicSource

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

//

gint TmsHandler::CreateMicSource()

    {

    gint status(TMS_RESULT_SUCCESS);

    if (iFactory && !iTmsMicSource)

        {

        status = iFactory->CreateSource(TMS_SOURCE_MIC, iTmsMicSource);

        }

    return status;

    }

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

// AddMicSourceToStream

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

//

gint TmsHandler::AddMicSourceToStream()

    {

    gint status(TMS_RESULT_SUCCESS);

    if (iTmsUplink && iTmsMicSource)

        {

        status = iTmsUplink->AddSource(iTmsMicSource);

        }

    return status;

    }

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

// CreateSpeakerSink

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

//

gint TmsHandler::CreateSpeakerSink()

    {

    gint status(TMS_RESULT_SUCCESS);

    if (iFactory && !iTmsSpeakerSink)

        {

        status = iFactory->CreateSink(TMS_SINK_SPEAKER, iTmsSpeakerSink);

        }

    return status;

    }

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

// AddSpeakerSinkToStream

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

//

gint TmsHandler::AddSpeakerSinkToStream()

    {

    gint status(TMS_RESULT_SUCCESS);

    if (iTmsDnlink && iTmsSpeakerSink)

        {

        status = iTmsDnlink->AddSink(iTmsSpeakerSink);

        }

    return status;

    }

// TMS CALLBACKS

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

// TmsHandler::TMSStreamEvent

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

//

void TmsHandler::TMSStreamEvent(const TMSStream& stream, TMSSignalEvent event)

    {

    CSPLOGSTRING2(CSPINT, "TmsHandler::TMSStreamEvent status %d", event.reason);

    TMSStreamType strmType = const_cast<TMSStream&>(stream).GetStreamType();

    if (strmType == TMS_STREAM_UPLINK &&

            event.type == TMS_EVENT_STREAM_STATE_CHANGED)

        {

        switch (event.curr_state)

            {

            case TMS_STREAM_INITIALIZED:

                //notify stream ready state

                break;

            case TMS_STREAM_UNINITIALIZED:

                //notify initialization error

                break;

            case TMS_STREAM_PAUSED:

                break;

            case TMS_STREAM_STARTED:

                iUplinkStarted = TRUE;

                iTmsDnlink->Start();

                break;

            default:

                break;

            }

        }

    else if (strmType == TMS_STREAM_DOWNLINK &&

            event.type == TMS_EVENT_STREAM_STATE_CHANGED)

        {

        switch (event.curr_state)

            {

            case TMS_STREAM_INITIALIZED:

                {

                if ((iTmsCall->GetCallType() == TMS_CALL_CS)

                        && (!iUplinkStarted))

                    {

                    OpenUplink();

                    }

                //notify stream ready state

                }

                break;

            case TMS_STREAM_UNINITIALIZED:

                //notify initialization error

                break;

            case TMS_STREAM_PAUSED:

                break;

            case TMS_STREAM_STARTED:

                iDnlinkStarted = TRUE;

                break;

            default:

                break;

            }

        }

    }

//  End of File