--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfintegrationtest/ACLNT/TestPlayerUtilsARN.cpp Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,2732 @@
+// Copyright (c) 2005-2009 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:
+// CPP file: Audio Resource Notification tests for Audio Player.
+//
+//
+
+/**
+ @file TestPlayerUtilsARN.cpp
+*/
+
+#include "TestAudioClientUtilitiesARN.h"
+
+//------------------------------------------------------------------------------
+//********************PREQ 797 - Audio Resource Notification********************
+//------------------------------------------------------------------------------
+
+//
+//CTestMdaAudioPlayerCallbackSupport
+//
+
+/**
+ * NewL
+ */
+CTestMdaAudioPlayerCallbackSupport* CTestMdaAudioPlayerCallbackSupport::NewL(MTestAudioPlayerCallback& aCallback)
+ {
+ return new(ELeave) CTestMdaAudioPlayerCallbackSupport(aCallback);
+ }
+
+/**
+ * MapcInitComplete
+ */
+void CTestMdaAudioPlayerCallbackSupport::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration)
+ {
+ iCallback.MapcInitCompleteTest(aError, aDuration, *this);
+ }
+
+/**
+ * MapcPlayComplete
+ */
+void CTestMdaAudioPlayerCallbackSupport::MapcPlayComplete(TInt aError)
+ {
+ iCallback.MapcPlayCompleteTest(aError, *this);
+ }
+
+/**
+ * MarncResourceAvailable
+ */
+void CTestMdaAudioPlayerCallbackSupport::MarncResourceAvailable(TUid aNotificationEventId, const TDesC8& aNotificationData)
+ {
+ iCallback.MarncResourceAvailableTest(aNotificationEventId, aNotificationData, *this);
+ }
+
+/**
+ * Constructor
+ */
+CTestMdaAudioPlayerCallbackSupport::CTestMdaAudioPlayerCallbackSupport(MTestAudioPlayerCallback& aCallback):iCallback(aCallback)
+ {
+
+ }
+
+//
+//CTestMmfAclntAudioPlayerARN
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntAudioPlayerARN::CTestMmfAclntAudioPlayerARN(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ // store the name of this test case
+ iTestStepName=aTestName;
+ iHeapSize = 3600000;
+ iSectName = aSectName;
+ }
+
+
+/**
+ * MapcInitCompleteTest
+ */
+void CTestMmfAclntAudioPlayerARN::MapcInitCompleteTest(TInt aError, const TTimeIntervalMicroSeconds& aDuration, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport)
+ {
+ iDuration = aDuration;
+ if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport1)
+ {
+ INFO_PRINTF2(_L("iAudioPlayer1 -> MMdaAudioPlayerCallback InitComplete (%d)"),aError);
+ TRAP(iError, FsmL(EMapcInitComplete1, aError));
+ }
+ else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport2)
+ {
+ INFO_PRINTF2(_L("iAudioPlayer2 -> MMdaAudioPlayerCallback InitComplete (%d)"),aError);
+ TRAP(iError, FsmL(EMapcInitComplete2, aError));
+ }
+ else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport3)
+ {
+ INFO_PRINTF2(_L("iAudioPlayer3 -> MMdaAudioPlayerCallback InitComplete (%d)"),aError);
+ TRAP(iError, FsmL(EMapcInitComplete3, aError));
+ }
+ }
+
+
+/**
+ * MapcPlayCompleteTest
+ */
+void CTestMmfAclntAudioPlayerARN::MapcPlayCompleteTest(TInt aError, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport)
+ {
+ if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport1)
+ {
+ INFO_PRINTF2(_L("iAudioPlayer1 -> MMdaAudioPlayerCallback PlayComplete (%d)"), aError);
+ TRAP(iError, FsmL(EMapcPlayComplete1, aError));
+ }
+ else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport2)
+ {
+ INFO_PRINTF2(_L("iAudioPlayer2 -> MMdaAudioPlayerCallback PlayComplete (%d)"), aError);
+ TRAP(iError, FsmL(EMapcPlayComplete2, aError));
+ }
+ else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport3)
+ {
+ INFO_PRINTF2(_L("iAudioPlayer3 -> MMdaAudioPlayerCallback PlayComplete (%d)"), aError);
+ TRAP(iError, FsmL(EMapcPlayComplete3, aError));
+ }
+ }
+
+
+/**
+ * MarncResourceAvailableTest
+ */
+void CTestMmfAclntAudioPlayerARN::MarncResourceAvailableTest(TUid aNotificationEventId, const TDesC8& aNotificationData, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport)
+ {
+ if (aNotificationEventId == KMMFEventCategoryAudioResourceAvailable)
+ {
+ INFO_PRINTF1(_L("iAudioPlayer::MMMFAudioResourceNotificationCallback -> KMMFEventCategoryAudioResourceAvailable"));
+
+ //Convert TDesc8 to TInt64
+ TMMFTimeIntervalMicroSecondsPckg timeIntvbuf;
+ timeIntvbuf.Copy(aNotificationData);
+ TTimeIntervalMicroSeconds intPos = timeIntvbuf();
+ iPosition = intPos;
+ if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport1)
+ {
+ INFO_PRINTF1(_L("iAudioPlayer1 -> MMMFAudioResourceNotificationCallback : AudioResourceAvailable..waiting for playcomplete"));
+ TRAP(iError, FsmL(EMarncResourceAvailable1, KErrNone));
+ }
+ else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport2)
+ {
+ INFO_PRINTF1(_L("iAudioPlayer2 -> MMMFAudioResourceNotificationCallback : AudioResourceAvailable"));
+ TRAP(iError, FsmL(EMarncResourceAvailable2, KErrNone));
+ }
+ else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport3)
+ {
+ INFO_PRINTF1(_L("iAudioPlayer3 -> MMMFAudioResourceNotificationCallback : AudioResourceAvailable"));
+ TRAP(iError, FsmL(EMarncResourceAvailable3, KErrNone));
+ }
+ }
+ else
+ {
+ INFO_PRINTF1(_L("MMMFAudioResourceNotificationCallback, but NOT KMMFEventCategoryAudioResourceAvailable"));
+ }
+ }
+
+/**
+ * DoTestStepPreambleL
+ */
+TVerdict CTestMmfAclntAudioPlayerARN::DoTestStepPreambleL()
+ {
+ TPtrC filename;
+ TVerdict ret = EPass;
+
+ // Call base DoTestStepPreambleL()
+ ret = CTestMmfAclntStep::DoTestStepPreambleL();
+ if (ret == EFail)
+ {
+ return ret;
+ }
+
+ // Get 1st file name
+ if(!GetStringFromConfig(iSectName, _L("playerAudioFile1"), filename))
+ {
+ return EInconclusive;
+ }
+ GetDriveName(iFilename1);
+ iFilename1.Append(filename);
+
+ iEventChecker = CMultiEventChecker::NewL();
+ // Initialise 1st Audio Player
+ INFO_PRINTF1(_L("Initialise CMdaAudioPlayerUtility1 : EMdaPriorityNormal"));
+ iMdaAudioPlayerCallbackSupport1 = CTestMdaAudioPlayerCallbackSupport::NewL(*this);
+ iTestAudioPlayer1 = CMdaAudioPlayerUtility::NewL(*iMdaAudioPlayerCallbackSupport1, EMdaPriorityNormal);
+
+ // Get 2nd file name
+ if(!GetStringFromConfig(iSectName, _L("playerAudioFile2"), filename))
+ {
+ return EInconclusive;
+ }
+ GetDriveName(iFilename2);
+ iFilename2.Append(filename);
+
+ // Initialise 2nd Audio Player
+ INFO_PRINTF1(_L("Initialise CMdaAudioPlayerUtility2 : EMdaPriorityMax"));
+ iMdaAudioPlayerCallbackSupport2 = CTestMdaAudioPlayerCallbackSupport::NewL(*this);
+ iTestAudioPlayer2 = CMdaAudioPlayerUtility::NewL(*iMdaAudioPlayerCallbackSupport2, EMdaPriorityMax);
+
+ // Get 3rd file name
+ if(!GetStringFromConfig(iSectName, _L("playerAudioFile3"), filename))
+ {
+ return EInconclusive;
+ }
+ GetDriveName(iFilename3);
+ iFilename3.Append(filename);
+
+ // Initialise 3rd Audio Player
+ INFO_PRINTF1(_L("Initialise CMdaAudioPlayerUtility3 : EMdaPriorityMin"));
+ iMdaAudioPlayerCallbackSupport3 = CTestMdaAudioPlayerCallbackSupport::NewL(*this);
+ iTestAudioPlayer3 = CMdaAudioPlayerUtility::NewL(*iMdaAudioPlayerCallbackSupport3, EMdaPriorityMin);
+
+ // Initialise the CCallBackTimer.
+ iCallBackTimer = CCallBackTimer::NewL(TCallBack(stopActiveScheduler));
+
+ return ret;
+ }
+
+/**
+ * DoTestStepPostambleL
+ */
+TVerdict CTestMmfAclntAudioPlayerARN::DoTestStepPostambleL()
+ {
+ // Delete all the iTestAudioPlayer utilities.
+ iTestAudioPlayer1->Close();
+ delete iTestAudioPlayer1;
+ iTestAudioPlayer1=NULL;
+ iTestAudioPlayer2->Close();
+ delete iTestAudioPlayer2;
+ iTestAudioPlayer2=NULL;
+ iTestAudioPlayer3->Close();
+ delete iTestAudioPlayer3;
+ iTestAudioPlayer3=NULL;
+ // Delete CTestMdaAudioPlayerCallbackSupport
+ delete iMdaAudioPlayerCallbackSupport1;
+ delete iMdaAudioPlayerCallbackSupport2;
+ delete iMdaAudioPlayerCallbackSupport3;
+ // Delete the CCallBackTimer.
+ delete iCallBackTimer;
+ iCallBackTimer=NULL;
+ delete iEventChecker;
+ // Base Postamble.
+ return CTestMmfAclntStep::DoTestStepPostambleL();
+ }
+
+/**
+ * DoTestStepL
+ */
+TVerdict CTestMmfAclntAudioPlayerARN::DoTestStepL()
+ {
+ return( DoTestL() );
+ }
+
+/**
+ * StateInit
+ */
+void CTestMmfAclntAudioPlayerARN::StateInit()
+ {
+ iExpectedEvent=EIdlePlayer;
+ iExpectedError=KErrNone;
+ iState=EStateBegin;
+ }
+
+/**
+ * StateChange
+ */
+void CTestMmfAclntAudioPlayerARN::StateChange(TMmfAudioPlayerState aState, TMmfAudioPlayerEvents aExpectedEvent, TInt aExpectedError)
+ {
+ iExpectedEvent=aExpectedEvent;
+ iExpectedError=aExpectedError;
+ iState=aState;
+ }
+
+/**
+ * FsmCheck
+ */
+TBool CTestMmfAclntAudioPlayerARN::FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ TBool retFsmCheck = EFalse;
+ if (((aEventCode == EMapcPlayComplete1) || (aEventCode == EMapcPlayComplete2)) && (aError == KErrUnderflow))
+ {
+ INFO_PRINTF1(_L("Underflow !"));
+ }
+ else if (iExpectedEvent != aEventCode)
+ {
+ ERR_PRINTF3(_L("ExpectedEvent : %d, ActualEvent : %d"), iExpectedEvent, aEventCode);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ else if (iExpectedError != aError)
+ {
+ ERR_PRINTF3(_L("ExpectedError : %d, ActualError : %d"), iExpectedError, aError);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ else
+ {
+ retFsmCheck = ETrue;
+ }
+ return retFsmCheck;
+ }
+
+//
+//POSITIVE TESTS//
+//
+
+//
+//CTestMmfAclntARN8101
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN8101::CTestMmfAclntARN8101(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN8101* CTestMmfAclntARN8101::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN8101* self = new (ELeave) CTestMmfAclntARN8101(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN8101::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN8101::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateOpenPlayer2, EMapcInitComplete1);
+ break;
+ case EStateOpenPlayer2:
+ // Register iTestAudioPlayer#1 for Notification
+ retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Open iTestAudioPlayer#2
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying2, EMapcInitComplete2);
+ break;
+ case EStatePlaying2:
+ // Play iTestAudioPlayer#2
+ iTestAudioPlayer2->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateEndPlay2, EMapcPlayComplete2);
+ break;
+ case EStateEndPlay2:
+ // Timer to check if Notification Event Occurs.
+ iCallBackTimer->After(2000000);
+ iTestStepResult = EPass;
+ // Set ExpectedEvent and change the State
+ StateChange(EStateNotifiedPlayer1, EMarncResourceAvailable1);
+ break;
+ case EStateNotifiedPlayer1:
+ iCallBackTimer->Cancel(); // in case something else stopped the AS
+ INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived"));
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN8101::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Register for notification, but make no request to play audio"));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+//
+//CTestMmfAclntARN8102
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN8102::CTestMmfAclntARN8102(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN8102* CTestMmfAclntARN8102::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN8102* self = new (ELeave) CTestMmfAclntARN8102(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN8102::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN8102::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateOpenPlayer2, EMapcInitComplete1);
+ break;
+ case EStateOpenPlayer2:
+ // Register iTestAudioPlayer#1 for Notification
+ retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Open iTestAudioPlayer#2
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying2, EMapcInitComplete2);
+ break;
+ case EStatePlaying2:
+ // Play iTestAudioPlayer#2
+ iTestAudioPlayer2->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateErrInUsePlayer1, EMapcPlayComplete1, KErrInUse);
+ break;
+ case EStateErrInUsePlayer1:
+ // Close iTestAudioPlayer#2
+ WaitWithTimeout(iRequestStatus,1000000);
+ iTestAudioPlayer2->Stop();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Stop()"));
+ iTestAudioPlayer2->Close();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Close()"));
+ // Timer to check if Notification Event Occurs.
+ iCallBackTimer->After(2000000);
+ // Set ExpectedEvent and change the State
+ StateChange(EStateNotifiedPlayer1, EMarncResourceAvailable1);
+ break;
+ case EStateNotifiedPlayer1:
+ iCallBackTimer->Cancel(); // in case something else stopped the AS
+ INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived"));
+ iTestStepResult = EPass;
+ CActiveScheduler::Stop();
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN8102::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Register (b4 play, after Open) and Receive Notification of a Resource Available Event."));
+ INFO_PRINTF1(_L("(when audio resource is currently unavailable and then available)"));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+//
+//CTestMmfAclntARN8103
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN8103::CTestMmfAclntARN8103(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN8103* CTestMmfAclntARN8103::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN8103* self = new (ELeave) CTestMmfAclntARN8103(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN8103::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmCheck
+ */
+TBool CTestMmfAclntARN8103::FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ TBool retFsmCheck = EFalse;
+ if (((aEventCode == EMapcPlayComplete1) || (aEventCode == EMapcPlayComplete2)) && (aError == KErrUnderflow))
+ {
+ INFO_PRINTF1(_L("Underflow !"));
+ }
+ else if (iExpectedEvent != aEventCode)
+ {
+ if ((aEventCode == EMapcPlayComplete2))
+ {
+ retFsmCheck = ETrue;
+ if (iEventOccured == EMarncResourceAvailable1)
+ {
+ return retFsmCheck;
+ }
+ else
+ {
+ iEventOccured = EMapcPlayComplete2;
+ }
+ }
+ else if (aEventCode == EMarncResourceAvailable1)
+ {
+ retFsmCheck = ETrue;
+ if (iEventOccured == EMapcPlayComplete2)
+ {
+ return retFsmCheck;
+ }
+ else
+ {
+ iEventOccured = EMarncResourceAvailable1;
+ }
+ }
+ else
+ {
+ ERR_PRINTF3(_L("ExpectedEvent : %d, ActualEvent : %d"), iExpectedEvent, aEventCode);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ }
+ else if (iExpectedError != aError)
+ {
+ ERR_PRINTF3(_L("ExpectedError : %d, ActualError : %d"), iExpectedError, aError);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ else
+ {
+ retFsmCheck = ETrue;
+ }
+ return retFsmCheck;
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN8103::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying1, EMapcInitComplete1);
+ break;
+ case EStatePlaying1:
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Register iTestAudioPlayer#1 for Notification
+ retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Open iTestAudioPlayer#2
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying2, EMapcInitComplete2);
+ break;
+ case EStatePlaying2:
+ // Play iTestAudioPlayer#2
+ iTestAudioPlayer2->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateErrInUsePlayer1, EMapcPlayComplete1, KErrInUse);
+ break;
+ case EStateErrInUsePlayer1:
+ // Set ExpectedEvent and change the State
+ StateChange(EStateEndPlay2, EMapcPlayComplete2);
+ break;
+ case EStateEndPlay2:
+ // Timer to check if Notification Event Occurs.
+ iCallBackTimer->After(2000000);
+ // Set ExpectedEvent and change the State
+ StateChange(EStateNotifiedPlayer1, EMarncResourceAvailable1);
+ break;
+ case EStateNotifiedPlayer1:
+ iCallBackTimer->Cancel(); // in case something else stopped the AS
+ INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived"));
+ iTestStepResult = EPass;
+ CActiveScheduler::Stop();
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN8103::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Register (at the time of Play) and Receive Notification of a Resource Available Event."));
+ INFO_PRINTF1(_L("(when audio resource is currently available and subsequently unavailable, and then available)"));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+//
+//CTestMmfAclntARN8104
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN8104::CTestMmfAclntARN8104(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN8104* CTestMmfAclntARN8104::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN8104* self = new (ELeave) CTestMmfAclntARN8104(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN8104::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN8104::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TInt canErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying1, EMapcInitComplete1);
+ break;
+ case EStatePlaying1:
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Open iTestAudioPlayer#2
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying2, EMapcInitComplete2);
+ break;
+ case EStatePlaying2:
+ // Play iTestAudioPlayer#2
+ iTestAudioPlayer2->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateErrInUsePlayer1, EMapcPlayComplete1, KErrInUse);
+ break;
+ case EStateErrInUsePlayer1:
+ // Cancel notification for iTestAudioPlayer#1
+ canErr = iTestAudioPlayer1->CancelRegisterAudioResourceNotification(KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->CancelRegisterAudioResourceNotification()"));
+ if( canErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->CancelRegisterAudioResourceNotification - Failed with Error : %d"), canErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Close iTestAudioPlayer#2
+ WaitWithTimeout(iRequestStatus,1000000);
+ iTestAudioPlayer2->Stop();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Stop()"));
+ iTestAudioPlayer2->Close();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Close()"));
+ // Timer to check if Notification Event Occurs.
+ iCallBackTimer->After(2000000);
+ iTestStepResult = EPass;
+ // Set ExpectedEvent and change the State
+ StateChange(EStateNotifiedPlayer1, EMarncResourceAvailable1);
+ break;
+ case EStateNotifiedPlayer1:
+ iCallBackTimer->Cancel(); // in case something else stopped the AS
+ INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived"));
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN8104::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Registration (b4 File Open) and Cancellation of the notification request"));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Register iTestAudioPlayer#1 for Notification
+ TInt retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ return EFail;
+ }
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+//
+//CTestMmfAclntARN8105
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN8105::CTestMmfAclntARN8105(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN8105* CTestMmfAclntARN8105::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN8105* self = new (ELeave) CTestMmfAclntARN8105(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN8105::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmCheck
+ */
+TBool CTestMmfAclntARN8105::FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ TBool retFsmCheck = EFalse;
+ if (((aEventCode == EMapcPlayComplete1) || (aEventCode == EMapcPlayComplete2)) && (aError == KErrUnderflow))
+ {
+ INFO_PRINTF1(_L("Underflow !"));
+ }
+ else if (iExpectedEvent != aEventCode)
+ {
+ if ((aEventCode == EMapcPlayComplete2))
+ {
+ retFsmCheck = ETrue;
+ if (iEventOccured == EMarncResourceAvailable1)
+ {
+ return retFsmCheck;
+ }
+ else
+ {
+ iEventOccured = EMapcPlayComplete2;
+ }
+ }
+ else if (aEventCode == EMarncResourceAvailable1)
+ {
+ retFsmCheck = ETrue;
+ if (iEventOccured == EMapcPlayComplete2)
+ {
+ return retFsmCheck;
+ }
+ else
+ {
+ iEventOccured = EMarncResourceAvailable1;
+ }
+ }
+ else
+ {
+ ERR_PRINTF3(_L("ExpectedEvent : %d, ActualEvent : %d"), iExpectedEvent, aEventCode);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ }
+ else if (iExpectedError != aError)
+ {
+ ERR_PRINTF3(_L("ExpectedError : %d, ActualError : %d"), iExpectedError, aError);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ else
+ {
+ retFsmCheck = ETrue;
+ }
+ return retFsmCheck;
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN8105::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying1, EMapcInitComplete1);
+ break;
+ case EStatePlaying1:
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Open iTestAudioPlayer#2
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying2, EMapcInitComplete2);
+ break;
+ case EStatePlaying2:
+ // Play iTestAudioPlayer#2
+ iTestAudioPlayer2->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateErrInUsePlayer1, EMapcPlayComplete1, KErrInUse);
+ break;
+ case EStateErrInUsePlayer1:
+ //Get Position of iTestAudioPlayer#1
+ retErr = iTestAudioPlayer1->GetPosition(iPositionStop);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->GetPosition()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->GetPosition - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ INFO_PRINTF2(_L("value of iPositionStop = %d"),iPositionStop.Int64());//Statement Changed under DEF105143
+
+ // Register iTestAudioPlayer#1 for Notification
+ retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Set ExpectedEvent and change the State
+ StateChange(EStateEndPlay2, EMapcPlayComplete2);
+ break;
+ case EStateEndPlay2:
+ // Timer to check if Notification Event Occurs.
+ iCallBackTimer->After(2000000);
+ // Set ExpectedEvent and change the State
+ StateChange(EStateNotifiedPlayer1, EMarncResourceAvailable1);
+ break;
+ case EStateNotifiedPlayer1:
+ iCallBackTimer->Cancel(); // in case something else stopped the AS
+ INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived"));
+ iPositionResume = iPosition;
+ CActiveScheduler::Stop();
+ // Check for the Position.
+ if (iPositionResume >= iPositionStop)
+ {
+ INFO_PRINTF3(_L("iTestAudioPlayer1->Audio Resource iPositionResume >= iPositionStop, Expected=%Ld, Actual=%Ld"), iPositionStop.Int64(), iPositionResume.Int64());
+ iTestStepResult=EPass;
+ }
+ else
+ {
+ ERR_PRINTF3(_L("iTestAudioPlayer1->Audio Resource Position is NOT iPositionResume >= iPositionStop, Expected=%Ld, Actual=%Ld"), iPositionStop.Int64(), iPositionResume.Int64());
+ iTestStepResult=EFail;
+ }
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN8105::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Register (after Play Error) and Get the actual position from where the paused audio can be resumed. Low priority client is played first."));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+//
+//CTestMmfAclntARN8106
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN8106::CTestMmfAclntARN8106(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN8106* CTestMmfAclntARN8106::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN8106* self = new (ELeave) CTestMmfAclntARN8106(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN8106::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmCheck
+ */
+TBool CTestMmfAclntARN8106::FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ TBool retFsmCheck = EFalse;
+ if (((aEventCode == EMapcPlayComplete1) || (aEventCode == EMapcPlayComplete2)) && (aError == KErrUnderflow))
+ {
+ INFO_PRINTF1(_L("Underflow !"));
+ }
+ else if (iExpectedEvent != aEventCode)
+ {
+ if ((aEventCode == EMapcPlayComplete2))
+ {
+ retFsmCheck = ETrue;
+ if (iEventOccured == EMarncResourceAvailable1)
+ {
+ return retFsmCheck;
+ }
+ else
+ {
+ iEventOccured = EMapcPlayComplete2;
+ }
+ }
+ else if (aEventCode == EMarncResourceAvailable1)
+ {
+ retFsmCheck = ETrue;
+ if (iEventOccured == EMapcPlayComplete2)
+ {
+ return retFsmCheck;
+ }
+ else
+ {
+ iEventOccured = EMarncResourceAvailable1;
+ }
+ }
+ else
+ {
+ ERR_PRINTF3(_L("ExpectedEvent : %d, ActualEvent : %d"), iExpectedEvent, aEventCode);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ }
+ else if (iExpectedError != aError)
+ {
+ ERR_PRINTF3(_L("ExpectedError : %d, ActualError : %d"), iExpectedError, aError);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ else
+ {
+ retFsmCheck = ETrue;
+ }
+ return retFsmCheck;
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN8106::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#2
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying2, EMapcInitComplete2);
+ break;
+ case EStatePlaying2:
+ // Play iTestAudioPlayer#2
+ iTestAudioPlayer2->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying1, EMapcInitComplete1);
+ break;
+ case EStatePlaying1:
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateErrInUsePlayer1, EMapcPlayComplete1, KErrInUse);
+ break;
+ case EStateErrInUsePlayer1:
+ //Get Position of iTestAudioPlayer#1
+ retErr = iTestAudioPlayer1->GetPosition(iPositionStop);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->GetPosition()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->GetPosition - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Register iTestAudioPlayer#1 for Notification
+ retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Set ExpectedEvent and change the State
+ StateChange(EStateEndPlay2, EMapcPlayComplete2);
+ break;
+ case EStateEndPlay2:
+ // Timer to check if Notification Event Occurs.
+ iCallBackTimer->After(2000000);
+ // Set ExpectedEvent and change the State
+ StateChange(EStateNotifiedPlayer1, EMarncResourceAvailable1);
+ break;
+ case EStateNotifiedPlayer1:
+ iCallBackTimer->Cancel(); // in case something else stopped the AS
+ INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived"));
+ iPositionResume = iPosition;
+ CActiveScheduler::Stop();
+ // Check for the Position
+ if (iPositionResume >= iPositionStop)
+ {
+ INFO_PRINTF3(_L("iTestAudioPlayer1->Audio Resource Position Matches, Expected=%Ld, Actual=%Ld"), iPositionStop.Int64(), iPositionResume.Int64());
+ iTestStepResult=EPass;
+ }
+ else
+ {
+ ERR_PRINTF3(_L("iTestAudioPlayer1->Audio Resource Position does NOT Match, Expected=%Ld, Actual=%Ld"), iPositionStop.Int64(), iPositionResume.Int64());
+ iTestStepResult=EFail;
+ }
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN8106::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Register (after Play Error) and Get the actual position from where the paused audio can be resumed. High priority client is played first."));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+//
+//CTestMmfAclntARN8107
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN8107::CTestMmfAclntARN8107(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN8107* CTestMmfAclntARN8107::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN8107* self = new (ELeave) CTestMmfAclntARN8107(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN8107::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmCheck
+ */
+TBool CTestMmfAclntARN8107::FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ TBool retFsmCheck = EFalse;
+ if (((aEventCode == EMapcPlayComplete1) || (aEventCode == EMapcPlayComplete2)) && (aError == KErrUnderflow))
+ {
+ INFO_PRINTF1(_L("Underflow !"));
+ }
+ else if (iExpectedEvent != aEventCode)
+ {
+ if ((aEventCode == EMapcPlayComplete2))
+ {
+ retFsmCheck = ETrue;
+ if (iEventOccured == EMarncResourceAvailable1)
+ {
+ return retFsmCheck;
+ }
+ else
+ {
+ iEventOccured = EMapcPlayComplete2;
+ }
+ }
+ else if (aEventCode == EMarncResourceAvailable1)
+ {
+ retFsmCheck = ETrue;
+ if (iEventOccured == EMapcPlayComplete2)
+ {
+ return retFsmCheck;
+ }
+ else
+ {
+ iEventOccured = EMarncResourceAvailable1;
+ }
+ }
+ else
+ {
+ ERR_PRINTF3(_L("ExpectedEvent : %d, ActualEvent : %d"), iExpectedEvent, aEventCode);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ }
+ else if (iExpectedError != aError)
+ {
+ ERR_PRINTF3(_L("ExpectedError : %d, ActualError : %d"), iExpectedError, aError);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ else
+ {
+ retFsmCheck = ETrue;
+ }
+ return retFsmCheck;
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN8107::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying1, EMapcInitComplete1);
+ break;
+ case EStatePlaying1:
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Register iTestAudioPlayer#1 for Notification
+ retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Open iTestAudioPlayer#2
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying2, EMapcInitComplete2);
+ break;
+ case EStatePlaying2:
+ // Play iTestAudioPlayer#2
+ iTestAudioPlayer2->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateErrInUsePlayer1, EMapcPlayComplete1, KErrInUse);
+ break;
+ case EStateErrInUsePlayer1:
+ // Set ExpectedEvent and change the State
+ StateChange(EStateEndPlay2, EMapcPlayComplete2);
+ break;
+ case EStateEndPlay2:
+ // Timer to check if Notification Event Occurs.
+ iCallBackTimer->After(2000000);
+ // Set ExpectedEvent and change the State
+ StateChange(EStateNotifiedPlayer1, EMarncResourceAvailable1);
+ break;
+ case EStateNotifiedPlayer1:
+ iCallBackTimer->Cancel(); // in case something else stopped the AS
+ INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived => 1"));
+ retErr = iTestAudioPlayer1->WillResumePlay();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->WillResumePlay()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->WillResumePlay() - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ iTestAudioPlayer1->SetPosition(iPosition);
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Open iTestAudioPlayer#2
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying2A, EMapcInitComplete2);
+ break;
+ case EStatePlaying2A:
+ // Play iTestAudioPlayer#2
+ iTestAudioPlayer2->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateErrInUsePlayer1A, EMapcPlayComplete1, KErrInUse);
+ break;
+ case EStateErrInUsePlayer1A:
+ // Set ExpectedEvent and change the State
+ StateChange(EStateEndPlay2A, EMapcPlayComplete2);
+ break;
+ case EStateEndPlay2A:
+ // Timer to check if Notification Event Occurs.
+ iCallBackTimer->After(2000000);
+ // Set ExpectedEvent and change the State
+ StateChange(EStateNotifiedPlayer1A, EMarncResourceAvailable1);
+ break;
+ case EStateNotifiedPlayer1A:
+ iCallBackTimer->Cancel(); // in case something else stopped the AS
+ INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived => 2"));
+ iTestStepResult = EPass;
+ CActiveScheduler::Stop();
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN8107::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Client does not need to Re-register for the same event when the event is received i.e API is not one shot."));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+//
+//CTestMmfAclntARN8108
+//
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN8108* CTestMmfAclntARN8108::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN8108* self = new (ELeave) CTestMmfAclntARN8108(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN8108::CTestMmfAclntARN8108(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN8108::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+void CTestMmfAclntARN8108::DecideFsmState(TInt aClientNumber,CMultiEventChecker::TClientUtilityType aClientType, TInt aEventCode, TInt aError)
+ {
+ if (iEventChecker->CheckFsm(aClientNumber, aClientType, aEventCode, aError))
+ {
+ iTestStepResult = (this->*(iStateHandlers[iEventChecker->NextState()]))();
+ if(iTestStepResult != EPass)
+ {
+ iEventChecker->StopTest();
+ }
+ }
+ }
+
+void CTestMmfAclntARN8108::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (aEventCode == EMapcInitComplete1 || aEventCode == EMapcPlayComplete1 || aEventCode == EMarncResourceAvailable1)
+ { //Client 1
+ DecideFsmState(1,CMultiEventChecker::EAudioPlayer,aEventCode,aError);
+ }
+ if (aEventCode == EMapcInitComplete2 || aEventCode == EMapcPlayComplete2 || aEventCode == EMarncResourceAvailable2)
+ { //Client 2
+ DecideFsmState(2,CMultiEventChecker::EAudioPlayer,aEventCode,aError);
+ }
+ if (aEventCode == EMapcInitComplete3 || aEventCode == EMapcPlayComplete3 || aEventCode == EMarncResourceAvailable3)
+ { //Client 3
+ DecideFsmState(3,CMultiEventChecker::EAudioPlayer,aEventCode,aError);
+ }
+ }
+
+
+void CTestMmfAclntARN8108::InitTest()
+ {
+ iStateHandlers[EStateOpenPlayer1]=&CTestMmfAclntARN8108::HandleStateOpenPlayer1;
+ iStateHandlers[EStateOpenPlayer3]=&CTestMmfAclntARN8108::HandleStateOpenPlayer3;
+ iStateHandlers[EStateOpenPlayer2]=&CTestMmfAclntARN8108::HandleStateOpenPlayer2;
+ iStateHandlers[EStateErrInUsePlayer1]=&CTestMmfAclntARN8108::HandleStateErrInUsePlayer1;
+ iStateHandlers[EStateErrInUsePlayer3]=&CTestMmfAclntARN8108::HandleStateErrInUsePlayer3;
+ iStateHandlers[EStateNotifiedPlayer1]=&CTestMmfAclntARN8108::HandleStateNotifiedPlayer1;
+ iStateHandlers[EStateNotifiedPlayer3]=&CTestMmfAclntARN8108::HandleStateNotifiedPlayer3;
+ iStateHandlers[EStatePlaying1]=&CTestMmfAclntARN8108::HandleStatePlaying1;
+ }
+
+void CTestMmfAclntARN8108::StartTestL()
+ {
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ iEventChecker->SetExpectedEvent(1,EMapcInitComplete1,KErrNone);
+ iEventChecker->SetExpectedState(EStateOpenPlayer1);
+ }
+
+TVerdict CTestMmfAclntARN8108::HandleStateOpenPlayer1()
+ {
+ TInt retErr;
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Register iTestAudioPlayer#1 for Notification
+ retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ return EFail;
+ }
+ // Register iTestAudioPlayer#3 for Notification
+ retErr = iTestAudioPlayer3->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport3, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer3->RegisterAudioResourceNotification()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer3->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ return EFail;
+ }
+ // Open iTestAudioPlayer#3
+ iTestAudioPlayer3->OpenFileL(iFilename3);
+ INFO_PRINTF1(_L("iTestAudioPlayer3->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ iEventChecker->SetExpectedEvent(3,EMapcInitComplete3,KErrNone);
+ iEventChecker->SetExpectedState(EStateOpenPlayer3);
+ return EPass;
+ }
+
+TVerdict CTestMmfAclntARN8108::HandleStateOpenPlayer3()
+ {
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ iEventChecker->SetExpectedEvent(2,EMapcInitComplete2,KErrNone);
+ iEventChecker->SetExpectedState(EStateOpenPlayer2);
+ return EPass;
+ }
+
+TVerdict CTestMmfAclntARN8108::HandleStateOpenPlayer2()
+ {
+ // Play iTestAudioPlayer#2
+ iTestAudioPlayer2->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Set ExpectedEvent and change the State
+ iEventChecker->SetExpectedEvent(1,EMapcPlayComplete1,KErrInUse);
+ iEventChecker->SetExpectedState(EStateErrInUsePlayer1);
+ return EPass;
+ }
+TVerdict CTestMmfAclntARN8108::HandleStateErrInUsePlayer1()
+ {
+ // Play iTestAudioPlayer#3
+ iTestAudioPlayer3->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer3->Play()"));
+ // Set ExpectedEvent and change the State
+ iEventChecker->SetExpectedEvent(3,EMapcPlayComplete3,KErrInUse);
+ iEventChecker->SetExpectedState(EStateErrInUsePlayer3);
+ return EPass;
+ }
+
+TVerdict CTestMmfAclntARN8108::HandleStateErrInUsePlayer3()
+ {
+ // Close iTestAudioPlayer#2
+ WaitWithTimeout(iRequestStatus,1000000);
+ iTestAudioPlayer2->Stop();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Stop()"));
+ iTestAudioPlayer2->Close();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Close()"));
+ // Timer to check if Notification Event Occurs.
+ iCallBackTimer->After(2000000);
+ // Set ExpectedEvent and change the State
+ iEventChecker->SetExpectedEvent(1,EMarncResourceAvailable1,KErrNone);
+ iEventChecker->SetExpectedState(EStateNotifiedPlayer1);
+ return EPass;
+ }
+
+TVerdict CTestMmfAclntARN8108::HandleStateNotifiedPlayer1()
+ {
+ iCallBackTimer->Cancel(); // in case something else stopped the AS
+ INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived"));
+ TInt retErr = iTestAudioPlayer1->WillResumePlay();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->WillResumePlay()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->WillResumePlay() - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ return EFail;
+ }
+ iTestAudioPlayer1->SetPosition(iPosition);
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Set ExpectedEvent and change the State
+ iEventChecker->RegisterClientEventToMonitor(1,EMapcPlayComplete1,KErrNone,EStateNotifiedPlayer3);
+ iEventChecker->RegisterClientEventToMonitor(3,EMarncResourceAvailable3,KErrNone,EStatePlaying1);
+ iEventChecker->EnableMultipleEventMonitor();
+ return EPass;
+ }
+
+TVerdict CTestMmfAclntARN8108::HandleStateNotifiedPlayer3()
+ {
+ INFO_PRINTF1(_L("iTestAudioPlayer3->NotificationReceived"));
+ if(iEventChecker->IsMonitoringFinished())
+ {
+ iTestStepResult = EPass;
+ iCallBackTimer->Cancel();
+ iEventChecker->StopTest();
+ }
+ else
+ {
+ iEventChecker->EnableMultipleEventMonitor();
+ }
+ return EPass;
+ }
+
+TVerdict CTestMmfAclntARN8108::HandleStatePlaying1()
+ {
+ INFO_PRINTF1(_L("iTestAudioPlayer1->AudioPlayerComplete"));
+ iCallBackTimer->After(2000000);
+ if(iEventChecker->IsMonitoringFinished())
+ {
+ iTestStepResult = EPass;
+ iCallBackTimer->Cancel();
+ iEventChecker->StopTest();
+ }
+ else
+ {
+ iEventChecker->EnableMultipleEventMonitor();
+ }
+ return EPass;
+ }
+
+TVerdict CTestMmfAclntARN8108::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Call WillResumePlay()."));
+ iTestStepResult = EFail;
+
+ // Initialise the handler functions
+ InitTest();
+
+ // Initiate the process
+ StartTestL();
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+
+//
+//CTestMmfAclntARN8109
+//
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN8109* CTestMmfAclntARN8109::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN8109* self = new (ELeave) CTestMmfAclntARN8109(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN8109::CTestMmfAclntARN8109(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName), iPlayComplete2(EFalse), iResourceAvailable1(EFalse)
+ {}
+
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN8109::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+/**
+ * MapcPlayCompleteTest
+ */
+void CTestMmfAclntARN8109::MapcPlayCompleteTest(TInt aError, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport)
+ {
+ if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport1)
+ {
+ INFO_PRINTF2(_L("iAudioPlayer1 -> MMdaAudioPlayerCallback PlayComplete (%d)"), aError);
+ TRAP(iError, FsmL(EMapcPlayComplete1, aError));
+ }
+ else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport2)
+ {
+ INFO_PRINTF2(_L("iAudioPlayer2 -> MMdaAudioPlayerCallback PlayComplete (%d)"), aError);
+ iPlayComplete2= ETrue;
+ TRAP(iError, FsmL(EMapcPlayComplete2, aError));
+ }
+ else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport3)
+ {
+ INFO_PRINTF2(_L("iAudioPlayer3 -> MMdaAudioPlayerCallback PlayComplete (%d)"), aError);
+ TRAP(iError, FsmL(EMapcPlayComplete3, aError));
+ }
+ }
+
+
+/**
+ * MarncResourceAvailableTest
+ */
+void CTestMmfAclntARN8109::MarncResourceAvailableTest(TUid aNotificationEventId, const TDesC8& aNotificationData, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport)
+ {
+ if (aNotificationEventId == KMMFEventCategoryAudioResourceAvailable)
+ {
+ INFO_PRINTF1(_L("iAudioPlayer::MMMFAudioResourceNotificationCallback -> KMMFEventCategoryAudioResourceAvailable"));
+
+ //Convert TDesc8 to TInt64
+ TMMFTimeIntervalMicroSecondsPckg timeIntvbuf;
+ timeIntvbuf.Copy(aNotificationData);
+ TTimeIntervalMicroSeconds intPos = timeIntvbuf();
+ iPosition = intPos;
+ if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport1)
+ {
+ INFO_PRINTF1(_L("iAudioPlayer1 -> MMMFAudioResourceNotificationCallback : AudioResourceAvailable..waiting for playcomplete"));
+ iResourceAvailable1 = ETrue;
+ TRAP(iError, FsmL(EMarncResourceAvailable1, KErrNone));
+ }
+ else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport2)
+ {
+ INFO_PRINTF1(_L("iAudioPlayer2 -> MMMFAudioResourceNotificationCallback : AudioResourceAvailable"));
+ TRAP(iError, FsmL(EMarncResourceAvailable2, KErrNone));
+ }
+ else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport3)
+ {
+ INFO_PRINTF1(_L("iAudioPlayer3 -> MMMFAudioResourceNotificationCallback : AudioResourceAvailable"));
+ TRAP(iError, FsmL(EMarncResourceAvailable3, KErrNone));
+ }
+ }
+ else
+ {
+ INFO_PRINTF1(_L("MMMFAudioResourceNotificationCallback, but NOT KMMFEventCategoryAudioResourceAvailable"));
+ }
+ }
+
+/**
+ * FsmCheck
+ */
+TBool CTestMmfAclntARN8109::FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ TBool retFsmCheck = EFalse;
+ if (((aEventCode == EMapcPlayComplete1) || (aEventCode == EMapcPlayComplete2)) && (aError == KErrUnderflow))
+ {
+ INFO_PRINTF1(_L("Underflow !"));
+ }
+ else if (iExpectedEvent != aEventCode)
+ {
+ if(aEventCode == EMarncResourceAvailable1)
+ {
+ retFsmCheck = EFalse;
+ }
+ else
+ {
+ ERR_PRINTF3(_L("ExpectedEvent : %d, ActualEvent : %d"), iExpectedEvent, aEventCode);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ }
+ else if (iExpectedError != aError)
+ {
+ ERR_PRINTF3(_L("ExpectedError : %d, ActualError : %d"), iExpectedError, aError);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ else
+ {
+ retFsmCheck = ETrue;
+ }
+ return retFsmCheck;
+ }
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN8109::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TTimeIntervalMicroSeconds silence(0); // 3 sec of silence
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+
+ case EStateBegin:
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying1, EMapcInitComplete1);
+ break;
+ case EStatePlaying1:
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Register iTestAudioPlayer#1 for Notification
+ retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Open iTestAudioPlayer#2
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying2, EMapcInitComplete2);
+ break;
+ case EStatePlaying2:
+ // Play iTestAudioPlayer#2
+ iDuration = I64INT(iTestAudioPlayer2->Duration().Int64());
+ INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility"));
+ INFO_PRINTF2( _L("Repeats = %d\n"),NUMBER_OF_REPEATS);
+ iTestAudioPlayer2->SetRepeats(NUMBER_OF_REPEATS,silence);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+
+ iTestAudioPlayer2->Play();
+ iStart.HomeTime();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateErrInUsePlayer1, EMapcPlayComplete1, KErrInUse);
+ break;
+ case EStateErrInUsePlayer1:
+ // Set ExpectedEvent and change the State
+ StateChange(EStateEndPlay2, EMapcPlayComplete2);
+ break;
+ case EStateEndPlay2:
+ iStop.HomeTime();
+ iActualDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64());
+ INFO_PRINTF2( _L("Clip Duration = %d "),iDuration);
+ INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration);
+ INFO_PRINTF2( _L("Expected Duration = %d "),iDuration *(NUMBER_OF_REPEATS));
+ if(iPlayComplete2 && iResourceAvailable1)
+ {
+ #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
+ if(TimeComparison(iActualDuration, iDuration * (NUMBER_OF_REPEATS + 1),
+ KExpectedDeviation))
+ {
+ iCallBackTimer->Cancel(); // in case something else stopped the AS
+ INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived"));
+ iTestStepResult = EPass;
+ CActiveScheduler::Stop();
+ }
+ else
+ {
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ #else
+ if(TimeComparison(iActualDuration, iDuration * (NUMBER_OF_REPEATS + 1),
+ KExpectedDeviation*NUMBER_OF_REPEATS))
+ {
+ iCallBackTimer->Cancel(); // in case something else stopped the AS
+ INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived"));
+ iTestStepResult = EPass;
+ CActiveScheduler::Stop();
+ // Timer to check if Notification Event Occurs.
+ }
+ else
+ {
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ #endif
+ }
+ else if(iPlayComplete2 && ! iResourceAvailable1)
+ {
+ #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
+ if(TimeComparison(iActualDuration, iDuration * (NUMBER_OF_REPEATS + 1),
+ KExpectedDeviation))
+ {
+ // Timer to check if Notification Event Occurs.
+ iCallBackTimer->After(2000000);
+ // Set ExpectedEvent and change the State
+ StateChange(EStateNotifiedPlayer1, EMarncResourceAvailable1);
+ }
+ else
+ {
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ #else
+ if(TimeComparison(iActualDuration, iDuration * (NUMBER_OF_REPEATS + 1),
+ KExpectedDeviation*NUMBER_OF_REPEATS))
+ {
+ // Timer to check if Notification Event Occurs.
+ iCallBackTimer->After(2000000);
+ // Set ExpectedEvent and change the State
+ StateChange(EStateNotifiedPlayer1, EMarncResourceAvailable1);
+ // Timer to check if Notification Event Occurs.
+ }
+ else
+ {
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ #endif
+ }
+ break;
+ case EStateNotifiedPlayer1:
+ iCallBackTimer->Cancel(); // in case something else stopped the AS
+ INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived"));
+ iTestStepResult = EPass;
+ CActiveScheduler::Stop();
+ break;
+ }
+ }
+ }
+TBool CTestMmfAclntARN8109::TimeComparison(const TUint aActual, const TUint aExpected, const TUint aDeviation)
+ {
+ // save unnessary conditions
+ if(aActual == aExpected)
+ return ETrue;
+
+ // Prevent unsigned wrapping errors
+ TUint difference;
+ if(aActual > aExpected)
+ difference = aActual - aExpected;
+ else
+ difference = aExpected - aActual;
+
+ // comapare
+ if(difference < aDeviation)
+ return ETrue;
+ return EFalse;
+ }
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN8109::PerformTestL()
+ {
+ INFO_PRINTF1(_L("High priority client plays with repeats and low priority client doesn't get resources."));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+
+//
+//CTestMmfAclntARN8110 //test to cover CR id:
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN8110::CTestMmfAclntARN8110(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN8110* CTestMmfAclntARN8110::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN8110* self = new (ELeave) CTestMmfAclntARN8110(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN8110::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN8110::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TTimeIntervalMicroSeconds32 wait2secs(2000000);
+ TTimeIntervalMicroSeconds oneNhalf(MAKE_TINT64(0,1500000));
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#1 // next event to play iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying1, EMapcInitComplete1);
+ break;
+ case EStatePlaying1:
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Open iTestAudioPlayer#2
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying2, EMapcInitComplete2);
+ break;
+ case EStatePlaying2:
+ // Play iTestAudioPlayer#2
+ User::After(wait2secs);
+ iTestAudioPlayer2->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateErrInUsePlayer1, EMapcPlayComplete1, KErrInUse);
+ break;
+ case EStateErrInUsePlayer1:
+ retErr = iTestAudioPlayer1->GetPosition(iPlayer1Pos);
+ if(retErr != KErrNone)
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->Position() - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Position()"));
+ //using 1.5 sec for comparison as sometimes playback is slow.
+ if(iPlayer1Pos < oneNhalf)
+ {
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Set ExpectedEvent and change the State
+ StateChange(EStateEndPlay2, EMapcPlayComplete2 );
+ break;
+ case EStateEndPlay2:
+ iTestStepResult = EPass;
+ // Play iTestAudioPlayer#1 again
+ TTimeIntervalMicroSeconds pos;
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Position()"));
+ retErr = iTestAudioPlayer1->GetPosition(pos);
+ if(retErr != KErrNone)
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->Position() - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ if(pos == 0 || pos != iPlayer1Pos )
+ {
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ retErr = iTestAudioPlayer1->GetPosition(pos);
+ if(retErr != KErrNone)
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->Position() - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Position()"));
+ if(pos < iPlayer1Pos)
+ {
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ iTestAudioPlayer1->Stop();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Stop()"));
+ iTestStepResult = EPass;
+ CActiveScheduler::Stop();
+ // Set ExpectedEvent and change the State
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN8110::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Register for notification, but make no request to play audio"));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+
+//
+//CTestMmfAclntARN8111 //test to cover CR id:
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN8111::CTestMmfAclntARN8111(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN8111* CTestMmfAclntARN8111::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN8111* self = new (ELeave) CTestMmfAclntARN8111(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN8111::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN8111::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TTimeIntervalMicroSeconds32 wait2secs(2000000);
+ TTimeIntervalMicroSeconds oneNhalf(MAKE_TINT64(0,1500000));
+ TTimeIntervalMicroSeconds zeroSecs(MAKE_TINT64(0,0));
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#1 // next event to play iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying1, EMapcInitComplete1);
+ break;
+ case EStatePlaying1:
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Open iTestAudioPlayer#2
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying2, EMapcInitComplete2);
+ break;
+ case EStatePlaying2:
+ // Play iTestAudioPlayer#2
+ User::After(wait2secs);
+ iTestAudioPlayer2->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateErrInUsePlayer1, EMapcPlayComplete1, KErrInUse);
+ break;
+ case EStateErrInUsePlayer1:
+ retErr = iTestAudioPlayer1->GetPosition(iPlayer1Pos);
+ if(retErr != KErrNone)
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->Position() - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Position()"));
+ //using 1.5 sec for comparison as sometimes playback is slow.
+ if(iPlayer1Pos < oneNhalf)
+ {
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ //stop the iTestAudioPlayer#1 after pre-emption and check if the position is reset.
+ iTestAudioPlayer1->Stop();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Stop()"));
+ retErr = iTestAudioPlayer1->GetPosition(iPlayer1Pos);
+ if(retErr != KErrNone)
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->Position() - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Position()"));
+ if(iPlayer1Pos != zeroSecs)
+ {
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Set ExpectedEvent and change the State
+ StateChange(EStateEndPlay2, EMapcPlayComplete2 );
+ break;
+ case EStateEndPlay2:
+ iTestStepResult = EPass;
+ // Play iTestAudioPlayer#1 again
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ User::After(wait2secs);
+ iTestAudioPlayer1->Stop();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Stop()"));
+ CActiveScheduler::Stop();
+ // Set ExpectedEvent and change the State
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN8111::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Register for notification, but make no request to play audio"));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+//
+//CTestMmfAclntARN8112 //test to cover CR id:
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN8112::CTestMmfAclntARN8112(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN8112* CTestMmfAclntARN8112::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN8112* self = new (ELeave) CTestMmfAclntARN8112(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN8112::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN8112::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TTimeIntervalMicroSeconds32 wait1secs(1000000);
+ TTimeIntervalMicroSeconds zeroSecs(MAKE_TINT64(0,0));
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#2 // next event to play iTestAudioPlayer#2
+ iTestAudioPlayer2->OpenFileL(iFilename2);
+ INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying2, EMapcInitComplete2);
+ break;
+ case EStatePlaying2:
+ // Play iTestAudioPlayer#1
+ iTestAudioPlayer2->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStatePlaying1, EMapcInitComplete1);
+ break;
+ case EStatePlaying1:
+ // Play iTestAudioPlayer#1
+ User::After(wait1secs);
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateErrInUsePlayer1, EMapcPlayComplete1, KErrInUse);
+ break;
+ case EStateErrInUsePlayer1:
+ retErr = iTestAudioPlayer1->GetPosition(iPlayer1Pos);
+ if(retErr != KErrNone)
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->Position() - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Position()"));
+ if(iPlayer1Pos != zeroSecs)
+ {
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ //stop the iTestAudioPlayer#1 after pre-emption and check if the position is reset.
+ iTestAudioPlayer2->Stop();
+ INFO_PRINTF1(_L("iTestAudioPlayer2->Stop()"));
+ iTestAudioPlayer1->Play();
+ INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));
+
+ // Set ExpectedEvent and change the State
+ StateChange(EStateEndPlay1, EMapcPlayComplete1 );
+ break;
+ case EStateEndPlay1:
+ iTestStepResult = EPass;
+ // Play iTestAudioPlayer#1 again
+ CActiveScheduler::Stop();
+ // Set ExpectedEvent and change the State
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN8112::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Register for notification, but make no request to play audio"));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+//
+//NEGATIVE TESTS//
+//
+
+//
+//CTestMmfAclntARN1301
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN1301::CTestMmfAclntARN1301(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN1301* CTestMmfAclntARN1301::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN1301* self = new (ELeave) CTestMmfAclntARN1301(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN1301::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN1301::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateOpenPlayer1, EMapcInitComplete1);
+ break;
+ case EStateOpenPlayer1:
+ // Register iTestAudioPlayer#1 for Notification
+ retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryPlaybackComplete);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification(KMMFEventCategoryPlaybackComplete)"));
+ if( retErr == KErrNotSupported )
+ {
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Returned KErrNotSupported ") );
+ iTestStepResult = EPass;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ }
+ CActiveScheduler::Stop();
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN1301::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Register for notification with an unsupported event type."));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+//
+//CTestMmfAclntARN1302
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN1302::CTestMmfAclntARN1302(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN1302* CTestMmfAclntARN1302::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN1302* self = new (ELeave) CTestMmfAclntARN1302(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN1302::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN1302::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateOpenPlayer1, EMapcInitComplete1);
+ break;
+ case EStateOpenPlayer1:
+ // Register iTestAudioPlayer#1 for Notification
+ retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Cancel notification for iTestAudioPlayer#1
+ retErr = iTestAudioPlayer1->CancelRegisterAudioResourceNotification(KMMFEventCategoryPlaybackComplete);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->CancelRegisterAudioResourceNotification(KMMFEventCategoryPlaybackComplete)"));
+ if( retErr == KErrNotSupported )
+ {
+ ERR_PRINTF1(_L("iTestAudioPlayer1->CancelRegisterAudioResourceNotification - Returned KErrNotSupported ") );
+ iTestStepResult = EPass;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->CancelRegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ }
+ CActiveScheduler::Stop();
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN1302::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Cancel the request for notification with an unsupported event type."));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+//
+//CTestMmfAclntARN1303
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN1303::CTestMmfAclntARN1303(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN1303* CTestMmfAclntARN1303::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN1303* self = new (ELeave) CTestMmfAclntARN1303(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN1303::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN1303::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateOpenPlayer1, EMapcInitComplete1);
+ break;
+ case EStateOpenPlayer1:
+ // Cancel notification for iTestAudioPlayer#1
+ retErr = iTestAudioPlayer1->CancelRegisterAudioResourceNotification(KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->CancelRegisterAudioResourceNotification(KMMFEventCategoryAudioResourceAvailable)"));
+ if( retErr == KErrCancel )
+ {
+ ERR_PRINTF1(_L("iTestAudioPlayer1->CancelRegisterAudioResourceNotification - Returned KErrCancel ") );
+ iTestStepResult = EPass;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->CancelRegisterAudioResourceNotification - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ }
+ CActiveScheduler::Stop();
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN1303::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Cancel when no resource Notification is requested."));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }
+
+//
+//CTestMmfAclntARN1304
+//
+
+/**
+ * Constructor
+ */
+CTestMmfAclntARN1304::CTestMmfAclntARN1304(const TDesC& aTestName, const TDesC& aSectName)
+ : CTestMmfAclntAudioPlayerARN(aTestName, aSectName)
+ {}
+
+/**
+ * NewL
+ */
+CTestMmfAclntARN1304* CTestMmfAclntARN1304::NewL(const TDesC& aTestName, const TDesC& aSectName)
+ {
+ CTestMmfAclntARN1304* self = new (ELeave) CTestMmfAclntARN1304(aTestName, aSectName);
+ return self;
+ }
+
+/**
+ * DoTestL
+ */
+TVerdict CTestMmfAclntARN1304::DoTestL()
+ {
+ return( PerformTestL() );
+ }
+
+/**
+ * FsmL
+ */
+void CTestMmfAclntARN1304::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)
+ {
+ if (FsmCheck(aEventCode, aError))
+ {
+ TInt retErr = KErrNone;
+ switch (iState)
+ {
+ case EStateBegin:
+ // Open iTestAudioPlayer#1
+ iTestAudioPlayer1->OpenFileL(iFilename1);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));
+ // Set ExpectedEvent and change the State
+ StateChange(EStateOpenPlayer1, EMapcInitComplete1);
+ break;
+ case EStateOpenPlayer1:
+ // Register iTestAudioPlayer#1 for Notification
+ retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()#1"));
+ if( retErr != KErrNone )
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification #1 - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+ break;
+ }
+ // Register iTestAudioPlayer#1 for Notification (AGAIN)
+ retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()#2"));
+ if( retErr == KErrAlreadyExists )
+ {
+ INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification #2 - Returned KErrAlreadyExists ") );
+ iTestStepResult = EPass;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification #2 - Failed with Error : %d"), retErr);
+ iTestStepResult = EFail;
+ }
+ CActiveScheduler::Stop();
+ break;
+ }
+ }
+ }
+
+/**
+ * PerformTestL
+ */
+TVerdict CTestMmfAclntARN1304::PerformTestL()
+ {
+ INFO_PRINTF1(_L("Multiple Registration for notification for the same event type."));
+ iTestStepResult = EFail;
+
+ // Initialise the state variables
+ StateInit();
+
+ // Begin the process
+ FsmL(EIdlePlayer, KErrNone);
+
+ // Start the scheduler - Done only once !
+ CActiveScheduler::Start();
+
+ return iTestStepResult;
+ }