equal
deleted
inserted
replaced
19 #include "tmsutility.h" |
19 #include "tmsutility.h" |
20 #include "tmscalladpt.h" |
20 #include "tmscalladpt.h" |
21 #include "tmscallserver.h" |
21 #include "tmscallserver.h" |
22 #include "tmscallclisrv.h" |
22 #include "tmscallclisrv.h" |
23 #include "tmscallsession.h" |
23 #include "tmscallsession.h" |
|
24 #include "tmscallipadpt.h" |
|
25 #include "tmscallcsadpt.h" |
24 |
26 |
25 using namespace TMS; |
27 using namespace TMS; |
26 |
28 |
27 const guint KArrayExpandSize = 8; |
29 const guint KArrayExpandSize = 8; |
28 const guint KNumOfElements = 10; |
30 const guint KNumOfElements = 10; |
101 // ----------------------------------------------------------------------------- |
103 // ----------------------------------------------------------------------------- |
102 // |
104 // |
103 void TMSCallSession::HandleMessageL(const RMessage2& aMessage) |
105 void TMSCallSession::HandleMessageL(const RMessage2& aMessage) |
104 { |
106 { |
105 TRACE_PRN_FN_ENT; |
107 TRACE_PRN_FN_ENT; |
|
108 |
|
109 if(iCallAdpt) |
|
110 { |
|
111 iCallAdpt->GetCallType(iActiveCallType); |
|
112 } |
|
113 |
106 switch (aMessage.Function()) |
114 switch (aMessage.Function()) |
107 { |
115 { |
108 case TMS_CREATE_CALL: |
116 case TMS_CREATE_CALL: |
109 HandleCreateCallL(aMessage); |
117 HandleCreateCallL(aMessage); |
110 break; |
118 break; |
225 case TMS_ROUTING_AVAILABLE_OUTPUT_GET: |
233 case TMS_ROUTING_AVAILABLE_OUTPUT_GET: |
226 HandleRoutingGetAvailableOutputsL(aMessage); |
234 HandleRoutingGetAvailableOutputsL(aMessage); |
227 break; |
235 break; |
228 case TMS_GET_ACTIVE_CALL_PARAMS: |
236 case TMS_GET_ACTIVE_CALL_PARAMS: |
229 HandleGetActiveCallL(aMessage); |
237 HandleGetActiveCallL(aMessage); |
|
238 break; |
|
239 case TMS_TERM_CALL_SRV: |
|
240 aMessage.Complete(TMS_RESULT_SUCCESS); |
|
241 iTMSCallServer.TerminateServer(); |
230 break; |
242 break; |
231 default: |
243 default: |
232 User::Leave(TMS_RESULT_ILLEGAL_OPERATION); |
244 User::Leave(TMS_RESULT_ILLEGAL_OPERATION); |
233 break; |
245 break; |
234 } |
246 } |
292 if (iCallAdpt) |
304 if (iCallAdpt) |
293 { |
305 { |
294 TMSCliSrvStreamInitDataStructBufPckg pckg; |
306 TMSCliSrvStreamInitDataStructBufPckg pckg; |
295 aMessage.ReadL(0, pckg); |
307 aMessage.ReadL(0, pckg); |
296 status = iCallAdpt->InitStream(pckg().CallType, pckg().StreamType, |
308 status = iCallAdpt->InitStream(pckg().CallType, pckg().StreamType, |
297 pckg().StreamId, pckg().FormatType, pckg().RetryTime, aMessage); |
309 pckg().StreamId, pckg().FormatType, pckg().RetryTime, |
298 |
310 aMessage); |
299 switch (pckg().StreamType) |
311 |
|
312 if (iActiveCallType == TMS_CALL_CS) |
300 { |
313 { |
301 case TMS_STREAM_DOWNLINK: |
314 switch (pckg().StreamType) |
302 { |
315 { |
303 iCallAdpt->SetGlobalVolume(iGlobalVol); |
316 case TMS_STREAM_DOWNLINK: |
|
317 { |
|
318 static_cast<TMSCallCSAdpt*> (iCallAdpt)->SetGlobalVolume( |
|
319 iGlobalVol); |
|
320 } |
|
321 break; |
|
322 case TMS_STREAM_UPLINK: |
|
323 { |
|
324 static_cast<TMSCallCSAdpt*> (iCallAdpt)->SetGlobalGain( |
|
325 iGlobalGain); |
|
326 } |
|
327 break; |
|
328 default: |
|
329 break; |
304 } |
330 } |
305 break; |
|
306 case TMS_STREAM_UPLINK: |
|
307 { |
|
308 iCallAdpt->SetGlobalGain(iGlobalGain); |
|
309 } |
|
310 break; |
|
311 default: |
|
312 break; |
|
313 } |
331 } |
314 } |
332 } |
315 aMessage.Complete(status); |
333 aMessage.Complete(status); |
316 TRACE_PRN_FN_EXT; |
334 TRACE_PRN_FN_EXT; |
317 } |
335 } |
438 void TMSCallSession::HandleDataXferBufferEmptiedCallL( |
456 void TMSCallSession::HandleDataXferBufferEmptiedCallL( |
439 const RMessage2& aMessage) |
457 const RMessage2& aMessage) |
440 { |
458 { |
441 TRACE_PRN_FN_ENT; |
459 TRACE_PRN_FN_ENT; |
442 gint status(TMS_RESULT_DOES_NOT_EXIST); |
460 gint status(TMS_RESULT_DOES_NOT_EXIST); |
443 if (iCallAdpt) |
461 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
444 { |
462 { |
445 TMSCliSrvDataXferDataStructBufPckg pckg; |
463 TMSCliSrvDataXferDataStructBufPckg pckg; |
446 aMessage.ReadL(0, pckg); |
464 aMessage.ReadL(0, pckg); |
447 status = iCallAdpt->DataXferBufferEmptied(pckg().CallType, |
465 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->DataXferBufferEmptied( |
448 pckg().StreamType, pckg().StreamId); |
466 pckg().CallType, pckg().StreamType, pckg().StreamId); |
449 } |
467 } |
450 aMessage.Complete(status); |
468 aMessage.Complete(status); |
451 TRACE_PRN_FN_EXT; |
469 TRACE_PRN_FN_EXT; |
452 } |
470 } |
453 |
471 |
458 // |
476 // |
459 void TMSCallSession::HandleDataXferBufferFilledCallL(const RMessage2& aMessage) |
477 void TMSCallSession::HandleDataXferBufferFilledCallL(const RMessage2& aMessage) |
460 { |
478 { |
461 TRACE_PRN_FN_ENT; |
479 TRACE_PRN_FN_ENT; |
462 gint status(TMS_RESULT_DOES_NOT_EXIST); |
480 gint status(TMS_RESULT_DOES_NOT_EXIST); |
463 if (iCallAdpt) |
481 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
464 { |
482 { |
465 TMSCliSrvDataXferDataStructBufPckg pckg; |
483 TMSCliSrvDataXferDataStructBufPckg pckg; |
466 aMessage.ReadL(0, pckg); |
484 aMessage.ReadL(0, pckg); |
467 status = iCallAdpt->DataXferBufferFilled(pckg().CallType, |
485 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->DataXferBufferFilled( |
468 pckg().StreamType, pckg().StreamId, pckg().DataSize); |
486 pckg().CallType, pckg().StreamType, pckg().StreamId, |
|
487 pckg().DataSize); |
469 } |
488 } |
470 aMessage.Complete(status); |
489 aMessage.Complete(status); |
471 TRACE_PRN_FN_EXT; |
490 TRACE_PRN_FN_EXT; |
472 } |
491 } |
473 |
492 |
481 { |
500 { |
482 TRACE_PRN_FN_ENT; |
501 TRACE_PRN_FN_ENT; |
483 gint status(TMS_RESULT_DOES_NOT_EXIST); |
502 gint status(TMS_RESULT_DOES_NOT_EXIST); |
484 RChunk chunk; |
503 RChunk chunk; |
485 |
504 |
486 if (iCallAdpt) |
505 if (iCallAdpt &&(iActiveCallType == TMS_CALL_IP)) |
487 { |
506 { |
488 TMSCliSrvDataXferChunkHndlDataStructBufPckg pckg; |
507 TMSCliSrvDataXferChunkHndlDataStructBufPckg pckg; |
489 aMessage.ReadL(0, pckg); |
508 aMessage.ReadL(0, pckg); |
490 status = iCallAdpt->GetDataXferBufferHndl(pckg().CallType, |
509 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->GetDataXferBufferHndl( |
491 pckg().StreamType, pckg().StreamId, pckg().Key, chunk); |
510 pckg().CallType, pckg().StreamType, pckg().StreamId, |
|
511 pckg().Key, chunk); |
492 } |
512 } |
493 |
513 |
494 if (status == TMS_RESULT_SUCCESS && chunk.Handle() > 0) |
514 if (status == TMS_RESULT_SUCCESS && chunk.Handle() > 0) |
495 { |
515 { |
496 aMessage.Complete(chunk); |
516 aMessage.Complete(chunk); |
511 // |
531 // |
512 void TMSCallSession::HandleEffectVolumeGetMaxVolL(const RMessage2& aMessage) |
532 void TMSCallSession::HandleEffectVolumeGetMaxVolL(const RMessage2& aMessage) |
513 { |
533 { |
514 TRACE_PRN_FN_ENT; |
534 TRACE_PRN_FN_ENT; |
515 gint status(TMS_RESULT_DOES_NOT_EXIST); |
535 gint status(TMS_RESULT_DOES_NOT_EXIST); |
516 if (iCallAdpt) |
536 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
517 { |
537 { |
518 guint vol; |
538 guint vol; |
519 status = iCallAdpt->GetMaxVolume(vol); |
539 status = static_cast<TMSCallIPAdpt*> (iCallAdpt)->GetMaxVolume(vol); |
520 if (status == TMS_RESULT_SUCCESS) |
540 if (status == TMS_RESULT_SUCCESS) |
521 { |
541 { |
522 TPckgBuf<guint> pckg(vol); |
542 TPckgBuf<guint> pckg(vol); |
523 aMessage.WriteL(0, pckg); |
543 aMessage.WriteL(0, pckg); |
524 } |
544 } |
534 // |
554 // |
535 void TMSCallSession::HandleEffectVolumeSetVolL(const RMessage2& aMessage) |
555 void TMSCallSession::HandleEffectVolumeSetVolL(const RMessage2& aMessage) |
536 { |
556 { |
537 TRACE_PRN_FN_ENT; |
557 TRACE_PRN_FN_ENT; |
538 gint status(TMS_RESULT_DOES_NOT_EXIST); |
558 gint status(TMS_RESULT_DOES_NOT_EXIST); |
539 if (iCallAdpt) |
559 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
540 { |
560 { |
541 guint vol; |
561 guint vol; |
542 vol = aMessage.Int0(); |
562 vol = aMessage.Int0(); |
543 status = iCallAdpt->SetVolume(vol); |
563 status = static_cast<TMSCallIPAdpt*> (iCallAdpt)->SetVolume(vol); |
544 } |
564 } |
545 aMessage.Complete(status); |
565 aMessage.Complete(status); |
546 TRACE_PRN_FN_EXT; |
566 TRACE_PRN_FN_EXT; |
547 } |
567 } |
548 |
568 |
553 // |
573 // |
554 void TMSCallSession::HandleEffectVolumeGetVolL(const RMessage2& aMessage) |
574 void TMSCallSession::HandleEffectVolumeGetVolL(const RMessage2& aMessage) |
555 { |
575 { |
556 TRACE_PRN_FN_ENT; |
576 TRACE_PRN_FN_ENT; |
557 gint status(TMS_RESULT_DOES_NOT_EXIST); |
577 gint status(TMS_RESULT_DOES_NOT_EXIST); |
558 if (iCallAdpt) |
578 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
559 { |
579 { |
560 guint vol; |
580 guint vol; |
561 status = iCallAdpt->GetVolume(vol); |
581 status = static_cast<TMSCallIPAdpt*> (iCallAdpt)->GetVolume(vol); |
562 if (status == TMS_RESULT_SUCCESS) |
582 if (status == TMS_RESULT_SUCCESS) |
563 { |
583 { |
564 TPckgBuf<guint> pckg(vol); |
584 TPckgBuf<guint> pckg(vol); |
565 aMessage.WriteL(0, pckg); |
585 aMessage.WriteL(0, pckg); |
566 } |
586 } |
576 // |
596 // |
577 void TMSCallSession::HandleEffectVolumeGetMaxGainL(const RMessage2& aMessage) |
597 void TMSCallSession::HandleEffectVolumeGetMaxGainL(const RMessage2& aMessage) |
578 { |
598 { |
579 TRACE_PRN_FN_ENT; |
599 TRACE_PRN_FN_ENT; |
580 gint status(TMS_RESULT_DOES_NOT_EXIST); |
600 gint status(TMS_RESULT_DOES_NOT_EXIST); |
581 if (iCallAdpt) |
601 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
582 { |
602 { |
583 guint gain; |
603 guint gain; |
584 status = iCallAdpt->GetMaxGain(gain); |
604 status = static_cast<TMSCallIPAdpt*> (iCallAdpt)->GetMaxGain(gain); |
585 if (status == TMS_RESULT_SUCCESS) |
605 if (status == TMS_RESULT_SUCCESS) |
586 { |
606 { |
587 TPckgBuf<guint> pckg(gain); |
607 TPckgBuf<guint> pckg(gain); |
588 aMessage.WriteL(0, pckg); |
608 aMessage.WriteL(0, pckg); |
589 } |
609 } |
599 // |
619 // |
600 void TMSCallSession::HandleEffectVolumeSetGainL(const RMessage2& aMessage) |
620 void TMSCallSession::HandleEffectVolumeSetGainL(const RMessage2& aMessage) |
601 { |
621 { |
602 TRACE_PRN_FN_ENT; |
622 TRACE_PRN_FN_ENT; |
603 gint status(TMS_RESULT_DOES_NOT_EXIST); |
623 gint status(TMS_RESULT_DOES_NOT_EXIST); |
604 if (iCallAdpt) |
624 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
605 { |
625 { |
606 guint gain; |
626 guint gain; |
607 gain = aMessage.Int0(); |
627 gain = aMessage.Int0(); |
608 status = iCallAdpt->SetGain(gain); |
628 status = static_cast<TMSCallIPAdpt*> (iCallAdpt)->SetGain(gain); |
609 } |
629 } |
610 aMessage.Complete(status); |
630 aMessage.Complete(status); |
611 TRACE_PRN_FN_EXT; |
631 TRACE_PRN_FN_EXT; |
612 } |
632 } |
613 |
633 |
618 // |
638 // |
619 void TMSCallSession::HandleEffectVolumeGetGainL(const RMessage2& aMessage) |
639 void TMSCallSession::HandleEffectVolumeGetGainL(const RMessage2& aMessage) |
620 { |
640 { |
621 TRACE_PRN_FN_ENT; |
641 TRACE_PRN_FN_ENT; |
622 gint status(TMS_RESULT_DOES_NOT_EXIST); |
642 gint status(TMS_RESULT_DOES_NOT_EXIST); |
623 if (iCallAdpt) |
643 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
624 { |
644 { |
625 guint gain; |
645 guint gain; |
626 status = iCallAdpt->GetGain(gain); |
646 status = static_cast<TMSCallIPAdpt*> (iCallAdpt)->GetGain(gain); |
627 if (status == TMS_RESULT_SUCCESS) |
647 if (status == TMS_RESULT_SUCCESS) |
628 { |
648 { |
629 TPckgBuf<guint> pckg(gain); |
649 TPckgBuf<guint> pckg(gain); |
630 aMessage.WriteL(0, pckg); |
650 aMessage.WriteL(0, pckg); |
631 } |
651 } |
642 void TMSCallSession::HandleGlobalEffectVolumeGetMaxVolL( |
662 void TMSCallSession::HandleGlobalEffectVolumeGetMaxVolL( |
643 const RMessage2& aMessage) |
663 const RMessage2& aMessage) |
644 { |
664 { |
645 TRACE_PRN_FN_ENT; |
665 TRACE_PRN_FN_ENT; |
646 gint status(TMS_RESULT_DOES_NOT_EXIST); |
666 gint status(TMS_RESULT_DOES_NOT_EXIST); |
647 if (iCallAdpt) |
667 if (iCallAdpt && (iActiveCallType == TMS_CALL_CS)) |
648 { |
668 { |
649 guint vol(0); |
669 guint vol(0); |
650 status = iCallAdpt->GetGlobalMaxVolume(vol); |
670 status = static_cast<TMSCallCSAdpt*>(iCallAdpt)->GetGlobalMaxVolume( |
|
671 vol); |
651 if (status == TMS_RESULT_SUCCESS) |
672 if (status == TMS_RESULT_SUCCESS) |
652 { |
673 { |
653 TPckgBuf<guint> pckg(vol); |
674 TPckgBuf<guint> pckg(vol); |
654 aMessage.WriteL(0, pckg); |
675 aMessage.WriteL(0, pckg); |
655 } |
676 } |
664 // ----------------------------------------------------------------------------- |
685 // ----------------------------------------------------------------------------- |
665 // |
686 // |
666 void TMSCallSession::HandleGlobalEffectVolumeSetVolL(const RMessage2& aMessage) |
687 void TMSCallSession::HandleGlobalEffectVolumeSetVolL(const RMessage2& aMessage) |
667 { |
688 { |
668 TRACE_PRN_FN_ENT; |
689 TRACE_PRN_FN_ENT; |
669 gint status(TMS_RESULT_SUCCESS); |
690 gint status(TMS_RESULT_DOES_NOT_EXIST); |
670 iGlobalVol = aMessage.Int0(); |
691 iGlobalVol = aMessage.Int0(); |
671 if (iCallAdpt) |
692 if (iCallAdpt && (iActiveCallType == TMS_CALL_CS)) |
672 { |
693 { |
673 status = iCallAdpt->SetGlobalVolume(iGlobalVol); |
694 status = static_cast<TMSCallCSAdpt*>(iCallAdpt)->SetGlobalVolume( |
|
695 iGlobalVol); |
674 } |
696 } |
675 aMessage.Complete(status); |
697 aMessage.Complete(status); |
676 TRACE_PRN_FN_EXT; |
698 TRACE_PRN_FN_EXT; |
677 } |
699 } |
678 |
700 |
683 // |
705 // |
684 void TMSCallSession::HandleGlobalEffectVolumeGetVolL(const RMessage2& aMessage) |
706 void TMSCallSession::HandleGlobalEffectVolumeGetVolL(const RMessage2& aMessage) |
685 { |
707 { |
686 TRACE_PRN_FN_ENT; |
708 TRACE_PRN_FN_ENT; |
687 gint status(TMS_RESULT_DOES_NOT_EXIST); |
709 gint status(TMS_RESULT_DOES_NOT_EXIST); |
688 if (iCallAdpt) |
710 if (iCallAdpt && (iActiveCallType == TMS_CALL_CS)) |
689 { |
711 { |
690 guint vol(0); |
712 guint vol(0); |
691 status = iCallAdpt->GetGlobalVolume(vol); |
713 status = static_cast<TMSCallCSAdpt*>(iCallAdpt)->GetGlobalVolume(vol); |
692 if (status == TMS_RESULT_SUCCESS) |
714 if (status == TMS_RESULT_SUCCESS) |
693 { |
715 { |
694 TPckgBuf<guint> pckg(vol); |
716 TPckgBuf<guint> pckg(vol); |
695 aMessage.WriteL(0, pckg); |
717 aMessage.WriteL(0, pckg); |
696 } |
718 } |
707 void TMSCallSession::HandleGlobalEffectVolumeGetMaxGainL( |
729 void TMSCallSession::HandleGlobalEffectVolumeGetMaxGainL( |
708 const RMessage2& aMessage) |
730 const RMessage2& aMessage) |
709 { |
731 { |
710 TRACE_PRN_FN_ENT; |
732 TRACE_PRN_FN_ENT; |
711 gint status(TMS_RESULT_DOES_NOT_EXIST); |
733 gint status(TMS_RESULT_DOES_NOT_EXIST); |
712 if (iCallAdpt) |
734 if (iCallAdpt && (iActiveCallType == TMS_CALL_CS)) |
713 { |
735 { |
714 guint gain; |
736 guint gain; |
715 status = iCallAdpt->GetGlobalMaxGain(gain); |
737 status = static_cast<TMSCallCSAdpt*>(iCallAdpt)->GetGlobalMaxGain( |
|
738 gain); |
716 if (status == TMS_RESULT_SUCCESS) |
739 if (status == TMS_RESULT_SUCCESS) |
717 { |
740 { |
718 TPckgBuf<guint> pckg(gain); |
741 TPckgBuf<guint> pckg(gain); |
719 aMessage.WriteL(0, pckg); |
742 aMessage.WriteL(0, pckg); |
720 } |
743 } |
730 // |
753 // |
731 void TMSCallSession::HandleGlobalEffectVolumeSetGainL( |
754 void TMSCallSession::HandleGlobalEffectVolumeSetGainL( |
732 const RMessage2& aMessage) |
755 const RMessage2& aMessage) |
733 { |
756 { |
734 TRACE_PRN_FN_ENT; |
757 TRACE_PRN_FN_ENT; |
735 gint status(TMS_RESULT_SUCCESS); |
758 gint status(TMS_RESULT_DOES_NOT_EXIST); |
736 iGlobalGain = aMessage.Int0(); |
759 iGlobalGain = aMessage.Int0(); |
737 if (iCallAdpt) |
760 if (iCallAdpt && (iActiveCallType == TMS_CALL_CS)) |
738 { |
761 { |
739 status = iCallAdpt->SetGlobalGain(iGlobalGain); |
762 status = static_cast<TMSCallCSAdpt*>(iCallAdpt)->SetGlobalGain( |
|
763 iGlobalGain); |
740 } |
764 } |
741 aMessage.Complete(status); |
765 aMessage.Complete(status); |
742 TRACE_PRN_FN_EXT; |
766 TRACE_PRN_FN_EXT; |
743 } |
767 } |
744 |
768 |
750 void TMSCallSession::HandleGlobalEffectVolumeGetGainL( |
774 void TMSCallSession::HandleGlobalEffectVolumeGetGainL( |
751 const RMessage2& aMessage) |
775 const RMessage2& aMessage) |
752 { |
776 { |
753 TRACE_PRN_FN_ENT; |
777 TRACE_PRN_FN_ENT; |
754 gint status(TMS_RESULT_DOES_NOT_EXIST); |
778 gint status(TMS_RESULT_DOES_NOT_EXIST); |
755 if (iCallAdpt) |
779 if (iCallAdpt && (iActiveCallType == TMS_CALL_CS)) |
756 { |
780 { |
757 guint gain; |
781 guint gain; |
758 status = iCallAdpt->GetGlobalGain(gain); |
782 status = static_cast<TMSCallCSAdpt*>(iCallAdpt)->GetGlobalGain(gain); |
759 if (status == TMS_RESULT_SUCCESS) |
783 if (status == TMS_RESULT_SUCCESS) |
760 { |
784 { |
761 TPckgBuf<guint> pckg(gain); |
785 TPckgBuf<guint> pckg(gain); |
762 aMessage.WriteL(0, pckg); |
786 aMessage.WriteL(0, pckg); |
763 } |
787 } |
774 void TMSCallSession::HandleFormatGetCodecModeL(const RMessage2& aMessage) |
798 void TMSCallSession::HandleFormatGetCodecModeL(const RMessage2& aMessage) |
775 { |
799 { |
776 TRACE_PRN_FN_ENT; |
800 TRACE_PRN_FN_ENT; |
777 gint status(TMS_RESULT_DOES_NOT_EXIST); |
801 gint status(TMS_RESULT_DOES_NOT_EXIST); |
778 |
802 |
779 if (iCallAdpt) |
803 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
780 { |
804 { |
781 gint mode; |
805 gint mode; |
782 TMSFormatType fmttype; |
806 TMSFormatType fmttype; |
783 TMSStreamType strmtype; |
807 TMSStreamType strmtype; |
784 fmttype = aMessage.Int0(); |
808 fmttype = aMessage.Int0(); |
785 strmtype = aMessage.Int1(); |
809 strmtype = aMessage.Int1(); |
786 status = iCallAdpt->GetCodecMode(fmttype, strmtype, mode); |
810 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->GetCodecMode(fmttype, |
|
811 strmtype, mode); |
787 TPckgBuf<gint> pckg(mode); |
812 TPckgBuf<gint> pckg(mode); |
788 aMessage.WriteL(2, pckg); |
813 aMessage.WriteL(2, pckg); |
789 } |
814 } |
790 aMessage.Complete(status); |
815 aMessage.Complete(status); |
791 TRACE_PRN_FN_EXT; |
816 TRACE_PRN_FN_EXT; |
798 // |
823 // |
799 void TMSCallSession::HandleFormatSetCodecModeL(const RMessage2& aMessage) |
824 void TMSCallSession::HandleFormatSetCodecModeL(const RMessage2& aMessage) |
800 { |
825 { |
801 TRACE_PRN_FN_ENT; |
826 TRACE_PRN_FN_ENT; |
802 gint status(TMS_RESULT_DOES_NOT_EXIST); |
827 gint status(TMS_RESULT_DOES_NOT_EXIST); |
803 if (iCallAdpt) |
828 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
804 { |
829 { |
805 gint mode; |
830 gint mode; |
806 TMSFormatType fmttype; |
831 TMSFormatType fmttype; |
807 TMSStreamType strmtype; |
832 TMSStreamType strmtype; |
808 fmttype = aMessage.Int0(); |
833 fmttype = aMessage.Int0(); |
809 strmtype = aMessage.Int1(); |
834 strmtype = aMessage.Int1(); |
810 mode = aMessage.Int2(); |
835 mode = aMessage.Int2(); |
811 status = iCallAdpt->SetCodecMode(fmttype, strmtype, mode); |
836 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->SetCodecMode(fmttype, |
|
837 strmtype, mode); |
812 } |
838 } |
813 aMessage.Complete(status); |
839 aMessage.Complete(status); |
814 TRACE_PRN_FN_EXT; |
840 TRACE_PRN_FN_EXT; |
815 } |
841 } |
816 |
842 |
822 void TMSCallSession::HandleFormatGetSupportedBitRatesCountL( |
848 void TMSCallSession::HandleFormatGetSupportedBitRatesCountL( |
823 const RMessage2& aMessage) |
849 const RMessage2& aMessage) |
824 { |
850 { |
825 TRACE_PRN_FN_ENT; |
851 TRACE_PRN_FN_ENT; |
826 gint status(TMS_RESULT_DOES_NOT_EXIST); |
852 gint status(TMS_RESULT_DOES_NOT_EXIST); |
827 if (iCallAdpt) |
853 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
828 { |
854 { |
829 guint count; |
855 guint count; |
830 status = iCallAdpt->GetSupportedBitRatesCount(count); |
856 status = static_cast<TMSCallIPAdpt*> |
|
857 (iCallAdpt)->GetSupportedBitRatesCount(count); |
831 TPckgBuf<guint> pckg(count); |
858 TPckgBuf<guint> pckg(count); |
832 aMessage.WriteL(0, pckg); |
859 aMessage.WriteL(0, pckg); |
833 } |
860 } |
834 aMessage.Complete(status); |
861 aMessage.Complete(status); |
835 TRACE_PRN_FN_EXT; |
862 TRACE_PRN_FN_EXT; |
843 void TMSCallSession::HandleFormatGetSupportedBitRatesL( |
870 void TMSCallSession::HandleFormatGetSupportedBitRatesL( |
844 const RMessage2& aMessage) |
871 const RMessage2& aMessage) |
845 { |
872 { |
846 TRACE_PRN_FN_ENT; |
873 TRACE_PRN_FN_ENT; |
847 gint status(TMS_RESULT_DOES_NOT_EXIST); |
874 gint status(TMS_RESULT_DOES_NOT_EXIST); |
848 if (iCallAdpt) |
875 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
849 { |
876 { |
850 CBufFlat* brbuf = CBufFlat::NewL(KArrayExpandSize); |
877 CBufFlat* brbuf = CBufFlat::NewL(KArrayExpandSize); |
851 CleanupStack::PushL(brbuf); |
878 CleanupStack::PushL(brbuf); |
852 status = iCallAdpt->GetSupportedBitRates(brbuf); |
879 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->GetSupportedBitRates( |
|
880 brbuf); |
853 aMessage.WriteL(0, brbuf->Ptr(0)); |
881 aMessage.WriteL(0, brbuf->Ptr(0)); |
854 CleanupStack::PopAndDestroy(brbuf); |
882 CleanupStack::PopAndDestroy(brbuf); |
855 } |
883 } |
856 aMessage.Complete(status); |
884 aMessage.Complete(status); |
857 TRACE_PRN_FN_EXT; |
885 TRACE_PRN_FN_EXT; |
864 // |
892 // |
865 void TMSCallSession::HandleFormatGetBitRateL(const RMessage2& aMessage) |
893 void TMSCallSession::HandleFormatGetBitRateL(const RMessage2& aMessage) |
866 { |
894 { |
867 TRACE_PRN_FN_ENT; |
895 TRACE_PRN_FN_ENT; |
868 gint status(TMS_RESULT_DOES_NOT_EXIST); |
896 gint status(TMS_RESULT_DOES_NOT_EXIST); |
869 if (iCallAdpt) |
897 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
870 { |
898 { |
871 guint bitrate; |
899 guint bitrate; |
872 status = iCallAdpt->GetBitRate(bitrate); |
900 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->GetBitRate(bitrate); |
873 TPckgBuf<guint> pckg(bitrate); |
901 TPckgBuf<guint> pckg(bitrate); |
874 aMessage.WriteL(0, pckg); |
902 aMessage.WriteL(0, pckg); |
875 } |
903 } |
876 aMessage.Complete(status); |
904 aMessage.Complete(status); |
877 TRACE_PRN_FN_EXT; |
905 TRACE_PRN_FN_EXT; |
884 // |
912 // |
885 void TMSCallSession::HandleFormatSetBitRateL(const RMessage2& aMessage) |
913 void TMSCallSession::HandleFormatSetBitRateL(const RMessage2& aMessage) |
886 { |
914 { |
887 TRACE_PRN_FN_ENT; |
915 TRACE_PRN_FN_ENT; |
888 gint status(TMS_RESULT_DOES_NOT_EXIST); |
916 gint status(TMS_RESULT_DOES_NOT_EXIST); |
889 if (iCallAdpt) |
917 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
890 { |
918 { |
891 guint bitrate; |
919 guint bitrate; |
892 bitrate = aMessage.Int0(); |
920 bitrate = aMessage.Int0(); |
893 status = iCallAdpt->SetBitRate(bitrate); |
921 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->SetBitRate(bitrate); |
894 } |
922 } |
895 aMessage.Complete(status); |
923 aMessage.Complete(status); |
896 TRACE_PRN_FN_EXT; |
924 TRACE_PRN_FN_EXT; |
897 } |
925 } |
898 |
926 |
903 // |
931 // |
904 void TMSCallSession::HandleFormatGetVADL(const RMessage2& aMessage) |
932 void TMSCallSession::HandleFormatGetVADL(const RMessage2& aMessage) |
905 { |
933 { |
906 TRACE_PRN_FN_ENT; |
934 TRACE_PRN_FN_ENT; |
907 gint status(TMS_RESULT_DOES_NOT_EXIST); |
935 gint status(TMS_RESULT_DOES_NOT_EXIST); |
908 if (iCallAdpt) |
936 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
909 { |
937 { |
910 gboolean vad; |
938 gboolean vad; |
911 TMSFormatType fmttype; |
939 TMSFormatType fmttype; |
912 fmttype = (TMSFormatType) aMessage.Int0(); |
940 fmttype = (TMSFormatType) aMessage.Int0(); |
913 status = iCallAdpt->GetVAD(fmttype, vad); |
941 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->GetVAD(fmttype, vad); |
914 TPckgBuf<gboolean> pckg(vad); |
942 TPckgBuf<gboolean> pckg(vad); |
915 aMessage.WriteL(1, pckg); |
943 aMessage.WriteL(1, pckg); |
916 } |
944 } |
917 aMessage.Complete(status); |
945 aMessage.Complete(status); |
918 TRACE_PRN_FN_EXT; |
946 TRACE_PRN_FN_EXT; |
925 // |
953 // |
926 void TMSCallSession::HandleFormatSetVADL(const RMessage2& aMessage) |
954 void TMSCallSession::HandleFormatSetVADL(const RMessage2& aMessage) |
927 { |
955 { |
928 TRACE_PRN_FN_ENT; |
956 TRACE_PRN_FN_ENT; |
929 gint status(TMS_RESULT_DOES_NOT_EXIST); |
957 gint status(TMS_RESULT_DOES_NOT_EXIST); |
930 if (iCallAdpt) |
958 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
931 { |
959 { |
932 gboolean vad; |
960 gboolean vad; |
933 TMSFormatType fmttype; |
961 TMSFormatType fmttype; |
934 fmttype = (TMSFormatType) aMessage.Int0(); |
962 fmttype = (TMSFormatType) aMessage.Int0(); |
935 vad = (gboolean) aMessage.Int1(); |
963 vad = (gboolean) aMessage.Int1(); |
936 status = iCallAdpt->SetVAD(fmttype, vad); |
964 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->SetVAD(fmttype, vad); |
937 } |
965 } |
938 aMessage.Complete(status); |
966 aMessage.Complete(status); |
939 TRACE_PRN_FN_EXT; |
967 TRACE_PRN_FN_EXT; |
940 } |
968 } |
941 |
969 |
946 // |
974 // |
947 void TMSCallSession::HandleFormatGetCNGL(const RMessage2& aMessage) |
975 void TMSCallSession::HandleFormatGetCNGL(const RMessage2& aMessage) |
948 { |
976 { |
949 TRACE_PRN_FN_ENT; |
977 TRACE_PRN_FN_ENT; |
950 gint status(TMS_RESULT_DOES_NOT_EXIST); |
978 gint status(TMS_RESULT_DOES_NOT_EXIST); |
951 if (iCallAdpt) |
979 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
952 { |
980 { |
953 gboolean cng; |
981 gboolean cng; |
954 TMSFormatType fmttype; |
982 TMSFormatType fmttype; |
955 fmttype = (TMSFormatType) aMessage.Int0(); |
983 fmttype = (TMSFormatType) aMessage.Int0(); |
956 status = iCallAdpt->GetCNG(fmttype, cng); |
984 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->GetCNG(fmttype, cng); |
957 TPckgBuf<gboolean> pckg(cng); |
985 TPckgBuf<gboolean> pckg(cng); |
958 aMessage.WriteL(1, pckg); |
986 aMessage.WriteL(1, pckg); |
959 } |
987 } |
960 aMessage.Complete(status); |
988 aMessage.Complete(status); |
961 TRACE_PRN_FN_EXT; |
989 TRACE_PRN_FN_EXT; |
968 // |
996 // |
969 void TMSCallSession::HandleFormatSetCNGL(const RMessage2& aMessage) |
997 void TMSCallSession::HandleFormatSetCNGL(const RMessage2& aMessage) |
970 { |
998 { |
971 TRACE_PRN_FN_ENT; |
999 TRACE_PRN_FN_ENT; |
972 gint status(TMS_RESULT_DOES_NOT_EXIST); |
1000 gint status(TMS_RESULT_DOES_NOT_EXIST); |
973 if (iCallAdpt) |
1001 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
974 { |
1002 { |
975 gboolean cng; |
1003 gboolean cng; |
976 TMSFormatType fmttype; |
1004 TMSFormatType fmttype; |
977 fmttype = (TMSFormatType) aMessage.Int0(); |
1005 fmttype = (TMSFormatType) aMessage.Int0(); |
978 cng = (gboolean) aMessage.Int1(); |
1006 cng = (gboolean) aMessage.Int1(); |
979 status = iCallAdpt->SetCNG(fmttype, cng); |
1007 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->SetCNG(fmttype, cng); |
980 } |
1008 } |
981 aMessage.Complete(status); |
1009 aMessage.Complete(status); |
982 TRACE_PRN_FN_EXT; |
1010 TRACE_PRN_FN_EXT; |
983 } |
1011 } |
984 |
1012 |
989 // |
1017 // |
990 void TMSCallSession::HandleFormatGetPlcL(const RMessage2& aMessage) |
1018 void TMSCallSession::HandleFormatGetPlcL(const RMessage2& aMessage) |
991 { |
1019 { |
992 TRACE_PRN_FN_ENT; |
1020 TRACE_PRN_FN_ENT; |
993 gint status(TMS_RESULT_DOES_NOT_EXIST); |
1021 gint status(TMS_RESULT_DOES_NOT_EXIST); |
994 if (iCallAdpt) |
1022 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
995 { |
1023 { |
996 gboolean plc; |
1024 gboolean plc; |
997 TMSFormatType fmttype; |
1025 TMSFormatType fmttype; |
998 fmttype = (TMSFormatType) aMessage.Int0(); |
1026 fmttype = (TMSFormatType) aMessage.Int0(); |
999 status = iCallAdpt->GetPlc(fmttype, plc); |
1027 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->GetPlc(fmttype, plc); |
1000 TPckgBuf<gboolean> pckg(plc); |
1028 TPckgBuf<gboolean> pckg(plc); |
1001 aMessage.WriteL(1, pckg); |
1029 aMessage.WriteL(1, pckg); |
1002 } |
1030 } |
1003 aMessage.Complete(status); |
1031 aMessage.Complete(status); |
1004 TRACE_PRN_FN_EXT; |
1032 TRACE_PRN_FN_EXT; |
1011 // |
1039 // |
1012 void TMSCallSession::HandleFormatSetPlcL(const RMessage2& aMessage) |
1040 void TMSCallSession::HandleFormatSetPlcL(const RMessage2& aMessage) |
1013 { |
1041 { |
1014 TRACE_PRN_FN_ENT; |
1042 TRACE_PRN_FN_ENT; |
1015 gint status(TMS_RESULT_DOES_NOT_EXIST); |
1043 gint status(TMS_RESULT_DOES_NOT_EXIST); |
1016 if (iCallAdpt) |
1044 if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) |
1017 { |
1045 { |
1018 gboolean plc; |
1046 gboolean plc; |
1019 TMSFormatType fmttype; |
1047 TMSFormatType fmttype; |
1020 fmttype = (TMSFormatType) aMessage.Int0(); |
1048 fmttype = (TMSFormatType) aMessage.Int0(); |
1021 plc = (gboolean) aMessage.Int1(); |
1049 plc = (gboolean) aMessage.Int1(); |
1022 status = iCallAdpt->SetPlc(fmttype, plc); |
1050 status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->SetPlc(fmttype, plc); |
1023 } |
1051 } |
1024 aMessage.Complete(status); |
1052 aMessage.Complete(status); |
1025 TRACE_PRN_FN_EXT; |
1053 TRACE_PRN_FN_EXT; |
1026 } |
1054 } |
1027 |
1055 |