1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Part of the MVS Application for TechView

    15 //

    16 

    17 #include <techview/eikfnlab.h>

    18 #include <techview/eikcfdlg.h>

    19 #include <techview/eikbtgpc.h>

    20 #include <techview/eikdialg.h>

    21 #include <techview/eikon.rsg>

    22 #include <eikmobs.h>

    23 #include <coecntrl.h>

    24 #include <eikenv.h>

    25 #include "MVSAppUI.h"

    26 #include "MVSApp.hrh"

    27 #include "MVSViewTicker.h"

    28 #include "MVSConstants.h"

    29 #include "MVSVolumeDialog.h"

    30 #include "MVSBalanceDialog.h"

    31 #include "MVSRepeatDialog.h"

    32 #include "MVSSelectPluginsDialog.h"

    33 #include "MVSSaveAsDialog.h"

    34 #include "MVSEditMetaInfoDialog.h"

    35 #include "MVSConfigAudioFormatDialog.h"

    36 #include "MVSConfigVideoFormatDialog.h"

    37 #include "MVSSystemInfoDialog.h"

    38 #include "MVSVideoSettingDialog.h"

    39 #include "MVSAudioSettingDialog.h"

    40 #include "MVSSetPlayWindowDialog.h"

    41 #include "MVSViewMetaInfoDialog.h"

    42 #include "MVSCropDialog.h"

    43 #include "MVSMultipleScreenDialog.h"

    44 #include "MVSResourceNotifyDialog.h"

    45 

    46 const TInt KMaxSupportedPlugins = 10;

    47 const TInt KMaxSupportedExtension = 10;

    48 const TInt KMaxSupportedCodecs = 10;

    49 const TInt KLabelCaptionMaxLength = 16;

    50 const TInt KTimeValueLength = 12;

    51  

    52 void CMVSAppUi::ConstructL()

    53 	{

    54    	CEikAppUi::ConstructL();

    55   	User::LeaveIfError(iLogs.Connect());

    56   	iLogs.MkDirAll(KLogsPath);

    57   	iButtons=iEikonEnv->AppUiFactory()->ToolBar();

    58   	//Meta entry initialization	                                         

    59   	iMetaTitle = CMMFMetaDataEntry::NewL(KTitle,Ka);

    60     iMetaAuthor = CMMFMetaDataEntry::NewL(KAuthor,Ka);

    61   	iMetaCopyright = CMMFMetaDataEntry::NewL(KCopyrt,Ka);

    62   	iMetaRevision = CMMFMetaDataEntry::NewL(KRevision,Ka);

    63   	iMetaCategory = CMMFMetaDataEntry::NewL(KCategory,Ka);

    64   	iMetaComments = CMMFMetaDataEntry::NewL(KComments,Ka);

    65   	iVideoPlayAgent = CMVSVideoPlayAgent::NewL(*this);

    66   	iAppView = CMVSAppView::NewL(ClientRect(), *iVideoPlayAgent);

    67   	iPluginArray = new(ELeave) CDesCArrayFlat(KMaxSupportedPlugins);

    68   	iExtArray = new(ELeave) CDesCArrayFlat(KMaxSupportedExtension);

    69   	iCodecArray = new(ELeave) CDesCArrayFlat(KMaxSupportedCodecs);

    70   	iAudioPlayAgent = CMVSAudioPlayAgent::NewL(*this);

    71   	iAudioRecordAgent = CMVSAudioRecordAgent::NewL(*this);

    72   	iVideoRecordAgent = CMVSVideoRecordAgent::NewL(*this);

    73   	iPluginInfo=CMVSControllerPluginInfo::NewL();

    74   	iAutoplay = EFalse;

    75   	iMode=EIdle;

    76   	User::LeaveIfError(iLogger.Connect());

    77   	iLogger.CreateLog(KLogsDir,KLogsFile,EFileLoggingModeAppend);

    78   	iSettingManager = CSettingsManager::NewL();

    79   	iRepeatDelay = 1000000;//initial value of 1 second in microseconds.

    80   	iPriority = 1;//default settings

    81     iPriorityPreference = EMdaPriorityPreferenceNone;//default settings

    82     iRotation = EVideoRotationNone;//default settings

    83     iNoRepeats = 0;

    84 	iScreenNumber = 0;

    85   	if(!iSettingManager->FileExists())

    86   		{

    87   		iSettingManager->MakeSeedIndexL();

    88   		}

    89   	iSettingManager->ReadGeneralSettingsL(this);

    90  	iSelectedPluginIdx = -1;

    91   	iMediaType = 0; //set audio media initially

    92  	iPluginsCnt = iPluginInfo->GetPluginListL(iPluginArray,iUidArray );

    93   	iControllerUid = TUid::Null();

    94   	iViewTicker = CMVSViewTicker::NewL(this);

    95 

    96 	// Add one video control per screen

    97 	// except for screen 0 which already has a video control

    98 	// via the app view

    99 	const TInt numScreens = CCoeEnv::Static()->WsSession().NumberOfScreens();

   100 

   101 	for(TInt i = 1; i < numScreens; ++i)

   102 		{

   103 		CMVSVideoControl* videoCtl = CMVSVideoControl::NewLC(*iVideoPlayAgent, i, *(CCoeEnv::Static()->RootWin(i)));

   104 		CWsScreenDevice* screenDevice = new (ELeave) CWsScreenDevice(CCoeEnv::Static()->WsSession());

   105 		CleanupStack::PushL(screenDevice);

   106 		User::LeaveIfError(screenDevice->Construct(i));

   107 		videoCtl->SetExtent(TPoint(0, 0), screenDevice->SizeInPixels());

   108 		CleanupStack::PopAndDestroy(screenDevice);

   109 		videoCtl->ActivateL();

   110 		iVideoCtls.AppendL(videoCtl);

   111 		CleanupStack::Pop(videoCtl);

   112 		}

   113 

   114 	iVideoCtl = iAppView->iMainWindowControl;

   115 	iLogger.Write(_L("Application START"));

   116   	iSrcFName.Copy(KDefault);

   117   	iDestFilename = KDefault;

   118   	iRecordLimitSet = EFalse;

   119 	iAlreadyRegistered = EFalse;

   120   	}

   121 

   122 CMVSAppUi::CMVSAppUi()

   123 :iVolumeOrGain(10),iNoRepeats(0),iMainWindowText(8), iMaxFileBuffer(0)

   124 #ifdef SYMBIAN_BUILD_GCE

   125 	,iAutoScaleType(EAutoScaleNone),

   126     iAutoScaleHorizPos(EHorizontalAlignCenter),

   127     iAutoScaleVertPos(EVerticalAlignCenter)

   128 #endif

   129 	{		

   130 	}

   131 

   132 CMVSAppUi::~CMVSAppUi()

   133 	{

   134 	delete iAudioPlayAgent;

   135 	delete iAudioRecordAgent;

   136 	delete iVideoPlayAgent;

   137 	delete iVideoRecordAgent;

   138 	iUidArray.Close();

   139 	iAudioUidArray.Close();

   140 	iVideoUidArray.Close();

   141 	iAudioPlayUidArray.Close();

   142 	iOverlayText.Close();

   143 	delete iPluginInfo;

   144 	delete iPluginArray;

   145 	delete iExtArray;

   146 	delete iCodecArray;

   147 	delete iMetaTitle;

   148 	delete iMetaAuthor;   

   149 	delete iMetaCopyright;

   150 	delete iMetaRevision;

   151 	delete iMetaCategory;

   152 	delete iMetaComments;

   153 	iMainWindowText.Reset();

   154 	if(iLogger.Handle())

   155 		{

   156 		iLogger.CloseLog();

   157 		iLogger.Close();	

   158 		}

   159 	iLogs.Close();

   160 	delete iViewTicker;

   161 	delete iSettingManager;

   162 	iVideoCtls.ResetAndDestroy();

   163     delete iAppView;

   164 	}

   165 

   166 //All the user actvated actions in the UI is captured and handled 

   167 //through here

   168 void CMVSAppUi::HandleCommandL(TInt aCommand)

   169 	{

   170 	TBool needsUpdating = ETrue;

   171 	switch (aCommand)

   172     	{

   173      	case EMVSCmdNew:

   174            	{

   175            	if( iMode != EIdle )

   176            		{

   177            		return;//dont get into record mode,as the system is still in a previous active state,Playing/Recording.

   178            		}

   179            	FileOpenForRecordL();

   180            	}

   181    	    	break;

   182         

   183         

   184         case EMVSCmdOpen:

   185         	{

   186         	if(iState == EAudioPlaying || iState == EVideoPlaying || iState == EAudioRecording || iState == EVideoRecording || iMode == EVideoRecord || iMode == EAudioRecord)

   187            		{

   188            		return;//dont get into record mode,as the system is still in a previous active state,Playing/Recording.

   189            		}

   190         	Reset();

   191         	FileOpenL();

   192     	 	iLogger.Write(_L("Opened for Play"));

   193        	  	}

   194        	  	break;	

   195         	

   196     	case EMVSCmdMultiScreen:

   197     		{

   198     	 	iSetScreen->SetupDialogLD(iScreenNumber,this);	

   199     		}

   200     		break;

   201     		

   202     	case EMVSRegisterForNotification:

   203     		{

   204     		iRegisterForNotification->SetupDialogLD(this);

   205     		}

   206     		break;

   207     		

   208         case EMVSCmdSetVolume:

   209         	{

   210         	if((iMode == EAudioPlay) || (iMode == EVideoPlay))

   211 	        	{

   212 	        	iVolumeDialog->SetupDialogLD(iVolumeOrGain,0,0, ETrue, this);	

   213 	        	iLogger.Write(_L("volume set"));

   214 	        	}

   215         	else if((iMode == EAudioRecord)||(iMode == EVideoRecord))

   216         		{

   217         		iVolumeDialog->SetupDialogLD(iVolumeOrGain,0,0, EFalse, this);

   218         		iLogger.Write(_L("gain set"));

   219         		}

   220            	}

   221            	break;

   222         	

   223         	

   224         case EMVSCmdSetPlayBalance:

   225          	{

   226          	iBalanceDialog->SetupDialogLD(iBalance,this, ETrue);    

   227          	iLogger.Write(_L("Balance Set"));    

   228            	}

   229            	break;

   230          	

   231         

   232         case EMVSCmdSetRecordBalance:

   233          	{

   234          	iBalanceDialog->SetupDialogLD(0,this, EFalse);    

   235         	}

   236         	break;

   237          	

   238          	     

   239         case EMVSCmdSetRepeats:

   240           	{

   241          	iRepeatDialog->SetupDialogLD(iNoRepeats,iRepeatDelay, this);

   242          	iLogger.Write(_L("Repeats Set"));	

   243          	}

   244         	break;

   245        

   246         case EMVSCmdEditMetadata:

   247             {

   248             iMetaArray.Reset();

   249             if(iMetaArray.Count() == 0)

   250             	{

   251               	InitializeMetaArrayL();

   252               	}

   253             switch(iMode)

   254             	{

   255             	case EAudioRecord:

   256             	case EVideoRecord:

   257             		{

   258             		iEditMetaInfoDialog->SetupDialogLD(iMetaArray,this);

   259          			iLogger.Write(_L("MetaData Edited"));

   260             		iMetaArray.Close();	

   261             		}

   262             	break;

   263             	

   264             	case EAudioPlay:

   265             	case EVideoPlay:

   266             		{

   267             		iViewMetaInfoDialog->SetupDialogLD(iMetaArray,this);

   268          			iLogger.Write(_L("MetaData View"));

   269             		iMetaArray.Close();	

   270             		}

   271             	}

   272             }

   273             break;

   274         

   275         

   276         case EMVSCmdExit:

   277             {

   278 			if (iDisplayAdded)

   279               	{

   280 				iVideoPlayAgent->RemoveDisplayWindowL(iVideoCtl->ControlWindow());

   281 				iVideoPlayAgent->RemoveDisplayWindowL(iVideoCtl->Pip().ControlWindow());

   282 				iVideoPlayAgent->RemoveDisplay(iVideoCtl->ScreenNumber());

   283 				iVideoCtl->Pip().Clear();

   284 				iDisplayAdded = EFalse;

   285               	}

   286             

   287             iLogger.Write(_L("Application EXIT"));

   288   		  	iSettingManager->WriteGeneralSettingsL(this);

   289         	Exit();

   290             }

   291             break;

   292     	

   293     	

   294     	case EMVSCmdPlay:

   295     		{

   296 	    	if(!iButtons->IsCommandDimmed(EMVSCmdPlay))

   297 	    		{

   298 	    	 	switch(iMode)

   299 					{

   300 					case EAudioPlay:

   301 						{

   302 						iAppView->iStatusWindowTimeControl->ResetText2L();

   303 						SetVolumeL(iVolumeOrGain,0);

   304 						iButtons->DimCommand(EMVSCmdRecord, ETrue);

   305 						iButtons->DrawNow();

   306 						if(iState == ENotReady)

   307 							{

   308 							FileOpenL();	

   309 							iAutoplay=ETrue;

   310 							}

   311 						else

   312 							{

   313 							iAudioPlayAgent->Play();	

   314 							iLogger.Write(_L("Playing using AudioPlayAgent"));

   315 							}	

   316 						}

   317 					break;

   318 

   319 					case EAudioRecord:

   320 						{

   321 						iAppView->iStatusWindowTimeControl->ResetText2L();

   322 						SetVolumeL(iVolumeOrGain,0);

   323 						iAudioRecordAgent->PlayL();

   324 						iLogger.Write(_L("Playing using AudioRecordAgent"));

   325 						}

   326 					break;

   327 

   328 					case EVideoPlay:

   329 						{						

   330 						if (iVideoPlayAgent->AudioEnabledL())

   331 							{

   332 							SetVolumeL(iVolumeOrGain, 0);

   333 							}

   334 						iButtons->DimCommand(EMVSCmdSetRepeats, ETrue);

   335 						iButtons->DrawNow();

   336 						

   337 #ifdef SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS

   338                         if (iVideoPlayAgent->SupportVideoPlayerUtility2())

   339                             {

   340 							PrepareVideoControlsL();                        				

   341 		                    }

   342 #endif // SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS

   343 					    iVideoPlayAgent->Play();

   344                         iLogger.Write(_L("Playing using VideoPlayAgent"));						    

   345 						}

   346 					    break;

   347 					

   348 					case EIdle:

   349 					case EVideoRecord:

   350 						break;

   351 					

   352 					default:

   353 						ASSERT(EFalse);

   354 					break;

   355 					}

   356     			}

   357     		else

   358     			{

   359     			needsUpdating = EFalse;

   360     			}

   361     		}

   362     		break;

   363     	

   364     	

   365     	case EMVSCmdRecord:

   366     	 	{

   367     	 	if(!iButtons->IsCommandDimmed(EMVSCmdRecord))

   368     	 		{

   369     	 		switch(iMode)

   370 	    			{

   371 	    			case EAudioRecord:

   372 		    			{

   373 		    			iAudioRecordAgent->RecordL();

   374 		    			iLogger.Write(_L("Recording using AudioRecordAgent"));	

   375 		    			iButtons->DimCommand(EMVSCmdRecord, ETrue);

   376 	                  	iButtons->DimCommand(EMVSCmdPlay, ETrue);

   377 	                  	iButtons->DrawNow();

   378 		    			}

   379 	    				break;	

   380 	    			case EVideoRecord:

   381 		    			{

   382 		    			//start view finder and record

   383 		    			CCamera *camera = iVideoRecordAgent->Camera();

   384 		    			TSize imageSize;

   385 						camera->EnumerateCaptureSizes(imageSize,1,CCamera::EFormatFbsBitmapColor16M);

   386 						TPoint pos = DrawBorders(imageSize);

   387 						TRect clientRect = ClientRect();

   388 						pos.iY += clientRect.iTl.iY;//add y-offset for menu bar

   389 						TRect screenRect(pos,imageSize);

   390 						TRect clipRect = screenRect ;

   391 						if (!camera->ViewFinderActive())

   392 							{

   393 							CCoeEnv *coenv = iAppView->iMainWindowControl->ControlEnv();

   394 							camera->StartViewFinderDirectL( coenv->WsSession(),

   395 															*coenv->ScreenDevice(),

   396 															*iAppView->DrawableWindow(),

   397 															screenRect,

   398 															clipRect);

   399 							}

   400 		    			if (!iFileReplace)

   401 		    				{

   402 		    				SetVideoFrameRateL(iVideoFrameRate);

   403 		    				SetVideoFrameSizeL(iFrameSize);

   404 		    				SetAudioEnabledL(iAudioEnabled);

   405 		    				}

   406 		    			iVideoRecordAgent->Record();

   407 		    			iLogger.Write(_L("Recording using VideoRecordAgent"));	

   408 		    			iButtons->DimCommand(EMVSCmdRecord, ETrue);

   409 	                  	iButtons->DimCommand(EMVSCmdPlay, ETrue);

   410 	                  	iButtons->DrawNow();

   411 		    			}

   412 		    			break;

   413 	    			default:

   414 	    				ASSERT(EFalse);

   415 	    				break;	

   416 	    			} 			

   417     	 	 	}

   418     	 	else

   419     	 		{

   420     	 		needsUpdating = EFalse;

   421     	 		}

   422     	 	}

   423     	 	break;	

   424         

   425         

   426         case EMVSCmdPause:

   427         	{

   428         	if(!iButtons->IsCommandDimmed(EMVSCmdPause))

   429 	        	{

   430 	        	switch(iMode)

   431 	        		{

   432 	        		case EAudioPlay:

   433 	        			{

   434 	        			iAudioPlayAgent->Pause();

   435 	        			iLogger.Write(_L("AudioPlayAgent Paused"));	

   436 	        			iButtons->DimCommand(EMVSCmdPlay, EFalse);

   437 	        			iButtons->DrawNow();

   438 	        			}

   439 	        			break;

   440 	        		

   441 	        		case EAudioRecord:

   442 	          	    	{

   443 	          	    	User::InfoPrint(KNotsupported);		

   444 	          	    	}

   445 	        			break;

   446 	        			

   447 	        		case EVideoPlay:

   448 	        		    {

   449 	        		    iVideoPlayAgent->PauseL();

   450 	        		    iLogger.Write(_L("AudioPlayAgent Paused"));	

   451 	        		    iButtons->DimCommand(EMVSCmdPlay, EFalse);

   452 	        			iButtons->DrawNow();

   453 	        		    }

   454 	        		    break;

   455 	        		    

   456 	        		case EVideoRecord:

   457 	          	    	{

   458 	          	    	iVideoRecordAgent->PauseL();

   459 	          	    	iLogger.Write(_L("VideoRecordAgent Paused"));	

   460 	          	    	iButtons->DimCommand(EMVSCmdRecord, EFalse);

   461 	          	        iButtons->DrawNow();

   462 	          	    	}

   463 	        			break;

   464 	        		

   465 	        		case EIdle:

   466 						break;

   467 	        		

   468 	        		default:

   469 	        			ASSERT(EFalse);

   470 	        			break;

   471 	        		}	

   472 	        	}

   473         	else

   474         		{

   475         		needsUpdating = EFalse;

   476         		}	

   477         	}

   478         	break;

   479     	

   480     	

   481     	case EMVSCmdStop:

   482     	    {

   483     	    if(!iButtons->IsCommandDimmed(EMVSCmdStop))

   484 	    	    {

   485 	    	    switch(iMode)

   486 	        		{

   487 	        		case EAudioPlay:

   488 	        			{

   489 	        			iAudioPlayAgent->Stop();

   490 	        			iLogger.Write(_L("AudioPlayAgent Stopped"));	

   491 	        			iButtons->DimCommand(EMVSCmdPlay, EFalse);

   492 	        			iButtons->DrawNow();

   493 	        			}

   494 	        			break;

   495 	        		

   496 	        		case EAudioRecord:

   497 	        			{

   498 	        			iAudioRecordAgent->Stop();

   499 	        		   	iLogger.Write(_L("AudioRecordAgent Stopped"));	

   500 	        			iButtons->DimCommand(EMVSCmdRecord, EFalse);

   501 	        			iButtons->DrawNow();

   502 	        			iButtons->DimCommand(EMVSCmdPlay, EFalse);

   503 	        			iButtons->DrawNow();

   504 	        			}

   505 	        			break;

   506 	        		

   507 	        		case EVideoPlay:

   508 	        		    {

   509 	        		    iVideoPlayAgent->Stop();	

   510 	        		    iLogger.Write(_L("VideoPlayAgent Stopped"));	

   511 	        		    iButtons->DimCommand(EMVSCmdPlay, EFalse);

   512 	        			iButtons->DrawNow();

   513 	        		    iAppView->DrawNow();

   514 	        		    }

   515 	        			break;

   516 	        			

   517 	        		case EVideoRecord:

   518 	        			{

   519 	        			StopViewFinder();

   520 	        			iVideoRecordAgent->Stop();

   521 	        			iLogger.Write(_L("VideoRecordAgent Stopped"));		

   522 	        			iButtons->DimCommand(EMVSCmdRecord, EFalse);

   523 	        			iButtons->DrawNow();

   524 	        			}

   525 	        			break;

   526 	        		

   527 	        		case EIdle:

   528 	        			break;

   529 	        		

   530 	        		default:

   531 	        			ASSERT(EFalse);

   532 	        			break;

   533 	        		}		

   534 	    	    }

   535     	    else

   536     	    	{

   537     	    	needsUpdating = EFalse;

   538     	    	}

   539     	    }

   540          	break;

   541      

   542      

   543         case EMVSCmdSetPlayWindow:

   544        		{

   545        		iSetPlayWindow->SetupDialogLD(iStart,iEnd,iDuration,this);

   546        	    iLogger.Write(_L("AudioPlayAgent SetPlayWindow"));	

   547        		}

   548     		break;

   549     

   550     

   551     	case EMVSCmdClearPlayWindow:

   552     		{

   553     		iStart = 0;

   554     		iEnd = iAudioPlayAgent->Duration();

   555     		iAudioPlayAgent->ClearPlayWindow();

   556     	    iLogger.Write(_L("AudioPlayAgent ClearPlayWindow"));	

   557     		}

   558     		break;

   559 

   560     

   561        	case EMVSCmdSystemInfo:

   562     		{

   563     		iSystemInfo->SetupDialogLD(this);

   564     		iLogger.Write(_L("System Info"));

   565     		}

   566     		break;

   567     	

   568     	

   569     	case EMVSVideoCmdSettings:

   570     		{

   571             if (iVideoPlayAgent->SupportVideoPlayerUtility2())

   572                 {

   573 	    		iVideoSetting->SetupDialogLD(iRotation, this, iVideoExtent, iWindowClipRect, ETrue, iPip, iCrp);

   574                 }

   575             else

   576                 {

   577 	    		iVideoSetting->SetupDialogLD(iRotation,this, TRect(0, 0, 0, 0), TRect(0, 0, 0, 0), EFalse, EFalse, iCrp);

   578                 }

   579     		iLogger.Write(_L("Video Settings"));

   580     		}

   581     		break;

   582     	

   583     	

   584     	case EMVSCmdAudioSetting:

   585     		{

   586     		iAudioSetting->SetupDialogLD(iNoRepeats,iRepeatDelay,iPriority,iPriorityPreference,iMaxFileBuffer, this);

   587     		iLogger.Write(_L("Audio Setting"));	

   588     		}

   589     		break; 

   590     	

   591     	

   592     	case EMVSCmdClose:

   593     		{

   594     		FileClose(); 

   595     		iRecordLimitSet = EFalse;	

   596     		}

   597     		break;

   598     	

   599     	

   600     	case EMVSCmdSetCropWindow:

   601     	    {

   602     	    iCropPosition=0;

   603     	    iCropStart=GetCropStart();

   604         	iClipLength = iAudioRecordAgent->Duration();

   605     	    iCropEnd=iClipLength;

   606     	    iCropDialog->SetupDialogLD(iCropPosition,iClipLength,0,iCropEnd,this);

   607     	    iLogger.Write(_L("CropWindow set"));	

   608     	    }

   609     	    break;

   610     		

   611     	case EMVSCmdClearLog:

   612     		{

   613     		

   614        		}

   615     		break;

   616 #ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

   617     	case EMVSCmdEnableSubtitles :

   618     		{

   619     		iVideoPlayAgent->EnableSubtitlesL();

   620     		}

   621     		break;

   622     	case EMVSCmdDisableSubtitles :

   623     		{

   624     		iVideoPlayAgent->DisableSubtitlesL();

   625     		}

   626     		break;

   627 #endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

   628     	}

   629     if(needsUpdating)

   630     	{

   631     	UpdateDisplayL(iState);

   632     	}

   633   	}

   634 

   635 void CMVSAppUi::PrepareVideoControlsL()

   636 	{

   637 	if (iDisplayAdded)

   638 		{

   639 		iVideoPlayAgent->RemoveDisplayWindowL(iVideoCtl->ControlWindow());

   640 		iVideoPlayAgent->RemoveDisplay(iVideoCtl->ScreenNumber());

   641 		TRAP_IGNORE(iVideoPlayAgent->RemoveDisplayWindowL(iVideoCtl->Pip().ControlWindow()));

   642 		iDisplayAdded = EFalse;

   643 		}

   644 

   645 	iVideoCtl = iAppView->iMainWindowControl;

   646 

   647 	CCoeEnv* env = CCoeEnv::Static();

   648 

   649 	if (iScreenNumber > 0)

   650 		{

   651 		// Video ctls start at 0 in index for display 1

   652 		iVideoCtl = iVideoCtls[iScreenNumber - 1];

   653 		}

   654 

   655 	TRect extent = iVideoExtentSet ? iVideoExtent : iVideoCtl->Rect();

   656 	TRect clip = iWindowClipRectSet ? iWindowClipRect : iVideoCtl->Rect();

   657 	iVideoPlayAgent->AddDisplayWindowL(env->WsSession(), *(env->ScreenDevice(iScreenNumber)), iVideoCtl->ControlWindow(), extent, clip);

   658 	iDisplayAdded = ETrue;

   659 

   660 	if (iPip)

   661 		{

   662 		// Picture-in-picture has been enabled.

   663 		TSize videoFrameSize;

   664 		iVideoPlayAgent->VideoFrameSizeL(videoFrameSize);

   665 		TSize winSize = iVideoCtl->Size();

   666 	

   667 		// Picture-in-picture should be an 8th of original	

   668 		videoFrameSize.iHeight /= 4;

   669 		videoFrameSize.iWidth /= 4;

   670 		

   671 		TPoint pipLoc(winSize.iWidth - (videoFrameSize.iWidth + 4), 4);

   672 

   673 		iVideoCtl->Pip().SetExtent(pipLoc, videoFrameSize);

   674 

   675 		if (iCrp)

   676 			{

   677 			iVideoCtl->EnablePip(CMVSPipControl::EUseCrp);

   678 			iVideoPlayAgent->AddDisplayL(env->WsSession(), iScreenNumber, iVideoCtl->Pip());

   679 			}

   680 		else

   681 			{

   682 			iVideoCtl->EnablePip(CMVSPipControl::EUseMmf);

   683 			iVideoPlayAgent->AddDisplayWindowL(env->WsSession(), *(env->ScreenDevice(iScreenNumber)), iVideoCtl->Pip().ControlWindow());

   684 			iVideoPlayAgent->SetAutoScaleL(iVideoCtl->Pip().ControlWindow(), EAutoScaleBestFit, EHorizontalAlignCenter, EVerticalAlignCenter);

   685 			}

   686 		}

   687 	else

   688 		{

   689 		// Picture-in-picture has been disabled.

   690 		iVideoCtl->DisablePip();

   691 		}

   692 	}

   693 

   694 void CMVSAppUi::SetPosition(TTimeIntervalMicroSeconds& aPos)

   695 	{

   696 	if(iMode == EAudioPlay)

   697 		{

   698 		iAudioPlayAgent->SetPosition(aPos);

   699 		}

   700 	else if(iMode == EAudioRecord)

   701 		{

   702 		iAudioRecordAgent->SetPosition(aPos);

   703 		}

   704 	}

   705   	

   706 //Opens a file for playing

   707 void CMVSAppUi::FileOpenL()

   708 	{

   709 	//Open the file dialog

   710     CEikFileOpenDialog* dialog = new (ELeave) CEikFileOpenDialog(&iSrcFName);  

   711     TInt val = dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN);

   712 	if(val != 0)

   713 	    {

   714 	    TUid mediatype = iPluginInfo->GetMediaTypeL(iSrcFName);

   715 	    if(mediatype == KUidMediaTypeVideo)

   716 			{

   717 		    TRect rect, clipRect;

   718 		    rect = clipRect = TRect(iAppView->iMainWindowControl->PositionRelativeToScreen(), iAppView->iMainWindowControl->Size());

   719 

   720 			rect.Shrink(2,2);

   721 		    clipRect.Shrink(2,2);

   722 		    

   723             // Clear the area where the video will be displayed 

   724 #ifdef SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS

   725         	iVideoPlayAgent->SetVideoOutputL(iCoeEnv->WsSession(),

   726 											 *iCoeEnv->ScreenDevice(iScreenNumber),

   727 											 iVideoCtl->ControlWindow(),

   728 											 rect, 

   729 											 clipRect);

   730 #else

   731         	iVideoPlayAgent->SetVideoOutputL(iCoeEnv->WsSession(),

   732 											 *iCoeEnv->ScreenDevice(),

   733 											 iVideoCtl->ControlWindow(),

   734 											 rect, 

   735 											 clipRect);

   736 #endif // SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS

   737 

   738 		    TInt res = iVideoPlayAgent->SetScreenNumber(iScreenNumber);

   739 			if(res == KErrNotSupported)

   740 				{

   741 				User::InfoPrint(KMultiScreenNotsupported);

   742 				}

   743 			//Enable AP&R for register notification made before opening the file

   744 			if(iRegistered)

   745 				{

   746 				TInt regerr = iVideoPlayAgent->RegisterForNotification();	

   747 				if(regerr == KErrNone)

   748 					{

   749 					User::InfoPrint(KRegisterSuccess);

   750 					}

   751 				else

   752 					{

   753 					User::InfoPrint(KRegisterFailure);	

   754 					}

   755 				}

   756 			else if(iAlreadyRegistered)

   757 				{

   758 				TInt cancelerr = iVideoPlayAgent->CancelNotification();

   759 				if(cancelerr == KErrNone)

   760 					{

   761 					iAlreadyRegistered = EFalse;	

   762 					User::InfoPrint(KRegisterCancelation);

   763 					}

   764 				else

   765 					{

   766 					User::InfoPrint(KCancelationFailure);	

   767 					}

   768 				}	

   769 		    iVideoPlayAgent->OpenFileL(iSrcFName);

   770 		    iMode = EVideoPlay;	

   771 		    }

   772 	    else if(mediatype == KUidMediaTypeAudio)

   773 		    {

   774 			iAudioPlayAgent->OpenFileL(iSrcFName);

   775 			iMode = EAudioPlay;

   776 	    	iButtons->DimCommand(EMVSCmdSetVolume,EFalse);

   777 			iButtons->DrawNow();

   778 	    	}

   779 	    else

   780 	    	{

   781 			User::InfoPrint(KNotSupported);    	

   782 	    	}   

   783 	 	}

   784     return;

   785 	}

   786 

   787 //Opens a new or existing file to record.	

   788 void CMVSAppUi::FileOpenForRecordL()

   789 	{

   790    	iExtArray->Reset();

   791   	iPluginArray->Reset();

   792     iCodecArray->Reset();

   793    	iSelectedPluginIdx = KBeforeSelectingController;

   794     iSelectPluginsDialog->SetupDialogLD(iPluginArray,iExtArray, iCodecArray, this);

   795     //Indicates that the controller wasnt selected, leave it to the MMF to select

   796     //tha appropriate controller.

   797     if(iSelectedPluginIdx == KControllerNotSelected)

   798     	{

   799     	iControllerUid = TUid::Null();

   800     	}

   801     else

   802     	{

   803     	if(iMediaType)

   804     		{

   805     		iControllerUid = iVideoUidArray[iSelectedPluginIdx];

   806     		}

   807     	else

   808     		{

   809     		iControllerUid = iAudioUidArray[iSelectedPluginIdx];				

   810     		}

   811     	}

   812     if(!iMediaType)

   813     	{

   814         iMode = EAudioRecord;

   815         }

   816     else if(iMediaType)

   817     	{

   818 		iMode = EVideoRecord;        		

   819         }	

   820     SaveAsDialogL();

   821     }

   822     

   823 void CMVSAppUi::FileClose()    

   824 	{

   825 	iButtons->DimCommand(EMVSCmdSetVolume, ETrue);

   826     iButtons->DimCommand(EMVSCmdRecord, ETrue);

   827 	switch(iMode)

   828    		{

   829 	    case EAudioPlay:

   830 	    	{

   831 	        iAudioPlayAgent->Stop();

   832 	        iLogger.Write(_L("AudioPlayAgent Close"));	

   833 	        }

   834 	        break;

   835 	        		

   836 	    case EAudioRecord:

   837 	     	{

   838 	     	iAudioRecordAgent->Stop();

   839 	        iLogger.Write(_L("AudioRecordAgent Close"));	

   840 	        }

   841 	        break;

   842 	        

   843 	    case EVideoPlay:

   844 	    	{

   845 	        iVideoPlayAgent->Close();

   846 	        iLogger.Write(_L("VideoPlayAgent Close"));		

   847 	        iAppView->DrawNow();

   848 	        }

   849 	        break;

   850 	        	    

   851 	    case EVideoRecord:

   852 	    	{

   853 	        iVideoRecordAgent->Close();	

   854 	        iLogger.Write(_L("VideoRecordAgent Close"));		

   855 	        }

   856 	        break;

   857 	        		

   858 	    default:

   859 	        break;

   860 	    }

   861 	Reset();	

   862 	}

   863 	

   864 	

   865 void CMVSAppUi::SaveAsDialogL()

   866 	{

   867 	iFileReplace = ETrue;

   868 	TInt errVal = iSaveAsDialog->SetupDialogLD(iDestFilename, &iFileReplace);

   869     if(errVal)

   870     	{

   871     	DetermineFinalFNameL();

   872     	if(iProceed)

   873     		{

   874         	iOpeningForRecord=ETrue;

   875         	RFs fs = CCoeEnv::Static()->FsSession();

   876         	if(iMode==EAudioRecord)

   877 	    		{

   878 	    		TInt uidcount = iAudioPlayUidArray.Count();

   879 	    		TUid playcontrollerUid = TUid::Null();

   880 	    		if(uidcount)

   881 		    		{

   882 		    		playcontrollerUid = iAudioPlayUidArray[0];

   883 		    		}

   884  		    	if(iFileReplace)

   885 		    		{

   886 		    		fs.Delete(iDestFilename);

   887 		    		}

   888 		    	iAudioRecordAgent->CreateNewFileL(iDestFilename,iControllerUid,playcontrollerUid);	

   889 		    	iLogger.Write(_L("Opened file for Audio Record"));

   890 		    	iRecFName.Copy(iDestFilename);

   891 	        	iButtons->DimCommand(EMVSCmdRecord, EFalse);

   892 	        	iButtons->DrawNow();

   893 		    	}

   894 		    	    	

   895         	else if(iMode==EVideoRecord)

   896 	    		{

   897 	    		if(iFileReplace)

   898 		    		{

   899 		    		fs.Delete(iDestFilename);

   900 		    		}

   901 	    		TInt err = iVideoRecordAgent->OpenFileL(iDestFilename,iControllerUid);

   902 	       		if(err != KErrNone)

   903 	      			{

   904 	       			iLogger.Write(_L("ECam Object creation failed"));

   905 	       			User::InfoPrint(KVideoError);

   906 	       			}

   907 	    		else

   908 	       			{

   909 	       			iLogger.Write(_L("Opened file for Video Record"));

   910 	       			iRecFName.Copy(iDestFilename);

   911         			iButtons->DimCommand(EMVSCmdRecord, EFalse);

   912         			iButtons->DrawNow();	

   913 	       			}

   914 	       		}

   915         	}

   916 		}

   917 	else

   918 		{

   919 		iMode = EIdle;

   920 		UpdateStateChange(ENotReady , KErrNone);

   921 		}

   922     }

   923 	

   924 //The state change calls from the agents

   925 void CMVSAppUi::UpdateStateChange(TMVSState aState, TInt aError)

   926 	{

   927 	TInt error = aError;

   928 	//if state changes from EVideoRecording and view finder is running, stop it.

   929 	if(iState == EVideoRecording && aState != EVideoRecording)

   930 		{

   931 		StopViewFinder();

   932 		}

   933 	//if playback stops, redraw the app view

   934 	if(iState == EVideoPlaying && aState != EVideoPlaying)

   935 		{

   936 		// the last frame is still on the display, but nothing is in charge

   937 		// of redrawing it. this would otherwise lead to graphical glitches

   938 		// as the frame is partially erased over time.

   939 		iAppView->iMainWindowControl->DrawNow();

   940 		}

   941 	iState=aState;

   942 	if(error == KErrNone)

   943 		{

   944 		if(aState == EAudioOpened)

   945 			{

   946 			iAppView->ResetProgressBar();

   947 	   		iButtons->DimCommand(EMVSCmdPlay,EFalse);

   948 	   		iButtons->DrawNow();

   949 	   		if(iMode == EAudioPlay)

   950 	   			{

   951 	   			iButtons->DimCommand(EMVSCmdRecord,ETrue);	

   952  				iDuration = iAudioPlayAgent->Duration();

   953  				if((iStart == 0) && (iEnd == 0))

   954 		   			{

   955 		   			iStart = 0;

   956 		   			iEnd = iDuration;	

   957 		   			}

   958 	   			}

   959          	if(iButtons->IsCommandDimmed(EMVSCmdSetRepeats))

   960          		{

   961          		iButtons->DimCommand(EMVSCmdSetRepeats,EFalse);	

   962          		iButtons->DrawNow();

   963          		}

   964          	if(iButtons->IsCommandDimmed(EMVSCmdSetPlayBalance))

   965          		{

   966          		iButtons->DimCommand(EMVSCmdSetPlayBalance,EFalse);	

   967          		iButtons->DrawNow();

   968          		}

   969 	   		//Provided to automatically start playing, when the play button is selected 

   970 			//without opening a file through the file menu.

   971 	   		if(iAutoplay)

   972 	   			{

   973 	   			iAudioPlayAgent->Play();

   974 	   			iAutoplay=EFalse;

   975 	   			}

   976 	   		if(iMode == EAudioRecord && !iOpeningForRecord)

   977 	   			{

   978 	   			iButtons->DimCommand(EMVSCmdRecord,EFalse);

   979 	   			iButtons->DimCommand(EMVSCmdPlay,EFalse);	

   980 	   			iButtons->DrawNow();

   981 	   			}

   982 	   		//Pop the Audio Record Settings Dialogue

   983 	   		if(iMode == EAudioRecord && iOpeningForRecord && iSelectedPluginIdx !=-2)

   984 	   			{

   985 	   			iButtons->DimCommand(EMVSCmdSetPlayBalance,EFalse);

   986 	   			if(iButtons->IsCommandDimmed(EMVSCmdRecord))

   987          			{

   988          			iButtons->DimCommand(EMVSCmdRecord,EFalse);

   989 		 			iButtons->DrawNow();	

   990          			}

   991 	   			//if appending to an existing file no need to re-enter the controller configuration.

   992 	   			if(iFileReplace)

   993 	   				{

   994 	   				if(!iMediaType && iSelectedPluginIdx !=-1)

   995 	         			{

   996 				 		TRAP(error, iConfigFormatDialog->SetupDialogLD(this,iAudioUidArray[iSelectedPluginIdx],iSettingManager) );

   997 				 		iOpeningForRecord = EFalse;

   998 				 	  	}

   999 	   				}

  1000 	   			}

  1001          	}

  1002 		else if(aState == EAudioPlaying)

  1003 			{

  1004 			iButtons->DimCommand(EMVSCmdPlay, ETrue);

  1005 			iButtons->DimCommand(EMVSCmdRecord,ETrue);

  1006 			iButtons->DimCommand(EMVSCmdPause, EFalse);

  1007 			iButtons->DimCommand(EMVSCmdStop, EFalse);

  1008 			iButtons->DrawNow();

  1009 	   		}

  1010 		else if(aState == ENotReady)

  1011 			{

  1012 			iButtons->DimCommand(EMVSCmdSetPlayBalance,EFalse);

  1013 			iButtons->DimCommand(EMVSCmdSetVolume, ETrue);

  1014             iButtons->DimCommand(EMVSCmdRecord, ETrue);

  1015             iButtons->DimCommand(EMVSCmdPlay, EFalse);

  1016             iButtons->DrawNow();

  1017 

  1018 			// File has been closed.  Remove the display window if it was added.

  1019 			if (iDisplayAdded)

  1020 				{

  1021 				TRAP(error, iVideoPlayAgent->RemoveDisplayWindowL(iVideoCtl->ControlWindow()));

  1022 				TRAP(error, iVideoPlayAgent->RemoveDisplayWindowL(iVideoCtl->Pip().ControlWindow()));

  1023 				iVideoPlayAgent->RemoveDisplay(iVideoCtl->ScreenNumber());

  1024 				iVideoCtl->Pip().Clear();

  1025 				iDisplayAdded = EFalse;

  1026 				}

  1027             }

  1028 		else if(aState == EAudioOpening)

  1029 			{

  1030 			iButtons->DimCommand(EMVSCmdSetVolume,EFalse);

  1031 	   		}

  1032 		else if(aState == EAudioPaused)

  1033 			{

  1034 			iButtons->DimCommand(EMVSCmdPause, ETrue);

  1035 	   		iButtons->DrawNow();

  1036 	   		}

  1037 		else if(aState == EAudioStopped)

  1038 			{

  1039 			iAppView->ResetProgressBar();

  1040 			iButtons->DimCommand(EMVSCmdStop, ETrue);

  1041 			iButtons->DimCommand(EMVSCmdPause, ETrue);

  1042 	   		iButtons->DrawNow();

  1043 			}

  1044 		else if(aState == EVideoPaused)

  1045 			{

  1046 			iButtons->DimCommand(EMVSCmdPause,ETrue);

  1047 			iButtons->DrawNow();

  1048 			}

  1049 		else if(aState == EVideoStopped)

  1050 			{

  1051 			iButtons->DimCommand(EMVSCmdStop,ETrue);

  1052 			iButtons->DimCommand(EMVSCmdPause, ETrue);

  1053 			iButtons->DrawNow();

  1054 			}

  1055 		else if(aState == EVideoPlaying)

  1056 			{

  1057 			iButtons->DimCommand(EMVSCmdPlay, ETrue);

  1058 			iButtons->DimCommand(EMVSCmdRecord,ETrue);

  1059 			iButtons->DimCommand(EMVSCmdPause,ETrue);

  1060 			iButtons->DimCommand(EMVSCmdStop,EFalse);

  1061 			iButtons->DrawNow();

  1062 			}

  1063 		else if(aState == EVideoRecording)

  1064 			{

  1065 			iButtons->DimCommand(EMVSCmdPlay, ETrue);

  1066 			iButtons->DimCommand(EMVSCmdRecord, ETrue);

  1067 			iButtons->DimCommand(EMVSCmdPause,EFalse);

  1068 			iButtons->DimCommand(EMVSCmdSetRepeats,ETrue);

  1069 			iButtons->DrawNow();

  1070 			}

  1071 		

  1072 		else if(aState == EAudioRecording)

  1073 			{

  1074 			iButtons->DimCommand(EMVSCmdPlay, ETrue);

  1075 			iButtons->DimCommand(EMVSCmdRecord,ETrue);

  1076 			iButtons->DimCommand(EMVSCmdPause,ETrue);

  1077 			iButtons->DrawNow();

  1078 			}

  1079 		else if(aState == EVideoOpened )

  1080 			{

  1081 			//Pop the Video Record Settings Dialogue

  1082 			iButtons->DimCommand(EMVSCmdPlay,EFalse);

  1083          	iButtons->DimCommand(EMVSCmdPause,ETrue);

  1084          	iButtons->DimCommand(EMVSCmdSetRepeats,ETrue);

  1085          	iButtons->DrawNow();

  1086 			if(iButtons->IsCommandDimmed(EMVSCmdSetPlayBalance))

  1087          		{

  1088          		iButtons->DimCommand(EMVSCmdSetPlayBalance,EFalse);	

  1089          		iButtons->DrawNow();

  1090          		}

  1091 			if(iMode==EVideoRecord && iOpeningForRecord)

  1092 				{

  1093 				iButtons->DimCommand(EMVSCmdSetPlayBalance,ETrue);

  1094 				if(iFileReplace)

  1095 	   				{

  1096 				if(iMediaType && iSelectedPluginIdx !=-1)

  1097 	        			{

  1098 		     			TRAP(error, iVideoFormatDialog->SetupDialogLD(this,iVideoUidArray[iSelectedPluginIdx],iSettingManager) );

  1099 		     			iOpeningForRecord=EFalse;

  1100 	         			}

  1101 	   				}

  1102 				}

  1103 			}

  1104 		if(error != KErrNone)		

  1105 			{

  1106 			LogErrors(error);		

  1107 			}

  1108 		}

  1109 	else if ((error == KErrEof) && (aState == EAudioStopped))

  1110 		{

  1111 		iButtons->DimCommand(EMVSCmdPlay, EFalse);

  1112 		iButtons->DimCommand(EMVSCmdRecord,ETrue);

  1113 		iButtons->DimCommand(EMVSCmdPause,EFalse);

  1114 		iButtons->DimCommand(EMVSCmdStop,EFalse);

  1115 		iButtons->DrawNow();

  1116 		}

  1117 	else	

  1118 		{

  1119 		LogErrors(error);

  1120 		}

  1121 	

  1122 	//As the state changes the display windows(views) contents also needs to be changed

  1123 	TRAPD(err,UpdateDisplayL(iState));

  1124 	if(err)

  1125 		{

  1126 		LogErrors(err);	

  1127 		iState = ENotReady;

  1128 		FileClose();

  1129 		}

  1130 	}

  1131 

  1132 void CMVSAppUi::MvsResourceNotification(const TDesC8& /*aNotificationData*/)

  1133 	{

  1134 	if(iMode == EVideoPlay)

  1135 		{