/*

* Copyright (c) 2002 - 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: 

*     This class acts as a high level wrapper around the media server

*     playback and recording functionalities.

*

*/

// INCLUDE FILES

#include "CVRSystemEventHandler.h"

#include <ctsydomainpskeys.h>

#include <e32svr.h>

#include <bautils.h>

#include <eikenv.h>

#include <aknappui.h>

#include <e32property.h>

#include <AudioPreference.h>

#include <aknsoundsystem.h>

#include <ScreensaverInternalPSKeys.h>

#include <AknGlobalNote.h>

#include <StringLoader.h>

#include <ErrorUI.h>

#include <sysutil.h>

#include <featmgr.h> // Feature manager

#include <voicerecorder.rsg>

#include <VoiceRecorderUID.h>

#include "VoiceRecorderPrivatePSKeys.h"

#include "CVRMemo.h"

#include "MVRObserver.h"

#include "VRConsts.h"

#include "VRUtils.h"

#include "CVRTonePlayer.h"

#include "CVRMdaRecorder.h"

#include "CVRDiskSpaceWatcher.h"

#include "CVRRecViewModel.h"

#include <AudioInput.h> 

// MACROS

#ifdef _DEBUG

#define DEB_PRN_0(str) RDebug::Print(str)

#else

#define DEB_PRN_0(str)

#endif

// CONSTANTS

const TInt KVRMdaRecorderDefaultStep( 5 );

const TInt KVRObserverArrayGranularity( 2 );

const TInt KVRMaxNoteLabelLength( 256 );

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

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

// CVRMdaRecorder::CVRMdaRecorder

// 

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

//

CVRMdaRecorder::CVRMdaRecorder() :

	iObservers( KVRObserverArrayGranularity ),

	iIsAttachedToMemo( EFalse ),

	iMediaServerError( KErrNone ),

	iDimLight (EFalse),

	iAttachingToMemo(EFalse),

	ifInRecording(EFalse),

	ifStopCalled(EFalse)

	{

	}

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

// CVRMdaRecorder::~CVRMdaRecorder

// 

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

//

CVRMdaRecorder::~CVRMdaRecorder()

	{

	delete iGlobalNote;

	delete iAudioInput; 

	delete iAudioRecorder;

	delete iErrorUI;

	delete iTimer;

	delete iTonePlayer;

	delete iLight;

	delete iDiskSpaceWatcher;

    iObservers.Close();

    if (iCurrentCallHandler)

    	{

    	delete iCurrentCallHandler;

    	}

	}

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

// CVRMdaRecorder::ConstructL

// 

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

//

void CVRMdaRecorder::ConstructL()

	{

	_LIT_SECURITY_POLICY_S0( KVRWritePolicy, KVoiceRecorderAppUID3 );

	_LIT_SECURITY_POLICY_PASS( KVRReadPolicy );

    // Connect to Pub&Sub:

    // Error ignored, key may be already defined which is ok for us

	iPropVRState.Define( KPSUidVoiceRecorder, KVoiceRecorderMode, 0,

	                     KVRReadPolicy, KVRWritePolicy );    

    User::LeaveIfError(

        iPropVRState.Attach(

        KPSUidVoiceRecorder, KVoiceRecorderMode ) );

   	// To allow/don't allow screensaver

   	// Errors ignored, no actions needed if API is not available

    iPropScreenSaver.Attach( KPSUidScreenSaver,

       KScreenSaverAllowScreenSaver );

	iAudioRecorder = CMdaAudioRecorderUtility::NewL( *this, NULL,

	  KAudioPriorityRecording, TMdaPriorityPreference( 

                               KAudioPrefRealOneLocalPlayback ) );

	iGlobalNote = CAknGlobalNote::NewL();

	iErrorUI = CErrorUI::NewL();

	iTonePlayer = CVRTonePlayer::NewL();

	iTonePlayer->PrepareToneL( EAvkonSIDVoiceRecordingStartTone );

	iLight = CHWRMLight::NewL(this);

	// start observe diskdrive

    RFs& fs( CEikonEnv::Static()->FsSession() );

    iDiskSpaceWatcher = CVRDiskSpaceWatcher::NewL(*this, fs);	

	}

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

