FCL/sf/app/videoplayer: comparison videoplayback/videohelix/tsrc/ut_videohelixtest/src/videohelixtestbody.cpp

equal deleted inserted replaced

-:3eb824b18d67
+:375929f879c2
 *
 * Description:  Test Harness for VideoHelixPlaybackPlugin
 *
 */
-// Version : %version: 27 %
+// Version : %version: e003sa33#24.1.1 %
 // [INCLUDE FILES] - do not remove
 #include <e32svr.h>
 #include <stifparser.h>
 ENTRY( "HandleVolume", CVHPPTestClass::HandleVolumeL ),
 ENTRY ("InitializeWithPositionL", CVHPPTestClass::InitializeWithPositionL),
 ENTRY ("InitializeLinkWithPositionL", CVHPPTestClass::InitializeLinkWithPositionL),
 ENTRY ("InitializeHandleWithPositionL", CVHPPTestClass::InitializeHandleWithPositionL),
-ENTRY ( "InitializeStreamingWithSdpFileHandleL", CVHPPTestClass::InitializeStreamingWithSdpFileHandleL ),
+ENTRY ( "InitializeStreamingWithSdpFileHandleL",
-ENTRY ( "RetrieveFileNameAndModeL", CVHPPTestClass::RetrieveFileNameAndModeL )
+		CVHPPTestClass::InitializeStreamingWithSdpFileHandleL ),
+ENTRY ( "RetrieveFileNameAndModeL", CVHPPTestClass::RetrieveFileNameAndModeL )
 //
 //  ADD NEW ENTRIES HERE
 //
 // ENTRY( "SendPlayCommandToServer",
 MPX_ENTER_EXIT(_L("CVHPPTestClass::InitializeL()"));
 iLog->Log(_L("CVHPPTestClass::InitializeL()"));
 TInt duration;
 TInt volumeSteps;
 TInt err = aItem.GetNextInt( duration );
 if ( err == KErrNone )
 {
 //
 event->iData  = duration;
 event->iError = KErrNone;
 AddExpectedEvent( event );
 //
 // read number of volume steps
 //
 err = aItem.GetNextInt( volumeSteps );
 if ( err == KErrNone )
 {
 //
 // set volume steps
 //
 SetVolumeSteps( volumeSteps );
 TBuf<120> fullPath;
 err = ReadFileInitializationParameters( aItem, fullPath );
 if ( err == KErrNone )
 {
 PreparePluginL();
 //
 //  Initalize the Plugin with a file name
 //
 MPX_DEBUG(_L("Initialize the Plugin:  filename = %S"), &fullPath);
 iLog->Log(_L("Initialize the Plugin:  filename = %S"), &fullPath);
 iPlaybackPlugin->InitialiseL( fullPath );
 }
 }
 }
 event->iData  = duration;
 event->iError = KErrNone;
 AddExpectedEvent( event );
 //
 // read number of volume steps
 //
 err = aItem.GetNextInt( volumeSteps );
 if ( err == KErrNone )
 {
 //
 // set volume steps
 //
 SetVolumeSteps( volumeSteps );
 TPtrC  link;
 //
 //  Read in the link from the config file
 //
 TInt err = aItem.GetNextString( link );
 if ( err == KErrNone )
 {
 TInt err = ReadInitializationErrors( aItem );
 if ( err == KErrNone )
 {
 PreparePluginL();
 //
 //  Extract the streaming link from the ram file and
 //  Initalize the Plugin with the link and an access point
 //
 MPX_DEBUG(_L("Initialize the Plugin:  link = %S"), &link);
 iLog->Log(_L("Initialize the Plugin:  link = %S"), &link);
 iPlaybackPlugin->InitStreamingL( link, KNullDesC8, 11 );
 }
 }
 }
 }
 iLog->Log(_L("CVHPPTestClass::InitializeHandleL()"));
 TInt duration;
 TInt volumeSteps;
 TInt fileHandle32;
 TInt err = aItem.GetNextInt( fileHandle32 );
 if ( err == KErrNone )
 {
 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
 //
 // set RFile as default if the 64-bit flag is not defined
 //
 fileHandle32 = ETrue;
 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
 err = aItem.GetNextInt( duration );
 if ( err == KErrNone )
 {
 //
 //  We will always get an Init Complete message out
 //
 TCallbackEvent* event = new TCallbackEvent;
 event->iEvent = EPInitialised;
 event->iData  = duration;
 event->iError = KErrNone;
 AddExpectedEvent( event );
 //
 // read number of volume steps
 //
 err = aItem.GetNextInt( volumeSteps );
 if ( err == KErrNone )
 {
 //
 // set volume steps
 //
 SetVolumeSteps( volumeSteps );
 TBuf<120> fullPath;
 err = ReadFileInitializationParameters( aItem, fullPath );
 if ( err == KErrNone )
 {
 PreparePluginL();
 RFs fs;
 TInt error = fs.Connect();
 //
 //  Open a file handle to the clip
 //
 if ( fileHandle32 )
 {
 User::LeaveIfError( file64.Open( fs, fullPath, EFileRead ) );
 iPlaybackPlugin->Initialise64L( file64 );
 file64.Close();
 }
 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
 //
 //  Initalize the Plugin with a file name
 //
 MPX_DEBUG(_L("Initialize the Plugin with File Handle:  filename = %S"), &fullPath);
 iLog->Log(_L("Initialize the Plugin with File Handle:  filename = %S"), &fullPath);
 fs.Close();
 }
 }
 }
 }
 return err;
 }
 TRect
 event->iEvent = EPMuteChanged;
 event->iData  = value;
 event->iError = KErrNone;
 AddExpectedEvent( event );
 }
