Symaptic: os/mm/mmlibs/mmfw/tsrc/mmfunittest/avictrl/tsu_mmf

     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 //

    17 #ifndef TSU_MMF_AVICTRLPLAY_H

    18 #define TSU_MMF_AVICTRLPLAY_H

    20 #include "tsu_mmf_avictrl_teststep.h"

    22 #ifdef SYMBIAN_BUILD_GCE

    23 #include <mmf/common/mmfvideosurfacecustomcommands.h>

    24 #endif // SYMBIAN_BUILD_GCE

    25 #define KMaxChunks 50 //The maximum chunks that can be allocated

    26 					  //Has been adjusted such that we dont need higher than this

    28 /**

    29 This class tests playing an avi file completely and checks for

    30 playcompletion event with KErrNone from the aviplaycontroller.

    31 */

    32 class RTestStepAviPlayCtrlPlay : public RTestStepAviCtrlPlayBase

    33 	{

    34 public:

    35 	RTestStepAviPlayCtrlPlay(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

    36 	virtual TVerdict  DoTestStepL(  );

    37 	};

    38 /**

    39 This class tests setting the volume on AviPlayController in Stopped, Primed and Playing states

    40 and checks if the volume set is same as the volume got.

    41 */

    42 class RTestStepAviPlayCtrlVolume : public RTestStepAviCtrlPlayBase

    43 	{

    44 public:

    45 	RTestStepAviPlayCtrlVolume(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

    46 	virtual TVerdict  DoTestStepL(  );

    47 	};

    49 /**

    50 This class tests setting the PlayBalance on AviPlayController in Stopped, Primed and Playing  states

    51 and checks if the PlayBalance set is same as the PlayBalance got.

    52 */

    53 class RTestStepAviPlayCtrlPlayBalance : public RTestStepAviCtrlPlayBase

    54 	{

    55 public:

    56 	RTestStepAviPlayCtrlPlayBalance(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

    57 	virtual TVerdict  DoTestStepL( );

    58 	};

    60 /**

    61 This class tests the duration of the file using AviPlayController.

    62 */

    63 class RTestStepAviPlayCtrlDuration : public RTestStepAviCtrlPlayBase

    64 	{

    65 public:

    66 	RTestStepAviPlayCtrlDuration(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

    67 	virtual TVerdict  DoTestStepL(  );

    68 	};

    70  /**

    71 This class tests pause functionality of AviPlayController in Stopped, Primed and Playing  states and checks

    72  if the play starts from the current position during playing state.

    73 */

    74 class RTestStepAviPlayCtrlPause : public RTestStepAviCtrlPlayBase

    75 	{

    76 public:

    77 	RTestStepAviPlayCtrlPause(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

    78 	virtual TVerdict  DoTestStepL( );

    79 	};

    81 /**

    82 This class tests stop functionality of AviPlayController in Stopped, Primed and Playing

    83 states and checks if the play starts from the initial position during playing state

    84 */

    85 class RTestStepAviPlayCtrlStop : public RTestStepAviCtrlPlayBase

    86 	{

    87 public:

    88 	RTestStepAviPlayCtrlStop(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

    89 	virtual TVerdict  DoTestStepL( );

    90 	};

    92 /**

    93 This class tests to set and get the crop region using AviPlayController.

    94 */

    95 class RTestStepAviPlayCtrlSetGetCropRegion : public RTestStepAviCtrlPlayBase

    96 	{

    97 public:

    98 	RTestStepAviPlayCtrlSetGetCropRegion(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

    99 	virtual TVerdict  DoTestStepL( );

   100 	};

   102 /**

   103 This class tests to set and get the framerate of the file using AviPlayController.

   104  */

   105 class RTestStepAviPlayCtrlSetGetFrameRate : public RTestStepAviCtrlPlayBase

   106 	{

   107 public:

   108 	RTestStepAviPlayCtrlSetGetFrameRate(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   109 	virtual TVerdict  DoTestStepL( );

   110 	};

   112 /**

   113 This class tests to get the frame size using AviPlayController.

   114 */

   115 class RTestStepAviPlayCtrlGetFrameSize : public RTestStepAviCtrlPlayBase

   116 	{

   117 public:

   118 	RTestStepAviPlayCtrlGetFrameSize(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   119 	virtual TVerdict  DoTestStepL( );

   120 	};

   122 /**

   123 This class tests to get the audio codec installed in the file using AviPlayController.

   124 */

   125 class RTestStepAviPlayCtrlGetAudioDataType : public RTestStepAviCtrlPlayBase

   126 	{

   127 public:

   128 	RTestStepAviPlayCtrlGetAudioDataType(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   129 	virtual TVerdict  DoTestStepL( );

   130 	};

   132 /**

   133 This class tests to get the video codec installed in the file using AviPlayController.

   134 */

   135 class RTestStepAviPlayCtrlGetVideoDataType : public RTestStepAviCtrlPlayBase

   136 	{

   137 public:

   138 	RTestStepAviPlayCtrlGetVideoDataType(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   139 	virtual TVerdict  DoTestStepL( );

   140 	};

   142 /**

   143 This class tests metadata support of the AviPlayController.

   144 */

   145 class RTestStepAviPlayCtrlMetaData : public RTestStepAviCtrlPlayBase

   146 	{

   147 public:

   148 	RTestStepAviPlayCtrlMetaData(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   149 	virtual TVerdict  DoTestStepL( );

   150 	};

   152 /**

   153 This class tests Rotation api of the AviPlayController.

   154 */

   155 class RTestStepAviPlayCtrlSetGetRotation : public RTestStepAviCtrlPlayBase

   156 	{

   157 public:

   158 	RTestStepAviPlayCtrlSetGetRotation(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   159 	virtual TVerdict  DoTestStepL( );

   160 	};

   161 /**

   162 This class tests Rotation api of the AviPlayController.

   163 */

   164 class RTestStepAviPlayCtrlSetGetScaling : public RTestStepAviCtrlPlayBase

   165 	{

   166 public:

   167 	RTestStepAviPlayCtrlSetGetScaling(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   168 	virtual TVerdict  DoTestStepL( );

   169 	};

   171 /**

   172 This class tests Position api of the AviPlayController.

   173 */

   174 class RTestStepAviPlayCtrlSetPosition : public RTestStepAviCtrlPlayBase

   175 	{

   176 public:

   177 	RTestStepAviPlayCtrlSetPosition(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   178 	virtual TVerdict  DoTestStepL( );

   179 	};

   181 /**

   182 This class tests getting video bit rate of the AviPlayController.

   183 */

   184 class RTestStepAviPlayCtrlGetVideoBitrate : public RTestStepAviCtrlPlayBase

   185 	{

   186 public:

   187 	RTestStepAviPlayCtrlGetVideoBitrate(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   188 	virtual TVerdict  DoTestStepL( );

   189 	};

   191 /**

   192 This class tests getting audio bit rate of the AviPlayController.

   193 */

   194 class RTestStepAviPlayCtrlGetAudioBitrate : public RTestStepAviCtrlPlayBase

   195 	{

   196 public:

   197 	RTestStepAviPlayCtrlGetAudioBitrate(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   198 	virtual TVerdict  DoTestStepL( );

   199 	};

   201 /**

   202 This class tests for direct screen access of aviplaycontroller

   203 */

   204 class RTestStepAviCtrlDirectScreenAccess : public RTestStepAviCtrlPlayBase

   205 	{

   206 public:

   207 	RTestStepAviCtrlDirectScreenAccess(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   208 	virtual TVerdict  DoTestStepL(void);

   209 	};

   211 /**

   212 This class tests for Play window property for .avi play controller

   213 */

   214 class RTestStepAviCtrlSetPlayWindow : public RTestStepAviCtrlPlayBase

   215 	{

   216 public:

   217 	RTestStepAviCtrlSetPlayWindow(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   218 	virtual TVerdict  DoTestStepL(void);

   219 	};

   221 //Negative Tests

   223 /**

   224 This class tests opening an invalid file using AviPlayController.

   225 */

   226 class RTestStepAviCtrlPlayInvalid : public RTestStepAviCtrlPlayBase

   227 	{

   228 public:

   229 	RTestStepAviCtrlPlayInvalid(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   230 	virtual TVerdict DoTestStepPreambleL(void);

   231 	virtual TVerdict  DoTestStepL(void);

   232 	};

   234 /**

   235 This class tests for volume and balance when audio is not enabled in the file.

   236 */

   237 class RTestStepAviCtrlNotAudioEnabled : public RTestStepAviCtrlPlayBase

   238 	{

   239 public:

   240 	RTestStepAviCtrlNotAudioEnabled(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   241 	virtual TVerdict  DoTestStepL(void);

   242 	};

   244 /**

   245 This class tests playing an avi file on primary or secondary screen depending on the screen number set during its

   246 construction and checks for playcompletion event with KErrNone from the aviplaycontroller.

   247 */

   248 class RTestStepAviPlayCtrlSetScrnPlay : public RTestStepAviCtrlPlayBase

   249 	{

   250 public:

   251 	RTestStepAviPlayCtrlSetScrnPlay(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid, TInt aScreenNumber);

   252 	virtual TVerdict DoTestStepPreambleL(void);

   253 	virtual TVerdict  DoTestStepL(void);

   254 protected:

   255 	//from MMMFControllerEventMonitorObserver

   256 	void HandleEvent(const TMMFEvent& aEvent);

   257 public:

   258 	TInt iScreenNumber;

   259 	};

   261 /**

   262 This class tests setting an invalid screen id on AviPlayController.

   263 */

   264 class RTestStepAviPlayCtrlSetInvalidScrn : public RTestStepAviCtrlPlayBase

   265 	{

   266 public:

   267 	RTestStepAviPlayCtrlSetInvalidScrn(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid, TInt aScreenNumber);

   268 	virtual TVerdict DoTestStepPreambleL(void);

   269 	virtual TVerdict  DoTestStepL(void);

   270 public:

   271 	TInt iScreenNumber;

   272 	};

   274 /**

   275 This class tests setting the invalid screen id after adding the datasink to the AviPlayController.

   276 It resets the controller and adds the datasink for the secondtime and expects KErrNotSupported.

   277 */

   278 class RTestStepAviPlayCtrlAddDataSinkTwice : public RTestStepAviPlayCtrlSetScrnPlay

   279 	{

   280 public:

   281 	RTestStepAviPlayCtrlAddDataSinkTwice(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid, TInt aScreenNumber);

   282 	virtual TVerdict DoTestStepPreambleL(void);

   283 	virtual TVerdict  DoTestStepL(void);

   284 	};

   287 /**

   288 This class tests playing an avi file when the xvid decoder finds low memory

   289 conditions. The codec will inform back to the controlller that a fatal error

   290 occured. After that, the memory conditions are returned back to normal and the

   291 video playback is restarted to demonstrate that DevVideo is recreated after the

   292 failure and that the video is played succesfully.

   293 */

   294 class RTestStepAviPlayNotEnoughMemoryForXvidCodecHeap :

   295 	public RAsyncTestStepAviCtrlPlayBase,

   296 	public MMMFControllerEventMonitorObserver

   298 	{

   299 public:

   300 	static const TUint KMaxFreeRamForTest = 0x4fff00; // 5-32k MB, this is adjusted

   301 													  // to leave just enough

   302 													  // memory for the xvid

   303 													  // decoder to fail

   305 public:

   306 	RTestStepAviPlayNotEnoughMemoryForXvidCodecHeap(

   307 		const TDesC& aTestName, const TDesC& aSectName,

   308 		const TDesC& aKeyName, TUid aControllerUid);

   310 	// from RAsyncTestStep

   311 	void KickoffTestL();

   312 	void CloseTest();

   314 protected:

   316 	// from MMMFControllerEventMonitorObserver

   317 	void HandleEvent(const TMMFEvent& aEvent);

   319 	// Call backs

   320 	static TInt AllocChunkCallBack(TAny* aPtr);

   321 	void DoAllocChunkCallBack();

   322 	static TInt PrimeControllerCallBack(TAny* aPtr);

   323 	void DoPrimeControllerCallBack();

   324 	static TInt PlayControllerCallBack(TAny* aPtr);

   325 	void DoPlayControllerCallBack();

   326 	static TInt ReturnChunckAndStopControllerCallBack(TAny* aPtr);

   327 	void DoReturnChunckAndStopControllerCallBack();

   330 protected:

   332 	// Set of states for simple state machine

   333 	enum TTestState

   334 		{

   335 		EStateDefault,

   336 		EStateLoadKickoffTestLComplete,

   337 		EStateAllocChunkCallBackComplete,

   338 		EStatePrimeControllerCallBackComplete1,

   339 		EStatePlayControllerCallBackComplete1,

   340 		EStateReturnChunckAndStopControllerCallBackComplete,

   341 		EStatePrimeControllerCallBackComplete2,

   342 		EStatePlayControllerCallBackComplete2

   343 		};

   345 	TTestState iTestState;

   346 	RChunk iRChunk[KMaxChunks];

   347 	TInt iNumAllocatedChunks;

   348 	CAsyncCallBack* iKickoff01;

   349 	CAsyncCallBack* iKickoff02;

   350 	CAsyncCallBack* iKickoff03;

   351 	CAsyncCallBack* iKickoff04;

   352 	CAsyncCallBack* iKickoff05;

   353 	CAsyncCallBack* iKickoff06;

   354 	};

   356 /**

   357 This class tests OOM situation on several controller functions.

   358 (e.g. AddSource/Sink)

   359 */

   360 class RTestStepAviPlayCtrlMemAlloc1 : public RTestStepAviCtrlBase

   361 	{

   362 public:

   363 	RTestStepAviPlayCtrlMemAlloc1(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   364 	virtual TVerdict DoTestStepL(  );

   365 protected:

   366 	//from MMMFControllerEventMonitorObserver

   367 	void HandleEvent(const TMMFEvent& aEvent);

   368 	};

   370 /**

   371 This class tests OOM situation on several controller functions.

   372 (e.g. Prime)

   373 */

   374 class RTestStepAviPlayCtrlMemAlloc2 : public RTestStepAviCtrlBase

   375 	{

   376 public:

   377 	RTestStepAviPlayCtrlMemAlloc2(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   378 	virtual TVerdict DoTestStepL(  );

   379 protected:

   380 	//from MMMFControllerEventMonitorObserver

   381 	void HandleEvent(const TMMFEvent& aEvent);

   382 	};

   384 /**

   385 This class tests OOM situation on several controller functions.

   386 (e.g. Prime)

   387 */

   388 class RTestStepAviPlayCtrlMemAlloc3 : public RTestStepAviCtrlBase

   389 	{

   390 public:

   391 	RTestStepAviPlayCtrlMemAlloc3(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   392 	virtual TVerdict DoTestStepL(  );

   393 protected:

   394 	//from MMMFControllerEventMonitorObserver

   395 	void HandleEvent(const TMMFEvent& aEvent);

   396 };

   398 #ifdef SYMBIAN_BUILD_GCE

   399 // Surface support positive tests:

   401 /**

   402 Test surface support in the AVI play controller.  It enables surfaces, adds a rendering

   403 target display, gets the surface parameter, updates the display and finally removes the display.

   404 */

   405 class RTestStepAviPlayCtrlSurfaceSupport : public RAsyncTestStepAviCtrlPlayBase

   406 	{

   407 public:

   408 	RTestStepAviPlayCtrlSurfaceSupport(const TDesC& aTestName, const TDesC& aSecName, const TDesC& aKeyName, TUid aControllerUid);

   410 	// from RAsyncTestStep

   411 	virtual void KickoffTestL();

   412 	virtual void CloseTest();

   414 	// from MMMFControllerEventMonitorObserver

   415 	virtual void HandleEvent(const TMMFEvent& aEvent);

   417 private:

   418 	virtual TVerdict CheckTestResult();

   420 	// Call back functions

   421 	static TInt UseSurfacesCallBack(TAny* aPtr);

   422 	void DoUseSurfacesCallBack();

   424 	static TInt PrimeControllerCallBack(TAny* aPtr);

   425 	void DoPrimeControllerCallBack();

   427 	static TInt PlayControllerCallBack(TAny* aPtr);

   428 	void DoPlayControllerCallBack();

   430 private:

   431 	TBool iSurfaceCreated;

   432 	TSurfaceId iSurfaceId;

   434 	CAsyncCallBack* iKickoffUseSurfaces;

   435 	CAsyncCallBack* iKickoffUseSurfaces2;

   436 	CAsyncCallBack* iKickoffPrimeController;

   437 	CAsyncCallBack* iKickoffPlayController;

   439 	RMMFVideoPlaySurfaceSupportCustomCommands iVpsCommands;

   440 	};

   442 // Surface support negative tests:

   444 /**

   445 Test surface support in the AVI play controller.  We expect a failure when we call surface removed

   446 without first callng UseSurfaces.

   447 */

   448 class RTestStepAviPlayCtrlSurfaceRemovedNoUS : public RAsyncTestStepAviCtrlPlayBase

   449 	{

   450 public:

   451 	RTestStepAviPlayCtrlSurfaceRemovedNoUS(const TDesC& aTestName, const TDesC& aSecName, const TDesC& aKeyName, TUid aControllerUid);

   453 	// from RAsyncTestStep

   454 	virtual void KickoffTestL();

   455 	virtual void CloseTest();

   457 private:

   458 	// Call back functions

   459 	static TInt SurfaceRemovedCallBack(TAny* aPtr);

   460 	void DoSurfaceRemovedCallBack();

   462 private:

   463 	CAsyncCallBack* iKickoffSurfaceRemoved;

   465 	TSurfaceId iSurfaceId;

   467 	RMMFVideoPlaySurfaceSupportCustomCommands iVpsCommands;

   468 	};

   470 /**

   471 Test surface support in the AVI play controller.  We expect a failure when we get the surface parameters

   472 without first callng UseSurfaces.

   473 */

   474 class RTestStepAviPlayCtrlGetSurfaceParametersNoUS : public RAsyncTestStepAviCtrlPlayBase

   475 	{

   476 public:

   477 	RTestStepAviPlayCtrlGetSurfaceParametersNoUS(const TDesC& aTestName, const TDesC& aSecName, const TDesC& aKeyName, TUid aControllerUid);

   479 	// from RAsyncTestStep

   480 	virtual void KickoffTestL();

   481 	virtual void CloseTest();

   483 private:

   484 	// Call back functions

   485 	static TInt GetSurfaceParametersCallBack(TAny* aPtr);

   486 	void DoGetSurfaceParametersCallBack();

   488 private:

   489 	CAsyncCallBack* iKickoffGetSurfaceParameters;

   491 	RMMFVideoPlaySurfaceSupportCustomCommands iVpsCommands;

   492 	};

   494 /**

   495 Test surface support in the AVI play controller.  We expect a failure when we call surface removed

   496 after callng UseSurfaces with a null surface Id

   497 */

   498 class RTestStepAviPlayCtrlSurfaceRemovedNullSurfaceId : public RAsyncTestStepAviCtrlPlayBase

   499 	{

   500 public:

   501 	RTestStepAviPlayCtrlSurfaceRemovedNullSurfaceId(const TDesC& aTestName, const TDesC& aSecName, const TDesC& aKeyName, TUid aControllerUid);

   503 	// from RAsyncTestStep

   504 	virtual void KickoffTestL();

   505 	virtual void CloseTest();

   507 private:

   508 	// Call back functions

   509 	static TInt SurfaceRemovedCallBack(TAny* aPtr);

   510 	void DoSurfaceRemovedCallBack();

   511 	static TInt UseSurfacesCallBack(TAny* aPtr);

   512 	void DoUseSurfacesCallBack();

   514 private:

   515 	CAsyncCallBack* iKickoffSurfaceRemoved;

   516 	CAsyncCallBack* iKickoffUseSurfaces;

   518 	TSurfaceId iSurfaceId;

   520 	RMMFVideoPlaySurfaceSupportCustomCommands iVpsCommands;

   521 	};

   523 /**

   524 Test surface support in the AVI play controller.  We expect a failure when we call surface removed

   525 after calling UseSurfaces with an invalid surface Id

   526 */

   527 class RTestStepAviPlayCtrlSurfaceRemovedInvalidSurfaceId : public RAsyncTestStepAviCtrlPlayBase

   528 	{

   529 public:

   530 	RTestStepAviPlayCtrlSurfaceRemovedInvalidSurfaceId(const TDesC& aTestName, const TDesC& aSecName, const TDesC& aKeyName, TUid aControllerUid);

   532 	// from RAsyncTestStep

   533 	virtual void KickoffTestL();

   534 	virtual void CloseTest();

   536 private:

   537 	// Call back functions

   538 	static TInt SurfaceRemovedCallBack(TAny* aPtr);

   539 	void DoSurfaceRemovedCallBack();

   540 	static TInt UseSurfacesCallBack(TAny* aPtr);

   541 	void DoUseSurfacesCallBack();

   543 private:

   544 	CAsyncCallBack* iKickoffSurfaceRemoved;

   545 	CAsyncCallBack* iKickoffUseSurfaces;

   547 	TSurfaceId iSurfaceId;

   549 	RMMFVideoPlaySurfaceSupportCustomCommands iVpsCommands;

   550 	};

   552 #endif // SYMBIAN_BUILD_GCE

   554 #ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

   556 /**

   557  * MM-MMF-AVICTRL-U-0100-HP

   558  */

   559 class RAsyncTestSubtitlePlay : public RAsyncTestStepSubtitleBase

   560 	{

   561 public:

   562 	RAsyncTestSubtitlePlay(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   564 private:

   565 	// From RAsyncTestStepSubtitleBase

   566 	void OnOpenCompleteL();

   567 	void OnPlayCompleteL();

   568 	};

   570 /**

   571  * MM-MMF-AVICTRL-U-0101-HP

   572  */

   573 class RAsyncTestSubtitleUpdateConfig : public RAsyncTestStepSubtitleBase

   574 	{

   575 public:

   576 	RAsyncTestSubtitleUpdateConfig(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   578 private:

   579 	// From RAsyncTestStepSubtitleBase

   580 	void OnOpenCompleteL();

   581 	void OnPlayCompleteL();

   582 	};

   584 class CCallBackTimer : public CTimer

   585 	{

   586 public:

   587 	static CCallBackTimer* NewL(const TCallBack& aCallBack, TInt aPriority);

   589 protected:

   590 	void RunL();

   592 private:

   593 	CCallBackTimer(const TCallBack& aCallBack, TInt aPriority);

   595 private:

   596 	TCallBack iCallBack;

   597 	};

   599 /**

   600  * MM-MMF-AVICTRL-U-0102-HP

   601  */

   602 class RAsyncTestSubtitleUpdateDuring : public RAsyncTestStepSubtitleBase

   603 	{

   604 public:

   605 	RAsyncTestSubtitleUpdateDuring(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   607 	//From RAsyncTestStep

   608 	void KickoffTestL();

   609 	void CloseTest();

   611 private:

   612 	// From RAsyncTestStepSubtitleBase

   613 	void OnOpenCompleteL();

   614 	void OnPlayCompleteL();

   616 	static TInt DuringPlaybackCallBack(TAny* aPtr);

   617 	void OnDuringPlayback();

   619 private:

   620 	CCallBackTimer* iCallBackTimer;

   621 	TBool iHasUpdated;

   622 	};

   624 /**

   625  * MM-MMF-AVICTRL-U-0103-HP

   626  */

   627 class RAsyncTestSubtitleRemoveAdd : public RAsyncTestStepSubtitleBase

   628 	{

   629 public:

   630 	RAsyncTestSubtitleRemoveAdd(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   632 private:

   633 	// From RAsyncTestStepSubtitleBase

   634 	void OnOpenCompleteL();

   635 	void OnPlayCompleteL();

   636 	};

   638 /**

   639  * MM-MMF-AVICTRL-U-0200-HP

   640  */

   641 class RAsyncTestSubtitleNotEnabled : public RAsyncTestStepSubtitleBase

   642 	{

   643 public:

   644 	RAsyncTestSubtitleNotEnabled(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   646 private:

   647 	// From RAsyncTestStepSubtitleBase

   648 	void OnOpenCompleteL();

   649 	void OnPlayCompleteL();

   650 	};

   652 /**

   653  * MM-MMF-AVICTRL-U-0201-HP

   654  */

   655 class RAsyncTestSubtitleNotAvailable : public RAsyncTestStepSubtitleBase

   656 	{

   657 public:

   658 	RAsyncTestSubtitleNotAvailable(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   660 private:

   661 	// From RAsyncTestStepSubtitleBase

   662 	void OnOpenCompleteL();

   663 	void OnPlayCompleteL();

   664 	};

   666 /**

   667  * MM-MMF-AVICTRL-U-0202-HP

   668  */

   669 class RAsyncTestSubtitleMismatchedId : public RAsyncTestStepSubtitleBase

   670 	{

   671 public:

   672 	RAsyncTestSubtitleMismatchedId(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   674 private:

   675 	// From RAsyncTestStepSubtitleBase

   676 	void OnOpenCompleteL();

   677 	};

   679 /**

   680  * MM-MMF-AVICTRL-U-0203-HP

   681  */

   682 class RAsyncTestSubtitleDoubleCall : public RAsyncTestStepSubtitleBase

   683 	{

   684 public:

   685 	RAsyncTestSubtitleDoubleCall(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   687 private:

   688 	// From RAsyncTestStepSubtitleBase

   689 	void OnOpenCompleteL();

   690 	void OnPlayCompleteL();

   691 	};

   693 /**

   694  * MM-MMF-AVICTRL-U-0204-HP

   695  */

   696 class RAsyncTestSubtitleMultipleConfigs : public RAsyncTestStepSubtitleBase

   697 	{

   698 public:

   699 	RAsyncTestSubtitleMultipleConfigs(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TUid aControllerUid);

   701 private:

   702 	// From RAsyncTestStepSubtitleBase

   703 	void OnOpenCompleteL();

   704 	};

   706 #endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

   707 #endif //(tsu_mmf_avictrlplay.h)

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--