/*

* Copyright (c) 2008-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:  File Player Events Info Note

*

*/

// System Includes

#include <e32base.h>

#include <mdaaudiotoneplayer.h>

#include <AudioPreference.h>

#include <e32property.h>

#include <coreapplicationuisdomainpskeys.h>

// User Includes

#include "evttoneplayer.h"

#include "evtutilsconsts.h"

#include "evttoneutils.h"

#include "evtdebug.h"

// Constants

const TInt KMicroSeconds = 1000000;

// ================ Member funtions for CEvtTonePlayer class ===============

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

// CEvtTonePlayer::CEvtTonePlayer

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

//

CEvtTonePlayer::CEvtTonePlayer( MEvtTonePlayObserver& aObserver ):

									iObserver(aObserver)

	{

	}

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

// CEvtTonePlayer::~CEvtTonePlayer

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

//

CEvtTonePlayer::~CEvtTonePlayer()

	{ 

	Stop();

	delete iProfileHandler;

	delete iCallHandler;

    // Delete the timer

    if( iTimer )

        {

    	StopTimer();

        delete iTimer;

        }

	}

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

// CEvtTonePlayer::NewL

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

//

EXPORT_C CEvtTonePlayer* CEvtTonePlayer::NewL( MEvtTonePlayObserver& aObserver )

    {

	CEvtTonePlayer* self = NewLC( aObserver );

	CleanupStack::Pop( self );

	return self;

    }

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

// CEvtTonePlayer::NewLC

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

//

EXPORT_C CEvtTonePlayer* CEvtTonePlayer::NewLC( MEvtTonePlayObserver& aObserver )

    {

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

	CleanupStack::PushL( self );

	self->ConstructL( );

	return self;

    } 

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

// CEvtTonePlayer::ConstructL

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

//

void CEvtTonePlayer::ConstructL()

    {

    EVTUIDEBUG( "+ CEvtTonePlayer::ConstructL()" );

    iProfileHandler = CEvtProfileHandler::NewL( *this );

    iCallHandler = CEvtCallHandler::NewL( *this );

    EVTUIDEBUG( "- CEvtTonePlayer::ConstructL()" );

    }

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

// CEvtTonePlayer::PlayFileL

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

//

EXPORT_C void CEvtTonePlayer::PlayFileL( const TFileName& aAudioFileName, 

						TBool aLoop, TInt aTimeInterval )

	{

    EVTUIDEBUG( "+ CEvtTonePlayer::PlayFileL()" );

	// Stop if some tone is already playing.

	Stop();

	// Stop the Timer, if it is On

    	StopTimer();

	// Play a beep sound if there is an active/incoming call.

	if( iCallHandler->IsCallActive() || iCallHandler->IsCallIncoming() )

		{

		iPlayerState = ENotReady;

		iTonePlayer = CMdaAudioToneUtility::NewL( *this );

		iTonePlayer->PrepareToPlayDesSequence( KPhoneBeepSequence() ); 

		return;

		}

	TBool exist(ETrue);

	TBool playable(ETrue);

	// Check if Tone exists and is playable. 

	TRAPD(existErr, exist = EvtToneUtils::IsExistL( aAudioFileName ) );

	TRAPD(playableErr, playable = EvtToneUtils::IsExistL( aAudioFileName ) );

	// Play tone if,

	// 1. File exists and is playable

	// 2. profile is NOT "Silent"

	if( !(iProfileHandler->IsSilentRingingType() || aAudioFileName.Length() == 0 || 

		existErr || playableErr || !exist || !playable ) )

		{

		// If the Mime type of ring tone is "KRngMimeType", then we need to play that file using

		// CMdaAudioToneUtility else we need to use CDrmPlayerUtility

		if ( EvtToneUtils::IsRNGTypeL( aAudioFileName ) )

			{

			// Mime type of tone is "KRngMimeType"

			iPlayerState = ENotReady;

			iTonePlayer = CMdaAudioToneUtility::NewL( *this );

			// Set the repeat flag based on Audio loop argument.

			if( aLoop )

				iAudioPlayer->SetRepeats( KMdaAudioToneRepeatForever, TTimeIntervalMicroSeconds(KMicroSeconds) );

			else

				iAudioPlayer->SetRepeats( 0 ,TTimeIntervalMicroSeconds(KMicroSeconds) );

			iTonePlayer->PrepareToPlayFileSequence( aAudioFileName );

			// Start the Timer if we have a Time Interval argument set.

			if( aTimeInterval )

			    {

			    StartTimerL( aTimeInterval );

			    }

			}

		else

			{

			// Mime type of tone is NOT "KRngMimeType"

			iPlayerState = ENotReady;

	        iAudioPlayer = CDrmPlayerUtility::NewFilePlayerL(

	            aAudioFileName,

	            *this, 

	            KAudioPriorityAlarm, 

	            static_cast<TMdaPriorityPreference>( KAudioPrefCalendarAlarm ) );

			// Set the repeat flag based on Audio loop argument.

			if( aLoop )

				iAudioPlayer->SetRepeats( KMdaAudioToneRepeatForever, TTimeIntervalMicroSeconds(KMicroSeconds) );

			else

				iAudioPlayer->SetRepeats( 0 ,TTimeIntervalMicroSeconds(KMicroSeconds) );

			// Start the Timer if we have a Time Interval argument set.

            if( aTimeInterval )

                {

			    StartTimerL( aTimeInterval );

                }

			}

		}

	else 

		{

		// Since we cannot play the Tone file, Play the Vibra tone if the Vibration settings is ON.

		if( iProfileHandler->IsVibra() )

			{

			iPlayerState = ENotReady;

			iTonePlayer = CMdaAudioToneUtility::NewL( *this );

			// Set to repeat forever.

			iTonePlayer->SetRepeats( KMdaAudioToneRepeatForever, TTimeIntervalMicroSeconds(KMicroSeconds) );

			// No Sound sequence which is the file to play Vibration ONLY.

			iTonePlayer->PrepareToPlayDesSequence( KPhoneNoSoundSequence() ); 

			// Start the Timer if we have a Time Interval argument set.

            if( aTimeInterval )

                {

			    StartTimerL( aTimeInterval );

                }

			}

		// Notify the Tone Player Observer

		iObserver.TonePlayCompleteL( EFalse );

		}

    EVTUIDEBUG( "- CEvtTonePlayer::PlayFileL()" );

	}

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

