/*

* 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 is the data model and state machine of the Recorder View.

*     The state machine is defined by a VR_STATEMACHINE resource structure.

*

*/

// INCLUDE FILES

#include <bldvariant.hrh>

#include <e32cmn.h>

#include <ctsydomainpskeys.h>

#include <UsbWatcherInternalPSKeys.h>

#include <usbpersonalityids.h>

#include <barsread.h>

#include <eikenv.h>

#include <eikappui.h>

#include <avkon.rsg>

#include <StringLoader.h>

#include <bautils.h>

#include <avkon.hrh>		// Key definitions

#include <AknGlobalNote.h>

#include <sendui.h>

#include <AknLayoutDef.h>

#include <AknUtils.h>

#include <featmgr.h>

#include <data_caging_path_literals.hrh>

#include <CMessageData.h>

#include <featmgr.h>	// Feature manager

#include <SendUiConsts.h>          // Disable e-mail  

#include "MessagingDomainCRKeys.h" // Disable e-mail variation flag

#include <centralrepository.h> // link against centralrepository.lib

#include "VoiceRecorderInternalCRKeys.h"

#include <voicerecorder.rsg>

#include "CVRMemo.h"

#include "TVRState.h"

#include "CVRMdaRecorder.h"

#include "VRConsts.h"

#include "CVRSystemEventHandler.h"

#include "CVRUSBEventHandler.h"

#include "VRUtils.h"

#include "CVRRecViewModel.h"

#include <csxhelp/vorec.hlp.hrh>

// CONSTANTS

const TInt KAllowInCallRecording( 1 );

// Shown if maximum recording time is not known

_LIT( KVRBeforeFirstEstimateLabel, "--:--:--" );

// MMS/High text is inserted here

_LIT( placeForQuality, "%U" );

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

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

// CVRRecViewModel::CVRRecViewModel

// 

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

//

CVRRecViewModel::CVRRecViewModel()

	: iStateArray( 2 ),

	iLabelSets( 2 ),

	iPreviousCallState( EPSCTsyCallStateNone ),

	iCanHandleCommands( ETrue ),

	iCBAEnabled( ETrue )

	{

	}

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

// CVRRecViewModel::~CVRRecViewModel

// 

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

//

CVRRecViewModel::~CVRRecViewModel()

	{

	// It might be possible to make this method leaving and put it

	// somewhere else than destructor

	SaveVolumeSettings();

	iLabelSets.ResetAndDestroy();

	iStateArray.Reset();

	delete[] iLabelLayoutLinks;

	delete iMemo;

	delete iRecorder;

	if ( iGlobalNote && iIsNoteLaunched )

		{

		// nothing much to do but ignore.

		TRAP_IGNORE( iGlobalNote->CancelNoteL( iNoteId ) );

		}

	delete iGlobalNote;

	if (iCurrentCallHandler) 

		{

		delete iCurrentCallHandler;

		}

	delete iCurrentUSBHandler;

	}

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

// CVRRecViewModel::ConstructFromResourceL

// 

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

//