-else
+				else
-{
+				{
-event->iEvent = EPSetComplete;
+					event->iEvent = EPSetComplete;
-event->iData  = property;
+					event->iData  = property;
-event->iError = KErrNone;
+					event->iError = KErrNone;
-AddExpectedEvent( event );
+					AddExpectedEvent( event );
-}
+				}
 }
 TRAP( err, iPlaybackPlugin->SetL( (TMPXPlaybackProperty)property, value ) );
 }
 }
 {
 MPX_ENTER_EXIT(_L("CVHPPTestClass::ConnectToDownloadL()"));
 iLog->Log(_L("CVHPPTestClass::ConnectToDownloadL()"));
 TInt err = KErrNone;
 #ifdef USE_S60_DOWNLOAD_MANAGER
 iDlMgrTester = CDlMgrTestClass::NewL();
 iDlMgrTester->AddStifObserver( this );
 TInt dlId;
 TPtrC filename;
 iPlaybackPlugin->CommandL( *cmd );
 CleanupStack::PopAndDestroy( cmd );
 }
 }
 #else // USE_S60_DOWNLOAD_MANAGER
-// suppress build warning
+	// suppress build warning
 MPX_DEBUG(_L("CVHPPTestClass::ConnectToDownloadL() : parsing type = %d"), aItem.ParsingType());
