/*

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

#include <e32uid.h>

#include <e32capability.h>

#include "tmsutility.h"

#include "tmsclientserver.h"

#include "tmstelephonycenrep.h"

#include "tmsservershutdown.h"

#include "tmsserversession.h"

#include "tmscallserverstartparam.h"

#include "tmscallserver.h"

#include "tmscallclisrv.h"

#include "tmsglobaleffectssettings.h"

#include "tmstareventhandler.h"

#include "tmscenrepaudiohandler.h"

#include "tmsserver.h"

using namespace TMS;

// CONSTANTS

const TInt KTMSShutDownDelayTime = 1000000; // 1 sec delay time

const TInt KOutputsArraySize = 10;

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

// TMSServer::NewL

//

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

//

TMSServer* TMSServer::NewL()

    {

    TMSServer* self = new (ELeave) TMSServer;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// TMSServer::TMSServer

//

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

//

TMSServer::TMSServer() :

    CServer2(CActive::EPriorityHigh, ESharableSessions),

    iSession(0)

    {

    }

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

// TMSServer::~TMSServer

//

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

//

TMSServer::~TMSServer()

    {

    TRACE_PRN_FN_ENT;

    delete iShutdownTimer;

    iTMSCallServList.ResetAndDestroy();

    iTMSCallServList.Close();

    iDnlCodecs.Reset();

    iDnlCodecs.Close();

    iUplCodecs.Reset();

    iUplCodecs.Close();

    delete iEffectSettings;

    CancelCenRepHandler();

    TRACE_PRN_FN_EXT;

    }

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

// TMSServer::NewSessionL

//

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

//

CSession2* TMSServer::NewSessionL(const TVersion& aVersion,

        const RMessage2& aMessage) const

    {

    TRACE_PRN_FN_ENT;

    if (!aMessage.HasCapability(ECapabilityMultimediaDD))

        {

        User::Leave(KErrPermissionDenied);

        }

    const TVersion version(KTMSServMajorVersionNumber,

            KTMSServMinorVersionNumber, KTMSServBuildVersionNumber);

    if (!User::QueryVersionSupported(version, aVersion))

        {

        User::Leave(KErrNotSupported);

        }

    TMSServerSession* session = TMSServerSession::NewL(*((TMSServer*) this));

    TRACE_PRN_FN_EXT;

    return session;

    }

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

// TMSServer::ConstructL

//

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

//

void TMSServer::ConstructL()

    {

    TRACE_PRN_FN_ENT;

    iShutdownTimer = TMSServerShutDown::NewL();

    StartL(KTMSServerName);

    RThread().SetPriority(EPriorityRealTime);

    iEffectSettings = TMSGlobalEffectsSettings::NewL();

    iTarHandler = NULL;

    iAudioCenRepHandler = NULL;

    TRACE_PRN_FN_EXT;

    }

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

// TMSServer::AddSession

//

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

//

void TMSServer::AddSession()

    {

    iSession++;

    // If shutdown timer is active, cancel it here.

    iShutdownTimer->Cancel();

    TRACE_PRN_N1(_L("TMS->SRV: AddSession->Active Sessions: [%d]"), iSession);

    }

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

// TMSServer::DropSession

//

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

//

void TMSServer::DropSession()

    {

    iSession--;

    // If session count is zero, start server shutdown

    if (iSession == 0)

        {

        iShutdownTimer->SetDelay(TTimeIntervalMicroSeconds32(

                KTMSShutDownDelayTime));

        }

    TRACE_PRN_N1(_L("TMS->DNL: DropSession->Active Sessions: [%d]"), iSession);

    }

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

// TMSServer::SessionCount

//

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

//

TInt TMSServer::SessionCount() const

    {

    return iSession;

    }

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

// TMSServer::SetDnLinkSession

//

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

//

void TMSServer::SetDnLinkSession(const TBool aSession)

    {

    iDnlinkSession = aSession;

    }

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

// TMSServer::SetUpLinkSession

//

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

//

void TMSServer::SetUpLinkSession(const TBool aSession)

    {

    iUplinkSession = aSession;

    }

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

// TMSServer::HasDnLinkSession

//

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

//

TBool TMSServer::HasDnLinkSession() const

    {

    return iDnlinkSession;

    }

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

// TMSServer::HasUpLinkSession

//

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

//

TBool TMSServer::HasUpLinkSession() const

    {

    return iUplinkSession;

    }

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

// TMSServer::GetNewTMSCallSessionHandleL

//

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

//

void TMSServer::GetNewTMSCallSessionHandleL(RHandleBase& aHandle)

    {

    TRACE_PRN_FN_ENT;

    TInt i = 0;

    while (i < iTMSCallServList.Count())

        {

        TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];

        if (!callThread->IsActive())

            {

            iTMSCallServList.Remove(i);

            delete callThread;

            }

        else

            {

            i++;

            }

        }

    iTMSCallServList.Compress();

    TMSCallProxyLocal tmsCallSessionHandle;

    User::LeaveIfError(StartTMSCallServer(tmsCallSessionHandle));

    aHandle = tmsCallSessionHandle;

    TRACE_PRN_FN_EXT;

    }

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

// TMSServer::StartTMSCallServer

//

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

//

TInt TMSServer::StartTMSCallServer(TMSCallProxyLocal& aHandle)

    {

    TRACE_PRN_FN_ENT;

    TInt status = TMS_RESULT_SUCCESS;

    TMSStartAndMonitorTMSCallThread* callServerThread = NULL;

    TRAP(status, callServerThread =TMSStartAndMonitorTMSCallThread::NewL(

            const_cast<TMSServer*>(this)));

    if (status != TMS_RESULT_SUCCESS)

        {

        delete callServerThread;

        }

    else

        {

        status = iTMSCallServList.Append(callServerThread);

        if (callServerThread && status == TMS_RESULT_SUCCESS)

            {

            status = callServerThread->StartTMSCallServer(aHandle);

            TInt count = 0;

            count = iTMSCallServList.Count();

            iTMSCallServList[count - 1]->iTMSCallProxyLocal = aHandle;

            //cache global vol and global gain to call server thread.

            TInt volume;

            switch (iCurrentRouting)

                {

                case TMS_AUDIO_OUTPUT_PUBLIC:

                case TMS_AUDIO_OUTPUT_LOUDSPEAKER:

                    {

                    iEffectSettings->GetLoudSpkrVolume(volume);

                    }

                    break;

                default:

                    {

                    iEffectSettings->GetEarPieceVolume(volume);

                    }

                    break;

                }

            aHandle.SendToCallServer(TMS_EFFECT_GLOBAL_VOL_SET, volume);

            aHandle.SendToCallServer(TMS_EFFECT_GLOBAL_GAIN_SET,

                    iEffectSettings->Gain());

            }

        else

            {

            delete callServerThread;

            }

        }

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSServer::StartRoutingNotifierL

//

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

//

void TMSServer::StartRoutingNotifierL()

    {

    TRACE_PRN_FN_ENT;

    if (!iTarHandler)

        {

        iTarHandlerCount = 0;

        iTarHandler = TMSTarEventHandler::NewL((const_cast<TMSServer*> (this)));

        }

    iTarHandlerCount++;

    TRACE_PRN_FN_EXT;

    }

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

// TMSServer::CancelRoutingNotifier

//

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

//

void TMSServer::CancelRoutingNotifier()

    {

        {

        delete iTarHandler;

        iTarHandler = NULL;

        }

    }

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

// TMSServer::StartCenRepHandlerL

//

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

//

void TMSServer::StartCenRepHandlerL()

    {

    TRACE_PRN_FN_ENT;

#ifdef _USE_TELEPHONY_CENREP_

    if (!iAudioCenRepHandler)

        {

        iAudioCenRepHandlerCount = 0;

        iAudioCenRepHandler = TMSCenRepAudioHandler::NewL(

                (const_cast<TMSServer*> (this)));

        }

    iAudioCenRepHandlerCount++;

#endif

    TRACE_PRN_FN_EXT;

    }

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

// TMSServer::CancelCenRepHandler

//

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

//

void TMSServer::CancelCenRepHandler()

    {

    if (--iAudioCenRepHandlerCount <= 0)

        {

        delete iAudioCenRepHandler;

        iAudioCenRepHandler = NULL;

        }

    }

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

// TMSServer::SetOutput

//

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

//

TInt TMSServer::SetOutput(CSession2* /*sid*/, TInt output)

    {

    TRACE_PRN_FN_ENT;

    TInt status = SendMessageToCallServ(TMS_ROUTING_OUTPUT_SET, output);

    if (status == TMS_RESULT_SUCCESS)

        {

        iCurrentRouting = output;

        }

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSServer::GetOutput

//

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

//

TInt TMSServer::GetOutput(const RMessage2& aMessage)

    {

    TRACE_PRN_FN_ENT;

    TUint output;

    TInt i = 0;

    TInt status(TMS_RESULT_SUCCESS);

    while (i < iTMSCallServList.Count())

        {

        TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];

        if (callThread)

            {

            status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(

                    TMS_ROUTING_OUTPUT_GET, output);

            if (status != TMS_RESULT_SUCCESS)

                {

                break;

                }

            }

        i++;

        }

    TPckgBuf<TInt> p(output);

    aMessage.Write(0, p);

    aMessage.Complete(TMS_RESULT_SUCCESS);

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSServer::GetPreviousOutput

//

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

//

TInt TMSServer::GetPreviousOutput(const RMessage2& aMessage)

    {

    TRACE_PRN_FN_ENT;

    TUint output;

    TInt i = 0;

    TInt status(TMS_RESULT_SUCCESS);

    while (i < iTMSCallServList.Count())

        {

        TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];

        if (callThread)

            {

            status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(

                    TMS_ROUTING_PREVIOUSOUTPUT_GET, output);

            if (status != TMS_RESULT_SUCCESS)

                {

                break;

                }

            }

        i++;

        }

    TPckgBuf<TInt> p(output);

    aMessage.Write(0, p);

    aMessage.Complete(TMS_RESULT_SUCCESS);

    TRACE_PRN_FN_EXT;

    return status;

    }

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

// TMSServer::GetAvailableOutputs

//

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

//

TInt TMSServer::GetAvailableOutputs(const RMessage2& aMessage)

    {

    TRAPD(status, GetAvailableOutputsL(aMessage));

    return status;

    }

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

// TMSServer::GetAvailableOutputsL

//

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

//

void TMSServer::GetAvailableOutputsL(const RMessage2& aMessage)

    {

    TRACE_PRN_FN_ENT;

    TInt status = TMS_RESULT_SUCCESS;

    OutputVector outputs;

    HBufC8* buf = HBufC8::NewLC(KOutputsArraySize * sizeof(TUint32));

    TPtr8 ptr = buf->Des();

    TPckgBuf<TInt> countpkg;

    TIpcArgs args;

    args.Set(0, &countpkg);

    args.Set(1, &ptr);

    TInt i = 0;

    while (i < iTMSCallServList.Count())

        {

        TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];

        if (callThread)

            {

            status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(

                    TMS_ROUTING_AVAILABLE_OUTPUT_GET, args);

            if (status != TMS_RESULT_SUCCESS)

                {

                break;

                }

            }

        i++;

        }

    aMessage.WriteL(0, countpkg);