/*

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

*      Voice Recorder Record View

*

*

*/

// INCLUDE FILES

#include <aknViewAppUi.h>

#include <AknQueryDialog.h>

#include <avkon.hrh>

#include <barsread.h>

#include <eikbtgpc.h>

#include <eikmenub.h>

#include <StringLoader.h>

#include <apparc.h>

#include <eikenv.h>

#include <eikappui.h>

#include <eikapp.h>

#include <CommonContentPolicy.h>

#include <vwsdef.h>

#include <pathinfo.h>

#include <sendui.h>

#include <avkon.rsg>

#include <featmgr.h>

#include <VoiceRecorderUID.h>

#include <voicerecorder.rsg>

#include <e32property.h> 

#include <coreapplicationuisdomainpskeys.h>

#include <AknLaunchAppService.h>

#include <AiwGenericParam.h>

#include <sysutil.h>

#include <aknnotewrappers.h>

#include "voicerecorder.hrh"

#include "CVRRecView.h"

#include "CVRRecViewContainer.h"

#include "CVRRecViewActivationContainer.h"

#include "CVRRecViewModel.h"

#include "VRUtils.h"

#include "VRUSBStateHanlder.h"

// CONSTANTS

const TUid KUidMmsEditor =

    {

    0x100058DE

    };

const TUid KUidMailEditor =

    {

    0x101F4CD6

    };

inline TBool ShowDialogForWaitUSBPluggingOutL()

    {

    HBufC* text = StringLoader::LoadLC(R_QTN_USB_MODE_NOTE_MODE);

    CAknQueryDialog* dlg = CAknQueryDialog::NewL();

    TInt result(dlg->ExecuteLD(R_INSERT_F_USB_PLUG_IN_DIALOG, *text));

    CleanupStack::PopAndDestroy(text);

    if (result)

        {

        return ETrue;

        }

    return EFalse;

    }

inline TInt WaitDialogForUSBPluggingOut(CAknWaitDialog*& aDialog)

    {

    aDialog = new (ELeave) CAknWaitDialog(

            (REINTERPRET_CAST(CEikDialog**,&aDialog)));

    aDialog->SetTone(CAknNoteDialog::EConfirmationTone);

    return aDialog->ExecuteLD(R_VOREC_USB_CONNECTED_DIALOG);

    }

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

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

// CVRRecView::CVRRecViewModelActivator::CVRRecViewModelActivator

// 

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

//

CVRRecView::CVRRecViewModelActivator::CVRRecViewModelActivator(

        CVRRecViewModel* aModel) :

    CAsyncOneShot(EPriorityNormal), iModel(aModel), iContext(

            EContextEmptyNormal)

    {

    }

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

// CVRRecView::CVRRecViewModelActivator::~CVRRecViewModelActivator

// 

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

//

CVRRecView::CVRRecViewModelActivator::~CVRRecViewModelActivator()

	{

	Cancel();

	}

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

// CVRRecView::CVRRecViewModelActivator::RunL

// 

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

//

void CVRRecView::CVRRecViewModelActivator::RunL()

	{

	if(iModel->GetIsDriveReady())

	    {

        // Activate model in correct context

	    iModel->SetMemoNameNewL( iContext == EContextRecordNewForRemote);

	    iModel->EnterContextL( iContext );

	    iModel->ActivateL();

	    } 

	// Notify recview

	iCallback.CallBack();

	}

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

// CVRRecView::CVRRecViewModelActivator::Activate

// 

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

//

void CVRRecView::CVRRecViewModelActivator::Activate( 

		TVRRecViewContexts aContext, TCallBack aCallback )

	{

	iContext = aContext;

	iCallback = aCallback;

	Call();

	}

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

// CVRRecView::CVRRecViewModelActivator::DoCancel

// 

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

//

void CVRRecView::CVRRecViewModelActivator::DoCancel()

    {

    }

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

// CVRRecView::CVRRecViewDialogActivator::CVRRecViewDialogActivator

// 

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

//

CVRRecView::CVRRecViewDialogActivator::CVRRecViewDialogActivator( CVRRecViewModel* aModel)

:CAsyncOneShot(EPriorityNormal), iModel(aModel)

    {

    }

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

// CVRRecView::CVRRecViewDialogActivator::~CVRRecViewDialogActivator

// 

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

//

CVRRecView::CVRRecViewDialogActivator::~CVRRecViewDialogActivator()

    {

    Cancel();

    }

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

// CVRRecView::CVRRecViewDialogActivator::~CVRRecViewDialogActivator

// 

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

//

void CVRRecView::CVRRecViewDialogActivator::SetDialogType(TDialogTypeID aType)

    {

    iType = aType;

    }

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

// CVRRecView::CVRRecViewDialogActivator::SetViewContexts

// 

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

//

