diff -r 000000000000 -r 96612d01cf9f videoplayback/videohelix/tsrc/ut_videohelixtest/src/videohelixtestbody.cpp --- /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 +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "dlmgr_stub.h" +#include "mpxvideoregion.h" +#include "videohelixtest.h" +#include "mpxvideoaccessoryobserver_stub.h" +#include +#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( KMPXCommandGeneralDoSync, ETrue ); + + cmd->SetTObjectValueL( KMPXCommandGeneralId, + KMPXCommandIdPlaybackGeneral ); + + cmd->SetTObjectValueL( 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(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( KMPXCommandGeneralDoSync, ETrue ); + + cmd->SetTObjectValueL( KMPXCommandGeneralId, + KMPXMediaIdVideoPlayback ); + + cmd->SetTObjectValueL( 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( 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( KMPXMediaVideoPlaybackTRect, rect ); + + cmd->SetCObjectValueL( 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 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( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD ); + cmd->SetTObjectValueL( KMPXCommandPlaybackGeneralType, EPbCmdStartPd ); + cmd->SetTObjectValueL( KMPXCommandPlaybackPDTransactionID, dlId ); + cmd->SetTextValueL( KMPXMediaVideoPlaybackFileName, fullPath ); + cmd->SetTObjectValueL( 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( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD ); + cmd->SetTObjectValueL( 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( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD ); + cmd->SetTObjectValueL( KMPXCommandPlaybackGeneralType, + EPbCmdGetPdStatus ); + + iPlaybackPlugin->CommandL( *cmd ); + + // + // Parse the PDL information + // + + pdlState = cmd->ValueTObjectL( KMPXCommandPlaybackPDState ); + downloadedBytes = cmd->ValueTObjectL( KMPXCommandPlaybackPDDownloadedBytes ); + downloadSize = cmd->ValueTObjectL( 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(KMPXMessageGeneralId)) ); + + if ( KMPXMediaIdVideoPlayback == id ) + { + TMPXVideoPlaybackCommand message = + ( *(aMsg->Value(KMPXMediaVideoPlaybackCommand)) ); + + switch ( message ) + { + case EPbCmdPluginError: + { + TInt error( *aMsg->Value( KMPXMediaVideoError ) ); + + ProcessErrorEvent( error ); + break; + } + case EPbCmdTvOutEvent: + { + TCallbackEvent* callback = new TCallbackEvent; + + callback->iEvent = EPbCmdTvOutEvent; + callback->iData = *aMsg->Value( KMPXMediaVideoTvOutConnected ); + callback->iError = *aMsg->Value( 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( KMPXMediaVideoError ); + + ProcessErrorEvent( error ); + } + else + { + TBool partialPlaybackError = EFalse; + + if ( aMedia->IsSupported( KMPXMediaVideoPartialPlayback ) ) + { + partialPlaybackError = aMedia->ValueTObjectL( 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( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXMediaIdVideoPlayback ); + + cmd->SetTObjectValueL( KMPXMediaVideoPlaybackCommand, + (TMPXVideoPlaybackCommand)aspectRatioCmd ); + + iPlaybackPlugin->CommandL( *cmd ); + + TInt result = cmd->ValueTObjectL( 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( KMPXCommandGeneralDoSync, ETrue ); + cmdPause->SetTObjectValueL( KMPXCommandGeneralId, KMPXMediaIdVideoPlayback ); + cmdPause->SetTObjectValueL( KMPXMediaVideoPlaybackCommand, backgroundCmd ); + cmdPause->SetTObjectValueL( 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( KMPXCommandGeneralDoSync, ETrue ); + cmdPlay->SetTObjectValueL( KMPXCommandGeneralId, KMPXMediaIdVideoPlayback ); + cmdPlay->SetTObjectValueL( KMPXMediaVideoPlaybackCommand, backgroundCmd ); + cmdPlay->SetTObjectValueL( 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( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXMediaIdVideoPlayback ); + cmd->SetTObjectValueL( KMPXMediaVideoPlaybackCommand, aBackground ); + cmd->SetTObjectValueL( 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