/*

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

*

*/

#include <cntdef.h>

#include <f32file.h>

#include <featmgr.h>

#include <utility.h>

#include <AudioPreference.h>

#include <ProfileEngineDomainCRKeys.h>

// <-- QT PHONE START -->

//#include <musicplayerdomaincrkeys.h>

// <-- QT PHONE END -->

#include <DRMHelperServerInternalCRKeys.h>

#include <DRMHelper.h>

#include <activeidle2domainpskeys.h>

#include <data_caging_path_literals.hrh>

#include "cphoneringingtoneplayer.h"

#include "cphoneaudioplayer.h"

#include "cphoneringingtone.h"

#include "phonelogger.h"

#include "cphonecenrepproxy.h"

#include "cphonepubsubproxy.h"

#include "cphonetimer.h"

#include "phoneconstants.h"

#include "phoneui.pan"

// CONSTANTS

// <-- QT PHONE START -->

// Minimum acceptable length of parsed DRM message.

//const TInt KPhoneMinDRMTextLength = 3;

// <-- QT PHONE END -->

CPhoneRingingtonePlayer::CPhoneRingingtonePlayer():

CActive( CActive::EPriorityStandard ), iAsyncDeletePlayers( EPlayerCount )

{

    CActiveScheduler::Add( this );

}

CPhoneRingingtonePlayer::~CPhoneRingingtonePlayer()

    {

    iAsyncDeletePlayers.ResetAndDestroy();

    iAsyncDeletePlayers.Close();

    delete iTimer;

    CleanupPlayers();

    Cancel();

    }

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

// 

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

//

void CPhoneRingingtonePlayer::CleanupPlayers()

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::CleanupPlayers()" );

    delete iAudioPlayer;

    iAudioPlayer = NULL;

    delete iDefaultPlayer;

    iDefaultPlayer = NULL;

    delete iBeepOncePlayer;

    iBeepOncePlayer = NULL;

    delete iSilentPlayer;

    iSilentPlayer = NULL;

    delete iBackupPlayer;

    iBackupPlayer = NULL;

    delete iMdaServer;

    iMdaServer = NULL;

    }

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

// 

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

//

CPhoneRingingtonePlayer* CPhoneRingingtonePlayer::NewL()

    {

    CPhoneRingingtonePlayer* self = 

        new ( ELeave ) CPhoneRingingtonePlayer();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

void CPhoneRingingtonePlayer::ConstructL()

    {

    // Construct timer.

    iTimer = CPhoneTimer::NewL();

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

        {

        User::LeaveIfError( 

            iAsyncDeletePlayers.Append( NULL ) );

        }

    // <-- QT PHONE START -->

       // Checks if DRM extend security is needed

    //TInt extSecNeeded = KErrNone;

/*

    TInt err = CPhoneCenRepProxy::Instance()->GetInt(

        KCRUidMusicPlayerFeatures,

        KRequireDRMInPlayback,

        extSecNeeded );

*/

    //disabling the DRM for the TB10.1wk46 release. Lets see if need to put it back and how.

    //iExtSecNeeded = ( ( err == KErrNone ) && extSecNeeded ) ? ETrue : EFalse;

    iExtSecNeeded = EFalse; 

    /*CPhoneCenRepProxy::Instance()->NotifyChangeL(

        KCRUidDRMHelperServer, 

        KDRMHelperServerNotificationPassive,

        this );*/

    // <-- QT PHONE END-->        

    // Construct players.

    if ( !iMdaServer )

        {

        iMdaServer = CMdaServer::NewL();

        }

    // Backup player. 

    ConstructBackupPlayer();

    // <-- QT PHONE START-->

    ConstructDefaultPlayerL();

    // <-- QT PHONE END-->

    }

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

// 

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

//

void CPhoneRingingtonePlayer::PlayProfileBasedTone( CPhoneRingingTone* aAudioVideoRingingTone )

    {

    iAudioVideoRingingTone = aAudioVideoRingingTone;

    // Construct player for line 1.

     if ( !iAudioPlayer )

         {

         iAudioPlayer = ConstructTonePlayer( 

             *iAudioVideoRingingTone, 

             EPlayerAudio );

         if ( !iTimer->IsActive() )

             {

             // Start timer, since the player is constructed.

             iTimer->After( KPhoneMaxRingingWaiting, this );

             }

         }

     // Start playing.

     if ( !iAudioPlayer )

         {

         iTimer->Cancel();

         PlayDefaultTone( aAudioVideoRingingTone->Volume(), 

                          aAudioVideoRingingTone->RingingType() );

         }

     else

         {

         __PHONELOG( 

             EBasic, 

             EPhoneControl, 

             "CPhoneRingingtonePlayer::PlayAudioRingTone - Start playing audio" );

         iVolume = aAudioVideoRingingTone->Volume();

         iRingingType = aAudioVideoRingingTone->RingingType();

         //AddTtsPlaybackIfNeeded( aRingingType );

         iTonePlayingStatus = EAudioTonePlaying;

         iAudioPlayer->Play( 

             ConvertRingingType( aAudioVideoRingingTone->RingingType() ),

             aAudioVideoRingingTone->Volume(),

             aAudioVideoRingingTone->TtsToneToBePlayed());

         }

    }

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

// 

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

//

void CPhoneRingingtonePlayer::PlayBeepOnce( TInt aVolume )

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::BeepOnce()" );

    __PHONELOG1( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::BeepOnce - aVolume(%d)",

        aVolume );

    if ( !iBeepOncePlayer )

        {

        ConstructSequencePlayer( EPlayerBeepOnce );

        }

    if ( iBeepOncePlayer )

        {

        __PHONELOG( 

            EBasic, 

            EPhoneControl, 

            "CPhoneRingingtonePlayer::BeepOnce - Play" );

        iTonePlayingStatus = EBeepOnce;

        iBeepOncePlayer->Play( CPhoneAudioPlayer::ETypeRingingOnce, 

            aVolume, EFalse );        

        }

    }

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

