|
1 /* |
|
2 * Copyright (c) 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: Telephony Multimedia Service - STIF TEST |
|
15 * |
|
16 */ |
|
17 |
|
18 // INCLUDE FILES |
|
19 #include <e32svr.h> |
|
20 #include <StifParser.h> |
|
21 #include <Stiftestinterface.h> |
|
22 #include "TmsAudioServicesTestClass.h" |
|
23 #include "debug.h" |
|
24 |
|
25 // ----------------------------------------------------------------------------- |
|
26 // CTmsAudioServicesTestClass::Delete |
|
27 // Delete here all resources allocated and opened from test methods. |
|
28 // Called from destructor. |
|
29 // ----------------------------------------------------------------------------- |
|
30 // |
|
31 void CTmsAudioServicesTestClass::Delete() |
|
32 { |
|
33 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::Delete"))); |
|
34 |
|
35 if (iFactory && iTmsBuffer) |
|
36 { |
|
37 iFactory->DeleteBuffer(iTmsBuffer); |
|
38 } |
|
39 if (iFactory && iTmsClientSource) |
|
40 { |
|
41 iFactory->DeleteSource(iTmsClientSource); |
|
42 } |
|
43 if (iFactory && iTmsModemSource) |
|
44 { |
|
45 iFactory->DeleteSource(iTmsModemSource); |
|
46 } |
|
47 if (iFactory && iTmsMicSource) |
|
48 { |
|
49 iFactory->DeleteSource(iTmsMicSource); |
|
50 } |
|
51 if (iFactory && iTmsClientSink) |
|
52 { |
|
53 iFactory->DeleteSink(iTmsClientSink); |
|
54 } |
|
55 if (iFactory && iTmsModemSink) |
|
56 { |
|
57 iFactory->DeleteSink(iTmsModemSink); |
|
58 } |
|
59 if (iFactory && iTmsSpkrSink) |
|
60 { |
|
61 iFactory->DeleteSink(iTmsSpkrSink); |
|
62 } |
|
63 if (iFactory && iTmsFormat) |
|
64 { |
|
65 iFactory->DeleteFormat(iTmsFormat); |
|
66 } |
|
67 if (iFactory && iTmsFormatUp) |
|
68 { |
|
69 iFactory->DeleteFormat(iTmsFormatUp); |
|
70 } |
|
71 if (iFactory && iTmsFormatDn) |
|
72 { |
|
73 iFactory->DeleteFormat(iTmsFormatDn); |
|
74 } |
|
75 if (iFactory && iTmsEffect) |
|
76 { |
|
77 iFactory->DeleteEffect(iTmsEffect); |
|
78 } |
|
79 if (iTmsUplink && iTmsCall) |
|
80 { |
|
81 iTmsCall->DeleteStream(iTmsUplink); |
|
82 } |
|
83 if (iTmsDnlink && iTmsCall) |
|
84 { |
|
85 iTmsCall->DeleteStream(iTmsDnlink); |
|
86 } |
|
87 if (iFactory && iTmsCall) |
|
88 { |
|
89 iFactory->DeleteCall(iTmsCall); |
|
90 } |
|
91 if (iFactory && iTmsDnlinkEffect) |
|
92 { |
|
93 iFactory->DeleteEffect(iTmsDnlinkEffect); |
|
94 } |
|
95 if (iFactory && iTmsUplinkEffect) |
|
96 { |
|
97 iFactory->DeleteEffect(iTmsUplinkEffect); |
|
98 } |
|
99 if (iFactory && iGlobalVol) |
|
100 { |
|
101 iFactory->DeleteEffect(iGlobalVol); |
|
102 } |
|
103 if (iFactory && iGlobalGain) |
|
104 { |
|
105 iFactory->DeleteEffect(iGlobalGain); |
|
106 } |
|
107 if (iFactory && iTmsGlobalRouting) |
|
108 { |
|
109 iFactory->DeleteGlobalRouting(iTmsGlobalRouting); |
|
110 } |
|
111 |
|
112 iExpectedEvents.Close(); |
|
113 iOcurredEvents.Close(); |
|
114 |
|
115 iLog->Log(_L("Deleti ng test class...")); |
|
116 iLog->Log(_L("")); |
|
117 iLog->Log(_L("")); |
|
118 |
|
119 // delete iPlayBuf; |
|
120 |
|
121 if (iTmsDnlink) |
|
122 { |
|
123 if (iDnLinkStatus != UNINITIALIZED) |
|
124 { |
|
125 iTmsDnlink->Deinit(); |
|
126 } |
|
127 delete iTmsDnlink; |
|
128 iTmsDnlink = NULL; |
|
129 } |
|
130 |
|
131 if (iTmsUplink) |
|
132 { |
|
133 if (iUpLinkStatus != UNINITIALIZED) |
|
134 { |
|
135 iTmsUplink->Deinit(); |
|
136 } |
|
137 delete iTmsUplink; |
|
138 iTmsUplink = NULL; |
|
139 } |
|
140 |
|
141 delete iFactory; |
|
142 } |
|
143 |
|
144 // ----------------------------------------------------------------------------- |
|
145 // CTmsAudioServicesTestClass::RunMethodL |
|
146 // Run specified method. Contains also table of test mothods and their names. |
|
147 // ----------------------------------------------------------------------------- |
|
148 // |
|
149 TInt CTmsAudioServicesTestClass::RunMethodL(CStifItemParser& aItem) |
|
150 { |
|
151 static TStifFunctionInfo const |
|
152 KFunctions[] = |
|
153 { |
|
154 // Copy this line for every implemented function. |
|
155 // First string is the function name used in TestScripter script file. |
|
156 // Second is the actual implementation member function. |
|
157 |
|
158 ENTRY( "SetTimeout", CTmsAudioServicesTestClass::SetTimeout ), |
|
159 ENTRY( "CreateFactory", CTmsAudioServicesTestClass::CreateTmsFactory ), |
|
160 ENTRY( "CreateCall", CTmsAudioServicesTestClass::CreateCall ), |
|
161 ENTRY( "CreateFormat", CTmsAudioServicesTestClass::CreateFormat ), |
|
162 ENTRY( "CreateBuffer", CTmsAudioServicesTestClass::CreateBuffer ), |
|
163 ENTRY( "CreateEffect", CTmsAudioServicesTestClass::CreateEffect ), |
|
164 ENTRY( "CreateGlobalRouting", CTmsAudioServicesTestClass::CreateGlobalRouting ), |
|
165 ENTRY( "CreateSource", CTmsAudioServicesTestClass::CreateSource ), |
|
166 ENTRY( "DeleteSource", CTmsAudioServicesTestClass::DeleteSource ), |
|
167 ENTRY( "CreateSink", CTmsAudioServicesTestClass::CreateSink ), |
|
168 ENTRY( "DeleteSink", CTmsAudioServicesTestClass::DeleteSink ), |
|
169 ENTRY( "GetSourceType", CTmsAudioServicesTestClass::GetSourceType ), |
|
170 ENTRY( "GetSinkType", CTmsAudioServicesTestClass::GetSinkType ), |
|
171 ENTRY( "GetEffectType", CTmsAudioServicesTestClass::GetEffectType ), |
|
172 ENTRY( "CreateDownlinkStream", CTmsAudioServicesTestClass::CreateDownlinkStream ), |
|
173 ENTRY( "CreateUplinkStream", CTmsAudioServicesTestClass::CreateUplinkStream ), |
|
174 ENTRY( "GetSupportedFormats", CTmsAudioServicesTestClass::GetSupportedFormats ), |
|
175 ENTRY( "IsCallTypeSupported", CTmsAudioServicesTestClass::IsCallTypeSupported ), |
|
176 ENTRY( "SetDownlinkFormat", CTmsAudioServicesTestClass::SetDownlinkFormat ), |
|
177 ENTRY( "SetUplinkFormat", CTmsAudioServicesTestClass::SetUplinkFormat ), |
|
178 ENTRY( "ReSetDownlinkFormat", CTmsAudioServicesTestClass::ReSetDownlinkFormat ), |
|
179 ENTRY( "ReSetUplinkFormat", CTmsAudioServicesTestClass::ReSetUplinkFormat ), |
|
180 ENTRY( "OpenDownlink", CTmsAudioServicesTestClass::OpenDownlink ), |
|
181 ENTRY( "OpenUplink", CTmsAudioServicesTestClass::OpenUplink ), |
|
182 ENTRY( "Gain", CTmsAudioServicesTestClass::Gain ), |
|
183 ENTRY( "AddGlobleGainEffectToStream", CTmsAudioServicesTestClass::AddGlobleGainEffectToStream), |
|
184 ENTRY( "RemoveGlobleGainEffectToStream", CTmsAudioServicesTestClass::RemoveGlobleGainEffectToStream), |
|
185 ENTRY( "Volume", CTmsAudioServicesTestClass::Volume ), |
|
186 ENTRY( "AddGlobleVolumeEffectToStream", CTmsAudioServicesTestClass::AddGlobleVolumeEffectToStream), |
|
187 ENTRY( "RemoveGlobleVolumeEffectToStream", CTmsAudioServicesTestClass::RemoveGlobleVolumeEffectToStream), |
|
188 ENTRY( "CreateGlobleGainEffect", CTmsAudioServicesTestClass::CreateGlobleGainEffect), |
|
189 ENTRY( "Close", CTmsAudioServicesTestClass::Close ), |
|
190 ENTRY( "Start", CTmsAudioServicesTestClass::Start ), |
|
191 ENTRY( "Pause", CTmsAudioServicesTestClass::Pause ), |
|
192 ENTRY( "Stop", CTmsAudioServicesTestClass::Stop ), |
|
193 ENTRY( "GetBitRateList", CTmsAudioServicesTestClass::GetBitRateList ), |
|
194 ENTRY( "SetBitrates", CTmsAudioServicesTestClass::SetBitrates ), |
|
195 ENTRY( "GetBitrates", CTmsAudioServicesTestClass::GetBitrates ), |
|
196 ENTRY( "GetDownlinkVersion", CTmsAudioServicesTestClass::GetDownlinkVersion ), |
|
197 ENTRY( "GetUplinkVersion", CTmsAudioServicesTestClass::GetUplinkVersion ), |
|
198 ENTRY( "GetType", CTmsAudioServicesTestClass::GetType ), |
|
199 ENTRY( "GetVAD", CTmsAudioServicesTestClass::GetVAD ), |
|
200 ENTRY( "ToggleVAD", CTmsAudioServicesTestClass::ToggleVAD ), |
|
201 ENTRY( "GetMode", CTmsAudioServicesTestClass::GetMode ), |
|
202 ENTRY( "SetMode", CTmsAudioServicesTestClass::SetMode ), |
|
203 ENTRY( "GetCNG", CTmsAudioServicesTestClass::GetCNG ), |
|
204 ENTRY( "ToggleCNG", CTmsAudioServicesTestClass::ToggleCNG ), |
|
205 ENTRY( "GetPLC", CTmsAudioServicesTestClass::GetPLC ), |
|
206 ENTRY( "TogglePLC", CTmsAudioServicesTestClass::TogglePLC ), |
|
207 ENTRY( "GetBufferType", CTmsAudioServicesTestClass::GetBufferType ), |
|
208 ENTRY( "AddClientSrcToDnlStream", CTmsAudioServicesTestClass::AddClientSrcToDnlStream ), |
|
209 ENTRY( "AddMicSrcToUplStream", CTmsAudioServicesTestClass::AddMicSrcToUplStream ), |
|
210 ENTRY( "AddModemSrcToDnlStream", CTmsAudioServicesTestClass::AddModemSrcToDnlStream ), |
|
211 ENTRY( "RemoveClientSrcFromDnlStream", CTmsAudioServicesTestClass::RemoveClientSrcFromDnlStream ), |
|
212 ENTRY( "RemoveMicSrcFromUplStream", CTmsAudioServicesTestClass::RemoveMicSrcFromUplStream ), |
|
213 ENTRY( "RemoveModemSrcFromDnlStream", CTmsAudioServicesTestClass::RemoveModemSrcFromDnlStream ), |
|
214 ENTRY( "AddSourceObserver", CTmsAudioServicesTestClass::AddSourceObserver ), |
|
215 ENTRY( "RemoveSourceObserver", CTmsAudioServicesTestClass::RemoveSourceObserver ), |
|
216 ENTRY( "AddClientSinkToUplStream", CTmsAudioServicesTestClass::AddClientSinkToUplStream ), |
|
217 ENTRY( "AddModemSinkToUplStream", CTmsAudioServicesTestClass::AddModemSinkToUplStream ), |
|
218 ENTRY( "AddSpkrSinkToDnlStream", CTmsAudioServicesTestClass::AddSpkrSinkToDnlStream ), |
|
219 ENTRY( "RemoveClientSinkFromUplStream", CTmsAudioServicesTestClass::RemoveClientSinkFromUplStream ), |
|
220 ENTRY( "RemoveModemSinkFromUplStream", CTmsAudioServicesTestClass::RemoveModemSinkFromUplStream ), |
|
221 ENTRY( "RemoveSpkrSinkFromDnlStream", CTmsAudioServicesTestClass::RemoveSpkrSinkFromDnlStream ), |
|
222 ENTRY( "AddSinkObserver", CTmsAudioServicesTestClass::AddSinkObserver ), |
|
223 ENTRY( "RemoveSinkObserver", CTmsAudioServicesTestClass::RemoveSinkObserver ), |
|
224 ENTRY( "GetStreamType", CTmsAudioServicesTestClass::GetStreamType ), |
|
225 ENTRY( "GetStreamState", CTmsAudioServicesTestClass::GetStreamState ), |
|
226 ENTRY( "SetOutput", CTmsAudioServicesTestClass::SetOutput ), |
|
227 ENTRY( "GetOutput", CTmsAudioServicesTestClass::GetOutput ), |
|
228 ENTRY( "GetPreviousOutput", CTmsAudioServicesTestClass::GetPreviousOutput ), |
|
229 ENTRY( "GetAvailableOutputs", CTmsAudioServicesTestClass::GetAvailableOutputs ), |
|
230 ENTRY( "AddGlobalRoutingObserver", CTmsAudioServicesTestClass::AddGlobalRoutingObserver ), |
|
231 ENTRY( "DeleteGlobalRoutingObserver", CTmsAudioServicesTestClass::DeleteGlobalRoutingObserver ), |
|
232 ENTRY( "Example", CTmsAudioServicesTestClass::ExampleL ) |
|
233 }; |
|
234 |
|
235 const TInt count = sizeof(KFunctions) / sizeof(TStifFunctionInfo); |
|
236 return RunInternalL(KFunctions, count, aItem); |
|
237 } |
|
238 |
|
239 // ----------------------------------------------------------------------------- |
|
240 // CTmsAudioServicesTestClass::EventName |
|
241 // Return descriptor with the notification description |
|
242 // ----------------------------------------------------------------------------- |
|
243 TPtrC CTmsAudioServicesTestClass::EventName(TInt aKey) |
|
244 { |
|
245 static TText* const badKeyword = (TText*) L"BadKeyword"; |
|
246 static TText* const keywords[] = |
|
247 { |
|
248 (TText*)L"EOpenDownlinkComplete", |
|
249 (TText*)L"EOpenUplinkComplete", |
|
250 (TText*)L"EDownlinkClosed", |
|
251 (TText*)L"EUplinkClosed", |
|
252 (TText*)L"EOpenCompleteDNL", |
|
253 (TText*)L"EOpenCompleteUPL", |
|
254 (TText*)L"EStreamPaused", |
|
255 (TText*)L"EStreamStarted", |
|
256 (TText*)L"EOpenComplete", |
|
257 (TText*)L"EPlaybackComplete", |
|
258 (TText*)L"EEmptyBuffer", |
|
259 (TText*)L"EFillBuffer", |
|
260 (TText*)L"EOutputChanged", |
|
261 (TText*)L"ESetOutputComplete", |
|
262 }; |
|
263 |
|
264 if( (TUint)aKey >= (sizeof( keywords )/sizeof(TText*)) ) |
|
265 { |
|
266 iLog->Log(_L("Keyword out of bounds")); |
|
267 TPtrC keyword( badKeyword ); |
|
268 return keyword; |
|
269 } |
|
270 else |
|
271 { |
|
272 TPtrC keyword( keywords[aKey] ); |
|
273 return keyword; |
|
274 } |
|
275 } |
|
276 |
|
277 // ----------------------------------------------------------------------------- |
|
278 // CTmsAudioServicesTestClass::AddExpectedEvent |
|
279 // Add an event to the expected events' list |
|
280 // ----------------------------------------------------------------------------- |
|
281 void CTmsAudioServicesTestClass::AddExpectedEvent(TTmsExpectedEvent event, |
|
282 TInt ms) |
|
283 { |
|
284 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::AddExpectedEvent"))); |
|
285 iExpectedEvents.Append(event); |
|
286 TPtrC eventName = EventName(event); |
|
287 iLog->Log(_L("Adding expected event:(0x%02x)%S Total=%d"), event, |
|
288 &eventName, iExpectedEvents.Count()); |
|
289 |
|
290 if (iTimeoutController && !iTimeoutController->IsActive()) |
|
291 { |
|
292 if (ms > 0) |
|
293 { |
|
294 iTimeoutController->Start(TTimeIntervalMicroSeconds(ms * 1000)); |
|
295 } |
|
296 else |
|
297 { |
|
298 iLog->Log(_L("Timeout with default value (1s)")); |
|
299 iTimeoutController->Start(TTimeIntervalMicroSeconds(1000000)); |
|
300 } |
|
301 } |
|
302 } |
|
303 |
|
304 // ----------------------------------------------------------------------------- |
|
305 // CTmsAudioServicesTestClass::RemoveExpectedEvent |
|
306 // Remove the indicated event from the expected events' list |
|
307 // ----------------------------------------------------------------------------- |
|
308 TBool CTmsAudioServicesTestClass::RemoveExpectedEvent( |
|
309 TTmsExpectedEvent aEvent) |
|
310 { |
|
311 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::RemoveExpectedEvent"))); |
|
312 iLog->Log(_L("CTmsAudioServicesTestClass::RemoveExpectedEvent")); |
|
313 TBool match = EFalse; |
|
314 for (TUint i = 0; i < iExpectedEvents.Count(); i++) |
|
315 { |
|
316 if (iExpectedEvents[i] == aEvent) |
|
317 { |
|
318 iLog->Log(_L("Expeted events: %d"), iExpectedEvents.Count()); |
|
319 iExpectedEvents.Remove(i); |
|
320 match = ETrue; |
|
321 break; |
|
322 } |
|
323 } |
|
324 return match; |
|
325 } |
|
326 |
|
327 // ----------------------------------------------------------------------------- |
|
328 // CTmsAudioServicesTestClass::RemoveAllExpectedEvents |
|
329 // Remove the indicated event from the expected events' list |
|
330 // ----------------------------------------------------------------------------- |
|
331 void CTmsAudioServicesTestClass::RemoveAllExpectedEvents() |
|
332 { |
|
333 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::RemoveAllExpectedEvents"))); |
|
334 iLog->Log(_L("Removing all expected events")); |
|
335 iExpectedEvents.Reset(); |
|
336 iOcurredEvents.Reset(); |
|
337 } |
|
338 |
|
339 // ----------------------------------------------------------------------------- |
|
340 // CTmsAudioServicesTestClass::ProcessEvent |
|
341 // ----------------------------------------------------------------------------- |
|
342 void CTmsAudioServicesTestClass::ProcessEvent(TTmsExpectedEvent aEvent, |
|
343 TInt aError) |
|
344 { |
|
345 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::ProcessExpectedEvent"))); |
|
346 iLog->Log(_L("CTmsAudioServicesTestClass:: ProcessExpectedEvent")); |
|
347 TPtrC nameEvent = EventName(aEvent); |
|
348 |
|
349 if (aError == KErrNone) |
|
350 { |
|
351 if (RemoveExpectedEvent(aEvent)) |
|
352 { |
|
353 iLog->Log(_L("Expected Event: (0x%02x)%S has ocurred Total=%d"), |
|
354 aEvent, &nameEvent, iExpectedEvents.Count()); |
|
355 } |
|
356 else |
|
357 { |
|
358 iLog->Log(_L("Event: (0x%02x)%S has ocurred"), aEvent, &nameEvent); |
|
359 return; |
|
360 } |
|
361 |
|
362 if (iExpectedEvents.Count() == 0) |
|
363 { |
|
364 Signal(); |
|
365 iTimeoutController->Cancel(); |
|
366 } |
|
367 |
|
368 } |
|
369 else |
|
370 { |
|
371 iLog->Log(_L("[Error] Event: (0x%02x)%S return with error code=%d"), |
|
372 aEvent, &nameEvent, aError); |
|
373 if (iExpectedEvents.Count() != 0) |
|
374 { |
|
375 RemoveExpectedEvent(aEvent); |
|
376 } |
|
377 iTimeoutController->Cancel(); |
|
378 Signal(KErrCallbackErrorCode); |
|
379 } |
|
380 } |
|
381 |
|
382 // ----------------------------------------------------------------------------- |
|
383 // CTmsAudioServicesTestClass::HandleTimeout |
|
384 // Review if all the expected events have ocurred once the time is over |
|
385 // ----------------------------------------------------------------------------- |
|
386 |
|
387 void CTmsAudioServicesTestClass::HandleTimeout(TInt aError) |
|
388 { |
|
389 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::HandleTimeout"))); |
|
390 |
|
391 if (aError != KErrNone) |
|
392 { |
|
393 if (iExpectedEvents.Count() == 0) |
|
394 { |
|
395 iLog->Log(_L("Timing out but events have ocurred")); |
|
396 Signal(); |
|
397 } |
|
398 else |
|
399 { |
|
400 RemoveAllExpectedEvents(); |
|
401 iLog->Log(_L("Timing out and events still pending")); |
|
402 Signal(KErrEventPending); |
|
403 } |
|
404 } |
|
405 else |
|
406 { |
|
407 iLog->Log(_L("Timing out return a error %d"), aError); |
|
408 Signal(aError); |
|
409 } |
|
410 } |
|
411 |
|
412 // ----------------------------------------------------------------------------- |
|
413 // CTmsAudioServicesTestClass::SetTimeout |
|
414 // Create a timer and set a timeout |
|
415 // When the timeout is reached the test case is marked as failed |
|
416 // It's used rather than the "timeout" keyword in the configuration file |
|
417 // because in this way the log continues |
|
418 // ----------------------------------------------------------------------------- |
|
419 TInt CTmsAudioServicesTestClass::SetTimeout(CStifItemParser& aItem) |
|
420 { |
|
421 FTRACE (FPrint(_L("CTmsAudioServicesTestClass::SetTimeout"))); |
|
422 TInt timeout = 0; |
|
423 TInt error = aItem.GetNextInt(timeout); |
|
424 if (iTimeoutController) |
|
425 { |
|
426 if (timeout > 0) |
|
427 { |
|
428 iTimeoutController->Start(TTimeIntervalMicroSeconds(timeout |
|
429 * 1000)); |
|
430 } |
|
431 else |
|
432 { |
|
433 iTimeoutController->Start(TTimeIntervalMicroSeconds(1000000)); |
|
434 } |
|
435 } |
|
436 else |
|
437 { |
|
438 iLog->Log(_L("Timeout Controller doesn't exist")); |
|
439 error = KErrTimeoutController; |
|
440 } |
|
441 |
|
442 return error; |
|
443 } |
|
444 |
|
445 // ----------------------------------------------------------------------------- |
|
446 // Uses the TestModuleBase API to allow a panic as exit reason for a test case |
|
447 // ----------------------------------------------------------------------------- |
|
448 TInt CTmsAudioServicesTestClass::SetAllowedPanic(CStifItemParser& aItem) |
|
449 { |
|
450 FTRACE (FPrint(_L("CTmsAudioServicesTestClass::SetAllowedPanic"))); |
|
451 TInt error = KErrNone; |
|
452 TInt panicCode; |
|
453 TPtrC panicType; |
|
454 if ((KErrNone == aItem.GetNextString(panicType)) && |
|
455 (KErrNone == aItem.GetNextInt(panicCode))) |
|
456 { |
|
457 iLog->Log(_L("Allowing panic: %S %d"), &panicType, panicCode); |
|
458 // iTestModuleIf.SetExitReason( CTestModuleIf::EPanic, panicCode ); |
|
459 iNormalExitReason = EFalse; |
|
460 } |
|
461 else |
|
462 { |
|
463 iLog->Log(KMsgBadTestParameters); |
|
464 error = KErrBadTestParameter; |
|
465 } |
|
466 return error; |
|
467 } |
|
468 |
|
469 // ----------------------------------------------------------------------------- |
|
470 // CTmsAudioServicesTestClass::SetExpectedEvents() |
|
471 // ----------------------------------------------------------------------------- |
|
472 TInt CTmsAudioServicesTestClass::SetExpectedEvents(CStifItemParser& aItem) |
|
473 { |
|
474 FTRACE (FPrint(_L("CTmsAudioServicesTestClass::SetExpectedEvents"))); |
|
475 TInt error = KErrNone; |
|
476 TInt event = 0; |
|
477 while (KErrNone == aItem.GetNextInt(event)) |
|
478 { |
|
479 AddExpectedEvent(static_cast<TTmsExpectedEvent> (event), 0); // Default timeout value |
|
480 } |
|
481 return error; |
|
482 } |
|
483 |
|
484 // ----------------------------------------------------------------------------- |
|
485 // CTmsAudioServicesTestClass::ExampleL |
|
486 // Example test method function. |
|
487 // (other items were commented in a header). |
|
488 // ----------------------------------------------------------------------------- |
|
489 // |
|
490 TInt CTmsAudioServicesTestClass::ExampleL(CStifItemParser& aItem) |
|
491 { |
|
492 // Print to UI |
|
493 _LIT( KTmsAudioServicesTestClass, "TmsAudioServicesTestClass" ); |
|
494 _LIT( KExample, "In Example" ); |
|
495 TestModuleIf().Printf(0, KTmsAudioServicesTestClass, KExample); |
|
496 // Print to log file |
|
497 iLog->Log(KExample); |
|
498 |
|
499 TInt i = 0; |
|
500 TPtrC string; |
|
501 _LIT( KParam, "Param[%i]: %S" ); |
|
502 while (aItem.GetNextString(string) == KErrNone) |
|
503 { |
|
504 TestModuleIf().Printf(i, KTmsAudioServicesTestClass, KParam, i, |
|
505 &string); |
|
506 i++; |
|
507 } |
|
508 return KErrNone; |
|
509 } |
|
510 |
|
511 TInt CTmsAudioServicesTestClass::CreateTmsFactory(CStifItemParser& /*aItem */) |
|
512 { |
|
513 RDebug::Printf("CTmsAudioServicesTestClass::CreateTmsFactory >> ENTER"); |
|
514 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::CreateFactory"))); |
|
515 iLog->Log(_L("CTmsAudioServicesTestClass::CreateFactory")); |
|
516 TInt error = KErrNone; |
|
517 |
|
518 TMSVer* v = NULL;//not defined yet |
|
519 error = TMSFactory::CreateFactory(iFactory, *v); |
|
520 RDebug::Printf("[TMS STIF] TMSFactory::CreateFactory Return [%d]", error); |
|
521 RDebug::Printf("CTmsAudioServicesTestClass::CreateTmsFactory << EXIT"); |
|
522 return error; |
|
523 } |
|
524 |
|
525 TInt CTmsAudioServicesTestClass::CreateCall(CStifItemParser& aItem) |
|
526 { |
|
527 iLog->Log(_L("CTmsAudioServicesTestClass::CreateCall")); |
|
528 TInt error = KErrNone; |
|
529 TInt calltype; |
|
530 aItem.GetNextInt(calltype); |
|
531 |
|
532 if (iFactory && !iTmsCall) |
|
533 { |
|
534 switch (calltype) |
|
535 { |
|
536 case TMS_CALL_CS: |
|
537 case TMS_CALL_ECS: |
|
538 case TMS_CALL_IP: |
|
539 { |
|
540 error = iFactory->CreateCall(calltype, iTmsCall, 0); |
|
541 iLog->Log( |
|
542 _L("CTmsAudioServicesTestClass::CreateCall, error [%d]"), |
|
543 error); |
|
544 } |
|
545 break; |
|
546 default: |
|
547 error = KErrNotSupported; |
|
548 break; |
|
549 } |
|
550 } |
|
551 RDebug::Printf("[TMS STIF] TMSFactory::CreateCall Return [%d]", error); |
|
552 return error; |
|
553 } |
|
554 |
|
555 TInt CTmsAudioServicesTestClass::CreateFormat(CStifItemParser& aItem) |
|
556 { |
|
557 iLog->Log(_L("CTmsAudioServicesTestClass::CreateFormat")); |
|
558 TInt error = KErrNone; |
|
559 TMSFormatType format; |
|
560 TPtrC StreamType; |
|
561 TPtrC formatType; |
|
562 |
|
563 // error = aItem.GetNextInt(formattype); |
|
564 error = aItem.GetNextString(formatType); |
|
565 |
|
566 if (error == KErrNone) |
|
567 { |
|
568 error = aItem.GetNextString(StreamType); |
|
569 |
|
570 if (iFactory && !iTmsFormat) |
|
571 { |
|
572 iLog ->Log( |
|
573 _L("CTmsAudioServicesTestClass::CreateFormat - input format")); |
|
574 |
|
575 if (formatType == KTagG711) |
|
576 { |
|
577 format = TMS_FORMAT_G711; |
|
578 iLog->Log( |
|
579 _L("CTmsAudioServicesTestClass::CreateFormat - input format TMS_FORMAT_G711")); |
|
580 } |
|
581 else if (formatType == KTagG729) |
|
582 { |
|
583 format = TMS_FORMAT_G729; |
|
584 iLog->Log( |
|
585 _L("CTmsAudioServicesTestClass::CreateFormat - input format TMS_FO RMAT_G729")); |
|
586 } |
|
587 else if (formatType == KTagILBC) |
|
588 { |
|
589 format = TMS_FORMAT_ILBC; |
|
590 iLog->Log( |
|
591 _L("CTmsAudioServicesTestClass::CreateFormat - input format TMS_FORMAT_ILBC")); |
|
592 } |
|
593 else if (formatType == KTagAMRNB) |
|
594 { |
|
595 format = TMS_FORMAT_AMR; |
|
596 iLog->Log( |
|
597 _L("CTmsAudioServicesTestClass::CreateFormat - input format TMS_FORMAT_AMR")); |
|
598 } |
|
599 else if (formatType == KTagPCM16) |
|
600 { |
|
601 format = TMS_FORMAT_PCM; |
|
602 iLog->Log( |
|
603 _L("CTmsAudioServicesTestClass::CreateFormat - input format TMS_FORMAT_PCM")); |
|
604 } |
|
605 else |
|
606 { |
|
607 iLog->Log( |
|
608 _L("CTmsAudioServicesTestClass::CreateFormat failed, format not supported")); |
|
609 error = KErrNotSupported; |
|
610 return error; |
|
611 } |
|
612 |
|
613 if (StreamType == KTagDnlink) |
|
614 { |
|
615 iLog ->Log( |
|
616 _L("CTmsAudioServicesTestClass::CreateFormat - iTmsFormatDn")); |
|
617 error = iFactory->CreateFormat(format, iTmsFormatDn); |
|
618 iDnLinkCodec = format; |
|
619 } |
|
620 else if (StreamType == KTagUplink) |
|
621 { |
|
622 iLog->Log( |
|
623 _L("CTmsAudioServicesTestClass::CreateFormat - iTmsFormatUp")); |
|
624 error = iFactory->CreateFormat(format, iTmsFormatUp); |
|
625 iUpLinkCodec = format; |
|
626 } |
|
627 else |
|
628 { |
|
629 error = iFactory->CreateFormat(format, iTmsFormat); |
|
630 } |
|
631 } |
|
632 else |
|
633 { |
|
634 error = KErrNotSupported; |
|
635 } |
|
636 } |
|
637 |
|
638 return error; |
|
639 } |
|
640 |
|
641 TInt CTmsAudioServicesTestClass::CreateBuffer(CStifItemParser& aItem) |
|
642 { |
|
643 FTRACE (FPrint(_L("CTmsAudioServicesTestClass::CreateBuffer"))); |
|
644 iLog->Log(_L("CTmsAudioServicesTestClass::CreateBuffer")); |
|
645 TInt error = KErrNone; |
|
646 TInt size = 0; |
|
647 TInt buffertype; |
|
648 |
|
649 aItem.GetNextInt(buffertype); |
|
650 aItem.GetNextInt(size); |
|
651 |
|
652 if (iFactory && !iTmsBuffer) |
|
653 { |
|
654 switch (buffertype) |
|
655 { |
|
656 case TMS_BUFFER_MEMORY: |
|
657 { |
|
658 error = iFactory->CreateBuffer(buffertype, size, iTmsBuffer); |
|
659 } |
|
660 break; |
|
661 default: |
|
662 error = KErrNotSupported; |
|
663 break; |
|
664 } |
|
665 } |
|
666 |
|
667 return error; |
|
668 } |
|
669 |
|
670 TInt CTmsAudioServicesTestClass::CreateEffect(CStifItemParser& aItem) |
|
671 { |
|
672 iLog->Log(_L("CTmsAudioServicesTestClass::CreateEffect")); |
|
673 TInt error = KErrNone; |
|
674 TInt effecttype; |
|
675 |
|
676 aItem.GetNextInt(effecttype); |
|
677 |
|
678 if (iFactory) |
|
679 { |
|
680 switch (effecttype) |
|
681 { |
|
682 case TMS_EFFECT_VOLUME: |
|
683 { |
|
684 error = CreateVolumeEffect(); |
|
685 // AddVolumeEffectToStream(); |
|
686 } |
|
687 break; |
|
688 case TMS_EFFECT_GLOBAL_VOL: |
|
689 { |
|
690 error = CreateVolumeGlobleEffect(); |
|
691 // AddGlobleVolumeEffectToStream(); |
|
692 } |
|
693 break; |
|
694 case TMS_EFFECT_GAIN: |
|
695 { |
|
696 error = CreateGainEffect(); |
|
697 // AddGainEffectToStream(); |
|
698 } |
|
699 break; |
|
700 case TMS_EFFECT_GLOBAL_GAIN: |
|
701 { |
|
702 error = CreateGlobleGainEffect(); |
|
703 // AddGlobleGainEffectToStream(); |
|
704 } |
|
705 break; |
|
706 default: |
|
707 error = KErrNotSupported; |
|
708 break; |
|
709 } |
|
710 } |
|
711 RDebug::Printf("[TMS STIF] CreateEffect Return [%d]", error); |
|
712 return error; |
|
713 } |
|
714 |
|
715 TInt CTmsAudioServicesTestClass::CreateGlobalRouting(CStifItemParser& /*aItem*/) |
|
716 { |
|
717 iLog->Log(_L("CTmsAudioServicesTestClass::CreateGlobalRouting")); |
|
718 TInt error = KErrNone; |
|
719 if (iFactory) |
|
720 { |
|
721 error = iFactory->CreateGlobalRouting(iTmsGlobalRouting); |
|
722 } |
|
723 else |
|
724 { |
|
725 error = KErrNotReady; |
|
726 iLog->Log( |
|
727 _L("CTmsAudioServicesTestClass::CreateGlobalRouting - Need create TMSFactory first" )); |
|
728 } |
|
729 return error; |
|
730 |
|
731 } |
|
732 |
|
733 TInt CTmsAudioServicesTestClass::CreateSource(CStifItemParser& aItem) |
|
734 { |
|
735 iLog ->Log(_L("CTmsAudioServicesTestClass::CreateSource")); |
|
736 TInt error = KErrNone; |
|
737 TInt sourcetype; |
|
738 |
|
739 aItem.GetNextInt(sourcetype); |
|
740 |
|
741 if (iFactory) |
|
742 { |
|
743 switch (sourcetype) |
|
744 { |
|
745 case TMS_SOURCE_CLIENT: |
|
746 { |
|
747 error = iFactory->CreateSource((TMSSourceType) sourcetype, |
|
748 iTmsClientSource); |
|
749 } |
|
750 break; |
|
751 case TMS_SOURCE_MODEM: |
|
752 { |
|
753 error = iFactory->CreateSource((TMSSourceType) sourcetype, |
|
754 iTmsModemSource); |
|
755 } |
|
756 break; |
|
757 case TMS_SOURCE_MIC: |
|
758 { |
|
759 error = iFactory->CreateSource((TMSSourceType) sourcetype, |
|
760 iTmsMicSource); |
|
761 } |
|
762 break; |
|
763 default: |
|
764 error = KErrNotSupported; |
|
765 break; |
|
766 } |
|
767 } |
|
768 return error; |
|
769 } |
|
770 |
|
771 TInt CTmsAudioServicesTestClass::CreateSink(CStifItemParser& aItem) |
|
772 { |
|
773 iLog->Log(_L("CTmsAudioServicesTestClass::CreateSink")); |
|
774 TInt error = KErrNone; |
|
775 TInt sinktype; |
|
776 |
|
777 aItem.GetNextInt(sinktype); |
|
778 |
|
779 if (iFactory) |
|
780 { |
|
781 switch (sinktype) |
|
782 { |
|
783 case TMS_SINK_CLIENT: |
|
784 { |
|
785 error = iFactory->CreateSink((TMSSinkType) sinktype, |
|
786 iTmsClientSink); |
|
787 } |
|
788 break; |
|
789 case TMS_SINK_MODEM: |
|
790 { |
|
791 error = iFactory->CreateSink((TMSSinkType) sinktype, |
|
792 iTmsModemSink); |
|
793 } |
|
794 break; |
|
795 case TMS_SINK_SPEAKER: |
|
796 { |
|
797 error = iFactory->CreateSink((TMSSinkType) sinktype, |
|
798 iTmsSpkrSink); |
|
799 } |
|
800 break; |
|
801 default: |
|
802 error = TMS_RESULT_SINK_TYPE_NOT_SUPPORTED; |
|
803 break; |
|
804 } |
|
805 } |
|
806 return error; |
|
807 } |
|
808 |
|
809 TInt CTmsAudioServicesTestClass::GetSourceType(CStifItemParser& aItem) |
|
810 { |
|
811 iLog->Log(_L("CTmsAudioServicesTestClass::GetSourceType")); |
|
812 TInt error = KErrNone; |
|
813 TInt sourcetype; |
|
814 TMSSourceType itSourceType; |
|
815 aItem.GetNextInt(sourcetype); |
|
816 |
|
817 if (iFactory) |
|
818 { |
|
819 switch (sourcetype) |
|
820 { |
|
821 case TMS_SOURCE_CLIENT: |
|
822 { |
|
823 if (iTmsClientSource) |
|
824 { |
|
825 error = iTmsClientSource->GetType(itSourceType); |
|
826 } |
|
827 } |
|
828 break; |
|
829 case TMS_SOURCE_MODEM: |
|
830 { |
|
831 if (iTmsModemSource) |
|
832 { |
|
833 error = iTmsModemSource->GetType(itSourceType); |
|
834 } |
|
835 } |
|
836 break; |
|
837 case TMS_SOURCE_MIC: |
|
838 { |
|
839 if (iTmsMicSource) |
|
840 { |
|
841 error = iTmsMicSource->GetType(itSourceType); |
|
842 } |
|
843 } |
|
844 break; |
|
845 default: |
|
846 error = KErrNotSupported; |
|
847 break; |
|
848 } |
|
849 } |
|
850 if (error != KErrNone) |
|
851 { |
|
852 iLog->Log(_L("GetType return error [%d]"), error); |
|
853 return error; |
|
854 } |
|
855 |
|
856 if (itSourceType != sourcetype) |
|
857 { |
|
858 iLog->Log( |
|
859 _L("returned souece type is not same as expected, returned sourcetype :[%d]"), |
|
860 itSourceType); |
|
861 error = KErrUnexpectedValue; |
|
862 } |
|
863 return error; |
|
864 } |
|
865 |
|
866 TInt CTmsAudioServicesTestClass::GetSinkType(CStifItemParser& aItem) |
|
867 { |
|
868 iLog->Log(_L("CTmsAudioServicesTestClass::GetSinkType")); |
|
869 TInt error = KErrNone; |
|
870 TInt sinktype; |
|
871 TMSSinkType itSinkType; |
|
872 aItem.GetNextInt(sinktype); |
|
873 |
|
874 if (iFactory) |
|
875 { |
|
876 switch (sinktype) |
|
877 { |
|
878 case TMS_SINK_CLIENT: |
|
879 { |
|
880 if (iTmsClientSink) |
|
881 error = iTmsClientSink->GetType(itSinkType); |
|
882 } |
|
883 break; |
|
884 case TMS_SINK_MODEM: |
|
885 { |
|
886 if (iTmsModemSink) |
|
887 error = iTmsModemSink->GetType(itSinkType); |
|
888 } |
|
889 break; |
|
890 case TMS_SINK_SPEAKER: |
|
891 { |
|
892 if (iTmsSpkrSink) |
|
893 error = iTmsSpkrSink->GetType(itSinkType); |
|
894 } |
|
895 break; |
|
896 default: |
|
897 error = TMS_RESULT_SINK_TYPE_NOT_SUPPORTED; |
|
898 break; |
|
899 } |
|
900 |
|
901 if (itSinkType != sinktype) |
|
902 { |
|
903 iLog->Log( |
|
904 _L("retur ned sink type is not sameas expected, returned sinktype :[%d]"), |
|
905 itSinkType); |
|
906 error = KErrUnexpectedValue; |
|
907 } |
|
908 } |
|
909 |
|
910 if (error != KErrNone) |
|
911 { |
|
912 iLog->Log(_L("GetType return error [%d]"), error); |
|
913 return error; |
|
914 } |
|
915 return error; |
|
916 } |
|
917 |
|
918 TInt CTmsAudioServicesTestClass::GetEffectType(CStifItemParser& aItem) |
|
919 { |
|
920 iLog->Log(_L("CTmsAudioServicesTestClass::GetEffectType")); |
|
921 TInt error = KErrNone; |
|
922 |
|
923 TInt effecttype; |
|
924 TMSEffectType itEffectType; |
|
925 aItem.GetNextInt(effecttype); |
|
926 |
|
927 if (iFactory) |
|
928 { |
|
929 switch (effecttype) |
|
930 { |
|
931 case TMS_EFFECT_VOLUME: |
|
932 { |
|
933 if (iTmsDnlink && iTmsDnlinkEffect) |
|
934 error = iTmsDnlinkEffect->GetType(itEffectType); |
|
935 } |
|
936 break; |
|
937 case TMS_EFFECT_GLOBAL_VOL: |
|
938 { |
|
939 if (iGlobalVol) |
|
940 error = iGlobalVol->GetType(itEffectType); |
|
941 } |
|
942 break; |
|
943 case TMS_EFFECT_GAIN: |
|
944 { |
|
945 if (iTmsUplink && iTmsUplinkEffect) |
|
946 error = iTmsUplinkEffect->GetType(itEffectType); |
|
947 } |
|
948 break; |
|
949 case TMS_EFFECT_GLOBAL_GAIN: |
|
950 { |
|
951 if (iGlobalGain) |
|
952 error = iGlobalGain->GetType(itEffectType); |
|
953 |
|
954 } |
|
955 break; |
|
956 default: |
|
957 error = KErrNotSupported; |
|
958 break; |
|
959 } |
|
960 } |
|
961 |
|
962 if (error != KErrNone) |
|
963 { |
|
964 iLog->Log(_L("GetType return error [%d]"), error); |
|
965 return error; |
|
966 } |
|
967 |
|
968 if (itEffectType != effecttype) |
|
969 { |
|
970 iLog->Log( |
|
971 _L("returned effecttype type is not same as expected, returned effecttype :[%d]"), |
|
972 itEffectType); |
|
973 error = KErrUnexpectedValue; |
|
974 } |
|
975 return error; |
|
976 } |
|
977 |
|
978 TInt CTmsAudioServicesTestClass::DeleteSource(CStifItemParser& /*aItem */) |
|
979 { |
|
980 iLog ->Log(_L("CTmsAudioServicesTestClass::DeleteSource")); |
|
981 TInt error = KErrNone; |
|
982 |
|
983 if (iFactory) |
|
984 { |
|
985 if (iTmsClientSource) |
|
986 { |
|
987 error = iFactory->DeleteSource(iTmsClientSource); |
|
988 if (error != KErrNone) |
|
989 { |
|
990 iLog->Log( |
|
991 _L("CTmsAudioServicesTestClass::DeleteClientSource, failed [%d]"), |
|
992 error); |
|
993 return error; |
|
994 } |
|
995 } |
|
996 if (iTmsModemSource) |
|
997 { |
|
998 error = iFactory->DeleteSource(iTmsModemSource); |
|
999 if (error != KErrNone) |
|
1000 { |
|
1001 iLog->Log( |
|
1002 _L("CTmsAudioServicesTestClass::DeleteModemSource, failed [%d]"), |
|
1003 error); |
|
1004 return error; |
|
1005 } |
|
1006 } |
|
1007 if (iTmsMicSource) |
|
1008 { |
|
1009 error = iFactory->DeleteSource(iTmsMicSource); |
|
1010 if (error != KErrNone) |
|
1011 { |
|
1012 iLog->Log( |
|
1013 _L("CTmsAudioServicesTestClass::DeleteMicSource, failed [%d]"), |
|
1014 error); |
|
1015 return error; |
|
1016 } |
|
1017 } |
|
1018 } |
|
1019 |
|
1020 return error; |
|
1021 } |
|
1022 |
|
1023 TInt CTmsAudioServicesTestClass::DeleteSink(CStifItemParser& /*aItem */) |
|
1024 { |
|
1025 iLog ->Log(_L("CTmsAudioServicesTestClass::DeleteSink")); |
|
1026 TInt error = KErrNone; |
|
1027 |
|
1028 if (iFactory) |
|
1029 { |
|
1030 if (iTmsClientSink) |
|
1031 { |
|
1032 error = iFactory->DeleteSink(iTmsClientSink); |
|
1033 if (error != KErrNone) |
|
1034 { |
|
1035 iLog->Log( |
|
1036 _L("CTmsAudioServicesTestClass::DeleteClientSource, failed [%d]"), |
|
1037 error); |
|
1038 return error; |
|
1039 } |
|
1040 } |
|
1041 if (iTmsModemSink) |
|
1042 { |
|
1043 error = iFactory->DeleteSink(iTmsModemSink); |
|
1044 if (error != KErrNone) |
|
1045 { |
|
1046 iLog->Log( |
|
1047 _L("CTmsAudioServicesTestClass::DeleteModemSource, failed [%d]"), |
|
1048 error); |
|
1049 return error; |
|
1050 } |
|
1051 } |
|
1052 if (iTmsSpkrSink) |
|
1053 { |
|
1054 error = iFactory->DeleteSink(iTmsSpkrSink); |
|
1055 if (error != KErrNone) |
|
1056 { |
|
1057 iLog->Log( |
|
1058 _L("CTmsAudioServicesTestClass::DeleteSpkrSource, failed [%d]"), |
|
1059 error); |
|
1060 return error; |
|
1061 } |
|
1062 } |
|
1063 } |
|
1064 |
|
1065 return error; |
|
1066 } |
|
1067 |
|
1068 TInt CTmsAudioServicesTestClass::CreateDownlinkStream(CStifItemParser& /*aItem*/) |
|
1069 { |
|
1070 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::CreateDownlinkStream"))); |
|
1071 iLog->Log(_L("CTmsAudioServicesTestClass::CreateDownlinkStream")); |
|
1072 TInt error = KErrNone; |
|
1073 |
|
1074 if (iTmsCall) |
|
1075 { |
|
1076 error = iTmsCall->CreateStream(TMS_STREAM_DOWNLINK, iTmsDnlink); |
|
1077 } |
|
1078 |
|
1079 iLog->Log( |
|
1080 _L("CTmsAudioServicesTestClass::CreateDownlinkStream Error [%d]"), |
|
1081 error); |
|
1082 return error; |
|
1083 } |
|
1084 |
|
1085 TInt CTmsAudioServicesTestClass::GetDownlinkVersion(CStifItemParser& /*aItem */) |
|
1086 { |
|
1087 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::GetDownlinkVersion"))); |
|
1088 iLog->Log(_L("CTmsAudioServicesTestClass::GetDownlinkVersion")); |
|
1089 TInt error = KErrNone; |
|
1090 TVersion ver(0, 0, 0); |
|
1091 // error = iTmsDnlink->GetVersion(ver); |
|
1092 return error; |
|
1093 } |
|
1094 |
|
1095 TInt CTmsAudioServicesTestClass::CreateUplinkStream(CStifItemParser& /*aItem */) |
|
1096 { |
|
1097 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::CreateUplinkStream"))); |
|
1098 iLog->Log(_L("CTmsAudioServicesTestClass::CreateUplinkStream")); |
|
1099 TInt error = KErrNone; |
|
1100 if (iTmsCall) |
|
1101 { |
|
1102 error = iTmsCall->CreateStream(TMS_STREAM_UPLINK, iTmsUplink); |
|
1103 } |
|
1104 RDebug::Printf("[TMS STIF] CreateUplinkStream Return [%d]", error); |
|
1105 return error; |
|
1106 } |
|
1107 |
|
1108 TInt CTmsAudioServicesTestClass::GetUplinkVersion(CStifItemParser& /*aItem */) |
|
1109 { |
|
1110 FTRACE(FPrint(_L("CTmsAudioServicesTe stClass::GetUplinkVersion"))); |
|
1111 iLog->Log(_L("CTmsAudioServicesTestClass::GetUplinkVersion")); |
|
1112 TInt error = KErrNone; |
|
1113 TVersion ver(0, 0, 0); |
|
1114 //error = iTmsUplink->GetVersion(ver); |
|
1115 return error; |
|
1116 } |
|
1117 |
|
1118 TInt CTmsAudioServicesTestClass::GetSupportedFormats(CStifItemParser& aItem) |
|
1119 { |
|
1120 iLog->Log(_L("CTmsAudioServicesTestClass::GetSupportedFormats")); |
|
1121 TInt error = KErrNone; |
|
1122 TPtrC StreamType; |
|
1123 error = aItem.GetNextString(StreamType); |
|
1124 |
|
1125 if (iFactory) |
|
1126 { |
|
1127 if (StreamType == KTagUplink) |
|
1128 { |
|
1129 error = iFactory->GetSupportedFormats(TMS_STREAM_UPLINK, iCodec); |
|
1130 } |
|
1131 else |
|
1132 { |
|
1133 error |
|
1134 = iFactory->GetSupportedFormats(TMS_STREAM_DOWNLINK, |
|
1135 iCodec); |
|
1136 } |
|
1137 |
|
1138 if (error != KErrNone) |
|
1139 { |
|
1140 iLog->Log(_L("DNL Codecs retrieve error, %d"), error); |
|
1141 return error; |
|
1142 } |
|
1143 |
|
1144 if (iCodec.size() > 0) |
|
1145 { |
|
1146 iLog->Log(_L("Supported DNL codecs")); |
|
1147 std::vector<TMSFormat*>::iterator itCodecs = iCodec.begin(); |
|
1148 TMSFormatType fmttype; |
|
1149 for (; itCodecs < iCodec.end(); itCodecs++) |
|
1150 { |
|
1151 (*itCodecs)->GetType(fmttype); |
|
1152 DisplayFormat(fmttype); |
|
1153 } |
|
1154 |
|
1155 itCodecs = iCodec.begin(); |
|
1156 for (; itCodecs < iCodec.end(); itCodecs++) |
|
1157 { |
|
1158 iCodec.erase(itCodecs); |
|
1159 //delete *itDnlCodecs; |
|
1160 iFactory->DeleteFormat(*itCodecs); |
|
1161 |
|
1162 } |
|
1163 } |
|
1164 } |
|
1165 return error; |
|
1166 } |
|
1167 |
|
1168 TInt CTmsAudioServicesTestClass::IsCallTypeSupported(CStifItemParser& aItem) |
|
1169 { |
|
1170 iLog ->Log(_L("CTmsAudioServicesTestClass::IsCallTypeSupported")); |
|
1171 TInt error = KErrNone; |
|
1172 TInt calltype; |
|
1173 TBool isSupported; |
|
1174 aItem.GetNextInt(calltype); |
|
1175 |
|
1176 if (iFactory) |
|
1177 { |
|
1178 error = iFactory->IsCallTypeSupported((TMSCallType) calltype, |
|
1179 isSupported); |
|
1180 |
|
1181 if (isSupported) |
|
1182 { |
|
1183 iLog->Log(_L("Call type is supported")); |
|
1184 } |
|
1185 else |
|
1186 { |
|
1187 iLog->Log(_L("Call type is not supported")); |
|
1188 } |
|
1189 } |
|
1190 return error; |
|
1191 } |
|
1192 |
|
1193 TInt CTmsAudioServicesTestClass::GetType(CStifItemParser& aItem) |
|
1194 { |
|
1195 iLog->Log(_L("CTmsAudioServicesTestClass::GetType")); |
|
1196 TInt error = KErrNone; |
|
1197 TMSFormatType fmttype; |
|
1198 |
|
1199 TPtrC formatType; |
|
1200 error = aItem.GetNextString(formatType); |
|
1201 if (error == KErrNone) |
|
1202 { |
|
1203 iTmsFormat->GetType(fmttype); |
|
1204 if ((formatType == KTagG711 && fmttype != TMS_FORMAT_G711) |
|
1205 || (formatType == KTagG729 && fmttype != TMS_FORMAT_G729) |
|
1206 || (formatType == KTagILBC && fmttype != TMS_FORMAT_ILBC) |
|
1207 || (formatType == KTagAMRNB && fmttype != TMS_FORMAT_AMR) |
|
1208 || (formatType == KTagPCM16 && fmttype != TMS_FORMAT_PCM)) |
|
1209 { |
|
1210 iLog->Log( |
|
1211 _L("CTmsAudioServicesTestClass::GetType failed, Format is same as expected")); |
|
1212 error = KErrUnexpectedValue; |
|
1213 } |
|
1214 } |
|
1215 return error; |
|
1216 } |
|
1217 |
|
1218 TInt CTmsAudioServicesTestClass::SetDownlinkFormat(CStifItemParser& /*aItem */) |
|
1219 { |
|
1220 iLog->Log(_L("CTmsAudioServicesTestClass::SetDownlinkFormat")); |
|
1221 TInt error = KErrNone; |
|
1222 |
|
1223 if (iTmsDnlink) |
|
1224 { |
|
1225 if (iTmsFormatDn) |
|
1226 { |
|
1227 error = iTmsDnlink->SetFormat(iTmsFormatDn); |
|
1228 } |
|
1229 else |
|
1230 { |
|
1231 error = iTmsDnlink->SetFormat(iTmsFormat); |
|
1232 } |
|
1233 |
|
1234 if (error != KErrNone) |
|
1235 { |
|
1236 iLog->Log( |
|
1237 _L("CTmsAudioServicesTestClass::SetDownlinkFormat - failed, return error = %d" ), |
|
1238 error); |
|
1239 return error; |
|
1240 } |
|
1241 } |
|
1242 else |
|
1243 { |
|
1244 error = KErrNotReady; |
|
1245 iLog->Log( |
|
1246 _L("CTmsAudioServicesTestClass::SetDownlinkFormat - Need create TMSStream & TMSFormat first" )); |
|
1247 } |
|
1248 |
|
1249 return error; |
|
1250 } |
|
1251 |
|
1252 TInt CTmsAudioServicesTestClass::ReSetDownlinkFormat(CStifItemParser& /*aItem */) |
|
1253 { |
|
1254 //FTRACE(FPrint(_L("CTmsAudioServicesTestClass::SetDownlinkFormat"))); |
|
1255 iLog->Log(_L("CTmsAudioServicesTestClass::ReSetDownlinkFormat")); |
|
1256 TInt error = KErrNone; |
|
1257 |
|
1258 if (iTmsDnlink && iTmsFormatDn) |
|
1259 { |
|
1260 error = iTmsDnlink->ResetFormat(iTmsFormatDn); |
|
1261 if (error != KErrNone) |
|
1262 { |
|
1263 iLog->Log( |
|
1264 _L("CTmsAudioServicesTestClass::ReSetDownlinkFormat - failed, return error = %d" ), |
|
1265 error); |
|
1266 return error; |
|
1267 } |
|
1268 } |
|
1269 else |
|
1270 { |
|
1271 error = KErrNotReady; |
|
1272 iLog->Log( |
|
1273 _L("CTmsAudioServicesTestClass::ReSetDownlinkFormat - Need create TMSStream & TMSFormat first" )); |
|
1274 } |
|
1275 return error; |
|
1276 } |
|
1277 |
|
1278 TInt CTmsAudioServicesTestClass::OpenDownlink(CStifItemParser& /*aItem */) |
|
1279 { |
|
1280 iLog ->Log(_L("CTmsAudioServicesTestClass::OpenDownlink")); |
|
1281 TInt error = KErrNone; |
|
1282 |
|
1283 if (iDnLinkStatus == UNINITIALIZED) |
|
1284 { |
|
1285 if (iTmsDnlink) |
|
1286 { |
|
1287 iLog->Log( |
|
1288 _L("CTmsAudioServicesTestClass::OpenDownlink - init Downlink")); |
|
1289 iTmsDnlink->AddObserver(*this, NULL); |
|
1290 error = iTmsDnlink->Init(); |
|
1291 } |
|
1292 |
|
1293 if (error != KErrNone) |
|
1294 { |
|
1295 iLog->Log(_L("DNL open failed: error = %d"), error); |
|
1296 } |
|
1297 else |
|
1298 { |
|
1299 AddExpectedEvent(EOpenDownlinkComplete, KMediumTimeout); |
|
1300 } |
|
1301 } |
|
1302 else |
|
1303 { |
|
1304 iLog->Log(_L("DNL already open: error = %d"), KErrInUse); |
|
1305 } |
|
1306 return error; |
|
1307 } |
|
1308 |
|
1309 TInt CTmsAudioServicesTestClass::SetUplinkFormat(CStifItemParser& /*aItem */) |
|
1310 { |
|
1311 iLog->Log(_L("CTmsAudioServicesTestClass::SetUplinkFormat")); |
|
1312 TInt error = KErrNone; |
|
1313 |
|
1314 if (iTmsUplink) |
|
1315 { |
|
1316 if (iTmsFormatUp) |
|
1317 { |
|
1318 iLog->Log( |
|
1319 _L("CTmsAudioServicesTestClass::SetUplinkFormat - iTmsFormatUp")); |
|
1320 error = iTmsUplink->SetFormat(iTmsFormatUp); |
|
1321 } |
|
1322 else |
|
1323 { |
|
1324 iLog->Log( |
|
1325 _L("CTmsAudioServicesTestClass::SetUplinkFormat - iTmsFormat")); |
|
1326 error = iTmsUplink->SetFormat(iTmsFormat); |
|
1327 } |
|
1328 |
|
1329 if (error != KErrNone) |
|
1330 { |
|
1331 iLog->Log( |
|
1332 _L("CTmsAudioServicesTestClass::SetUplinkFormat - failed, return error = %d" ), |
|
1333 error); |
|
1334 return error; |
|
1335 } |
|
1336 } |
|
1337 else |
|
1338 { |
|
1339 error = KErrNotReady; |
|
1340 iLog->Log( |
|
1341 _L("CTmsAudioServicesTestClass::SetUplinkFormat - Need create TMSStream & TMSFormat first" )); |
|
1342 } |
|
1343 return error; |
|
1344 } |
|
1345 |
|
1346 TInt CTmsAudioServicesTestClass::ReSetUplinkFormat(CStifItemParser& /*aItem */) |
|
1347 { |
|
1348 // FTRACE(FPrint(_L("CTmsAudioServicesTestClass::SetDownlinkFormat"))); |
|
1349 iLog->Log(_L("CTmsAudioServicesTestClass::ReSetUplinkFormat")); |
|
1350 TInt error = KErrNone; |
|
1351 |
|
1352 if (iTmsUplink && iTmsFormatUp) |
|
1353 { |
|
1354 error = iTmsUplink->ResetFormat(iTmsFormatUp); |
|
1355 if (error != KErrNone) |
|
1356 { |
|
1357 iLog->Log( |
|
1358 _L("CTmsAudioServicesTestClass::ReSetUplinkFormat - failed, return error = %d" ), |
|
1359 error); |
|
1360 return error; |
|
1361 } |
|
1362 } |
|
1363 else |
|
1364 { |
|
1365 error = KErrNotReady; |
|
1366 iLog->Log( |
|
1367 _L("CTmsAudioServicesTestClass::ReSetUplinkFormat - Need create TMSStream & TMSFormat first" )); |
|
1368 } |
|
1369 return error; |
|
1370 } |
|
1371 |
|
1372 TInt CTmsAudioServicesTestClass::OpenUplink(CStifItemParser& /*aItem */) |
|
1373 { |
|
1374 //FTRACE(FPrint(_L("CTmsAudioServicesTestClass::OpenUplink"))); |
|
1375 iLog->Log(_L("CTmsAudioServicesTestClass::OpenUplink")); |
|
1376 TInt error = KErrNone; |
|
1377 |
|
1378 if (iUpLinkStatus == UNINITIALIZED) |
|
1379 { |
|
1380 if (iTmsUplink) |
|
1381 { |
|
1382 iLog->Log( |
|
1383 _L("CTmsAudioServicesTestClass::OpenDownlink - init Uplink")); |
|
1384 iTmsUplink->AddObserver(*this, NULL); |
|
1385 error = iTmsUplink->Init(); |
|
1386 } |
|
1387 |
|
1388 if (error != KErrNone) |
|
1389 { |
|
1390 iLog->Log(_L("UPL open error: error = %d"), error); |
|
1391 } |
|
1392 else |
|
1393 { |
|
1394 AddExpectedEvent(EOpenUplinkComplete, KMediumTimeout); |
|
1395 } |
|
1396 } |
|
1397 else |
|
1398 { |
|
1399 iLog->Log(_L("UPL already open: error = %d"), KErrInUse); |
|
1400 } |
|
1401 return error; |
|
1402 } |
|
1403 |
|
1404 // ---------------------------------------------------------------------------- |
|
1405 // CTmsAudioServicesTestClass::DisplayFormat |
|
1406 // |
|
1407 // ---------------------------------------------------------------------------- |
|
1408 // |
|
1409 void CTmsAudioServicesTestClass::DisplayFormat(TMSFormatType aFormat) |
|
1410 { |
|
1411 if (aFormat == TMS_FORMAT_AMR) |
|
1412 { |
|
1413 iLog->Log(_L("AMR-NB")); |
|
1414 } |
|
1415 else if (aFormat == TMS_FORMAT_G711) |
|
1416 { |
|
1417 iLog->Log(_L("G.711")); |
|
1418 } |
|
1419 else if (aFormat == TMS_FORMAT_G729) |
|
1420 { |
|
1421 iLog->Log(_L("G.729")); |
|
1422 } |
|
1423 else if (aFormat == TMS_FORMAT_ILBC) |
|
1424 { |
|
1425 iLog->Log(_L("iLBC")); |
|
1426 } |
|
1427 else if (aFormat == TMS_FORMAT_PCM) |
|
1428 { |
|
1429 iLog->Log(_L("PCM-16")); |
|
1430 } |
|
1431 } |
|
1432 |
|
1433 TInt CTmsAudioServicesTestClass::Close(CStifItemParser& aItem) |
|
1434 { |
|
1435 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::Close"))); |
|
1436 iLog->Log(_L("CTmsAudioServicesTestClass::Close")); |
|
1437 TInt error = KErrNone; |
|
1438 |
|
1439 TPtrC closeType; |
|
1440 error = aItem.GetNextString(closeType); |
|
1441 if (error == KErrNone) |
|
1442 { |
|
1443 if (closeType == KTagUplink) |
|
1444 { |
|
1445 //iRecBufPtr.Set(NULL, 0, 0); |
|
1446 iRecBufReady = EFalse; |
|
1447 //iUpLinkCodec = ENULL; |
|
1448 iTmsUplink->Deinit(); |
|
1449 iUpLinkStatus = UNINITIALIZED; |
|
1450 iLog->Log(_L("Close Uplink")); |
|
1451 AddExpectedEvent(EUplinkClosed, KMediumTimeout); |
|
1452 } |
|
1453 else if (closeType == KTagDnlink) |
|
1454 { |
|
1455 //iPlayBufPtr.Set(NULL, 0, 0); |
|
1456 iTmsDnlink->Deinit(); |
|
1457 iDnLinkStatus = UNINITIALIZED; |
|
1458 iPlayBufReady = EFalse; |
|
1459 // iDnLinkCodec = ENULL; |
|
1460 iLog->Log(_L("Close Dnlink")); |
|
1461 AddExpectedEvent(EDownlinkClosed, KMediumTimeout); |
|
1462 } |
|
1463 else |
|
1464 { |
|
1465 iLog->Log(KMsgBadTestParameters); |
|
1466 error = KErrBadTestParameter; |
|
1467 } |
|
1468 } |
|
1469 return error; |
|
1470 } |
|
1471 |
|
1472 TInt CTmsAudioServicesTestClass::Start(CStifItemParser& aItem) |
|
1473 { |
|
1474 iLog->Log(_L("CTmsAudioServicesTestClass::Start")); |
|
1475 TInt error = KErrNone; |
|
1476 |
|
1477 TPtrC startType; |
|
1478 error = aItem.GetNextString(startType); |
|
1479 if (error == KErrNone) |
|
1480 { |
|
1481 if (startType == KTagUplink) |
|
1482 { |
|
1483 if ((iUpLinkStatus == INITIALIZED) || (iUpLinkStatus == PAUSED)) |
|
1484 { |
|
1485 iTmsUplink->Start(); |
|
1486 |
|
1487 if (iUpLinkStatus == INITIALIZED) |
|
1488 { |
|
1489 AddExpectedEvent(EEmptyBuffer, KMediumTimeout); |
|
1490 } |
|
1491 else |
|
1492 { |
|
1493 AddExpectedEvent(EStreamStarted, KMediumTimeout); |
|
1494 } |
|
1495 iUpLinkStatus = STARTED; |
|
1496 iLog->Log(_L("Start Uplink")); |
|
1497 } |
|
1498 else |
|
1499 { |
|
1500 iLog->Log(_L("UPL not ready")); |
|
1501 error = KErrNotReady; |
|
1502 } |
|
1503 } |
|
1504 else if (startType == KTagDnlink) |
|
1505 { |
|
1506 if ((iDnLinkStatus == INITIALIZED) || (iDnLinkStatus == PAUSED)) |
|
1507 { |
|
1508 iTmsDnlink->Start(); |
|
1509 if (iDnLinkStatus == INITIALIZED) |
|
1510 { |
|
1511 AddExpectedEvent(EFillBuffer, KMediumTimeout); |
|
1512 } |
|
1513 else |
|
1514 { |
|
1515 AddExpectedEvent(EStreamStarted, KMediumTimeout); |
|
1516 } |
|
1517 iDnLinkStatus = STARTED; |
|
1518 iLog->Log(_L("Start Dnlink")); |
|
1519 } |
|
1520 else |
|
1521 { |
|
1522 iLog->Log(_L("DNL not ready")); |
|
1523 error = KErrNotReady; |
|
1524 } |
|
1525 } |
|
1526 else |
|
1527 { |
|
1528 iLog->Log(KMsgBadTestParameters); |
|
1529 error = KErrBadTestParameter; |
|
1530 } |
|
1531 } |
|
1532 return error; |
|
1533 } |
|
1534 |
|
1535 TInt CTmsAudioServicesTestClass::Pause(CStifItemParser& aItem) |
|
1536 { |
|
1537 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::Pause -- ENTER"))); |
|
1538 iLog->Log(_L("CTmsAudioServicesTestClass::Pause --ENTER")); |
|
1539 TInt error = KErrNone; |
|
1540 TPtrC startType; |
|
1541 error = aItem.GetNextString(startType); |
|
1542 if (error == KErrNone) |
|
1543 { |
|
1544 if (startType == KTagUplink) |
|
1545 { |
|
1546 if (iUpLinkStatus == STARTED) |
|
1547 { |
|
1548 iTmsUplink->Pause(); |
|
1549 iUpLinkStatus = PAUSED; |
|
1550 iLog->Log(_L("Pause Uplink")); |
|
1551 AddExpectedEvent(EStreamPaused, KMediumTimeout); |
|
1552 } |
|
1553 else |
|
1554 { |
|
1555 iLog->Log(_L("UPL not started")); |
|
1556 error = KErrNotReady; |
|
1557 } |
|
1558 } |
|
1559 else if (startType == KTagDnlink) |
|
1560 { |
|
1561 if (iDnLinkStatus == STARTED) |
|
1562 { |
|
1563 iTmsDnlink->Pause(); |
|
1564 iDnLinkStatus = PAUSED; |
|
1565 iLog->Log(_L("Pause Dnlink")); |
|
1566 AddExpectedEvent(EStreamPaused, KMediumTimeout); |
|
1567 } |
|
1568 else |
|
1569 { |
|
1570 iLog->Log(_L("DNL not started")); |
|
1571 error = KErrNotReady; |
|
1572 } |
|
1573 } |
|
1574 else |
|
1575 { |
|
1576 iLog->Log(KMsgBadTestParameters); |
|
1577 error = KErrBadTestParameter; |
|
1578 } |
|
1579 } |
|
1580 |
|
1581 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::Pause -- EXIT"))); |
|
1582 iLog->Log(_L("CTmsAudioServicesTestClass::Pause --EXIT")); |
|
1583 return error; |
|
1584 } |
|
1585 |
|
1586 TInt CTmsAudioServicesTestClass::Stop(CStifItemParser& aItem) |
|
1587 { |
|
1588 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::Stop"))); |
|
1589 iLog->Log(_L("CTmsAudioServicesTestClass::Stop")); |
|
1590 TInt error = KErrNone; |
|
1591 TPtrC stopType; |
|
1592 error = aItem.GetNextString(stopType); |
|
1593 if (error == KErrNone) |
|
1594 { |
|
1595 if (stopType == KTagUplink) |
|
1596 { |
|
1597 if ((iUpLinkStatus == STARTED) || (iUpLinkStatus == PAUSED)) |
|
1598 { |
|
1599 iTmsUplink->Stop(); |
|
1600 iUpLinkStatus = INITIALIZED; |
|
1601 iLog->Log(_L("Stop Uplink")); |
|
1602 } |
|
1603 else |
|
1604 { |
|
1605 iLog->Log(_L("UPL not started")); |
|
1606 error = KErrNotReady; |
|
1607 } |
|
1608 } |
|
1609 else if (stopType == KTagDnlink) |
|
1610 { |
|
1611 if ((iDnLinkStatus == STARTED) || (iDnLinkStatus == PAUSED)) |
|
1612 { |
|
1613 iTmsDnlink->Stop(); |
|
1614 iDnLinkStatus = INITIALIZED; |
|
1615 iLog->Log(_L("Stop Dnlink")); |
|
1616 } |
|
1617 else |
|
1618 { |
|
1619 iLog->Log(_L("DNL not started")); |
|
1620 error = KErrNotReady; |
|
1621 } |
|
1622 } |
|
1623 else |
|
1624 { |
|
1625 iLog->Log(KMsgBadTestParameters); |
|
1626 error = KErrBadTestParameter; |
|
1627 } |
|
1628 } |
|
1629 return error; |
|
1630 } |
|
1631 |
|
1632 TInt CTmsAudioServicesTestClass::Gain(CStifItemParser& aItem) |
|
1633 { |
|
1634 iLog->Log(_L("CTmsAudioServicesTestClass::Gain")); |
|
1635 TInt error = KErrNone; |
|
1636 guint ret; |
|
1637 TInt effecttype; |
|
1638 aItem.GetNextInt(effecttype); |
|
1639 |
|
1640 if (effecttype == TMS_EFFECT_GAIN) |
|
1641 { |
|
1642 RDebug::Printf("[TMS STIF] GAIN, GetMaxLevel"); |
|
1643 ret = ((TMSGainEffect*) iTmsUplinkEffect)->GetMaxLevel(iMaxGain); |
|
1644 RDebug::Printf( |
|
1645 "[TMS STIF] GAIN, GetMaxLevel Level [%d] Ret Err [%d]", |
|
1646 iMaxGain, ret); |
|
1647 RDebug::Printf("[TMS STIF] GAIN, SetLevel to [%d]", iMaxGain); |
|
1648 ret = ((TMSGainEffect*) iTmsUplinkEffect)->SetLevel(iMaxGain); |
|
1649 RDebug::Printf("[TMS STIF] GAIN, SetLevel ret [%d]", ret); |
|
1650 iLog->Log(_L("SetMaxGain: %d"), iMaxGain); |
|
1651 RDebug::Printf("[TMS STIF] GAIN, GetLevel"); |
|
1652 ret = ((TMSGainEffect*) iTmsUplinkEffect)->GetLevel(iGain); |
|
1653 RDebug::Printf( |
|
1654 "[TMS STIF] GAIN, Exp Level [%d] Ret Level [%d] Ret Err [%d]", |
|
1655 iMaxGain, iGain, ret); |
|
1656 if (iGain != iMaxGain) |
|
1657 { |
|
1658 iLog->Log( |
|
1659 _L("GetGain doesn't return expected MaxGain!!! returned Gain = %d"), |
|
1660 iGain); |
|
1661 return KErrUnexpectedValue; |
|
1662 } |
|
1663 |
|
1664 ((TMSGainEffect*) iTmsUplinkEffect)->SetLevel(0); |
|
1665 iLog->Log(_L("MuteMic")); |
|
1666 ((TMSGainEffect*) iTmsUplinkEffect)->GetLevel(iGain); |
|
1667 |
|
1668 if (iGain != 0) |
|
1669 { |
|
1670 iLog->Log( |
|
1671 _L("GetGain does not return expected Mute value!!! returned Gain = %d"), |
|
1672 iGain); |
|
1673 return KErrUnexpectedValue; |
|
1674 } |
|
1675 } |
|
1676 else if (effecttype == TMS_EFFECT_GLOBAL_GAIN) |
|
1677 { |
|
1678 RDebug::Printf("[TMS STIF] GLOBAL GAIN, GetMaxLevel"); |
|
1679 ret = ((TMSGlobalGainEffect*) iGlobalGain)->GetMaxLevel(iMaxGain); |
|
1680 RDebug::Printf( |
|
1681 "[TMS STIF] GLOBAL GAIN, GetMaxLevel Level [%d] Ret Err [%d]", |
|
1682 iMaxGain, ret); |
|
1683 RDebug::Printf("[TMS STIF] GLOBAL GAIN, SetLevel to [%d]", iMaxGain); |
|
1684 ret = ((TMSGlobalGainEffect*) iGlobalGain)->SetLevel(iMaxGain); |
|
1685 RDebug::Printf("[TMS STIF] GLOBAL GAIN, SetLevel ret [%d]", ret); |
|
1686 iLog->Log(_L("SetGlobleMaxGain: %d"), iMaxGain); |
|
1687 RDebug::Printf("[TMS STIF] GLOBAL GAIN, GetLevel"); |
|
1688 ret = ((TMSGlobalGainEffect*) iGlobalGain)->GetLevel(iGain); |
|
1689 RDebug::Printf( |
|
1690 "[TMS STIF] GLOBAL GAIN, Exp Level [%d] Ret Level [%d] Ret Err [%d]", |
|
1691 iMaxGain, iGain, ret); |
|
1692 if (iGain != iMaxGain) |
|
1693 { |
|
1694 iLog->Log( |
|
1695 _L("GetGain doesn't return expected Globle MaxGain!!! returned Gain = %d"), |
|
1696 iGain); |
|
1697 return KErrUnexpectedValue; |
|
1698 } |
|
1699 |
|
1700 ((TMSGlobalGainEffect*) iGlobalGain)->SetLevel(0); |
|
1701 iLog->Log(_L("MuteMic")); |
|
1702 ((TMSGlobalGainEffect*) iGlobalGain)->GetLevel(iGain); |
|
1703 |
|
1704 if (iGain != 0) |
|
1705 { |
|
1706 iLog->Log( |
|
1707 _L("GetGain does not return expected loble Mute value!!! returned Gain = %d"), |
|
1708 iGain); |
|
1709 return KErrUnexpectedValue; |
|
1710 } |
|
1711 } |
|
1712 else |
|
1713 { |
|
1714 error = KErrArgument; |
|
1715 } |
|
1716 return error; |
|
1717 } |
|
1718 |
|
1719 TInt CTmsAudioServicesTestClass::Volume(CStifItemParser& aItem) |
|
1720 { |
|
1721 iLog->Log(_L("CTmsAudioServicesTestClass::Volume")); |
|
1722 TInt error = KErrNone; |
|
1723 TInt effecttype; |
|
1724 guint ret; |
|
1725 aItem.GetNextInt(effecttype); |
|
1726 |
|
1727 if (effecttype == TMS_EFFECT_VOLUME) |
|
1728 { |
|
1729 RDebug::Printf("[TMS STIF] Volume, GetMaxLevel"); |
|
1730 ret = ((TMSVolumeEffect*) iTmsDnlinkEffect)->GetMaxLevel(iMaxVolume); |
|
1731 RDebug::Printf("[TMS STIF] MaxLevel [%d] Ret Error [%d]", iMaxVolume, |
|
1732 ret); |
|
1733 RDebug::Printf("[TMS STIF] Volume, SetLevel to MaxLevel [%d]", |
|
1734 iMaxVolume); |
|
1735 ret = ((TMSVolumeEffect*) iTmsDnlinkEffect)->SetLevel(iMaxVolume); |
|
1736 RDebug::Printf("[TMS STIF] SetLevel Ret Error [%d]", ret); |
|
1737 iLog->Log(_L("SetMaxVolume: %d"), iMaxVolume); |
|
1738 RDebug::Printf("[TMS STIF] GetLevel"); |
|
1739 ret = ((TMSVolumeEffect*) iTmsDnlinkEffect)->GetLevel(iVolume); |
|
1740 RDebug::Printf("[TMS STIF] Level [%d] Ret Error [%d]", iVolume, ret); |
|
1741 if (iVolume != iMaxVolume) |
|
1742 { |
|
1743 iLog->Log( |
|
1744 _L("GetVolume doesn't return expected MaxVolume!!! returned Volume = %d"), |
|
1745 iVolume); |
|
1746 return KErrUnexpectedValue; |
|
1747 } |
|
1748 |
|
1749 RDebug::Printf("[TMS STIF] Volume, SetLevel to 0 "); |
|
1750 ret = ((TMSVolumeEffect*) iTmsDnlinkEffect)->SetLevel(0); |
|
1751 RDebug::Printf("[TMS STIF] SetLevel Ret Error [%d]", ret); |
|
1752 iLog->Log(_L("Mute Volume")); |
|
1753 ret = ((TMSVolumeEffect*) iTmsDnlinkEffect)->GetLevel(iVolume); |
|
1754 RDebug::Printf("[TMS STIF] Level [%d] Ret Error [%d]", iVolume, ret); |
|
1755 if (iVolume != 0) |
|
1756 { |
|
1757 iLog->Log( |
|
1758 _L("GetVolume does not return expected Mute value!!! returned Volume = %d"), |
|
1759 iVolume); |
|
1760 return KErrUnexpectedValue; |
|
1761 } |
|
1762 } |
|
1763 else if (effecttype == TMS_EFFECT_GLOBAL_VOL) |
|
1764 { |
|
1765 RDebug::Printf("[TMS STIF] GLOBAL_VOL, Get Current Level"); |
|
1766 ret = ((TMSGlobalVolEffect*) iGlobalVol)->GetLevel(iVolume); |
|
1767 RDebug::Printf("[TMS STIF] Current Vol Level [%d] Ret Error [%d]", |
|
1768 iVolume, ret); |
|
1769 RDebug::Printf("[TMS STIF] GLOBAL_VOL, GetMaxLevel"); |
|
1770 ret = ((TMSGlobalVolEffect*) iGlobalVol)->GetMaxLevel(iMaxVolume); |
|
1771 RDebug::Printf("[TMS STIF] MaxLevel [%d] Ret Error [%d]", iMaxVolume, |
|
1772 ret); |
|
1773 RDebug::Printf("[TMS STIF] GLOBAL_VOL, SetLevel to [%d]", iMaxVolume); |
|
1774 ret = ((TMSGlobalVolEffect*) iGlobalVol)->SetLevel(iMaxVolume); |
|
1775 RDebug::Printf("[TMS STIF] SetLevel Ret Error [%d]", ret); |
|
1776 iLog->Log(_L("SetMaxGlobleVolume: %d"), iMaxVolume); |
|
1777 RDebug::Printf("[TMS STIF] GLOBAL_VOL,GetLevel"); |
|
1778 ret = ((TMSGlobalVolEffect*) iGlobalVol)->GetLevel(iVolume); |
|
1779 RDebug::Printf( |
|
1780 "[TMS STIF] Expected Level [%d] Ret Level [%d] Ret Error [%d]", |
|
1781 iMaxVolume, iVolume, ret); |
|
1782 iLog->Log(_L("GetMaxGlobleVolume: %d"), iVolume); |
|
1783 if (iVolume != iMaxVolume) |
|
1784 { |
|
1785 iLog->Log( |
|
1786 _L("GetGlobleVolume doesn't return expected MaxVolume!!! returned Volume = %d"), |
|
1787 iVolume); |
|
1788 return KErrUnexpectedValue; |
|
1789 } |
|
1790 |
|
1791 ((TMSGlobalVolEffect*) iGlobalVol)->SetLevel(0); |
|
1792 iLog->Log(_L("Mute Globle Volume")); |
|
1793 ((TMSGlobalVolEffect*) iGlobalVol)->GetLevel(iVolume); |
|
1794 |
|
1795 if (iVolume != 0) |
|
1796 { |
|
1797 iLog->Log( |
|
1798 _L("GetGlobleVolume does not return expected Mute value!!! returned Volume = %d"), |
|
1799 iVolume); |
|
1800 return KErrUnexpectedValue; |
|
1801 } |
|
1802 } |
|
1803 else |
|
1804 { |
|
1805 error = KErrArgument; |
|
1806 } |
|
1807 |
|
1808 return error; |
|
1809 } |
|
1810 |
|
1811 TInt CTmsAudioServicesTestClass::GetStreamType(CStifItemParser& aItem) |
|
1812 { |
|
1813 iLog->Log(_L("CTmsAudioServicesTestClass::GetStreamType")); |
|
1814 TInt error = KErrNone; |
|
1815 gint status(KErrNone); |
|
1816 TPtrC StreamType; |
|
1817 error = aItem.GetNextString(StreamType); |
|
1818 if (error == KErrNone) |
|
1819 { |
|
1820 if (StreamType == KTagDnlink) |
|
1821 { |
|
1822 if (iTmsDnlink) |
|
1823 { |
|
1824 status = iTmsDnlink->GetStreamType(); |
|
1825 return status; |
|
1826 } |
|
1827 } |
|
1828 else if (StreamType == KTagUplink) |
|
1829 { |
|
1830 if (iTmsUplink) |
|
1831 { |
|
1832 status = iTmsUplink->GetStreamType(); |
|
1833 return status; |
|
1834 } |
|
1835 } |
|
1836 else |
|
1837 { |
|
1838 iLog->Log(KMsgBadTestParameters); |
|
1839 error = KErrBadTestParameter; |
|
1840 } |
|
1841 } |
|
1842 return error; |
|
1843 } |
|
1844 |
|
1845 TInt CTmsAudioServicesTestClass::GetStreamState(CStifItemParser& aItem) |
|
1846 { |
|
1847 iLog ->Log(_L("CTmsAudioServicesTestClass::GetStreamState")); |
|
1848 TInt error = KErrNone; |
|
1849 gint state(KErrNone); |
|
1850 TPtrC StreamType; |
|
1851 error = aItem.GetNextString(StreamType); |
|
1852 if (error == KErrNone) |
|
1853 { |
|
1854 if (StreamType == KTagDnlink) |
|
1855 { |
|
1856 if (iTmsDnlink) |
|
1857 { |
|
1858 state = iTmsDnlink->GetState(); |
|
1859 iLog->Log(_L("Downlink STREAM state:[ %d]"), state); |
|
1860 return state; |
|
1861 } |
|
1862 } |
|
1863 else if (StreamType == KTagUplink) |
|
1864 { |
|
1865 if (iTmsUplink) |
|
1866 { |
|
1867 state = iTmsUplink->GetState(); |
|
1868 iLog->Log(_L("Uplink STREAM state:[ %d]"), state); |
|
1869 return state; |
|
1870 } |
|
1871 } |
|
1872 else |
|
1873 { |
|
1874 iLog->Log(KMsgBadTestParameters); |
|
1875 error = KErrBadTestParameter; |
|
1876 } |
|
1877 } |
|
1878 return error; |
|
1879 } |
|
1880 |
|
1881 TInt CTmsAudioServicesTestClass::AddGlobalRoutingObserver(CStifItemParser& /*aItem */) |
|
1882 { |
|
1883 iLog->Log(_L("CTmsAudioServicesTestClass::AddGlobalRoutingObserver")); |
|
1884 TInt error = KErrNone; |
|
1885 |
|
1886 if (iTmsGlobalRouting) |
|
1887 { |
|
1888 error = iTmsGlobalRouting->AddObserver(*this, NULL); |
|
1889 } |
|
1890 |
|
1891 if (error != KErrNone) |
|
1892 { |
|
1893 iLog->Log( |
|
1894 _L("CTmsAudioServicesTestClass::AddGlobalRoutingObserver failed error [%d]"), |
|
1895 error); |
|
1896 } |
|
1897 return error; |
|
1898 } |
|
1899 |
|
1900 TInt CTmsAudioServicesTestClass::DeleteGlobalRoutingObserver(CStifItemParser& /*aItem*/) |
|
1901 { |
|
1902 iLog->Log(_L("CTmsAu dioServicesTestClass::DeleteGlobalRoutingObserver")); |
|
1903 TInt error = KErrNone; |
|
1904 |
|
1905 if (iTmsGlobalRouting) |
|
1906 { |
|
1907 error = iTmsGlobalRouting->RemoveObserver(*this); |
|
1908 } |
|
1909 |
|
1910 if (error != KErrNone) |
|
1911 { |
|
1912 iLog->Log( |
|
1913 _L("CTmsAudioServicesTestClass::DeleteGlobalRoutingObserver failed error [%d]"), |
|
1914 error); |
|
1915 } |
|
1916 return error; |
|
1917 } |
|
1918 |
|
1919 TInt CTmsAudioServicesTestClass::SetOutput(CStifItemParser& aItem) |
|
1920 { |
|
1921 iLog->Log(_L("CTmsAudioServicesTestClass::SetOutputDevice")); |
|
1922 TInt error = KErrNone; |
|
1923 TPtrC OutputType; |
|
1924 error = aItem.GetNextString(OutputType); |
|
1925 if (error == KErrNone) |
|
1926 { |
|
1927 if (OutputType == KTagNone) |
|
1928 { |
|
1929 error = iTmsGlobalRouting->SetOutput(TMS_AUDIO_OUTPUT_NONE); |
|
1930 iLog->Log( |
|
1931 _L("CTmsAudioServicesTestClass::SetOutputDevice - TMS_AUDIO_OUTPUT_NONE, error:[%d] "), |
|
1932 error); |
|
1933 } |
|
1934 else if (OutputType == KTagPublic) |
|
1935 { |
|
1936 error = iTmsGlobalRouting->SetOutput(TMS_AUDIO_OUTPUT_PUBLIC); |
|
1937 iLog->Log( |
|
1938 _L("CTmsAudioServicesTestClass::SetOutputDevice - TMS_AUDIO_OUTPUT_PUBLIC, error:[%d] "), |
|
1939 error); |
|
1940 } |
|
1941 else if (OutputType == KTagPrivate) |
|
1942 { |
|
1943 error = iTmsGlobalRouting->SetOutput(TMS_AUDIO_OUTPUT_PRIVATE); |
|
1944 iLog->Log( |
|
1945 _L ("CTmsAudioServicesTestClass::SetOutputDevice - TMS_AUDIO_OUTPUT_PRIVATE, error:[%d] "), |
|
1946 error); |
|
1947 } |
|
1948 else if (OutputType == KTagHandset) |
|
1949 { |
|
1950 error = iTmsGlobalRouting->SetOutput(TMS_AUDIO_OUTPUT_HANDSET); |
|
1951 iLog->Log( |
|
1952 _L("CTmsAudioServicesTestClass::SetOutputDevice - TMS_AUDIO_OUTPUT_HANDSET, error:[%d] "), |
|
1953 error); |
|
1954 } |
|
1955 else if (OutputType == KTagLoudspeaker) |
|
1956 { |
|
1957 error = iTmsGlobalRouting->SetOutput(TMS_AUDIO_OUTPUT_LOUDSPEAKER); |
|
1958 iLog->Log( |
|
1959 _L("CTmsAudioServicesTestClass::SetOutputDevice - TMS_AUDIO_OUTPUT_LOUDSPEAKER, error:[%d] "), |
|
1960 error); |
|
1961 } |
|
1962 else if (OutputType == KTagWiredAccessory) |
|
1963 { |
|
1964 error = iTmsGlobalRouting->SetOutput( |
|
1965 TMS_AUDIO_OUTPUT_WIRED_ACCESSORY); |
|
1966 iLog->Log( |
|
1967 _L("CTmsAudioServicesTestClass::SetOutputDevice - TMS_AUDIO_OUTPUT_WIRED_ACCESSORY, error:[%d] "), |
|
1968 error); |
|
1969 } |
|
1970 else if (OutputType == KTagAccessory) |
|
1971 { |
|
1972 error = iTmsGlobalRouting->SetOutput(TMS_AUDIO_OUTPUT_ACCESSORY); |
|
1973 iLog->Log( |
|
1974 _L("CTmsAudioServicesTestClass::SetOutputDevice - TMS_AUDIO_OUTPUT_ACCESSORY, error:[%d] "), |
|
1975 error); |
|
1976 } |
|
1977 else if (OutputType == KTagTTY) |
|
1978 { |
|
1979 error = iTmsGlobalRouting->SetOutput(TMS_AUDIO_OUTPUT_ETTY); |
|
1980 iLog->Log( |
|
1981 _L("CTmsAudioServicesTestClass::SetOutputDevice - TMS_AUDIO_OUTPUT_ETTY, error:[%d] "), |
|
1982 error); |
|
1983 } |
|
1984 else |
|
1985 { |
|
1986 iLog-> Log(KMsgBadTestParameters); |
|
1987 error = KErrBadTestParameter; |
|
1988 return error; |
|
1989 } |
|
1990 |
|
1991 AddExpectedEvent(ESetOutputComplete, KLongTimeout); |
|
1992 } |
|
1993 |
|
1994 return error; |
|
1995 } |
|
1996 |
|
1997 TInt CTmsAudioServicesTestClass::GetOutput(CStifItemParser & aItem) |
|
1998 { |
|
1999 iLog->Log(_L("CallAudioControl::GetOutput")); |
|
2000 TInt error = KErrNone; |
|
2001 |
|
2002 if (iTmsGlobalRouting) |
|
2003 { |
|
2004 error = iTmsGlobalRouting->GetOutput(device); |
|
2005 iLog->Log( |
|
2006 _L("CTmsAudioServicesTestClass::GetOutput, error:[%d] device:[%d]"), |
|
2007 error, device); |
|
2008 |
|
2009 } |
|
2010 |
|
2011 if (error != KErrNone) |
|
2012 { |
|
2013 return error; |
|
2014 } |
|
2015 |
|
2016 TPtrC OutputType; |
|
2017 error = aItem.GetNextString(OutputType); |
|
2018 if (error == KErrNone) |
|
2019 { |
|
2020 if (OutputType == KTagNone) |
|
2021 { |
|
2022 if (device != TMS_AUDIO_OUTPUT_NONE) |
|
2023 { |
|
2024 error = KErrUnexpectedValue; |
|
2025 iLog->Log( |
|
2026 _L("CTmsAudioServicesTestClass::GetOutput - not expected output, error:[%d] "), |
|
2027 error); |
|
2028 } |
|
2029 } |
|
2030 else if (OutputType == KTagPublic) |
|
2031 { |
|
2032 if (device != TMS_AUDIO_OUTPUT_PUBLIC) |
|
2033 { |
|
2034 error = KErrUnexpectedValue; |
|
2035 iLog->Log( |
|
2036 _L("CTmsAudioServicesTestClass::GetOutput - TMS_AUDIO_OUTPUT_PUBLIC, error:[%d] "), |
|
2037 error); |
|
2038 } |
|
2039 } |
|
2040 else if (OutputType == KTagPrivate) |
|
2041 { |
|
2042 if (device != TMS_AUDIO_OUTPUT_PRIVATE) |
|
2043 { |
|
2044 error = KErrUnexpectedValue; |
|
2045 iLog->Log( |
|
2046 _L("CTmsAudioServicesTestClass::GetOutput - TMS_AUDIO_OUTPUT_PRIVATE, error:[%d] "), |
|
2047 error); |
|
2048 } |
|
2049 } |
|
2050 else if (OutputType == KTagHandset) |
|
2051 { |
|
2052 if (device != TMS_AUDIO_OUTPUT_HANDSET) |
|
2053 { |
|
2054 error = KErrUnexpectedValue; |
|
2055 iLog->Log( |
|
2056 _L("CTmsAudioServicesTestClass::GetOutput - not expected output, error:[%d] "), |
|
2057 error); |
|
2058 } |
|
2059 } |
|
2060 else if (OutputType == KTagLoudspeaker) |
|
2061 { |
|
2062 if (device != TMS_AUDIO_OUTPUT_LOUDSPEAKER) |
|
2063 { |
|
2064 error = KErrUnexpectedValue; |
|
2065 iLog->Log( |
|
2066 _L("CTmsAudioServicesTestClass::GetOutput - not expected output, error:[%d] "), |
|
2067 error); |
|
2068 } |
|
2069 } |
|
2070 else if (OutputType == KTagWiredAccessory) |
|
2071 { |
|
2072 if (device != TMS_AUDIO_OUTPUT_WIRED_ACCESSORY) |
|
2073 { |
|
2074 error = KErrUnexpectedValue; |
|
2075 iLog->Log( |
|
2076 _L("CTmsAudioServicesTestClass::GetOutput - not expected output, error:[%d] "), |
|
2077 error); |
|
2078 } |
|
2079 } |
|
2080 else if (OutputType == KTagAccessory) |
|
2081 { |
|
2082 if (device != TMS_AUDIO_OUTPUT_ACCESSORY) |
|
2083 { |
|
2084 error = KErrUnexpectedValue; |
|
2085 iLog->Log( |
|
2086 _L("CTmsAudioServicesTestClass::GetOutput - not expected output, error:[%d] "), |
|
2087 error); |
|
2088 } |
|
2089 } |
|
2090 else if (OutputType == KTagTTY) |
|
2091 { |
|
2092 if (device != TMS_AUDIO_OUTPUT_ETTY) |
|
2093 { |
|
2094 error = KErrUnexpectedValue; |
|
2095 iLog->Log( |
|
2096 _L("CTmsAudioServicesTestClass::GetOutput - not expected output, error:[%d] "), |
|
2097 error); |
|
2098 } |
|
2099 } |
|
2100 else |
|
2101 { |
|
2102 iLog->Log(KMsgBadTestParameters); |
|
2103 error = KErrBadTestParameter; |
|
2104 } |
|
2105 } |
|
2106 |
|
2107 return error; // GetOutput doesn't expect any specific output value. |
|
2108 } |
|
2109 |
|
2110 TInt CTmsAudioServicesTestClass::GetPreviousOutput(CStifItemParser& aItem) |
|
2111 { |
|
2112 iLog ->Log(_L("CallAudioControl::GetPreviousOutput")); |
|
2113 TInt error = KErrNone; |
|
2114 |
|
2115 if (iTmsGlobalRouting) |
|
2116 { |
|
2117 error = iTmsGlobalRouting->GetPreviousOutput(device); |
|
2118 iLog->Log( |
|
2119 _L("CTmsAudioServicesTestClass::GetPreviousOutput, error:[%d] "), |
|
2120 error); |
|
2121 } |
|
2122 |
|
2123 if (error != KErrNone) |
|
2124 { |
|
2125 return error; |
|
2126 } |
|
2127 |
|
2128 TPtrC OutputType; |
|
2129 error = aItem.GetNextString(OutputType); |
|
2130 if (error == KErrNone) |
|
2131 { |
|
2132 if (OutputType == KTagNone) |
|
2133 { |
|
2134 if (device != TMS_AUDIO_OUTPUT_NONE) |
|
2135 { |
|
2136 error = KErrUnexpectedValue; |
|
2137 iLog->Log( |
|
2138 _L("CTmsAudioServicesTestClass::GetPreviousOutput - not expected output, error:[%d] "), |
|
2139 error); |
|
2140 } |
|
2141 } |
|
2142 else if (OutputType == KTagPublic) |
|
2143 { |
|
2144 if (device != TMS_AUDIO_OUTPUT_PUBLIC) |
|
2145 { |
|
2146 error = KErrUnexpectedValue; |
|
2147 iLog->Log( |
|
2148 _L("CTmsAudioServicesTestClass::GetPreviousOutput - TMS_AUDIO_OUTPUT_PUBLIC, error:[%d] "), |
|
2149 error); |
|
2150 } |
|
2151 } |
|
2152 else if (OutputType == KTagPrivate) |
|
2153 { |
|
2154 if (device != TMS_AUDIO_OUTPUT_PRIVATE) |
|
2155 { |
|
2156 error = KErrUnexpectedValue; |
|
2157 iLog->Log( |
|
2158 _L("CTmsAudioServicesTestClass::GetPreviousOutput - TMS_AUDIO_OUTPUT_PRIVATE, error:[%d] "), |
|
2159 error); |
|
2160 } |
|
2161 } |
|
2162 else if (OutputType == KTagHandset) |
|
2163 { |
|
2164 if (device != TMS_AUDIO_OUTPUT_HANDSET) |
|
2165 { |
|
2166 error = KErrUnexpectedValue; |
|
2167 iLog->Log( |
|
2168 _L("CTmsAudioServicesTestClass::GetPreviousOutput - not expected output, error:[%d] "), |
|
2169 error); |
|
2170 } |
|
2171 } |
|
2172 else if (OutputType == KTagLoudspeaker) |
|
2173 { |
|
2174 if (device != TMS_AUDIO_OUTPUT_LOUDSPEAKER) |
|
2175 { |
|
2176 error = KErrUnexpectedValue; |
|
2177 iLog->Log( |
|
2178 _L("CTmsAudioServicesTestClass::GetPreviousOutput - not expected output, error:[%d] "), |
|
2179 error); |
|
2180 } |
|
2181 } |
|
2182 else if (OutputType == KTagWiredAccessory) |
|
2183 { |
|
2184 if (device != TMS_AUDIO_OUTPUT_WIRED_ACCESSORY) |
|
2185 { |
|
2186 error = KErrUnexpectedValue; |
|
2187 iLog->Log( |
|
2188 _L("CTmsAudioServicesTestClass::GetPreviousOutput - not expected output, error:[%d] "), |
|
2189 error); |
|
2190 } |
|
2191 } |
|
2192 else if (OutputType == KTagAccessory) |
|
2193 { |
|
2194 if (device != TMS_AUDIO_OUTPUT_ACCESSORY) |
|
2195 { |
|
2196 error = KErrUnexpectedValue; |
|
2197 iLog->Log( |
|
2198 _L("CTmsAudioServicesTestClass::GetPreviousOutput - not expected output, error:[%d] "), |
|
2199 error); |
|
2200 } |
|
2201 } |
|
2202 else if (OutputType == KTagTTY) |
|
2203 { |
|
2204 if (device != TMS_AUDIO_OUTPUT_ETTY) |
|
2205 { |
|
2206 error = KErrUnexpectedValue; |
|
2207 iLog->Log( |
|
2208 _L("CTmsAudioServicesTestClass::GetPr eviousOutput - not expected output, error:[%d] "), |
|
2209 error); |
|
2210 } |
|
2211 } |
|
2212 else |
|
2213 { |
|
2214 iLog->Log(KMsgBadTestParameters); |
|
2215 error = KErrBadTestParameter; |
|
2216 } |
|
2217 } |
|
2218 |
|
2219 return error; |
|
2220 } |
|
2221 |
|
2222 TInt CTmsAudioServicesTestClass::GetAvailableOutputs(CStifItemParser& /*aItem */) |
|
2223 { |
|
2224 iLog->Log(_L("CTmsAudioServicesTestClass::GetAvailableOutputs")); |
|
2225 TInt error = KErrNone; |
|
2226 |
|
2227 if (iTmsGlobalRouting) |
|
2228 { |
|
2229 error = iTmsGlobalRouting ->GetAvailableOutputs(iAvailableoutputs); |
|
2230 |
|
2231 if (error == KErrNone) |
|
2232 { |
|
2233 iLog->Log( |
|
2234 _L("CTmsAudioServicesTestClass::GetAvailableOutputs, display output")); |
|
2235 std::vector<guint>::iterator iteroutputs = |
|
2236 iAvailableoutputs.begin(); |
|
2237 |
|
2238 for (; iteroutputs < iAvailableoutputs.end(); iteroutputs++) |
|
2239 { |
|
2240 DisplayDevice(*iteroutputs); |
|
2241 } |
|
2242 } |
|
2243 else |
|
2244 { |
|
2245 iLog->Log( |
|
2246 _L("CTmsAudioServicesTestClass::GetAvailableOutputs failed, error = %d"), |
|
2247 error); |
|
2248 } |
|
2249 } |
|
2250 else |
|
2251 { |
|
2252 error = KErrNotReady; |
|
2253 } |
|
2254 return error; |
|
2255 } |
|
2256 |
|
2257 TInt CTmsAudioServicesTestClass::GetBitRateList(CStifItemParser& /*aItem*/) |
|
2258 { |
|
2259 iLog ->Log(_L("CTmsAudioServicesTestClass::GetBitRateList")); |
|
2260 TInt error = KErrNone; |
|
2261 error = iTmsFormatUp -> GetSupportedBitRates(iBitratesVector); |
|
2262 |
|
2263 if (error == KErrNone) |
|
2264 { |
|
2265 iLog->Log( |
|
2266 _L("CTmsAudioServicesTestClass::GetBitRateList - display supported bitRate list")); |
|
2267 std::vector<guint>::iterator itBitrates = iBitratesVector.begin(); |
|
2268 for (; itBitrates <= iBitratesVector.end(); itBitrates++) |
|
2269 { |
|
2270 iLog->Log( |
|
2271 _L("CTmsAudioServicesTestClass::GetBitRateList BR: %d"), |
|
2272 *itBitrates); |
|
2273 } |
|
2274 } |
|
2275 else |
|
2276 { |
|
2277 iLog->Log( |
|
2278 _L("CTmsAudioServicesTestClass::GetBitRateList failed. error: %d"), |
|
2279 error); |
|
2280 } |
|
2281 return error; |
|
2282 } |
|
2283 |
|
2284 TInt CTmsAudioServicesTestClass::SetBitrates(CStifItemParser& aItem) |
|
2285 { |
|
2286 iLog->Log(_L("CTmsAudioServicesTestClass::SetBitrate")); |
|
2287 TInt error = KErrNone; |
|
2288 TPtrC bitRate; |
|
2289 error = aItem.GetNextString(bitRate); |
|
2290 if (error == KErrNone) |
|
2291 { |
|
2292 if (bitRate == KTagMin) |
|
2293 { |
|
2294 if (iBitratesVector.size() > 0) |
|
2295 { |
|
2296 std::vector<guint>::iterator iBitrate = |
|
2297 iBitratesVector.begin(); |
|
2298 error = iTmsFormatUp -> SetBitRate(*iBitrate); |
|
2299 iLog->Log(_L("BR set %d"), *iBitrate); |
|
2300 } |
|
2301 } |
|
2302 else if (bitRate == KTagMax) |
|
2303 { |
|
2304 if (iBitratesVector.size() > 0) |
|
2305 { |
|
2306 std::vector<guint>::iterator iBitrate = iBitratesVector.end(); |
|
2307 error = iTmsFormatUp -> SetBitRate(*iBitrate); |
|
2308 iLog->Log(_L("BR set %d"), *iBitrate); |
|
2309 } |
|
2310 } |
|
2311 else |
|
2312 { |
|
2313 iLog->Log(KMsgBadTestParameters); |
|
2314 error = KErrBadTestParameter; |
|
2315 } |
|
2316 } |
|
2317 return error; |
|
2318 } |
|
2319 |
|
2320 TInt CTmsAudioServicesTestClass::GetBitrates(CStifItemParser& aItem) |
|
2321 { |
|
2322 iLog->Log(_L("CTmsAudioServicesTestClass::GetBitrate")); |
|
2323 TInt error = KErrNone; |
|
2324 TPtrC expectedBitRate; |
|
2325 error = aItem.GetNextString(expectedBitRate); |
|
2326 if (error == KErrNone) |
|
2327 { |
|
2328 if (expectedBitRate == KTagMin) |
|
2329 { |
|
2330 if (iBitratesVector.size() > 0) |
|
2331 { |
|
2332 std::vector<guint>::iterator currentBitrate = |
|
2333 iBitratesVector.begin(); |
|
2334 guint iBitrate; |
|
2335 error = iTmsFormatUp -> GetBitRate(iBitrate); |
|
2336 if (iBitrate != *currentBitrate) |
|
2337 { |
|
2338 iLog->Log(_L("BR get %d"), iBitrate); |
|
2339 iLog->Log(_L("BR set %d"), *currentBitrate); |
|
2340 error = KErrUnexpectedValue; |
|
2341 } |
|
2342 } |
|
2343 } |
|
2344 else if (expectedBitRate == KTagMax) |
|
2345 { |
|
2346 if (iBitratesVector.size() > 0) |
|
2347 { |
|
2348 guint iBitrate; |
|
2349 std::vector<guint>::iterator currentBitrate = |
|
2350 iBitratesVector.end(); |
|
2351 error = iTmsFormatUp -> GetBitRate(iBitrate); |
|
2352 if (iBitrate != *currentBitrate) |
|
2353 { |
|
2354 iLog->Log(_L("BR get %d"), iBitrate); |
|
2355 iLog->Log(_L("BR set %d"), *currentBitrate); |
|
2356 error = KErrUnexpectedValue; |
|
2357 } |
|
2358 } |
|
2359 } |
|
2360 else |
|
2361 { |
|
2362 iLog->Log(KMsgBadTestParameters); |
|
2363 error = KErrBadTestParameter; |
|
2364 } |
|
2365 } |
|
2366 return error; |
|
2367 } |
|
2368 |
|
2369 TInt CTmsAudioServicesTestClass::GetVAD(CStifItemParser& /*aItem*/) |
|
2370 { |
|
2371 iLog->Log(_L("CTmsAudioServicesTestClass::GetVAD")); |
|
2372 TInt error = KErrNone; |
|
2373 TBool aVad; |
|
2374 |
|
2375 switch (iUpLinkCodec) |
|
2376 { |
|
2377 case TMS_FORMAT_G711: |
|
2378 error = ((TMSG711Format*) iTmsFormatUp)->GetVADMode(aVad); |
|
2379 break; |
|
2380 case TMS_FORMAT_G729: |
|
2381 error = ((TMSG729Format*) iTmsFormatUp)->GetVADMode(aVad); |
|
2382 break; |
|
2383 case TMS_FORMAT_ILBC: |
|
2384 error = ((TMSILBCFormat*) iTmsFormatUp)->GetVADMode(aVad); |
|
2385 break; |
|
2386 default: |
|
2387 break; |
|
2388 } |
|
2389 |
|
2390 iLog->Log(_L("get VAD: %d"), aVad); |
|
2391 |
|
2392 if (aVad != iVad) |
|
2393 { |
|
2394 iLog->Log(_L("returned VAD doesn't match set VAD: Failed")); |
|
2395 error = KErrUnexpectedValue; |
|
2396 } |
|
2397 return error; |
|
2398 } |
|
2399 |
|
2400 TInt CTmsAudioServicesTestClass::ToggleVAD(CStifItemParser & /*aItem*/) |
|
2401 { |
|
2402 iLog ->Log(_L("CTmsAudioServicesTestClass::ToggleVAD")); |
|
2403 TInt error = KErrNone; |
|
2404 iVad = (iVad) ? EFalse : ETrue; |
|
2405 |
|
2406 switch (iUpLinkCodec) |
|
2407 { |
|
2408 case TMS_FORMAT_G711: |
|
2409 error = ((TMSG711Format*) iTmsFormatUp)->SetVADMode(iVad); |
|
2410 break; |
|
2411 case TMS_FORMAT_G729: |
|
2412 error = ((TMSG729Format*) iTmsFormatUp)->SetVADMode(iVad); |
|
2413 break; |
|
2414 case TMS_FORMAT_ILBC: |
|
2415 error = ((TMSILBCFormat*) iTmsFormatUp)->SetVADMode(iVad); |
|
2416 break; |
|
2417 default: |
|
2418 break; |
|
2419 } |
|
2420 iLog->Log(_L("VAD set: %d"), iVad); |
|
2421 return error; |
|
2422 } |
|
2423 |
|
2424 TInt CTmsAudioServicesTestClass::GetMode(CStifItemParser& aItem) |
|
2425 { |
|
2426 iLog->Log(_L("CTmsAudioServicesTestClass::GetMode")); |
|
2427 TInt error = KErrNone; |
|
2428 TPtrC linkType; |
|
2429 error = aItem.GetNextString(linkType); |
|
2430 if (error == KErrNone) |
|
2431 { |
|
2432 if ((linkType == KTagUplink) && (iUpLinkCodec == TMS_FORMAT_G711)) |
|
2433 { |
|
2434 TMSG711CodecMode aMode; |
|
2435 ((TMSG711Format*) iTmsFormatUp)->GetMode(aMode); |
|
2436 |
|
2437 if (aMode == TMS_G711_CODEC_MODE_ALAW) |
|
2438 { |
|
2439 iLog->Log(_L("UPL Mode: aLaw")); |
|
2440 } |
|
2441 else if (aMode == TMS_G711_CODEC_MODE_MULAW) |
|
2442 { |
|
2443 iLog->Log(_L("UPL Mode: uLaw")); |
|
2444 } |
|
2445 else |
|
2446 { |
|
2447 iLog->Log(_L("UPL Mode: unknown")); |
|
2448 } |
|
2449 } |
|
2450 else if ((linkType == KTagUplink) |
|
2451 && (iUpLinkCodec == TMS_FORMAT_ILBC)) |
|
2452 { |
|
2453 TMSILBCCodecMode aMode; |
|
2454 ((TMSILBCFormat*) iTmsFormatUp)->GetMode(aMode); |
|
2455 |
|
2456 if (aMode == TMS_ILBC_CODEC_MODE_20MS_FRAME) |
|
2457 { |
|
2458 iLog->Log(_L("UPL Mode: 20ms frame")); |
|
2459 } |
|
2460 else if (aMode == TMS_ILBC_CODEC_MODE_30MS_FRAME) |
|
2461 { |
|
2462 iLog->Log(_L("UPL Mode: 30ms frame")); |
|
2463 } |
|
2464 else |
|
2465 { |
|
2466 iLog->Log(_L("UPL Mode: unknown")); |
|
2467 } |
|
2468 } |
|
2469 else if ((linkType == KTagDnlink) |
|
2470 && (iDnLinkCodec == TMS_FORMAT_G711)) |
|
2471 { |
|
2472 TMSG711CodecMode aMode; |
|
2473 ((TMSG711Format*) iTmsFormatDn)->GetMode(aMode); |
|
2474 |
|
2475 if (aMode == TMS_G711_CODEC_MODE_ALAW) |
|
2476 { |
|
2477 iLog->Log(_L("DNL Mode: aLaw")); |
|
2478 } |
|
2479 else if (aMode == TMS_G711_CODEC_MODE_MULAW) |
|
2480 { |
|
2481 iLog->Log(_L("DNL Mode: uLaw")); |
|
2482 } |
|
2483 else |
|
2484 { |
|
2485 iLog->Log(_L("DNL Mode: unknown")); |
|
2486 } |
|
2487 } |
|
2488 else if ((linkType == KTagDnlink) |
|
2489 && (iDnLinkCodec == TMS_FORMAT_ILBC)) |
|
2490 { |
|
2491 TMSILBCCodecMode aMode; |
|
2492 ((TMSILBCFormat*) iTmsFormatDn)->GetMode(aMode); |
|
2493 |
|
2494 if (aMode == TMS_ILBC_CODEC_MODE_20MS_FRAME) |
|
2495 { |
|
2496 iLog->Log(_L("DNL Mode: 20ms frame")); |
|
2497 } |
|
2498 else if (aMode == TMS_ILBC_CODEC_MODE_30MS_FRAME) |
|
2499 { |
|
2500 iLog->Log(_L("DNL Mode: 30ms frame")); |
|
2501 } |
|
2502 else |
|
2503 { |
|
2504 iLog->Log(_L("DNL Mode: unknown")); |
|
2505 } |
|
2506 } |
|
2507 else |
|
2508 { |
|
2509 iLog->Log(KMsgBadTestParameters); |
|
2510 error = KErrBadTestParameter; |
|
2511 } |
|
2512 } |
|
2513 return error; |
|
2514 } |
|
2515 |
|
2516 TInt CTmsAudioServicesTestClass::SetMode(CStifItemParser& aItem) |
|
2517 { |
|
2518 iLog->Log(_L("CTmsAudioServicesTestClass::SetMode")); |
|
2519 TInt error = KErrNone; |
|
2520 TPtrC linkType; |
|
2521 error = aItem.GetNextString(linkType); |
|
2522 if (error != KErrNone) |
|
2523 { |
|
2524 return error; |
|
2525 } |
|
2526 |
|
2527 TPtrC mode; |
|
2528 error = aItem.GetNextString(mode); |
|
2529 if (error == KErrNone) |
|
2530 { |
|
2531 if ((linkType == KTagUplink) && (iUpLinkCodec == TMS_FORMAT_G711) |
|
2532 && (mode == KTagALaw)) |
|
2533 { |
|
2534 iLog->Log(_L("UPL Mode Set: aLaw")); |
|
2535 ((TMSG711Format*) iTmsFormatUp)->SetMode(TMS_G711_CODEC_MODE_ALAW); |
|
2536 } |
|
2537 else if ((linkType == KTagUplink) |
|
2538 && (iUpLinkCodec == TMS_FORMAT_G711) && (mode == KTagULaw)) |
|
2539 { |
|
2540 iLog->Log(_L("UPL Mode Set: uLaw")); |
|
2541 ((TMSG711Format*) iTmsFormatUp)->SetMode( |
|
2542 TMS_G711_CODEC_MODE_MULAW); |
|
2543 } |
|
2544 else if ((linkType == KTagUplink) |
|
2545 && (iUpLinkCodec == TMS_FORMAT_ILBC) && (mode == KTag20ms)) |
|
2546 { |
|
2547 iLog->Log(_L("UPL Mode Set: 20ms frame")); |
|
2548 ((TMSILBCFormat*) iTmsFormatUp)->SetMode( |
|
2549 TMS_ILBC_CODEC_MODE_20MS_FRAME); |
|
2550 } |
|
2551 else if ((linkType == KTagUplink) |
|
2552 && (iUpLinkCodec == TMS_FORMAT_ILBC) && (mode == KTag30ms)) |
|
2553 { |
|
2554 iLog->Log(_L("UPL Mode Set: 30ms frame")); |
|
2555 ((TMSILBCFormat*) iTmsFormatUp)->SetMode( |
|
2556 TMS_ILBC_CODEC_MODE_30MS_FRAME); |
|
2557 } |
|
2558 else if ((linkType == KTagDnlink) |
|
2559 && (iDnLinkCodec == TMS_FORMAT_G711) && (mode == KTagALaw)) |
|
2560 { |
|
2561 iLog->Log(_L("DNL Mode Set: aLaw")); |
|
2562 ((TMSG711Format*) iTmsFormatDn)->SetMode(TMS_G711_CODEC_MODE_ALAW); |
|
2563 } |
|
2564 else if ((linkType == KTagDnlink) |
|
2565 && (iDnLinkCodec == TMS_FORMAT_G711) && (mode == KTagULaw)) |
|
2566 { |
|
2567 iLog->Log(_L("DNL Mode Set: uLaw")); |
|
2568 ((TMSG711Format*) iTmsFormatDn)->SetMode( |
|
2569 TMS_G711_CODEC_MODE_MULAW); |
|
2570 } |
|
2571 else if ((linkType == KTagDnlink) |
|
2572 && (iDnLinkCodec == TMS_FORMAT_ILBC) && (mode == KTag20ms)) |
|
2573 { |
|
2574 iLog->Log(_L("DNL Mode Set: 20ms frame")); |
|
2575 ((TMSILBCFormat*) iTmsFormatDn)->SetMode( |
|
2576 TMS_ILBC_CODEC_MODE_20MS_FRAME); |
|
2577 } |
|
2578 else if ((linkType == KTagDnlink) |
|
2579 && (iDnLinkCodec == TMS_FORMAT_ILBC) && (mode == KTag30ms)) |
|
2580 { |
|
2581 iLog->Log(_L("DNL Mode Set: 30ms frame")); |
|
2582 ((TMSILBCFormat*) iTmsFormatDn)->SetMode( |
|
2583 TMS_ILBC_CODEC_MODE_30MS_FRAME); |
|
2584 } |
|
2585 else |
|
2586 { |
|
2587 iLog->Log(KMsgBadTestParameters); |
|
2588 error = KErrBadTestParameter; |
|
2589 } |
|
2590 } |
|
2591 return error; |
|
2592 } |
|
2593 |
|
2594 TInt CTmsAudioServicesTestClass::GetCNG(CStifItemParser& /*aItem*/) |
|
2595 { |
|
2596 FTRACE (FPrint(_L("CTmsAudioServicesTestClass::GetCNG"))); |
|
2597 iLog->Log(_L("CTmsAudioServicesTestClass::GetCNG")); |
|
2598 TInt error = KErrNone; |
|
2599 TBool aCng = EFalse; |
|
2600 switch (iDnLinkCodec) |
|
2601 { |
|
2602 case TMS_FORMAT_G711: |
|
2603 error = ((TMSG711Format*) iTmsFormatDn)->GetCNG(aCng); |
|
2604 iLog->Log(_L("CNG: %d"), aCng); |
|
2605 break; |
|
2606 case TMS_FORMAT_ILBC: |
|
2607 error = ((TMSILBCFormat*) iTmsFormatDn)->GetCNG(aCng); |
|
2608 iLog->Log(_L("CNG: %d"), aCng); |
|
2609 break; |
|
2610 default: |
|
2611 break; |
|
2612 } |
|
2613 |
|
2614 if (aCng != iCng) |
|
2615 { |
|
2616 iLog->Log(_L("returned Cng doesn't match set Cng: Failed")); |
|
2617 error = KErrUnexpectedValue; |
|
2618 } |
|
2619 return error; |
|
2620 } |
|
2621 |
|
2622 TInt CTmsAudioServicesTestClass::ToggleCNG(CStifItemParser & /*aItem*/) |
|
2623 { |
|
2624 |
|
2625 iLog ->Log(_L("CTmsAudioServicesTestClass::ToggleCNG")); |
|
2626 TInt error = KErrNone; |
|
2627 iCng = (iCng) ? EFalse : ETrue; |
|
2628 switch (iDnLinkCodec) |
|
2629 { |
|
2630 case TMS_FORMAT_G711: |
|
2631 ((TMSG711Format*) iTmsFormatDn)->SetCNG(iCng); |
|
2632 iLog->Log(_L("CNG set: %d"), iCng); |
|
2633 break; |
|
2634 case TMS_FORMAT_ILBC: |
|
2635 ((TMSILBCFormat*) iTmsFormatDn)->SetCNG(iCng); |
|
2636 iLog->Log(_L("CNG set: %d"), iCng); |
|
2637 break; |
|
2638 default: |
|
2639 break; |
|
2640 } |
|
2641 return error; |
|
2642 } |
|
2643 |
|
2644 TInt CTmsAudioServicesTestClass::GetPLC(CStifItemParser& /*aItem*/) |
|
2645 { |
|
2646 iLog->Log(_L("CTmsAudioServicesTestClass::GetPLC")); |
|
2647 TInt error = KErrNone; |
|
2648 TBool aPlc = EFalse; |
|
2649 if (iDnLinkCodec == TMS_FORMAT_G711) |
|
2650 { |
|
2651 ((TMSG711Format*) iTmsFormatDn)->GetPlc(aPlc); |
|
2652 iLog->Log(_L("PLC: %d"), aPlc); |
|
2653 } |
|
2654 |
|
2655 if (aPlc != iPlc) |
|
2656 { |
|
2657 iLog->Log(_L("returned Cng doesn't match set Plc: Failed")); |
|
2658 error = KErrUnexpectedValue; |
|
2659 } |
|
2660 return error; |
|
2661 } |
|
2662 |
|
2663 TInt CTmsAudioServicesTestClass::TogglePLC(CStifItemParser & /*aItem*/) |
|
2664 { |
|
2665 |
|
2666 iLog ->Log(_L("CTmsAudioServicesTestClass::TogglePLC")); |
|
2667 TInt error = KErrNone; |
|
2668 iPlc = (iPlc) ? EFalse : ETrue; |
|
2669 if (iDnLinkCodec == TMS_FORMAT_G711) |
|
2670 { |
|
2671 error = ((TMSG711Format*) iTmsFormatDn)->SetPlc(iPlc); |
|
2672 iLog->Log(_L("PLC set: %d"), iPlc); |
|
2673 } |
|
2674 |
|
2675 return error; |
|
2676 } |
|
2677 |
|
2678 TInt CTmsAudioServicesTestClass::GetBufferType(CStifItemParser& /*aItem*/) |
|
2679 { |
|
2680 FTRACE (FPrint(_L("CTmsAudioServicesTestClass::GetBufferType"))); |
|
2681 iLog->Log(_L("CTmsAudioServicesTestClass::GetBufferType")); |
|
2682 TInt error = KErrNone; |
|
2683 return error; |
|
2684 } |
|
2685 |
|
2686 // Note: IP ONLY |
|
2687 TInt CTmsAudioServicesTestClass::AddClientSrcToDnlStream(CStifItemParser& /*aItem*/) |
|
2688 { |
|
2689 iLog->Log(_L("CTmsAudioServicesTestClass::AddClientSrcToDnlStream")); |
|
2690 TInt error = KErrNone; |
|
2691 if (iTmsDnlink && iTmsClientSource) |
|
2692 { |
|
2693 error = iTmsDnlink->AddSource(iTmsClientSource); |
|
2694 } |
|
2695 iLog->Log( |
|
2696 _L("CTmsAudioServicesTestClass::AddClientSrcToDnlStream Error [%d]"), |
|
2697 error); |
|
2698 return error; |
|
2699 } |
|
2700 |
|
2701 // NOTE: CS and IP |
|
2702 TInt CTmsAudioServicesTestClass::AddMicSrcToUplStream(CStifItemParser& /*aItem*/) |
|
2703 { |
|
2704 iLog->Log(_L("CTmsAudioServicesTestClass::AddMicSrcToUplStream")); |
|
2705 TInt error = KErrNone; |
|
2706 if (iTmsUplink && iTmsMicSource) |
|
2707 { |
|
2708 error = iTmsUplink->AddSource(iTmsMicSource); |
|
2709 } |
|
2710 iLog->Log( |
|
2711 _L("CTmsAudioServicesTestClass::AddMicSrcToUplStream Error [%d]"), |
|
2712 error); |
|
2713 return error; |
|
2714 } |
|
2715 |
|
2716 // Note: CS ONLY |
|
2717 TInt CTmsAudioServicesTestClass::AddModemSrcToDnlStream(CStifItemParser& /*aItem*/) |
|
2718 { |
|
2719 iLog->Log(_L("CTmsAudioServicesTestClass::AddModemSrcToDnlStream")); |
|
2720 TInt error = KErrNone; |
|
2721 if (iTmsDnlink && iTmsModemSource) |
|
2722 { |
|
2723 error = iTmsDnlink->AddSource(iTmsModemSource); |
|
2724 } |
|
2725 iLog->Log( |
|
2726 _L("CTmsAudioServicesTestClass::AddModemSrcToDnlStream Error [%d]"), |
|
2727 error); |
|
2728 return error; |
|
2729 } |
|
2730 |
|
2731 // Note: IP ONLY |
|
2732 TInt CTmsAudioServicesTestClass::RemoveClientSrcFromDnlStream( |
|
2733 CStifItemParser& /*aItem*/) |
|
2734 { |
|
2735 iLog->Log(_L("CTmsAudioServicesTestClass::RemoveClientSrcFromDnlStream")); |
|
2736 TInt error = KErrNone; |
|
2737 if (iTmsDnlink && iTmsClientSource) |
|
2738 { |
|
2739 error = iTmsDnlink->RemoveSource(iTmsClientSource); |
|
2740 } |
|
2741 iLog->Log( |
|
2742 _L("CTmsAudioServicesTestClass::RemoveClientSrcFromDnlStream Error [%d]"), |
|
2743 error); |
|
2744 return error; |
|
2745 } |
|
2746 |
|
2747 // Note: CS and IP |
|
2748 TInt CTmsAudioServicesTestClass::RemoveMicSrcFromUplStream(CStifItemParser& /*aItem*/) |
|
2749 { |
|
2750 iLog->Log(_L("CTmsAudioServicesTestClass::RemoveMicSrcFromUplStream")); |
|
2751 TInt error = KErrNone; |
|
2752 if (iTmsUplink && iTmsMicSource) |
|
2753 { |
|
2754 error = iTmsUplink->RemoveSource(iTmsMicSource); |
|
2755 } |
|
2756 iLog->Log( |
|
2757 _L("CTmsAudioServicesTestClass::RemoveMicSrcFromUplStream Error [%d]"), |
|
2758 error); |
|
2759 return error; |
|
2760 } |
|
2761 |
|
2762 // Note: CS ONLY |
|
2763 TInt CTmsAudioServicesTestClass::RemoveModemSrcFromDnlStream(CStifItemParser& /*aItem*/) |
|
2764 { |
|
2765 iLog->Log(_L("CTmsAudioServicesTestClass::RemoveModemSrcFromDnlStream")); |
|
2766 TInt error = KErrNone; |
|
2767 if (iTmsDnlink && iTmsModemSource) |
|
2768 { |
|
2769 error = iTmsDnlink->RemoveSource(iTmsModemSource); |
|
2770 } |
|
2771 iLog->Log( |
|
2772 _L("CTmsAudioServicesTestClass::RemoveModemSrcFromDnlStream Error [%d]"), |
|
2773 error); |
|
2774 return error; |
|
2775 } |
|
2776 |
|
2777 TInt CTmsAudioServicesTestClass::AddSourceObserver(CStifItemParser& /*aItem*/) |
|
2778 { |
|
2779 iLog->Log(_L("CTmsAudioServicesTestClass::AddSourceObserver")); |
|
2780 TInt error = KErrNone; |
|
2781 if (iTmsClientSource) |
|
2782 { |
|
2783 error = ((TMSClientSource*) iTmsClientSource)->AddObserver(*this, |
|
2784 NULL); |
|
2785 } |
|
2786 return error; |
|
2787 } |
|
2788 |
|
2789 TInt CTmsAudioServicesTestClass::RemoveSourceObserver(CStifItemParser& /*aItem*/) |
|
2790 { |
|
2791 iLog->Log(_L("CTmsAudioServicesTestClass::RemoveSourceObserver")); |
|
2792 TInt error = KErrNone; |
|
2793 if (iTmsClientSource) |
|
2794 { |
|
2795 error = ((TMSClientSource*) iTmsClientSource)->RemoveObserver(*this); |
|
2796 } |
|
2797 return error; |
|
2798 } |
|
2799 |
|
2800 TInt CTmsAudioServicesTestClass::AddClientSinkToUplStream(CStifItemParser& /*aItem*/) |
|
2801 { |
|
2802 iLog->Log(_L("CTmsAudioServicesTestClass::AddClientSinkToUplStream")); |
|
2803 TInt error = KErrNone; |
|
2804 if (iTmsUplink && iTmsClientSink) |
|
2805 { |
|
2806 //((TMSClientSink*) iTmsSink)->AddObserver(*this, NULL); |
|
2807 error = iTmsUplink->AddSink(iTmsClientSink); |
|
2808 } |
|
2809 return error; |
|
2810 } |
|
2811 |
|
2812 TInt CTmsAudioServicesTestClass::AddModemSinkToUplStream(CStifItemParser& /*aItem*/) |
|
2813 { |
|
2814 iLog->Log(_L("CTmsAudioServicesTestClass::AddModemSinkToUplStream")); |
|
2815 TInt error = KErrNone; |
|
2816 if (iTmsUplink && iTmsModemSink) |
|
2817 { |
|
2818 //((TMSClientSink*) iTmsSink)->AddObserver(*this, NULL); |
|
2819 error = iTmsUplink->AddSink(iTmsModemSink); |
|
2820 } |
|
2821 return error; |
|
2822 } |
|
2823 |
|
2824 TInt CTmsAudioServicesTestClass::AddSpkrSinkToDnlStream(CStifItemParser& /*aItem*/) |
|
2825 { |
|
2826 iLog->Log(_L("CTmsAudioServicesTestClass::AddSpkrSinkToDnlStream")); |
|
2827 TInt error = KErrNone; |
|
2828 if (iTmsDnlink && iTmsSpkrSink) |
|
2829 { |
|
2830 error = iTmsDnlink->AddSink(iTmsSpkrSink); |
|
2831 } |
|
2832 return error; |
|
2833 } |
|
2834 |
|
2835 TInt CTmsAudioServicesTestClass::RemoveClientSinkFromUplStream( |
|
2836 CStifItemParser& /*aItem*/) |
|
2837 { |
|
2838 iLog->Log(_L("CTmsAudioServicesTestClass::RemoveClientSinkFromUplStream")); |
|
2839 TInt error = KErrNone; |
|
2840 if (iTmsUplink && iTmsClientSink) |
|
2841 { |
|
2842 error = iTmsUplink->RemoveSink(iTmsClientSink); |
|
2843 } |
|
2844 return error; |
|
2845 } |
|
2846 |
|
2847 TInt CTmsAudioServicesTestClass::RemoveModemSinkFromUplStream( |
|
2848 CStifItemParser& /*aItem*/) |
|
2849 { |
|
2850 iLog->Log(_L("CTmsAudioServicesTestClass::RemoveModemSinkFromUplStream")); |
|
2851 TInt error = KErrNone; |
|
2852 if (iTmsUplink && iTmsModemSink) |
|
2853 { |
|
2854 error = iTmsUplink->RemoveSink(iTmsModemSink); |
|
2855 } |
|
2856 return error; |
|
2857 } |
|
2858 |
|
2859 TInt CTmsAudioServicesTestClass::RemoveSpkrSinkFromDnlStream(CStifItemParser& /*aItem*/) |
|
2860 { |
|
2861 iLog->Log(_L("CTmsAudioServicesTestClass::RemoveSpkrSinkFromDnlStream")); |
|
2862 TInt error = KErrNone; |
|
2863 if (iTmsDnlink && iTmsSpkrSink) |
|
2864 { |
|
2865 error = iTmsDnlink->RemoveSink(iTmsSpkrSink); |
|
2866 } |
|
2867 return error; |
|
2868 } |
|
2869 |
|
2870 TInt CTmsAudioServicesTestClass::AddSinkObserver(CStifItemParser& /*aItem*/) |
|
2871 { |
|
2872 iLog ->Log(_L("CTmsAudioServicesTestClass::AddSinkObserver")); |
|
2873 TInt error = KErrNone; |
|
2874 if (iTmsUplink && iTmsClientSink) |
|
2875 { |
|
2876 error = ((TMSClientSink*) iTmsClientSink)->AddObserver(*this, NULL); |
|
2877 } |
|
2878 return error; |
|
2879 } |
|
2880 |
|
2881 TInt CTmsAudioServicesTestClass::RemoveSinkObserver(CStifItemParser& /*aItem*/) |
|
2882 { |
|
2883 iLog->Log(_L("CTmsAudioServicesTestClass::RemoveSinkObserver")); |
|
2884 TInt error = KErrNone; |
|
2885 if (iTmsUplink && iTmsClientSink) |
|
2886 { |
|
2887 error = ((TMSClientSink*) iTmsClientSink)->RemoveObserver(*this); |
|
2888 } |
|
2889 return error; |
|
2890 } |
|
2891 |
|
2892 gint CTmsAudioServicesTestClass::CreateVolumeEffect() |
|
2893 { |
|
2894 iLog->Log(_L("CTmsAudioServicesTestClass::CreateVolumeEffect")); |
|
2895 gint status(KErrNone); |
|
2896 if (iFactory && iTmsDnlink && !iTmsDnlinkEffect) |
|
2897 { |
|
2898 status = iFactory->CreateEffect(TMS_EFFECT_VOLUME, iTmsDnlinkEffect); |
|
2899 if (status == KErrNone) |
|
2900 { |
|
2901 ((TMSVolumeEffect*) iTmsDnlinkEffect)->AddObserver(*this, NULL); |
|
2902 } |
|
2903 } |
|
2904 RDebug::Printf("[TMS STIF] CreateVolumeEffect Return [%d]", status); |
|
2905 return status; |
|
2906 } |
|
2907 |
|
2908 gint CTmsAudioServicesTestClass::CreateVolumeGlobleEffect() |
|
2909 { |
|
2910 iLog->Log(_L("CTmsAudioServicesTestClass::CreateVolumeGlobleEffect")); |
|
2911 gint status(KErrNone); |
|
2912 if (iFactory && !iGlobalVol) |
|
2913 { |
|
2914 status = iFactory->CreateEffect(TMS_EFFECT_GLOBAL_VOL, iGlobalVol); |
|
2915 |
|
2916 if (status == KErrNone) |
|
2917 { |
|
2918 ((TMSGlobalVolEffect*) iGlobalVol)->AddObserver(*this, NULL); |
|
2919 iLog->Log( |
|
2920 _L("CTmsAudioServicesTestClass::CreateVolumeGlobleEffect - AddObserver")); |
|
2921 } |
|
2922 } |
|
2923 RDebug::Printf("[TMS STIF] CreateVolumeGlobleEffect Return [%d]", status); |
|
2924 return status; |
|
2925 } |
|
2926 |
|
2927 TInt CTmsAudioServicesTestClass::AddVolumeEffectToStream(CStifItemParser& /*aItem*/) |
|
2928 { |
|
2929 iLog->Log(_L("CTmsAudioServicesTestClass::AddVolumeEffectToStream")); |
|
2930 TInt error = KErrNone; |
|
2931 if (iTmsDnlink && iTmsDnlinkEffect) |
|
2932 { |
|
2933 error = iTmsDnlink->AddEffect(iTmsDnlinkEffect); |
|
2934 } |
|
2935 return error; |
|
2936 } |
|
2937 |
|
2938 TInt CTmsAudioServicesTestClass::AddGlobleVolumeEffectToStream( |
|
2939 CStifItemParser& /*aItem*/) |
|
2940 { |
|
2941 iLog->Log(_L("CTmsAudioServicesTestClass::AddGlobleVolumeEffectToStream")); |
|
2942 TInt error = KErrNone; |
|
2943 if (iTmsDnlink && iGlobalVol) |
|
2944 { |
|
2945 error = iTmsDnlink->AddEffect(iGlobalVol); |
|
2946 } |
|
2947 return error; |
|
2948 } |
|
2949 |
|
2950 TInt CTmsAudioServicesTestClass::RemoveGlobleVolumeEffectToStream( |
|
2951 CStifItemParser& /*aItem*/) |
|
2952 { |
|
2953 iLog->Log( |
|
2954 _L("CTmsAudioServicesTestClass::RemoveGlobleVolumeEffectToStream")); |
|
2955 TInt error = KErrNone; |
|
2956 if (iTmsDnlink && iGlobalVol) |
|
2957 { |
|
2958 error = iTmsDnlink->RemoveEffect(iGlobalVol); |
|
2959 } |
|
2960 return error; |
|
2961 } |
|
2962 |
|
2963 gint CTmsAudioServicesTestClass::CreateGainEffect() |
|
2964 { |
|
2965 iLog->Log(_L("CTmsAudioServicesTestClass::CreateGainEffect")); |
|
2966 gint status(KErrNone); |
|
2967 |
|
2968 if (iFactory && iTmsUplink && !iTmsUplinkEffect) |
|
2969 { |
|
2970 status = iFactory->CreateEffect(TMS_EFFECT_GAIN, iTmsUplinkEffect); |
|
2971 if (status == KErrNone) |
|
2972 { |
|
2973 ((TMSGainEffect*) iTmsUplinkEffect)->AddObserver(*this, NULL); |
|
2974 } |
|
2975 } |
|
2976 RDebug::Printf("[TMS STIF] CreateGainEffect Return [%d]", status); |
|
2977 return status; |
|
2978 } |
|
2979 |
|
2980 gint CTmsAudioServicesTestClass::CreateGlobleGainEffect() |
|
2981 { |
|
2982 iLog->Log(_L("CTmsAudioServicesTestClass::CreateGlobleGainEffect")); |
|
2983 gint status(KErrNone); |
|
2984 if (iFactory && !iGlobalGain) |
|
2985 { |
|
2986 status = iFactory->CreateEffect(TMS_EFFECT_GLOBAL_GAIN, iGlobalGain); |
|
2987 if (status == KErrNone) |
|
2988 { |
|
2989 ((TMSGlobalGainEffect*) iGlobalGain)->AddObserver(*this, NULL); |
|
2990 } |
|
2991 } |
|
2992 RDebug::Printf("[TMS STIF] CreateGlobleGainEffect Return [%d]", status); |
|
2993 return status; |
|
2994 } |
|
2995 |
|
2996 TInt CTmsAudioServicesTestClass::AddGainEffectToStream(CStifItemParser& /*aItem*/) |
|
2997 { |
|
2998 iLog->Log(_L("CTmsAudioServicesTestClass::AddGainEffectToStream")); |
|
2999 TInt error = KErrNone; |
|
3000 if (iTmsUplink && iTmsUplinkEffect) |
|
3001 { |
|
3002 error = iTmsUplink->AddEffect(iTmsUplinkEffect); |
|
3003 } |
|
3004 return error; |
|
3005 } |
|
3006 |
|
3007 TInt CTmsAudioServicesTestClass::AddGlobleGainEffectToStream(CStifItemParser& /*aItem*/) |
|
3008 { |
|
3009 iLog->Log(_L("CTmsAudioServicesTestClass::AddGlobleGainEffectToStream")); |
|
3010 TInt error = KErrNone; |
|
3011 if (iTmsUplink && iGlobalGain) |
|
3012 { |
|
3013 error = iTmsUplink->AddEffect(iGlobalGain); |
|
3014 } |
|
3015 return error; |
|
3016 } |
|
3017 |
|
3018 TInt CTmsAudioServicesTestClass::RemoveGlobleGainEffectToStream( |
|
3019 CStifItemParser& /*aItem*/) |
|
3020 { |
|
3021 iLog->Log( |
|
3022 _L("CTmsAudioServicesTestClass::RemoveGlobleGainEffectToStream")); |
|
3023 TInt error = KErrNone; |
|
3024 if (iTmsUplink && iGlobalGain) |
|
3025 { |
|
3026 error = iTmsUplink->RemoveEffect(iGlobalGain); |
|
3027 } |
|
3028 return error; |
|
3029 } |
|
3030 |
|
3031 // ---------------------------------------------------------------------------- |
|
3032 // CTmsTestEngine::DoLoopback |
|
3033 // |
|
3034 // ---------------------------------------------------------------------------- |
|
3035 // |
|
3036 void CTmsAudioServicesTestClass::DoLoopback() |
|
3037 { |
|
3038 iLog->Log(_L("CTmsAudioServicesTestClass::DoLoopback")); |
|
3039 |
|
3040 if (iPlayBufReady && iRecBufReady) |
|
3041 { |
|
3042 iLog->Log(_L("Both uplink and downlink are ready")); |
|
3043 guint8* srcptr(0); |
|
3044 guint8* desptr(0); |
|
3045 guint srcsize(0); |
|
3046 guint dessize(0); |
|
3047 |
|
3048 iPlayBuf->GetDataPtr(desptr); |
|
3049 iPlayBuf->GetDataSize(dessize); |
|
3050 |
|
3051 iRecBuf->GetDataPtr(srcptr); |
|
3052 iRecBuf->GetDataSize(srcsize); |
|
3053 |
|
3054 Mem::Copy(desptr, srcptr, srcsize); |
|
3055 |
|
3056 ((TMSClientSource*) iTmsClientSource)->BufferFilled(*iPlayBuf); |
|
3057 ((TMSClientSink*) iTmsClientSink)->BufferProcessed(iRecBuf); |
|
3058 |
|
3059 iPlayBufReady = EFalse; // buf filled, ready for FillBuffer |
|
3060 iRecBufReady = EFalse; // buf consumed, ready for EmptyBuffer |
|
3061 } |
|
3062 |
|
3063 iLog->Log(_L("CTmsAudioServicesTestClass::DoLoopback END")); |
|
3064 } |
|
3065 |
|
3066 TInt CTmsAudioServicesTestClass::ConfigEncAudDevice(CStifItemParser& /*aItem*/) |
|
3067 { |
|
3068 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::ConfigEncAudDevice"))); |
|
3069 iLog->Log(_L("CTmsAudioServicesTestClass::ConfigEncAudDevice")); |
|
3070 TInt error = KErrNone; |
|
3071 return error; |
|
3072 } |
|
3073 |
|
3074 // ---------------------------------------------------------------------------- |
|
3075 // CTmsAudioServicesTestClass::DisplayDevice |
|
3076 // |
|
3077 // ---------------------------------------------------------------------------- |
|
3078 // |
|
3079 void CTmsAudioServicesTestClass::DisplayDevice(TMSAudioOutput device) |
|
3080 { |
|
3081 switch (device) |
|
3082 { |
|
3083 case TMS_AUDIO_OUTPUT_NONE: |
|
3084 iLog->Log(_L("none")); |
|
3085 break; |
|
3086 case TMS_AUDIO_OUTPUT_PUBLIC: |
|
3087 iLog->Log(_L("Public")); |
|
3088 break; |
|
3089 case TMS_AUDIO_OUTPUT_PRIVATE: |
|
3090 iLog->Log(_L("Private")); |
|
3091 break; |
|
3092 case TMS_AUDIO_OUTPUT_HANDSET: |
|
3093 iLog->Log(_L("Handset")); |
|
3094 break; |
|
3095 case TMS_AUDIO_OUTPUT_LOUDSPEAKER: |
|
3096 iLog->Log(_L("Loudspeaker")); |
|
3097 break; |
|
3098 case TMS_AUDIO_OUTPUT_WIRED_ACCESSORY: |
|
3099 iLog->Log(_L("Wired accessory")); |
|
3100 break; |
|
3101 case TMS_AUDIO_OUTPUT_ACCESSORY: |
|
3102 iLog->Log(_L("Accessory")); |
|
3103 break; |
|
3104 case TMS_AUDIO_OUTPUT_ETTY: |
|
3105 iLog->Log(_L("TTY")); |
|
3106 break; |
|
3107 default: |
|
3108 break; |
|
3109 } |
|
3110 } |