// CVRMdaRecorder::MoscoStateChangeEvent

// 

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

//

void CVRMdaRecorder::MoscoStateChangeEvent( CBase* /*aObject*/,

										    TInt aPreviousState,

											TInt aCurrentState,

											TInt aErrorCode )

	{

#ifdef _DEBUG

	RDebug::Print( _L( "VoiceRecorder: MoscoStateChangeEvent() prev: %d, current: %d, error: %d" ), 

			aPreviousState, aCurrentState, aErrorCode );

#endif

	iMediaServerError = aErrorCode;

   	TRAP_IGNORE(CreateAudioInputL());

	// Stop the active scheduler wait (if present)

	if ( iActiveWait.IsStarted() )

		{

		iActiveWait.AsyncStop();

		}

	if (iMediaServerError != KErrNone ) 

		{

        // when mmc card is used and unpluged, this error returned

        if (iMediaServerError == KErrCorrupt || iMediaServerError == KErrNotReady)

        	{

        	CVRRecViewModel* iViewModel = NULL;

        	//iAudioRecorder->Close();

        	iViewModel = dynamic_cast <CVRRecViewModel*>(iAutoStopObserver);

        	if(iViewModel != NULL)

        		{

        		TRAP_IGNORE( iViewModel->HandleCommandL(EEikCmdExit) );

        		}

        	else

        		{

        		TRAP_IGNORE( CEikonEnv::Static()->EikAppUi()->HandleCommandL( EAknSoftkeyExit) );

        		}

        	}

		// Media server reports KErrDied if the playing was interrupted

		// by some other system sound triggered by for example incoming SMS

        if (aPreviousState == CMdaAudioClipUtility::ERecording || aPreviousState == CMdaAudioClipUtility::EPlaying )

        	{ 	

        	//if ( iMediaServerError != KErrDied &&  iMediaServerError != KErrAccessDenied )

        	if ( iMediaServerError != KErrDied &&  

        		 iMediaServerError != KErrAccessDenied &&  

        		 iMediaServerError != KErrInUse )

				{

				TBuf< KVRMaxNoteLabelLength > label;

				// If showing of error note fails, then.. well it fails

				if ( iMediaServerError == KErrNotSupported )

					{

					CCoeEnv::Static()->

					ReadResourceAsDes16( label, R_VR_UNSUPPORTED_INFONOTE_LABEL );

					TRAP_IGNORE( iGlobalNote->

					ShowNoteL( EAknGlobalErrorNote, label ) );

					}

				else if ( iMediaServerError == KErrCorrupt )

					{

					CCoeEnv::Static()->

					ReadResourceAsDes16( label, R_VR_CORRUPT_INFONOTE_LABEL );

					TRAP_IGNORE( iGlobalNote->ShowNoteL( EAknGlobalErrorNote, 

													 label ) );

					}

				else

					{

					TRAP_IGNORE( iErrorUI->ShowGlobalErrorNoteL( iMediaServerError ) );

					}

				}

        	    if(iMediaServerError == KErrInUse && aPreviousState == CMdaAudioClipUtility::EPlaying)

        	    	{

					CVRRecViewModel* iViewModel = NULL;

					iViewModel = dynamic_cast <CVRRecViewModel*>(iAutoStopObserver);

					if(iViewModel != NULL)

            		{

            		iViewModel->HandleCommandL(ECmdPause);

            		}

        	        return;

        	    	}

        	    else

        	    	{

					StopAndNotify();

        	    	}

        	}

        //it will happen when the openfile fails

        if (aPreviousState == CMdaAudioClipUtility::ENotReady && aCurrentState == CMdaAudioClipUtility::ENotReady )

        	{

#ifdef _DEBUG        	

        	RDebug::Print( _L( "VoiceRecorder: callback stop called" ) );

#endif	    	

	    	iAudioRecorder->Close();				

        	}

#ifdef _DEBUG

		if ( aCurrentState == CMdaAudioClipUtility::ERecording)

			{

	        RDebug::Print( _L( "VoiceRecorder: ERecording" ) );

			}

#endif

		} // if ( iMediaServerError != KErrNone )

	if ( aCurrentState == CMdaAudioClipUtility::ERecording ||

		 aCurrentState == CMdaAudioClipUtility::EPlaying )

		{

	   	// Do not allow screen saver while playing

   	    // Errors ignored, no actions needed if API is not available	   	

	   	iPropScreenSaver.Set( KPSUidScreenSaver,

			KScreenSaverAllowScreenSaver, EVRScreenSaverNotAllowed );

		}

	if ( aCurrentState == CMdaAudioClipUtility::EOpen )

		{

		switch ( aPreviousState )

			{

			case CMdaAudioClipUtility::ENotReady:

				{

				iMemo->UpdateModifiedDate();

				if ( iAttachingToMemo )

				    {

				    iAttachingToMemo = EFalse;

				    TRAP_IGNORE( ConfigureMemoL());

				    }

				break;

				}

			default:

				{

				StopAndNotify();

				break;

				}

			}

		}

    DEB_PRN_0( _L( "CVRMdaRecorder::MoscoStateChangeEvent::Exit"));

	}

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

