1 /*

     2 * Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:    See class definition below.

    15 *

    16 */

    17 

    18 

    19 

    20 #ifndef __TMCETESTUIENGINECMDENABLEAUDIOSOURCE_H__

    21 #define __TMCETESTUIENGINECMDENABLEAUDIOSOURCE_H__

    22 

    23 // INCLUDES

    24 #include "TMCETestUIEngineCmdBase.h"

    25 

    26 // FORWARD DECLARATIONS

    27 class CMCETestUIEngineAudioSource;

    28 class CMCETestUIEngineVideoSource;

    29 class CMCETestUIEngineSource;

    30 

    31 // CLASS DEFINITION

    32 /**

    33  * 

    34  */

    35 class TMCETestUIEngineCmdEnableSource: public TMCETestUIEngineCmdBase

    36 	{

    37 

    38 	public:	// Constructors

    39 

    40 		/**

    41 		 * Constructor

    42 		 */

    43 		TMCETestUIEngineCmdEnableSource( 

    44 		            CMCETestUIEngine& aEngine,

    45 		            CMCETestUIEngineSource& aAudioSource );

    46 

    47 	public: // Implementation for base class abstract methods

    48 

    49 		/// Executes a sequence of operations.

    50 		IMPORT_C void ExecuteL();

    51 		

    52 		/// Returns short textual representation for behavior of command

    53 		IMPORT_C const TDesC& Caption() const;

    54 

    55     private: // Data

    56     

    57         CMCETestUIEngineSource& iAudioSource;

    58 

    59 	};

    60 // CLASS DEFINITION

    61 /**

    62  * 

    63  */

    64 class TMCETestUIEngineCmdEnableVideoSource: public TMCETestUIEngineCmdBase

    65 	{

    66 

    67 	public:	// Constructors

    68 

    69 		/**

    70 		 * Constructor

    71 		 */

    72 		TMCETestUIEngineCmdEnableVideoSource( 

    73 		            CMCETestUIEngine& aEngine,

    74 		            CMCETestUIEngineVideoSource& aVideoSource );

    75 

    76 	public: // Implementation for base class abstract methods

    77 

    78 		/// Executes a sequence of operations.

    79 		IMPORT_C void ExecuteL();

    80 		

    81 		/// Returns short textual representation for behavior of command

    82 		IMPORT_C const TDesC& Caption() const;

    83 

    84     private: // Data

    85     

    86         CMCETestUIEngineVideoSource& iVideoSource;

    87 

    88 	};

    89 	

    90 // CLASS DEFINITION

    91 /**

    92  * 

    93  */

    94 class TMCETestUIEngineCmdEnableRtpSourceInActivityTimer: public TMCETestUIEngineCmdBase

    95 	{

    96 

    97 	public:	// Constructors

    98 

    99 		/**

   100 		 * Constructor

   101 		 */

   102 		TMCETestUIEngineCmdEnableRtpSourceInActivityTimer( 

   103 		            CMCETestUIEngine& aEngine,

   104 		            CMCETestUIEngineSource& aAudioSource );

   105 

   106 	public: // Implementation for base class abstract methods

   107 

   108 		/// Executes a sequence of operations.

   109 		IMPORT_C void ExecuteL();

   110 		

   111 		/// Returns short textual representation for behavior of command

   112 		IMPORT_C const TDesC& Caption() const;

   113 

   114     private: // Data

   115     

   116         CMCETestUIEngineSource& iAudioSource;

   117 

   118 	};

   119 // CLASS DEFINITION

   120 /**

   121  * 

   122  */

   123 class TMCETestUIEngineCmdSendRR: public TMCETestUIEngineCmdBase

   124 	{

   125 

   126 	public:	// Constructors

   127 

   128 		/**

   129 		 * Constructor

   130 		 */

   131 		TMCETestUIEngineCmdSendRR( 

   132 		            CMCETestUIEngine& aEngine,

   133 		            CMCETestUIEngineSource& aAudioSource );

   134 

   135 	public: // Implementation for base class abstract methods

   136 

   137 		/// Executes a sequence of operations.

   138 		IMPORT_C void ExecuteL();

   139 		

   140 		/// Returns short textual representation for behavior of command

   141 		IMPORT_C const TDesC& Caption() const;

   142 

   143     private: // Data

   144     

   145         CMCETestUIEngineSource& iAudioSource;

   146 

   147 	};

   148 

   149 // CLASS DEFINITION

   150 /**

   151  * 

   152  */

   153 class TMCETestUIEngineCmdAudioTranscode: public TMCETestUIEngineCmdBase

   154 	{

   155 

   156 	public:	// Constructors

   157 

   158 		/**

   159 		 * Constructor

   160 		 */

   161 		TMCETestUIEngineCmdAudioTranscode( 

   162 		            CMCETestUIEngine& aEngine,

   163 		            CMCETestUIEngineSource& aAudioSource );

   164 

   165 	public: // Implementation for base class abstract methods

   166 

   167 		/// Executes a sequence of operations.

   168 		IMPORT_C void ExecuteL();

   169 		

   170 		/// Returns short textual representation for behavior of command

   171 		IMPORT_C const TDesC& Caption() const;

   172 

   173     private: // Data

   174     

   175         CMCETestUIEngineSource& iAudioSource;

   176 

   177 	};

   178 	

   179 // CLASS DEFINITION

   180 /**

   181  * 

   182  */

   183 class TMCETestUIEngineCmdAudioCancelTranscode: public TMCETestUIEngineCmdBase

   184 	{

   185 

   186 	public:	// Constructors

   187 

   188 		/**

   189 		 * Constructor

   190 		 */

   191 		TMCETestUIEngineCmdAudioCancelTranscode( 

   192 		            CMCETestUIEngine& aEngine,

   193 		            CMCETestUIEngineSource& aAudioSource );

   194 

   195 	public: // Implementation for base class abstract methods

   196 

   197 		/// Executes a sequence of operations.

   198 		IMPORT_C void ExecuteL();

   199 		

   200 		/// Returns short textual representation for behavior of command

   201 		IMPORT_C const TDesC& Caption() const;

   202 

   203     private: // Data

   204     

   205         CMCETestUIEngineSource& iAudioSource;

   206 

   207 	};

   208 	

   209 // CLASS DEFINITION

   210 /**

   211  * 

   212  */

   213 class TMCETestUIEngineCmdVideoTranscode: public TMCETestUIEngineCmdBase

   214 	{

   215 

   216 	public:	// Constructors

   217 

   218 		/**

   219 		 * Constructor

   220 		 */

   221 		TMCETestUIEngineCmdVideoTranscode( 

   222 		            CMCETestUIEngine& aEngine,

   223 		            CMCETestUIEngineVideoSource& aVideoSource );

   224 

   225 	public: // Implementation for base class abstract methods

   226 

   227 		/// Executes a sequence of operations.

   228 		IMPORT_C void ExecuteL();

   229 		

   230 		/// Returns short textual representation for behavior of command

   231 		IMPORT_C const TDesC& Caption() const;

   232 

   233     private: // Data

   234     

   235         CMCETestUIEngineVideoSource& iVideoSource;

   236 

   237 	};

   238 	

   239 // CLASS DEFINITION

   240 /**

   241  * 

   242  */

   243 class TMCETestUIEngineCmdVideoCancelTranscode: public TMCETestUIEngineCmdBase

   244 	{

   245 

   246 	public:	// Constructors

   247 

   248 		/**

   249 		 * Constructor

   250 		 */

   251 		TMCETestUIEngineCmdVideoCancelTranscode( 

   252 		            CMCETestUIEngine& aEngine,

   253 		            CMCETestUIEngineVideoSource& aVideoSource );

   254 

   255 	public: // Implementation for base class abstract methods

   256 

   257 		/// Executes a sequence of operations.

   258 		IMPORT_C void ExecuteL();

   259 		

   260 		/// Returns short textual representation for behavior of command

   261 		IMPORT_C const TDesC& Caption() const;

   262 

   263     private: // Data

   264     

   265         CMCETestUIEngineVideoSource& iVideoSource;

   266 

   267 	};

   268 

   269 // CLASS DEFINITION

   270 /**

   271  * 

   272  */

   273 class TMCETestUIEngineCmdStartDtmfToneL: public TMCETestUIEngineCmdBase

   274 	{

   275 

   276 	public:	// Constructors

   277 

   278 		/**

   279 		 * Constructor

   280 		 */

   281 		TMCETestUIEngineCmdStartDtmfToneL( 

   282 		            CMCETestUIEngine& aEngine,

   283 		            CMCETestUIEngineSource& aMediaSource );

   284 

   285 	public: // Implementation for base class abstract methods

   286 

   287 		/// Executes a sequence of operations.

   288 		IMPORT_C void ExecuteL();

   289 		

   290 		/// Returns short textual representation for behavior of command

   291 		IMPORT_C const TDesC& Caption() const;

   292 

   293     private: // Data

   294     

   295         CMCETestUIEngineSource& iMediaSource;

   296 

   297 	};

   298 

   299 // CLASS DEFINITION

   300 /**

   301  * 

   302  */

   303 class TMCETestUIEngineCmdStopDtmfToneL: public TMCETestUIEngineCmdBase

   304 	{

   305 

   306 	public:	// Constructors

   307 

   308 		/**

   309 		 * Constructor

   310 		 */

   311 		TMCETestUIEngineCmdStopDtmfToneL( 

   312 		            CMCETestUIEngine& aEngine,

   313 		            CMCETestUIEngineSource& aMediaSource );

   314 

   315 	public: // Implementation for base class abstract methods

   316 

   317 		/// Executes a sequence of operations.

   318 		IMPORT_C void ExecuteL();

   319 		

   320 		/// Returns short textual representation for behavior of command

   321 		IMPORT_C const TDesC& Caption() const;

   322 

   323     private: // Data

   324     

   325         CMCETestUIEngineSource& iMediaSource;

   326 

   327 	};

   328 

   329 // CLASS DEFINITION

   330 /**

   331  * 

   332  */

   333 class TMCETestUIEngineCmdSendDtmfToneL: public TMCETestUIEngineCmdBase

   334 	{

   335 

   336 	public:	// Constructors

   337 

   338 		/**

   339 		 * Constructor

   340 		 */

   341 		TMCETestUIEngineCmdSendDtmfToneL( 

   342 		            CMCETestUIEngine& aEngine,

   343 		            CMCETestUIEngineSource& aMediaSource );

   344 

   345 	public: // Implementation for base class abstract methods

   346 

   347 		/// Executes a sequence of operations.

   348 		IMPORT_C void ExecuteL();

   349 		

   350 		/// Returns short textual representation for behavior of command

   351 		IMPORT_C const TDesC& Caption() const;

   352 

   353     private: // Data

   354     

   355         CMCETestUIEngineSource& iMediaSource;

   356 

   357 	};

   358 // CLASS DEFINITION

   359 /**

   360  * 

   361  */

   362 class TMCETestUIEngineCmdSendDtmfToneSequenceL: public TMCETestUIEngineCmdBase

   363 	{

   364 

   365 	public:	// Constructors

   366 

   367 		/**

   368 		 * Constructor

   369 		 */

   370 		TMCETestUIEngineCmdSendDtmfToneSequenceL( 

   371 		            CMCETestUIEngine& aEngine,

   372 		            CMCETestUIEngineSource& aMediaSource );

   373 

   374 	public: // Implementation for base class abstract methods

   375 

   376 		/// Executes a sequence of operations.

   377 		IMPORT_C void ExecuteL();

   378 		

   379 		/// Returns short textual representation for behavior of command

   380 		IMPORT_C const TDesC& Caption() const;

   381 

   382     private: // Data

   383     

   384         CMCETestUIEngineSource& iMediaSource;

   385 

   386 	};

   387 			

   388 #endif // __TMCETESTUIENGINECMDEnableStream_H__