/*

 * 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 FILES

#include <AudioPreference.h>

#include <MProEngTones.h>

#include <MProEngToneSettings.h>

#include <ProEngFactory.h>

#include "tmsshared.h"

#include "tmsutility.h"

#include "tmsrtplayerobsrv.h"

#include "tmsrtcontainer.h"

#include "tmsrtplayer.h"

using namespace TMS;

// CONSTANTS

const TInt KTMSMaxRingingWaiting = 3000000;

const TInt KTMSTtsAscendingStep = 3000000;

const TInt KRTDefaultVolume = 2;

//const TInt KTtsVolumeBoost = 9;

const TInt KTtsVolumeMin = 2;

const TInt KTtsVolumeAscendingRepeat = 4;

const TInt KPlayerVolumeAscendingRepeat = 3;

const TInt KTtsVolumeAscendingDecrease = 2;

// Delays between periods of Text-To-Speech playback

// {3000000, 4000000} means the following order of playing:

// 3 secs tone, then TTS, then 4 secs of tone, then TTS, then tone forever.

const TInt KTMSTtsDelays[] = {3000000, 4000000};

// Number of elements in KTMSTtsDelays array.

const TInt KTMSTtsDelaysCount = sizeof(KTMSTtsDelays) / sizeof (TInt);

const TInt Kkilo = 1024;

_LIT(KTMSTtsHeader, "(tts)");

#ifdef __WINS__

//_LIT(KTMSDefaultSoundFile, "z:\\data\\sounds\\digital\\Nokia_tune.aac");

_LIT(KTMSDefaultSoundFile, "Z:\\Data\\Sounds\\Digital\\Nokia tune.aac");

//_LIT(KTMSDefaultSoundFile, "c:\\data\\sounds\\digital\\test_8khz.wav");

_LIT(KTMSNoSoundSequence,  "z:\\data\\sounds\\digital\\clock.aac");

//_LIT(KTMSNoSoundSequence, "c:\\data\\sounds\\digital\\test_8khz.wav");

_LIT(KTMSBeepSequence,     "z:\\data\\sounds\\digital\\clock.aac");

//_LIT(KTMSBeepSequence, "c:\\data\\sounds\\digital\\test_8khz.wav");

_LIT(KTMSUnsecureVoIPCall, "z:\\data\\sounds\\digital\\alarm.aac");

//_LIT(KTMSUnsecureVoIPCall, "c:\\data\\sounds\\digital\\test_8khz.wav");

#else

// DO NOT change these sequences!

_LIT(KTMSDefaultSoundFile, "\\System\\Sounds\\Simple\\Nokia tune.wav");

_LIT8(KTMSBeepSequence, "\x00\x11\x0A\x0A\x08\x73\x0A\x40\x28\x0A\xF7\x05\

\xFC\x40\x64\x0A\x08\x40\x32\x0A\xF7\x06\x0B");

_LIT8(KTMSNoSoundSequence, "\x00\x11\x0A\x05\xFC\x0A\x08\x40\x32\x0A\xF7\

\x40\x64\x06\x0B");

_LIT8(KTMSUnsecureVoIPCall, "\x00\x11\x0B\x67\x04\x40\x04\x67\x04\x40\x04\

\x6C\x04\x40\x04\x6D\x04\x0B");

#endif // __WINS__

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

// TMSRingTonePlayer::NewL

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

//

TMSRingTonePlayer* TMSRingTonePlayer::NewL(TMSRtPlayerObsrv& aObserver)

    {

    TMSRingTonePlayer* self = new (ELeave) TMSRingTonePlayer(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// TMSRingTonePlayer::TMSRingTonePlayer

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

//

TMSRingTonePlayer::TMSRingTonePlayer(TMSRtPlayerObsrv& aObserver) :

    iRtObserver(aObserver)

    {

    }

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

// TMSRingTonePlayer::ConstructL

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

//

void TMSRingTonePlayer::ConstructL()

    {

    TRACE_PRN_FN_ENT;

    for (TInt i = EPlayerFirst; i <= EPlayerLast; i++)

        {

        User::LeaveIfError(iAsyncDeletePlayers.Append(NULL));

        }

    // Construct timer.

    iTimer = TMSTimer::NewL();

    iTtsDelayTimer = TMSTimer::NewL();

    iAsyncReqAO = TMSAsyncReqAO::NewL(this);

    // TODO:

    // Checks if DRM extend security is needed

    // Check video player configuration.

    iEngine =  ProEngFactory::NewEngineL();

    InitRtParamsL(EPlayerBackup);

    //CreateDefaultRingToneL();

    CreateBkpRtPlayerL();

    //GetMaxToneFileSizeL(iToneFileSizeLimitKB);

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::~TMSRingTonePlayer

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

//

TMSRingTonePlayer::~TMSRingTonePlayer()

    {

    TRACE_PRN_FN_ENT;

    iAsyncDeletePlayers.ResetAndDestroy();

    iAsyncDeletePlayers.Close();

    if (iProfile)

        {

        iProfile->Release();

        }

    if (iEngine)

        {

        iEngine->Release();

        }

    RemovePlayers();

    delete iBackupPlayer;

    delete iAsyncReqAO;

    delete iTimer;

    delete iTtsDelayTimer;

    delete iRtContainer;

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::InitRtParamsL

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

//

void TMSRingTonePlayer::InitRtParamsL(TRtPlayerType aPlayerType)

    {

    TRACE_PRN_FN_ENT;

    iRtParam.iType = aPlayerType;

    iRtParam.iPriority = KAudioPriorityPhoneCall;

    iRtParam.iPreference = KAudioPrefIncomingCall;

    iRtParam.iRingingType = EProfileRingingTypeRinging;

    iRtParam.iVolume = KRTDefaultVolume;

    iRtParam.iTextToSay.Set(KNullDesC());

    if (aPlayerType == EPlayerUnsecureVoIP)

        {

        iRtParam.iPriority = KAudioPrioritySpecialInformationTone;

        iRtParam.iPreference = KAudioPrefSpecialInformation;

        }

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::CreateDefaultPlayerL

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

//

void TMSRingTonePlayer::CreateDefaultRingToneL()

    {

    TRACE_PRN_FN_ENT;

    InitRtParamsL(EPlayerDefault);

    LoadProfileRingToneL();

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::LoadActiveProfileSettingsL

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

//

void TMSRingTonePlayer::LoadActiveProfileSettingsL()

    {

    if (!iEngine)

        {

        iEngine =  ProEngFactory::NewEngineL();

        }

    if (iProfile)

        {

        iProfile->Release();

        iProfile = NULL;

        }

    __ASSERT_DEBUG(iEngine, PANIC(TMS_RESULT_UNINITIALIZED_OBJECT));

    iProfile = iEngine->ActiveProfileL();

    MProEngToneSettings& settings = iProfile->ToneSettings();

    iRtParam.iVolume = settings.RingingVolume();

    iRtParam.iRingingType = settings.RingingType();

    iRtParam.iCallerText = settings.TextToSpeech();

    }

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

// TMSRingTonePlayer::LoadProfileRingToneL

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

//

void TMSRingTonePlayer::LoadProfileRingToneL()

    {

    TRACE_PRN_FN_ENT;

    LoadActiveProfileSettingsL();

    __ASSERT_DEBUG(iProfile, PANIC(TMS_RESULT_UNINITIALIZED_OBJECT));

    MProEngTones& tones = iProfile->ProfileTones();

    // Get alternate line RT: tones.RingingTone2()

    // Get default video RT: tones.VideoCallRingingTone()

    if (!iRtContainer)

        {

        iRtContainer = TMSRtContainer::NewL(tones.RingingTone1());

        }

    else

        {

        if (tones.RingingTone1().CompareF(iRtContainer->FileName()) != KErrNone)

            {

            // Profile changed - update RT

            iRtContainer->SetFileName(tones.RingingTone1());

            iRtContainer->RefreshMime();

            }

        }

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::CreateBkpRtPlayerL

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

//

void TMSRingTonePlayer::CreateBkpRtPlayerL()

    {

    TRACE_PRN_FN_ENT;

    delete iBackupPlayer;

    iBackupPlayer = NULL;

    TFileName file(KTMSDefaultSoundFile);

    iBackupPlayer = TMSRtAudioHdlr::NewL(file, KAudioPriorityPhoneCall,

            KAudioPrefIncomingCall, *this, EPlayerBackup);

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::CreateDefaultRtPlayerL

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

//

void TMSRingTonePlayer::CreateDefaultRtPlayerL()

    {

    TRACE_PRN_FN_ENT;

    // Fresh start for the default tone.

    CreateDefaultRingToneL();

    delete iDefaultPlayer;

    iDefaultPlayer = NULL;

    iDefaultPlayer = TMSRtAudioHdlr::NewL(*iRtContainer,

            KAudioPriorityPhoneCall, KAudioPrefIncomingCall, *this,

            EPlayerDefault, EFalse);

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::CreateAudioPlayerL

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

//

void TMSRingTonePlayer::CreateAudioPlayerL()

    {

    TRACE_PRN_FN_ENT;

    delete iAudioPlayer;

    iAudioPlayer = NULL;

    iAudioPlayer = TMSRtAudioHdlr::NewL(*iRtContainer, iRtParam.iPriority,

            iRtParam.iPreference, *this, iRtParam.iType,

            iRtParam.iType == EPlayerDefault ? EFalse : iExtSecNeeded);

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::CreateRingTonePlayerL

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

//

void TMSRingTonePlayer::CreateRingTonePlayerL(const TRtPlayerType aPlayer,

        const TDesC& aFile)

    {

    TRACE_PRN_FN_ENT;

    TInt len = aFile.Length();

    if (!len || aPlayer == EPlayerDefault)

        {

        CreateDefaultRtPlayerL();

        }

    else

        {

        if (!iRtContainer)

            {

            CreateDefaultRingToneL();

            }

        if (len && iRtContainer)

            {

            iRtContainer->SetFileName(aFile);

            iRtContainer->RefreshMime();

            iRtParam.iType = aPlayer;

            }

        CreateAudioPlayerL();

        }

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::CreateSequencePlayerL

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

//

void TMSRingTonePlayer::CreateSequencePlayerL(const TRtPlayerType aPlayer)

    {

    TRACE_PRN_FN_ENT;

    switch (aPlayer)

        {

        case EPlayerBeepOnce:

            CreateBeepOncePlayerL();

            break;

        case EPlayerSilent:

            CreateSilentPlayerL();

            break;

        case EPlayerUnsecureVoIP:

            CreateUnsecureVoipPlayerL();

            break;

        default:

            break;

        }

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::CreateBeepOncePlayerL

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

//

void TMSRingTonePlayer::CreateBeepOncePlayerL()

    {

    TRACE_PRN_FN_ENT;

    delete iBeepOncePlayer;

    iBeepOncePlayer = NULL;

#ifdef __WINS__

    TParse* fp = new (ELeave) TParse();

    fp->Set(KTMSBeepSequence, NULL, NULL);

    TFileName fileName(fp->FullName());

    delete fp;

    iBeepOncePlayer = TMSRtAudioHdlr::NewL(fileName, iRtParam.iPriority,

            iRtParam.iPreference, *this, EPlayerBeepOnce);

#else

    iBeepOncePlayer = TMSRtAudioHdlr::NewSeqL(KTMSBeepSequence(),

            iRtParam.iPriority, iRtParam.iPreference, *this, EPlayerBeepOnce);

#endif // __WINS__

    iRtParam.iType = EPlayerBeepOnce;

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::CreateSilentPlayerL

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

//

void TMSRingTonePlayer::CreateSilentPlayerL()

    {

    TRACE_PRN_FN_ENT;

    iRtParam.iVolume = 0;

    delete iSilentPlayer;

    iSilentPlayer = NULL;

#ifdef __WINS__

    TParse* fp = new (ELeave) TParse();

    fp->Set(KTMSNoSoundSequence, NULL, NULL);

    TFileName fileName(fp->FullName());

    delete fp;

    iSilentPlayer = TMSRtAudioHdlr::NewL(fileName, iRtParam.iPriority,

            iRtParam.iPreference, *this, EPlayerSilent);

#else

    iSilentPlayer = TMSRtAudioHdlr::NewSeqL(KTMSNoSoundSequence(),

            iRtParam.iPriority, iRtParam.iPreference, *this, EPlayerSilent);

#endif // __WINS__

    iRtParam.iType = EPlayerSilent;

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::CreateUnsecureVoipPlayerL

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

//

void TMSRingTonePlayer::CreateUnsecureVoipPlayerL()

    {

    TRACE_PRN_FN_ENT;

    delete iUnsecureVoIPTonePlayer;

    iUnsecureVoIPTonePlayer = NULL;

#ifdef __WINS__

    TParse* fp = new (ELeave) TParse();

    fp->Set(KTMSUnsecureVoIPCall, NULL, NULL);

    TFileName fileName(fp->FullName());

    delete fp;

    iUnsecureVoIPTonePlayer = TMSRtAudioHdlr::NewL(fileName,

            iRtParam.iPriority, iRtParam.iPreference, *this,

            EPlayerUnsecureVoIP);

#else

    iUnsecureVoIPTonePlayer = TMSRtAudioHdlr::NewSeqL(KTMSUnsecureVoIPCall(),

            iRtParam.iPriority, iRtParam.iPreference, *this,

            EPlayerUnsecureVoIP);

#endif // __WINS__

    iRtParam.iType = EPlayerUnsecureVoIP;

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::CreateCustomSequencePlayerL

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

//

void TMSRingTonePlayer::CreateCustomSequencePlayerL(const TDesC8&

#ifdef __WINS__

        /*aSequence*/)