void CVRRecViewModel::ConstructFromResourceL( TResourceReader& aReader )

	{

	TRAP_IGNORE( iCurrentCallHandler = CVRSystemEventHandler::NewL() );

	iCurrentCallHandler->Listen( KPSUidCtsyCallInformation, KCTsyCallState, 

								 this );

    // for USB

    iCurrentUSBHandler = CVRUSBEventHandler::NewL();

	iCurrentUSBHandler->Listen( KPSUidUsbWatcher, KUsbWatcherSelectedPersonality,

								 this );

	if ( FeatureManager::FeatureSupported( KFeatureIdKeypadNoVoiceKey ) &&

		FeatureManager::FeatureSupported( 

						KFeatureIdApplicationControllableAudioRouting ) )

		{

		ReadDefaultSpeakerL();

		}

	else

		{

		iIhfState = ETrue;

		}

	LoadVolumeSettingsL();

   // Connecting and initialization:

    CRepository* myRepSession = CRepository::NewLC( KCRUidVoiceRecorder );

    // Get the values from the repository

    User::LeaveIfError( myRepSession->Get( KVRDefaultAudioFormat, 

    									   iVRAudioFormat ) );

    User::LeaveIfError( myRepSession->Get( KVRAllowInCallRecording, 

    									   iVRAllowInCallRecording ) );

    CleanupStack::PopAndDestroy( myRepSession ); 

	iGlobalNote = CAknGlobalNote::NewL();

	iMemo = new( ELeave ) CVRMemo;

	iMemo->ConstructL( iVRAudioFormat );

	TInt numLabelSets( aReader.ReadInt16() );

	TInt i;

	for ( i = 0; i < numLabelSets; i++ )

		{

		CDesCArray* labelSet;

		TInt numLabels( aReader.ReadInt16() );

		if ( numLabels > 0 )

			{

			// TResourceReader re-reads the length, have to rewind

			aReader.Rewind( sizeof( TInt16 ) );

			labelSet = aReader.ReadDesCArrayL();

			}

		else

			{

			// create an empty array "by hand",

			// TResourceReader is not able to do this

			labelSet = new( ELeave ) CDesCArrayFlat( 1 );

			}

		CleanupStack::PushL( labelSet );

		iLabelSets.AppendL( labelSet );

		CleanupStack::Pop( labelSet);

		}

	TInt linkCount( aReader.ReadInt16() );

	iLabelLayoutLinks = new( ELeave ) TVRLabelLayoutLink[ linkCount ];

	for ( i = 0; i < linkCount; i++ )

		{

		iLabelLayoutLinks[ i ].ReadFromResource( aReader );

		}

	TInt numUiStates( aReader.ReadInt16() );

	TVRState uistate;

	for ( i = 0; i < numUiStates; i++ )

		{

		uistate.ReadFromResource( aReader );

		uistate.iId =  i;

		iStateArray.AppendL( uistate );

		}

	iState = &iStateArray.At( 0 );

	TInt numContexts( aReader.ReadInt16() );

	for ( i = 0; i < numContexts; i++ )

		{

		TInt id( aReader.ReadInt8() );

		TVRContext* context = &iContexts[ id ];

		context->iValid = ETrue;

		context->iInitialTransition.iCommandId = aReader.ReadUint8();

		context->iInitialTransition.iNewState = aReader.ReadUint8();

		context->iInitialTransition.iFunctionId = aReader.ReadUint8();

		context->iInitialTransition.iValid = ETrue;

		TInt numStates( aReader.ReadInt16() );

		for ( TInt j = 0; j < numStates; j++ )

			{

			TInt id( aReader.ReadInt8() );

			TVRContext::TState* state = &context->iStates[ id ];

			state->iValid = ETrue;

			TInt numTransitions( aReader.ReadInt16() );

			__ASSERT_DEBUG( numTransitions <= KVRMaxTransitions,

						User::Panic( KVRPanic, EPanicTooManyTransitions ) );

			for ( TInt k = 0; k < numTransitions; k++ )

				{

				TVRContext::TTransition* trans = &state->iTransitions[ k ];

				trans->iCommandId = aReader.ReadUint8();

				trans->iNewState = aReader.ReadUint8();

				trans->iFunctionId = aReader.ReadUint8();

				trans->iValid = ETrue;

				}

			}

		}

	StringLoader::Load( iDateUsualWithZero, R_QTN_DATE_USUAL_WITH_ZERO );

	StringLoader::Load( iTimeUsualWithZero, R_QTN_TIME_USUAL_WITH_ZERO );

	StringLoader::Load( iTimeDuratLong,	R_QTN_TIME_DURAT_LONG );	

	StringLoader::Load( iTimeDuratMinSecWithZero,

										R_QTN_TIME_DURAT_MIN_SEC_WITH_ZERO );

	}

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

// CVRRecViewModel::ProcessKeyEventL

// 

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

//

TBool CVRRecViewModel::ProcessKeyEventL( const TKeyEvent& aKeyEvent,

										 const TEventCode aType )

	{

	TBool retval( EFalse );

	if ( aType != EEventKey )

		{

		return retval;

		}

	switch ( aKeyEvent.iCode )

		{

		case EKeyPhoneEnd:

			{

			TInt currentState( iCurrentCallHandler->StateL(KPSUidCtsyCallInformation, KCTsyCallState) );

			if ( ( currentState != EPSCTsyCallStateNone ) )

				{

				HandleCommandL( ECmdDisconnectCall );

				retval = EKeyWasNotConsumed;

				}

			else

				{

				// Voice recorder wasn't here =), retval stays EFalse

				iIsEndKey = ETrue;	

				// Exit if app is not fully initialized

				if ( !iContextEntered )

					{

					CEikonEnv::Static()->EikAppUi()->

											HandleCommandL( EEikCmdExit );

					}

				}

			break;

			}

		case EKeyBackspace:

			{

			HandleCommandL( ECmdDelete );

			retval = ETrue;

			break;

			}

		case EKeyYes:

			{

			if( aKeyEvent.iRepeats > 0 )

				{

				if( VisualStateId() == EStateRecording ||

						VisualStateId() == EStatePlaying )

					{

					HandleCommandL( ECmdPause );

					}

				}

			break;

			}

		case EKeySide:

            {

            retval = ETrue;

            if ( aKeyEvent.iRepeats )

                {

                switch ( iState->iId )

                    {

                    case EStateIdle:

                        {

                        HandleCommandL( ECmdPlay );

                        break;

                        }

                    case EStateRecording:

                    case EStateRecordEmbedded:

                    case EStateRecordingPaused:

                    case EStatePlaying:

                    case EStatePlayingPaused:

                        {

                        HandleCommandL( ECmdStop );

                        break;

                        }

                    case EStateDeleted:

                    default:

                        {

                        retval = EFalse;

                        break;

                        }

                    }

                }

            else

                {

                switch ( iState->iId )

                    {

                    case EStateIdle:

                    case EStateDeleted:

                    case EStateRecordingPaused:

                        {

                        HandleCommandL( ECmdRecord );

                        break;

                        }

                    case EStateRecording:

                    case EStateRecordEmbedded:

                    case EStatePlaying:

                        {

                        HandleCommandL( ECmdPause );

                        break;

                        }

                    case EStatePlayingPaused:

                        {

                        HandleCommandL( ECmdPlay );

                        break;

                        }

                    default:

                        {

                        retval = EFalse;

                        break;

                        }

                    }

                }

            break;

            }

		default:

			{

			break;

			}

		}

	return retval;

	}

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

