| changeset 42 | 1fa3fb47b1e3 |
| parent 32 | 94fc26b6e006 |
| child 55 | e267340986c9 |
| 32:94fc26b6e006 | 42:1fa3fb47b1e3 |
|---|---|
45 void TMSCallIPAdpt::ConstructL() |
45 void TMSCallIPAdpt::ConstructL() |
46 { |
46 { |
47 TRACE_PRN_FN_ENT; |
47 TRACE_PRN_FN_ENT; |
48 iIPDownlink = NULL; |
48 iIPDownlink = NULL; |
49 iIPUplink = NULL; |
49 iIPUplink = NULL; |
50 iDTMFDnlinkPlayer = NULL; |
|
51 iDTMFUplinkPlayer = NULL; |
|
52 iDTMFNotifier = NULL; |
|
53 TRACE_PRN_FN_EXT; |
50 TRACE_PRN_FN_EXT; |
54 } |
51 } |
55 |
52 |
56 // ----------------------------------------------------------------------------- |
53 // ----------------------------------------------------------------------------- |
57 // TMSCallIPAdpt::TMSCallIPAdpt |
54 // TMSCallIPAdpt::TMSCallIPAdpt |
72 TRACE_PRN_FN_ENT; |
69 TRACE_PRN_FN_ENT; |
73 |
70 |
74 iCodecs.Reset(); |
71 iCodecs.Reset(); |
75 iCodecs.Close(); |
72 iCodecs.Close(); |
76 iArrBitrates.Reset(); |
73 iArrBitrates.Reset(); |
77 delete iDTMFUplinkPlayer; |
|
78 delete iDTMFDnlinkPlayer; |
|
79 delete iDTMFNotifier; |
|
80 delete iIPUplink; |
74 delete iIPUplink; |
81 delete iIPDownlink; |
75 delete iIPDownlink; |
82 |
76 |
83 if (iMsgQueueUp.Handle() > 0) |
77 if (iMsgQueueUp.Handle() > 0) |
84 { |
78 { |
100 gint TMSCallIPAdpt::PostConstruct() |
94 gint TMSCallIPAdpt::PostConstruct() |
101 { |
95 { |
102 TRACE_PRN_FN_ENT; |
96 TRACE_PRN_FN_ENT; |
103 gint status(TMS_RESULT_SUCCESS); |
97 gint status(TMS_RESULT_SUCCESS); |
104 iNextStreamId = 1; |
98 iNextStreamId = 1; |
105 iUplinkInitialized = FALSE; |
99 iUplState = EIdle; |
106 iDnlinkInitialized = FALSE; |
100 iDnlState = EIdle; |
107 TRACE_PRN_FN_EXT; |
101 TRACE_PRN_FN_EXT; |
108 return status; |
102 return status; |
109 } |
103 } |
110 |
104 |
111 // ----------------------------------------------------------------------------- |
105 // ----------------------------------------------------------------------------- |
121 switch (strmType) |
115 switch (strmType) |
122 { |
116 { |
123 case TMS_STREAM_UPLINK: |
117 case TMS_STREAM_UPLINK: |
124 { |
118 { |
125 status = TMS_RESULT_ALREADY_EXIST; |
119 status = TMS_RESULT_ALREADY_EXIST; |
126 if (!iUplinkInitialized) |
120 if (iUplState == EIdle) |
127 { |
121 { |
128 iUplinkStreamId = iNextStreamId; |
122 iUplinkStreamId = iNextStreamId; |
129 outStrmId = iUplinkStreamId; |
123 outStrmId = iUplinkStreamId; |
130 iNextStreamId++; |
124 iNextStreamId++; |
131 //iUplinkInitialized = TRUE; //not initialized yet! |
|
132 status = TMS_RESULT_SUCCESS; |
125 status = TMS_RESULT_SUCCESS; |
133 } |
126 } |
134 break; |
127 break; |
135 } |
128 } |
136 case TMS_STREAM_DOWNLINK: |
129 case TMS_STREAM_DOWNLINK: |
137 { |
130 { |
138 status = TMS_RESULT_ALREADY_EXIST; |
131 status = TMS_RESULT_ALREADY_EXIST; |
139 if (!iDnlinkInitialized) |
132 if (iDnlState == EIdle) |
140 { |
133 { |
141 iDnlinkStreamId = iNextStreamId; |
134 iDnlinkStreamId = iNextStreamId; |
142 outStrmId = iDnlinkStreamId; |
135 outStrmId = iDnlinkStreamId; |
143 iNextStreamId++; |
136 iNextStreamId++; |
144 //iDnlinkInitialized = TRUE; //not initialized yet! |
|
145 status = TMS_RESULT_SUCCESS; |
137 status = TMS_RESULT_SUCCESS; |
146 } |
138 } |
147 break; |
139 break; |
148 } |
140 } |
149 default: |
141 default: |
181 status = TMS_RESULT_DOES_NOT_EXIST; |
173 status = TMS_RESULT_DOES_NOT_EXIST; |
182 if (strmId == iUplinkStreamId) |
174 if (strmId == iUplinkStreamId) |
183 { |
175 { |
184 SetFormat(iUplinkStreamId, fourCC); |
176 SetFormat(iUplinkStreamId, fourCC); |
185 status = OpenUplink(message, retrytime); |
177 status = OpenUplink(message, retrytime); |
186 if (status == TMS_RESULT_SUCCESS) |
|
187 { |
|
188 status = InitDTMF(TMS_STREAM_UPLINK); |
|
189 } |
|
190 } |
178 } |
191 break; |
179 break; |
192 } |
180 } |
193 case TMS_STREAM_DOWNLINK: |
181 case TMS_STREAM_DOWNLINK: |
194 { |
182 { |
195 status = TMS_RESULT_DOES_NOT_EXIST; |
183 status = TMS_RESULT_DOES_NOT_EXIST; |
196 if (strmId == iDnlinkStreamId) |
184 if (strmId == iDnlinkStreamId) |
197 { |
185 { |
198 SetFormat(iDnlinkStreamId, fourCC); |
186 SetFormat(iDnlinkStreamId, fourCC); |
199 status = OpenDownlink(message, retrytime); |
187 status = OpenDownlink(message, retrytime); |
200 if (status == TMS_RESULT_SUCCESS) |
|
201 { |
|
202 status = InitDTMF(TMS_STREAM_DOWNLINK); |
|
203 } |
|
204 } |
188 } |
205 break; |
189 break; |
206 } |
190 } |
207 default: |
191 default: |
208 { |
192 { |
228 gint status(TMS_RESULT_INVALID_STATE); |
212 gint status(TMS_RESULT_INVALID_STATE); |
229 switch (strmType) |
213 switch (strmType) |
230 { |
214 { |
231 case TMS_STREAM_UPLINK: |
215 case TMS_STREAM_UPLINK: |
232 { |
216 { |
233 if (iIPUplink && strmId == iUplinkStreamId) |
217 if (iIPUplink && strmId == iUplinkStreamId && |
218 iUplState == EInitialized) |
|
234 { |
219 { |
235 iIPUplink->Start(retrytime); |
220 iIPUplink->Start(retrytime); |
236 status = TMS_RESULT_SUCCESS; |
221 status = TMS_RESULT_SUCCESS; |
237 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
|
238 } |
222 } |
239 break; |
223 break; |
240 } |
224 } |
241 case TMS_STREAM_DOWNLINK: |
225 case TMS_STREAM_DOWNLINK: |
242 { |
226 { |
243 if (iIPDownlink && strmId == iDnlinkStreamId) |
227 if (iIPDownlink && strmId == iDnlinkStreamId && |
228 iDnlState == EInitialized) |
|
244 { |
229 { |
245 iIPDownlink->Start(retrytime); |
230 iIPDownlink->Start(retrytime); |
246 status = TMS_RESULT_SUCCESS; |
231 status = TMS_RESULT_SUCCESS; |
247 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
|
248 } |
232 } |
249 break; |
233 break; |
250 } |
234 } |
251 default: |
235 default: |
252 { |
236 { |
273 case TMS_STREAM_UPLINK: |
257 case TMS_STREAM_UPLINK: |
274 { |
258 { |
275 if (strmId == iUplinkStreamId && iIPUplink) |
259 if (strmId == iUplinkStreamId && iIPUplink) |
276 { |
260 { |
277 iIPUplink->Stop(); |
261 iIPUplink->Stop(); |
262 iUplState = EInitialized; |
|
278 status = TMS_RESULT_SUCCESS; |
263 status = TMS_RESULT_SUCCESS; |
279 NotifyClient(iUplinkStreamId, ECmdUplinkPaused, status); |
264 NotifyClient(iUplinkStreamId, ECmdUplinkPaused, status); |
280 } |
265 } |
281 break; |
266 break; |
282 } |
267 } |
283 case TMS_STREAM_DOWNLINK: |
268 case TMS_STREAM_DOWNLINK: |
284 { |
269 { |
285 if (strmId == iDnlinkStreamId && iIPDownlink) |
270 if (strmId == iDnlinkStreamId && iIPDownlink) |
286 { |
271 { |
287 iIPDownlink->Stop(); |
272 iIPDownlink->Stop(); |
273 iDnlState = EInitialized; |
|
288 status = TMS_RESULT_SUCCESS; |
274 status = TMS_RESULT_SUCCESS; |
289 NotifyClient(iDnlinkStreamId, ECmdDownlinkPaused, status); |
275 NotifyClient(iDnlinkStreamId, ECmdDownlinkPaused, status); |
290 } |
276 } |
291 break; |
277 break; |
292 } |
278 } |
313 |
299 |
314 switch (strmType) |
300 switch (strmType) |
315 { |
301 { |
316 case TMS_STREAM_UPLINK: |
302 case TMS_STREAM_UPLINK: |
317 { |
303 { |
318 if (iIPUplink && strmId == iUplinkStreamId) |
304 if (iIPUplink && strmId == iUplinkStreamId && |
305 iUplState == EActivated) |
|
319 { |
306 { |
320 iIPUplink->Stop(); |
307 iIPUplink->Stop(); |
308 iUplState = EInitialized; |
|
321 status = TMS_RESULT_SUCCESS; |
309 status = TMS_RESULT_SUCCESS; |
322 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
310 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
323 } |
311 } |
324 break; |
312 break; |
325 } |
313 } |
326 case TMS_STREAM_DOWNLINK: |
314 case TMS_STREAM_DOWNLINK: |
327 { |
315 { |
328 if (iIPDownlink && strmId == iDnlinkStreamId) |
316 if (iIPDownlink && strmId == iDnlinkStreamId && |
317 iDnlState == EActivated) |
|
329 { |
318 { |
330 iIPDownlink->Stop(); |
319 iIPDownlink->Stop(); |
320 iDnlState = EInitialized; |
|
331 status = TMS_RESULT_SUCCESS; |
321 status = TMS_RESULT_SUCCESS; |
332 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
322 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
333 } |
323 } |
334 break; |
324 break; |
335 } |
325 } |
356 |
346 |
357 switch (strmType) |
347 switch (strmType) |
358 { |
348 { |
359 case TMS_STREAM_UPLINK: |
349 case TMS_STREAM_UPLINK: |
360 { |
350 { |
361 if (iIPUplink && strmId == iUplinkStreamId) |
351 if (iIPUplink && strmId == iUplinkStreamId && iUplState != EIdle) |
362 { |
352 { |
363 iIPUplink->Stop(); |
353 iIPUplink->Stop(); |
364 //iUplinkStreamId = -1; |
354 iUplState = EIdle; |
365 iUplinkInitialized = FALSE; |
|
366 status = TMS_RESULT_SUCCESS; |
355 status = TMS_RESULT_SUCCESS; |
367 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status); |
356 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status); |
368 } |
357 } |
369 break; |
358 break; |
370 } |
359 } |
371 case TMS_STREAM_DOWNLINK: |
360 case TMS_STREAM_DOWNLINK: |
372 { |
361 { |
373 if (iIPDownlink && strmId == iDnlinkStreamId) |
362 if (iIPDownlink && strmId == iDnlinkStreamId && iDnlState != EIdle) |
374 { |
363 { |
375 iIPDownlink->Stop(); |
364 iIPDownlink->Stop(); |
376 //iDnlinkStreamId = -1; |
365 iDnlState = EIdle; |
377 iDnlinkInitialized = FALSE; |
|
378 status = TMS_RESULT_SUCCESS; |
366 status = TMS_RESULT_SUCCESS; |
379 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete, |
367 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete, |
380 status); |
368 status); |
381 } |
369 } |
382 break; |
370 break; |
385 { |
373 { |
386 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
374 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
387 break; |
375 break; |
388 } |
376 } |
389 } |
377 } |
390 |
|
391 TRACE_PRN_FN_EXT; |
378 TRACE_PRN_FN_EXT; |
392 return status; |
379 return status; |
393 } |
380 } |
394 |
381 |
395 // ----------------------------------------------------------------------------- |
382 // ----------------------------------------------------------------------------- |
407 case TMS_STREAM_UPLINK: |
394 case TMS_STREAM_UPLINK: |
408 { |
395 { |
409 if (strmId == iUplinkStreamId) |
396 if (strmId == iUplinkStreamId) |
410 { |
397 { |
411 iUplinkStreamId = -1; |
398 iUplinkStreamId = -1; |
412 iUplinkInitialized = FALSE; |
399 iUplState = EIdle; |
413 } |
400 } |
414 break; |
401 break; |
415 } |
402 } |
416 case TMS_STREAM_DOWNLINK: |
403 case TMS_STREAM_DOWNLINK: |
417 { |
404 { |
418 if (strmId == iDnlinkStreamId) |
405 if (strmId == iDnlinkStreamId) |
419 { |
406 { |
420 iDnlinkStreamId = -1; |
407 iDnlinkStreamId = -1; |
421 iDnlinkInitialized = FALSE; |
408 iDnlState = EIdle; |
422 } |
409 } |
423 break; |
410 break; |
424 } |
411 } |
425 default: |
412 default: |
426 { |
413 { |
536 // |
523 // |
537 gint TMSCallIPAdpt::GetMaxVolume(guint& volume) |
524 gint TMSCallIPAdpt::GetMaxVolume(guint& volume) |
538 { |
525 { |
539 TRACE_PRN_FN_ENT; |
526 TRACE_PRN_FN_ENT; |
540 gint status(TMS_RESULT_INVALID_STATE); |
527 gint status(TMS_RESULT_INVALID_STATE); |
541 if (iDnlinkInitialized && iIPDownlink) |
528 if (iIPDownlink && iDnlState != EIdle) |
542 { |
529 { |
543 status = iIPDownlink->GetMaxVolume(volume); |
530 status = iIPDownlink->GetMaxVolume(volume); |
544 iMaxVolume = volume; |
531 iMaxVolume = volume; |
545 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume); |
532 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume); |
546 } |
533 } |
555 // |
542 // |
556 gint TMSCallIPAdpt::SetVolume(const guint volume) |
543 gint TMSCallIPAdpt::SetVolume(const guint volume) |
557 { |
544 { |
558 TRACE_PRN_FN_ENT; |
545 TRACE_PRN_FN_ENT; |
559 gint status(TMS_RESULT_INVALID_STATE); |
546 gint status(TMS_RESULT_INVALID_STATE); |
560 if (iDnlinkInitialized && iIPDownlink) |
547 if (iIPDownlink && iDnlState != EIdle) |
561 { |
548 { |
562 status = iIPDownlink->SetVolume(volume); |
549 status = iIPDownlink->SetVolume(volume); |
563 NotifyClient(iDnlinkStreamId, ECmdSetVolume, status); |
550 NotifyClient(iDnlinkStreamId, ECmdSetVolume, status); |
564 } |
551 } |
565 TRACE_PRN_FN_EXT; |
552 TRACE_PRN_FN_EXT; |
573 // |
560 // |
574 gint TMSCallIPAdpt::GetVolume(guint& volume) |
561 gint TMSCallIPAdpt::GetVolume(guint& volume) |
575 { |
562 { |
576 TRACE_PRN_FN_ENT; |
563 TRACE_PRN_FN_ENT; |
577 gint status(TMS_RESULT_INVALID_STATE); |
564 gint status(TMS_RESULT_INVALID_STATE); |
578 if (iDnlinkInitialized && iIPDownlink) |
565 if (iIPDownlink && iDnlState != EIdle) |
579 { |
566 { |
580 status = iIPDownlink->GetVolume(volume); |
567 status = iIPDownlink->GetVolume(volume); |
581 } |
568 } |
582 TRACE_PRN_FN_EXT; |
569 TRACE_PRN_FN_EXT; |
583 return status; |
570 return status; |
590 // |
577 // |
591 gint TMSCallIPAdpt::GetMaxGain(guint& gain) |
578 gint TMSCallIPAdpt::GetMaxGain(guint& gain) |
592 { |
579 { |
593 TRACE_PRN_FN_ENT; |
580 TRACE_PRN_FN_ENT; |
594 gint status(TMS_RESULT_INVALID_STATE); |
581 gint status(TMS_RESULT_INVALID_STATE); |
595 if (iUplinkInitialized && iIPUplink) |
582 if (iIPUplink && iUplState != EIdle) |
596 { |
583 { |
597 status = iIPUplink->GetMaxGain(gain); |
584 status = iIPUplink->GetMaxGain(gain); |
598 iMaxGain = gain; |
585 iMaxGain = gain; |
599 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetMaxGain [%d]"), iMaxGain); |
586 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetMaxGain [%d]"), iMaxGain); |
600 } |
587 } |
609 // |
596 // |
610 gint TMSCallIPAdpt::SetGain(const guint gain) |
597 gint TMSCallIPAdpt::SetGain(const guint gain) |
611 { |
598 { |
612 TRACE_PRN_FN_ENT; |
599 TRACE_PRN_FN_ENT; |
613 gint status(TMS_RESULT_INVALID_STATE); |
600 gint status(TMS_RESULT_INVALID_STATE); |
614 if (iUplinkInitialized && iIPUplink) |
601 if (iIPUplink && iUplState != EIdle) |
615 { |
602 { |
616 status = iIPUplink->SetGain(gain); |
603 status = iIPUplink->SetGain(gain); |
617 NotifyClient(iUplinkStreamId, ECmdSetGain, status); |
604 NotifyClient(iUplinkStreamId, ECmdSetGain, status); |
618 } |
605 } |
619 TRACE_PRN_FN_EXT; |
606 TRACE_PRN_FN_EXT; |
627 // |
614 // |
628 gint TMSCallIPAdpt::GetGain(guint& gain) |
615 gint TMSCallIPAdpt::GetGain(guint& gain) |
629 { |
616 { |
630 TRACE_PRN_FN_ENT; |
617 TRACE_PRN_FN_ENT; |
631 gint status(TMS_RESULT_INVALID_STATE); |
618 gint status(TMS_RESULT_INVALID_STATE); |
632 if (iUplinkInitialized && iIPUplink) |
619 if (iIPUplink && iUplState != EIdle) |
633 { |
620 { |
634 status = iIPUplink->GetGain(gain); |
621 status = iIPUplink->GetGain(gain); |
635 } |
622 } |
636 TRACE_PRN_FN_EXT; |
623 TRACE_PRN_FN_EXT; |
637 return status; |
624 return status; |
644 // |
631 // |
645 gint TMSCallIPAdpt::GetGlobalMaxVolume(guint& volume) |
632 gint TMSCallIPAdpt::GetGlobalMaxVolume(guint& volume) |
646 { |
633 { |
647 TRACE_PRN_FN_ENT; |
634 TRACE_PRN_FN_ENT; |
648 gint status(TMS_RESULT_INVALID_STATE); |
635 gint status(TMS_RESULT_INVALID_STATE); |
649 if (iDnlinkInitialized && iIPDownlink) |
636 if (iIPDownlink && iDnlState != EIdle) |
650 { |
637 { |
651 status = iIPDownlink->GetMaxVolume(volume); |
638 status = iIPDownlink->GetMaxVolume(volume); |
652 iMaxVolume = volume; |
639 iMaxVolume = volume; |
653 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetGlobalMaxVolume [%d]"), volume); |
640 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetGlobalMaxVolume [%d]"), volume); |
654 } |
641 } |
664 gint TMSCallIPAdpt::SetGlobalVolume(const guint volume) |
651 gint TMSCallIPAdpt::SetGlobalVolume(const guint volume) |
665 { |
652 { |
666 TRACE_PRN_FN_ENT; |
653 TRACE_PRN_FN_ENT; |
667 gint status(TMS_RESULT_INVALID_STATE); |
654 gint status(TMS_RESULT_INVALID_STATE); |
668 //iGlobalVol = volume; |
655 //iGlobalVol = volume; |
669 if (iDnlinkInitialized && iIPDownlink) |
656 if (iIPDownlink && iDnlState != EIdle) |
670 { |
657 { |
671 status = iIPDownlink->SetVolume(volume); |
658 status = iIPDownlink->SetVolume(volume); |
672 } |
659 } |
673 TRACE_PRN_FN_EXT; |
660 TRACE_PRN_FN_EXT; |
674 return status; |
661 return status; |
681 // |
668 // |
682 gint TMSCallIPAdpt::GetGlobalVolume(guint& volume) |
669 gint TMSCallIPAdpt::GetGlobalVolume(guint& volume) |
683 { |
670 { |
684 TRACE_PRN_FN_ENT; |
671 TRACE_PRN_FN_ENT; |
685 gint status(TMS_RESULT_INVALID_STATE); |
672 gint status(TMS_RESULT_INVALID_STATE); |
686 if (iDnlinkInitialized && iIPDownlink) |
673 if (iIPDownlink && iDnlState != EIdle) |
687 { |
674 { |
688 status = iIPDownlink->GetVolume(volume); |
675 status = iIPDownlink->GetVolume(volume); |
689 } |
676 } |
690 TRACE_PRN_FN_EXT; |
677 TRACE_PRN_FN_EXT; |
691 return status; |
678 return status; |
698 // |
685 // |
699 gint TMSCallIPAdpt::GetGlobalMaxGain(guint& gain) |
686 gint TMSCallIPAdpt::GetGlobalMaxGain(guint& gain) |
700 { |
687 { |
701 TRACE_PRN_FN_ENT; |
688 TRACE_PRN_FN_ENT; |
702 gint status(TMS_RESULT_INVALID_STATE); |
689 gint status(TMS_RESULT_INVALID_STATE); |
703 if (iUplinkInitialized && iIPUplink) |
690 if (iIPUplink && iUplState != EIdle) |
704 { |
691 { |
705 status = iIPUplink->GetMaxGain(gain); |
692 status = iIPUplink->GetMaxGain(gain); |
706 iMaxGain = gain; |
693 iMaxGain = gain; |
707 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetGlobalMaxGain [%d]"), gain); |
694 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetGlobalMaxGain [%d]"), gain); |
708 } |
695 } |
718 gint TMSCallIPAdpt::SetGlobalGain(const guint gain) |
705 gint TMSCallIPAdpt::SetGlobalGain(const guint gain) |
719 { |
706 { |
720 TRACE_PRN_FN_ENT; |
707 TRACE_PRN_FN_ENT; |
721 gint status(TMS_RESULT_INVALID_STATE); |
708 gint status(TMS_RESULT_INVALID_STATE); |
722 //iGlobalGain = gain; |
709 //iGlobalGain = gain; |
723 if (iUplinkInitialized && iIPUplink) |
710 if (iIPUplink && iUplState != EIdle) |
724 { |
711 { |
725 status = iIPUplink->SetGain(gain); |
712 status = iIPUplink->SetGain(gain); |
726 } |
713 } |
727 TRACE_PRN_FN_EXT; |
714 TRACE_PRN_FN_EXT; |
728 return status; |
715 return status; |
735 // |
722 // |
736 gint TMSCallIPAdpt::GetGlobalGain(guint& gain) |
723 gint TMSCallIPAdpt::GetGlobalGain(guint& gain) |
737 { |
724 { |
738 TRACE_PRN_FN_ENT; |
725 TRACE_PRN_FN_ENT; |
739 gint status(TMS_RESULT_INVALID_STATE); |
726 gint status(TMS_RESULT_INVALID_STATE); |
740 if (iUplinkInitialized && iIPUplink) |
727 if (iIPUplink && iUplState != EIdle) |
741 { |
728 { |
742 status = iIPUplink->GetGain(gain); |
729 status = iIPUplink->GetGain(gain); |
743 } |
730 } |
744 TRACE_PRN_FN_EXT; |
731 TRACE_PRN_FN_EXT; |
745 return status; |
732 return status; |
804 // |
791 // |
805 gint TMSCallIPAdpt::GetSupportedBitRatesCount(guint& count) |
792 gint TMSCallIPAdpt::GetSupportedBitRatesCount(guint& count) |
806 { |
793 { |
807 TRACE_PRN_FN_ENT; |
794 TRACE_PRN_FN_ENT; |
808 gint status(TMS_RESULT_INVALID_STATE); |
795 gint status(TMS_RESULT_INVALID_STATE); |
809 if (iIPUplink) |
796 if (iIPUplink && iUplState != EIdle) |
810 { |
797 { |
811 status = iIPUplink->GetSupportedBitrates(iArrBitrates); |
798 status = iIPUplink->GetSupportedBitrates(iArrBitrates); |
812 count = iArrBitrates.Count(); |
799 count = iArrBitrates.Count(); |
813 } |
800 } |
814 TRACE_PRN_FN_EXT; |
801 TRACE_PRN_FN_EXT; |
860 // |
847 // |
861 gint TMSCallIPAdpt::GetBitRate(guint& bitrate) |
848 gint TMSCallIPAdpt::GetBitRate(guint& bitrate) |
862 { |
849 { |
863 TRACE_PRN_FN_ENT; |
850 TRACE_PRN_FN_ENT; |
864 gint status(TMS_RESULT_INVALID_STATE); |
851 gint status(TMS_RESULT_INVALID_STATE); |
865 if (iIPUplink) |
852 if (iIPUplink && iUplState != EIdle) |
866 { |
853 { |
867 status = iIPUplink->GetBitrate(bitrate); |
854 status = iIPUplink->GetBitrate(bitrate); |
868 } |
855 } |
869 TRACE_PRN_FN_EXT; |
856 TRACE_PRN_FN_EXT; |
870 return status; |
857 return status; |
877 // |
864 // |
878 gint TMSCallIPAdpt::SetBitRate(const guint bitrate) |
865 gint TMSCallIPAdpt::SetBitRate(const guint bitrate) |
879 { |
866 { |
880 TRACE_PRN_FN_ENT; |
867 TRACE_PRN_FN_ENT; |
881 gint status(TMS_RESULT_INVALID_STATE); |
868 gint status(TMS_RESULT_INVALID_STATE); |
882 if (iIPUplink) |
869 if (iIPUplink && iUplState != EIdle) |
883 { |
870 { |
884 status = iIPUplink->SetBitrate(bitrate); |
871 status = iIPUplink->SetBitrate(bitrate); |
885 } |
872 } |
886 TRACE_PRN_FN_EXT; |
873 TRACE_PRN_FN_EXT; |
887 return status; |
874 return status; |
894 // |
881 // |
895 gint TMSCallIPAdpt::GetVAD(const TMSFormatType fmttype, gboolean& vad) |
882 gint TMSCallIPAdpt::GetVAD(const TMSFormatType fmttype, gboolean& vad) |
896 { |
883 { |
897 TRACE_PRN_FN_ENT; |
884 TRACE_PRN_FN_ENT; |
898 gint status(TMS_RESULT_INVALID_STATE); |
885 gint status(TMS_RESULT_INVALID_STATE); |
899 if (iIPUplink) |
886 if (iIPUplink && iUplState != EIdle) |
900 { |
887 { |
901 status = iIPUplink->GetVad(fmttype, vad); |
888 status = iIPUplink->GetVad(fmttype, vad); |
902 } |
889 } |
903 TRACE_PRN_FN_EXT; |
890 TRACE_PRN_FN_EXT; |
904 return status; |
891 return status; |
911 // |
898 // |
912 gint TMSCallIPAdpt::SetVAD(const TMSFormatType fmttype, const gboolean vad) |
899 gint TMSCallIPAdpt::SetVAD(const TMSFormatType fmttype, const gboolean vad) |
913 { |
900 { |
914 TRACE_PRN_FN_ENT; |
901 TRACE_PRN_FN_ENT; |
915 gint status(TMS_RESULT_INVALID_STATE); |
902 gint status(TMS_RESULT_INVALID_STATE); |
916 if (iIPUplink) |
903 if (iIPUplink && iUplState != EIdle) |
917 { |
904 { |
918 status = iIPUplink->SetVad(fmttype, vad); |
905 status = iIPUplink->SetVad(fmttype, vad); |
919 } |
906 } |
920 TRACE_PRN_FN_EXT; |
907 TRACE_PRN_FN_EXT; |
921 return status; |
908 return status; |
928 // |
915 // |
929 gint TMSCallIPAdpt::GetCNG(const TMSFormatType fmttype, gboolean& cng) |
916 gint TMSCallIPAdpt::GetCNG(const TMSFormatType fmttype, gboolean& cng) |
930 { |
917 { |
931 TRACE_PRN_FN_ENT; |
918 TRACE_PRN_FN_ENT; |
932 gint status(TMS_RESULT_INVALID_STATE); |
919 gint status(TMS_RESULT_INVALID_STATE); |
933 if (iIPDownlink) |
920 if (iIPDownlink && iDnlState == EInitialized) |
934 { |
921 { |
935 status = iIPDownlink->GetCng(fmttype, cng); |
922 status = iIPDownlink->GetCng(fmttype, cng); |
936 } |
923 } |
937 TRACE_PRN_FN_EXT; |
924 TRACE_PRN_FN_EXT; |
938 return status; |
925 return status; |
945 // |
932 // |
946 gint TMSCallIPAdpt::SetCNG(const TMSFormatType fmttype, const gboolean cng) |
933 gint TMSCallIPAdpt::SetCNG(const TMSFormatType fmttype, const gboolean cng) |
947 { |
934 { |
948 TRACE_PRN_FN_ENT; |
935 TRACE_PRN_FN_ENT; |
949 gint status(TMS_RESULT_INVALID_STATE); |
936 gint status(TMS_RESULT_INVALID_STATE); |
950 if (iIPDownlink) |
937 if (iIPDownlink && iDnlState == EInitialized) |
951 { |
938 { |
952 status = iIPDownlink->SetCng(fmttype, cng); |
939 status = iIPDownlink->SetCng(fmttype, cng); |
953 } |
940 } |
954 TRACE_PRN_FN_EXT; |
941 TRACE_PRN_FN_EXT; |
955 return status; |
942 return status; |
962 // |
949 // |
963 gint TMSCallIPAdpt::GetPlc(const TMSFormatType fmttype, gboolean& plc) |
950 gint TMSCallIPAdpt::GetPlc(const TMSFormatType fmttype, gboolean& plc) |
964 { |
951 { |
965 TRACE_PRN_FN_ENT; |
952 TRACE_PRN_FN_ENT; |
966 gint status(TMS_RESULT_INVALID_STATE); |
953 gint status(TMS_RESULT_INVALID_STATE); |
967 if (iIPDownlink) |
954 if (iIPDownlink && iDnlState != EIdle) |
968 { |
955 { |
969 status = iIPDownlink->GetPlc(fmttype, plc); |
956 status = iIPDownlink->GetPlc(fmttype, plc); |
970 } |
957 } |
971 TRACE_PRN_FN_EXT; |
958 TRACE_PRN_FN_EXT; |
972 return status; |
959 return status; |
979 // |
966 // |
980 gint TMSCallIPAdpt::SetPlc(const TMSFormatType fmttype, const gboolean plc) |
967 gint TMSCallIPAdpt::SetPlc(const TMSFormatType fmttype, const gboolean plc) |
981 { |
968 { |
982 TRACE_PRN_FN_ENT; |
969 TRACE_PRN_FN_ENT; |
983 gint status(TMS_RESULT_INVALID_STATE); |
970 gint status(TMS_RESULT_INVALID_STATE); |
984 if (iIPDownlink) |
971 if (iIPDownlink && iDnlState == EInitialized) |
985 { |
972 { |
986 status = iIPDownlink->SetPlc(fmttype, plc); |
973 status = iIPDownlink->SetPlc(fmttype, plc); |
987 } |
974 } |
988 TRACE_PRN_FN_EXT; |
975 TRACE_PRN_FN_EXT; |
989 return status; |
976 return status; |
1053 * 1) KAudioPrefUnknownVoipAudioUplink -3rd party VoIP? |
1040 * 1) KAudioPrefUnknownVoipAudioUplink -3rd party VoIP? |
1054 * KAudioPriorityUnknownVoipAudioUplink -3rd party VoIP? |
1041 * KAudioPriorityUnknownVoipAudioUplink -3rd party VoIP? |
1055 * 2) KAudioPrefVoipAudioUplink -NOK native VoIP? |
1042 * 2) KAudioPrefVoipAudioUplink -NOK native VoIP? |
1056 * KAudioPriorityVoipAudioUplink -NOK native VoIP? |
1043 * KAudioPriorityVoipAudioUplink -NOK native VoIP? |
1057 */ |
1044 */ |
1058 iPriority.iPref = KAudioPrefVoipAudioUplink; |
1045 iPriority.iPref = KAudioPrefVoipAudioUplinkNonSignal; |
1059 iPriority.iPriority = KAudioPriorityVoipAudioUplink; |
1046 iPriority.iPriority = KAudioPriorityVoipAudioUplink; |
1060 |
1047 |
1061 delete iIPUplink; |
1048 delete iIPUplink; |
1062 iIPUplink = NULL; |
1049 iIPUplink = NULL; |
1063 TRAP(status, iIPUplink = TMSIPUplink::NewL(*this, iUpFourCC, iPriority, |
1050 TRAP(status, iIPUplink = TMSIPUplink::NewL(*this, iUpFourCC, iPriority, |
1170 // ----------------------------------------------------------------------------- |
1157 // ----------------------------------------------------------------------------- |
1171 // |
1158 // |
1172 gint TMSCallIPAdpt::SetIlbcCodecMode(const gint mode, |
1159 gint TMSCallIPAdpt::SetIlbcCodecMode(const gint mode, |
1173 const TMSStreamType strmtype) |
1160 const TMSStreamType strmtype) |
1174 { |
1161 { |
1175 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1162 gint status(TMS_RESULT_SUCCESS); |
1176 |
1163 |
1177 if (strmtype == TMS_STREAM_DOWNLINK) |
1164 if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink && |
1178 { |
1165 iDnlState == EInitialized) |
1179 if (iDnlinkInitialized && iIPDownlink) |
1166 { |
1180 { |
1167 status = iIPDownlink->SetIlbcCodecMode(mode); |
1181 status = iIPDownlink->SetIlbcCodecMode(mode); |
1168 } |
1182 } |
1169 else if (strmtype == TMS_STREAM_UPLINK && iIPUplink && |
1183 } |
1170 iUplState == EInitialized) |
1184 else if (strmtype == TMS_STREAM_UPLINK) |
1171 { |
1185 { |
1172 status = iIPUplink->SetIlbcCodecMode(mode); |
1186 if (iUplinkInitialized && iIPUplink) |
1173 } |
1187 { |
1174 else |
1188 status = iIPUplink->SetIlbcCodecMode(mode); |
1175 { |
1189 } |
1176 status = TMS_RESULT_INVALID_STATE; |
1190 } |
1177 } |
1191 |
|
1192 return status; |
1178 return status; |
1193 } |
1179 } |
1194 |
1180 |
1195 // ----------------------------------------------------------------------------- |
1181 // ----------------------------------------------------------------------------- |
1196 // TMSCallIPAdpt::GetIlbcCodecMode |
1182 // TMSCallIPAdpt::GetIlbcCodecMode |
1197 // |
1183 // |
1198 // ----------------------------------------------------------------------------- |
1184 // ----------------------------------------------------------------------------- |
1199 // |
1185 // |
1200 gint TMSCallIPAdpt::GetIlbcCodecMode(gint& mode, const TMSStreamType strmtype) |
1186 gint TMSCallIPAdpt::GetIlbcCodecMode(gint& mode, const TMSStreamType strmtype) |
1201 { |
1187 { |
1202 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1188 gint status(TMS_RESULT_SUCCESS); |
1203 |
1189 |
1204 if (strmtype == TMS_STREAM_DOWNLINK) |
1190 if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink && |
1205 { |
1191 iDnlState != EIdle) |
1206 if (iDnlinkInitialized && iIPDownlink) |
1192 { |
1207 { |
1193 status = iIPDownlink->GetIlbcCodecMode(mode); |
1208 status = iIPDownlink->GetIlbcCodecMode(mode); |
1194 } |
1209 } |
1195 else if (strmtype == TMS_STREAM_UPLINK && iIPUplink && |
1210 } |
1196 iUplState != EIdle) |
1211 else if (strmtype == TMS_STREAM_UPLINK) |
1197 { |
1212 { |
1198 status = iIPUplink->GetIlbcCodecMode(mode); |
1213 if (iUplinkInitialized && iIPUplink) |
1199 } |
1214 { |
1200 else |
1215 status = iIPUplink->GetIlbcCodecMode(mode); |
1201 { |
1216 } |
1202 status = TMS_RESULT_INVALID_STATE; |
1217 } |
1203 } |
1218 |
|
1219 return status; |
1204 return status; |
1220 } |
1205 } |
1221 |
1206 |
1222 // ----------------------------------------------------------------------------- |
1207 // ----------------------------------------------------------------------------- |
1223 // TMSCallIPAdpt::SetG711CodecMode |
1208 // TMSCallIPAdpt::SetG711CodecMode |
1225 // ----------------------------------------------------------------------------- |
1210 // ----------------------------------------------------------------------------- |
1226 // |
1211 // |
1227 gint TMSCallIPAdpt::SetG711CodecMode(const gint mode, |
1212 gint TMSCallIPAdpt::SetG711CodecMode(const gint mode, |
1228 const TMSStreamType strmtype) |
1213 const TMSStreamType strmtype) |
1229 { |
1214 { |
1230 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1215 gint status(TMS_RESULT_SUCCESS); |
1231 |
1216 |
1232 if (strmtype == TMS_STREAM_DOWNLINK) |
1217 if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink && |
1233 { |
1218 iDnlState == EInitialized) |
1234 if (iDnlinkInitialized && iIPDownlink) |
1219 { |
1235 { |
1220 status = iIPDownlink->SetG711CodecMode(mode); |
1236 status = iIPDownlink->SetG711CodecMode(mode); |
1221 } |
1237 } |
1222 else if (strmtype == TMS_STREAM_UPLINK && iIPUplink && |
1238 } |
1223 iUplState == EInitialized) |
1239 else if (strmtype == TMS_STREAM_UPLINK) |
1224 { |
1240 { |
1225 status = iIPUplink->SetG711CodecMode(mode); |
1241 if (iUplinkInitialized && iIPUplink) |
1226 } |
1242 { |
1227 else |
1243 status = iIPUplink->SetG711CodecMode(mode); |
1228 { |
1244 } |
1229 status = TMS_RESULT_INVALID_STATE; |
1245 } |
1230 } |
1246 |
|
1247 return status; |
1231 return status; |
1248 } |
1232 } |
1249 |
1233 |
1250 // ----------------------------------------------------------------------------- |
1234 // ----------------------------------------------------------------------------- |
1251 // TMSCallIPAdpt::GetG711CodecMode |
1235 // TMSCallIPAdpt::GetG711CodecMode |
1252 // |
1236 // |
1253 // ----------------------------------------------------------------------------- |
1237 // ----------------------------------------------------------------------------- |
1254 // |
1238 // |
1255 gint TMSCallIPAdpt::GetG711CodecMode(gint& mode, const TMSStreamType strmtype) |
1239 gint TMSCallIPAdpt::GetG711CodecMode(gint& mode, const TMSStreamType strmtype) |
1256 { |
1240 { |
1257 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1241 gint status(TMS_RESULT_SUCCESS); |
1258 |
1242 |
1259 if (strmtype == TMS_STREAM_DOWNLINK) |
1243 if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink && |
1260 { |
1244 iDnlState != EIdle) |
1261 if (iDnlinkInitialized && iIPDownlink) |
1245 { |
1262 { |
1246 status = iIPDownlink->GetG711CodecMode(mode); |
1263 status = iIPDownlink->GetG711CodecMode(mode); |
1247 } |
1264 } |
1248 else if (strmtype == TMS_STREAM_UPLINK && iIPUplink && |
1265 } |
1249 iUplState != EIdle) |
1266 else if (strmtype == TMS_STREAM_UPLINK) |
1250 { |
1267 { |
1251 status = iIPUplink->GetG711CodecMode(mode); |
1268 if (iUplinkInitialized && iIPUplink) |
1252 } |
1269 { |
1253 else |
1270 status = iIPUplink->GetG711CodecMode(mode); |
1254 { |
1271 } |
1255 status = TMS_RESULT_INVALID_STATE; |
1272 } |
1256 } |
1273 |
|
1274 return status; |
1257 return status; |
1275 } |
1258 } |
1276 |
1259 |
1277 // ----------------------------------------------------------------------------- |
1260 // ----------------------------------------------------------------------------- |
1278 // TMSCallIPAdpt::FrameModeRequiredForEC |
1261 // TMSCallIPAdpt::FrameModeRequiredForEC |
1279 // |
1262 // |
1280 // ----------------------------------------------------------------------------- |
1263 // ----------------------------------------------------------------------------- |
1281 // |
1264 // |
1282 gint TMSCallIPAdpt::FrameModeRqrdForEC(gboolean& frmodereq) |
1265 gint TMSCallIPAdpt::FrameModeRqrdForEC(gboolean& frmodereq) |
1283 { |
1266 { |
1284 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1267 gint status(TMS_RESULT_INVALID_STATE); |
1285 if (iIPDownlink) |
1268 if (iIPDownlink && iDnlState == EInitialized) |
1286 { |
1269 { |
1287 status = iIPDownlink->FrameModeRqrdForEC(frmodereq); |
1270 status = iIPDownlink->FrameModeRqrdForEC(frmodereq); |
1288 } |
1271 } |
1289 return status; |
1272 return status; |
1290 } |
1273 } |
1294 // |
1277 // |
1295 // ----------------------------------------------------------------------------- |
1278 // ----------------------------------------------------------------------------- |
1296 // |
1279 // |
1297 gint TMSCallIPAdpt::SetFrameMode(const gboolean frmode) |
1280 gint TMSCallIPAdpt::SetFrameMode(const gboolean frmode) |
1298 { |
1281 { |
1299 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1282 gint status(TMS_RESULT_INVALID_STATE); |
1300 if (iIPDownlink) |
1283 if (iIPDownlink && iDnlState == EInitialized) |
1301 { |
1284 { |
1302 status = iIPDownlink->SetFrameMode(frmode); |
1285 status = iIPDownlink->SetFrameMode(frmode); |
1303 } |
1286 } |
1304 return status; |
1287 return status; |
1305 } |
1288 } |
1309 // |
1292 // |
1310 // ----------------------------------------------------------------------------- |
1293 // ----------------------------------------------------------------------------- |
1311 // |
1294 // |
1312 gint TMSCallIPAdpt::GetFrameMode(gboolean& frmode) |
1295 gint TMSCallIPAdpt::GetFrameMode(gboolean& frmode) |
1313 { |
1296 { |
1314 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1297 gint status(TMS_RESULT_INVALID_STATE); |
1315 if (iIPDownlink) |
1298 if (iIPDownlink && iDnlState != EIdle) |
1316 { |
1299 { |
1317 status = iIPDownlink->GetFrameMode(frmode); |
1300 status = iIPDownlink->GetFrameMode(frmode); |
1318 } |
1301 } |
1319 return status; |
1302 return status; |
1320 } |
1303 } |
1323 // TMSCallIPAdpt::ConcealErrorForNextBuffer |
1306 // TMSCallIPAdpt::ConcealErrorForNextBuffer |
1324 // ----------------------------------------------------------------------------- |
1307 // ----------------------------------------------------------------------------- |
1325 // |
1308 // |
1326 gint TMSCallIPAdpt::ConcealErrorForNextBuffer() |
1309 gint TMSCallIPAdpt::ConcealErrorForNextBuffer() |
1327 { |
1310 { |
1328 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1311 gint status(TMS_RESULT_INVALID_STATE); |
1329 if (iIPDownlink) |
1312 if (iIPDownlink && iDnlState == EActivated) |
1330 { |
1313 { |
1331 status = iIPDownlink->ConcealErrorForNextBuffer(); |
1314 status = iIPDownlink->ConcealErrorForNextBuffer(); |
1332 } |
1315 } |
1333 return status; |
1316 return status; |
1334 } |
1317 } |
1338 // |
1321 // |
1339 // ----------------------------------------------------------------------------- |
1322 // ----------------------------------------------------------------------------- |
1340 // |
1323 // |
1341 gint TMSCallIPAdpt::BadLsfNextBuffer() |
1324 gint TMSCallIPAdpt::BadLsfNextBuffer() |
1342 { |
1325 { |
1343 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1326 gint status(TMS_RESULT_INVALID_STATE); |
1344 if (iIPDownlink) |
1327 if (iIPDownlink && iDnlState == EActivated) |
1345 { |
1328 { |
1346 status = iIPDownlink->BadLsfNextBuffer(); |
1329 status = iIPDownlink->BadLsfNextBuffer(); |
1347 } |
1330 } |
1348 return status; |
1331 return status; |
1349 } |
1332 } |
1354 // ----------------------------------------------------------------------------- |
1337 // ----------------------------------------------------------------------------- |
1355 // |
1338 // |
1356 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output) |
1339 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output) |
1357 { |
1340 { |
1358 TRACE_PRN_FN_ENT; |
1341 TRACE_PRN_FN_ENT; |
1359 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1342 gint status(TMS_RESULT_INVALID_STATE); |
1360 if (iDnlinkInitialized && iIPDownlink) |
1343 if (iIPDownlink && iDnlState != EIdle) |
1361 { |
1344 { |
1362 TRAP(status, iIPDownlink->SetAudioDeviceL(output)); |
1345 TRAP(status, iIPDownlink->SetAudioDeviceL(output)); |
1363 } |
1346 } |
1364 TRACE_PRN_FN_EXT; |
1347 TRACE_PRN_FN_EXT; |
1365 return status; |
1348 return status; |
1366 } |
1349 } |
1350 |
|
1367 // ----------------------------------------------------------------------------- |
1351 // ----------------------------------------------------------------------------- |
1368 // TMSCallIPAdpt::GetOutput |
1352 // TMSCallIPAdpt::GetOutput |
1369 // |
1353 // |
1370 // ----------------------------------------------------------------------------- |
1354 // ----------------------------------------------------------------------------- |
1371 // |
1355 // |
1372 gint TMSCallIPAdpt::GetOutput(TMSAudioOutput& output) |
1356 gint TMSCallIPAdpt::GetOutput(TMSAudioOutput& output) |
1373 { |
1357 { |
1374 TRACE_PRN_FN_ENT; |
1358 TRACE_PRN_FN_ENT; |
1375 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1359 gint status(TMS_RESULT_INVALID_STATE); |
1376 if (iDnlinkInitialized && iIPDownlink) |
1360 if (iIPDownlink && iDnlState != EIdle) |
1377 { |
1361 { |
1378 TRAP(status, iIPDownlink->GetAudioDeviceL(output)); |
1362 TRAP(status, iIPDownlink->GetAudioDeviceL(output)); |
1379 } |
1363 } |
1380 TRACE_PRN_FN_EXT; |
1364 TRACE_PRN_FN_EXT; |
1381 return status; |
1365 return status; |
1397 // ----------------------------------------------------------------------------- |
1381 // ----------------------------------------------------------------------------- |
1398 // |
1382 // |
1399 gint TMSCallIPAdpt::GetAvailableOutputsL(gint& /*count*/, |
1383 gint TMSCallIPAdpt::GetAvailableOutputsL(gint& /*count*/, |
1400 CBufFlat*& /*outputsbuf*/) |
1384 CBufFlat*& /*outputsbuf*/) |
1401 { |
1385 { |
1386 //TODO: return public & private |
|
1402 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
1387 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
1403 } |
|
1404 |
|
1405 // ----------------------------------------------------------------------------- |
|
1406 // TMSCallIPAdpt::InitDTMF |
|
1407 // |
|
1408 // ----------------------------------------------------------------------------- |
|
1409 // |
|
1410 gint TMSCallIPAdpt::InitDTMF(TMSStreamType strmtype) |
|
1411 { |
|
1412 TRACE_PRN_FN_ENT; |
|
1413 gint status(TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED); |
|
1414 |
|
1415 if (strmtype == TMS_STREAM_DOWNLINK) |
|
1416 { |
|
1417 delete iDTMFDnlinkPlayer; |
|
1418 iDTMFDnlinkPlayer = NULL; |
|
1419 TRAP(status, iDTMFDnlinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this, |
|
1420 KAudioDTMFString, KAudioPriorityDTMFString)); |
|
1421 } |
|
1422 else if (strmtype == TMS_STREAM_UPLINK) |
|
1423 { |
|
1424 delete iDTMFUplinkPlayer; |
|
1425 iDTMFUplinkPlayer = NULL; |
|
1426 TRAP(status, iDTMFUplinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this, |
|
1427 KAudioDTMFString, KAudioPriorityDTMFString)); |
|
1428 } |
|
1429 |
|
1430 if (!iDTMFNotifier && status == TMS_RESULT_SUCCESS) |
|
1431 { |
|
1432 TRAP(status, iDTMFNotifier = TMSDtmfNotifier::NewL()); |
|
1433 } |
|
1434 |
|
1435 TRACE_PRN_FN_EXT; |
|
1436 return status; |
|
1437 } |
|
1438 |
|
1439 // ----------------------------------------------------------------------------- |
|
1440 // TMSCallIPAdpt::StartDTMF |
|
1441 // |
|
1442 // ----------------------------------------------------------------------------- |
|
1443 // |
|
1444 gint TMSCallIPAdpt::StartDTMF(TMSStreamType strmtype, TDes& dtmfstring) |
|
1445 { |
|
1446 TRACE_PRN_FN_ENT; |
|
1447 gint status(TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED); |
|
1448 TmsMsgBufPckg dtmfpckg; |
|
1449 dtmfpckg().iStatus = status; |
|
1450 dtmfpckg().iRequest = ECmdDTMFTonePlayFinished; |
|
1451 |
|
1452 if (strmtype == TMS_STREAM_DOWNLINK) |
|
1453 { |
|
1454 status = TMS_RESULT_UNINITIALIZED_OBJECT; |
|
1455 if (iDTMFDnlinkPlayer) |
|
1456 { |
|
1457 iDTMFDnlinkPlayer->PlayDtmfTone(dtmfstring); |
|
1458 status = TMS_RESULT_SUCCESS; |
|
1459 } |
|
1460 dtmfpckg().iStatus = status; |
|
1461 dtmfpckg().iRequest = ECmdDTMFToneDnlPlayStarted; |
|
1462 } |
|
1463 else if (strmtype == TMS_STREAM_UPLINK) |
|
1464 { |
|
1465 status = TMS_RESULT_UNINITIALIZED_OBJECT; |
|
1466 if (iDTMFUplinkPlayer) |
|
1467 { |
|
1468 iDTMFUplinkPlayer->PlayDtmfTone(dtmfstring); |
|
1469 status = TMS_RESULT_SUCCESS; |
|
1470 } |
|
1471 dtmfpckg().iStatus = status; |
|
1472 dtmfpckg().iRequest = ECmdDTMFToneUplPlayStarted; |
|
1473 } |
|
1474 |
|
1475 if (iDTMFNotifier) |
|
1476 { |
|
1477 iDTMFNotifier->SetDtmf(dtmfpckg); |
|
1478 } |
|
1479 |
|
1480 TRACE_PRN_IF_ERR(status); |
|
1481 TRACE_PRN_FN_EXT; |
|
1482 return status; |
|
1483 } |
|
1484 |
|
1485 // ----------------------------------------------------------------------------- |
|
1486 // TMSCallIPAdpt::StopDTMF |
|
1487 // |
|
1488 // ----------------------------------------------------------------------------- |
|
1489 // |
|
1490 gint TMSCallIPAdpt::StopDTMF(TMSStreamType streamtype) |
|
1491 { |
|
1492 TRACE_PRN_FN_ENT; |
|
1493 gint status(TMS_RESULT_SUCCESS); |
|
1494 |
|
1495 if (streamtype == TMS_STREAM_DOWNLINK && iDTMFDnlinkPlayer) |
|
1496 { |
|
1497 iDTMFDnlinkPlayer->Cancel(); |
|
1498 } |
|
1499 else if (streamtype == TMS_STREAM_UPLINK && iDTMFUplinkPlayer) |
|
1500 { |
|
1501 //status = iDTMFUplinkPlayer->StopDtmfTone(); |
|
1502 iDTMFUplinkPlayer->Cancel(); |
|
1503 } |
|
1504 |
|
1505 TRACE_PRN_FN_EXT; |
|
1506 return status; |
|
1507 } |
|
1508 |
|
1509 // ----------------------------------------------------------------------------- |
|
1510 // TMSCallIPAdpt::ContinueDTMF |
|
1511 // |
|
1512 // ----------------------------------------------------------------------------- |
|
1513 // |
|
1514 gint TMSCallIPAdpt::ContinueDTMF(const gboolean /*sending*/) |
|
1515 { |
|
1516 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
|
1517 } |
|
1518 |
|
1519 //From DTMFTonePlayerObserver |
|
1520 // ----------------------------------------------------------------------------- |
|
1521 // TMSCallIPAdpt::DTMFInitCompleted |
|
1522 // |
|
1523 // ----------------------------------------------------------------------------- |
|
1524 // |
|
1525 void TMSCallIPAdpt::DTMFInitCompleted(gint /*status*/) |
|
1526 { |
|
1527 TRACE_PRN_FN_ENT; |
|
1528 // TODO: process error |
|
1529 TRACE_PRN_FN_EXT; |
|
1530 } |
|
1531 |
|
1532 // ----------------------------------------------------------------------------- |
|
1533 // TMSCallIPAdpt::DTMFToneFinished |
|
1534 // |
|
1535 // ----------------------------------------------------------------------------- |
|
1536 // |
|
1537 void TMSCallIPAdpt::DTMFToneFinished(gint status) |
|
1538 { |
|
1539 TRACE_PRN_FN_ENT; |
|
1540 TRACE_PRN_IF_ERR(status); |
|
1541 TmsMsgBufPckg dtmfpckg; |
|
1542 |
|
1543 // KErrUnderflow indicates end of DTMF playback. |
|
1544 if (status == KErrUnderflow /*|| status == KErrInUse*/) |
|
1545 { |
|
1546 status = TMS_RESULT_SUCCESS; |
|
1547 } |
|
1548 dtmfpckg().iStatus = TMSUtility::TMSResult(status); |
|
1549 dtmfpckg().iRequest = ECmdDTMFTonePlayFinished; |
|
1550 if (iDTMFNotifier) |
|
1551 { |
|
1552 iDTMFNotifier->SetDtmf(dtmfpckg); |
|
1553 } |
|
1554 TRACE_PRN_FN_EXT; |
|
1555 } |
1388 } |
1556 |
1389 |
1557 // ----------------------------------------------------------------------------- |
1390 // ----------------------------------------------------------------------------- |
1558 // TMSCallIPAdpt::DownlinkInitCompleted |
1391 // TMSCallIPAdpt::DownlinkInitCompleted |
1559 // From TMSIPDevSoundObserver |
1392 // From TMSIPDevSoundObserver |
1562 void TMSCallIPAdpt::DownlinkInitCompleted(gint status) |
1395 void TMSCallIPAdpt::DownlinkInitCompleted(gint status) |
1563 { |
1396 { |
1564 TRACE_PRN_FN_ENT; |
1397 TRACE_PRN_FN_ENT; |
1565 if (status == TMS_RESULT_SUCCESS) |
1398 if (status == TMS_RESULT_SUCCESS) |
1566 { |
1399 { |
1567 iDnlinkInitialized = TRUE; |
1400 iDnlState = EInitialized; |
1568 } |
1401 } |
1569 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
1402 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
1570 TRACE_PRN_FN_EXT; |
1403 TRACE_PRN_FN_EXT; |
1571 } |
1404 } |
1572 |
1405 |
1578 void TMSCallIPAdpt::UplinkInitCompleted(gint status) |
1411 void TMSCallIPAdpt::UplinkInitCompleted(gint status) |
1579 { |
1412 { |
1580 TRACE_PRN_FN_ENT; |
1413 TRACE_PRN_FN_ENT; |
1581 if (status == TMS_RESULT_SUCCESS) |
1414 if (status == TMS_RESULT_SUCCESS) |
1582 { |
1415 { |
1583 iUplinkInitialized = TRUE; |
1416 iUplState = EInitialized; |
1584 } |
1417 } |
1585 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
1418 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
1586 TRACE_PRN_FN_EXT; |
1419 TRACE_PRN_FN_EXT; |
1587 } |
1420 } |
1588 |
1421 |
1592 // ----------------------------------------------------------------------------- |
1425 // ----------------------------------------------------------------------------- |
1593 // |
1426 // |
1594 void TMSCallIPAdpt::UplinkStarted(gint status) |
1427 void TMSCallIPAdpt::UplinkStarted(gint status) |
1595 { |
1428 { |
1596 TRACE_PRN_FN_ENT; |
1429 TRACE_PRN_FN_ENT; |
1430 if (status == TMS_RESULT_SUCCESS) |
|
1431 { |
|
1432 iUplState = EActivated; |
|
1433 } |
|
1597 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
1434 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
1598 TRACE_PRN_FN_EXT; |
1435 TRACE_PRN_FN_EXT; |
1599 } |
1436 } |
1600 |
1437 |
1601 // ----------------------------------------------------------------------------- |
1438 // ----------------------------------------------------------------------------- |
1604 // ----------------------------------------------------------------------------- |
1441 // ----------------------------------------------------------------------------- |
1605 // |
1442 // |
1606 void TMSCallIPAdpt::DownlinkStarted(gint status) |
1443 void TMSCallIPAdpt::DownlinkStarted(gint status) |
1607 { |
1444 { |
1608 TRACE_PRN_FN_ENT; |
1445 TRACE_PRN_FN_ENT; |
1446 if (status == TMS_RESULT_SUCCESS) |
|
1447 { |
|
1448 iDnlState = EActivated; |
|
1449 } |
|
1609 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
1450 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
1610 TRACE_PRN_FN_EXT; |
1451 TRACE_PRN_FN_EXT; |
1611 } |
1452 } |
1612 |
1453 |
1613 // ----------------------------------------------------------------------------- |
1454 // ----------------------------------------------------------------------------- |
1628 { |
1469 { |
1629 iMsgQueueDn.Send(iMsgBuffer); |
1470 iMsgQueueDn.Send(iMsgBuffer); |
1630 } |
1471 } |
1631 } |
1472 } |
1632 |
1473 |
1633 // End of file |