// CEvtTonePlayer::StopPlayingL

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

//

EXPORT_C void CEvtTonePlayer::StopPlayingL( TBool aTimeout )

	{

    EVTUIDEBUG( "+ CEvtTonePlayer::StopPlayingL()" );

	// Stop the currently playing tone file.

	Stop();

	// If the tone is stopped NOT because of the time out, then we continue to

	// play vibration tone till the time out.

	if( !aTimeout && iProfileHandler->IsVibra() )

		{

		iPlayerState = ENotReady;

		iTonePlayer = CMdaAudioToneUtility::NewL( *this );

		iTonePlayer->SetRepeats( KMdaAudioToneRepeatForever, TTimeIntervalMicroSeconds(KMicroSeconds) );

		iTonePlayer->PrepareToPlayDesSequence( KPhoneNoSoundSequence() );

		}

	else

		{

    		StopTimer();

		}

	// Notify the Tone Player Observer

	iObserver.TonePlayCompleteL( aTimeout );

    EVTUIDEBUG( "- CEvtTonePlayer::StopPlayingL()" );

	}

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

// CEvtTonePlayer::MdapcInitComplete

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

//

void CEvtTonePlayer::MdapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& /*aDuration*/)

	{

    EVTUIDEBUG( "+ CEvtTonePlayer::MdapcInitComplete()" );

	if( KErrNone == aError )

		{

		iPlayerState = EReady;

		if( iAudioPlayer )

			{

			iPlayerState = EPlaying;

			iAudioPlayer->SetVolume( PlayerVolume(iAudioPlayer->MaxVolume(), iProfileHandler->Volume()) );

			iAudioPlayer->SetPriority( KAudioPriorityAlarm, static_cast<TMdaPriorityPreference>( KAudioPrefCalendarAlarm ) );

			iAudioPlayer->Play();

			}

		}

	else

		{

		iPlayerState = ENotReady;

		}

    EVTUIDEBUG( "- CEvtTonePlayer::MdapcInitComplete()" );

	}

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

// CEvtTonePlayer::MdapcPlayComplete

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

//

void CEvtTonePlayer::MdapcPlayComplete(TInt /*aError*/)

	{

    EVTUIDEBUG( "+ CEvtTonePlayer::MdapcPlayComplete()" );

	// Notify the Tone Player Observer

	TRAPD( err, iObserver.TonePlayCompleteL( EFalse ) );

	if(!err)

		EVTUIDEBUG1( "TonePlayCompleteL Error - %d", err );

    EVTUIDEBUG( "- CEvtTonePlayer::MdapcPlayComplete()" );

	}

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

