#include <aknwaitdialog.h>

    if (iActiveWait.IsStarted())

        {

        iActiveWait.AsyncStop();

        }

    if (iDoorObserver)

        {

        iDoorObserver->NotifyExit(MApaEmbeddedDocObserver::EEmpty);

        }

            if (CVRUSBStateHanlder::IsUsbActive())

                {

                HBufC* noteText = iCoeEnv->AllocReadResourceLC(

                        R_QTN_MEMC_VOREC_NOTE1 );

                CAknInformationNote* infoNote =

                new( ELeave ) CAknInformationNote( ETrue );

                infoNote->ExecuteLD( *noteText );

                CleanupStack::PopAndDestroy( noteText );

                VRUtils::SetMemoStoreL( EMemoStorePhoneMemory );

                }

        TInt memoDrive = VRUtils::MemoDriveL();

        if (VRUtils::DriveValid(memoDrive))

            {

            VRUtils::SetMemoDriveL((TDriveNumber) memoDrive);

            }

        else

            {

            TInt defaultDrive = VRUtils::DefaultMemoDriveL(); //eMMC

            if (defaultDrive == memoDrive)

                {

                SetDriveL();

                }

            else

                {

                if (VRUtils::DriveValid(defaultDrive))

                    {

                    VRUtils::SetMemoDriveL((TDriveNumber) defaultDrive);

                    }

                else

                    {

                    SetDriveL();

                    }

                }

            }

        /***** 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);

            Exit();

            }

        // check memory size end

    CVRRecView* view = CVRRecView::NewLC(R_VR_RECORDER_VIEW,

            R_VR_RECVIEW_STATES);

    if (iEikonEnv->StartedAsServerApp())

        {

        ActivateLocalViewL(TUid::Uid(KVRRecorderViewUID), TUid::Uid(

                EContextRecordNewForRemote), KNullDesC8);

        }

// Make user insert the SD card, and choose SD card as the memo storage

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

//

void CVRAppUi::SetDriveL()

    {

    if ( VRUtils::DriveValid( EDriveF ) )

    	{

    	VRUtils::SetMemoDriveL((TDriveNumber)EDriveF );

    	}

    else

        {

        if (CVRUSBStateHanlder::IsUsbActive())

            {

            ShowDialogForWaitUSBPluggingOutL();

            Exit();

            }

        while (!VRUtils::DriveValid(EDriveF))

            {

            if (!ShowDialogForWaitStorageCardL())

                {

                Exit();

                }

            }

        // Come to here when drive F is valid

        VRUtils::SetMemoDriveL((TDriveNumber) EDriveF);

        }

    }

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

// This method show a dialog to warn user to insert the SD card.

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

//

TBool CVRAppUi::ShowDialogForWaitStorageCardL()

    {

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

    CAknQueryDialog* dlg = CAknQueryDialog::NewL();

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

    CleanupStack::PopAndDestroy( text );

    if ( result )

    	{

    	return ETrue;

    	}

    return EFalse;

    }

TBool CVRAppUi::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;    

}

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

            // The file service needs to abort if it's still going on

            if (iEmbeddedObserver)

                {

                CNewFileServiceBase * iNewFileService = NULL;

                iNewFileService

                        = dynamic_cast<CNewFileServiceBase*> (iEmbeddedObserver);

                if (iNewFileService != NULL)

                    {

                    iNewFileService->SetErrorCode(KErrAbort);

                    }

                iEmbeddedObserver->AbortL();

                }

            // The file service needs to abort if it's still going on

            if (iEmbeddedObserver)

                {

                CNewFileServiceBase * iNewFileService = NULL;

                iNewFileService

                        = dynamic_cast<CNewFileServiceBase*> (iEmbeddedObserver);

                if (iNewFileService != NULL)

                    {

                    iNewFileService->SetErrorCode(KErrAbort);

                    }

                iEmbeddedObserver->AbortL();

                }

            Exit();

            break;

            }

        case ECmdHelp:

            {

            if (FeatureManager::FeatureSupported(KFeatureIdHelp))

                {

                if (iIsSettingsOpen)

                    {

                    CArrayFix<TCoeHelpContext>* contexts = AppHelpContextL();

                    contexts->At(0).iContext = KVOREC_HLP_SETTINGS;

                    HlpLauncher::LaunchHelpApplicationL(

                            iEikonEnv->WsSession(), contexts);

                    }

                else

                    {

                    HlpLauncher::LaunchHelpApplicationL(

                            iEikonEnv->WsSession(), AppHelpContextL());

                    }

                }

            }

        case ECmdSettings:

            {

            if (FeatureManager::FeatureSupported(KFeatureIdMmc)

                    || VRUtils::FeatureEnabled(EVRFeatureShowQualitySetting))

                {

                iIsSettingsOpen = ETrue;

                CVRSettingsDialog* settingsDlg = CVRSettingsDialog::NewL();

                settingsDlg->ExecuteLD(R_VR_SETTINGS_DIALOG);

                iIsSettingsOpen = EFalse;

                }

            break;

            }

        case ECmdNewFileServiceNotify:

            {

            if (iActiveWait.IsStarted())

                {

                iActiveWait.AsyncStop();

                }

            break;

            }

        case ECmdEmbeddedRecordingReady:

            {

            if (iEmbeddedObserver)

                {

                TBool canExit(ETrue);

                TVRSelectionStyle selStyle;

                TPtrC memoFile(SelectionProviderL()-> GetSelectedFilesLC(

                        selStyle)-> MdcaPoint(0));

                if (memoFile.Length() > 0)

                    {

                    TFileName myFilename(memoFile);

                    canExit = iEmbeddedObserver->FileCompleteL(myFilename);

                    }

    if (aType == KEikDynamicLayoutVariantSwitch || aType

            == KAknsMessageSkinChange)

        {

        iLayoutChangeObserver->LayoutChangedL(aType);

        }

    }

    // Check if we got "-record" as command line parameter

    // convert 8-bit descriptor to a 16-bit one without altering data.

    const TUint16* ptr16 = reinterpret_cast<const TUint16*> (aTail.Ptr());

    TPtrC16 tail(ptr16, aTail.Size() >> 1);

    if (aDocumentName.Compare(KVRCommandRecord) == 0 || tail.Compare(

            KVRCommandRecord) == 0)

        {

        // Enter recording context

        ActivateLocalViewL(TUid::Uid(KVRRecorderViewUID), TUid::Uid(

                EContextRecordNewNormal), KNullDesC8);

        return EFalse;

        }

        ActivateLocalViewL(TUid::Uid(KVRRecorderViewUID), TUid::Uid(

                EContextEmptyNormal), KNullDesC8);