void CVRRecView::CVRRecViewDialogActivator::SetViewContexts(TVRRecViewContexts aContext)

    {

    iContext = aContext;

    }

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

// CVRRecView::CVRRecViewDialogActivator::DoCancel

// 

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

//

void CVRRecView::CVRRecViewDialogActivator::DoCancel()

    {

    }

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

// CVRRecView::CVRRecViewNoteActivator::RunL

// 

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

//

void CVRRecView::CVRRecViewDialogActivator::RunL()

    {

    if(iType == EDialogForWaitStorageCard)

        {

        TInt driveRemovableMassStorage = VRUtils::GetRemovableMassStorageL();

        while ( !VRUtils::DriveValid( (TDriveNumber) driveRemovableMassStorage ) )

            {

            if (!ShowDialogForWaitStorageCardL())

                {

                iModel->SendExitEvent();

                }

            }

        // Come to here when driveRemovableMassStorage is valid

        VRUtils::SetMemoDriveL( (TDriveNumber) driveRemovableMassStorage );    

        /***** check if memory is below min value, if yes, close app*****/

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

        if (SysUtil::DiskSpaceBelowCriticalLevelL(&fs, 0, VRUtils::MemoDriveL()))

           {

           HBufC* errorText = StringLoader::LoadLC(

                   R_VR_MEMORY_LOW_STOP_WARNING);

           CAknErrorNote* dlg = new (ELeave) CAknErrorNote(ETrue);

           dlg->ExecuteLD(*errorText);

           CleanupStack::PopAndDestroy(errorText);

           iModel->SendExitEvent();

           }

        // check memory size end

        // To activate view model

        iModel->SetMemoNameNewL( iContext == EContextRecordNewForRemote);

        iModel->SetIsDriveReady(ETrue);

        iModel->EnterContextL( iContext );

        iModel->ActivateL();

        }

    else if(iType == EDialogForWaitUSBPluggingOut)

        {

        ShowDialogForWaitUSBPluggingOutL();

        iModel->SendExitEvent();

        }

    }

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

// CVRRecView::NewLC

// 

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

//

EXPORT_C CVRRecView* CVRRecView::NewLC( TInt aViewResourceId,

										TInt aModelResourceId )

	{

	CVRRecView* recview = new( ELeave ) CVRRecView;

	CleanupStack::PushL( recview );

	recview->ConstructL( aViewResourceId, aModelResourceId );

	return recview;

	}

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

// CVRRecView::~CVRRecView

// 

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

//

CVRRecView::~CVRRecView()

	{

	if ( iContainer )

		{

		AppUi()->RemoveFromViewStack( *this, iContainer );

		}

	if ( iActivationContainer )

		{

		AppUi()->RemoveFromViewStack( *this, iActivationContainer );

		}

    delete iContainer;

    delete iActivationContainer;

    delete iDialogActivator;

    delete iModel;

    delete iSendUi;

    delete iModelActivator;

    delete iLaunchService;

    delete iUSBStateHandler;

    if (iUsbWaitDialog)

        {

        TRAP_IGNORE(iUsbWaitDialog->ProcessFinishedL());

        }

    }

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

// CVRRecView::ConstructL

// 

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

//

void CVRRecView::ConstructL( TInt aViewResourceId, TInt aModelResourceId )

	{

	BaseConstructL( aViewResourceId );

	iModel = new( ELeave ) CVRRecViewModel;

	TResourceReader reader;

	iEikonEnv->CreateResourceReaderLC( reader, aModelResourceId );

	iModel->ConstructFromResourceL( reader );

	CleanupStack::PopAndDestroy(); // reader;

    // Create SendUi (Send as MMS, E-Mail, etc...)

    iSendUi = CSendUi::NewL();

    iModelActivator = new (ELeave) CVRRecViewModelActivator(iModel);

    iUSBStateHandler = CVRUSBStateHanlder::NewL(this);

    }

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

// CVRRecView::Id

// 

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

//

TUid CVRRecView::Id() const

    {

    const TUid KVRRecViewUID =

        {

        KVRRecorderViewUID

        };

	return KVRRecViewUID;

	}

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

// CVRRecView::HandleCommandL

// 

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

//