// CEvtTonePlayer::MatoPrepareComplete

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

//

void CEvtTonePlayer::MatoPrepareComplete(TInt aError)

	{

    EVTUIDEBUG( "+ CEvtTonePlayer::MatoPrepareComplete()" );

	if( KErrNone == aError )

		{

		iPlayerState = EReady;

		if( iTonePlayer )

			{

			iPlayerState = EPlaying;

			iTonePlayer->SetVolume( PlayerVolume(iTonePlayer->MaxVolume(), iProfileHandler->Volume()) );

	    	iTonePlayer->SetPriority( KAudioPriorityAlarm, static_cast<TMdaPriorityPreference>( KAudioPrefCalendarAlarm ) );

			iTonePlayer->Play();

			}

		}

	else

		{

		iPlayerState = ENotReady;

		}

    EVTUIDEBUG( "- CEvtTonePlayer::MatoPrepareComplete()" );

	}

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

// CEvtTonePlayer::MatoPlayComplete

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

//

void CEvtTonePlayer::MatoPlayComplete(TInt /*aError*/)

	{

    EVTUIDEBUG( "+ CEvtTonePlayer::MdapcPlayComplete()" );

	// Notify the Tone Player Observer

	TRAPD( err, iObserver.TonePlayCompleteL( EFalse ) );

	if(!err)

		EVTUIDEBUG1( "TonePlayCompleteL Error - %d", err );

    EVTUIDEBUG( "- CEvtTonePlayer::MdapcPlayComplete()" );

	}

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

// CEvtTonePlayer::Stop

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

//

void CEvtTonePlayer::Stop()

	{

    EVTUIDEBUG( "+ CEvtTonePlayer::Stop()" );

	if( iTonePlayer )

    	{

        if( iTonePlayer->State() == EMdaAudioToneUtilityPlaying )

	        {

	            iTonePlayer->CancelPlay();

	        }

        else

	        {

	            iTonePlayer->CancelPrepare();

	        }

    	}

    if( iAudioPlayer )

    	{

        iAudioPlayer->Stop();

        iAudioPlayer->Close();

    	}

    if( iTonePlayer )

    	{

		delete iTonePlayer;

		iTonePlayer = NULL;

    	}

    if( iAudioPlayer )

    	{

		delete iAudioPlayer;

		iAudioPlayer = NULL;

    	}

	iPlayerState = EStop;

    EVTUIDEBUG( "- CEvtTonePlayer::Stop()" );

	}

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

// CEvtTonePlayer::HandleIncomingCallL()

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

//

void CEvtTonePlayer::HandleIncomingCallL()

    {

    EVTUIDEBUG( "= CEvtTonePlayer::HandleIncomingCallL()" );

    StopTimer();

	Stop();

	// Notify the Tone Player Observer

	iObserver.TonePlayCompleteL( EFalse );

    }

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

// CEvtTonePlayer::HandleProfileSettingsChange()

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

//

void CEvtTonePlayer::HandleProfileSettingsChange()

    {

    // Nothing to do now.

    }

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

// CEvtTonePlayer::StartTimerL

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

//

void CEvtTonePlayer::StartTimerL( TInt aTimeInterval )

	{

        if( !iTimer )

             {

             iTimer = CPeriodic::NewL( 0 ); // neutral priority

             }

        iTimer->Start( TTimeIntervalMicroSeconds32( aTimeInterval * KMicroSeconds ),

                       TTimeIntervalMicroSeconds32( aTimeInterval * KMicroSeconds ),

                       TCallBack(TickL, this));

	}

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

// CEvtTonePlayer::StopTimer

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

//

void CEvtTonePlayer::StopTimer( )

	{

    	if( iTimer )

        	{

        	iTimer->Cancel();

        	}

	}

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

// CEvtTonePlayer::TickL()

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

//

TInt CEvtTonePlayer::TickL(TAny* aObject)

    {

		((CEvtTonePlayer*)aObject)->StopPlayingL( ETrue );

    return KErrNone;

    }

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

// Set volume between zero and player's maximum volume

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

//

TInt CEvtTonePlayer::PlayerVolume(TInt aPlayerMaxVol, TInt aVol)

{    

    const TInt KMaxProfileVolume( 10 );

    TInt vol( 0 ); // leave as 0 if using off tone

    // calculate value between 0 and aPlayerMaxVolume

    vol = Max( 0, Min( aPlayerMaxVol / KMaxProfileVolume * aVol, aPlayerMaxVol ) ); 

    return vol;

}