#else

        aSequence)

#endif

    {

    TRACE_PRN_FN_ENT;

    delete iSequencePlayer;

    iSequencePlayer = NULL;

#ifdef __WINS__

    TParse* fp = new (ELeave) TParse();

    fp->Set(KTMSBeepSequence, NULL, NULL);

    TFileName fileName(fp->FullName());

    delete fp;

    iSequencePlayer = TMSRtAudioHdlr::NewL(fileName, iRtParam.iPriority,

            iRtParam.iPreference, *this, EPlayerSequence);

#else

    iSequencePlayer = TMSRtAudioHdlr::NewSeqL(aSequence, iRtParam.iPriority,

            iRtParam.iPreference, *this, EPlayerSequence);

#endif // __WINS__

    iRtParam.iType = EPlayerSequence;

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::CreateTTSPlayerL

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

//

void TMSRingTonePlayer::CreateTTSPlayerL(const TDesC& aTextToSay)

    {

    TRACE_PRN_FN_ENT;

    RemoveTTSPlayer();

    TPtrC ttsHeader(KTMSTtsHeader);

    HBufC* buf = HBufC::New(aTextToSay.Length() + ttsHeader.Length());

    if (buf)

        {

        TPtr ptr = buf->Des();

        ptr.Append(ttsHeader);

        ptr.Append(aTextToSay);

        TRACE_PRN_N1(_L("TMS->CreateTTSPlayerL: Text:[%S]"), &ptr);

        TRAPD(err, iTtsPlayer = TMSRtAudioHdlr::NewTtsL(*buf,

                KAudioPriorityTextToSpeechCall, KAudioPrefTextToSpeechCall,

                *this, EPlayerTts));

        if (err == TMS_RESULT_SUCCESS)

            {

            iTtsToneToBePlayed = ETrue;

            iRtParam.iTextToSay.Set(aTextToSay);

            }

        }

    delete buf;

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::RemoveTTSPlayer

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

//

void TMSRingTonePlayer::RemoveTTSPlayer()

    {

    TRACE_PRN_FN_ENT;

    delete iTtsPlayer;

    iTtsPlayer = NULL;

    iTtsToneToBePlayed = EFalse;

    iRtParam.iTextToSay.Set(KNullDesC());

    TRACE_PRN_FN_EXT;

    }

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

// TMSRingTonePlayer::PlayRingToneL

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

//

void TMSRingTonePlayer::PlayRingToneL()

    {