void CVRRecView::HandleCommandL( TInt aCommandId )

	{

	// This command must be acceptable all times.

	if ( aCommandId == ECmdCancelNote )

		{

        iCommand = aCommandId;

		if( iModel )

			{

			iModel->HandleCommandL( aCommandId );			

			}

		return;

		}

	if ( !iModel->CanAcceptCommands() )

		{

		return;

		}

	switch ( aCommandId )

		{

		// Don't do anything in case of a Task Swapper command

		case EAknCmdTaskSwapper:

			{

			break;	

			}

		// No operation	

		case ECmdNOP: 

			{

			break;	

			}	

		// Go back to voice memo list view

		case EAknSoftkeyBack:

			{

			AppUi()->HandleCommandL( EEikCmdExit );

			break;

			}

		case ECmdSettings:

			{

			// Saving the volume control state before entering settings

			TBool hasVolumeControl( iModel->HasVolumeControl() );

			// Disabling volume control 

			iModel->EnableVolumeControl( EFalse );

			iContainer->Update();

			AppUi()->HandleCommandL( aCommandId );

			// Set volume control as it was before settings dialog

			iModel->EnableVolumeControl( hasVolumeControl );

			iContainer->Update();

			break;

			}

	     case ECmdGoToMyClips:

	        {

            delete iLaunchService;

            iLaunchService = NULL;

	        TFileName path;

	        VRUtils::MemoStoreDirectoryL( path );

	        TInt sortMode = 0;

            CAiwGenericParamList* inParams = CAiwGenericParamList::NewLC();

            inParams->AppendL(TAiwGenericParam(EGenericParamDir, TAiwVariant(

                    path)));

            inParams->AppendL(TAiwGenericParam(EGenericParamDir, TAiwVariant(

                    sortMode)));

            iLaunchService = CAknLaunchAppService::NewL(

                    TUid::Uid(0x101F84EB), NULL, inParams);

            CleanupStack::PopAndDestroy(inParams);

            break;

            }

        case ECmdSendVia:

            {

            iModel->SendViaL(iSendUi);

            break;

            }

            // Handles Middle SoftKey presses in this view

        case ECmdMSK:

            {

            // Don't forward the command if dimmed button was clicked or 

            // if model can't handle commands

            if (iModel->ButtonState(iContainer->FocusedButton()) == EDimmed

                    || !iModel->CanHandleCommands())

                {

                break;

                }

            // Fetch the command to execute 

            TInt commandId(iModel->CommandId(iContainer->FocusedButton()));

            iModel->HandleCommandL(commandId);

            AppUi()->HandleCommandL(commandId);

            iContainer->UpdateButtonPanel(EVRUpdateStateChange);

            break;

            }

        case ECmdUSBChange:

            if (iUsbWaitDialog)

                {

                iUsbWaitDialog->ProcessFinishedL();

                }

            iContainer->UpdateButtonPanel(EVRUpdateStateChange);

            break;

        default:

            {

            iModel->HandleCommandL(aCommandId);

            AppUi()->HandleCommandL(aCommandId);

            break;

            }

        }

    }

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

// CVRRecView::DynInitMenuPaneL

// 

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

//

void CVRRecView::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane )

	{

	switch ( aResourceId )

		{

		case R_VR_REC_MENUPANE_DEFAULT:

			{

            // Check if HELP is enabled in FeatureManager, if not, disable the Help menu item

            if (!FeatureManager::FeatureSupported(KFeatureIdHelp))

                {

                aMenuPane->SetItemDimmed(ECmdHelp, ETrue);

                }

            if (CVRUSBStateHanlder::IsUsbActive())

                {

                aMenuPane->SetItemDimmed(ECmdRecord, ETrue);

                aMenuPane->SetItemDimmed(ECmdDelete, ETrue);

                aMenuPane->SetItemDimmed(ECmdRename, ETrue);

                aMenuPane->SetItemDimmed(ECmdGoToMyClips, ETrue);

                }

			TRAP_IGNORE(AddSendToMenuL( aResourceId, aMenuPane ));

			break;

			}

		case R_VR_REC_MENUPANE_VIEWER:

			{

			TUid appuid( KNullUid );

			CEikAppUi* container = iEikonEnv->EikAppUi()->ContainerAppUi();

			if ( container )

				{

                // Check if HELP is enabled in FeatureManager, if not, disable the Help menu item

                if (!FeatureManager::FeatureSupported(KFeatureIdHelp))

                  {

                  aMenuPane->SetItemDimmed(ECmdHelp, ETrue);

                  }

                if (CVRUSBStateHanlder::IsUsbActive())

                    {

                    aMenuPane->SetItemDimmed(ECmdSaveAttachment, ETrue);

                    }

                appuid = container->Application()->AppDllUid();

                if ((appuid == KUidMmsEditor) || (appuid == KUidMailEditor))

                    {

                    aMenuPane->SetItemDimmed(ECmdSaveAttachment, ETrue);

                    }

                else

                    {

					TRAP_IGNORE(AddSendToMenuL(aResourceId, aMenuPane));

                    }

                }

			break;

			}

		case R_VR_SETTINGS_MENUPANE:

			{

			// Check if HELP is enabled in FeatureManager, if not, disable the Help menu item

			if (!FeatureManager::FeatureSupported(KFeatureIdHelp))

				{

				aMenuPane->SetItemDimmed(ECmdHelp, ETrue);

				}

            break; 

			}

		case R_VR_REC_MENUPANE_DELETED: