--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videoplayback/videohelix/tsrc/ut_videohelixtest/src/videohelixtestbody.cpp Mon Jan 18 20:21:12 2010 +0200
@@ -0,0 +1,2166 @@
+/*
+* Copyright (c) 2008 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: Test Harness for VideoHelixPlaybackPlugin
+*
+*/
+
+// Version : %version: 15 %
+
+
+// [INCLUDE FILES] - do not remove
+#include <e32svr.h>
+#include <stifparser.h>
+#include <stiftestinterface.h>
+
+#include <mpxmediageneraldefs.h>
+#include <mpxcommandgeneraldefs.h>
+#include <mmf/common/mmferrors.h>
+#include <mpxplaybackpluginversion2.h>
+#include <mpxmessagegeneraldefs.h>
+
+#include <accpolnamevaluerecord.h>
+#include <accconfigfileparser.h>
+#include <acccongenericid.h>
+#include <accpolnamevaluerecord.h>
+
+#include "dlmgr_stub.h"
+#include "mpxvideoregion.h"
+#include "videohelixtest.h"
+#include "mpxvideoaccessoryobserver_stub.h"
+#include <mpxvideoplaybackdefs.h>
+#include "mpxmediavideodefs.h"
+#include "mpxvideo_debug.h"
+#include "mpxvideoplayerutility_stub.h"
+
+#ifdef __WINSCW__
+ _LIT( KVideoTestPath, "c:\\data\\Videos\\" );
+#else
+ _LIT( KVideoTestPath, "f:\\testing\\data\\" );
+#endif
+
+_LIT( KOpenControllerFilename, "c:\\vhpp_openerror.txt" );
+_LIT( KPrepareControllerFilename, "c:\\vhpp_prepareerror.txt" );
+_LIT( KPlaybackCompleteFilename, "c:\\vhpp_playerror.txt" );
+_LIT( KDlMgrFile, "c:\\vhpp_dlmgr.txt" );
+_LIT( KDrmRightsFile, "c:\\vhpp_drmrights.txt" );
+
+#define ELightsNotBlinking 1
+#define ELightsBlinking 2
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::RunMethodL
+// Run specified method. Contains also table of test mothods and their names.
+// -----------------------------------------------------------------------------
+//
+TInt CVHPPTestClass::RunMethodL( CStifItemParser& aItem )
+{
+ static TStifFunctionInfo const KFunctions[] =
+ {
+ //
+ // Copy this line for every implemented function.
+ // First string is the function name used in TestScripter script file.
+ // Second is the actual implementation member function.
+ //
+ ENTRY( "Initialize", CVHPPTestClass::InitializeL ),
+ ENTRY( "InitializeHandle", CVHPPTestClass::InitializeHandleL ),
+ ENTRY( "InitializeLink", CVHPPTestClass::InitializeLinkL ),
+ ENTRY( "InitializeSdp", CVHPPTestClass::InitializeSdpL ),
+ ENTRY( "IssueGeneralCommand", CVHPPTestClass::IssueGeneralCommandL),
+ ENTRY( "IssuePlaybackCommand", CVHPPTestClass::IssuePlaybackCommandL),
+ ENTRY( "IssueVideoCommand", CVHPPTestClass::IssueVideoCommandL),
+ ENTRY( "IssueSeekingCommand", CVHPPTestClass::IssueSeekingCommandL),
+ ENTRY( "SetProperty", CVHPPTestClass::SetPropertyL),
+ ENTRY( "GetProperty", CVHPPTestClass::GetPropertyL),
+ ENTRY( "GetSubPlayerNames", CVHPPTestClass::GetSubPlayerNamesL),
+ ENTRY( "SelectSubPlayer", CVHPPTestClass::SelectSubPlayerL),
+ ENTRY( "SubPlayerName", CVHPPTestClass::SubPlayerName),
+ ENTRY( "SubPlayerIndex", CVHPPTestClass::SubPlayerIndex),
+ ENTRY( "CancelRequest", CVHPPTestClass::CancelRequest),
+ ENTRY( "GetMedia", CVHPPTestClass::GetMediaL),
+ ENTRY( "SetPlaybackComplete", CVHPPTestClass::SetPlaybackCompleteL),
+ ENTRY( "SetUnexpectedMmfEvent", CVHPPTestClass::SetUnexpectedMmfEventL),
+ ENTRY( "ConnectToDownload", CVHPPTestClass::ConnectToDownloadL),
+ ENTRY( "PauseDownload", CVHPPTestClass::PauseDownloadL),
+ ENTRY( "ResumeDownload", CVHPPTestClass::ResumeDownloadL),
+ ENTRY( "CancelDownload", CVHPPTestClass::CancelDownloadL),
+ ENTRY( "RetrievePdlStatus", CVHPPTestClass::RetrievePdlStatusL),
+ ENTRY( "ChangeAspectRatioL", CVHPPTestClass::ChangeAspectRatioL),
+
+ ENTRY( "AlarmOn", CVHPPTestClass::AlarmOn),
+ ENTRY( "AlarmAutoResume", CVHPPTestClass::AlarmAutoResume),
+ ENTRY( "PhoneCallRejected", CVHPPTestClass::PhoneCallRejected),
+ ENTRY( "VoiceCallAccepted", CVHPPTestClass::VoiceCallAccepted),
+ ENTRY( "VideoCallAccepted", CVHPPTestClass::VideoCallAccepted),
+ ENTRY( "PlayduringVideoCall", CVHPPTestClass::PlayduringVideoCall),
+ ENTRY( "PlayduringVoiceCall", CVHPPTestClass::PlayduringVoiceCall),
+
+ ENTRY( "EndPhoneCall", CVHPPTestClass::EndPhoneCall),
+
+ ENTRY( "SetTvOutConnected", CVHPPTestClass::SetTvOutConnectedL ),
+ ENTRY( "SetTvOutDisconnected", CVHPPTestClass::SetTvOutDisconnectedL ),
+ ENTRY( "ConnectTvOut", CVHPPTestClass::ConnectTvOutL ),
+ ENTRY( "DisconnectTvOut", CVHPPTestClass::DisconnectTvOutL ),
+
+ ENTRY( "SetDrmProtected", CVHPPTestClass::SetDrmProtectedL ),
+ ENTRY( "IssueSeekedToEndCommand", CVHPPTestClass::IssueSeekedToEndCommandL),
+ ENTRY( "HandleVolume", CVHPPTestClass::HandleVolumeL )
+
+
+ //
+ // ADD NEW ENTRIES HERE
+ //
+ // ENTRY( "SendPlayCommandToServer",
+ // CVHPPTestClass::SendPlayCommandToServer ),
+ // [test cases entries] - Do not remove
+ };
+
+ const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );
+
+ return RunInternalL( KFunctions, count, aItem );
+}
+
+void
+CVHPPTestClass::WriteControllerError( const TDesC& aFilename, TInt aData )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::WriteControllerError()"),
+ _L("file = %S, data = %d"), &aFilename, aData );
+
+ //
+ // Write to test file so the controller open fails
+ //
+ RFile file;
+
+ RFs fs;
+ TInt error = fs.Connect();
+
+ TBuf8<16> tgt;
+ tgt.Num( aData );
+
+ file.Replace( fs, aFilename, EFileWrite );
+
+ file.Write( tgt );
+
+ file.Close();
+ fs.Close();
+}
+
+void
+CVHPPTestClass::CreateGeneralPlaybackCommandL( TMPXPlaybackCommand aCmd )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::CreateGeneralPlaybackCommandL()"),
+ _L("aCmd = %d"), aCmd );
+
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd );
+
+ cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
+
+ cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId,
+ KMPXCommandIdPlaybackGeneral );
+
+ cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralType, aCmd );
+
+ iPlaybackPlugin->CommandL( *cmd );
+
+ CleanupStack::PopAndDestroy( cmd );
+}
+
+void
+CVHPPTestClass::PreparePluginL()
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::PreparePluginL()"));
+
+ //
+ // Set this class as the observer for the Plugin events
+ //
+ iLog->Log(_L(" SetObserver on Plugin"));
+ iPlaybackPlugin->SetObserver( *this );
+
+ //
+ // Create Playback Message
+ //
+ iLog->Log(_L(" Close the Plugin"));
+ CreateGeneralPlaybackCommandL( EPbCmdClose );
+}
+
+TInt
+CVHPPTestClass::ReadFileInitializationParameters( CStifItemParser& aItem, TDes& aFilename )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::ReadFileInitializationParameters()"));
+
+ TPtrC filename;
+
+ //
+ // Read in the filename from the config file
+ //
+ TInt err = aItem.GetNextString( filename );
+
+ if ( err == KErrNone )
+ {
+ //
+ // Build the full path to the file
+ //
+ aFilename.Append( KVideoTestPath );
+ aFilename.Append( filename );
+
+ err = ReadInitializationErrors( aItem );
+ }
+
+ return err;
+}
+
+TInt
+CVHPPTestClass::ReadInitializationErrors( CStifItemParser& aItem )
+{
+ TInt err;
+ TInt initError;
+ TInt openError;
+ TInt prepError;
+
+ //
+ // Read in the expected init error code
+ //
+ err = aItem.GetNextInt( initError );
+
+ if ( err == KErrNone && initError != KErrNone )
+ {
+ AddErrorEvent( initError );
+ }
+ else
+ {
+ //
+ // Read in the expected open complete error code
+ //
+ err = aItem.GetNextInt( openError );
+
+ WriteControllerError( KOpenControllerFilename, openError );
+
+ if ( err == KErrNone && openError != KErrNone )
+ {
+ AddErrorEvent( openError );
+ }
+ else
+ {
+ //
+ // Open Complete does not return error
+ // Read in the expected prepare complete error code
+ //
+ err = aItem.GetNextInt( prepError );
+
+ WriteControllerError( KPrepareControllerFilename, prepError );
+
+ if ( err == KErrNone && prepError != KErrNone )
+ {
+ AddErrorEvent( prepError );
+ }
+ }
+ }
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::InitializeL
+// Test creation of a general playback command.
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::InitializeL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::InitializeL()"));
+ iLog->Log(_L("CVHPPTestClass::InitializeL()"));
+
+ TInt duration;
+ TInt volumeSteps;
+
+ TInt 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();
+
+ //
+ // 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 );
+ }
+ }
+ }
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::InitializeLinkL
+// Test creation of a general playback command.
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::InitializeLinkL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::InitializeLinkL()"));
+ iLog->Log(_L("CVHPPTestClass::InitializeLinkL()"));
+
+ TInt duration;
+ TInt volumeSteps;
+ TInt 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 );
+
+ 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 );
+ }
+ }
+ }
+ }
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::InitializeSdpL
+// Test creation of a general playback command.
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::InitializeSdpL( CStifItemParser& /*aItem*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::InitializeSdpL()"));
+ iLog->Log(_L("CVHPPTestClass::InitializeSdpL()"));
+
+ TBuf<120> fullPath;
+ TInt initError = KErrNone;
+
+ TInt err = KErrNone;// = ReadInitializationParameters( aItem, fullPath, initError );
+
+ if ( err == KErrNone )
+ {
+ PreparePluginL();
+
+ MPX_DEBUG(_L("Initialize the Plugin: filename = %S"), &fullPath);
+ iLog->Log(_L("Initialize the Plugin: filename = %S"), &fullPath);
+
+
+ TRAPD( err,
+ static_cast<CMPXPlaybackPluginVersion2*>(iPlaybackPlugin)->InitStreamingL
+ ( fullPath, KNullDesC8, 11 );
+ );
+
+ MPX_DEBUG(_L("CVHPPTestClass::InitialisePluginL(%d)"), err);
+
+ if ( err == initError )
+ {
+ MPX_DEBUG(_L("InitialiseL() returned proper error %d"), err);
+ iLog->Log(_L("InitialiseL() returned proper error %d"), err);
+ err = KErrNone;
+ }
+ }
+
+ return err;
+}
+
+
+TInt
+CVHPPTestClass::InitializeHandleL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::InitializeHandleL()"));
+ 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 )
+ {
+ RFile file;
+ User::LeaveIfError( file.Open( fs, fullPath, EFileRead ) );
+ iPlaybackPlugin->InitialiseL( file );
+ file.Close();
+ }
+#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
+ else
+ {
+ RFile64 file64;
+ 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
+CVHPPTestClass::ReadRect( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::ReadRect()"));
+
+ TRect rect;
+
+ TInt value;
+
+ if ( ! aItem.GetNextInt( value ) )
+ {
+ rect.iTl.iX = value;
+
+ if ( ! aItem.GetNextInt( value ) )
+ {
+ rect.iTl.iY = value;
+
+ if ( ! aItem.GetNextInt( value ) )
+ {
+ rect.iBr.iX = value;
+
+ if ( ! aItem.GetNextInt( value ) )
+ {
+ rect.iBr.iY = value;
+ }
+ }
+ }
+ }
+
+ return rect;
+}
+
+void
+CVHPPTestClass::CreateVideoPlaybackCommandL( CStifItemParser& aItem,
+ TMPXVideoPlaybackCommand aCmd )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::CreateVideoPlaybackCommandL()"),
+ _L("aCmd = %d"), aCmd );
+
+ //
+ // create command to pass to playback plugin
+ //
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd );
+
+ cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
+
+ cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId,
+ KMPXMediaIdVideoPlayback );
+
+ cmd->SetTObjectValueL<TInt>( KMPXMediaVideoPlaybackCommand, aCmd );
+
+ switch ( aCmd )
+ {
+ case EPbCmdRestartDSA:
+ {
+ TRect rect = ReadRect( aItem );
+ RRegion region( rect );
+
+ CMPXVideoRegion* vidReg = CMPXVideoRegion::NewL();
+ CleanupStack::PushL( vidReg );
+
+ vidReg->SetRegion( region );
+
+ vidReg->Print();
+
+ cmd->SetCObjectValueL<CMPXVideoRegion>( KMPXMediaVideoPlaybackDSARegion, vidReg );
+
+ CleanupStack::PopAndDestroy( vidReg );
+
+ break;
+ }
+ case EPbCmdSetDisplayWindow:
+ {
+ TRect rect = ReadRect( aItem );
+ RRegion region( rect );
+
+ CMPXVideoRegion* vidReg = CMPXVideoRegion::NewL();
+ CleanupStack::PushL( vidReg );
+
+ vidReg->SetRegion( region);
+
+ vidReg->Print();
+
+ cmd->SetTObjectValueL<TRect>( KMPXMediaVideoPlaybackTRect, rect );
+
+ cmd->SetCObjectValueL<CMPXVideoRegion>( KMPXMediaVideoPlaybackDSARegion, vidReg );
+
+ CleanupStack::PopAndDestroy( vidReg );
+
+ break;
+ }
+ }
+
+ iPlaybackPlugin->CommandL( *cmd );
+
+ CleanupStack::PopAndDestroy( cmd );
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::IssueVideoCommandL
+// Test creation of a general playback command.
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::IssueVideoCommandL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::IssueVideoCommandL()"));
+ iLog->Log(_L("CVHPPTestClass::IssueVideoCommandL()"));
+
+ TInt vidCmd;
+ TInt err = aItem.GetNextInt( vidCmd );
+
+ if ( err == KErrNone )
+ {
+ TCallbackEvent* event = new TCallbackEvent;
+
+ event->iEvent = vidCmd;
+ event->iData = 0;
+ event->iError = KErrNone;
+
+ AddExpectedEvent( event );
+
+ CreateVideoPlaybackCommandL( aItem, (TMPXVideoPlaybackCommand)vidCmd );
+ }
+
+ return KErrNone;
+}
+
+TInt
+CVHPPTestClass::IssueSeekingCommandL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::IssueSeekingCommandL()"));
+ iLog->Log(_L("CVHPPTestClass::IssueSeekingCommandL()"));
+
+ TInt vidCmd;
+ TInt err = aItem.GetNextInt( vidCmd );
+
+ //
+ // Seeking is starting, allow posiiton callbacks
+ //
+ iAllowPositionCallback = ETrue;
+
+ if ( err == KErrNone )
+ {
+ TCallbackEvent* event = new TCallbackEvent;
+
+ if ( vidCmd == EPbCmdStartVideoSeekingForward || vidCmd == EPbCmdStartVideoSeekingBackward )
+ {
+ TBool addEvent = ETrue;
+
+ aItem.GetNextInt( addEvent );
+
+ if ( addEvent )
+ {
+ event->iEvent = EPPluginSeeking;
+ event->iData = 0;
+ event->iError = KErrNone;
+ AddExpectedEvent( event );
+ }
+ }
+ else if ( vidCmd == EPbCmdStopVideoSeeking )
+ {
+ TInt callbackEvent;
+ aItem.GetNextInt( callbackEvent );
+
+ if ( callbackEvent )
+ {
+ event->iEvent = callbackEvent;
+ event->iData = 0;
+ event->iError = KErrNone;
+ AddExpectedEvent( event );
+
+ iAllowPositionCallback = EFalse;
+ }
+ }
+
+ CreateVideoPlaybackCommandL( aItem, (TMPXVideoPlaybackCommand)vidCmd );
+ }
+
+ return KErrNone;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::IssueSeekedToEndCommandL
+// Test creation of a End of Clip command.
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::IssueSeekedToEndCommandL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::IssueSeekedToEndCommandL()"));
+ iLog->Log(_L("CVHPPTestClass::IssueSeekedToEndCommandL()"));
+
+ TCallbackEvent* event = new TCallbackEvent;
+
+ event->iEvent = EPPlayComplete;
+ event->iData = 0;
+ event->iError = KErrNone;
+
+ AddExpectedEvent( event );
+
+ CreateVideoPlaybackCommandL( aItem, EPbCmdEndofClipReached);
+
+ return KErrNone;
+}
+
+TInt
+CVHPPTestClass::ParsePlaybackCommand( CStifItemParser& aItem, TInt& aCmd )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::ParsePlaybackCommand()"));
+
+ TInt err = aItem.GetNextInt( aCmd );
+
+ if ( err == KErrNone )
+ {
+ TCallbackEvent* event = new TCallbackEvent;
+ event->iData = 0;
+
+ err = aItem.GetNextInt( event->iError );
+
+ if ( err == KErrNone )
+ {
+ if ( event->iError == KErrNotSupported )
+ {
+ delete event;
+ }
+ else
+ {
+ err = aItem.GetNextInt( event->iEvent );
+
+ if ( err == KErrNone )
+ {
+ if ( event->iEvent == EPBufferingStarted )
+ {
+ //
+ // A playing command will be added also
+ //
+ AddExpectedEvent( event );
+
+ event = new TCallbackEvent;
+ event->iEvent = EPPlaying;
+ event->iData = 0;
+ event->iError = KErrNone;
+ }
+
+ AddExpectedEvent( event );
+ }
+ }
+ }
+ }
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::IssueGeneralCommandL
+// Test creation of a general playback command.
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::IssueGeneralCommandL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::IssueGeneralCommandL()"));
+ iLog->Log(_L("CVHPPTestClass::IssueGeneralCommandL()"));
+
+ TInt genCmd = 0;
+
+ TInt error = ParsePlaybackCommand( aItem, genCmd );
+
+ if ( error == KErrNone )
+ {
+ CreateGeneralPlaybackCommandL( (TMPXPlaybackCommand)genCmd );
+ }
+
+ return error;
+}
+
+TInt
+CVHPPTestClass::IssuePlaybackCommandL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::IssuePlaybackCommandL()"));
+ iLog->Log(_L("CVHPPTestClass::IssuePlaybackCommandL()"));
+
+ TInt genCmd;
+
+ TInt error = ParsePlaybackCommand( aItem, genCmd );
+
+ if ( error == KErrNone )
+ {
+ iPlaybackPlugin->CommandL( (TMPXPlaybackCommand)genCmd, 0 );
+ }
+
+ return error;
+}
+
+TInt
+CVHPPTestClass::SetPropertyL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::SetPropertyL()"));
+ iLog->Log(_L("CVHPPTestClass::SetPropertyL()"));
+
+ TInt property;
+ TInt value;
+
+ TInt trapErr = KErrNone;
+ TInt err = aItem.GetNextInt( property );
+
+ if ( err == KErrNone )
+ {
+ err = aItem.GetNextInt( value );
+
+ if ( err == KErrNone )
+ {
+ if ( property >= EPbPropertyNum )
+ {
+ trapErr = KErrNotSupported;
+ }
+ else
+ {
+ TCallbackEvent* event = new TCallbackEvent;
+
+ if ( property == EPbPropertyVolume )
+ {
+ TInt addEvent;
+ err = aItem.GetNextInt( addEvent );
+
+ if ( err == KErrNone && addEvent )
+ {
+ event->iEvent = EPVolumeChanged;
+ event->iData = value;
+ event->iError = KErrNone;
+ AddExpectedEvent( event );
+ }
+ }
+ else if ( property == EPbPropertyMute )
+ {
+ event->iEvent = EPMuteChanged;
+ event->iData = value;
+ event->iError = KErrNone;
+ AddExpectedEvent( event );
+ }
+ else
+ {
+ event->iEvent = EPSetComplete;
+ event->iData = property;
+ event->iError = KErrNone;
+ AddExpectedEvent( event );
+ }
+
+ }
+
+ TRAP( err, iPlaybackPlugin->SetL( (TMPXPlaybackProperty)property, value ) );
+ }
+ }
+
+ if ( err == trapErr )
+ {
+ MPX_DEBUG(_L("CVHPPTestClass::SetPropertyL() leaves with proper error"));
+ err = KErrNone;
+ }
+
+ return err;
+}
+
+TInt
+CVHPPTestClass::GetPropertyL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::GetPropertyL()"));
+ iLog->Log(_L("CVHPPTestClass::GetPropertyL()"));
+
+ TInt property;
+ TInt value;
+
+ TInt trapErr = KErrNone;
+
+ TInt err = aItem.GetNextInt( property );
+
+ if ( err == KErrNone )
+ {
+ err = aItem.GetNextInt( value );
+
+ if ( err == KErrNone )
+ {
+ if ( property >= EPbPropertyNum )
+ {
+ trapErr = KErrNotSupported;
+ }
+ else
+ {
+ TCallbackEvent* event = new TCallbackEvent;
+
+ event->iEvent = property;
+ event->iData = value;
+ event->iError = KErrNone;
+
+ AddExpectedEvent( event );
+ }
+
+ TRAP( err, iPlaybackPlugin->PropertyL( (TMPXPlaybackProperty)property ) );
+ }
+ }
+
+ if ( err == trapErr )
+ {
+ MPX_DEBUG(_L("CVHPPTestClass::GetPropertyL() leaves with proper error"));
+ err = KErrNone;
+ }
+
+ return err;
+}
+
+TInt
+CVHPPTestClass::GetSubPlayerNamesL( CStifItemParser& /*aItem*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::GetSubPlayerNamesL()"));
+ iLog->Log(_L("CVHPPTestClass::GetSubPlayerNmaesL()"));
+
+ iPlaybackPlugin->SubPlayerNamesL();
+
+ return KErrNone;
+}
+
+TInt
+CVHPPTestClass::SelectSubPlayerL( CStifItemParser& /*aItem*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::SelectSubPlayerL()"));
+ iLog->Log(_L("CVHPPTestClass::SelectSubPlayerL()"));
+
+ TRAPD( err, iPlaybackPlugin->SelectSubPlayerL( 1 ); );
+
+ if ( err == KErrNotSupported )
+ {
+ err = KErrNone;
+ }
+
+ return err;
+}
+
+TInt
+CVHPPTestClass::SubPlayerName( CStifItemParser& /*aItem*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::SubPlayerName()"));
+ iLog->Log(_L("CVHPPTestClass::SubPlayerName()"));
+
+ TInt err = KErrNone;
+
+ TDesC name = iPlaybackPlugin->SubPlayerName();
+
+ if ( name != KNullDesC )
+ {
+ err = KErrNotFound;
+ }
+
+ return err;
+}
+
+TInt
+CVHPPTestClass::SubPlayerIndex( CStifItemParser& /*aItem*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::SubPlayerIndex()"));
+ iLog->Log(_L("CVHPPTestClass::SubPlayerIndex()"));
+
+ TInt err = iPlaybackPlugin->SubPlayerIndex();
+
+ if ( err == KErrNotFound )
+ {
+ err = KErrNone;
+ }
+
+ return err;
+}
+
+TInt
+CVHPPTestClass::GetMediaL( CStifItemParser& /*aItem*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::GetMediaL()"));
+ iLog->Log(_L("CVHPPTestClass::GetMediaL()"));
+
+ RArray<TMPXAttribute> attrs;
+ CleanupClosePushL(attrs);
+
+ // TMPXAttribute attr( KMPXMediaGeneralAll );
+
+ attrs.Append( KMPXMediaGeneralAll );
+ attrs.Append( KMPXMediaVideoAll );
+
+ iPlaybackPlugin->MediaL( attrs.Array() );
+
+ CleanupStack::PopAndDestroy( &attrs );
+
+ return KErrNone;
+}
+
+TInt
+CVHPPTestClass::CancelRequest( CStifItemParser& /*aItem*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::CancelRequest()"));
+ iLog->Log(_L("CVHPPTestClass::CancelRequest()"));
+
+ iPlaybackPlugin->CancelRequest();
+
+ return KErrNone;
+}
+
+TInt
+CVHPPTestClass::SetPlaybackCompleteL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::SetPlaybackCompleteL()"));
+ iLog->Log(_L("CVHPPTestClass::SetPlaybackCompleteL()"));
+
+ TInt playError = KErrNone;
+
+ TInt err = aItem.GetNextInt( playError );
+
+ if ( err == KErrNone )
+ {
+ TInt duration;
+
+ err = aItem.GetNextInt( duration );
+
+ if ( err == KErrNone )
+ {
+ WriteControllerError( KPlaybackCompleteFilename, playError );
+
+ TCallbackEvent* event = new TCallbackEvent;
+ event->iEvent = EPSetComplete;
+ event->iData = EPbPropertyPosition;
+ event->iError = KErrNone;
+ AddExpectedEvent( event );
+
+ //
+ // Trigger a playback complete by setting time to duration
+ //
+ iPlaybackPlugin->SetL( EPbPropertyPosition, duration );
+
+ if ( playError )
+ {
+ AddErrorEvent( playError );
+ }
+ else
+ {
+ TCallbackEvent* event = new TCallbackEvent;
+
+ event->iEvent = EPPlayComplete;
+ event->iData = 0;
+ event->iError = playError;
+
+ AddExpectedEvent( event );
+ }
+ }
+ }
+
+ return KErrNone;
+}
+
+TInt
+CVHPPTestClass::SetUnexpectedMmfEventL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::SetUnexpectedMmfEventL()"));
+ iLog->Log(_L("CVHPPTestClass::SetUnexpectedMmfEventL()"));
+
+ TInt playError = KErrNone;
+
+ TInt err = aItem.GetNextInt( playError );
+
+ if ( err == KErrNone )
+ {
+ WriteControllerError( KPlaybackCompleteFilename, playError );
+
+ //
+ // Trigger an unexpected event by setting time to a negative value
+ //
+ iPlaybackPlugin->SetL( EPbPropertyPosition, -1 );
+
+ TCallbackEvent* event = new TCallbackEvent;
+
+ event->iEvent = EPClosed;
+ event->iData = 0;
+ event->iError = playError;
+
+ AddExpectedEvent( event );
+ }
+
+ return KErrNone;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::ConnectToDownload
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::ConnectToDownloadL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::ConnectToDownloadL()"));
+ iLog->Log(_L("CVHPPTestClass::ConnectToDownloadL()"));
+
+ iDlMgrTester = CDlMgrTestClass::NewL();
+ iDlMgrTester->AddStifObserver( this );
+
+ TInt dlId;
+ TPtrC filename;
+ TBuf<120> fullPath;
+
+ //
+ // Read in the download id and filename
+ //
+ TInt err = aItem.GetNextInt( dlId );
+
+ if ( err == KErrNone )
+ {
+ err = aItem.GetNextString( filename );
+
+ if ( err == KErrNone )
+ {
+ TCallbackEvent* event = new TCallbackEvent;
+ event->iEvent = EConnectedToDownload;
+ event->iData = dlId;
+ event->iError = KErrNone;
+
+ AddExpectedEvent( event );
+
+ //
+ // Build the full path to the file
+ //
+ fullPath.Append( KVideoTestPath );
+ fullPath.Append( filename );
+
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd );
+
+ cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
+ cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD );
+ cmd->SetTObjectValueL<TMPXPlaybackPdCommand>( KMPXCommandPlaybackGeneralType, EPbCmdStartPd );
+ cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackPDTransactionID, dlId );
+ cmd->SetTextValueL( KMPXMediaVideoPlaybackFileName, fullPath );
+ cmd->SetTObjectValueL<TInt>( KMPXMediaVideoMovePdlFile, ETrue );
+
+ iPlaybackPlugin->CommandL( *cmd );
+
+ CleanupStack::PopAndDestroy( cmd );
+ }
+ }
+
+ return err;
+}
+
+// -------------------------------------------------------------------------------------------------
+// CVHPPTestClass::SendPdlCustomCommandL()
+// -------------------------------------------------------------------------------------------------
+//
+void
+CVHPPTestClass::SendPdlCustomCommandL( TMPXPlaybackPdCommand aCustomCmd )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::SendPdlCustomCommandL"),
+ _L("aCustomCmd = %d"), aCustomCmd );
+
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd );
+
+ cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
+ cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD );
+ cmd->SetTObjectValueL<TMPXPlaybackPdCommand>( KMPXCommandPlaybackGeneralType, aCustomCmd );
+
+ iPlaybackPlugin->CommandL( *cmd );
+
+ CleanupStack::PopAndDestroy( cmd );
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::PauseDownloadL
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::PauseDownloadL( CStifItemParser& /*aItem*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::PauseDownloadL()"));
+ iLog->Log(_L("CVHPPTestClass::PauseDownloadL()"));
+
+ TCallbackEvent* event = new TCallbackEvent;
+
+ event->iEvent = EPDownloadStateChanged;
+ event->iData = EPbDlStateDownloadPaused;
+ event->iError = KErrNone;
+
+ AddExpectedEvent( event );
+
+ iDlMgrTester->PauseDownload();
+
+ return KErrNone;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::ResumeDownloadL
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::ResumeDownloadL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::ResumeDownloadL()"));
+ iLog->Log(_L("CVHPPTestClass::ResumeDownloadL()"));
+
+ TInt dlSize;
+
+ TInt err = aItem.GetNextInt( dlSize );
+
+ if ( err == KErrNone )
+ {
+ WriteControllerError( KDlMgrFile, dlSize );
+
+ TCallbackEvent* event = new TCallbackEvent;
+
+ event->iEvent = EPDownloadStateChanged;
+ event->iError = KErrNone;
+
+ if ( dlSize >= 100 )
+ {
+ event->iData = EPbDlStateDownloadCompleted;
+ }
+ else
+ {
+ event->iData = EPbDlStateDownloading;
+ }
+
+ AddExpectedEvent( event );
+
+ iDlMgrTester->ResumeDownload();
+ }
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::CancelDownloadL
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::CancelDownloadL( CStifItemParser& /*aItem*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::CancelDownloadL()"));
+ iLog->Log(_L("CVHPPTestClass::CancelDownloadL()"));
+
+ TCallbackEvent* event = new TCallbackEvent;
+
+ event->iEvent = EPDownloadStateChanged;
+ event->iData = EPbDlStateDownloadCanceled;
+ event->iError = KErrNone;
+
+ AddExpectedEvent( event );
+
+ iDlMgrTester->CancelDownload();
+
+ return KErrNone;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::RetrievePdlStatusL
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::RetrievePdlStatusL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::RetrievePdlStatusL()"));
+ iLog->Log(_L("CVHPPTestClass::RetrievePdlStatusL()"));
+
+ TInt pdlState;
+ TInt expectedPdlState;
+ TInt downloadedBytes;
+ TInt expectedDownloadedBytes;
+ TInt downloadSize;
+ TInt expectedDownloadSize;
+
+ //
+ // Read in the expected download data
+ //
+ TInt err = aItem.GetNextInt( expectedPdlState );
+
+ if ( err == KErrNone )
+ {
+ err = aItem.GetNextInt( expectedDownloadedBytes );
+
+ if ( err == KErrNone )
+ {
+ err = aItem.GetNextInt( expectedDownloadSize );
+ }
+ }
+
+ if ( err == KErrNone )
+ {
+ CMPXCommand* cmd( CMPXCommand::NewL() );
+ CleanupStack::PushL( cmd );
+
+ cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
+ cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD );
+ cmd->SetTObjectValueL<TMPXPlaybackPdCommand>( KMPXCommandPlaybackGeneralType,
+ EPbCmdGetPdStatus );
+
+ iPlaybackPlugin->CommandL( *cmd );
+
+ //
+ // Parse the PDL information
+ //
+
+ pdlState = cmd->ValueTObjectL<TMPXPlaybackPdDownloadState>( KMPXCommandPlaybackPDState );
+ downloadedBytes = cmd->ValueTObjectL<TInt>( KMPXCommandPlaybackPDDownloadedBytes );
+ downloadSize = cmd->ValueTObjectL<TInt>( KMPXCommandPlaybackPDTotalBytes );
+
+ MPX_DEBUG(_L(" Expected Data: PDL State = %d, current size = %d, total size = %d"),
+ expectedPdlState, expectedDownloadedBytes, expectedDownloadSize );
+
+ MPX_DEBUG(_L(" Received PDL State = %d, current size = %d, total size = %d"),
+ pdlState, downloadedBytes, downloadSize );
+
+ if ( ( expectedPdlState != pdlState ) ||
+ ( expectedDownloadedBytes != downloadedBytes ) ||
+ ( expectedDownloadSize != downloadSize ) )
+ {
+ err = KErrGeneral;
+ }
+
+ CleanupStack::PopAndDestroy( cmd );
+ }
+
+ return err;
+}
+
+void
+CVHPPTestClass::HandlePluginEvent( TEvent aEvent, TInt aData, TInt aError )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::HandlePluginEvent"),
+ _L("(%d, %d, %d)"), aEvent, aData, aError );
+
+ iLog->Log(_L("CVHPPTestClass::HandlePluginEvent(%d, %d, %d)"),
+ aEvent, aData, aError);
+
+ TCallbackEvent* callback = new TCallbackEvent;
+
+ callback->iEvent = aEvent;
+ callback->iData = aData;
+ callback->iError = aError;
+
+ ProcessEvent( callback );
+}
+
+void
+CVHPPTestClass::HandlePlaybackMessage( CMPXMessage* aMsg, TInt /*aErr*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::HandlePlaybackMessage()"));
+ iLog->Log(_L("CVHPPTestClass::HandlePlaybackMessage"));
+
+ TMPXMessageId id( *(aMsg->Value<TMPXMessageId>(KMPXMessageGeneralId)) );
+
+ if ( KMPXMediaIdVideoPlayback == id )
+ {
+ TMPXVideoPlaybackCommand message =
+ ( *(aMsg->Value<TMPXVideoPlaybackCommand>(KMPXMediaVideoPlaybackCommand)) );
+
+ switch ( message )
+ {
+ case EPbCmdPluginError:
+ {
+ TInt error( *aMsg->Value<TInt>( KMPXMediaVideoError ) );
+
+ ProcessErrorEvent( error );
+ break;
+ }
+ case EPbCmdTvOutEvent:
+ {
+ TCallbackEvent* callback = new TCallbackEvent;
+
+ callback->iEvent = EPbCmdTvOutEvent;
+ callback->iData = *aMsg->Value<TInt>( KMPXMediaVideoTvOutConnected );
+ callback->iError = *aMsg->Value<TInt>( KMPXMediaVideoTvOutPlayAllowed );
+
+ ProcessEvent( callback );
+
+ break;
+ }
+ }
+ }
+}
+
+void
+CVHPPTestClass::HandleProperty( TMPXPlaybackProperty aProperty,
+ TInt aValue,
+ TInt aError )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::HandleProperty()"));
+ iLog->Log(_L("CVHPPTestClass::HandleProperty"));
+
+ TCallbackEvent* callback = new TCallbackEvent;
+
+ callback->iEvent = aProperty;
+ callback->iData = aValue;
+ callback->iError = aError;
+
+ ProcessEvent( callback );
+}
+
+void
+CVHPPTestClass::HandleSubPlayerNames( TUid /*aPlayer*/,
+ const MDesCArray* /*aSubPlayers*/,
+ TBool /*aComplete*/,
+ TInt /*aError*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::HandleSubPlayerNames()"));
+ iLog->Log(_L("CVHPPTestClass::HandleSubPlayerNames"));
+
+ Signal();
+}
+
+void
+CVHPPTestClass::HandleMedia( CMPXMedia* aMedia, TInt /*aError*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::HandleMedia()"));
+ iLog->Log(_L("CVHPPTestClass::HandleMedia"));
+
+ //
+ // Check for an error condition
+ //
+ if ( aMedia->IsSupported( KMPXMediaVideoError ) )
+ {
+ MPX_DEBUG(_L("CVHPPTestClass::HandleMedia() Plugin has error"));
+
+ TInt error = aMedia->ValueTObjectL<TInt>( KMPXMediaVideoError );
+
+ ProcessErrorEvent( error );
+ }
+ else
+ {
+ TBool partialPlaybackError = EFalse;
+
+ if ( aMedia->IsSupported( KMPXMediaVideoPartialPlayback ) )
+ {
+ partialPlaybackError = aMedia->ValueTObjectL<TInt>( KMPXMediaVideoPartialPlayback );
+ }
+
+ if ( partialPlaybackError )
+ {
+ ProcessErrorEvent( KErrMMPartialPlayback );
+ }
+ else
+ {
+ Signal();
+ }
+ }
+}
+
+void
+CVHPPTestClass::HandlePlaybackCommandComplete( CMPXCommand* /*aCommandResult*/,
+ TInt /*aError*/ )
+{
+ MPX_DEBUG(_L("CVHPPTestClass::HandlePlaybackCommandComplete"));
+}
+
+void
+CVHPPTestClass::AddExpectedEvent( TCallbackEvent* aEvent )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::AddExpectedEvent()"));
+
+ iExpectedCallbackArray->AppendL( aEvent );
+
+ if ( iTimeoutController && ! iTimeoutController->IsActive() )
+ {
+ iTimeoutController->Start( TTimeIntervalMicroSeconds(15000000) );
+ }
+}
+
+void
+CVHPPTestClass::AddErrorEvent( TInt aError )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::AddErrorEvent"),
+ _L("(%d)"), aError );
+
+ iExpectedError = aError;
+
+ if ( iTimeoutController && ! iTimeoutController->IsActive() )
+ {
+ iTimeoutController->Start( TTimeIntervalMicroSeconds(15000000) );
+ }
+}
+
+void
+CVHPPTestClass::HandleTimeout( TInt aError )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::HandleTimeout"),
+ _L("(%d)"), aError );
+
+ if ( aError == KErrNone )
+ {
+ iLog->Log(_L(" Callback timed out"));
+ Signal( KErrTimedOut );
+ }
+ else
+ {
+ iLog->Log(_L(" Callback timeout error %d"), aError);
+ Signal( aError );
+ }
+}
+
+void
+CVHPPTestClass::ProcessEvent( TCallbackEvent* aCallback )
+{
+ if ( iExpectedCallbackArray->Count() > 0 )
+ {
+ TCallbackEvent* expectedCallback = (*iExpectedCallbackArray)[0];
+
+ MPX_DEBUG(_L("CVHPPTestClass::ProcessEvent(%d,%d,%d) Expected(%d,%d,%d)"),
+ aCallback->iEvent, aCallback->iData, aCallback->iError,
+ expectedCallback->iEvent, expectedCallback->iData, expectedCallback->iError);
+
+ if ( expectedCallback->iEvent == aCallback->iEvent )
+ {
+ if ( expectedCallback->iData == aCallback->iData &&
+ expectedCallback->iError == aCallback->iError )
+ {
+ MPX_DEBUG(_L("Callback received with proper error code"));
+ iLog->Log(_L("Callback received with proper error code"));
+
+ //
+ // Pop the event from the array
+ //
+ iExpectedCallbackArray->Delete( 0 );
+
+ if ( iExpectedCallbackArray->Count() == 0 )
+ {
+ iTimeoutController->Cancel();
+ }
+
+ Signal();
+ }
+ else
+ {
+ iTimeoutController->Cancel();
+ MPX_DEBUG(_L("Callback received with wrong error code"));
+ iLog->Log(_L("Callback received with wrong error code"));
+ Signal( KErrGeneral );
+ }
+ }
+ }
+ else
+ {
+ if ( ! ( iAllowPositionCallback && aCallback->iEvent == EPPositionChanged ) )
+ {
+ //
+ // Unexpected event
+ //
+ _LIT( KPanic, "Unexpected Event" );
+ User::Panic( KPanic, -33 );
+ }
+ }
+
+ delete aCallback;
+}
+
+void
+CVHPPTestClass::ProcessErrorEvent( TInt aError )
+{
+ MPX_DEBUG(_L("CVHPPTestClass::ProcessErrorEvent(%d) ExpectedError(%d)"),
+ aError, iExpectedError );
+
+ iLog->Log(_L(" Error received (%d)"), aError );
+
+ if ( iExpectedError == aError )
+ {
+ iTimeoutController->Cancel();
+
+ MPX_DEBUG(_L("Error received with proper error code"));
+ iLog->Log(_L("Error received with proper error code"));
+ Signal();
+
+ iExpectedError = KErrNone;
+ }
+ else
+ {
+ iTimeoutController->Cancel();
+
+ MPX_DEBUG(_L("Unexpected error received"));
+ iLog->Log(_L("Unexpected error received"));
+ Signal( KErrAbort );
+
+ iExpectedError = KErrNone;
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::ChangeAspectRatioL
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::ChangeAspectRatioL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::ChangeAspectRatioL()"));
+ iLog->Log(_L("CVHPPTestClass::ChangeAspectRatioL()"));
+
+ TInt aspectRatioCmd = 0;
+ TInt expectedResult = 0;
+ TInt err = aItem.GetNextInt( aspectRatioCmd );
+
+ if ( err == KErrNone )
+ {
+ err = aItem.GetNextInt( expectedResult );
+
+ if ( err == KErrNone )
+ {
+ //
+ // create command to pass to playback plugin
+ //
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd );
+
+ cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
+ cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXMediaIdVideoPlayback );
+
+ cmd->SetTObjectValueL<TInt>( KMPXMediaVideoPlaybackCommand,
+ (TMPXVideoPlaybackCommand)aspectRatioCmd );
+
+ iPlaybackPlugin->CommandL( *cmd );
+
+ TInt result = cmd->ValueTObjectL<TInt>( KMPXMediaVideoAspectRatio );
+
+ if ( expectedResult != result )
+ {
+ err = KErrGeneral;
+ }
+
+ CleanupStack::PopAndDestroy( cmd );
+ }
+ }
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::AlarmOn
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::AlarmOn( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::AlarmOn()"));
+ iLog->Log(_L("CVHPPTestClass::AlarmOn()"));
+
+ TInt backgroundCmd = 0;
+ TInt err = aItem.GetNextInt( backgroundCmd );
+
+ if ( err == KErrNone )
+ {
+ //callback event
+ TCallbackEvent* event = new TCallbackEvent;
+ event->iError = 0;
+ event->iData = 0;
+ event->iEvent = EPPaused;
+ AddExpectedEvent( event );
+
+ // set alarm status
+ RProperty::Set( KPSUidCoreApplicationUIs, KLightsAlarmLightActive, ELightsBlinking );
+
+ //
+ // create background Cmd to pass to playback plugin
+ //
+ CMPXCommand* cmdPause = CMPXCommand::NewL();
+ CleanupStack::PushL( cmdPause );
+ cmdPause->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
+ cmdPause->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXMediaIdVideoPlayback );
+ cmdPause->SetTObjectValueL<TInt>( KMPXMediaVideoPlaybackCommand, backgroundCmd );
+ cmdPause->SetTObjectValueL<TBool>( KMPXMediaVideoAppForeground, ETrue );
+ iPlaybackPlugin->CommandL( *cmdPause );
+ CleanupStack::PopAndDestroy( cmdPause );
+
+ //reset alarm
+ RProperty::Set( KPSUidCoreApplicationUIs, KLightsAlarmLightActive, ELightsNotBlinking );
+ }
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::AlarmOnAndOff
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::AlarmAutoResume( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::AlarmOnAndOff()"));
+ iLog->Log(_L("CVHPPTestClass::AlarmOnAndOff()"));
+
+ TInt backgroundCmd = 0;
+ TInt err = 0;//aItem.GetNextInt( backgroundCmd );
+
+ err = AlarmOn(aItem);
+
+ if ( err == KErrNone )
+ {
+ err = aItem.GetNextInt( backgroundCmd );
+
+ //reset alarm
+ RProperty::Set( KPSUidCoreApplicationUIs, KLightsAlarmLightActive, ELightsNotBlinking );
+
+ if ( err == KErrNone )
+ {
+ TCallbackEvent* event = new TCallbackEvent;
+ event->iError = 0;
+ event->iData = 0;
+ event->iEvent = EPPlaying;
+ AddExpectedEvent( event );
+
+ //auto resume if alarm off
+ CMPXCommand* cmdPlay = CMPXCommand::NewL();
+ CleanupStack::PushL( cmdPlay );
+ cmdPlay->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
+ cmdPlay->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXMediaIdVideoPlayback );
+ cmdPlay->SetTObjectValueL<TInt>( KMPXMediaVideoPlaybackCommand, backgroundCmd );
+ cmdPlay->SetTObjectValueL<TBool>( KMPXMediaVideoAppForeground, ETrue );
+ iPlaybackPlugin->CommandL( *cmdPlay );
+ CleanupStack::PopAndDestroy( cmdPlay );
+ }
+ }
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::PhoneCallRejected
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::PhoneCallRejected( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::PhoneCallRejected()"));
+ iLog->Log(_L("CVHPPTestClass::PhoneCallRejected()"));
+
+ TInt background = 0;
+ TInt err = aItem.GetNextInt( background );
+ TCallbackEvent* event = new TCallbackEvent;
+
+ if ( err == KErrNone )
+ {
+ //callback event
+ TCallbackEvent* event = new TCallbackEvent;
+ event->iError = 0;
+ event->iData = 0;
+ event->iEvent = EPPaused;
+ AddExpectedEvent( event );
+
+ //set phone call as ringing
+ RProperty::Set(KPSUidCtsyCallInformation, KCTsyCallState, EPSCTsyCallStateRinging);
+
+ //pause
+ CreateBackgroundCommand(background);
+
+ err = aItem.GetNextInt( background );
+
+ if ( err == KErrNone )
+ {
+ //
+ // Clear ringing
+ //
+ RProperty::Set(KPSUidCtsyCallInformation, KCTsyCallState, EPSCTsyCallStateNone);
+
+ CreateBackgroundCommand(background);
+ }
+ }
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::VoiceCallAccepted
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::VoiceCallAccepted( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::VoiceCallAccepted()"));
+ iLog->Log(_L("CVHPPTestClass::VoiceCallAccepted()"));
+
+ TInt background = 0;
+ TInt err = aItem.GetNextInt( background );
+
+ if ( err == KErrNone )
+ {
+ //callback event
+ TCallbackEvent* event = new TCallbackEvent;
+ event->iError = 0;
+ event->iData = 0;
+ event->iEvent = EPPaused;
+ AddExpectedEvent( event );
+
+ //set phone call as ringing
+ RProperty::Set(KPSUidCtsyCallInformation, KCTsyCallState, EPSCTsyCallStateRinging);
+
+ //pause
+ CreateBackgroundCommand(background);
+
+ err = aItem.GetNextInt( background );
+
+ if ( err == KErrNone )
+ {
+ //set phone call as Connected
+ RProperty::Set(KPSUidCtsyCallInformation, KCTsyCallState, EPSCTsyCallStateConnected);
+
+ CreateBackgroundCommand(background);
+ }
+ }
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::VideoCallAccepted
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::VideoCallAccepted( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::VideoCallAccepted()"));
+ iLog->Log(_L("CVHPPTestClass::VideoCallAccepted()"));
+
+ TInt background = 0;
+ TInt err = aItem.GetNextInt( background );
+
+ if ( err == KErrNone )
+ {
+ //callback event
+ TCallbackEvent* event = new TCallbackEvent;
+ event->iError = 0;
+ event->iData = 0;
+ event->iEvent = EPPaused;
+ AddExpectedEvent( event );
+
+ //set phone call as ringing
+ RProperty::Set(KPSUidCtsyCallInformation, KCTsyCallState, EPSCTsyCallStateRinging);
+
+ //pause
+ CreateBackgroundCommand(background);
+
+ err = aItem.GetNextInt( background );
+
+ if ( err == KErrNone )
+ {
+ //set phone call as Connected
+ RProperty::Set(KPSUidCtsyCallInformation, KCTsyCallType, EPSCTsyCallTypeH324Multimedia);
+
+ CreateBackgroundCommand(background);
+ }
+ }
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::PlayduringVideoCall
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::PlayduringVideoCall( CStifItemParser& /*aItem*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::PlayduringVideoCall()"));
+ iLog->Log(_L("CVHPPTestClass::PlayduringVideoCall()"));
+
+ TInt err = 0;
+
+ //set phone call as Connected
+ err = RProperty::Set(KPSUidCtsyCallInformation, KCTsyCallType, EPSCTsyCallTypeH324Multimedia);
+
+ AddErrorEvent(KMPXVideoCallOngoingError);
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CVHPPTestClass::PlayduringVoiceCall
+// -----------------------------------------------------------------------------
+//
+TInt
+CVHPPTestClass::PlayduringVoiceCall( CStifItemParser& /*aItem*/ )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::PlayduringVoiceCall()"));
+ iLog->Log(_L("CVHPPTestClass::PlayduringVoiceCall()"));
+
+ TInt err = 0;
+
+ //set phone call as Connected
+ err = RProperty::Set(KPSUidCtsyCallInformation, KCTsyCallState, EPSCTsyCallStateConnected);
+
+ AddErrorEvent(KMPXVideoPlayOver2GDuringVoiceCallError);
+
+ return err;
+}
+
+TInt
+CVHPPTestClass::EndPhoneCall()
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::EndPhoneCall()"));
+ iLog->Log(_L("CVHPPTestClass::EndPhoneCall()"));
+
+ //Disconnect phone call
+ RProperty::Set(KPSUidCtsyCallInformation, KCTsyCallState, EPSCTsyCallStateNone);
+ RProperty::Set(KPSUidCtsyCallInformation, KCTsyCallType, EPSCTsyCallTypeNone);
+
+ return KErrNone;
+}
+
+TInt
+CVHPPTestClass::ConnectTvOutL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::ConnectTvOutL()"));
+ iLog->Log(_L("CVHPPTestClass::ConnectTvOutL()"));
+
+ TBool playable = EFalse;
+
+ TInt err = aItem.GetNextInt( playable );
+
+ if ( err == KErrNone )
+ {
+ if ( ! playable )
+ {
+ TCallbackEvent* event = new TCallbackEvent;
+
+ event->iEvent = EPPaused;
+ event->iData = 0;
+ event->iError = 0;
+
+ AddExpectedEvent( event );
+
+ iExpectedError = KMPXVideoTvOutPlaybackNotAllowed;
+ }
+
+ //
+ // Add event for callback
+ //
+ TCallbackEvent* event = new TCallbackEvent;
+
+ event->iEvent = EPbCmdTvOutEvent;
+ event->iData = ETrue;
+ event->iError = playable;
+
+ AddExpectedEvent( event );
+ }
+
+ iAccObserver->UpdateTvOutStatusL( ETrue );
+
+ return err;
+}
+
+TInt
+CVHPPTestClass::DisconnectTvOutL()
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::DisconnectTvOutL()"));
+ iLog->Log(_L("CVHPPTestClass::DisconnectTvOutL()"));
+
+ //
+ // Add event for callback
+ //
+ TCallbackEvent* event = new TCallbackEvent;
+
+ event->iEvent = EPbCmdTvOutEvent;
+ event->iData = EFalse;
+ event->iError = ETrue;
+
+ AddExpectedEvent( event );
+
+ iAccObserver->UpdateTvOutStatusL( EFalse );
+
+ return KErrNone;
+}
+
+void
+CVHPPTestClass::CreateBackgroundCommand( TBool aBackground )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::CreateBackgroundCommand()"),
+ _L("aBackground = %d"), aBackground );
+
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd );
+ cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
+ cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXMediaIdVideoPlayback );
+ cmd->SetTObjectValueL<TInt>( KMPXMediaVideoPlaybackCommand, aBackground );
+ cmd->SetTObjectValueL<TBool>( KMPXMediaVideoAppForeground, ETrue );
+ iPlaybackPlugin->CommandL( *cmd );
+ CleanupStack::PopAndDestroy( cmd );
+}
+
+TInt
+CVHPPTestClass::SetTvOutConnectedL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::SetTvOutConnectedL()"));
+ iLog->Log(_L("CVHPPTestClass::SetTvOutConnectedL()"));
+
+ TInt allowed = ETrue;
+
+ TInt err = aItem.GetNextInt( allowed );
+
+ if ( err == KErrNone )
+ {
+ iAccObserver->SetTvOutConnected( ETrue );
+ iAccObserver->SetTvOutPlaybackAllowed( allowed );
+ }
+
+ return err;
+}
+
+TInt
+CVHPPTestClass::SetTvOutDisconnectedL()
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::SetTvOutDisconnectedL()"));
+ iLog->Log(_L("CVHPPTestClass::SetTvOutDisconnectedL()"));
+
+ iAccObserver->SetTvOutConnected( EFalse );
+ iAccObserver->SetTvOutPlaybackAllowed( ETrue );
+
+ return KErrNone;
+}
+
+void
+CVHPPTestClass::HandleUtilityEvent( TCallbackEvent* aEvent )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::HandleUtilityEvent"),
+ _L("(%d, %d, %d)"), aEvent->iEvent, aEvent->iData, aEvent->iError );
+
+ ProcessEvent( aEvent );
+}
+
+void
+CVHPPTestClass::CleanupTempFiles()
+{
+ RFs fs;
+ TInt error = fs.Connect();
+
+ error = fs.Delete( KOpenControllerFilename );
+ error = fs.Delete( KPrepareControllerFilename );
+ error = fs.Delete( KPlaybackCompleteFilename );
+ error = fs.Delete( KDlMgrFile );
+ error = fs.Delete( KDrmRightsFile );
+
+ fs.Close();
+}
+
+TInt
+CVHPPTestClass::SetDrmProtectedL( CStifItemParser& aItem )
+{
+ MPX_ENTER_EXIT(_L("CVHPPTestClass::SetDrmProtectedL()"));
+
+ TBool drmError = EFalse;
+
+ TInt err = aItem.GetNextInt( drmError );
+
+ if ( err == KErrNone )
+ {
+ WriteControllerError( KDrmRightsFile, drmError );
+ }
+
+ 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;
+}
+
+// EOF