//

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

//

void CPhoneRingingtonePlayer::PlaySilentTone()

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::PlaySilentTone()" );

    if ( !iSilentPlayer )

        {

        ConstructSequencePlayer( EPlayerSilent );

        }

    if ( iSilentPlayer )

        {

        __PHONELOG( 

            EBasic, 

            EPhoneControl, 

            "CPhoneRingingtonePlayer::PlaySilentTone - play" );

        iTonePlayingStatus = ESilentTonePlaying;

        iSilentPlayer->Play( CPhoneAudioPlayer::ETypeRinging, 0, EFalse );        

        }

    }

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

// 

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

//

void CPhoneRingingtonePlayer::PlayDefaultTone( 

    TInt aVolume, 

    TProfileRingingType aRingingType )

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::PlayDefaultTone()" );

    if( aRingingType == EProfileRingingTypeSilent ||

        aRingingType == EProfileRingingTypeBeepOnce )

        {

        return;

        }

    if ( !iDefaultRingingTone )

        {

        __PHONELOG( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::PlayDefaultTone - default tone does not exist, play backup..." );

        PlayBackupTone( aVolume, aRingingType );

        return;    

        }

    // Construct player.

    if ( !iDefaultPlayer )

        {

        iDefaultPlayer = ConstructTonePlayer( 

            *iDefaultRingingTone, 

            EPlayerDefault );

        if ( !iTimer->IsActive() )

            {

            iTimer->After( KPhoneMaxRingingWaiting, this );

            }

        }

    // Start playing backup.

    if ( !iDefaultPlayer )

        {

        __PHONELOG( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::PlayDefaultTone - player not constructed, play backup..." );

        iTimer->Cancel();

        PlayBackupTone( aVolume, aRingingType );

        }

    else

        {

        __PHONELOG( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::PlayDefaultTone - play" );

        iVolume = aVolume;

        iRingingType = aRingingType;

        iTonePlayingStatus = EDefaultTonePlaying;

        iDefaultPlayer->Play( 

            ConvertRingingType( aRingingType ), aVolume,

            iAudioVideoRingingTone->TtsToneToBePlayed());

        }

    }

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

// CPhoneRingingtonePlayer::PlayBackupTone

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

//

void CPhoneRingingtonePlayer::PlayBackupTone( 

    TInt aVolume, 

    TProfileRingingType aRingingType )

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::PlayBackupTone()" );

    __ASSERT_DEBUG( iBackupPlayer, Panic( EPhoneViewGeneralError ) );

    if ( !iBackupPlayer )

        {

        ConstructBackupPlayer();

        }

    if ( iBackupPlayer )

        {

        __PHONELOG( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::PlayBackupTone - play" );

        iTonePlayingStatus = EBackupTonePlaying;

/*

        // playing text-to-speech, if necessary

        iTtsToneToBePlayed = EFalse;

        iTTsTimeOutCounter = 0;

        iTtsDelayTimer->Cancel();

        if ( iTtsPlayer )

            {

            iTtsPlayer->StopPlaying();

            delete iTtsPlayer;

            iTtsPlayer = NULL;

            }*/

        iBackupPlayer->Play( 

            ConvertRingingType( aRingingType ), aVolume, EFalse );        

        }

    }

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

// 

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

//

void CPhoneRingingtonePlayer::StopPlaying()

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::StopPlaying()" );

    iTimer->Cancel();

    switch( iTonePlayingStatus )

        {

        case EAudioTonePlaying:

            if( iAudioPlayer )

                {

                iAudioPlayer->StopPlaying();

                delete iAudioPlayer;

                iAudioPlayer = NULL;

                }

            break;

        case EDefaultTonePlaying:

            if ( iDefaultPlayer )

                {

                iDefaultPlayer->StopPlaying();

                delete iDefaultPlayer;

                iDefaultPlayer = NULL;

                }

            break;

        case EBeepOnce:

            if( iBeepOncePlayer )

                {

                iBeepOncePlayer->StopPlaying();

                delete iBeepOncePlayer;

                iBeepOncePlayer = NULL;

                }

            break;

        case EBackupTonePlaying:

            if( iBackupPlayer )

                {

                iBackupPlayer->StopPlaying();

                }

            break;

        case ESilentTonePlaying:

            if( iSilentPlayer )

                {

                iSilentPlayer->StopPlaying();

                delete iSilentPlayer;

                iSilentPlayer = NULL;

                }

            break;

        case EVideoTonePlaying: // video ringing tone

        case EPersonalVideoTonePlaying:

        case ESilentVideoTonePlaying:

            if ( iBeepOncePlayer )

                {

                iBeepOncePlayer->StopPlaying();

                delete iBeepOncePlayer;

                iBeepOncePlayer = NULL;                    

                }

            if ( iSilentPlayer )

                {

                iSilentPlayer->StopPlaying();

                delete iSilentPlayer;

                iSilentPlayer = NULL;                    

                }    

            /*if ( iVideoPlayer )

                {

                iVideoPlayer->StopVideoRingTone();

                }*/

            if ( iAudioVideoRingingTone )

                {

                delete iAudioVideoRingingTone;

                iAudioVideoRingingTone = NULL;    

                }

            break;

        case EIdle:

            // Do nothing here.

            return;

        default:

            Panic( EPhoneViewCaseNotHandled );

            break;

        }

    iTonePlayingStatus = EIdle;

    }

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

// 

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

//

CPhoneAudioPlayer* CPhoneRingingtonePlayer::ConstructTonePlayer( 

    const CPhoneRingingTone& aRingingTone,

    TInt aId )

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::ConstructTonePlayer()" );

    return CPhoneAudioPlayer::New(

        aRingingTone, 

        KAudioPriorityPhoneCall, 

        KAudioPrefIncomingCall,

        *this, 

        aId,

        iMdaServer,

        aId == EPlayerDefault ? EFalse : iExtSecNeeded );

    }

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