// CVRRecViewModel::HandleCommandL

// 

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

//

void CVRRecViewModel::HandleCommandL( TInt aCommandId )

	{

	// This command must be acceptable all times.

	if ( aCommandId == ECmdCancelNote )

		{

		if ( iIsNoteLaunched )

			{

			// nothing much to do but ignore.

			TRAP_IGNORE( iGlobalNote->CancelNoteL( iNoteId ) );

			}

		return;

		}

	if ( !CanAcceptCommands() )

		{

		return;

		}

	if ( !CanHandleCommands() )

		{

		return;

		}

	if ( EStateRecording == iState->iId && ECmdRecord == aCommandId ||

			EStateRecording == iState->iId && ECmdRename == aCommandId )

		{

		return;

		}

	switch ( aCommandId )

		{

		case ECmdHelp:

			{

			CEikonEnv::Static()->EikAppUi()->HandleCommandL( aCommandId );

			break;

			}	

		case EEikCmdExit:

			{

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

			break;

			}

		case EAknSoftkeyExit:

			{

			CEikonEnv::Static()->EikAppUi()->HandleCommandL( aCommandId );

			break;

			}

		case ECmdSendVia:

			{

			CEikonEnv::Static()->EikAppUi()->HandleCommandL( aCommandId );

			break;

			}

		case ECmdSaveAttachment:

			{

			__ASSERT_DEBUG( iRecorder, User::Panic( KVRPanic, KErrNotFound ) );

			iRecorder->DetachMemo();

			// Save permanently but do not remove the original

			HBufC* label = StringLoader::LoadLC( R_VR_SAVE_WAITNOTE_LABEL );

			iIsNoteLaunched = ETrue;

			iMemo->SavePermanentlyL( iGlobalNote, iNoteId, *label, ETrue );

			if ( iStateInfoObserver )

				{

				iStateInfoObserver->Update();

				}

			iRecorder->AttachToMemoL( iMemo );

			// Remove the waitnote

			iGlobalNote->CancelNoteL( iNoteId );

			iIsNoteLaunched = EFalse;

			CleanupStack::PopAndDestroy( label );

			break;

			}

		// FLOWTHROUGH

		// in case of end key, different command must be given to state

		// machine - recview gives ECmdAutoStopInterrupted

		case ECmdAutoStopInterrupted:

			{

			if ( iIsEndKey )

				{

				aCommandId = ECmdEndKey;

				iIsEndKey = EFalse;

				}

			}

		// Other commands are given to the state machine

		default:

			{

			TVRContext::TTransition transition;

			GetTransition( transition, aCommandId );

			TBool functionOK( ETrue );

			TRAPD( err, functionOK = 

								CallFunctionByIdL( transition.iFunctionId ) );

			if ( err != KErrNone )

				{

				// This is done to enable button events

				iCanHandleCommands = ETrue;

				}

			// We may have detached memo and we must reattach

			if ( err == KErrInUse )

				{

				__ASSERT_DEBUG( iRecorder, 

								User::Panic( KVRPanic, KErrNotFound ) );

				iRecorder->AttachToMemoL( iMemo );

				}

			if ( err == KErrNotReady && iIsNoteLaunched && iGlobalNote )

				{

				// nothing much to do but ignore.

				TRAP_IGNORE( iGlobalNote->CancelNoteL( iNoteId ) );

				}

			// If the disk gets full while saving, the next state is deleted

			if ( err == KErrDiskFull || err == KErrArgument )

				{

				if ( iContext == EContextRecordNewNormal ||

					 iContext == EContextNormal ||

					 iContext == EContextEmptyNormal )

					{

					ChangeState( EStateDeleted, ETrue );

					}

				else

					{

					// In record new embedded context the UI is left in

					// idle state, so the memo must be attached

					// (EFunctionOK detaches it)

					__ASSERT_DEBUG( iRecorder, 

									User::Panic( KVRPanic, KErrNotFound ) );

					if(!dynamic_cast<CVRMdaRecorder*>(iRecorder)->IsAttachedToMemo())

						{

					    iRecorder->AttachToMemoL( iMemo );	

						}

					}

				if ( err == KErrDiskFull )

					{

					// Maybe an error note should be shown