/*
* Copyright (c) 2005 - 2006 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:  Class that handles playback of tones in VoiceRec application
*
*/


// INCLUDE FILES

#include <avkon.hrh>
#include <aknappui.h>
#include <AudioPreference.h>
#include <aknsoundsystem.h>
#include <aknSoundinfo.h>

#include "CVRTonePlayer.h"


// ============================ MEMBER FUNCTIONS =============================

// ---------------------------------------------------------------------------
// CVRTonePlayer::CVRTonePlayer
// 
// ---------------------------------------------------------------------------
//
CVRTonePlayer::CVRTonePlayer()
	: iState( EVRToneIdle )
    {
    }


// ---------------------------------------------------------------------------
// CVRTonePlayer::ConstructL
// 
// ---------------------------------------------------------------------------
//
void CVRTonePlayer::ConstructL()
    {
    iPlayer = CMdaAudioToneUtility::NewL( *this );
    
    iSoundSystem = ( static_cast< CAknAppUi* >(
						CEikonEnv::Static()->EikAppUi() )->KeySounds() );
    }


// ---------------------------------------------------------------------------
// CVRTonePlayer::NewL
// 
// ---------------------------------------------------------------------------
//
CVRTonePlayer* CVRTonePlayer::NewL()
    {
    CVRTonePlayer* self = new ( ELeave ) CVRTonePlayer;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CVRTonePlayer::~CVRTonePlayer
// 
// ---------------------------------------------------------------------------
//
CVRTonePlayer::~CVRTonePlayer()
    {
    if ( iPlayer )
        {
        switch ( iPlayer->State() )
            {
            case EMdaAudioToneUtilityNotReady:
                {
                iPlayer->CancelPrepare();
                break;
                }
            case EMdaAudioToneUtilityPlaying:
                {
                iPlayer->CancelPlay();
                break;
                }           
            }
        }
    delete iPlayer;
    
    // if tone play is not finished before, finish waitloop
    if ( iShedulerWait.IsStarted() )
		{
		iShedulerWait.AsyncStop();
		}		
    }


// ---------------------------------------------------------------------------
// CVRTonePlayer::PrepareToneL
// Starts preparing the specified tone, preparing completes with call-back to
// MatoPrepareComplete
// ---------------------------------------------------------------------------
//
void CVRTonePlayer::PrepareToneL( TInt aToneId )
    {
	if ( iState != EVRToneIdle )
		{
		iQueuedTone = aToneId;
		return;
		}

	// Retrieve the tone
	CAknSoundInfo* info = CAknSoundInfo::NewL();
	CleanupStack::PushL( info );
	User::LeaveIfError( iSoundSystem->RequestSoundInfoL(
					                  aToneId, *info ) );
    
    iPreparedTone = aToneId;
    iState = EVRTonePreparing;
    
    iPlayer->PrepareToPlayDesSequence( *info->iSequence );
    CleanupStack::PopAndDestroy( info );
    }


// ---------------------------------------------------------------------------
// CVRTonePlayer::PrepareTone
// Non-leaving version of PrepareToneL
// ---------------------------------------------------------------------------
//
void CVRTonePlayer::PrepareTone( TInt aToneId )
    {
    TRAP_IGNORE( PrepareToneL( aToneId ) );
    }


// ---------------------------------------------------------------------------
// CVRTonePlayer::PlayTone
// Starts playback of specified tone. Completes with call-back to
// MatoPlayComplete
// ---------------------------------------------------------------------------
//
void CVRTonePlayer::PlayTone( TInt aToneId )
    {
    if ( iState != EVRToneIdle || iPreparedTone != aToneId || 
        iPlayer->State() == EMdaAudioToneUtilityPlaying )
    	{
    	// Preparing an unprepared tone synchronously is not supported,
    	// tone playback is skipped
    	return;
    	}
    
    // Preferences need to be set according to tone
    switch( aToneId )
    	{
    	case EAvkonSIDVoiceRecordingStartTone:
    		{
    		iPlayer->SetPriority( KAudioPriorityRecording,
    			TMdaPriorityPreference( KAudioPrefVoiceRecStart ) );
			break;	    		
    		}    
    	case EAvkonSIDVoiceRecordingStopTone:
    		{
    		iPlayer->SetPriority( KAudioPriorityRecording,
    			TMdaPriorityPreference( KAudioPrefVoiceRecStop ) );    		
			break;    	    		    			
    		}
    	default:
    		{
    		break;
    		}
		}
 
    iState = EVRTonePlaying;
    
    iPlayer->Play();
    
    // Do not continue until start tone play is finished
    if( aToneId == EAvkonSIDVoiceRecordingStartTone )
	    {
#ifdef _DEBUG
	    RDebug::Print( _L("VoiceRecorder: Waiting for Start tone play complete") );
#endif	
	    iShedulerWait.Start();
	    }
    }


// ---------------------------------------------------------------------------
// CVRTonePlayer::MatoPrepareComplete
// 
// ---------------------------------------------------------------------------
//
void CVRTonePlayer::MatoPrepareComplete(TInt aError)
	{
	if ( aError )
		{
		iPreparedTone = 0;
		}

	iState = EVRToneIdle;

	// Prepare the next tone in queue
	if ( iQueuedTone )
		{
		TRAP_IGNORE( PrepareToneL( iQueuedTone ) );
		iQueuedTone = 0;
		}
	}
	


// ---------------------------------------------------------------------------
// CVRTonePlayer::MatoPlayComplete
// 
// ---------------------------------------------------------------------------
//
#ifdef _DEBUG
void CVRTonePlayer::MatoPlayComplete(TInt aError )
    {
	RDebug::Print( _L("VoiceRecorder: Tone %d played, error %d"), 
			iPreparedTone, aError );
#else
void CVRTonePlayer::MatoPlayComplete(TInt /*aError*/ )
    {
#endif    	

	iState = EVRToneIdle;

	// Prepare the next tone in queue
	if ( iQueuedTone )
		{
		TRAP_IGNORE( PrepareToneL( iQueuedTone ) );
		iQueuedTone = 0;
		}
	
	// Started only for start-tone	
	if ( iShedulerWait.IsStarted() )
		{
#ifdef _DEBUG
	    RDebug::Print( _L("VoiceRecorder: Start tone play completed -> Recording started") );
#endif		
		// Start tone played -> Recording can be started
		iShedulerWait.AsyncStop();
		}	
			
	}