-// Signal TestScripter to continue from waittestclass
+	// Signal TestScripter to continue from waittestclass
 Signal();
 #endif // USE_S60_DOWNLOAD_MANAGER
 return err;
 }
 // -------------------------------------------------------------------------------------------------
 //   CVHPPTestClass::SendPdlCustomCommandL()
 CVHPPTestClass::SendPdlCustomCommandL( TMPXPlaybackPdCommand aCustomCmd )
 {
 MPX_ENTER_EXIT(_L("CVHPPTestClass::SendPdlCustomCommandL"),
 _L("aCustomCmd = %d"), aCustomCmd );
 #ifdef USE_S60_DOWNLOAD_MANAGER
 CMPXCommand* cmd = CMPXCommand::NewL();
 CleanupStack::PushL( cmd );
 cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
 cmd->SetTObjectValueL<TMPXPlaybackPdCommand>( KMPXCommandPlaybackGeneralType, aCustomCmd );
 iPlaybackPlugin->CommandL( *cmd );
 CleanupStack::PopAndDestroy( cmd );
 #else // USE_S60_DOWNLOAD_MANAGER
-// Signal TestScripter to continue from waittestclass
+	// Signal TestScripter to continue from waittestclass
 Signal();
 #endif // USE_S60_DOWNLOAD_MANAGER
 }
 // -----------------------------------------------------------------------------
 CVHPPTestClass::PauseDownloadL( CStifItemParser& /*aItem*/ )
 {
 MPX_ENTER_EXIT(_L("CVHPPTestClass::PauseDownloadL()"));
 iLog->Log(_L("CVHPPTestClass::PauseDownloadL()"));
 #ifdef USE_S60_DOWNLOAD_MANAGER
 TCallbackEvent* event = new TCallbackEvent;
 event->iEvent = EPDownloadStateChanged;
 event->iData  = EPbDlStateDownloadPaused;
 event->iError = KErrNone;
 AddExpectedEvent( event );
 iDlMgrTester->PauseDownload();
 #else // USE_S60_DOWNLOAD_MANAGER
-// Signal TestScripter to continue from waittestclass
+	// Signal TestScripter to continue from waittestclass
 Signal();
 #endif // USE_S60_DOWNLOAD_MANAGER
 return KErrNone;
 }
 // -----------------------------------------------------------------------------
 //  CVHPPTestClass::ResumeDownloadL
 {
 MPX_ENTER_EXIT(_L("CVHPPTestClass::ResumeDownloadL()"));
 iLog->Log(_L("CVHPPTestClass::ResumeDownloadL()"));
 TInt err = KErrNone;
 #ifdef USE_S60_DOWNLOAD_MANAGER
 TInt dlSize;
 err = aItem.GetNextInt( dlSize );
 if ( err == KErrNone )
 AddExpectedEvent( event );
 iDlMgrTester->ResumeDownload();
 }
 #else // USE_S60_DOWNLOAD_MANAGER
-// suppress build warning
+	// suppress build warning
 MPX_DEBUG(_L("CVHPPTestClass::ResumeDownloadL() : parsing type = %d"), aItem.ParsingType());
-// Signal TestScripter to continue from waittestclass
+	// Signal TestScripter to continue from waittestclass
 Signal();
 #endif // USE_S60_DOWNLOAD_MANAGER
 return err;
 }
 // -----------------------------------------------------------------------------
 //  CVHPPTestClass::CancelDownloadL
 CVHPPTestClass::CancelDownloadL( CStifItemParser& /*aItem*/ )
 {
 MPX_ENTER_EXIT(_L("CVHPPTestClass::CancelDownloadL()"));
 iLog->Log(_L("CVHPPTestClass::CancelDownloadL()"));
 #ifdef USE_S60_DOWNLOAD_MANAGER
 TCallbackEvent* event = new TCallbackEvent;
 event->iEvent = EPDownloadStateChanged;
 event->iData  = EPbDlStateDownloadCanceled;
 event->iError = KErrNone;
 AddExpectedEvent( event );
 iDlMgrTester->CancelDownload();
 #else // USE_S60_DOWNLOAD_MANAGER
-// Signal TestScripter to continue from waittestclass
+	// Signal TestScripter to continue from waittestclass
 Signal();
 #endif // USE_S60_DOWNLOAD_MANAGER
 return KErrNone;
 }
 // -----------------------------------------------------------------------------
 //  CVHPPTestClass::RetrievePdlStatusL
 {
 MPX_ENTER_EXIT(_L("CVHPPTestClass::RetrievePdlStatusL()"));
 iLog->Log(_L("CVHPPTestClass::RetrievePdlStatusL()"));
 TInt err = KErrNone;
 #ifdef USE_S60_DOWNLOAD_MANAGER
 TInt pdlState;
 TInt expectedPdlState;
 TInt downloadedBytes;
 TInt expectedDownloadedBytes;
 TInt downloadSize;
 }
 CleanupStack::PopAndDestroy( cmd );
 }
 #else // USE_S60_DOWNLOAD_MANAGER