// 

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

//

TInt CPhoneRingingtonePlayer::ConstructBackupPlayer()

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::ConstructBackupPlayer()" );

    TRAPD( err, ConstructBackupPlayerL() );

    return err;

    }

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

//

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

//

void CPhoneRingingtonePlayer::ConstructBackupPlayerL()

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::ConstructBackupPlayerL()" );

    // Construct Backup player.

    if ( !iBackupPlayer )

        {

        TFileName defaultSoundFile( KDriveZ );

        defaultSoundFile.Append( KPhoneDefaultSoundFile );

        iBackupPlayer = CPhoneAudioPlayer::NewL( 

            defaultSoundFile,

            KAudioPriorityPhoneCall,

            KAudioPrefIncomingCall,

            *this,

            EPlayerBackup,

            iMdaServer 

            );

        }

    }

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

// 

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

//

void CPhoneRingingtonePlayer::ConstructDefaultPlayerL()

    {

    // Construct the default ringing tone

    TBuf<KMaxFileName> defaultTone;

// <-- QT PHONE START-->

    /*TInt err = CPhoneCenRepProxy::Instance()->GetString(            

        KCRUidProfileEngine,

        KProEngDefaultRingingTone,

        defaultTone );*/

    defaultTone = _L("z:\\data\\sounds\\digital\\Nokia tune.aac");        

    TInt err(KErrNone);

// <-- QT PHONE END-->    

    if ( err == KErrNone )

        {

        iDefaultRingingTone = CPhoneRingingTone::NewL( defaultTone );

        }

    }

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

// 

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

//

void CPhoneRingingtonePlayer::ConstructSequencePlayer( TPlayerId aId )

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::ConstructSequencePlayer()" );

    // Construct players.

    TRAPD( err, ConstructSequencePlayerL( aId ) );

    if ( err )

        {

        __PHONELOG1( EBasic, EPhoneControl, 

        "CPhoneRingingtonePlayer::ConstructSequencePlayer - err(%d)", err );    

        }

    }

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

//

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

//

void CPhoneRingingtonePlayer::ConstructSequencePlayerL( TPlayerId aId )

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::ConstructSequencePlayerL()" );

    // Construct beep once player

    if ( aId == EPlayerBeepOnce )

        {