MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/mm/mmlibs/mmfw/tsrc/mmfintegrationtest/ACLNT/TestTone.h
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 

     2 // Copyright (c) 2001-2009 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:

    15 // Header file: Basic  tests.

    16 // 

    17 //

    18 

    19 /**

    20  @file TestTone.h

    21 */

    22 

    23 #ifndef TESTTONE_H__

    24 #define TESTTONE_H__

    25 

    26 #include "TSI_MMFACLNT.h"

    27 

    28 

    29 

    30 /**

    31  * Play a tone

    32  *

    33  * @class CTestMmfAclntTone

    34  *

    35  */

    36 class CTestMmfAclntTone : public  CTestMmfAclntStep, public MMdaAudioToneObserver

    37 	{

    38 public:

    39 	CTestMmfAclntTone(const TDesC& aTestName, const TInt aExpectedResult=KErrNone) ;

    40 	static CTestMmfAclntTone* NewL(const TDesC& aTestName, const TInt aExpectedResult=KErrNone);

    41 	virtual TVerdict DoTestStepL();

    42 	virtual TVerdict DoTestL(CMdaAudioToneUtility* aToneUtil);

    43 	// From MMdaAudioToneObserver

    44 	virtual void MatoPrepareComplete(TInt aError);

    45 	virtual void MatoPlayComplete(TInt aError);

    46 

    47 protected:

    48 	TInt iError;

    49 	TInt iExpectedResult;

    50 	TInt iFrequency;

    51 	TBool iStop;

    52 	TTimeIntervalMicroSeconds iDuration;

    53 	};

    54 

    55 

    56 /**

    57  * Play a Dual tone

    58  *

    59  * @class CTestMmfAclntDualTone

    60  *

    61  */

    62 class CTestMmfAclntDualTone : public CTestMmfAclntTone

    63 	{

    64 public:

    65 	CTestMmfAclntDualTone(const TDesC& aTestName) ;

    66 	static CTestMmfAclntDualTone* NewL(const TDesC& aTestName);

    67 	virtual TVerdict DoTestStepL();

    68 

    69 protected:

    70 	TInt iFreqOne;

    71 	TInt iFreqTwo;

    72  	};

    73 

    74 

    75 /**

    76  * Play a DTMF string

    77  *

    78  * @class CTestMmfAclntToneDtmf

    79  *

    80  */

    81 class CTestMmfAclntToneDtmf : public CTestMmfAclntTone

    82 	{

    83 public:

    84 	CTestMmfAclntToneDtmf(const TDesC& aTestName,const TDesC& aDTMF,const TInt aExpectedResult=KErrNone) ;

    85 	static CTestMmfAclntToneDtmf* NewL(const TDesC& aTestName,const TDesC& aDTMF,const TInt aExpectedResult=KErrNone);

    86 	virtual TVerdict DoTestStepL();

    87 

    88 protected:

    89 	TBuf<KNameBufSize> iDTMF;

    90  	};

    91 

    92 

    93 /** 

    94  * Play a tone file

    95  *

    96  * @class CTestMmfAclntToneFile

    97  *

    98  */

    99 class CTestMmfAclntToneFile : public CTestMmfAclntTone

   100 	{

   101 public:

   102 	CTestMmfAclntToneFile(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) ;

   103 	static CTestMmfAclntToneFile* NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   104 	virtual TVerdict DoTestStepL();

   105 	virtual TVerdict DoTestStepPreambleL();

   106 

   107 protected:	

   108 	TInt iFrequency;

   109 	TBuf<KNameBufSize> iSectName;

   110 	TBuf<KNameBufSize> iKeyName;

   111 	};

   112 

   113 

   114 /**

   115  * Play a tone from a descriptor.

   116  *

   117  * @class CTestMmfAclntToneDes

   118  *

   119  */

   120 class CTestMmfAclntToneDes : public CTestMmfAclntTone 

   121 	{

   122 public:

   123 	CTestMmfAclntToneDes(const TDesC& aTestName, const TDesC8& aDes, const TInt aExpectedResult);

   124 	static CTestMmfAclntToneDes* NewL(const TDesC& aTestName, const TDesC8& aDes, const TInt aExpectedResult);

   125 	virtual TVerdict DoTestStepL();

   126 

   127 public:

   128 	const TDesC8& iDes;

   129 	} ;

   130 

   131 

   132 /**

   133  * Play a predefined/fixed tone

   134  *

   135  * @class CTestMmfAclntToneFixed

   136  *

   137  */

   138 class CTestMmfAclntToneFixed : public CTestMmfAclntTone 

   139 	{

   140 public:

   141 	CTestMmfAclntToneFixed(const TDesC& aTestName,const TInt aTone);

   142 	virtual TVerdict DoTestStepL();

   143 	static CTestMmfAclntToneFixed* NewL(const TDesC& aTestName,const TInt aTone);

   144 

   145 protected:

   146 	TInt iTone;

   147 	} ;

   148 

   149 

   150 /**

   151  * Playing a tone and playing an audio file.

   152  *

   153  * @class CTestMmfAclntToneAudio

   154  *

   155  */

   156 class CTestMmfAclntToneAudio : public CTestMmfAclntStep, public MMdaAudioToneObserver, public MMdaAudioPlayerCallback

   157 	{

   158 public:

   159 	CTestMmfAclntToneAudio() ;

   160 	virtual TVerdict DoTestStepL();

   161 	// From MMdaAudioToneObserver

   162 	virtual void MatoPrepareComplete(TInt aError);

   163 	virtual void MatoPlayComplete(TInt aError);

   164 	// from MMdaAudioPlayerCallback

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

   166     virtual void MapcPlayComplete(TInt aError);

   167 

   168 private:

   169 	TInt iPlayerError;

   170 	TInt iToneError;

   171 	TInt iCallbackCount;

   172 	};

   173 

   174 /**

   175  * Cancel tone play

   176  *

   177  * @class CTestMmfAclntToneCancelP

   178  *

   179  */

   180 class CTestMmfAclntToneCancelP : public CTestMmfAclntTone 

   181 	{

   182 public:

   183 	CTestMmfAclntToneCancelP(const TDesC& aTestName);

   184 	virtual TVerdict DoTestL(CMdaAudioToneUtility* aToneUtil);

   185 	static CTestMmfAclntToneCancelP* NewL(const TDesC& aTestName);

   186 	};

   187 

   188 /**

   189  * Cancel tone prepare.

   190  *

   191  * @class CTestMmfAclntToneCancelIni

   192  *

   193  */

   194 class CTestMmfAclntToneCancelIni : public CTestMmfAclntTone 

   195 	{

   196 public:

   197 	CTestMmfAclntToneCancelIni(const TDesC& aTestName);

   198 	virtual TVerdict DoTestStepL();

   199 	static CTestMmfAclntToneCancelIni* NewL(const TDesC& aTestName);

   200 	};

   201 

   202 /**

   203  * Enquire sequence name

   204  *

   205  * @class CTestMmfAclntToneNames

   206  *

   207  */

   208 class CTestMmfAclntToneNames : public CTestMmfAclntToneFixed

   209 	{

   210 public:

   211 	CTestMmfAclntToneNames(const TDesC& aTestName) ;

   212 	virtual TVerdict DoTestL(CMdaAudioToneUtility* aToneUtil);

   213 	static CTestMmfAclntToneNames* NewL(const TDesC& aTestName);

   214 	};

   215 

   216 /**

   217  * Enquire sequence count

   218  *

   219  * @class CTestMmfAclntToneCount

   220  *

   221  */

   222 class CTestMmfAclntToneCount : public CTestMmfAclntToneFixed

   223 	{

   224 public:

   225 	CTestMmfAclntToneCount(const TDesC& aTestName);

   226 	virtual TVerdict DoTestL(CMdaAudioToneUtility* aToneUtil);

   227 	static CTestMmfAclntToneCount* NewL(const TDesC& aTestName);

   228 	};

   229 

   230 /**

   231  * Set volume to max and enquire volume

   232  *

   233  * @class CTestMmfAclntToneVolume

   234  *

   235  */

   236 class CTestMmfAclntToneVolume : public CTestMmfAclntTone

   237 	{

   238 public:

   239 	CTestMmfAclntToneVolume(const TDesC& aTestName,const TInt aVolume) ;

   240 	virtual TVerdict DoTestL(CMdaAudioToneUtility* aToneUtil);

   241 	static CTestMmfAclntToneVolume* NewL(const TDesC& aTestName,const TInt aVolume);

   242 

   243 private:

   244 	TInt iVolume;

   245 	};

   246 

   247 /**

   248  * Set volume ramp

   249  *

   250  * @class CTestMmfAclntVolumeRamp

   251  *

   252  */

   253 class CTestMmfAclntVolumeRamp : public CTestMmfAclntTone

   254 	{

   255 public:

   256 	CTestMmfAclntVolumeRamp(const TDesC& aTestName, const TInt aRamp);

   257 	virtual TVerdict DoTestL(CMdaAudioToneUtility* aToneUtil);

   258 	static CTestMmfAclntVolumeRamp* NewL(const TDesC& aTestName, const TInt aRamp);

   259 

   260 private:

   261 	TInt iRamp;

   262 	};

   263 

   264 

   265 /**

   266  * Set repeats

   267  *

   268  * @class CTestMmfAclntToneRepeat

   269  *

   270  */

   271 class CTestMmfAclntToneRepeat : public CTestMmfAclntTone

   272 	{

   273 public:

   274 	CTestMmfAclntToneRepeat(const TDesC& aTestName) ;

   275 	virtual TVerdict DoTestL(CMdaAudioToneUtility* aToneUtil);

   276 	static CTestMmfAclntToneRepeat* NewL(const TDesC& aTestName);

   277 	};

   278 

   279 /**

   280  * Configure tone on length, tone of length, pause length of DTMF Tones

   281  *

   282  * @class CTestMmfAclntToneLength

   283  *

   284  */

   285 class CTestMmfAclntToneLength : public CTestMmfAclntToneDtmf

   286 	{

   287 public:

   288 	CTestMmfAclntToneLength(const TDesC& aTestName) ;

   289 	virtual TVerdict DoTestL(CMdaAudioToneUtility* aToneUtil);

   290 	static CTestMmfAclntToneLength* NewL(const TDesC& aTestName);

   291 	};

   292 

   293 /**

   294  * Set prioritys of tones

   295  *

   296  * @class CTestMmfAclntPriorityTones

   297  *

   298  */

   299 class CTestMmfAclntPriorityTones : public CTestMmfAclntStep, public MCallbackHandlerObserver

   300 	{

   301 public:

   302 	CTestMmfAclntPriorityTones() ;

   303 	virtual TVerdict DoTestStepL();

   304 	// MCallbackHandlerObserver

   305 	void MchoComplete(TInt aID, TInt aError);

   306 

   307 private:

   308 	CMdaAudioToneUtility* iToneUtil[2];

   309 	CToneCallbackHandler* iCallback[2];

   310 	TInt iCallbackCount;

   311 	TInt iFirstCallback;

   312 	TInt iFrequency;

   313 	TInt iError;

   314 	};

   315 

   316 /**

   317  * Set balance and enquire balance

   318  *

   319  * @class CTestMmfAclntToneBalance

   320  *

   321  */

   322 class CTestMmfAclntToneBalance : public CTestMmfAclntTone

   323 	{

   324 public:

   325 	CTestMmfAclntToneBalance(const TDesC& aTestName,const TInt aBalance) ;

   326 	virtual TVerdict DoTestL(CMdaAudioToneUtility* aToneUtil);

   327 	static CTestMmfAclntToneBalance* NewL(const TDesC& aTestName,const TInt aBalance);

   328 

   329 private:

   330 	TInt iBalance;

   331 	};

   332 

   333 //

   334 // NEGATIVE TESTS

   335 //

   336 

   337 

   338 /** 

   339  * Set up tone on, off and pause length to illegal values.

   340  *

   341  * @class CTestMM_MMF_ACLNT_I_1155_HP

   342  *

   343  */

   344 class CTestMmfAclntOnOffPause : public CTestMmfAclntStep, public MMdaAudioToneObserver

   345 	{

   346 public:

   347 	CTestMmfAclntOnOffPause() ;

   348 	virtual TVerdict DoTestStepL();

   349 // From MMdaAudioToneObserver

   350 public:

   351 	virtual void MatoPrepareComplete(TInt aError);

   352 	virtual void MatoPlayComplete(TInt aError);

   353 

   354 private:

   355 	TInt iFrequency;

   356 	TInt iError;

   357 	};

   358 

   359 

   360 #endif
Symaptic