-// suppress build warning
+	// suppress build warning
 MPX_DEBUG(_L("CVHPPTestClass::RetrievePdlStatusL() : parsing type = %d"), aItem.ParsingType());
-// Signal TestScripter to continue from waittestclass
+	// Signal TestScripter to continue from waittestclass
 Signal();
 #endif // USE_S60_DOWNLOAD_MANAGER
 return err;
 }
 void
 CVHPPTestClass::HandlePluginEvent( TEvent aEvent, TInt aData, TInt aError )
 void
 CVHPPTestClass::ProcessEvent( TCallbackEvent* aCallback )
 {
 MPX_ENTER_EXIT(_L("CVHPPTestClass::ProcessEvent"));
 if ( iExpectedCallbackArray->Count() > 0 )
 {
 TCallbackEvent* expectedCallback = (*iExpectedCallbackArray)[0];
 MPX_DEBUG(_L("CVHPPTestClass::ProcessEvent(%d,%d,%d) Expected(%d,%d,%d)"),
 MPX_ENTER_EXIT(_L("CVHPPTestClass::PlayduringVoiceCall()"));
 iLog->Log(_L("CVHPPTestClass::PlayduringVoiceCall()"));
 TInt err = 0;
-//callback event
-TCallbackEvent* event = new TCallbackEvent;
-event->iError = 0;
-event->iData  = 0;
-event->iEvent = EPPaused;
-AddExpectedEvent( event );
 //set phone call as Connected
 err = RProperty::Set(KPSUidCtsyCallInformation, KCTsyCallState, EPSCTsyCallStateConnected);
 AddErrorEvent(KMPXVideoPlayOver2GDuringVoiceCallError);
 event->iEvent = EPbCmdTvOutEvent;
 event->iData  = EFalse;
 event->iError = KErrNone;
 AddExpectedEvent( event );
-event = new TCallbackEvent;
-event->iEvent = EPPaused;
-event->iData  = 0;
-event->iError = KErrNone;
-AddExpectedEvent( event );
 iAccObserver->UpdateTvOutStatusL( EFalse );
 return KErrNone;
 }
 }
 return err;
 }
 // -----------------------------------------------------------------------------
 //  CVHPPTestClass::SetVolumeSteps
 // -----------------------------------------------------------------------------
 //
 TInt
 CVHPPTestClass::SetVolumeSteps( TInt aVolumeSteps )
 {
 MPX_ENTER_EXIT(_L("CVHPPTestClass::SetVolumeSteps()"));
 iLog->Log(_L("CVHPPTestClass::SetVolumeSteps()"));
 iPlayerUtility->SetVolumeSteps( aVolumeSteps );
 return KErrNone;
 }
 // -----------------------------------------------------------------------------
 //  CVHPPTestClass::HandleVolumeL
 // -----------------------------------------------------------------------------
 //
 TInt
 CVHPPTestClass::HandleVolumeL( CStifItemParser& aItem )
 {
 MPX_ENTER_EXIT(_L("CVHPPTestClass::HandleVolumeL()"));
 iLog->Log(_L("CVHPPTestClass::HandleVolumeL()"));
 TInt command;
 TInt value;
 TInt err = aItem.GetNextInt( command );
 if ( err == KErrNone )
 {
 err = aItem.GetNextInt( value );
 if ( err == KErrNone )
 {
 //
 // assign callback event values
 //
 TCallbackEvent* event = new TCallbackEvent;
 event->iEvent = EPVolumeChanged;
 event->iData  = value;
 event->iError = KErrNone;
 //
 // save expected result to be compared later
 //
 AddExpectedEvent( event );
 //
 // send command to playback plugin
 //
 CreateVideoPlaybackCommandL( aItem, (TMPXVideoPlaybackCommand)command );
 }
 }
 if ( err == KErrNone )
 {
 MPX_DEBUG(_L("CVHPPTestClass::HandleVolumeL() leaves with proper error"));
 }
 return err;
 }
 TInt
 CVHPPTestClass::InitializeWithPositionL( CStifItemParser& aItem )
 {
 iLog->Log(_L("CVHPPTestClass::InitializeL()"));
 TInt duration;
 TInt volumeSteps;
 TInt position;
 TInt err = aItem.GetNextInt( duration );
 if ( err == KErrNone )
 {
 //
 event->iData  = duration;
 event->iError = KErrNone;
 AddExpectedEvent( event );
 //
 // read number of volume steps
 //
 err = aItem.GetNextInt( volumeSteps );
 if ( err == KErrNone )
 {
 //
 // set volume steps
 //
 SetVolumeSteps( volumeSteps );
 err = aItem.GetNextInt( position );
 if (err == KErrNone )
 {
 TBuf<120> fullPath;
 err = ReadFileInitializationParameters( aItem, fullPath );
 if ( err == KErrNone )
 {
 PreparePluginL();
 //
 //  Initalize the Plugin with a file name
 //
 MPX_DEBUG(_L("Initialize the Plugin:  filename = %S, position = %d"), &fullPath, position);
 iLog->Log(_L("Initialize the Plugin:  filename = %S, position = %d"), &fullPath, position);
 iPlaybackPlugin->InitialiseWithPositionL( fullPath, position );
 }
 }
 }
 iLog->Log(_L("CVHPPTestClass::InitializeLinkL()"));
 TInt duration;
 TInt volumeSteps;
 TInt position;
 TInt err = aItem.GetNextInt( duration );
 if ( err == KErrNone )
 {
 //
 event->iData  = duration;
 event->iError = KErrNone;
 AddExpectedEvent( event );
 //
 // read number of volume steps
 //
 err = aItem.GetNextInt( volumeSteps );
 if ( err == KErrNone )
 {
 //
 // set volume steps
 //
 SetVolumeSteps( volumeSteps );
 err = aItem.GetNextInt( position );
 if ( err == KErrNone )
 {
 TPtrC  link;
 //
 //  Read in the link from the config file
 //
 TInt err = aItem.GetNextString( link );
 if ( err == KErrNone )
 {
 TInt err = ReadInitializationErrors( aItem );
 if ( err == KErrNone )
 {
 PreparePluginL();
 //
 //  Extract the streaming link from the ram file and
 //  Initalize the Plugin with the link and an access point
 //
 MPX_DEBUG(_L("Initialize the Plugin:  link = %S, position = %d"), &link, position);
 iLog->Log(_L("Initialize the Plugin:  link = %S, position = %d"), &link, position);
 iPlaybackPlugin->InitStreamingL( link, KNullDesC8, 11, position );
 }
 }
 }
 }
 TInt duration;
 TInt volumeSteps;
 TInt position;
 TInt fileHandle32;
 TInt err = aItem.GetNextInt( fileHandle32 );
 if ( err == KErrNone )
 {
 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
 //
 // set RFile as default if the 64-bit flag is not defined
 //
 fileHandle32 = ETrue;
 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
 err = aItem.GetNextInt( duration );
 if ( err == KErrNone )
 {
 //
 //  We will always get an Init Complete message out
 //
 TCallbackEvent* event = new TCallbackEvent;
 event->iEvent = EPInitialised;
 event->iData  = duration;
 event->iError = KErrNone;
 AddExpectedEvent( event );
 //
 // read number of volume steps
 //
 err = aItem.GetNextInt( volumeSteps );
 if ( err == KErrNone )
 {
 //
 // set volume steps
 //
 SetVolumeSteps( volumeSteps );
 err = aItem.GetNextInt( position );
 if (err == KErrNone )
 {
 TBuf<120> fullPath;
 err = ReadFileInitializationParameters( aItem, fullPath );
 if ( err == KErrNone )
 {
 PreparePluginL();
 RFs fs;
 TInt error = fs.Connect();
 //
 //  Open a file handle to the clip
 //
 if ( fileHandle32 )
 {
 file64.Open( fs, fullPath, EFileRead );
 iPlaybackPlugin->Initialise64L( file64, position );
 file64.Close();
 }
 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
 //
 //  Initalize the Plugin with a file name
 //
 MPX_DEBUG(_L("Initialize the Plugin with File Handle:  filename = %S, position = %d"), &fullPath, position);
 iLog->Log(_L("Initialize the Plugin with File Handle:  filename = %S, position = %d"), &fullPath, position);
 fs.Close();
 }
 }
 }
 }
 }
 return err;
 }
 TInt
 iLog->Log(_L("CVHPPTestClass::InitializeStreamingWithSdpFileHandleL()"));
 TInt duration;
 TInt volumeSteps;
 TInt fileHandle32;
 TInt err = aItem.GetNextInt( fileHandle32 );
 if ( err == KErrNone )
 {
 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
 //
 // set RFile as default if the 64-bit flag is not defined
 //
 fileHandle32 = ETrue;
 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
 err = aItem.GetNextInt( duration );
 if ( err == KErrNone )
 {
 //
 //  We will always get an Init Complete message out
 //
 TCallbackEvent* event = new TCallbackEvent;
 event->iEvent = EPInitialised;
 event->iData  = duration;
 event->iError = KErrNone;
 AddExpectedEvent( event );
 //
 // read number of volume steps
 //
 err = aItem.GetNextInt( volumeSteps );
 if ( err == KErrNone )
 {
 //
 // set volume steps
 //
 SetVolumeSteps( volumeSteps );
 TBuf<120> fullPath;
 err = ReadFileInitializationParameters( aItem, fullPath );
 if ( err == KErrNone )
 {
-PreparePluginL();
+					PreparePluginL();
-MPX_DEBUG( _L("Initialize the Plugin:  link = %S"), &fullPath );
+					MPX_DEBUG( _L("Initialize the Plugin:  link = %S"), &fullPath );
-iLog->Log( _L("Initialize the Plugin:  link = %S"), &fullPath );
+					iLog->Log( _L("Initialize the Plugin:  link = %S"), &fullPath );
-//
+					//
-//  Extract the streaming link from the ram file and
+					//  Extract the streaming link from the ram file and
-//  Initalize the Plugin with the file handle and an access point
+					//  Initalize the Plugin with the file handle and an access point
-//
+					//
-RFs fs;
+					RFs fs;
-TInt error = fs.Connect();
+					TInt error = fs.Connect();
-if ( fileHandle32 )
+					if ( fileHandle32 )
-{
+					{
-RFile file;
+						RFile file;
-error = file.Open( fs, fullPath, EFileRead | EFileShareAny );
+						error = file.Open( fs, fullPath, EFileRead | EFileShareAny );
-MPX_DEBUG( _L("Initialize the Plugin:  file open error = %d"),
+						MPX_DEBUG( _L("Initialize the Plugin:  file open error = %d"),
-error );
+								error );
-User::LeaveIfError( error );
+						User::LeaveIfError( error );
-iPlaybackPlugin->InitStreamingL( file, 11 );
+						iPlaybackPlugin->InitStreamingL( file, 11 );
-file.Close();
+						file.Close();
-}
+					}
 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
-else
+					else
-{
+					{
-RFile64 file64;
+						RFile64 file64;
-error = file64.Open( fs, fullPath, EFileRead | EFileShareAny  );
+						error = file64.Open( fs, fullPath, EFileRead | EFileShareAny  );
-MPX_DEBUG( _L("Initialize the Plugin:  file open error = %d"),
+						MPX_DEBUG( _L("Initialize the Plugin:  file open error = %d"),
-error );
+								error );
-User::LeaveIfError( error );
+						User::LeaveIfError( error );
-iPlaybackPlugin->InitStreaming64L( file64, 11 );
+						iPlaybackPlugin->InitStreaming64L( file64, 11 );
-file64.Close();
+						file64.Close();
-}
+					}
 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
-fs.Close();
+					fs.Close();
 }
 }
 }
 }
 return err;
 }
 TInt
 CVHPPTestClass::RetrieveFileNameAndModeL( CStifItemParser& aItem )
 {
 MPX_ENTER_EXIT( _L("CVHPPTestClass::RetrieveFileNameAndModeL()") );
 iLog->Log( _L("CVHPPTestClass::RetrieveFileNameAndModeL()") );
-TBuf<120>    fullPath;
+TBuf<120>	fullPath;
-TPtrC        fileName;
+TPtrC		fileName;
-TInt        err;
+TInt		err;
 err = aItem.GetNextString( fileName );
 if ( err == KErrNone )
 {
 //
 //  Build the full path to the file
 //
 fullPath.Append( KVideoTestPath );
 fullPath.Append( fileName );
 TInt mode;
 err = aItem.GetNextInt( mode);
 if ( err == KErrNone )
 {
-CMPXCommand* cmd = CMPXCommand::NewL();
+			CMPXCommand* cmd = CMPXCommand::NewL();
-CleanupStack::PushL( cmd );
+			CleanupStack::PushL( cmd );
-cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
+			cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
-cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId,
+			cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId,
-KMPXMediaIdVideoPlayback );
+										 KMPXMediaIdVideoPlayback );
-cmd->SetTObjectValueL<TInt>( KMPXMediaVideoPlaybackCommand, EPbCmdInitView );
+			cmd->SetTObjectValueL<TInt>( KMPXMediaVideoPlaybackCommand, EPbCmdInitView );
-iPlaybackPlugin->CommandL( *cmd );
+			iPlaybackPlugin->CommandL( *cmd );
-TPtrC clipName( cmd->ValueText( KMPXMediaVideoPlaybackFileName ) );
+			TPtrC clipName( cmd->ValueText( KMPXMediaVideoPlaybackFileName ) );
-TMPXVideoMode  playbackMode = (TMPXVideoMode) cmd->ValueTObjectL<TInt>( KMPXMediaVideoMode );
+			TMPXVideoMode  playbackMode = (TMPXVideoMode) cmd->ValueTObjectL<TInt>( KMPXMediaVideoMode );
-MPX_DEBUG( _L("    Expected Data:  filename = %S, playbackmode= %d" ),
+			MPX_DEBUG( _L("    Expected Data:  filename = %S, playbackmode= %d" ),
-&fullPath, mode );
+				 &fullPath, mode );
-MPX_DEBUG( _L("    Retrieved Data: filename = %S, playbackmode= %d"),
+			MPX_DEBUG( _L("    Retrieved Data: filename = %S, playbackmode= %d"),
-&clipName, playbackMode );
+				 &clipName, playbackMode );
-if ( fullPath.Compare( clipName) != 0 || mode != playbackMode )
+			if ( fullPath.Compare( clipName) != 0 || mode != playbackMode )
-{
+			{
-err = KErrGeneral;
+			    err = KErrGeneral;
-MPX_DEBUG( _L("    err = %d"), err );
+				MPX_DEBUG( _L("    err = %d"), err );
-}
+			}
-CleanupStack::PopAndDestroy( cmd );
+			CleanupStack::PopAndDestroy( cmd );
 }
 }
 return err;
 }

branch	RCL_3
changeset 70	375929f879c2
parent 64	3eb824b18d67