Symaptic: os/mm/mmlibs/mmfw/tsrc/mmfintegrationtest/vclntavi/inc/testvideoplayer

     1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Header file: Declaration for Various Classes used for Audio Resource Notification tests for Video Client.

    15 //

    16 //

    18 /**

    19  @file Testvideoplayer_apr.h

    20 */

    22 #ifndef TESTVIDEOPLAYER_APR_H

    23 #define TESTVIDEOPLAYER_APR_H

    26 #include "testvideoplayer.h"

    27 #include "mdaaudiosampleplayer.h"

    28 #include "u32hal.h"

    31 const TInt KSizeBuf = 256;

    32 const TInt KMaxEvents = 2;

    34 //------------------------------------------------------------------------------

    35 //********************PREQ 797 - Audio Resource Notification********************

    36 //------------------------------------------------------------------------------

    38 /**

    39  * stopActiveScheduler

    40  */

    41 static TInt stopActiveScheduler(TAny*)

    42 	{

    43 	CActiveScheduler::Stop();

    44 	return KErrNone;

    45 	}

    47 //

    48 //Declarations//

    49 //

    51 //

    52 //Custom Error Codes & CONST Declarations.

    53 //

    54 const TInt KErrUser = -1000;

    55 const TInt KErrBadResult = (KErrUser - 1);

    56 const TInt KMicroSecsInOneSec = 1000000;

    57 const TUint KSampleRate8000Hz  = 8000;

    59 //

    60 //Forward class declarations

    61 //

    62 class CCallbackTimer;

    63 class CTestAVPlayerAPRCallbackSupport;

    64 class CVclntAviAprWillResumeTimer;

    65 //------------------------------------------------------------------------------

    66 //******************CR 0805 - Auto Pause Resume for video client*******************

    67 //------------------------------------------------------------------------------

    69 //

    70 //ENUM DECLARATIONS//

    71 //

    73 // Enum to describe the current state.

    74 enum TAVPlayerAPRState

    75 	{

    76 	EStateBegin = 0,

    77 	EStateOpenAudioPlayer1,

    78 	EStateOpenAudioPlayer2,

    79 	EStateAudioPlaying1,

    80 	EStateAudioPlaying2,

    81 	EStateEndAudioPlay1,

    82 	EStateEndAudioPlay1A,

    83 	EStateEndAudioPlay2,

    84 	EStateEndAudioPlay2A,

    85 	EStateErrInUseAudioPlayer1,

    86 	EStateErrInUseAudioPlayer2,

    87 	EStateNotifiedAudioPlayer1,

    88 	EStateNotifiedAudioPlayer2,

    89 	EStateErrInUseAudioPlayer1A,

    90 	EStateNotifiedAudioPlayer1A,

    91 	EStateAudioPlaying2A,

    92 	EStateAudioEndPlay2A,

    93 	EStatePrepareVideoPlayer,

    94 	EStateOpenVideoPlayer,

    95 	EStateVideoPlaying,

    96 	EStateEndVideoPlay,

    97 	EStateErrInUseVideoPlayer,

    98 	EStateNotifiedVideoPlayer,

    99 	EStateErrInUseVideoPlayer1A,

   100 	EStateNotifiedVideoPlayer1A,

   101 	EStateVideoPlaying2A,

   102 	EStateEndVideoPlay2A,

   103 	EStateNoOtherPlayerNotified

   104 	};

   106 // Enum to decide which Event has occured.

   107 enum TAVPlayerAPREvents

   108 	{

   109 	EIdlePlayer = 0,

   110 	EMvpuoOpenComplete,

   111 	EMvpuoPrepareComplete,

   112 	EMvpuoFrameReady,

   113 	EMvpuoPlayComplete,

   114 	EMvpuoEvent,

   115 	EMapcInitComplete1,

   116 	EMapcInitComplete2,

   117 	EMapcPlayComplete1,

   118 	EMapcPlayComplete2,

   119 	EMarncResourceAvailable1,

   120 	EMarncResourceAvailable2,

   121 	EMarncResourceAvailable3

   122 	};

   124 //

   125 //BASE CLASS DECLARATIONS//

   126 //

   128 /**

   129  * timer support

   130  *

   131  * @class CCallBackTimer

   132  *

   133  */

   135 class CCallBackTimer : public CTimer

   136 	{

   137 public:

   138 	static CCallBackTimer* NewL(TCallBack aCallBack, TPriority aPriority = EPriorityStandard);

   139 private:

   140 	virtual void RunL();

   141 private:

   142 	CCallBackTimer(TCallBack aCallBack, TPriority aPriority);

   143 private:

   144 	TCallBack iCallBack;

   145 	};

   148 /**

   149  * Observer class to identify and pass events to the test step class

   150  *

   151  * @class MTestAVPlayerAPRCallback

   152  *

   153  */

   154 class MTestAVPlayerAPRCallback

   155 	{

   156 public :

   157 	virtual void MvpuoOpenCompleteTest(TInt aError, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport) = 0;

   158 	virtual void MvpuoPrepareCompleteTest(TInt aError, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport)= 0;

   159 	virtual void MvpuoFrameReadyTest(CFbsBitmap &aFrame, TInt aError, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport)=0;

   160 	virtual void MvpuoPlayCompleteTest(TInt aError,CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport)=0;

   161 	virtual void MvpuoEventTest(const TMMFEvent &aEvent, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport)=0;

   162 	virtual void MapcInitCompleteTest(TInt aError, const TTimeIntervalMicroSeconds &aDuration, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport)=0;

   163 	virtual void MapcPlayCompleteTest(TInt aError, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport)=0;

   164 	virtual void MarncResourceAvailableTest(TUid aNotificationEventId, const TDesC8& aNotificationData, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport) = 0;

   165 	};

   167 /**

   168  * Support class to pass the events to the test step class using the MTestAVPlayerAPRCallback

   169  *

   170  * @class CTestAVPlayerAPRCallbackSupport

   171  *

   172  */

   173 class CTestAVPlayerAPRCallbackSupport : public CBase, public MVideoPlayerUtilityObserver, public MMMFAudioResourceNotificationCallback, public MMdaAudioPlayerCallback

   174 	{

   175 public :

   176 	static CTestAVPlayerAPRCallbackSupport* NewL(MTestAVPlayerAPRCallback& aCallback);

   177 	virtual void MvpuoOpenComplete(TInt aError);

   178 	virtual void MvpuoPrepareComplete(TInt aError);

   179 	virtual void MvpuoFrameReady(CFbsBitmap &aFrame, TInt aError);

   180 	virtual void MvpuoPlayComplete(TInt aError);

   181 	virtual void MvpuoEvent(const TMMFEvent &aEvent);

   182 	virtual void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &aDuration);

   183 	virtual void MapcPlayComplete(TInt aError);

   184 	virtual void MarncResourceAvailable(TUid aNotificationEventId, const TDesC8& aNotificationData);

   186 protected:

   187 	CTestAVPlayerAPRCallbackSupport(MTestAVPlayerAPRCallback& aCallback);

   188 	void ConstructL();

   189 private :

   190 	MTestAVPlayerAPRCallback& iCallback;

   191 	};

   194 /**

   195  * Base Class for APR functionality for most APR video player tests

   196  *

   197  * @class RTestMmfVclntVideoPlayerAPR

   198  *

   199  */

   200 class RTestMmfVclntVideoPlayerAPR : public RTestMmfVclntAviStep, public MTestAVPlayerAPRCallback

   201 	{

   202 public :

   203 	// Constructor

   204 	RTestMmfVclntVideoPlayerAPR(const TDesC& aTestName, const TDesC& aSectName);

   206 	// Virtual methods for Preamble and Postamble.

   207 	virtual TVerdict DoTestStepCreateL();

   208 	virtual TVerdict DoTestStepDeleteL();

   209 	// Virtual function to access test specific methods

   210 	virtual TVerdict DoTestStepL();

   211 	// Pure function to access test specific methods

   212 	virtual TVerdict DoTestL()=0;

   213 	// from MTestAVPlayerAPRCallback

   214 	virtual void MvpuoOpenCompleteTest(TInt aError, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport);

   215 	virtual void MvpuoPrepareCompleteTest(TInt aError, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport);

   216 	virtual void MvpuoFrameReadyTest(CFbsBitmap &aFrame, TInt aError, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport);

   217 	virtual void MvpuoPlayCompleteTest(TInt aError,CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport);

   218 	virtual void MvpuoEventTest(const TMMFEvent &aEvent, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport);

   219 	virtual void MarncResourceAvailableTest(TUid aNotificationEventId, const TDesC8& aNotificationData, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport);

   220 	virtual void MapcInitCompleteTest(TInt aError, const TTimeIntervalMicroSeconds &aDuration, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport);

   221 	virtual void MapcPlayCompleteTest(TInt aError, CTestAVPlayerAPRCallbackSupport& aMdaVideoPlayerCallbackSupport);

   223 	// Centralised State Handler

   224 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError)=0;

   225 	virtual TBool FsmCheck(TAVPlayerAPREvents aEventCode, TInt aError);

   226 	virtual TInt SetCacheSize();

   227 	virtual TInt CheckCacheError(TInt aError);

   229 protected :

   230 		// StateInit Function

   231 	void StateInit();

   232 	// StateChange Function

   233 	void StateChange(TAVPlayerAPRState aState, TAVPlayerAPREvents aExpectedEvent, TInt aExpectedError=KErrNone, TInt aEventIndex = 1);

   234 	// check if we can go to the next state

   235 	TInt AnalyseInput(TAVPlayerAPREvents aEventCode, TInt aError);

   236 protected :

   238 	// CMdaAudioPlayerUtility instances

   239 	CMdaAudioPlayerUtility* iTestAudioPlayer1;

   240 	CMdaAudioPlayerUtility* iTestAudioPlayer2;

   241 	// CVideoPlayerUtility instances

   242 	CVideoPlayerUtility* iTestVideoPlayer;

   243 	// CTestAVPlayerAPRCallbackSupport instances

   244 	CTestAVPlayerAPRCallbackSupport* iVideoPlayerCallbackSupport1;

   245 	CTestAVPlayerAPRCallbackSupport* iAudioPlayerCallbackSupport1;

   246 	CTestAVPlayerAPRCallbackSupport* iAudioPlayerCallbackSupport2;

   249 	// Other class variable declarations

   250 	TBuf<KSizeBuf> iFilename1;

   251 	TBuf<KSizeBuf> iFilename2;

   252 	TBuf<KSizeBuf> iFilename3;

   253 	TTimeIntervalMicroSeconds iPosition;

   254 	TTimeIntervalMicroSeconds iDuration;

   255 	TInt iError;

   256 	TAVPlayerAPRState iState;

   257 	TRequestStatus iRequestStatus;

   258 	CCallBackTimer* iCallBackTimer;

   259 	TAVPlayerAPREvents iExpectedEvent[KMaxEvents];

   260 	TInt iExpectedError[KMaxEvents];

   261 	TBool iCanStateChange;

   262 	TInt iExpEventCount;

   263 	TInt iActEventCount;

   264 	};

   266 //

   267 //POSITIVE TESTS//

   268 //

   270 /**

   271  * One-time registration for same event by a player.

   272  *

   273  * RTestVclntAprRegOnce4SameEvent

   274  * MM-MMF-VCLNTAVIAPR-I-0001-HP

   275  *

   276  */

   277 class RTestVclntAprRegOnce4SameEvent : public RTestMmfVclntVideoPlayerAPR

   278 	{

   279 public:

   280 	static RTestVclntAprRegOnce4SameEvent* NewL( const TDesC& aTestName, const TDesC& aSectName );

   281 	virtual TVerdict DoTestL();

   282 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError);

   284 protected:

   285 	RTestVclntAprRegOnce4SameEvent( const TDesC& aTestName, const TDesC& aSectName );

   286 	TVerdict PerformTestL();

   287 	};

   289 /**

   290  * Register before opening Video player and receive notification of a resource available event

   291  *

   292  * RTestVclntAprRegB4Open

   293  * MM-MMF-VCLNTAVIAPR-I-0002-HP

   294  *

   295  */

   296 class RTestVclntAprRegB4Open : public RTestMmfVclntVideoPlayerAPR

   297 	{

   298 public:

   299 	static RTestVclntAprRegB4Open* NewL( const TDesC& aTestName, const TDesC& aSectName );

   300 	virtual TVerdict DoTestL();

   301 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError);

   303 protected:

   304 	RTestVclntAprRegB4Open( const TDesC& aTestName, const TDesC& aSectName );

   305 	TVerdict PerformTestL();

   306 	};

   308 /**

   309  * Register (after Open and before Play of video) , receive notification of a resource available event.

   310  *

   311  * RTestVclntAprRegAftrOpenAndB4Play

   312  * MM-MMF-VCLNTAVIAPR-I-0003-HP

   313  *

   314  */

   315 class RTestVclntAprRegAftrOpenAndB4Play : public RTestMmfVclntVideoPlayerAPR

   316 	{

   317 public:

   318 	static RTestVclntAprRegAftrOpenAndB4Play* NewL( const TDesC& aTestName, const TDesC& aSectName );

   319 	virtual TVerdict DoTestL();

   320 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError);

   321 	TTimeIntervalMicroSeconds iVidPosition;

   323 protected:

   324 	RTestVclntAprRegAftrOpenAndB4Play( const TDesC& aTestName, const TDesC& aSectName );

   325 	TVerdict PerformTestL();

   326 	};

   328 /**

   329  * Register after the highest priority client (Audio) completes playing and receive the notification of a resource availalble event.

   330  *

   331  * RTestVclntAprRegAftrHpClntCompltPlay

   332  * MM-MMF-VCLNTAVIAPR-I-0004-HP

   333  *

   334  */

   335 class RTestVclntAprRegAftrHpClntCompltPlay : public RTestMmfVclntVideoPlayerAPR

   336 	{

   337 public:

   338 	static RTestVclntAprRegAftrHpClntCompltPlay* NewL( const TDesC& aTestName, const TDesC& aSectName );

   339 	virtual TVerdict DoTestL();

   340 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError);

   342 protected:

   343 	RTestVclntAprRegAftrHpClntCompltPlay( const TDesC& aTestName, const TDesC& aSectName );

   344 	TVerdict PerformTestL();

   345 	};

   347 /**

   348  * Receive notification by same priority players in the order of registration

   349  *

   350  * RTestVclntAprRegSamePriorityPlayers

   351  * MM-MMF-VCLNTAVIAPR-I-0005-HP

   352  *

   353  */

   354 class RTestVclntAprRegSamePriorityPlayers : public RTestMmfVclntVideoPlayerAPR

   355 	{

   356 public:

   357 	static RTestVclntAprRegSamePriorityPlayers* NewL( const TDesC& aTestName, const TDesC& aSectName );

   358 	virtual TVerdict DoTestL();

   359 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError);

   361 protected:

   362 	RTestVclntAprRegSamePriorityPlayers( const TDesC& aTestName, const TDesC& aSectName );

   363 	TVerdict PerformTestL();

   364 	};

   367 /**

   368  * Register (at the time of Play) and Cancellation of the notification request

   369  *

   370  * RTestVclntAprRegAtPlayAndCancelNfn

   371  * MM-MMF-VCLNTAVIAPR-I-0006-HP

   372  *

   373  */

   374 class RTestVclntAprRegAtPlayAndCancelNfn : public RTestMmfVclntVideoPlayerAPR

   375 	{

   376 public:

   377 	static RTestVclntAprRegAtPlayAndCancelNfn* NewL( const TDesC& aTestName, const TDesC& aSectName );

   378 	virtual TVerdict DoTestL();

   379 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError);

   381 protected:

   382 	RTestVclntAprRegAtPlayAndCancelNfn( const TDesC& aTestName, const TDesC& aSectName );

   383 	TVerdict PerformTestL();

   384 	};

   386 /**

   387  * Test for WillResumePlay() using 3 clients.

   388  *

   389  * RTestVclntAprTestWillResumePlay

   390  * MM-MMF-VCLNTAVIAPR-I-0007-HP

   391  *

   392  */

   393 class RTestVclntAprTestWillResumePlay : public RTestMmfVclntVideoPlayerAPR

   394 	{

   395 public:

   396 	static RTestVclntAprTestWillResumePlay* NewL( const TDesC& aTestName, const TDesC& aSectName );

   397 	virtual TVerdict DoTestL();

   398 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError);

   399 	virtual void FinishedL(); // for CVclntAviAprWillResumeTimer

   401 protected:

   402 	RTestVclntAprTestWillResumePlay( const TDesC& aTestName, const TDesC& aSectName );

   403 	TVerdict PerformTestL();

   404 	CVclntAviAprWillResumeTimer* iWillResumePlayTimer;

   405 	};

   407 /**

   408  *

   409  * CVclntAviAprWillResumeTimer

   410  * MM-MMF-VCLNTAVIAPR-I-0007-HP

   411  * - Timer for checking if no notification occurs in 5 seconds

   412  *   after calling WillResumePlay()

   413  *

   414  */

   415 class CVclntAviAprWillResumeTimer : public CTimer

   416     {

   417 public:

   418     static CVclntAviAprWillResumeTimer* NewL(RTestVclntAprTestWillResumePlay* aParent, TTimeIntervalMicroSeconds32 aWaitTime);

   419     void Start();

   420 protected:

   421     TInt RunError(TInt aError);

   422     void RunL();

   423 private:

   424     CVclntAviAprWillResumeTimer(RTestVclntAprTestWillResumePlay* aParent, TTimeIntervalMicroSeconds32 aWaitTime);

   425     RTestVclntAprTestWillResumePlay* iParent;

   426     TTimeIntervalMicroSeconds32 iWaitTime;

   427     };

   429 /**

   430  * APR Alloc tests (using shared heap) for Video Player utility.

   431  *

   432  * RTestVclntAprAllocUsingSharedHeap

   433  * MM-MMF-VCLNTAVIAPR-I-0008-HP

   434  *

   435  */

   436 class RTestVclntAprAllocUsingSharedHeap : public RTestMmfVclntVideoPlayerAPR

   437 	{

   438 public:

   439 	static RTestVclntAprAllocUsingSharedHeap* NewL( const TDesC& aTestName, const TDesC& aSectName );

   440 	void VideoPlayAllocL();

   441 	virtual TVerdict DoTestStepL();

   442 	virtual TVerdict DoTestL();

   443 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError);

   445 protected:

   446 	RTestVclntAprAllocUsingSharedHeap( const TDesC& aTestName, const TDesC& aSectName );

   447 	TVerdict PerformTestL();

   448 	};

   451 //

   452 //NEGATIVE TESTS//

   453 //

   455 /**

   456  * Multiple Registration (at the time of Play) and receive notification of a resource available event

   457  *

   458  * RTestVclntAprMultRegAtPlay

   459  * MM-MMF-VCLNTAVIAPR-I-0101-HP

   460  *

   461  */

   462 class RTestVclntAprMultRegAtPlay : public RTestMmfVclntVideoPlayerAPR

   463 	{

   464 public:

   465 	static RTestVclntAprMultRegAtPlay* NewL( const TDesC& aTestName, const TDesC& aSectName );

   466 	virtual TVerdict DoTestL();

   467 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError);

   469 protected:

   470 	RTestVclntAprMultRegAtPlay( const TDesC& aTestName, const TDesC& aSectName );

   471 	TVerdict PerformTestL();

   472 	};

   474 /**

   475  * Cancel when no resource Notification is requested.

   476  *

   477  * RTestVclntAprCancelNoResourceNfn

   478  * MM-MMF-VCLNTAVIAPR-I-0102-HP

   479  *

   480  */

   481  class RTestVclntAprCancelNoResourceNfn : public RTestMmfVclntVideoPlayerAPR

   482 	{

   483 public:

   484 	static RTestVclntAprCancelNoResourceNfn* NewL( const TDesC& aTestName, const TDesC& aSectName );

   485 	virtual TVerdict DoTestL();

   486 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError);

   488 protected:

   489 	RTestVclntAprCancelNoResourceNfn( const TDesC& aTestName, const TDesC& aSectName );

   490 	TVerdict PerformTestL();

   491 	};

   493 /**

   494  * Register for notification with an unsupported event type.

   495  *

   496  * RTestVclntAprRegUnsupportedEvent

   497  * MM-MMF-VCLNTAVIAPR-I-0103-HP

   498  *

   499  */

   500 class RTestVclntAprRegUnsupportedEvent : public RTestMmfVclntVideoPlayerAPR

   501 	{

   502 public:

   503 	static RTestVclntAprRegUnsupportedEvent* NewL( const TDesC& aTestName, const TDesC& aSectName );

   504 	virtual TVerdict DoTestL();

   505 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError);

   507 protected:

   508 	RTestVclntAprRegUnsupportedEvent( const TDesC& aTestName, const TDesC& aSectName );

   509 	TVerdict PerformTestL();

   510 	};

   512 /**

   513  * Cancellation of  notification with an unsupported event type.

   514  *

   515  * RTestVclntAprCancelUnsupportedEvent

   516  * MM-MMF-VCLNTAVIAPR-I-0104-HP

   517  *

   518  */

   519 class RTestVclntAprCancelUnsupportedEvent : public RTestMmfVclntVideoPlayerAPR

   520 	{

   521 public:

   522 	static RTestVclntAprCancelUnsupportedEvent* NewL( const TDesC& aTestName, const TDesC& aSectName );

   523 	virtual TVerdict DoTestL();

   524 	virtual void Fsm(TAVPlayerAPREvents aEventCode, TInt aError);

   526 protected:

   527 	RTestVclntAprCancelUnsupportedEvent( const TDesC& aTestName, const TDesC& aSectName );

   528 	TVerdict PerformTestL();

   529 	};

   531 #endif

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--