| changeset 33 | 5e8b14bae8c3 |
| parent 28 | ebf79c79991a |
| child 36 | 73253677b50a |
| 28:ebf79c79991a | 33:5e8b14bae8c3 |
|---|---|
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 { |
313 |
297 |
314 switch (strmType) |
298 switch (strmType) |
315 { |
299 { |
316 case TMS_STREAM_UPLINK: |
300 case TMS_STREAM_UPLINK: |
317 { |
301 { |
318 if (iIPUplink && strmId == iUplinkStreamId) |
302 if (iIPUplink && strmId == iUplinkStreamId && |
303 iUplState == EActivated) |
|
319 { |
304 { |
320 iIPUplink->Stop(); |
305 iIPUplink->Stop(); |
306 iUplState = EInitialized; |
|
321 status = TMS_RESULT_SUCCESS; |
307 status = TMS_RESULT_SUCCESS; |
322 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
308 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
323 } |
309 } |
324 break; |
310 break; |
325 } |
311 } |
326 case TMS_STREAM_DOWNLINK: |
312 case TMS_STREAM_DOWNLINK: |
327 { |
313 { |
328 if (iIPDownlink && strmId == iDnlinkStreamId) |
314 if (iIPDownlink && strmId == iDnlinkStreamId && |
315 iDnlState == EActivated) |
|
329 { |
316 { |
330 iIPDownlink->Stop(); |
317 iIPDownlink->Stop(); |
318 iDnlState = EInitialized; |
|
331 status = TMS_RESULT_SUCCESS; |
319 status = TMS_RESULT_SUCCESS; |
332 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
320 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
333 } |
321 } |
334 break; |
322 break; |
335 } |
323 } |
356 |
344 |
357 switch (strmType) |
345 switch (strmType) |
358 { |
346 { |
359 case TMS_STREAM_UPLINK: |
347 case TMS_STREAM_UPLINK: |
360 { |
348 { |
361 if (iIPUplink && strmId == iUplinkStreamId) |
349 if (iIPUplink && strmId == iUplinkStreamId && iUplState != EIdle) |
362 { |
350 { |
363 iIPUplink->Stop(); |
351 iIPUplink->Stop(); |
364 //iUplinkStreamId = -1; |
352 iUplState = EIdle; |
365 iUplinkInitialized = FALSE; |
|
366 status = TMS_RESULT_SUCCESS; |
353 status = TMS_RESULT_SUCCESS; |
367 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status); |
354 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status); |
368 } |
355 } |
369 break; |
356 break; |
370 } |
357 } |
371 case TMS_STREAM_DOWNLINK: |
358 case TMS_STREAM_DOWNLINK: |
372 { |
359 { |
373 if (iIPDownlink && strmId == iDnlinkStreamId) |
360 if (iIPDownlink && strmId == iDnlinkStreamId && iDnlState != EIdle) |
374 { |
361 { |
375 iIPDownlink->Stop(); |
362 iIPDownlink->Stop(); |
376 //iDnlinkStreamId = -1; |
363 iDnlState = EIdle; |
377 iDnlinkInitialized = FALSE; |
|
378 status = TMS_RESULT_SUCCESS; |
364 status = TMS_RESULT_SUCCESS; |
379 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete, |
365 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete, |
380 status); |
366 status); |
381 } |
367 } |
382 break; |
368 break; |
385 { |
371 { |
386 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
372 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
387 break; |
373 break; |
388 } |
374 } |
389 } |
375 } |
390 |
|
391 TRACE_PRN_FN_EXT; |
376 TRACE_PRN_FN_EXT; |
392 return status; |
377 return status; |
393 } |
378 } |
394 |
379 |
395 // ----------------------------------------------------------------------------- |
380 // ----------------------------------------------------------------------------- |
407 case TMS_STREAM_UPLINK: |
392 case TMS_STREAM_UPLINK: |
408 { |
393 { |
409 if (strmId == iUplinkStreamId) |
394 if (strmId == iUplinkStreamId) |
410 { |
395 { |
411 iUplinkStreamId = -1; |
396 iUplinkStreamId = -1; |
412 iUplinkInitialized = FALSE; |
397 iUplState = EIdle; |
413 } |
398 } |
414 break; |
399 break; |
415 } |
400 } |
416 case TMS_STREAM_DOWNLINK: |
401 case TMS_STREAM_DOWNLINK: |
417 { |
402 { |
418 if (strmId == iDnlinkStreamId) |
403 if (strmId == iDnlinkStreamId) |
419 { |
404 { |
420 iDnlinkStreamId = -1; |
405 iDnlinkStreamId = -1; |
421 iDnlinkInitialized = FALSE; |
406 iDnlState = EIdle; |
422 } |
407 } |
423 break; |
408 break; |
424 } |
409 } |
425 default: |
410 default: |
426 { |
411 { |
536 // |
521 // |
537 gint TMSCallIPAdpt::GetMaxVolume(guint& volume) |
522 gint TMSCallIPAdpt::GetMaxVolume(guint& volume) |
538 { |
523 { |
539 TRACE_PRN_FN_ENT; |
524 TRACE_PRN_FN_ENT; |
540 gint status(TMS_RESULT_INVALID_STATE); |
525 gint status(TMS_RESULT_INVALID_STATE); |
541 if (iDnlinkInitialized && iIPDownlink) |
526 if (iIPDownlink && iDnlState != EIdle) |
542 { |
527 { |
543 status = iIPDownlink->GetMaxVolume(volume); |
528 status = iIPDownlink->GetMaxVolume(volume); |
544 iMaxVolume = volume; |
529 iMaxVolume = volume; |
545 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume); |
530 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume); |
546 } |
531 } |
555 // |
540 // |
556 gint TMSCallIPAdpt::SetVolume(const guint volume) |
541 gint TMSCallIPAdpt::SetVolume(const guint volume) |
557 { |
542 { |
558 TRACE_PRN_FN_ENT; |
543 TRACE_PRN_FN_ENT; |
559 gint status(TMS_RESULT_INVALID_STATE); |
544 gint status(TMS_RESULT_INVALID_STATE); |
560 if (iDnlinkInitialized && iIPDownlink) |
545 if (iIPDownlink && iDnlState != EIdle) |
561 { |
546 { |
562 status = iIPDownlink->SetVolume(volume); |
547 status = iIPDownlink->SetVolume(volume); |
563 NotifyClient(iDnlinkStreamId, ECmdSetVolume, status); |
548 NotifyClient(iDnlinkStreamId, ECmdSetVolume, status); |
564 } |
549 } |
565 TRACE_PRN_FN_EXT; |
550 TRACE_PRN_FN_EXT; |
573 // |
558 // |
574 gint TMSCallIPAdpt::GetVolume(guint& volume) |
559 gint TMSCallIPAdpt::GetVolume(guint& volume) |
575 { |
560 { |
576 TRACE_PRN_FN_ENT; |
561 TRACE_PRN_FN_ENT; |
577 gint status(TMS_RESULT_INVALID_STATE); |
562 gint status(TMS_RESULT_INVALID_STATE); |
578 if (iDnlinkInitialized && iIPDownlink) |
563 if (iIPDownlink && iDnlState != EIdle) |
579 { |
564 { |
580 status = iIPDownlink->GetVolume(volume); |
565 status = iIPDownlink->GetVolume(volume); |
581 } |
566 } |
582 TRACE_PRN_FN_EXT; |
567 TRACE_PRN_FN_EXT; |
583 return status; |
568 return status; |
590 // |
575 // |
591 gint TMSCallIPAdpt::GetMaxGain(guint& gain) |
576 gint TMSCallIPAdpt::GetMaxGain(guint& gain) |
592 { |
577 { |
593 TRACE_PRN_FN_ENT; |
578 TRACE_PRN_FN_ENT; |
594 gint status(TMS_RESULT_INVALID_STATE); |
579 gint status(TMS_RESULT_INVALID_STATE); |
595 if (iUplinkInitialized && iIPUplink) |
580 if (iIPUplink && iUplState != EIdle) |
596 { |
581 { |
597 status = iIPUplink->GetMaxGain(gain); |
582 status = iIPUplink->GetMaxGain(gain); |
598 iMaxGain = gain; |
583 iMaxGain = gain; |
599 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetMaxGain [%d]"), iMaxGain); |
584 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetMaxGain [%d]"), iMaxGain); |
600 } |
585 } |
609 // |
594 // |
610 gint TMSCallIPAdpt::SetGain(const guint gain) |
595 gint TMSCallIPAdpt::SetGain(const guint gain) |
611 { |
596 { |
612 TRACE_PRN_FN_ENT; |
597 TRACE_PRN_FN_ENT; |
613 gint status(TMS_RESULT_INVALID_STATE); |
598 gint status(TMS_RESULT_INVALID_STATE); |
614 if (iUplinkInitialized && iIPUplink) |
599 if (iIPUplink && iUplState != EIdle) |
615 { |
600 { |
616 status = iIPUplink->SetGain(gain); |
601 status = iIPUplink->SetGain(gain); |
617 NotifyClient(iUplinkStreamId, ECmdSetGain, status); |
602 NotifyClient(iUplinkStreamId, ECmdSetGain, status); |
618 } |
603 } |
619 TRACE_PRN_FN_EXT; |
604 TRACE_PRN_FN_EXT; |
627 // |
612 // |
628 gint TMSCallIPAdpt::GetGain(guint& gain) |
613 gint TMSCallIPAdpt::GetGain(guint& gain) |
629 { |
614 { |
630 TRACE_PRN_FN_ENT; |
615 TRACE_PRN_FN_ENT; |
631 gint status(TMS_RESULT_INVALID_STATE); |
616 gint status(TMS_RESULT_INVALID_STATE); |
632 if (iUplinkInitialized && iIPUplink) |
617 if (iIPUplink && iUplState != EIdle) |
633 { |
618 { |
634 status = iIPUplink->GetGain(gain); |
619 status = iIPUplink->GetGain(gain); |
635 } |
620 } |
636 TRACE_PRN_FN_EXT; |
621 TRACE_PRN_FN_EXT; |
637 return status; |
622 return status; |
644 // |
629 // |
645 gint TMSCallIPAdpt::GetGlobalMaxVolume(guint& volume) |
630 gint TMSCallIPAdpt::GetGlobalMaxVolume(guint& volume) |
646 { |
631 { |
647 TRACE_PRN_FN_ENT; |
632 TRACE_PRN_FN_ENT; |
648 gint status(TMS_RESULT_INVALID_STATE); |
633 gint status(TMS_RESULT_INVALID_STATE); |
649 if (iDnlinkInitialized && iIPDownlink) |
634 if (iIPDownlink && iDnlState != EIdle) |
650 { |
635 { |
651 status = iIPDownlink->GetMaxVolume(volume); |
636 status = iIPDownlink->GetMaxVolume(volume); |
652 iMaxVolume = volume; |
637 iMaxVolume = volume; |
653 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetGlobalMaxVolume [%d]"), volume); |
638 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetGlobalMaxVolume [%d]"), volume); |
654 } |
639 } |
664 gint TMSCallIPAdpt::SetGlobalVolume(const guint volume) |
649 gint TMSCallIPAdpt::SetGlobalVolume(const guint volume) |
665 { |
650 { |
666 TRACE_PRN_FN_ENT; |
651 TRACE_PRN_FN_ENT; |
667 gint status(TMS_RESULT_INVALID_STATE); |
652 gint status(TMS_RESULT_INVALID_STATE); |
668 //iGlobalVol = volume; |
653 //iGlobalVol = volume; |
669 if (iDnlinkInitialized && iIPDownlink) |
654 if (iIPDownlink && iDnlState != EIdle) |
670 { |
655 { |
671 status = iIPDownlink->SetVolume(volume); |
656 status = iIPDownlink->SetVolume(volume); |
672 } |
657 } |
673 TRACE_PRN_FN_EXT; |
658 TRACE_PRN_FN_EXT; |
674 return status; |
659 return status; |
681 // |
666 // |
682 gint TMSCallIPAdpt::GetGlobalVolume(guint& volume) |
667 gint TMSCallIPAdpt::GetGlobalVolume(guint& volume) |
683 { |
668 { |
684 TRACE_PRN_FN_ENT; |
669 TRACE_PRN_FN_ENT; |
685 gint status(TMS_RESULT_INVALID_STATE); |
670 gint status(TMS_RESULT_INVALID_STATE); |
686 if (iDnlinkInitialized && iIPDownlink) |
671 if (iIPDownlink && iDnlState != EIdle) |
687 { |
672 { |
688 status = iIPDownlink->GetVolume(volume); |
673 status = iIPDownlink->GetVolume(volume); |
689 } |
674 } |
690 TRACE_PRN_FN_EXT; |
675 TRACE_PRN_FN_EXT; |
691 return status; |
676 return status; |
698 // |
683 // |
699 gint TMSCallIPAdpt::GetGlobalMaxGain(guint& gain) |
684 gint TMSCallIPAdpt::GetGlobalMaxGain(guint& gain) |
700 { |
685 { |
701 TRACE_PRN_FN_ENT; |
686 TRACE_PRN_FN_ENT; |
702 gint status(TMS_RESULT_INVALID_STATE); |
687 gint status(TMS_RESULT_INVALID_STATE); |
703 if (iUplinkInitialized && iIPUplink) |
688 if (iIPUplink && iUplState != EIdle) |
704 { |
689 { |
705 status = iIPUplink->GetMaxGain(gain); |
690 status = iIPUplink->GetMaxGain(gain); |
706 iMaxGain = gain; |
691 iMaxGain = gain; |
707 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetGlobalMaxGain [%d]"), gain); |
692 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetGlobalMaxGain [%d]"), gain); |
708 } |
693 } |
718 gint TMSCallIPAdpt::SetGlobalGain(const guint gain) |
703 gint TMSCallIPAdpt::SetGlobalGain(const guint gain) |
719 { |
704 { |
720 TRACE_PRN_FN_ENT; |
705 TRACE_PRN_FN_ENT; |
721 gint status(TMS_RESULT_INVALID_STATE); |
706 gint status(TMS_RESULT_INVALID_STATE); |
722 //iGlobalGain = gain; |
707 //iGlobalGain = gain; |
723 if (iUplinkInitialized && iIPUplink) |
708 if (iIPUplink && iUplState != EIdle) |
724 { |
709 { |
725 status = iIPUplink->SetGain(gain); |
710 status = iIPUplink->SetGain(gain); |
726 } |
711 } |
727 TRACE_PRN_FN_EXT; |
712 TRACE_PRN_FN_EXT; |
728 return status; |
713 return status; |
735 // |
720 // |
736 gint TMSCallIPAdpt::GetGlobalGain(guint& gain) |
721 gint TMSCallIPAdpt::GetGlobalGain(guint& gain) |
737 { |
722 { |
738 TRACE_PRN_FN_ENT; |
723 TRACE_PRN_FN_ENT; |
739 gint status(TMS_RESULT_INVALID_STATE); |
724 gint status(TMS_RESULT_INVALID_STATE); |
740 if (iUplinkInitialized && iIPUplink) |
725 if (iIPUplink && iUplState != EIdle) |
741 { |
726 { |
742 status = iIPUplink->GetGain(gain); |
727 status = iIPUplink->GetGain(gain); |
743 } |
728 } |
744 TRACE_PRN_FN_EXT; |
729 TRACE_PRN_FN_EXT; |
745 return status; |
730 return status; |
804 // |
789 // |
805 gint TMSCallIPAdpt::GetSupportedBitRatesCount(guint& count) |
790 gint TMSCallIPAdpt::GetSupportedBitRatesCount(guint& count) |
806 { |
791 { |
807 TRACE_PRN_FN_ENT; |
792 TRACE_PRN_FN_ENT; |
808 gint status(TMS_RESULT_INVALID_STATE); |
793 gint status(TMS_RESULT_INVALID_STATE); |
809 if (iIPUplink) |
794 if (iIPUplink && iUplState != EIdle) |
810 { |
795 { |
811 status = iIPUplink->GetSupportedBitrates(iArrBitrates); |
796 status = iIPUplink->GetSupportedBitrates(iArrBitrates); |
812 count = iArrBitrates.Count(); |
797 count = iArrBitrates.Count(); |
813 } |
798 } |
814 TRACE_PRN_FN_EXT; |
799 TRACE_PRN_FN_EXT; |
860 // |
845 // |
861 gint TMSCallIPAdpt::GetBitRate(guint& bitrate) |
846 gint TMSCallIPAdpt::GetBitRate(guint& bitrate) |
862 { |
847 { |
863 TRACE_PRN_FN_ENT; |
848 TRACE_PRN_FN_ENT; |
864 gint status(TMS_RESULT_INVALID_STATE); |
849 gint status(TMS_RESULT_INVALID_STATE); |
865 if (iIPUplink) |
850 if (iIPUplink && iUplState != EIdle) |
866 { |
851 { |
867 status = iIPUplink->GetBitrate(bitrate); |
852 status = iIPUplink->GetBitrate(bitrate); |
868 } |
853 } |
869 TRACE_PRN_FN_EXT; |
854 TRACE_PRN_FN_EXT; |
870 return status; |
855 return status; |
877 // |
862 // |
878 gint TMSCallIPAdpt::SetBitRate(const guint bitrate) |
863 gint TMSCallIPAdpt::SetBitRate(const guint bitrate) |
879 { |
864 { |
880 TRACE_PRN_FN_ENT; |
865 TRACE_PRN_FN_ENT; |
881 gint status(TMS_RESULT_INVALID_STATE); |
866 gint status(TMS_RESULT_INVALID_STATE); |
882 if (iIPUplink) |
867 if (iIPUplink && iUplState != EIdle) |
883 { |
868 { |
884 status = iIPUplink->SetBitrate(bitrate); |
869 status = iIPUplink->SetBitrate(bitrate); |
885 } |
870 } |
886 TRACE_PRN_FN_EXT; |
871 TRACE_PRN_FN_EXT; |
887 return status; |
872 return status; |
894 // |
879 // |
895 gint TMSCallIPAdpt::GetVAD(const TMSFormatType fmttype, gboolean& vad) |
880 gint TMSCallIPAdpt::GetVAD(const TMSFormatType fmttype, gboolean& vad) |
896 { |
881 { |
897 TRACE_PRN_FN_ENT; |
882 TRACE_PRN_FN_ENT; |
898 gint status(TMS_RESULT_INVALID_STATE); |
883 gint status(TMS_RESULT_INVALID_STATE); |
899 if (iIPUplink) |
884 if (iIPUplink && iUplState != EIdle) |
900 { |
885 { |
901 status = iIPUplink->GetVad(fmttype, vad); |
886 status = iIPUplink->GetVad(fmttype, vad); |
902 } |
887 } |
903 TRACE_PRN_FN_EXT; |
888 TRACE_PRN_FN_EXT; |
904 return status; |
889 return status; |
911 // |
896 // |
912 gint TMSCallIPAdpt::SetVAD(const TMSFormatType fmttype, const gboolean vad) |
897 gint TMSCallIPAdpt::SetVAD(const TMSFormatType fmttype, const gboolean vad) |
913 { |
898 { |
914 TRACE_PRN_FN_ENT; |
899 TRACE_PRN_FN_ENT; |
915 gint status(TMS_RESULT_INVALID_STATE); |
900 gint status(TMS_RESULT_INVALID_STATE); |
916 if (iIPUplink) |
901 if (iIPUplink && iUplState != EIdle) |
917 { |
902 { |
918 status = iIPUplink->SetVad(fmttype, vad); |
903 status = iIPUplink->SetVad(fmttype, vad); |
919 } |
904 } |
920 TRACE_PRN_FN_EXT; |
905 TRACE_PRN_FN_EXT; |
921 return status; |
906 return status; |
928 // |
913 // |
929 gint TMSCallIPAdpt::GetCNG(const TMSFormatType fmttype, gboolean& cng) |
914 gint TMSCallIPAdpt::GetCNG(const TMSFormatType fmttype, gboolean& cng) |
930 { |
915 { |
931 TRACE_PRN_FN_ENT; |
916 TRACE_PRN_FN_ENT; |
932 gint status(TMS_RESULT_INVALID_STATE); |
917 gint status(TMS_RESULT_INVALID_STATE); |
933 if (iIPDownlink) |
918 if (iIPDownlink && iDnlState == EInitialized) |
934 { |
919 { |
935 status = iIPDownlink->GetCng(fmttype, cng); |
920 status = iIPDownlink->GetCng(fmttype, cng); |
936 } |
921 } |
937 TRACE_PRN_FN_EXT; |
922 TRACE_PRN_FN_EXT; |
938 return status; |
923 return status; |
945 // |
930 // |
946 gint TMSCallIPAdpt::SetCNG(const TMSFormatType fmttype, const gboolean cng) |
931 gint TMSCallIPAdpt::SetCNG(const TMSFormatType fmttype, const gboolean cng) |
947 { |
932 { |
948 TRACE_PRN_FN_ENT; |
933 TRACE_PRN_FN_ENT; |
949 gint status(TMS_RESULT_INVALID_STATE); |
934 gint status(TMS_RESULT_INVALID_STATE); |
950 if (iIPDownlink) |
935 if (iIPDownlink && iDnlState == EInitialized) |
951 { |
936 { |
952 status = iIPDownlink->SetCng(fmttype, cng); |
937 status = iIPDownlink->SetCng(fmttype, cng); |
953 } |
938 } |
954 TRACE_PRN_FN_EXT; |
939 TRACE_PRN_FN_EXT; |
955 return status; |
940 return status; |
962 // |
947 // |
963 gint TMSCallIPAdpt::GetPlc(const TMSFormatType fmttype, gboolean& plc) |
948 gint TMSCallIPAdpt::GetPlc(const TMSFormatType fmttype, gboolean& plc) |
964 { |
949 { |
965 TRACE_PRN_FN_ENT; |
950 TRACE_PRN_FN_ENT; |
966 gint status(TMS_RESULT_INVALID_STATE); |
951 gint status(TMS_RESULT_INVALID_STATE); |
967 if (iIPDownlink) |
952 if (iIPDownlink && iDnlState != EIdle) |
968 { |
953 { |
969 status = iIPDownlink->GetPlc(fmttype, plc); |
954 status = iIPDownlink->GetPlc(fmttype, plc); |
970 } |
955 } |
971 TRACE_PRN_FN_EXT; |
956 TRACE_PRN_FN_EXT; |
972 return status; |
957 return status; |
979 // |
964 // |
980 gint TMSCallIPAdpt::SetPlc(const TMSFormatType fmttype, const gboolean plc) |
965 gint TMSCallIPAdpt::SetPlc(const TMSFormatType fmttype, const gboolean plc) |
981 { |
966 { |
982 TRACE_PRN_FN_ENT; |
967 TRACE_PRN_FN_ENT; |
983 gint status(TMS_RESULT_INVALID_STATE); |
968 gint status(TMS_RESULT_INVALID_STATE); |
984 if (iIPDownlink) |
969 if (iIPDownlink && iDnlState == EInitialized) |
985 { |
970 { |
986 status = iIPDownlink->SetPlc(fmttype, plc); |
971 status = iIPDownlink->SetPlc(fmttype, plc); |
987 } |
972 } |
988 TRACE_PRN_FN_EXT; |
973 TRACE_PRN_FN_EXT; |
989 return status; |
974 return status; |
1170 // ----------------------------------------------------------------------------- |
1155 // ----------------------------------------------------------------------------- |
1171 // |
1156 // |
1172 gint TMSCallIPAdpt::SetIlbcCodecMode(const gint mode, |
1157 gint TMSCallIPAdpt::SetIlbcCodecMode(const gint mode, |
1173 const TMSStreamType strmtype) |
1158 const TMSStreamType strmtype) |
1174 { |
1159 { |
1175 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1160 gint status(TMS_RESULT_SUCCESS); |
1176 |
1161 |
1177 if (strmtype == TMS_STREAM_DOWNLINK) |
1162 if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink && |
1178 { |
1163 iDnlState == EInitialized) |
1179 if (iDnlinkInitialized && iIPDownlink) |
1164 { |
1180 { |
1165 status = iIPDownlink->SetIlbcCodecMode(mode); |
1181 status = iIPDownlink->SetIlbcCodecMode(mode); |
1166 } |
1182 } |
1167 else if (strmtype == TMS_STREAM_UPLINK && iIPUplink && |
1183 } |
1168 iUplState == EInitialized) |
1184 else if (strmtype == TMS_STREAM_UPLINK) |
1169 { |
1185 { |
1170 status = iIPUplink->SetIlbcCodecMode(mode); |
1186 if (iUplinkInitialized && iIPUplink) |
1171 } |
1187 { |
1172 else |
1188 status = iIPUplink->SetIlbcCodecMode(mode); |
1173 { |
1189 } |
1174 status = TMS_RESULT_INVALID_STATE; |
1190 } |
1175 } |
1191 |
|
1192 return status; |
1176 return status; |
1193 } |
1177 } |
1194 |
1178 |
1195 // ----------------------------------------------------------------------------- |
1179 // ----------------------------------------------------------------------------- |
1196 // TMSCallIPAdpt::GetIlbcCodecMode |
1180 // TMSCallIPAdpt::GetIlbcCodecMode |
1197 // |
1181 // |
1198 // ----------------------------------------------------------------------------- |
1182 // ----------------------------------------------------------------------------- |
1199 // |
1183 // |
1200 gint TMSCallIPAdpt::GetIlbcCodecMode(gint& mode, const TMSStreamType strmtype) |
1184 gint TMSCallIPAdpt::GetIlbcCodecMode(gint& mode, const TMSStreamType strmtype) |
1201 { |
1185 { |
1202 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1186 gint status(TMS_RESULT_SUCCESS); |
1203 |
1187 |
1204 if (strmtype == TMS_STREAM_DOWNLINK) |
1188 if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink && |
1205 { |
1189 iDnlState != EIdle) |
1206 if (iDnlinkInitialized && iIPDownlink) |
1190 { |
1207 { |
1191 status = iIPDownlink->GetIlbcCodecMode(mode); |
1208 status = iIPDownlink->GetIlbcCodecMode(mode); |
1192 } |
1209 } |
1193 else if (strmtype == TMS_STREAM_UPLINK && iIPUplink && |
1210 } |
1194 iUplState != EIdle) |
1211 else if (strmtype == TMS_STREAM_UPLINK) |
1195 { |
1212 { |
1196 status = iIPUplink->GetIlbcCodecMode(mode); |
1213 if (iUplinkInitialized && iIPUplink) |
1197 } |
1214 { |
1198 else |
1215 status = iIPUplink->GetIlbcCodecMode(mode); |
1199 { |
1216 } |
1200 status = TMS_RESULT_INVALID_STATE; |
1217 } |
1201 } |
1218 |
|
1219 return status; |
1202 return status; |
1220 } |
1203 } |
1221 |
1204 |
1222 // ----------------------------------------------------------------------------- |
1205 // ----------------------------------------------------------------------------- |
1223 // TMSCallIPAdpt::SetG711CodecMode |
1206 // TMSCallIPAdpt::SetG711CodecMode |
1225 // ----------------------------------------------------------------------------- |
1208 // ----------------------------------------------------------------------------- |
1226 // |
1209 // |
1227 gint TMSCallIPAdpt::SetG711CodecMode(const gint mode, |
1210 gint TMSCallIPAdpt::SetG711CodecMode(const gint mode, |
1228 const TMSStreamType strmtype) |
1211 const TMSStreamType strmtype) |
1229 { |
1212 { |
1230 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1213 gint status(TMS_RESULT_SUCCESS); |
1231 |
1214 |
1232 if (strmtype == TMS_STREAM_DOWNLINK) |
1215 if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink && |
1233 { |
1216 iDnlState == EInitialized) |
1234 if (iDnlinkInitialized && iIPDownlink) |
1217 { |
1235 { |
1218 status = iIPDownlink->SetG711CodecMode(mode); |
1236 status = iIPDownlink->SetG711CodecMode(mode); |
1219 } |
1237 } |
1220 else if (strmtype == TMS_STREAM_UPLINK && iIPUplink && |
1238 } |
1221 iUplState == EInitialized) |
1239 else if (strmtype == TMS_STREAM_UPLINK) |
1222 { |
1240 { |
1223 status = iIPUplink->SetG711CodecMode(mode); |
1241 if (iUplinkInitialized && iIPUplink) |
1224 } |
1242 { |
1225 else |
1243 status = iIPUplink->SetG711CodecMode(mode); |
1226 { |
1244 } |
1227 status = TMS_RESULT_INVALID_STATE; |
1245 } |
1228 } |
1246 |
|
1247 return status; |
1229 return status; |
1248 } |
1230 } |
1249 |
1231 |
1250 // ----------------------------------------------------------------------------- |
1232 // ----------------------------------------------------------------------------- |
1251 // TMSCallIPAdpt::GetG711CodecMode |
1233 // TMSCallIPAdpt::GetG711CodecMode |
1252 // |
1234 // |
1253 // ----------------------------------------------------------------------------- |
1235 // ----------------------------------------------------------------------------- |
1254 // |
1236 // |
1255 gint TMSCallIPAdpt::GetG711CodecMode(gint& mode, const TMSStreamType strmtype) |
1237 gint TMSCallIPAdpt::GetG711CodecMode(gint& mode, const TMSStreamType strmtype) |
1256 { |
1238 { |
1257 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1239 gint status(TMS_RESULT_SUCCESS); |
1258 |
1240 |
1259 if (strmtype == TMS_STREAM_DOWNLINK) |
1241 if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink && |
1260 { |
1242 iDnlState != EIdle) |
1261 if (iDnlinkInitialized && iIPDownlink) |
1243 { |
1262 { |
1244 status = iIPDownlink->GetG711CodecMode(mode); |
1263 status = iIPDownlink->GetG711CodecMode(mode); |
1245 } |
1264 } |
1246 else if (strmtype == TMS_STREAM_UPLINK && iIPUplink && |
1265 } |
1247 iUplState != EIdle) |
1266 else if (strmtype == TMS_STREAM_UPLINK) |
1248 { |
1267 { |
1249 status = iIPUplink->GetG711CodecMode(mode); |
1268 if (iUplinkInitialized && iIPUplink) |
1250 } |
1269 { |
1251 else |
1270 status = iIPUplink->GetG711CodecMode(mode); |
1252 { |
1271 } |
1253 status = TMS_RESULT_INVALID_STATE; |
1272 } |
1254 } |
1273 |
|
1274 return status; |
1255 return status; |
1275 } |
1256 } |
1276 |
1257 |
1277 // ----------------------------------------------------------------------------- |
1258 // ----------------------------------------------------------------------------- |
1278 // TMSCallIPAdpt::FrameModeRequiredForEC |
1259 // TMSCallIPAdpt::FrameModeRequiredForEC |
1279 // |
1260 // |
1280 // ----------------------------------------------------------------------------- |
1261 // ----------------------------------------------------------------------------- |
1281 // |
1262 // |
1282 gint TMSCallIPAdpt::FrameModeRqrdForEC(gboolean& frmodereq) |
1263 gint TMSCallIPAdpt::FrameModeRqrdForEC(gboolean& frmodereq) |
1283 { |
1264 { |
1284 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1265 gint status(TMS_RESULT_INVALID_STATE); |
1285 if (iIPDownlink) |
1266 if (iIPDownlink && iDnlState == EInitialized) |
1286 { |
1267 { |
1287 status = iIPDownlink->FrameModeRqrdForEC(frmodereq); |
1268 status = iIPDownlink->FrameModeRqrdForEC(frmodereq); |
1288 } |
1269 } |
1289 return status; |
1270 return status; |
1290 } |
1271 } |
1294 // |
1275 // |
1295 // ----------------------------------------------------------------------------- |
1276 // ----------------------------------------------------------------------------- |
1296 // |
1277 // |
1297 gint TMSCallIPAdpt::SetFrameMode(const gboolean frmode) |
1278 gint TMSCallIPAdpt::SetFrameMode(const gboolean frmode) |
1298 { |
1279 { |
1299 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1280 gint status(TMS_RESULT_INVALID_STATE); |
1300 if (iIPDownlink) |
1281 if (iIPDownlink && iDnlState == EInitialized) |
1301 { |
1282 { |
1302 status = iIPDownlink->SetFrameMode(frmode); |
1283 status = iIPDownlink->SetFrameMode(frmode); |
1303 } |
1284 } |
1304 return status; |
1285 return status; |
1305 } |
1286 } |
1309 // |
1290 // |
1310 // ----------------------------------------------------------------------------- |
1291 // ----------------------------------------------------------------------------- |
1311 // |
1292 // |
1312 gint TMSCallIPAdpt::GetFrameMode(gboolean& frmode) |
1293 gint TMSCallIPAdpt::GetFrameMode(gboolean& frmode) |
1313 { |
1294 { |
1314 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1295 gint status(TMS_RESULT_INVALID_STATE); |
1315 if (iIPDownlink) |
1296 if (iIPDownlink && iDnlState != EIdle) |
1316 { |
1297 { |
1317 status = iIPDownlink->GetFrameMode(frmode); |
1298 status = iIPDownlink->GetFrameMode(frmode); |
1318 } |
1299 } |
1319 return status; |
1300 return status; |
1320 } |
1301 } |
1323 // TMSCallIPAdpt::ConcealErrorForNextBuffer |
1304 // TMSCallIPAdpt::ConcealErrorForNextBuffer |
1324 // ----------------------------------------------------------------------------- |
1305 // ----------------------------------------------------------------------------- |
1325 // |
1306 // |
1326 gint TMSCallIPAdpt::ConcealErrorForNextBuffer() |
1307 gint TMSCallIPAdpt::ConcealErrorForNextBuffer() |
1327 { |
1308 { |
1328 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1309 gint status(TMS_RESULT_INVALID_STATE); |
1329 if (iIPDownlink) |
1310 if (iIPDownlink && iDnlState == EActivated) |
1330 { |
1311 { |
1331 status = iIPDownlink->ConcealErrorForNextBuffer(); |
1312 status = iIPDownlink->ConcealErrorForNextBuffer(); |
1332 } |
1313 } |
1333 return status; |
1314 return status; |
1334 } |
1315 } |
1338 // |
1319 // |
1339 // ----------------------------------------------------------------------------- |
1320 // ----------------------------------------------------------------------------- |
1340 // |
1321 // |
1341 gint TMSCallIPAdpt::BadLsfNextBuffer() |
1322 gint TMSCallIPAdpt::BadLsfNextBuffer() |
1342 { |
1323 { |
1343 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1324 gint status(TMS_RESULT_INVALID_STATE); |
1344 if (iIPDownlink) |
1325 if (iIPDownlink && iDnlState == EActivated) |
1345 { |
1326 { |
1346 status = iIPDownlink->BadLsfNextBuffer(); |
1327 status = iIPDownlink->BadLsfNextBuffer(); |
1347 } |
1328 } |
1348 return status; |
1329 return status; |
1349 } |
1330 } |
1354 // ----------------------------------------------------------------------------- |
1335 // ----------------------------------------------------------------------------- |
1355 // |
1336 // |
1356 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output) |
1337 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output) |
1357 { |
1338 { |
1358 TRACE_PRN_FN_ENT; |
1339 TRACE_PRN_FN_ENT; |
1359 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1340 gint status(TMS_RESULT_INVALID_STATE); |
1360 if (iDnlinkInitialized && iIPDownlink) |
1341 if (iIPDownlink && iDnlState != EIdle) |
1361 { |
1342 { |
1362 TRAP(status, iIPDownlink->SetAudioDeviceL(output)); |
1343 TRAP(status, iIPDownlink->SetAudioDeviceL(output)); |
1363 } |
1344 } |
1364 TRACE_PRN_FN_EXT; |
1345 TRACE_PRN_FN_EXT; |
1365 return status; |
1346 return status; |
1366 } |
1347 } |
1348 |
|
1367 // ----------------------------------------------------------------------------- |
1349 // ----------------------------------------------------------------------------- |
1368 // TMSCallIPAdpt::GetOutput |
1350 // TMSCallIPAdpt::GetOutput |
1369 // |
1351 // |
1370 // ----------------------------------------------------------------------------- |
1352 // ----------------------------------------------------------------------------- |
1371 // |
1353 // |
1372 gint TMSCallIPAdpt::GetOutput(TMSAudioOutput& output) |
1354 gint TMSCallIPAdpt::GetOutput(TMSAudioOutput& output) |
1373 { |
1355 { |
1374 TRACE_PRN_FN_ENT; |
1356 TRACE_PRN_FN_ENT; |
1375 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1357 gint status(TMS_RESULT_INVALID_STATE); |
1376 if (iDnlinkInitialized && iIPDownlink) |
1358 if (iIPDownlink && iDnlState != EIdle) |
1377 { |
1359 { |
1378 TRAP(status, iIPDownlink->GetAudioDeviceL(output)); |
1360 TRAP(status, iIPDownlink->GetAudioDeviceL(output)); |
1379 } |
1361 } |
1380 TRACE_PRN_FN_EXT; |
1362 TRACE_PRN_FN_EXT; |
1381 return status; |
1363 return status; |
1397 // ----------------------------------------------------------------------------- |
1379 // ----------------------------------------------------------------------------- |
1398 // |
1380 // |
1399 gint TMSCallIPAdpt::GetAvailableOutputsL(gint& /*count*/, |
1381 gint TMSCallIPAdpt::GetAvailableOutputsL(gint& /*count*/, |
1400 CBufFlat*& /*outputsbuf*/) |
1382 CBufFlat*& /*outputsbuf*/) |
1401 { |
1383 { |
1384 //TODO: return public & private |
|
1402 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
1385 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 } |
1386 } |
1556 |
1387 |
1557 // ----------------------------------------------------------------------------- |
1388 // ----------------------------------------------------------------------------- |
1558 // TMSCallIPAdpt::DownlinkInitCompleted |
1389 // TMSCallIPAdpt::DownlinkInitCompleted |
1559 // From TMSIPDevSoundObserver |
1390 // From TMSIPDevSoundObserver |
1562 void TMSCallIPAdpt::DownlinkInitCompleted(gint status) |
1393 void TMSCallIPAdpt::DownlinkInitCompleted(gint status) |
1563 { |
1394 { |
1564 TRACE_PRN_FN_ENT; |
1395 TRACE_PRN_FN_ENT; |
1565 if (status == TMS_RESULT_SUCCESS) |
1396 if (status == TMS_RESULT_SUCCESS) |
1566 { |
1397 { |
1567 iDnlinkInitialized = TRUE; |
1398 iDnlState = EInitialized; |
1568 } |
1399 } |
1569 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
1400 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
1570 TRACE_PRN_FN_EXT; |
1401 TRACE_PRN_FN_EXT; |
1571 } |
1402 } |
1572 |
1403 |
1578 void TMSCallIPAdpt::UplinkInitCompleted(gint status) |
1409 void TMSCallIPAdpt::UplinkInitCompleted(gint status) |
1579 { |
1410 { |
1580 TRACE_PRN_FN_ENT; |
1411 TRACE_PRN_FN_ENT; |
1581 if (status == TMS_RESULT_SUCCESS) |
1412 if (status == TMS_RESULT_SUCCESS) |
1582 { |
1413 { |
1583 iUplinkInitialized = TRUE; |
1414 iUplState = EInitialized; |
1584 } |
1415 } |
1585 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
1416 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
1586 TRACE_PRN_FN_EXT; |
1417 TRACE_PRN_FN_EXT; |
1587 } |
1418 } |
1588 |
1419 |
1592 // ----------------------------------------------------------------------------- |
1423 // ----------------------------------------------------------------------------- |
1593 // |
1424 // |
1594 void TMSCallIPAdpt::UplinkStarted(gint status) |
1425 void TMSCallIPAdpt::UplinkStarted(gint status) |
1595 { |
1426 { |
1596 TRACE_PRN_FN_ENT; |
1427 TRACE_PRN_FN_ENT; |
1428 if (status == TMS_RESULT_SUCCESS) |
|
1429 { |
|
1430 iUplState = EActivated; |
|
1431 } |
|
1597 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
1432 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
1598 TRACE_PRN_FN_EXT; |
1433 TRACE_PRN_FN_EXT; |
1599 } |
1434 } |
1600 |
1435 |
1601 // ----------------------------------------------------------------------------- |
1436 // ----------------------------------------------------------------------------- |
1604 // ----------------------------------------------------------------------------- |
1439 // ----------------------------------------------------------------------------- |
1605 // |
1440 // |
1606 void TMSCallIPAdpt::DownlinkStarted(gint status) |
1441 void TMSCallIPAdpt::DownlinkStarted(gint status) |
1607 { |
1442 { |
1608 TRACE_PRN_FN_ENT; |
1443 TRACE_PRN_FN_ENT; |
1444 if (status == TMS_RESULT_SUCCESS) |
|
1445 { |
|
1446 iDnlState = EActivated; |
|
1447 } |
|
1609 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
1448 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
1610 TRACE_PRN_FN_EXT; |
1449 TRACE_PRN_FN_EXT; |
1611 } |
1450 } |
1612 |
1451 |
1613 // ----------------------------------------------------------------------------- |
1452 // ----------------------------------------------------------------------------- |
1628 { |
1467 { |
1629 iMsgQueueDn.Send(iMsgBuffer); |
1468 iMsgQueueDn.Send(iMsgBuffer); |
1630 } |
1469 } |
1631 } |
1470 } |
1632 |
1471 |
1633 // End of file |