// CVRMdaRecorder::RegisterObserver

// 

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

//

void CVRMdaRecorder::RegisterObserver( MVRObserver* aObserver )

	{

	if ( aObserver && iObservers.Find( aObserver ) == KErrNotFound )

		{

		iObservers.Append( aObserver );

		}

	}

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

// CVRMdaRecorder::UnregisterObserver

// 

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

//

void CVRMdaRecorder::UnregisterObserver( MVRObserver* aObserver )

	{

	if ( !aObserver )

		{

		return;

		}

	TInt index( iObservers.Find( aObserver ) );

	if ( index != KErrNotFound )

		{

		iObservers.Remove( index );

		}

	}

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

// CVRMdaRecorder::SetAutoStopObserver

// 

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

//

void CVRMdaRecorder::SetAutoStopObserver( MVRObserver* aObserver )

	{

	iAutoStopObserver = aObserver;

	}

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

// CVRMdaRecorder::AttachToMemoL

// Opens a memo file.

// If the specified file does not exist (yet), it is created. 

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

//

void CVRMdaRecorder::AttachToMemoL( CVRMemo* aMemo )

	{

#ifdef _DEBUG

     RDebug::Print( _L( "CVRMdaRecorder::AttachToMemoL -enter" ));      	

#endif

     // if error happen, attach will fail 

	if( iIsAttachedToMemo )

		{

		User::Panic( KVRPanic,EPanicAlreadyAttached );

		}

	if( !aMemo )

		{

		User::Panic( KVRPanic, KErrNotFound );

		}

	iMemo = aMemo;

    // if the mmc card is full, should not attach to it

     RFs& fs( CEikonEnv::Static()->FsSession() );

// old storage system

#ifndef RD_MULTIPLE_DRIVE

	if ( iMemo->MemoStore() == EMemoStorePhoneMemory )

		{

#ifdef  __AAC_ENCODER_PLUGIN

		if (((iMemo->Quality() != EQualityHigh) && SysUtil::FFSSpaceBelowCriticalLevelL( &fs, KVRRecStartMemBuf )) || 

		((iMemo->Quality() == EQualityHigh) && SysUtil::FFSSpaceBelowCriticalLevelL( &fs, KVRAACCriticalMemoryLevel )))

#else

        // now AAC format is not enabled

        if (SysUtil::FFSSpaceBelowCriticalLevelL( &fs, KVRRecStartMemBuf ))

#endif

        	{

 			VRUtils::ShowMemoryFullConfirmationQuery();

			if(GetInRecordingFlag())

				{

				SetInRecordingFlag(EFalse);	

				}       		

        	}

		}

     // MMC card

        else

     	{

#ifdef  __AAC_ENCODER_PLUGIN

		if (((iMemo->Quality() != EQualityHigh) && SysUtil::MMCSpaceBelowCriticalLevelL( &fs, KVRRecStartMemBuf )) || 

		((iMemo->Quality() == EQualityHigh) && SysUtil::MMCSpaceBelowCriticalLevelL( &fs, KVRAACCriticalMemoryLevel )))

#else

        // now AAC format is not enabled

        if (SysUtil::FFSSpaceBelowCriticalLevelL( &fs, KVRRecStartMemBuf ))

#endif

        	{

			VRUtils::ShowMemoryFullConfirmationQuery(ETrue);

			if(GetInRecordingFlag())

				{

				SetInRecordingFlag(EFalse);	

				}       		

        	}     		

     	}

// now multiple drives

#else

#ifdef  __AAC_ENCODER_PLUGIN

		if (((iMemo->Quality() != EQualityHigh) && SysUtil::DiskSpaceBelowCriticalLevelL( &fs, KVRRecStartMemBuf, iMemo->StorageDrive())) ||

		((iMemo->Quality() == EQualityHigh) && SysUtil::DiskSpaceBelowCriticalLevelL( &fs, KVRAACCriticalMemoryLevel, iMemo->StorageDrive())))		 

#else

        // now AAC format is not enabled

        if (SysUtil::DiskSpaceBelowCriticalLevelL( &fs, KVRRecStartMemBuf, iMemo->StorageDrive()))

#endif 

			{

			//mmc card			

			if ( iMemo->StorageDrive() == VRUtils::GetRemovableMassStorageL())

				{

 				VRUtils::ShowMemoryFullConfirmationQuery(ETrue);

				}

			else

				{

		 		VRUtils::ShowMemoryFullConfirmationQuery();

				}

			if(GetInRecordingFlag())

				{

				SetInRecordingFlag(EFalse);	

				}			

			}

#endif

	// opens an existing file or creates new

	iAudioRecorder->OpenFileL( iMemo->File() );

	iAttachingToMemo = ETrue;

	if( !iActiveWait.IsStarted() )

		{

#ifdef _DEBUG

		RDebug::Print( _L( "CVRMdaRecorder::AttachToMemoL::AWaitStarting..."));

#endif

		iActiveWait.Start(); // CSI: 10 #

#ifdef _DEBUG

		RDebug::Print( _L( "CVRMdaRecorder::AttachToMemoL::AWResuming...[%d]"), iMediaServerError);

#endif

		}    

	User::LeaveIfError( iMediaServerError );

/*

	if( !iActiveWait.IsStarted() )

		{

		RDebug::Print( _L( "CVRMdaRecorder::AttachToMemoL::AWaitStarting..."));

		iActiveWait.Start(); // CSI: 10 #

		RDebug::Print( _L( "CVRMdaRecorder::AttachToMemoL::AWResuming...[%d]"), iMediaServerError);

		}    

	User::LeaveIfError( iMediaServerError );

    // Configure bitrate if recording an AMR clip.

    // Default bitrate is 12200 and it's used if codec doesn't support

    // the bitrate that is retrieved from Central Repository.

    if (iMemo->Quality() == EQualityMMSOptimized )

        {

        TUint configuredAmrBitrate( VRUtils::AMRBitrateL() );

        TUint amrBitrate( KVRDefaultAmrBitrate );

        // Fetch supported bitrates and find out if configured bitrate

        // is supported

        RArray<TUint> rates;

        iAudioRecorder->GetSupportedBitRatesL( rates );        

        TInt num = rates.Count();

        if(num > 0)

        	{

            rates.Sort();

            TInt found = rates.Find(configuredAmrBitrate);

            if (found == KErrNotFound)

            	{

            		amrBitrate = rates[num-1];

            	}

        	}

        rates.Reset();  // Clear array      

        iAudioRecorder->SetDestinationBitRateL( amrBitrate );                  

        }

// added for supporting mp4 format

#ifdef __AAC_ENCODER_PLUGIN

  else if (iMemo->Quality() == EQualityHigh)

    	{

         TInt configuredAacSamplerate( VRUtils::AACSamplerateL() );

         TInt aacSampleRate( KVRDefaultSamplerateAac );

         TInt configuredAacBitrate( VRUtils::AACBitrateL() );

         TInt aacBitrate( KVRDefaultBitrateAac );

         TInt configuredAudioMode( VRUtils::AACAudioModeL() );   

         // Sample rate

     	 RArray<TUint> supportedSampleRates;

#ifdef _DEBUG

      RDebug::Print( _L( "CVRMdaRecorder::AttachToMemoL-GetSupportedSampleRatesL -before" ));      	

#endif

         iAudioRecorder->GetSupportedSampleRatesL(supportedSampleRates);