/*

 * 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: Activates TMS call audio control streams.

 *

 */

#include <tmsfactory.h>

#include <tmscall.h>

#include <tmsstream.h>

#include "tmshandler.h"

#include "csplogger.h"

#include "csppanic.pan"

#include "mtmshandlerobserver.h"

const TInt KStreamInitRetry = 1000000; //1 sec

const TInt KRetryForever = -1;

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

// Static constructor

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

//

TmsHandler* TmsHandler::NewL(MTmsHandlerObserver& aObserver)

    {

    TmsHandler* self = TmsHandler::NewLC(aObserver);

    CleanupStack::Pop(self);

    return self;

    }

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

// Static constructor

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

//

TmsHandler* TmsHandler::NewLC(MTmsHandlerObserver& aObserver)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aObserver);

    return self;

    }

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

// Destructor

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

//

TmsHandler::~TmsHandler()

    {

    if (iTmsUplink && iTmsCall)

        {

        iTmsCall->DeleteStream(iTmsUplink);

        }

    if (iTmsDnlink && iTmsCall)

        {

        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;

    }

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

// TmsHandler::StartStreams

// Activates TMS call audio control streams. If called in the middle of an

// ongoing stream initialization, the request is cashed in until both streams

// transition to initialized state.

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

//

TInt TmsHandler::StartStreams()

    {

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

    TInt status(TMS_RESULT_SUCCESS);

    if (iTmsUplink)

        {

        if (iTmsUplink->GetState() == TMS_STREAM_INITIALIZED)

            {

            status = iTmsUplink->Start(KRetryForever);

            }

        else if (iUplInitializing)

            {

            iStartAfterInitComplete = ETrue;

            }

        }

    if (iTmsDnlink && status == TMS_RESULT_SUCCESS)

        {

        if (iTmsDnlink->GetState() == TMS_STREAM_INITIALIZED)

            {

            status = iTmsDnlink->Start(KRetryForever);

            }

        else if (iDnlInitializing)

            {

            iStartAfterInitComplete = ETrue;

            }

        }

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

    if (status != TMS_RESULT_SUCCESS)

        {

        // Cancel any pending retry and cancel.

        StopStreams();

        status = KErrCancel;

        }

    return status;

    }

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

// TmsHandler::StopStreams

// Deactivates TMS call audio control streams. If streams are not started yet,

// any pending request on TMS streams will be canceled.

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

//

void TmsHandler::StopStreams()

    {

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

    if (iTmsUplink)

        {

        iTmsUplink->Stop();

        }

    if (iTmsDnlink)

        {

        iTmsDnlink->Stop();

        }

    iUplInitializing = EFalse;

    iDnlInitializing = EFalse;

    iStartAfterInitComplete = EFalse;

    }

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

// TmsHandler::AreStreamsStarted

// Indicates whether both audio control streams have been started.

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

//

TBool TmsHandler::AreStreamsStarted()

    {

    TBool status(EFalse);

    if (iTmsUplink && iTmsDnlink)

        {

        if (iTmsUplink->GetState() == TMS_STREAM_STARTED &&

                iTmsDnlink->GetState() == TMS_STREAM_STARTED)

            {

            status = ETrue;

            }

        }

    return status;

    }

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

// Constructor

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

//

TmsHandler::TmsHandler()

    {

    }

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

// Second phase constructor

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

//

void TmsHandler::ConstructL(MTmsHandlerObserver& aObserver)

    {

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

    iObserver = &aObserver;

    User::LeaveIfError(CreateTMSCallControl());

    }

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

// TmsHandler::CreateTMSCallControl()

// Allocates and initializes all TMS resources needed for call audio control.

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

//

TInt TmsHandler::CreateTMSCallControl()

    {

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

    TInt status;

    __ASSERT_ALWAYS(iFactory, Panic(ECSPPanicBadHandle));

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

    if (iTmsCall && status == TMS_RESULT_SUCCESS)

        {

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

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

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

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

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

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

        }

    if (iTmsUplink && iTmsMicSource && iTmsModemSink &&

            status == TMS_RESULT_SUCCESS)

        {

        status = iTmsUplink->AddSource(iTmsMicSource);

        status |= iTmsUplink->AddSink(iTmsModemSink);

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

        status |= iTmsUplink->Init(KStreamInitRetry);

        }

    if (iTmsDnlink && iTmsModemSource && iTmsSpeakerSink &&

            status == TMS_RESULT_SUCCESS)

        {

        status = iTmsDnlink->AddSource(iTmsModemSource);

        status |= iTmsDnlink->AddSink(iTmsSpeakerSink);

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

        status |= iTmsDnlink->Init(KStreamInitRetry);

        }

    if (status == TMS_RESULT_SUCCESS)

        {

        iUplInitializing = ETrue;

        iDnlInitializing = ETrue;

        }

    else

        {

        status = KErrCancel; // Convert to Symbian error and cancel

        }

    return status;

    }

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

// TmsHandler::ProcessUplinkStreamChangeEvent

// Processes Uplink stream state change events.

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

//

void TmsHandler::ProcessUplinkStreamChangeEvent(TInt aState)

    {

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

    switch (aState)

        {

        case TMS_STREAM_INITIALIZED:

            iUplInitializing = EFalse;

            if (iStartAfterInitComplete)

                {

                iStartAfterInitComplete = EFalse;

                TInt status = StartStreams();

                if (status != TMS_RESULT_SUCCESS)

                    {

                    iObserver->AudioStreamsError(status);

                    }

                }

            break;

        case TMS_STREAM_UNINITIALIZED:

            // As result of Deinit() or error

            iUplInitializing = EFalse;

            iStartAfterInitComplete = EFalse;

            break;

        case TMS_STREAM_PAUSED:

            break;

        case TMS_STREAM_STARTED:

            if (AreStreamsStarted())

                {

                iObserver->AudioStreamsStarted();

                }

            break;

        default:

            break;

        }

    }

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

// TmsHandler::ProcessDownlinkStreamChangeEvent

// Processes Downlink stream state change events.

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

//

void TmsHandler::ProcessDownlinkStreamChangeEvent(TInt aState)

    {

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

    switch (aState)

        {

        case TMS_STREAM_INITIALIZED:

            iDnlInitializing = EFalse;

            if (iStartAfterInitComplete)

                {

                iStartAfterInitComplete = EFalse;

                TInt status = StartStreams();

                if (status != TMS_RESULT_SUCCESS)

                    {

                    iObserver->AudioStreamsError(status);

                    }

                }

            break;

        case TMS_STREAM_UNINITIALIZED:

            // As result of Deinit() or error

            iDnlInitializing = EFalse;

            iStartAfterInitComplete = EFalse;

            break;

        case TMS_STREAM_PAUSED:

            break;

        case TMS_STREAM_STARTED:

            if (AreStreamsStarted())

                {

                iObserver->AudioStreamsStarted();

                }

            break;

        default:

            break;

        }

    }

// TMS CALLBACKS

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

// TmsHandler::TMSStreamEvent

// From TMSStreamObserver

// TMS call audio stream control event handler.

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

//

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)

        {

        if (event.type == TMS_EVENT_STREAM_STATE_CHANGED)

            {

            ProcessUplinkStreamChangeEvent(event.curr_state);

            }

        else if (event.type == TMS_EVENT_STREAM_STATE_CHANGE_ERROR)

            {

            Panic( ECSPPanicAudioStreamInitFailure );

            }

        }

    else if (strmType == TMS_STREAM_DOWNLINK)

        {

        if (event.type == TMS_EVENT_STREAM_STATE_CHANGED)

            {

            ProcessDownlinkStreamChangeEvent(event.curr_state);

            }

        else if (event.type == TMS_EVENT_STREAM_STATE_CHANGE_ERROR)

            {

            Panic( ECSPPanicAudioStreamInitFailure );

            }

        }

    }

//  End of File