--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmaudio_pub/drm_audio_player_api/tsrc/DRMAudioPlay/src/DRMAudioPlay_core.cpp Thu Oct 07 22:34:12 2010 +0100
@@ -0,0 +1,4039 @@
+/*
+* Copyright (c) 2002 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: DRM Player
+*
+*/
+
+// INCLUDE FILES
+#include <StifTestInterface.h>
+#include "DRMAudioPlay.h"
+#include <caf.h>
+#include <caf/supplier.h>
+#include <caf/importfile.h>
+#include <BAUTILS.H>
+
+using namespace ContentAccess;
+
+ // Constants
+ const TInt CDRMAudioPlay::MAX_TESTCASE_ID = 1046;
+ const TInt CDRMAudioPlay::KDefaultRepeats = 5;
+ const TInt CDRMAudioPlay::KDefaultRepeatForever = -2;
+ const TInt CDRMAudioPlay::KDefaultPauseDelay = 1000000;
+ const TInt CDRMAudioPlay::KDefaultPlayDelay = 3000000;
+ const TInt CDRMAudioPlay::KDefaultStopOpenPlayDelay = 1000000;
+ const TInt CDRMAudioPlay::KDefaultReportDelay = 500000;
+
+ // Taken from Oma2Agent.h
+ _LIT8(KOma1XmlRoContentType, "application/vnd.oma.drm.rights+xml");
+
+ //Cases
+ const TInt CDRMAudioPlay::KCaseImplementationInformation = 1001;
+ const TInt CDRMAudioPlay::KCasePlayFile = 1002;
+ const TInt CDRMAudioPlay::KCasePlayFileStopOpen = 1003;
+ const TInt CDRMAudioPlay::KCasePlayDes = 1004;
+ const TInt CDRMAudioPlay::KCasePlayDesStopOpen = 1005;
+ const TInt CDRMAudioPlay::KCasePlayUrl = 1006;
+ const TInt CDRMAudioPlay::KCasePlayUrlStopOpen = 1007;
+ const TInt CDRMAudioPlay::KCasePlayFileWithPause = 1008;
+ const TInt CDRMAudioPlay::KCasePlayFileWithPosition = 1009;
+ const TInt CDRMAudioPlay::KCasePlayFileReportPosition = 1010;
+ const TInt CDRMAudioPlay::KCasePlayFileReportDuration = 1011;
+ const TInt CDRMAudioPlay::KCasePlayFilesWithVolumes = 1012;
+ const TInt CDRMAudioPlay::KCasePlayFileWithRamp = 1013;
+ const TInt CDRMAudioPlay::KCasePlayFileMetaInfo = 1014;
+ const TInt CDRMAudioPlay::KCasePlayFileWindow = 1015;
+ const TInt CDRMAudioPlay::KCasePlayFileClearWindow = 1016;
+ const TInt CDRMAudioPlay::KCasePlayFileWithRepeats = 1017;
+ const TInt CDRMAudioPlay::KCasePlayFileWithBalance = 1018;
+ const TInt CDRMAudioPlay::KCasePlayFilesWithPriorities = 1019;
+ const TInt CDRMAudioPlay::KCasePlayHandler = 1020;
+ const TInt CDRMAudioPlay::KCasePlayHandlerStopOpen = 1021;
+ const TInt CDRMAudioPlay::KCasePlayHandlerWithPause = 1022;
+ const TInt CDRMAudioPlay::KCasePlayFileHandlerWithRamp = 1023;
+ const TInt CDRMAudioPlay::KCasePlayFileHandlerWithSetPosition = 1024;
+ const TInt CDRMAudioPlay::KCasePlayFileHandlerWithGetPosition = 1025;
+ const TInt CDRMAudioPlay::KCasePlayFileHandlerWithDuration = 1026;
+ const TInt CDRMAudioPlay::KCasePlayFileHandlerWithWindow = 1027;
+ const TInt CDRMAudioPlay::KCasePlayFileHandlerWithClearWindow = 1028;
+ const TInt CDRMAudioPlay::KCasePlayFileSetVolume = 1029;
+ const TInt CDRMAudioPlay::KCasePlayFileGetBalance = 1030;
+ const TInt CDRMAudioPlay::KCasePlayFileGetBitRate = 1031;
+ const TInt CDRMAudioPlay::KCasePlayFileGetAudioLoadingProgress = 1032;
+ const TInt CDRMAudioPlay::KCasePlayFileRegisterForAudioLoadingNotification = 1033;
+ const TInt CDRMAudioPlay::KCasePlayFileImplementationInformation = 1034;
+ const TInt CDRMAudioPlay::KCasePlayFileMaxVolume = 1035;
+ const TInt CDRMAudioPlay::KCasePlayFileSetBalance = 1036;
+ const TInt CDRMAudioPlay::KCasePlayFileSetPriority = 1037;
+ const TInt CDRMAudioPlay::KCasePlayFileSetRepeats = 1038;
+ const TInt CDRMAudioPlay::KCasePlayFilesGetMetaDataEntry = 1039;
+ const TInt CDRMAudioPlay::KCasePlayFilesGetNumberOfMetaDataEntries = 1040;
+ const TInt CDRMAudioPlay::KCasePlayRepeatDRMFile = 1041;
+ const TInt CDRMAudioPlay::KCasePlayPauseRepeatDRMFile = 1042;
+ const TInt CDRMAudioPlay::KCasePlayRepeatDRMFileForever = 1043;
+ const TInt CDRMAudioPlay::KCasePlayRepeatDRMFileWithPlayWindow = 1044;
+ const TInt CDRMAudioPlay::KCasePlayPauseRepeatDRMFileWithPlayWindow = 1045;
+ const TInt CDRMAudioPlay::KCasePlayRepeatForeverDRMFileWithPlayWindow = 1046;
+
+// ** FilePlay *******************************************************
+TInt CDRMAudioPlay::TestCasePlayFileWithPauseL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 PauseDelay=KDefaultPauseDelay;
+ TTimeIntervalMicroSeconds32 PlayDelay=KDefaultPlayDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************************************
+ TBool UsingDefault;
+ PauseDelay = GetTimeIntervalL(section, KTagPauseDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPauseDelay);
+ if (UsingDefault) {iLogger->Log(_L("Error retrieving pause delay, using default"));}
+
+ PlayDelay = GetTimeIntervalL(section, KTagPlayDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPlayDelay);
+ if (UsingDefault) {iLogger->Log(_L("Error retrieving play delay, using default"));}
+
+ if (PauseDelay > PlayDelay)
+ {
+ //Pause delay longer than play delay. Switching
+ TTimeIntervalMicroSeconds32 TempDelay = PlayDelay;
+ PlayDelay = PauseDelay;
+ PauseDelay = TempDelay;
+ }
+ iLogger->Log(_L("Setting Pause and Play delays to [%d] and [%d]"), PauseDelay.Int(), PlayDelay.Int());
+
+ TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);
+ if (UsingDefault) {iLogger->Log(_L("Using default error range"));}
+
+ //*********************************************
+
+ CParameters *pauseParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPause );
+ CleanupStack::PushL(pauseParams);
+
+ CParameters *playParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPlay );
+ CleanupStack::PushL(playParams);
+
+ CMediaEvent *mEventPlay = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PlayDelay, PlayDelay, sndPlayer, playParams);
+ CMediaEvent *mEventPause = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PauseDelay, PauseDelay, sndPlayer, pauseParams, CActive::EPriorityStandard+1);
+
+ iLogger->Log(_L("Starting scheduler"));
+ TTime StartTime, EndTime;
+ StartTime.HomeTime();
+ CActiveScheduler::Start();
+ EndTime.HomeTime();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ TTimeIntervalMicroSeconds PerceivedDuration = EndTime.MicroSecondsFrom( StartTime );
+
+ TTime ExpectedEnd = StartTime + sndPlayer->GetDuration() + PlayDelay - PauseDelay;
+ TTime Range1 = ExpectedEnd - ErrorRange;
+ TTime Range2 = ExpectedEnd + ErrorRange;
+
+ TTimeIntervalMicroSeconds ExpectedDuration = ExpectedEnd.MicroSecondsFrom( StartTime );
+
+ iLogger->Log(_L("Perceived duration (%d)") , PerceivedDuration.Int64() );
+
+ iLogger->Log(_L("Expected duration (%d)"), ExpectedDuration.Int64() );
+ // iLogger->Log(_L("Difference = (%d)") , ExpectedEnd.MicroSecondsFrom(EndTime) );
+
+ if (mEventPlay->GetCount()<=0 || mEventPause->GetCount()<=0)
+ {
+ iLogger->Log( KTestCaseResultFailSkippedEvents() );
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ aResult.iResult = KErrSkippedEvents;
+ }
+ else if (EndTime < Range1 || Range2 < EndTime)
+ { //Durations too different
+ iLogger->Log(_L("The clips duration + silence duration (%d) is too different from the actual duration (%d)") , ExpectedDuration.Int64() , PerceivedDuration.Int64() );
+ aResult.iResult = KErrExpectedValueDifferent;
+ aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());
+ }
+ else if (sndPlayer->iFinalError)
+ {
+ aResult.iResult = sndPlayer->iFinalError;
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ CleanupStack::PopAndDestroy(mEventPause);
+ CleanupStack::PopAndDestroy(mEventPlay);
+ CleanupStack::Pop(playParams);
+ CleanupStack::Pop(pauseParams);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+TInt CDRMAudioPlay::TestCasePlayHandlerWithPauseL(CStifSectionParser *section , TTestResult &aResult)
+ {
+
+ TPtrC FileNamePtr;
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+
+ TTimeIntervalMicroSeconds32 PauseDelay = KDefaultPauseDelay;
+ TTimeIntervalMicroSeconds32 PlayDelay = KDefaultPlayDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+
+ iLogger->Log(_L("Creating simple player with file handler [%S]"), &FileNamePtr);
+ User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));
+
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+
+ iFile.Close();
+ // iFs.Close();
+
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************************************
+ TBool UsingDefault;
+ PauseDelay = GetTimeIntervalL(section, KTagPauseDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPauseDelay);
+ if (UsingDefault) {iLogger->Log(_L("Error retrieving pause delay, using default"));}
+
+ PlayDelay = GetTimeIntervalL(section, KTagPlayDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPlayDelay);
+ if (UsingDefault) {iLogger->Log(_L("Error retrieving play delay, using default"));}
+
+ if (PauseDelay > PlayDelay)
+ {
+ //Pause delay longer than play delay. Switching
+ TTimeIntervalMicroSeconds32 TempDelay = PlayDelay;
+ PlayDelay = PauseDelay;
+ PauseDelay = TempDelay;
+ }
+ iLogger->Log(_L("Setting Pause and Play delays to [%d] and [%d]"), PauseDelay.Int(), PlayDelay.Int());
+
+ TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);
+ if (UsingDefault) {iLogger->Log(_L("Using default error range"));}
+
+ //*********************************************
+
+ CParameters *pauseParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPause );
+ CleanupStack::PushL(pauseParams);
+
+ CParameters *playParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPlay );
+ CleanupStack::PushL(playParams);
+
+ CMediaEvent *mEventPlay = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PlayDelay, PlayDelay, sndPlayer, playParams);
+ CMediaEvent *mEventPause = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PauseDelay, PauseDelay, sndPlayer, pauseParams, CActive::EPriorityStandard+1);
+
+ iLogger->Log(_L("Starting scheduler"));
+ TTime StartTime, EndTime;
+ StartTime.HomeTime();
+ CActiveScheduler::Start();
+ EndTime.HomeTime();
+
+ iFs.Close();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ TTimeIntervalMicroSeconds PerceivedDuration = EndTime.MicroSecondsFrom( StartTime );
+
+ TTime ExpectedEnd = StartTime + sndPlayer->GetDuration() + PlayDelay - PauseDelay;
+ TTime Range1 = ExpectedEnd - ErrorRange;
+ TTime Range2 = ExpectedEnd + ErrorRange;
+
+ TTimeIntervalMicroSeconds ExpectedDuration = ExpectedEnd.MicroSecondsFrom( StartTime );
+
+ iLogger->Log(_L("Perceived duration (%d)") , PerceivedDuration.Int64() );
+
+ iLogger->Log(_L("Expected duration (%d)"), ExpectedDuration.Int64() );
+
+ // iLogger->Log(_L("Difference = (%d)") , ExpectedEnd.MicroSecondsFrom(EndTime) );
+
+ if (mEventPlay->GetCount()<=0 || mEventPause->GetCount()<=0)
+ {
+ iLogger->Log( KTestCaseResultFailSkippedEvents() );
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ aResult.iResult = KErrSkippedEvents;
+ }
+ else if (EndTime < Range1 || Range2 < EndTime)
+ { //Durations too different
+ iLogger->Log(_L("The clips duration + silence duration (%d) is too different from the actual duration (%d)") , ExpectedDuration.Int64() , PerceivedDuration.Int64() );
+ aResult.iResult = KErrExpectedValueDifferent;
+ aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());
+ }
+ else if (sndPlayer->iFinalError)
+ {
+ aResult.iResult = sndPlayer->iFinalError;
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+
+ CleanupStack::PopAndDestroy(mEventPause);
+ CleanupStack::PopAndDestroy(mEventPlay);
+ CleanupStack::Pop(playParams);
+ CleanupStack::Pop(pauseParams);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+TInt CDRMAudioPlay::TestCasePlayFileL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ CStifItemParser *item;
+ TInt parseError = KErrNone;
+ TBool Immediate = 0;
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ item = section->GetItemLineL(KTagImmediate);
+ if (item)
+ {
+ CleanupStack::PushL(item);
+ parseError = item->GetInt(KTagImmediate, Immediate);
+ CleanupStack::PopAndDestroy(item);
+ }
+ item = NULL;
+ TBool FileType = EFalse;
+ item = section->GetItemLineL(KTagFileType);
+ if (item)
+ {
+ CleanupStack::PushL(item);
+ parseError = item->GetInt(KTagFileType, FileType);
+ CleanupStack::PopAndDestroy(item);
+ }
+
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger, Immediate, FileType);
+
+ CleanupStack::PushL(sndPlayer);
+ iLogger->Log(_L("Starting scheduler"));
+
+ CActiveScheduler::Start();
+
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError ;
+
+ TBool DontCheckExpectedDuration;
+ TTimeIntervalMicroSeconds ErrorRange=GetTimeIntervalL(section, KTagErrorRange, DontCheckExpectedDuration);
+ if (!DontCheckExpectedDuration && !aResult.iResult)
+ {
+ TBool DontUseExpectedDuration;
+ TTimeIntervalMicroSeconds ExpectedDuration=GetTimeIntervalL(section, KTagExpectedDuration, DontUseExpectedDuration);
+ if (!IsDurationInRange(0, (DontUseExpectedDuration ? sndPlayer->GetDuration() : ExpectedDuration), TTimeIntervalMicroSeconds(0), ErrorRange, sndPlayer->GetPlayStartTime(), sndPlayer->GetPlayStopTime() ) )
+ {
+ iLogger->Log(_L("Duration too different"));
+ aResult.iResult = KErrExpectedValueDifferent;
+ }
+ }
+
+ if (aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayHandlerL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+
+ User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));
+ // TRAP(err, iAudioPlayer->OpenFileL( iFile ));
+
+ // CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+
+ iFile.Close();
+ // iFs.Close();
+
+ CleanupStack::PushL(sndPlayer);
+ iLogger->Log(_L("Starting scheduler"));
+
+ CActiveScheduler::Start();
+
+ iFs.Close();
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError ;
+
+ TBool DontCheckExpectedDuration;
+ TTimeIntervalMicroSeconds ErrorRange=GetTimeIntervalL(section, KTagErrorRange, DontCheckExpectedDuration);
+ if (!DontCheckExpectedDuration && !aResult.iResult)
+ {
+ TBool DontUseExpectedDuration;
+ TTimeIntervalMicroSeconds ExpectedDuration=GetTimeIntervalL(section, KTagExpectedDuration, DontUseExpectedDuration);
+ if (!IsDurationInRange(0, (DontUseExpectedDuration ? sndPlayer->GetDuration() : ExpectedDuration), TTimeIntervalMicroSeconds(0), ErrorRange, sndPlayer->GetPlayStartTime(), sndPlayer->GetPlayStopTime() ) )
+ {
+ iLogger->Log(_L("Duration too different"));
+ aResult.iResult = KErrExpectedValueDifferent;
+ }
+ }
+
+ if (aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayFileWithRepeatsL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TInt Repeats = KDefaultRepeats;
+ TTimeIntervalMicroSeconds SilenceDuration = KDefaultSilenceDuration;
+ TInt ParseError=KErrNone;
+ CStifItemParser *item;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ TBool DontCheckExpectedDuration;
+ TTimeIntervalMicroSeconds ErrorRange=GetTimeIntervalL(section, KTagErrorRange, DontCheckExpectedDuration);
+
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //Setup repeat count
+ ParseError=KErrNotFound;
+ item = section->GetItemLineL(KTagRepeatTimes);
+ if (item)
+ {
+ CleanupStack::PushL(item);
+ ParseError = item->GetInt(KTagRepeatTimes, Repeats);
+ CleanupStack::PopAndDestroy(item);
+ }
+ iLogger->Log(_L("Setting up repeat count to %d"), Repeats);
+ if (ParseError)
+ {
+ iLogger->Log(_L("Using default value of %d"), KDefaultRepeats); Repeats=KDefaultRepeats;
+ }
+
+ TBool UsingDefault;
+ SilenceDuration = GetTimeIntervalL(section, KTagSilenceDuration, UsingDefault, KDefaultSilenceDuration);
+ // * ****************************************************
+ iLogger->Log(_L("Setting interval to %d"), SilenceDuration.Int64());
+
+ if (UsingDefault) { iLogger->Log(_L("Using default of %d"), KDefaultSilenceDuration.Int64()) ; }
+ sndPlayer->SetRepeats(Repeats, SilenceDuration);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (!DontCheckExpectedDuration && !aResult.iResult)
+ {
+ TBool DontUseExpectedDuration;
+ TTimeIntervalMicroSeconds ExpectedDuration=GetTimeIntervalL(section, KTagExpectedDuration, DontUseExpectedDuration);
+ if (!IsDurationInRange(Repeats, ( DontUseExpectedDuration ? sndPlayer->GetDuration() : ExpectedDuration), SilenceDuration, ErrorRange, sndPlayer->GetPlayStartTime(), sndPlayer->GetPlayStopTime() ) )
+ {
+ iLogger->Log(_L("Duration too different"));
+ aResult.iResult = KErrExpectedValueDifferent;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ if (aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ return KErrExecuted; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayFileWithPositionL(CStifSectionParser *section, TTestResult & aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds Position = KDefaultPosition;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ TBool UsingDefault;
+ Position = GetTimeIntervalL(section, KTagPosition, UsingDefault, KDefaultPosition);
+
+ iLogger->Log(_L("Seting position to: %d"), Position.Int64());
+ if (UsingDefault) {iLogger->Log(_L("Using default position duration of: (%d)") , KDefaultPosition.Int64());}
+ sndPlayer->iPosition = Position;
+
+ TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);
+ if (UsingDefault) {iLogger->Log(_L("Using default error range"));}
+ // * **************************************************************
+
+ iLogger->Log(_L("Starting scheduler"));
+ TTime StartTime,EndTime;
+ StartTime.HomeTime();
+ CActiveScheduler::Start();
+ EndTime.HomeTime();
+
+
+
+ TTimeIntervalMicroSeconds PerceivedDuration = EndTime.MicroSecondsFrom( StartTime );
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ iLogger->Log(_L("Perceived duration: %d") , PerceivedDuration.Int64() );
+
+
+ TTimeIntervalMicroSeconds ExpectedDuration = TTimeIntervalMicroSeconds(I64INT(sndPlayer->GetDuration().Int64()) - I64INT(Position.Int64()));
+ iLogger->Log(_L("ExpectedDuration: %d") ,ExpectedDuration.Int64() );
+
+ if ( Abs(ExpectedDuration.Int64() - PerceivedDuration.Int64()) > ErrorRange.Int64() )
+ { //Durations too different
+ iLogger->Log(_L("The clips duration is too different from the actual duration + position") );
+ aResult.iResult = KErrExpectedValueDifferent;
+ aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());
+ }
+ else
+ {
+ aResult.iResult = sndPlayer->iFinalError;
+ if (aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ }
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+//FH
+TInt CDRMAudioPlay::TestCasePlayHandlerWithSetPositionL(CStifSectionParser *section, TTestResult & aResult)
+ {
+
+ TPtrC FileNamePtr;
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+
+ TTimeIntervalMicroSeconds Position = KDefaultPosition;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));
+ // CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+ iFile.Close();
+ CleanupStack::PushL(sndPlayer);
+
+ TBool UsingDefault;
+ Position = GetTimeIntervalL(section, KTagPosition, UsingDefault, KDefaultPosition);
+
+ iLogger->Log(_L("Seting position to: %d"), Position.Int64());
+ if (UsingDefault) {iLogger->Log(_L("Using default position duration of: (%d)") , KDefaultPosition.Int64());}
+ sndPlayer->iPosition = Position;
+
+ TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);
+ if (UsingDefault) {iLogger->Log(_L("Using default error range"));}
+ // * **************************************************************
+
+ iLogger->Log(_L("Starting scheduler"));
+ TTime StartTime,EndTime;
+ StartTime.HomeTime();
+ CActiveScheduler::Start();
+ EndTime.HomeTime();
+
+ iFs.Close();
+
+ TTimeIntervalMicroSeconds PerceivedDuration = EndTime.MicroSecondsFrom( StartTime );
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ iLogger->Log(_L("Perceived duration: %d") , PerceivedDuration.Int64() );
+
+
+ TTimeIntervalMicroSeconds ExpectedDuration = TTimeIntervalMicroSeconds(I64INT(sndPlayer->GetDuration().Int64()) - I64INT(Position.Int64()));
+ iLogger->Log(_L("ExpectedDuration: %d") ,ExpectedDuration.Int64() );
+
+ if ( Abs(ExpectedDuration.Int64() - PerceivedDuration.Int64()) > ErrorRange.Int64() )
+ { //Durations too different
+ iLogger->Log(_L("The clips duration is too different from the actual duration + position") );
+ aResult.iResult = KErrExpectedValueDifferent;
+ aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());
+ }
+ else
+ {
+ aResult.iResult = sndPlayer->iFinalError;
+ if (aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ }
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayFileStopOpenL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 StopDelay=KDefaultPauseDelay;
+ TTimeIntervalMicroSeconds32 PlayDelay=KDefaultPlayDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+
+ CParameters *playParams;
+ if ( section->GetNextLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ playParams = CFileNameParameters::NewLC(CSimpleSoundPlayer::KPlayerActionOpen, FileName );
+ iLogger->Log(_L("Second filename not found, using the same file twice"));
+ }
+ else
+ {
+ playParams = CFileNameParameters::NewLC(CSimpleSoundPlayer::KPlayerActionOpen, FileNamePtr );
+ iLogger->Log(_L("Second filename set to [%S]") , &FileNamePtr );
+ }
+
+ //*********************************************
+ TBool UsingDefault;
+ StopDelay = GetTimeIntervalL(section, KTagStopDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPauseDelay);
+ if (UsingDefault)
+ {
+ iLogger->Log(_L("Error retrieving pause delay, using default"));
+ }
+
+ PlayDelay = GetTimeIntervalL(section, KTagPlayDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPlayDelay);
+ if (UsingDefault) {iLogger->Log(_L("Error retrieving play delay, using default"));}
+
+ if (StopDelay > PlayDelay)
+ {
+ //Pause delay longer than play delay. Switching
+ TTimeIntervalMicroSeconds32 TempDelay = PlayDelay;
+ PlayDelay = StopDelay;
+ StopDelay = TempDelay;
+ }
+
+ TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);
+ if (UsingDefault) {iLogger->Log(_L("Using default error range"));}
+
+ //*********************************************
+
+ CParameters *stopParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionStopPlayFile );
+ CleanupStack::PushL(stopParams);
+
+ CMediaEvent *mEventPlay = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PlayDelay, PlayDelay, sndPlayer, playParams);
+ CMediaEvent *mEventStop = CMediaEvent::NewLC(TestModuleIf() , *iLogger, StopDelay, StopDelay, sndPlayer, stopParams, CActive::EPriorityStandard+1);
+
+ iLogger->Log(_L("Starting scheduler"));
+ TTime StartTime, EndTime;
+ StartTime.HomeTime();
+ CActiveScheduler::Start();
+ EndTime.HomeTime();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+ iLogger->Log(_L("Playcount: (%d)") , mEventStop->GetCount() );
+ if (mEventStop->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFailSkippedEvents());
+ }
+ else if (sndPlayer->iFinalError)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ aResult.iResult = sndPlayer->iFinalError;
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ aResult.iResult = sndPlayer->iFinalError;
+ }
+
+ CleanupStack::PopAndDestroy(mEventStop);
+ CleanupStack::PopAndDestroy(mEventPlay);
+ CleanupStack::Pop(stopParams);
+ CleanupStack::Pop(playParams);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+TInt CDRMAudioPlay::TestCasePlayHandlerStopOpenL(CStifSectionParser *section , TTestResult &aResult)
+ {
+
+ TPtrC FileNamePtr;
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+
+ TTimeIntervalMicroSeconds32 StopDelay=KDefaultStopOpenPlayDelay;
+ TTimeIntervalMicroSeconds32 PlayDelay=KDefaultPlayDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));
+
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+
+ iFile.Close();
+ CleanupStack::PushL(sndPlayer);
+
+
+ CParameters *playParams;
+ if ( section->GetNextLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ playParams = CFileNameParameters::NewLC(CSimpleSoundPlayer::KPlayerActionOpenFileHandler, FileName );
+ iLogger->Log(_L("Second filename not found, using the same file twice"));
+ }
+ else
+ {
+ playParams = CFileNameParameters::NewLC(CSimpleSoundPlayer::KPlayerActionOpenFileHandler, FileNamePtr );
+ iLogger->Log(_L("Second filename set to [%S]") , &FileNamePtr );
+ }
+
+ //*********************************************
+ TBool UsingDefault;
+ StopDelay = GetTimeIntervalL(section, KTagStopDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPauseDelay);
+ if (UsingDefault) {iLogger->Log(_L("Error retrieving pause delay, using default"));}
+
+ PlayDelay = GetTimeIntervalL(section, KTagPlayDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPlayDelay);
+ if (UsingDefault) {iLogger->Log(_L("Error retrieving play delay, using default"));}
+
+ if (StopDelay > PlayDelay)
+ {
+ //Pause delay longer than play delay. Switching
+ TTimeIntervalMicroSeconds32 TempDelay = PlayDelay;
+ PlayDelay = StopDelay;
+ StopDelay = TempDelay;
+ }
+
+ TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);
+ if (UsingDefault) {iLogger->Log(_L("Using default error range"));}
+
+ //*********************************************
+
+ CParameters *stopParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionStopPlayFileHandler );
+ CleanupStack::PushL(stopParams);
+
+ CMediaEvent *mEventPlay = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PlayDelay, PlayDelay, sndPlayer, playParams);
+ CMediaEvent *mEventStop = CMediaEvent::NewLC(TestModuleIf() , *iLogger, StopDelay, StopDelay, sndPlayer, stopParams, CActive::EPriorityStandard+1);
+
+ iLogger->Log(_L("Starting scheduler"));
+ TTime StartTime, EndTime;
+ StartTime.HomeTime();
+ CActiveScheduler::Start();
+ EndTime.HomeTime();
+
+ iFs.Close();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+ iLogger->Log(_L("Playcount: (%d)") , mEventStop->GetCount() );
+ if (mEventStop->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFailSkippedEvents());
+ }
+ else if (sndPlayer->iFinalError)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ aResult.iResult = sndPlayer->iFinalError;
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ aResult.iResult = sndPlayer->iFinalError;
+ }
+
+ CleanupStack::PopAndDestroy(mEventStop);
+ CleanupStack::PopAndDestroy(mEventPlay);
+ CleanupStack::Pop(stopParams);
+ CleanupStack::Pop(playParams);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+}
+
+
+TInt CDRMAudioPlay::TestCasePlayFileWithBalanceL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TInt Balance = KMMFBalanceCenter;
+ TInt ParseError=KErrNone;
+ CStifItemParser *item;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ // TInt BalanceError=KErrNone;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************
+ ParseError=KErrNotFound;
+ item = section->GetItemLineL(KTagBalance);
+ if (item)
+ {
+ CleanupStack::PushL(item);
+ ParseError = item->GetInt(KTagBalance, Balance);
+ CleanupStack::PopAndDestroy(item);
+ }
+ if (ParseError)
+ {
+ iLogger->Log(_L("Value for Balance not found, using default (%d)") , KMMFBalanceCenter);
+ Balance = KMMFBalanceCenter;
+ }
+ else
+ {
+ iLogger->Log(_L("Setting Balance to: %d"), Balance);
+ sndPlayer->iBalance = Balance;
+ }
+
+ sndPlayer->iSetBalance = true;
+
+// iLogger->Log(_L("Setting Balance to: %d"), Balance);
+// BalanceError = sndPlayer->SetBalance(Balance);
+ // if (BalanceError)
+ // {
+ // iLogger->Log(_L("Error setting balance"));
+ // aResult.iResult = BalanceError;
+ // }
+ // else
+ // {
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+ // }
+
+ if (aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayDesL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ CStifItemParser *item;
+ TInt parseError = KErrNone;
+ TBool Immediate = 0;
+ TBool DesReadOnly = 0;
+ if ( !section->GetLine(KTagSoundDes, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+
+ HBufC8 *SoundFile = GetDescriptor8LC(FileName, section);
+
+ item = section->GetItemLineL(KTagImmediate);
+ if (item)
+ {
+ CleanupStack::PushL(item);
+ parseError = item->GetInt(KTagImmediate, Immediate);
+ CleanupStack::PopAndDestroy(item);
+ }
+ item = NULL;
+ item = section->GetItemLineL(KTagDesReadOnly);
+ if (item)
+ {
+ CleanupStack::PushL(item);
+ parseError = item->GetInt(KTagDesReadOnly, DesReadOnly);
+ CleanupStack::PopAndDestroy(item);
+ }
+
+ iLogger->Log(_L("Creating simple player with descriptor from [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( *SoundFile, TestModuleIf() , *iLogger, Immediate, DesReadOnly);
+
+ CleanupStack::PushL(sndPlayer);
+
+ iLogger->Log(_L("Starting scheduler"));
+
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError ;
+
+ TBool DontCheckExpectedDuration;
+ TTimeIntervalMicroSeconds ErrorRange=GetTimeIntervalL(section, KTagErrorRange, DontCheckExpectedDuration);
+
+ if (!DontCheckExpectedDuration && !aResult.iResult)
+ {
+ TBool DontUseExpectedDuration;
+ TTimeIntervalMicroSeconds ExpectedDuration=GetTimeIntervalL(section, KTagExpectedDuration, DontUseExpectedDuration);
+ if (!IsDurationInRange(0, (DontUseExpectedDuration
+ ? sndPlayer->GetDuration()
+ : ExpectedDuration
+ ), TTimeIntervalMicroSeconds(0), ErrorRange, sndPlayer->GetPlayStartTime(), sndPlayer->GetPlayStopTime() ) )
+ {
+ iLogger->Log(_L("Duration too different"));
+ aResult.iResult = KErrExpectedValueDifferent;
+ }
+ }
+
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+
+ CleanupStack::PopAndDestroy(SoundFile);
+
+ if (aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ return KErrExecuted;
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+
+ return KErrConfigInvalid;
+ }
+ }
+
+
+TInt CDRMAudioPlay::TestCasePlayFileReportPositionL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ TBool UsingDefaultReportDelay;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************************************
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //*********************************************
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KPlayerActionReportPosition);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventReportPosition = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ CleanupStack::PopAndDestroy(mEventReportPosition);
+ CleanupStack::Pop(reportParams);
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+ if (aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+//FH
+TInt CDRMAudioPlay::TestCasePlayHandlerWithGetPositionL(CStifSectionParser *section , TTestResult &aResult)
+ {
+
+ TPtrC FileNamePtr;
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+
+ TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ TBool UsingDefaultReportDelay;
+ User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ // CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+ iFile.Close();
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************************************
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //*********************************************
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KPlayerActionReportPosition);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventReportPosition = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iFs.Close();
+
+ CleanupStack::PopAndDestroy(mEventReportPosition);
+ CleanupStack::Pop(reportParams);
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+ if (aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayFileReportDurationL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool ExpectedDurationNotSet = EFalse, UsingDefaultReportDelay;;
+ TTimeIntervalMicroSeconds ExpectedDuration;
+
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************************************
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //*********************************************
+ ExpectedDuration = GetTimeIntervalL( section, KTagExpectedDuration, ExpectedDurationNotSet) ;
+ //*********************************************
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KPlayerActionReportDuration);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventReportPosition = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventReportPosition->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ if (!ExpectedDurationNotSet)
+ {
+ iLogger->Log(_L("Expected duration: (%d)") , ExpectedDuration.Int64() );
+
+ if ( ExpectedDuration!=sndPlayer->GetDuration() )
+ {
+ aResult.iResult = KErrExpectedValueDifferent;
+ }
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventReportPosition);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+TInt CDRMAudioPlay::TestCasePlayFileMaxVolumeL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingDefaultReportDelay;;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //###############################################
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //###############################################
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KplayerActionMaxVolume);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventMaxVolume = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventMaxVolume->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventMaxVolume);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayFileSetVolumeL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingDefaultReportDelay;;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //###############################################
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //###############################################
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KplayerActionSetVolume);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventSetVolume = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventSetVolume->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventSetVolume);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+
+
+TInt CDRMAudioPlay::TestCasePlayFileGetBalanceL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingDefaultReportDelay;;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //###############################################
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //###############################################
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KplayerActionGetBalance);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventGetBalance = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventGetBalance->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventGetBalance);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+TInt CDRMAudioPlay::TestCasePlayFileSetBalanceL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingDefaultReportDelay;;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //###############################################
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //###############################################
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KplayerActionSetBalance);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventSetBalance = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventSetBalance->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventSetBalance);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+TInt CDRMAudioPlay::TestCasePlayFileSetPriorityL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingDefaultReportDelay;;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //###############################################
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //###############################################
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KplayerActionSetPriority);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventGetBalance = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventGetBalance->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventGetBalance);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+
+TInt CDRMAudioPlay::TestCasePlayFileSetRepeatsL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingDefaultReportDelay;;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ sndPlayer->ControllerImplementationInformationL();
+ CleanupStack::PushL(sndPlayer);
+
+ //###############################################
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //###############################################
+
+ //CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KplayerActionSetRepeats);
+ //CleanupStack::PushL(reportParams);
+ //CMediaEvent *mEventSetRepeats = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ /*if (mEventSetRepeats->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }*/
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ //CleanupStack::PopAndDestroy(mEventSetRepeats);
+ //CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+TInt CDRMAudioPlay::TestCasePlayFilesGetMetaDataEntryL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingDefaultReportDelay;;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //###############################################
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //###############################################
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KplayerActionGetBalance);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventGetBalance = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventGetBalance->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventGetBalance);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+
+TInt CDRMAudioPlay::TestCasePlayFilesGetNumberOfMetaDataEntriesL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingDefaultReportDelay;;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //###############################################
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //###############################################
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KplayerActionGetBalance);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventGetBalance = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventGetBalance->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventGetBalance);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+
+TInt CDRMAudioPlay::TestCasePlayFileGetBitRateL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingDefaultReportDelay;;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //###############################################
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //###############################################
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KplayerActionGetBitRate);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventGetBitRate = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventGetBitRate->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventGetBitRate);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+
+TInt CDRMAudioPlay::TestCasePlayFilesImplementationInformation(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingDefaultReportDelay;;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //###############################################
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //###############################################
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KplayerActionControllerImplementationInformation);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventImplementationInformation = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventImplementationInformation->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventImplementationInformation);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayFilesRegisterForAudioLoadingNotification(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingDefaultReportDelay;;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //###############################################
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //###############################################
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KplayerActionRegisterForAudioLoadingNotification);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventRegisterForAudioLoadingNotification = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventRegisterForAudioLoadingNotification->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventRegisterForAudioLoadingNotification);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayFilesGetAudioLoadingProgress(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingDefaultReportDelay;;
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //###############################################
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //###############################################
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KplayerActionGetAudioLoadingProgress);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventGetAudioLoadingProgress = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventGetAudioLoadingProgress->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventGetAudioLoadingProgress);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+//FH
+TInt CDRMAudioPlay::TestCasePlayHandlerWithDurationL(CStifSectionParser *section , TTestResult &aResult)
+ {
+
+ TPtrC FileNamePtr;
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool ExpectedDurationNotSet = EFalse, UsingDefaultReportDelay;;
+ TTimeIntervalMicroSeconds ExpectedDuration;
+
+ TFileName FileName = FileNamePtr;
+ User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ // CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+ iFile.Close();
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************************************
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+ //*********************************************
+ ExpectedDuration = GetTimeIntervalL( section, KTagExpectedDuration, ExpectedDurationNotSet) ;
+ //*********************************************
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KPlayerActionReportDuration);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventReportPosition = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+ iFs.Close();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventReportPosition->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ if (!ExpectedDurationNotSet)
+ {
+ iLogger->Log(_L("Expected duration: (%d)") , ExpectedDuration.Int64() );
+
+ if ( ExpectedDuration!=sndPlayer->GetDuration() )
+ {
+ aResult.iResult = KErrExpectedValueDifferent;
+ }
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrExpectedValueDifferent:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventReportPosition);
+ CleanupStack::Pop(reportParams);
+
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrNone; //aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayFileWindowL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds StartPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds EndPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;
+ TBool UsingDefault;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingStartDefault, UsingEndDefault, UsingDefaultReportDelay;
+ TFileName FileName = FileNamePtr;
+ // TInt WindowError;
+
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************
+ StartPosition = GetTimeIntervalL(section, KTagWindowStart, UsingStartDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()-1E6));
+ EndPosition = GetTimeIntervalL(section, KTagWindowEnd, UsingEndDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()+1E6));
+
+ TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);
+ if (UsingDefault) {iLogger->Log(_L("Using default error range"));}
+
+
+ sndPlayer->iStartPosition = StartPosition;
+ sndPlayer->iEndPosition = EndPosition;
+ sndPlayer->iPlayWindow = true;
+
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KPlayerActionReportPosition);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventReportPosition = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ TTime StartTime,EndTime;
+ StartTime.HomeTime();
+ CActiveScheduler::Start();
+ EndTime.HomeTime();
+
+ TTimeIntervalMicroSeconds PerceivedDuration = EndTime.MicroSecondsFrom( StartTime );
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ iLogger->Log(_L("Perceived duration: %d") , PerceivedDuration.Int64() );
+
+
+ TTimeIntervalMicroSeconds ExpectedDuration = TTimeIntervalMicroSeconds(I64INT(EndPosition.Int64()) - I64INT(StartPosition.Int64()));
+ iLogger->Log(_L("ExpectedDuration: %d") ,ExpectedDuration.Int64() );
+
+ if ( Abs(ExpectedDuration.Int64() - PerceivedDuration.Int64()) > ErrorRange.Int64() )
+ { //Durations too different
+ iLogger->Log(_L("The clips duration is too different from the actual duration + position") );
+ aResult.iResult = KErrExpectedValueDifferent;
+ aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());
+ }
+ else if (aResult.iResult = sndPlayer->iFinalError , aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+
+ CleanupStack::PopAndDestroy(mEventReportPosition);
+ CleanupStack::Pop(reportParams);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+//FH
+TInt CDRMAudioPlay::TestCasePlayHandlerWithWindowL(CStifSectionParser *section , TTestResult &aResult)
+ {
+
+ TPtrC FileNamePtr;
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+
+ TTimeIntervalMicroSeconds StartPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds EndPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;
+ TBool UsingDefault;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingStartDefault, UsingEndDefault, UsingDefaultReportDelay;
+ TFileName FileName = FileNamePtr;
+ // TInt WindowError;
+ User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ // CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+ iFile.Close();
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************
+ StartPosition = GetTimeIntervalL(section, KTagWindowStart, UsingStartDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()-1E6));
+ EndPosition = GetTimeIntervalL(section, KTagWindowEnd, UsingEndDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()+1E6));
+
+ TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);
+ if (UsingDefault) {iLogger->Log(_L("Using default error range"));}
+
+
+ sndPlayer->iStartPosition = StartPosition;
+ sndPlayer->iEndPosition = EndPosition;
+ sndPlayer->iPlayWindow = true;
+
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KPlayerActionReportPosition);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventReportPosition = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ TTime StartTime,EndTime;
+ StartTime.HomeTime();
+ CActiveScheduler::Start();
+ EndTime.HomeTime();
+ iFs.Close();
+ TTimeIntervalMicroSeconds PerceivedDuration = EndTime.MicroSecondsFrom( StartTime );
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ iLogger->Log(_L("Perceived duration: %d") , PerceivedDuration.Int64() );
+
+
+ TTimeIntervalMicroSeconds ExpectedDuration = TTimeIntervalMicroSeconds(I64INT(EndPosition.Int64()) - I64INT(StartPosition.Int64()));
+ iLogger->Log(_L("ExpectedDuration: %d") ,ExpectedDuration.Int64() );
+
+ if ( Abs(ExpectedDuration.Int64() - PerceivedDuration.Int64()) > ErrorRange.Int64() )
+ { //Durations too different
+ iLogger->Log(_L("The clips duration is too different from the actual duration + position") );
+ aResult.iResult = KErrExpectedValueDifferent;
+ aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());
+ }
+ else if (aResult.iResult = sndPlayer->iFinalError , aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+
+ CleanupStack::PopAndDestroy(mEventReportPosition);
+ CleanupStack::Pop(reportParams);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayFileWindowClearL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds StartPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds EndPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingStartDefault, UsingEndDefault, UsingDefaultReportDelay;
+ TFileName FileName = FileNamePtr;
+
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************
+ StartPosition = GetTimeIntervalL(section, KTagWindowStart, UsingStartDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()-1E6));
+ EndPosition = GetTimeIntervalL(section, KTagWindowEnd, UsingEndDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()+1E6));
+
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KPlayerActionReportPosition);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventReportPosition = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ sndPlayer->iStartPosition = StartPosition;
+ sndPlayer->iEndPosition = EndPosition;
+ sndPlayer->iPlayWindow = true;
+ sndPlayer->iClearWindow = true;
+
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ TBool PositionReset=ETrue;
+ TTimeIntervalMicroSeconds position;
+ TInt PosError = sndPlayer->GetPosition(position);
+ if ( !PosError && (position!=TTimeIntervalMicroSeconds(0) ) )
+ {
+ iLogger->Log(_L("Position not reset to zero, position is (%d)") , position.Int64() );
+ PositionReset=EFalse;
+ }
+ if (PosError)
+ {
+ iLogger->Log(_L("Error (%d) obtaining clip position"), PosError );
+ }
+
+
+ if (!PositionReset)
+ {
+ iLogger->Log(_L("Error clearing PlayWindow, position not reset to zero") );
+ aResult.iResult = KErrExpectedValueDifferent;
+ aResult.iResultDes.Copy(KTestCaseResultFail() );
+ }
+ else if (aResult.iResult = sndPlayer->iFinalError , aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+
+ CleanupStack::PopAndDestroy(mEventReportPosition);
+ CleanupStack::Pop(reportParams);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+//FH
+TInt CDRMAudioPlay::TestCasePlayHandlerWithClearWindowL(CStifSectionParser *section , TTestResult &aResult)
+ {
+
+ TPtrC FileNamePtr;
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+
+ TTimeIntervalMicroSeconds StartPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds EndPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TBool UsingStartDefault, UsingEndDefault, UsingDefaultReportDelay;
+ TFileName FileName = FileNamePtr;
+ User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));
+
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ // CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+ iFile.Close();
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************
+ StartPosition = GetTimeIntervalL(section, KTagWindowStart, UsingStartDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()-1E6));
+ EndPosition = GetTimeIntervalL(section, KTagWindowEnd, UsingEndDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()+1E6));
+
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);
+ iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KPlayerActionReportPosition);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventReportPosition = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ sndPlayer->iStartPosition = StartPosition;
+ sndPlayer->iEndPosition = EndPosition;
+ sndPlayer->iPlayWindow = true;
+ sndPlayer->iClearWindow = true;
+
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iFs.Close();
+ TBool PositionReset=ETrue;
+ TTimeIntervalMicroSeconds position;
+ TInt PosError = sndPlayer->GetPosition(position);
+ if ( !PosError && (position!=TTimeIntervalMicroSeconds(0) ) )
+ {
+ iLogger->Log(_L("Position not reset to zero, position is (%d)") , position.Int64() );
+ PositionReset=EFalse;
+ }
+ if (PosError)
+ {
+ iLogger->Log(_L("Error (%d) obtaining clip position"), PosError );
+ }
+
+
+ if (!PositionReset)
+ {
+ iLogger->Log(_L("Error clearing PlayWindow, position not reset to zero") );
+ aResult.iResult = KErrExpectedValueDifferent;
+ aResult.iResultDes.Copy(KTestCaseResultFail() );
+ }
+ else if (aResult.iResult = sndPlayer->iFinalError , aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+
+ CleanupStack::PopAndDestroy(mEventReportPosition);
+ CleanupStack::Pop(reportParams);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayDesStopOpenL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+
+ if ( !section->GetLine(KTagSoundDes, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with descriptor from [%S]"), &FileName);
+ //*********************************************
+ //Open descriptor
+ HBufC8 *SoundFile = GetDescriptor8LC(FileName, section);
+ HBufC8 *SoundFile2;
+
+ //*********************************************
+ //FileName of second file to play
+ CParameters *stopParams ;
+ if ( section->GetNextLine(KTagSoundDes, FileNamePtr, ENoTag) )
+ { //Using same filename
+ SoundFile2 = SoundFile->AllocLC();
+ stopParams = CDes8Parameters::NewLC(CSimpleSoundPlayer::KPlayerActionStopPlayDes, *SoundFile2 );
+ iLogger->Log(_L("Second descriptor filename not found, using the same file twice"));
+ }
+ else
+ { //Found second filename
+ FileName=FileNamePtr;
+ SoundFile2 = GetDescriptor8LC(FileName, section);
+ stopParams = CDes8Parameters::NewLC(CSimpleSoundPlayer::KPlayerActionStopPlayDes, *SoundFile2 );
+ iLogger->Log(_L("Second descriptor from [%S]") , &FileName );
+ }
+
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewLC( *SoundFile, TestModuleIf() , *iLogger);
+
+ TBool UsingDefault;
+ TTimeIntervalMicroSeconds32 StopDelay = GetTimeIntervalL(section, KTagDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultStopOpenPlayDelay);
+ if (UsingDefault) {iLogger->Log(_L("Error retrieving stop delay, using default"));}
+ iLogger->Log(_L("Setting delays to stop and open descriptor to [%d]"), StopDelay.Int());
+ //*********************************************
+
+ CMediaEvent *mEventStopPlay = CMediaEvent::NewLC(TestModuleIf() , *iLogger, StopDelay, StopDelay, sndPlayer, stopParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+
+ //]TBool DontCheckExpectedDuration;
+ //]TTimeIntervalMicroSeconds ErrorRange=GetTimeIntervalL(section, KTagErrorRange, DontCheckExpectedDuration);
+ //]TBool DontUseExpectedDuration;
+ //]TTimeIntervalMicroSeconds ExpectedDuration=GetTimeIntervalL(section, KTagExpectedDuration, DontUseExpectedDuration);
+
+ if (mEventStopPlay->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ aResult.iResultDes.Copy(KTestCaseResultFailSkippedEvents);
+ iLogger->Log(KTestCaseResultFailSkippedEvents() );
+ }
+ else if ( sndPlayer->iFinalError)
+ {
+ aResult.iResult = sndPlayer->iFinalError;
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail() );
+ }
+ else
+ {
+ //]aResult.iResult = KErrNone;
+ //]if (!DontCheckExpectedDuration && !DontUseExpectedDuration)
+ //] {
+ //] if (!IsDurationInRange(0, ExpectedDuration, TTimeIntervalMicroSeconds(0), ErrorRange, sndPlayer->GetPlayStartTime(), sndPlayer->GetPlayStopTime() ) )
+ //] {
+ //] iLogger->Log(_L("Duration too different"));
+ //] aResult.iResult = KErrExpectedValueDifferent;
+ //] }
+ //] }
+ //]if (aResult.iResult)
+ //] {
+ //] aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());
+ //] }
+ //]else
+ //] {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ //] }
+ }
+
+ CleanupStack::PopAndDestroy(mEventStopPlay);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ CleanupStack::Pop(stopParams);
+ CleanupStack::PopAndDestroy(SoundFile2);
+ CleanupStack::PopAndDestroy(SoundFile);
+ return KErrExecuted;
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayFileWithVolumeRampL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ TTimeIntervalMicroSeconds RampDuration = KDefaultRampDuration;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************
+ TBool UsingReportDefault, UsingRampDefault;
+ RampDuration = GetTimeIntervalL(section, KTagRampDuration, UsingRampDefault, KDefaultRampDuration);
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingReportDefault, (TTimeIntervalMicroSeconds32)KDefaultReportDelay );
+
+ // ******************************************
+ iLogger->Log(_L("Seting up volume ramp with duration: %d"), RampDuration.Int64());
+ if (UsingRampDefault) {iLogger->Log(_L("Using default Ramp duration of: %d") , KDefaultRampDuration.Int64());}
+
+ sndPlayer->SetVolumeRamp(RampDuration);
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KPlayerActionReportVolume);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventReportPosition = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventReportPosition->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventReportPosition);
+ CleanupStack::Pop(reportParams);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+//FH
+TInt CDRMAudioPlay::TestCasePlayHandlerWithRampL(CStifSectionParser *section , TTestResult &aResult)
+ {
+
+ TPtrC FileNamePtr;
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+
+ TTimeIntervalMicroSeconds RampDuration = KDefaultRampDuration;
+ TTimeIntervalMicroSeconds32 ReportDelay=KDefaultReportDelay;
+
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);
+ User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));
+
+ //CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+ iFile.Close();
+ CleanupStack::PushL(sndPlayer);
+
+ //*********************
+ TBool UsingReportDefault, UsingRampDefault;
+ RampDuration = GetTimeIntervalL(section, KTagRampDuration, UsingRampDefault, KDefaultRampDuration);
+ ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingReportDefault, (TTimeIntervalMicroSeconds32)KDefaultReportDelay );
+
+ // ******************************************
+ iLogger->Log(_L("Seting up volume ramp with duration: %d"), RampDuration.Int64());
+ if (UsingRampDefault) {iLogger->Log(_L("Using default Ramp duration of: %d") , KDefaultRampDuration.Int64());}
+
+ sndPlayer->SetVolumeRamp(RampDuration);
+
+ CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KPlayerActionReportVolume);
+ CleanupStack::PushL(reportParams);
+ CMediaEvent *mEventReportPosition = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+ iFs.Close();
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+
+ if (mEventReportPosition->GetCount() <= 0)
+ {
+ aResult.iResult = KErrSkippedEvents;
+ }
+
+ switch (aResult.iResult)
+ {
+ case KErrNone:
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy( KTestCaseResultSuccess() );
+ break;
+ case KErrSkippedEvents:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );
+ break;
+ default:
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy( KTestCaseResultFail() );
+ }
+
+ CleanupStack::PopAndDestroy(mEventReportPosition);
+ CleanupStack::Pop(reportParams);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return aResult.iResult;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+
+TInt CDRMAudioPlay::TestCasePlayFilesWithPrioritiesL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TInt PriorityLow = EMdaPriorityNormal+1;
+ TInt PriorityHigh = EMdaPriorityNormal+20;
+
+ TBool UsingDefaultPriority;
+ PriorityHigh = GetIntL(section, KTagPriority, UsingDefaultPriority, PriorityHigh);
+ PriorityLow = GetIntL(section, KTagPriority, UsingDefaultPriority, PriorityLow, ETrue);
+
+ if (PriorityHigh < PriorityLow)
+ {
+ TInt tempPriority = PriorityHigh;
+ PriorityHigh = PriorityLow;
+ PriorityLow = tempPriority;
+ }
+
+ TBool UsingDefaultPriorityPreference;
+ TInt tmpPrefHigh = GetIntL(section, KTagPriorityPreference, UsingDefaultPriorityPreference, -1);
+ TInt tmpPrefLow = GetIntL(section, KTagPriorityPreference, UsingDefaultPriorityPreference, tmpPrefHigh, ETrue);
+
+ TMdaPriorityPreference prefHigh;
+ switch (tmpPrefHigh)
+ {
+ case 0:
+ prefHigh = EMdaPriorityPreferenceNone; break;
+ case 1:
+ prefHigh = EMdaPriorityPreferenceTime; break;
+ case 2:
+ prefHigh = EMdaPriorityPreferenceQuality; break;
+ case 3:
+ default:
+ prefHigh = EMdaPriorityPreferenceTimeAndQuality; break;
+ }
+ TMdaPriorityPreference prefLow;
+ switch (tmpPrefLow)
+ {
+ case 0:
+ prefLow = EMdaPriorityPreferenceNone; break;
+ case 1:
+ prefLow = EMdaPriorityPreferenceTime; break;
+ case 2:
+ prefLow = EMdaPriorityPreferenceQuality; break;
+ case 3:
+ default:
+ prefLow = EMdaPriorityPreferenceTimeAndQuality; break;
+ }
+
+ TFileName FileName = FileNamePtr;
+ TObjectCountDown counter;
+
+ iLogger->Log(_L("Creating playerHigh with file [%S]"), &FileName);
+ CSimpleSoundPlayer *sndPlayerHigh = CSimpleSoundPlayer::NewLC( FileName, TestModuleIf() , *iLogger);
+
+ if ( section->GetNextLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ iLogger->Log(_L("Second filename not found, using the same file twice"));
+ }
+ else
+ {
+ FileName=FileNamePtr;
+ iLogger->Log(_L("Second filename set to [%S]") , &FileName );
+ }
+
+ // ***************
+ iLogger->Log(_L("Creating playerLow with file [%S]"), &FileName);
+ CSimpleSoundPlayer *sndPlayerLow = CSimpleSoundPlayer::NewLC( FileName, TestModuleIf() , *iLogger);
+
+ iLogger->Log(_L("Setting playerLow priority to (%d)"), PriorityLow);
+ sndPlayerLow->SetPriority( PriorityLow, prefLow);
+
+ iLogger->Log(_L("Setting playerHigh priority to (%d)"), PriorityHigh);
+ sndPlayerHigh->SetPriority( PriorityHigh, prefHigh);
+
+ sndPlayerLow->SetSupervisor(&counter);
+ sndPlayerHigh->SetSupervisor(&counter);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from playerHigh, errorcode: (%d)"), sndPlayerHigh->iFinalError );
+ iLogger->Log(_L("Returned from playerLow, errorcode: (%d)"), sndPlayerLow->iFinalError );
+
+ aResult.iResult = sndPlayerHigh->iFinalError ;
+ if (aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ CleanupStack::PopAndDestroy(sndPlayerLow);
+ CleanupStack::PopAndDestroy(sndPlayerHigh);
+ return KErrExecuted;
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayFilesWithVolumesL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC FileNamePtr;
+ if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ TFileName FileName = FileNamePtr;
+ TObjectCountDown counter;
+
+ CSimpleSoundPlayer *sndPlayerHigh = CSimpleSoundPlayer::NewLC( FileName, TestModuleIf() , *iLogger);
+ // TInt VolumeHigh;
+ // sndPlayerHigh->SetVolume(VolumeHigh=sndPlayerHigh->MaxVolume());
+ // iLogger->Log(_L("Creating player 1 (playerHigh) with file [%S] and volume (%d), max=(%d)"), &FileName, VolumeHigh, sndPlayerHigh->MaxVolume() );
+ iLogger->Log(_L("Creating player 1 (playerHigh) with file [%S] "), &FileName);
+
+ sndPlayerHigh->iPlayVolume = true;
+
+ if ( section->GetNextLine(KTagSoundFile, FileNamePtr, ENoTag) )
+ {
+ iLogger->Log(_L("Second filename not found, using the same file twice"));
+ }
+ else
+ {
+ FileName=FileNamePtr;
+ iLogger->Log(_L("Second filename set to [%S]") , &FileName );
+ }
+
+ // ***************
+ CSimpleSoundPlayer *sndPlayerLow = CSimpleSoundPlayer::NewLC( FileName , TestModuleIf() , *iLogger , EFalse);
+ // TInt VolumeLow;
+ // sndPlayerLow->SetVolume(VolumeLow=sndPlayerLow->MaxVolume()/2);
+ // iLogger->Log(_L("Creating player 2 (playerLow) with file [%S] and volume (%d), max=(%d)"), &FileName, VolumeLow, sndPlayerLow->MaxVolume() );
+ iLogger->Log(_L("Creating player 2 (playerHigh) with file [%S] "), &FileName);
+ sndPlayerLow->iPlayVolume = true;
+
+ CParameters *mPlayParameters = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPlay );
+ CleanupStack::PushL(mPlayParameters);
+
+ sndPlayerHigh->SetPlayCompleteTarget(sndPlayerLow, mPlayParameters);
+
+ sndPlayerLow->SetSupervisor(&counter);
+ sndPlayerHigh->SetSupervisor(&counter);
+
+ iLogger->Log(_L("Starting scheduler"));
+
+
+ CActiveScheduler::Start();
+
+
+ iLogger->Log(_L("Returned from playerHigh, errorcode: (%d)"), sndPlayerHigh->iFinalError );
+ iLogger->Log(_L("Returned from playerLow, errorcode: (%d)"), sndPlayerLow->iFinalError );
+
+ aResult.iResult = sndPlayerHigh->iFinalError ;
+
+ if (!sndPlayerHigh->iFinalError && !sndPlayerLow->iFinalError)
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ aResult.iResult = KErrNone;
+ }
+ else
+ {
+ if (sndPlayerHigh->iFinalError)
+ {
+ aResult.iResult = sndPlayerHigh->iFinalError;
+ }
+ if (sndPlayerLow->iFinalError)
+ {
+ aResult.iResult = sndPlayerLow->iFinalError;
+ }
+
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ CleanupStack::PopAndDestroy(mPlayParameters);
+ CleanupStack::PopAndDestroy(sndPlayerLow);
+ CleanupStack::PopAndDestroy(sndPlayerHigh);
+ return KErrExecuted;
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayUrlL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC UrlPtr;
+ if ( !section->GetLine(KTagSoundUrl, UrlPtr, ENoTag) )
+ {
+ CStifItemParser *item;
+ HBufC *Url = UrlPtr.AllocLC();
+ TInt IapId = KUseDefaultIap;
+ TPtrC MimePtr;
+ HBufC *Mime;
+ HBufC8 *Mime8;
+ if ( ! section->GetLine(KTagMime, MimePtr, ENoTag) )
+ {
+ Mime = MimePtr.AllocLC();
+ }
+ else
+ {
+ Mime = KNullDesC().AllocLC();
+ }
+
+ if ( item=section->GetItemLineL(KTagIapId) , item)
+ {
+ CleanupStack::PushL(item);
+ TInt newVal;
+ if ( ! item->GetInt(KTagIapId, newVal) )
+ {
+ IapId = newVal;
+ }
+ CleanupStack::PopAndDestroy(item);
+ }
+
+ Mime8 = HBufC8::NewLC( Mime->Length() );
+ TPtr8 Mime8Ptr = Mime8->Des();
+
+ for (TInt x=0 ; x < Mime->Length() ; x++)
+ {
+ //TUint8 tmp8 = (TUint8)( (*Mime)[x]);
+ //TBufC8<10> tmp( &tmp8 );
+ TUint8 tmp8Array[2] = {0, 0};
+ //tmp8Array[1]=0;
+ tmp8Array[0]=(TUint8)( (*Mime)[x] );
+ TBufC8<10> tmp( tmp8Array );
+ Mime8Ptr += tmp.Left(1);
+ }
+
+ iLogger->Log(_L("Creating simple player with url [%S], IapId [%d] "), Url, IapId);
+ iLogger->Log(_L8(" and MIME Type [%S]L(%d)") , Mime8, Mime8->Length() );
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewUrlLC( *Url, IapId, *Mime8, TestModuleIf() , *iLogger);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError ;
+ if (aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ CleanupStack::PopAndDestroy(sndPlayer);
+ CleanupStack::PopAndDestroy(Mime8);
+ CleanupStack::PopAndDestroy(Mime);
+ CleanupStack::PopAndDestroy(Url);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayUrlStopOpenL(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TPtrC UrlPtr;
+ TTimeIntervalMicroSeconds32 StopDelay=KDefaultStopOpenPlayDelay;
+
+ if ( !section->GetLine(KTagSoundUrl, UrlPtr, ENoTag) )
+ {
+ CStifItemParser *item;
+ TInt IapId = KUseDefaultIap;
+ TInt IapIdB = KUseDefaultIap;
+
+ TPtrC MimePtr;
+ HBufC *Mime;
+ HBufC8 *Mime8;
+
+ HBufC *MimeB;
+ HBufC8 *Mime8B;
+
+ HBufC *Url = UrlPtr.AllocLC();
+ if ( ! section->GetLine(KTagMime, MimePtr, ENoTag) )
+ {
+ Mime = MimePtr.AllocLC();
+ }
+ else
+ {
+ Mime = KNullDesC().AllocLC();
+ }
+
+ Mime8 = HBufC8::NewLC( Mime->Length() );
+ TPtr8 Mime8Ptr = Mime8->Des();
+ TInt x;
+ for (x=0 ; x < Mime->Length() ; x++)
+ {
+ TUint8 tmp8[2];
+ tmp8[0] = (TUint8)( (*Mime)[x]);
+ tmp8[1] = '\0';
+ TBufC8<10> tmp( tmp8 );
+ Mime8Ptr += tmp.Left(1);
+ }
+
+ if ( item=section->GetItemLineL(KTagIapId) , item)
+ {
+ CleanupStack::PushL(item);
+ TInt newVal;
+ if ( ! item->GetInt(KTagIapId, newVal) )
+ {
+ IapId = newVal;
+ }
+ CleanupStack::PopAndDestroy(item);
+ }
+
+ iLogger->Log(_L("Creating simple player with url [%S], IapId [%d] "), Url, IapId);
+ iLogger->Log(_L8(" and MIME Type [%S]L(%d)") , Mime8, Mime8->Length() );
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewUrlLC( *Url, IapId, *Mime8, TestModuleIf() , *iLogger);
+
+ //*********************************************
+ //Url of second file to play
+ HBufC *UrlB;
+ if ( ! section->GetLine(KTagMime, MimePtr, ENoTag) )
+ {
+ MimeB = MimePtr.AllocLC();
+ }
+ else
+ {
+ MimeB = KNullDesC().AllocLC();
+ }
+
+ Mime8B = HBufC8::NewLC( MimeB->Length() );
+ TPtr8 Mime8PtrB = Mime8B->Des();
+ for (x=0 ; x < MimeB->Length() ; x++)
+ {
+ TUint8 tmp8B = (TUint8)( (*MimeB)[x]);
+ TBufC8<10> tmpB( &tmp8B );
+ Mime8PtrB += tmpB.Left(1);
+ }
+
+ if ( item=section->GetItemLineL(KTagIapId) , item)
+ {
+ CleanupStack::PushL(item);
+ TInt newValB;
+ if ( ! item->GetInt(KTagIapId, newValB) )
+ {
+ IapIdB = newValB;
+ }
+ CleanupStack::PopAndDestroy(item);
+ }
+
+ CUrlParameters *stopParams ;
+ if ( section->GetNextLine(KTagSoundUrl, UrlPtr, ENoTag) )
+ {
+ iLogger->Log(_L("Second url not found, using the same file twice"));
+ UrlB = Url->AllocLC();
+ }
+ else
+ {
+ iLogger->Log(_L("Second url set to [%S]") , &UrlPtr );
+ UrlB = UrlPtr.AllocLC();
+ }
+
+ stopParams = new(ELeave) CUrlParameters (CSimpleSoundPlayer::KPlayerActionStopPlayUrl, *UrlB, IapIdB, *Mime8B);
+ CleanupStack::PushL(stopParams);
+
+ TBool UsingDefaultDelay=EFalse;
+ StopDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultDelay, (TTimeIntervalMicroSeconds32)KDefaultStopOpenPlayDelay);
+
+ iLogger->Log(_L("Setting delays to stop and open url to [%d]"), StopDelay.Int());
+ //*********************************************
+
+ CMediaEvent *mEventStopPlay = CMediaEvent::NewLC(TestModuleIf() , *iLogger, StopDelay, StopDelay, sndPlayer, stopParams);
+
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+
+ CleanupStack::PopAndDestroy(mEventStopPlay);
+ CleanupStack::Pop(stopParams);
+
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+ if (aResult.iResult)
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+
+ CleanupStack::PopAndDestroy(UrlB);
+ CleanupStack::PopAndDestroy(Mime8B);
+ CleanupStack::PopAndDestroy(MimeB);
+ CleanupStack::PopAndDestroy(sndPlayer);
+
+ CleanupStack::PopAndDestroy(Mime8);
+ CleanupStack::PopAndDestroy(Mime);
+
+ CleanupStack::PopAndDestroy(Url);
+ return KErrExecuted;
+
+ }
+ else
+ {
+ //The file name of the clip to play is missing
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+// ** Module *****************************************************************
+HBufC8 *CDRMAudioPlay::GetDescriptor8LC(const TFileName &aFileName, CStifSectionParser *section)
+ {
+ TInt FileError, SoundSize=0;
+ RFile file;
+ RFs FsSession;
+ HBufC8 *SoundFile;
+
+
+ TInt MimeUsed = 0;
+ CStifItemParser *item;
+ item = section->GetItemLineL(KTagMime);
+ if (item)
+ {
+ CleanupStack::PushL(item);
+ item->GetInt(KTagMime, MimeUsed) ;
+ CleanupStack::PopAndDestroy(item);
+ }
+
+ iLogger->Log(_L("Connecting to File Server Session") );
+ FileError = FsSession.Connect();
+ if (FileError)
+ {
+ iLogger->Log(_L("File error FsSession.Connect() (%d)") , FileError);
+ User::LeaveIfError(FileError);
+ }
+
+ iLogger->Log(_L("Opening file to get size") );
+ FileError = file.Open(FsSession, aFileName, EFileStream);
+ if (FileError)
+ {
+ iLogger->Log(_L("File error file.Open() (%d)") , FileError);
+ User::LeaveIfError(FileError);
+ }
+ FileError = file.Size(SoundSize);
+ iLogger->Log(_L("File Size (%d)") , SoundSize);
+ if (FileError)
+ {
+ iLogger->Log(_L("Error getting size") );
+ User::LeaveIfError(FileError);
+ }
+
+// TPtr8 helper;
+
+ if (MimeUsed == 1)
+ {
+ _LIT(MP3MIME,"zzaudio/mpeg");
+ SoundFile = HBufC8::NewLC(SoundSize+12);
+
+ TPtr8 helper(SoundFile->Des());
+ helper.Append (MP3MIME);
+ helper.AppendFill (0x00, 1);
+ TPtr8 helper1(&helper[12], SoundSize);
+ User::LeaveIfError(file.Read(helper1, SoundSize));
+ helper.SetLength (SoundSize+12);
+
+
+
+
+ }
+ else
+ {
+ SoundFile = HBufC8::NewLC(SoundSize);
+
+ // TPtr8 helper = SoundFile->Des();
+ TPtr8 helper(SoundFile->Des());
+ // FileError = file.Read( helper );
+ User::LeaveIfError(file.Read(helper, SoundSize));
+
+
+ }
+
+ iLogger->Log(_L("Descriptor length [%d]") , SoundFile->Size() );
+ file.Close();
+ FsSession.Close();
+ return SoundFile;
+ }
+
+TTimeIntervalMicroSeconds CDRMAudioPlay::GetTimeIntervalL(CStifSectionParser *aSection, const TDesC &aTag, TBool &aUsingDefaults, const TTimeIntervalMicroSeconds &aDefaultInterval)
+ {
+ TInt TempInterval1=0 , TempInterval2=0;
+ TInt64 tmp=0;
+ TInt ParseError=KErrNotFound;
+ TTimeIntervalMicroSeconds ReturnValue = aDefaultInterval;
+ aUsingDefaults = ETrue;
+
+ CStifItemParser *item = aSection->GetItemLineL(aTag);
+ if (item)
+ {
+ CleanupStack::PushL(item);
+ ParseError = item->GetInt(aTag, TempInterval1) ;
+ if (!ParseError)
+ {
+ //First delay found.
+ aUsingDefaults = EFalse;
+ tmp = TempInterval1*1000000; //convert from seconds to microseconds
+
+ if ( ! item->GetNextInt(TempInterval2) )
+ {
+ tmp += TempInterval2*1000; //add miliseconds
+ if ( ! item->GetNextInt(TempInterval2) )
+ {
+ tmp += TempInterval2;
+ }
+ }
+ ReturnValue = tmp;
+ }
+ CleanupStack::PopAndDestroy(item);
+ }
+ if (ParseError) {iLogger->Log(_L("Error retrieving interval, [%S] not found"), &aTag);}
+ iLogger->Log(_L("Interval retrieved: (%d)") , ReturnValue.Int64());
+ return ReturnValue;
+ }
+
+ /*TTimeIntervalMicroSeconds CDRMAudioPlay::GetDelayL(CStifSectionParser *aSection, const TDesC &aTag)
+{return 0;}*/
+
+TTimeIntervalMicroSeconds32 CDRMAudioPlay::GetTimeIntervalL(CStifSectionParser *aSection, const TDesC &aTag, TBool &aUsingDefault, const TTimeIntervalMicroSeconds32 &aDefaultDelay)
+ {
+ TInt ParseError=KErrNotFound;
+ TInt TempDelay=0;
+ TTimeIntervalMicroSeconds32 ReturnValue=aDefaultDelay;
+ CStifItemParser *item = aSection->GetItemLineL(aTag);
+ if (item)
+ {
+ CleanupStack::PushL(item);
+ ParseError = item->GetInt(aTag, TempDelay) ;
+ if (ParseError)
+ { //Delay not found, using defaults
+ aUsingDefault=ETrue;
+ }
+ else
+ { //Delay found.
+ aUsingDefault=EFalse;
+ ReturnValue=TempDelay;
+ }
+ CleanupStack::PopAndDestroy(item);
+ }
+ if (ParseError) {iLogger->Log(_L("Error retrieving report delay, [%S] not found") , &aTag);}
+ return ReturnValue;
+ }
+
+TInt CDRMAudioPlay::RunTestCaseFunctionL(TInt id , CStifSectionParser *section , TTestResult &aResult)
+ {
+ switch (id)
+ {
+ case KCasePlayFile:
+ return TestCasePlayFileL(section, aResult);
+ case KCasePlayFileWithRamp:
+ return TestCasePlayFileWithVolumeRampL(section, aResult);
+ case KCasePlayFileWithRepeats:
+ return TestCasePlayFileWithRepeatsL(section, aResult);
+ case KCasePlayFileWithPause:
+ return TestCasePlayFileWithPauseL(section, aResult);
+ case KCasePlayFileWithPosition:
+ return TestCasePlayFileWithPositionL(section, aResult);
+ case KCasePlayFileWithBalance:
+ return TestCasePlayFileWithBalanceL(section, aResult);
+ case KCasePlayFileStopOpen:
+ return TestCasePlayFileStopOpenL(section, aResult);
+ case KCasePlayFileReportDuration:
+ return TestCasePlayFileReportDurationL(section, aResult);
+ case KCasePlayFileMaxVolume:
+ return TestCasePlayFileMaxVolumeL(section, aResult);
+ case KCasePlayFileSetVolume:
+ return TestCasePlayFileSetVolumeL(section, aResult);
+ case KCasePlayFileSetBalance:
+ return TestCasePlayFileSetBalanceL(section, aResult);
+ case KCasePlayFileGetBalance:
+ return TestCasePlayFileGetBalanceL(section, aResult);
+ case KCasePlayFileGetBitRate:
+ return TestCasePlayFileGetBitRateL(section, aResult);
+ case KCasePlayFileSetPriority:
+ return TestCasePlayFileSetPriorityL(section, aResult);
+ case KCasePlayFileSetRepeats:
+ return TestCasePlayFileSetRepeatsL(section, aResult);
+ case KCasePlayFileReportPosition:
+ return TestCasePlayFileReportPositionL(section, aResult);
+ case KCasePlayFileWindow:
+ return TestCasePlayFileWindowL(section, aResult);
+ case KCasePlayFileClearWindow:
+ return TestCasePlayFileWindowClearL(section, aResult);
+ case KCasePlayFilesWithPriorities:
+ return TestCasePlayFilesWithPrioritiesL(section, aResult);
+ case KCasePlayFilesWithVolumes:
+ return TestCasePlayFilesWithVolumesL(section, aResult);
+ case KCasePlayFilesGetMetaDataEntry:
+ return TestCasePlayFilesGetMetaDataEntryL(section, aResult);
+ case KCasePlayFilesGetNumberOfMetaDataEntries:
+ return TestCasePlayFilesGetNumberOfMetaDataEntriesL(section, aResult);
+ case KCasePlayDes:
+ return TestCasePlayDesL(section, aResult);
+ case KCasePlayDesStopOpen:
+ return TestCasePlayDesStopOpenL(section, aResult);
+ case KCasePlayUrl:
+ return TestCasePlayUrlL(section, aResult);
+ case KCasePlayUrlStopOpen:
+ return TestCasePlayUrlStopOpenL(section, aResult);
+ case KCasePlayFileMetaInfo:
+ return TestCasePlayFileMetaInfoL(section, aResult);
+ case KCaseImplementationInformation:
+ return TestCasePlayFileFormatsL(section, aResult);
+ case KCasePlayHandler:
+ return TestCasePlayHandlerL(section, aResult);
+ case KCasePlayHandlerStopOpen:
+ return TestCasePlayHandlerStopOpenL(section, aResult);
+ case KCasePlayHandlerWithPause:
+ return TestCasePlayHandlerWithPauseL(section, aResult);
+ case KCasePlayFileHandlerWithRamp:
+ return TestCasePlayHandlerWithRampL(section, aResult);
+ case KCasePlayFileHandlerWithSetPosition:
+ return TestCasePlayHandlerWithSetPositionL(section, aResult);
+ case KCasePlayFileHandlerWithGetPosition:
+ return TestCasePlayHandlerWithGetPositionL(section, aResult);
+ case KCasePlayFileHandlerWithDuration:
+ return TestCasePlayHandlerWithDurationL(section, aResult);
+ case KCasePlayFileHandlerWithWindow:
+ return TestCasePlayHandlerWithWindowL(section, aResult);
+ case KCasePlayFileHandlerWithClearWindow:
+ return TestCasePlayHandlerWithClearWindowL(section, aResult);
+ case KCasePlayFileGetAudioLoadingProgress:
+ return TestCasePlayFilesGetAudioLoadingProgress(section, aResult);
+ case KCasePlayFileRegisterForAudioLoadingNotification:
+ return TestCasePlayFilesRegisterForAudioLoadingNotification(section, aResult);
+ case KCasePlayFileImplementationInformation:
+ return TestCasePlayFilesImplementationInformation(section, aResult);
+ case KCasePlayRepeatDRMFile:
+ return TestCasePlayRepeatDRMFile(section, aResult);
+ case KCasePlayPauseRepeatDRMFile:
+ return TestCasePlayPauseRepeatDRMFile(section, aResult);
+ case KCasePlayRepeatDRMFileForever:
+ return TestCasePlayRepeatDRMFileForever(section, aResult);
+ case KCasePlayRepeatDRMFileWithPlayWindow:
+ return TestCasePlayRepeatDRMFileWithPlayWindow(section, aResult);
+ case KCasePlayPauseRepeatDRMFileWithPlayWindow:
+ return TestCasePlayPauseRepeatDRMFileWithPlayWindow(section, aResult);
+ case KCasePlayRepeatForeverDRMFileWithPlayWindow:
+ return TestCasePlayRepeatForeverDRMFileWithPlayWindow(section, aResult);
+ }
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+
+TBool CDRMAudioPlay::IsDurationInRange
+ ( TInt aRepeatTimes, TTimeIntervalMicroSeconds aToneDuration, TTimeIntervalMicroSeconds aRepeatSilence,
+ TTimeIntervalMicroSeconds aErrorRange , TTime aStartTime , TTime aEndTime )
+ {
+ TInt64 tmp=aToneDuration.Int64();
+ TInt64 tmp2=aRepeatSilence.Int64();
+
+ tmp*=(aRepeatTimes+1); tmp2*=(aRepeatTimes);
+ TTimeIntervalMicroSeconds ExpectedDuration = tmp+tmp2;
+
+ TTime EndTimeRange1 = aStartTime;
+ EndTimeRange1+= ExpectedDuration;
+ TTime EndTimeRange2 = EndTimeRange1;
+ EndTimeRange1-=aErrorRange;
+ EndTimeRange2+=aErrorRange;
+
+ iLogger->Log(_L("Actual play duration (%d)") , (aEndTime.MicroSecondsFrom(aStartTime)).Int64() );
+ iLogger->Log(_L("Expected duration (%d)") , ExpectedDuration.Int64());
+ iLogger->Log(_L("Error range (%d)") , aErrorRange.Int64());
+ return (EndTimeRange1<aEndTime && aEndTime<EndTimeRange2) ;
+ }
+
+void CDRMAudioPlay::TestCasePreCheck(CStifSectionParser *section, TFileName& aFileName)
+ {
+ TPtrC FileNamePtr;
+ TPtrC RightsPtr;
+ RFs rightsFs;
+ RFile rightsFile;
+ RFs contentFs;
+ RFile contentFile;
+ if (( ! section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) ) && ( ! section->GetLine(KTagRightsFile, RightsPtr, ENoTag) ))
+ {
+ User::LeaveIfError(rightsFs.Connect());
+ rightsFs.ShareProtected();
+ TFileName rightsFileName = RightsPtr;
+ iLogger->Log(_L("Rights file location [%S] "), &rightsFileName);
+ if (! BaflUtils::FileExists(rightsFs, rightsFileName))
+ {
+ iLogger->Log(_L("Rights file [%S] doesn't exits !!! "), &rightsFileName);
+ User::Leave(KErrNotFound);
+ }
+#ifdef __WINSCW__
+ // copy the DRM rights file to the destination folder (\private\DRM_AGENT_SID\Import) only for WINSCW
+ if (! BaflUtils::PathExists(rightsFs, KTagOMADRMRightsDir))
+ {
+ TRAPD(err, rightsFs.MkDirAll(KTagOMADRMRightsDir));
+ if ((err != KErrNone) && (err != KErrAlreadyExists))
+ {
+ iLogger->Log(_L("Unable to create the path [%S] Err[%d]"), &KTagOMADRMRightsDir, err);
+ User::Leave(err);
+ }
+ }
+ iLogger->Log(_L("Copying Rights file [%S] to [%S] "),&rightsFileName, &KTagOMADRMRightsDir);
+ BaflUtils::CopyFile(rightsFs, rightsFileName, KTagOMADRMRightsDir);
+#endif
+ rightsFs.Close();
+ User::LeaveIfError(rightsFs.Connect());
+ rightsFs.ShareProtected();
+ User::LeaveIfError(rightsFile.Open( rightsFs, rightsFileName, EFileRead));
+ HBufC8* rContent = HBufC8::NewL(2048); // incase the drm rights file size is more than 2kb then this size must be altered accordingly
+ CleanupStack::PushL(rContent);
+ TPtr8 rightsContentPtr = rContent->Des();
+ rightsFile.Read(rightsContentPtr);
+ ProcessRightsL(rightsContentPtr);
+ CleanupStack::PopAndDestroy(rContent); // HBufC8*
+ rightsFile.Close();
+ rightsFs.Close();
+
+ // copy the DRM content file to the destination folder (\private\DRM_AGENT_SID\DRM_AGENT_NAME)
+ User::LeaveIfError(contentFs.Connect());
+ contentFs.ShareProtected();
+ TFileName contentFileName = FileNamePtr;
+ iLogger->Log(_L("Audio file location [%S] "), &contentFileName);
+ if (! BaflUtils::FileExists(contentFs, contentFileName))
+ {
+ iLogger->Log(_L("Content file [%S] doesn't exits !!! "), &contentFileName);
+ User::Leave(KErrNotFound);
+ }
+ if (! BaflUtils::PathExists(contentFs, KTagOMADRMContentDir))
+ {
+ TRAPD(err, contentFs.MkDirAll(KTagOMADRMContentDir));
+ if ((err != KErrNone) && (err != KErrAlreadyExists))
+ {
+ iLogger->Log(_L("Unable to create the path [%S] Err[%d]"), &KTagOMADRMContentDir, err);
+ User::Leave(err);
+ }
+ }
+ iLogger->Log(_L("Copying Content file [%S] to [%S] "),&contentFileName, &KTagOMADRMContentDir);
+ BaflUtils::CopyFile(contentFs, contentFileName, KTagOMADRMContentDir);
+ contentFs.Close();
+ User::LeaveIfError(contentFs.Connect());
+ contentFs.ShareProtected();
+ User::LeaveIfError(contentFile.Open( contentFs, contentFileName, EFileRead));
+ TFileName contentFileNameWithExt;
+ contentFile.Name(contentFileNameWithExt);
+ aFileName.Append(KTagOMADRMContentDir);
+ aFileName.Append(contentFileNameWithExt);
+ iLogger->Log(_L("contentFileNameWithExt [%S]"), &contentFileNameWithExt);
+ contentFile.Close();
+ contentFs.Close();
+ iDRMPreCheckPassed = ETrue;
+ }
+ else
+ {
+ iDRMPreCheckPassed = EFalse;
+ }
+ }
+
+_LIT(KDirectoryPath, "C:\\private\\12345678\\");
+void CDRMAudioPlay::ProcessRightsL(const TDesC8& aRightsXMLContent)
+ {
+ iLogger->Log(_L("ProcessRightsL <==="));
+ TInt err = KErrNone;
+ TFileName fileName;
+ TPath outputFileName;
+ CSupplier *mySupplier = CSupplier::NewL();
+ CleanupStack::PushL(mySupplier);
+ iLogger->Log(_L("ProcessRightsL: Supplier created ... "));
+ CMetaDataArray* metaDataArray = CMetaDataArray::NewL();
+ iLogger->Log(_L("ProcessRightsL: MetaDataArray created ... "));
+ CleanupStack::PushL(metaDataArray);
+ metaDataArray->AddL(_L("Content Type"),_L("application/vnd.oma.drm.rights+xml"));
+ // Create the import object
+ CImportFile* import = mySupplier->ImportFileL(KOma1XmlRoContentType, *metaDataArray);
+ iLogger->Log(_L("ProcessRightsL: ImportFile created ... "));
+ CleanupStack::PushL(import);
+ err = import->WriteData(aRightsXMLContent);
+ iLogger->Log(_L("ProcessRightsL: Wrote the rightsfile to ImportData err[%d] "), err);
+ while(err == KErrCANewFileHandleRequired)
+ {
+ iLogger->Log(_L("ProcessRightsL: KErrCANewFileHandleRequired"));
+ RFs newfs;
+ RFile newFile;
+ User::LeaveIfError(newfs.Connect());
+ import->GetSuggestedOutputFileName(fileName);
+ outputFileName.Copy(KDirectoryPath);
+ outputFileName.Append(fileName);
+ newFile.Open(newfs, outputFileName, EFileWrite);
+ err = import->ContinueWithNewOutputFile(newFile, outputFileName);
+ newFile.Close(); // agent makes a copy so we don't need to keep our file handle
+ newfs.Close();
+ }
+ iLogger->Log(_L("ProcessRightsL: Error after the Writing ImportFile [%d]"), err);
+ // tell CAF (and hence the agent) it's now got the entire file
+ if (err == KErrNone)
+ {
+ err = import->WriteDataComplete();
+ iLogger->Log(_L("ProcessRightsL: Error after the ImportFile WriteDataComplete [%d]"), err);
+ if (err == KErrNone)
+ {
+ // Look at the output of the import operation
+ for(TInt i = 0; i < import->OutputFileCountL(); i++)
+ {
+ // for this example only add content output files
+ // (absorb any rights in the original attachment 'silently')
+ if(import->OutputFileL(i).OutputType() == EContent)
+ {
+ // Add file to list of attachments for this message
+ iLogger->Log(_L("FileName [%S]"),(import->OutputFileL(i).FileName().Ptr()));
+ }
+ }
+ }
+ }
+ // Error handling
+ if (err != KErrNone)
+ {
+ if (err == KErrNotReady)
+ {
+ iLogger->Log(_L("Agent not ready for import"));
+ }
+ else if (err == KErrCACorruptContent)
+ {
+ iLogger->Log(_L("Content data is corrupt"));
+ }
+ else
+ {
+ iLogger->Log(_L("Unexpected error: %d"), err);
+ }
+ }
+ // Finished
+ CleanupStack::PopAndDestroy(3); // mySupplier, metaDataArray, import
+ iLogger->Log(_L("ProcessRightsL ===>"));
+ }
+
+TInt CDRMAudioPlay::TestCasePlayRepeatDRMFile(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;
+ TTimeIntervalMicroSeconds repeatSilenceTimer = KDefaultSilenceDuration;
+ TInt repeatCount = 0;
+ TFileName fileName;
+ iDRMPreCheckPassed = EFalse;
+ TestCasePreCheck(section, fileName);
+ if (iDRMPreCheckPassed)
+ {
+ TBool UsingRepeatCountDefault, UsingRepeatSilencerDefault;
+ repeatCount = GetIntL(section, KTagRepeatTimes, UsingRepeatCountDefault, KDefaultRepeats);
+ repeatSilenceTimer = GetTimeIntervalL(section, KTagSilenceDuration, UsingRepeatSilencerDefault, KDefaultSilenceDuration);
+ iLogger->Log(_L("Repeat count [%d] Silence timer [%d]"), repeatCount, I64LOW(repeatSilenceTimer.Int64()));
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+ User::LeaveIfError(iFile.Open( iFs, fileName, EFileRead));
+ iLogger->Log(_L("Creating simple player with file [%S]"), &fileName);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+ sndPlayer->iDontPlayAudioClip = ETrue; // don't start the play back after initialize complete
+ CActiveScheduler::Start();
+ sndPlayer->SetRepeats(repeatCount, TTimeIntervalMicroSeconds(repeatSilenceTimer));
+ sndPlayer->SetVolumeRamp(100000);
+ sndPlayer->Play(); // Start the playback
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start();
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+ sndPlayer->SetRepeats(0,0);
+ if ((aResult.iResult != KErrNone) && (aResult.iResult != KErrCANoRights))
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ if (aResult.iResult == KErrCANoRights)
+ aResult.iResult = KErrNone;
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ iFile.Close();
+ iFs.Close();
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ iFs.Close();
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayPauseRepeatDRMFile(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;
+ TInt repeatCount = 0;
+ TTimeIntervalMicroSeconds repeatSilenceTimer = KDefaultSilenceDuration;
+ TTimeIntervalMicroSeconds32 PauseDelay=KDefaultPauseDelay;
+ TTimeIntervalMicroSeconds32 PlayDelay=KDefaultPlayDelay;
+ TFileName fileName;
+ iDRMPreCheckPassed = EFalse;
+ TestCasePreCheck(section, fileName);
+ if (iDRMPreCheckPassed)
+ {
+ TBool UsingRepeatCountDefault, UsingRepeatSilencerDefault, UsingDefault;
+ repeatCount = GetIntL(section, KTagRepeatTimes, UsingRepeatCountDefault, KDefaultRepeats);
+ repeatSilenceTimer = GetTimeIntervalL(section, KTagSilenceDuration, UsingRepeatSilencerDefault, KDefaultSilenceDuration);
+ iLogger->Log(_L("Repeat count [%d] Silence timer [%d]"), repeatCount, I64LOW(repeatSilenceTimer.Int64()));
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+ User::LeaveIfError(iFile.Open( iFs, fileName, EFileRead));
+ iLogger->Log(_L("Creating simple player with file [%S]"), &fileName);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+ PauseDelay = GetTimeIntervalL(section, KTagPauseDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPauseDelay);
+ if (UsingDefault) {iLogger->Log(_L("Error retrieving pause delay, using default"));}
+ PlayDelay = GetTimeIntervalL(section, KTagPlayDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPlayDelay);
+ if (UsingDefault) {iLogger->Log(_L("Error retrieving play delay, using default"));}
+ iLogger->Log(_L("Setting Pause and Play delays to [%d] and [%d]"), PauseDelay.Int(), PlayDelay.Int());
+ sndPlayer->SetRepeats(repeatCount, TTimeIntervalMicroSeconds(repeatSilenceTimer));
+ sndPlayer->SetVolumeRamp(100000);
+ sndPlayer->iDontPlayAudioClip = ETrue; // don't start the play back after initialize complete
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start(); // initialize the player and wait for the intialize complete event
+ TTimeIntervalMicroSeconds dur = sndPlayer->GetDuration();
+ sndPlayer->Play(); // Start the loop play in the play window
+ /*********************************************/
+ /* For generating the Pause event during playback */
+ /*********************************************/
+ TTimeIntervalMicroSeconds32 interval = TTimeIntervalMicroSeconds32(dur.Int64() + repeatSilenceTimer.Int64() + (PlayDelay.Int() - PauseDelay.Int()));
+ CParameters *pauseParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPause );
+ CleanupStack::PushL(pauseParams);
+ CParameters *playParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPlay );
+ CleanupStack::PushL(playParams);
+ CMediaEvent* mEventPause = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PauseDelay, interval, sndPlayer, pauseParams);
+ CMediaEvent* mEventPlay = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PlayDelay, interval, sndPlayer, playParams);
+ CActiveScheduler::Start(); // start the playback in the play window and loop play
+ sndPlayer->SetRepeats(0,0);
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+ if ((aResult.iResult != KErrNone) && (aResult.iResult != KErrCANoRights))
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ if (aResult.iResult == KErrCANoRights)
+ aResult.iResult = KErrNone;
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ iFile.Close();
+ iFs.Close();
+ CleanupStack::PopAndDestroy(mEventPlay);
+ CleanupStack::PopAndDestroy(mEventPause);
+ CleanupStack::Pop(playParams);
+ CleanupStack::Pop(pauseParams);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ return KErrExecuted;
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayRepeatDRMFileForever(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;
+ TInt repeatCount = 0;
+ TTimeIntervalMicroSeconds repeatSilenceTimer = 0;
+ TFileName fileName;
+ iDRMPreCheckPassed = EFalse;
+ TestCasePreCheck(section, fileName);
+ if (iDRMPreCheckPassed)
+ {
+ TBool UsingRepeatCountDefault, UsingRepeatSilencerDefault;
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+ User::LeaveIfError(iFile.Open( iFs, fileName, EFileRead));
+ iLogger->Log(_L("Creating simple player with file [%S]"), &fileName);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+ repeatCount = GetIntL(section, KTagRepeatTimes, UsingRepeatCountDefault, KDefaultRepeats);
+ if (repeatCount != KDefaultRepeatForever)
+ repeatCount = KDefaultRepeatForever;
+ repeatSilenceTimer = GetTimeIntervalL(section, KTagSilenceDuration, UsingRepeatSilencerDefault, (TTimeIntervalMicroSeconds)KDefaultSilenceDuration);
+ sndPlayer->SetRepeats(repeatCount, repeatSilenceTimer);
+ sndPlayer->SetVolumeRamp(100000);
+ CActiveScheduler::Start();
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+ sndPlayer->SetRepeats(0,0);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ if ((aResult.iResult != KErrNone) && (aResult.iResult != KErrCANoRights))
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ if (aResult.iResult == KErrCANoRights)
+ aResult.iResult = KErrNone;
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ iFile.Close();
+ iFs.Close();
+ return KErrExecuted;
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayRepeatDRMFileWithPlayWindow(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TTimeIntervalMicroSeconds startPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds endPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;
+ TInt repeatCount = 0;
+ TTimeIntervalMicroSeconds repeatSilenceTimer = 0;
+ TFileName fileName;
+ iDRMPreCheckPassed = EFalse;
+ TestCasePreCheck(section, fileName);
+ if (iDRMPreCheckPassed)
+ {
+ TBool UsingStartDefault, UsingEndDefault, UsingRepeatCountDefault, UsingRepeatSilencerDefault;
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+ User::LeaveIfError(iFile.Open( iFs, fileName, EFileRead));
+ iLogger->Log(_L("Creating simple player with file [%S]"), &fileName);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+ repeatCount = GetIntL(section, KTagRepeatTimes, UsingRepeatCountDefault, KDefaultRepeats);
+ repeatSilenceTimer = GetTimeIntervalL(section, KTagSilenceDuration, UsingRepeatSilencerDefault, (TTimeIntervalMicroSeconds)KDefaultSilenceDuration);
+ startPosition = GetTimeIntervalL(section, KTagWindowStart, UsingStartDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()-1E6));
+ endPosition = GetTimeIntervalL(section, KTagWindowEnd, UsingEndDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()+1E6));
+ // sndPlayer->iDontPlayAudioClip = ETrue; // don't start the play back after initialize complete
+ iLogger->Log(_L("Starting scheduler"));
+ sndPlayer->SetRepeats(repeatCount, repeatSilenceTimer);
+ sndPlayer->SetVolumeRamp(100000);
+ sndPlayer->iPlayWindow = ETrue;
+ sndPlayer->iStartPosition = startPosition;
+ sndPlayer->iEndPosition = endPosition;
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start(); // initialize the player and wait for the intialize complete event
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+ sndPlayer->SetRepeats(0,0);
+ sndPlayer->iPlayWindow = EFalse;
+ sndPlayer->ClearPlayWindow();
+ CleanupStack::PopAndDestroy(sndPlayer);
+ if ((aResult.iResult != KErrNone) && (aResult.iResult != KErrCANoRights))
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ if (aResult.iResult == KErrCANoRights)
+ aResult.iResult = KErrNone;
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ iFile.Close();
+ iFs.Close();
+ return KErrExecuted;
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayPauseRepeatDRMFileWithPlayWindow(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TTimeIntervalMicroSeconds startPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds endPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;
+ TTimeIntervalMicroSeconds32 PauseDelay=KDefaultPauseDelay;
+ TTimeIntervalMicroSeconds32 PlayDelay=KDefaultPlayDelay;
+ TInt repeatCount = 0;
+ TTimeIntervalMicroSeconds repeatSilenceTimer = 0;
+ TFileName fileName;
+ iDRMPreCheckPassed = EFalse;
+ TestCasePreCheck(section, fileName);
+ if (iDRMPreCheckPassed)
+ {
+ TBool UsingStartDefault, UsingEndDefault, UsingRepeatCountDefault, UsingRepeatSilencerDefault, UsingDefault;
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+ User::LeaveIfError(iFile.Open( iFs, fileName, EFileRead));
+ iLogger->Log(_L("Creating simple player with file [%S]"), &fileName);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+ repeatCount = GetIntL(section, KTagRepeatTimes, UsingRepeatCountDefault, KDefaultRepeats);
+ repeatSilenceTimer = GetTimeIntervalL(section, KTagSilenceDuration, UsingRepeatSilencerDefault, (TTimeIntervalMicroSeconds)KDefaultSilenceDuration);
+ startPosition = GetTimeIntervalL(section, KTagWindowStart, UsingStartDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()-1E6));
+ endPosition = GetTimeIntervalL(section, KTagWindowEnd, UsingEndDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()+1E6));
+ PauseDelay = GetTimeIntervalL(section, KTagPauseDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPauseDelay);
+ if (UsingDefault) {iLogger->Log(_L("Error retrieving pause delay, using default"));}
+ PlayDelay = GetTimeIntervalL(section, KTagPlayDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPlayDelay);
+ if (UsingDefault) {iLogger->Log(_L("Error retrieving play delay, using default"));}
+ iLogger->Log(_L("Setting Pause and Play delays to [%d] and [%d]"), PauseDelay.Int(), PlayDelay.Int());
+ sndPlayer->iDontPlayAudioClip = ETrue; // don't start the play back after initialize complete
+ sndPlayer->SetRepeats(repeatCount, repeatSilenceTimer);
+ sndPlayer->SetVolumeRamp(100000);
+ sndPlayer->iPlayWindow = ETrue;
+ sndPlayer->iStartPosition = startPosition;
+ sndPlayer->iEndPosition = endPosition;
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start(); // initialize the player and wait for the intialize complete event
+ TTimeIntervalMicroSeconds dur = sndPlayer->GetDuration();
+ TTimeIntervalMicroSeconds32 interval = TTimeIntervalMicroSeconds32((endPosition.Int64() - startPosition.Int64()) + repeatSilenceTimer.Int64() + (PlayDelay.Int() - PauseDelay.Int()));
+ sndPlayer->Play(); // Start the loop play in the play window
+ // sndPlayer->SetPlayWindow(startPosition, endPosition);
+ /*********************************************/
+ /* For generating the Pause event during playback */
+ /*********************************************/
+ CParameters *pauseParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPause );
+ CleanupStack::PushL(pauseParams);
+ CParameters *playParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPlay );
+ CleanupStack::PushL(playParams);
+ CMediaEvent* mEventPause = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PauseDelay, interval, sndPlayer, pauseParams);
+ CMediaEvent* mEventPlay = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PlayDelay, interval, sndPlayer, playParams);
+ CActiveScheduler::Start(); // start the playback in the play window and loop play
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+ if ((aResult.iResult != KErrNone) && (aResult.iResult != KErrCANoRights))
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ if (aResult.iResult == KErrCANoRights)
+ aResult.iResult = KErrNone;
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ sndPlayer->SetRepeats(0,0);
+ sndPlayer->iPlayWindow = EFalse;
+ sndPlayer->ClearPlayWindow();
+ CleanupStack::PopAndDestroy(mEventPlay);
+ CleanupStack::PopAndDestroy(mEventPause);
+ CleanupStack::Pop(playParams);
+ CleanupStack::Pop(pauseParams);
+ CleanupStack::PopAndDestroy(sndPlayer);
+ iFile.Close();
+ iFs.Close();
+ return KErrExecuted;
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }
+
+TInt CDRMAudioPlay::TestCasePlayRepeatForeverDRMFileWithPlayWindow(CStifSectionParser *section , TTestResult &aResult)
+ {
+ TTimeIntervalMicroSeconds startPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds endPosition = KDefaultPosition;
+ TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;
+ TInt repeatCount = 0;
+ TTimeIntervalMicroSeconds repeatSilenceTimer = 0;
+ TFileName fileName;
+ iDRMPreCheckPassed = EFalse;
+ TestCasePreCheck(section, fileName);
+ if (iDRMPreCheckPassed)
+ {
+ TBool UsingStartDefault, UsingEndDefault, UsingRepeatCountDefault, UsingRepeatSilencerDefault;
+ User::LeaveIfError(iFs.Connect());
+ iFs.ShareProtected();
+ User::LeaveIfError(iFile.Open( iFs, fileName, EFileRead));
+ iLogger->Log(_L("Creating simple player with file [%S]"), &fileName);
+ CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);
+ CleanupStack::PushL(sndPlayer);
+ repeatCount = GetIntL(section, KTagRepeatTimes, UsingRepeatCountDefault, KDefaultRepeats);
+ if (repeatCount != KDefaultRepeatForever)
+ repeatCount = KDefaultRepeatForever;
+ repeatSilenceTimer = GetTimeIntervalL(section, KTagSilenceDuration, UsingRepeatSilencerDefault, (TTimeIntervalMicroSeconds)KDefaultSilenceDuration);
+ startPosition = GetTimeIntervalL(section, KTagWindowStart, UsingStartDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()-1E6));
+ endPosition = GetTimeIntervalL(section, KTagWindowEnd, UsingEndDefault, (TTimeIntervalMicroSeconds)(KDefaultPosition.Int64()+1E6));
+ sndPlayer->SetRepeats(repeatCount, repeatSilenceTimer);
+ sndPlayer->SetVolumeRamp(100000);
+ sndPlayer->iPlayWindow = ETrue;
+ sndPlayer->iStartPosition = startPosition;
+ sndPlayer->iEndPosition = endPosition;
+ sndPlayer->iDontPlayAudioClip = ETrue; // don't start the play back after initialize complete
+ iLogger->Log(_L("Starting scheduler"));
+ CActiveScheduler::Start(); // initialize the player and wait for the intialize complete event
+ sndPlayer->Play(); // Start the loop play in the play window
+ CActiveScheduler::Start();
+ iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );
+ aResult.iResult = sndPlayer->iFinalError;
+ sndPlayer->SetRepeats(0,0);
+ sndPlayer->iPlayWindow = EFalse;
+ sndPlayer->ClearPlayWindow();
+ CleanupStack::PopAndDestroy(sndPlayer);
+ if ((aResult.iResult != KErrNone) && (aResult.iResult != KErrCANoRights))
+ {
+ iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);
+ aResult.iResultDes.Copy(KTestCaseResultFail());
+ }
+ else
+ {
+ iLogger->Log(_L("Test was successful"));
+ if (aResult.iResult == KErrCANoRights)
+ aResult.iResult = KErrNone;
+ aResult.iResultDes.Copy(KTestCaseResultSuccess());
+ }
+ iFile.Close();
+ iFs.Close();
+ return KErrExecuted;
+ }
+ else
+ {
+ aResult.iResultDes.Copy(KConfigInvalid());
+ aResult.iResult = KErrNotExecuted;
+ return KErrConfigInvalid;
+ }
+ }