The Tor Browser / file comparison

comparison: media/webrtc/signaling/src/softphonewrapper/CC_SIPCCCallInfo.cpp

media/webrtc/signaling/src/softphonewrapper/CC_SIPCCCallInfo.cpp

branch
TOR_BUG_9701
changeset 10
ac0c01689b40
equal deleted inserted replaced
-1:000000000000 0:9811200c29f4
1 /* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4
5 #include "CSFLog.h"
6
7 #include "CC_Common.h"
8
9 #include "CC_SIPCCCallInfo.h"
10 #include "CC_SIPCCLine.h"
11
12 extern "C"
13 {
14 #include "ccapi_call.h"
15 #include "ccapi_call_info.h"
16 #include "fsmdef_states.h"
17 }
18
19 static const char* logTag = "CC_SIPCCCallInfo";
20
21 using namespace std;
22 using namespace CSF;
23
24 CC_SIPCCCallInfo::CC_SIPCCCallInfo (cc_callinfo_ref_t callinfo) : callinfo_ref(callinfo)
25 {
26 CCAPI_Call_retainCallInfo(callinfo);
27 }
28
29 CSF_IMPLEMENT_WRAP(CC_SIPCCCallInfo, cc_callinfo_ref_t);
30
31 CC_SIPCCCallInfo::~CC_SIPCCCallInfo()
32 {
33 CCAPI_Call_releaseCallInfo(callinfo_ref);
34 }
35
36 bool CC_SIPCCCallInfo::hasCapability (CC_CallCapabilityEnum::CC_CallCapability capability)
37 {
38 generateCapabilities();
39 return (caps.find(capability) != caps.end());
40 }
41
42 set<CC_CallCapabilityEnum::CC_CallCapability> CC_SIPCCCallInfo::getCapabilitySet()
43 {
44 generateCapabilities();
45 set<CC_CallCapabilityEnum::CC_CallCapability> callCaps(caps);
46 return callCaps;
47 }
48
49 /*
50 CC_LinePtr CC_SIPCCCallInfo::getLine ()
51 {
52 }
53 */
54
55 cc_call_state_t CC_SIPCCCallInfo::getCallState()
56 {
57 return CCAPI_CallInfo_getCallState(callinfo_ref);
58 }
59
60 fsmdef_states_t CC_SIPCCCallInfo::getFsmState() const
61 {
62 return CCAPI_CallInfo_getFsmState(callinfo_ref);
63 }
64
65 std::string CC_SIPCCCallInfo::fsmStateToString (fsmdef_states_t state) const
66 {
67 return fsmdef_state_name(state);
68 }
69
70 std::string CC_SIPCCCallInfo::callStateToString (cc_call_state_t state)
71 {
72 std::string statestr = "";
73
74 switch(state) {
75 case OFFHOOK:
76 statestr = "OFFHOOK";
77 break;
78 case ONHOOK:
79 statestr = "ONHOOK";
80 break;
81 case RINGOUT:
82 statestr = "RINGOUT";
83 break;
84 case RINGIN:
85 statestr = "RINGIN";
86 break;
87 case PROCEED:
88 statestr = "PROCEED";
89 break;
90 case CONNECTED:
91 statestr = "CONNECTED";
92 break;
93 case HOLD:
94 statestr = "ONHOOK";
95 break;
96 case REMHOLD:
97 statestr = "REMHOLD";
98 break;
99 case RESUME:
100 statestr = "RESUME";
101 break;
102 case BUSY:
103 statestr = "BUSY";
104 break;
105 case REORDER:
106 statestr = "REORDER";
107 break;
108 case CONFERENCE:
109 statestr = "CONFERENCE";
110 break;
111 case DIALING:
112 statestr = "DIALING";
113 break;
114 case REMINUSE:
115 statestr = "REMINUSE";
116 break;
117 case HOLDREVERT:
118 statestr = "HOLDREVERT";
119 break;
120 case WHISPER:
121 statestr = "WHISPER";
122 break;
123 case PRESERVATION:
124 statestr = "PRESERVATION";
125 break;
126 case WAITINGFORDIGITS:
127 statestr = "WAITINGFORDIGITS";
128 break;
129 case CREATEOFFERSUCCESS:
130 statestr = "CREATEOFFERSUCCESS";
131 break;
132 case CREATEANSWERSUCCESS:
133 statestr = "CREATEANSWERSUCCESS";
134 break;
135 case CREATEOFFERERROR:
136 statestr = "CREATEOFFERERROR";
137 break;
138 case CREATEANSWERERROR:
139 statestr = "CREATEANSWERERROR";
140 break;
141 case SETLOCALDESCSUCCESS:
142 statestr = "SETLOCALDESCSUCCESS";
143 break;
144 case SETREMOTEDESCSUCCESS:
145 statestr = "SETREMOTEDESCSUCCESS";
146 break;
147 case UPDATELOCALDESC:
148 statestr = "UPDATELOCALDESC";
149 break;
150 case SETLOCALDESCERROR:
151 statestr = "SETLOCALDESCERROR";
152 break;
153 case SETREMOTEDESCERROR:
154 statestr = "SETREMOTEDESCERROR";
155 break;
156 case REMOTESTREAMADD:
157 statestr = "REMOTESTREAMADD";
158 break;
159 case ADDICECANDIDATE:
160 statestr = "ADDICECANDIDATE";
161 break;
162 case ADDICECANDIDATEERROR:
163 statestr = "ADDICECANDIDATEERROR";
164 break;
165 default:
166 break;
167 }
168
169 return statestr;
170 }
171
172 std::string CC_SIPCCCallInfo::callEventToString (ccapi_call_event_e callEvent)
173 {
174 std::string statestr = "";
175
176 switch(callEvent) {
177 case CCAPI_CALL_EV_CREATED:
178 statestr = "CCAPI_CALL_EV_CREATED";
179 break;
180 case CCAPI_CALL_EV_STATE:
181 statestr = "CCAPI_CALL_EV_STATE";
182 break;
183 case CCAPI_CALL_EV_CALLINFO:
184 statestr = "CCAPI_CALL_EV_CALLINFO";
185 break;
186 case CCAPI_CALL_EV_ATTR:
187 statestr = "CCAPI_CALL_EV_ATTR";
188 break;
189 case CCAPI_CALL_EV_SECURITY:
190 statestr = "CCAPI_CALL_EV_SECURITY";
191 break;
192 case CCAPI_CALL_EV_LOG_DISP:
193 statestr = "CCAPI_CALL_EV_LOG_DISP";
194 break;
195 case CCAPI_CALL_EV_PLACED_CALLINFO:
196 statestr = "CCAPI_CALL_EV_PLACED_CALLINFO";
197 break;
198 case CCAPI_CALL_EV_STATUS:
199 statestr = "CCAPI_CALL_EV_STATUS";
200 break;
201 case CCAPI_CALL_EV_SELECT:
202 statestr = "CCAPI_CALL_EV_SELECT";
203 break;
204 case CCAPI_CALL_EV_LAST_DIGIT_DELETED:
205 statestr = "CCAPI_CALL_EV_LAST_DIGIT_DELETED";
206 break;
207 case CCAPI_CALL_EV_GCID:
208 statestr = "CCAPI_CALL_EV_GCID";
209 break;
210 case CCAPI_CALL_EV_XFR_OR_CNF_CANCELLED:
211 statestr = "CCAPI_CALL_EV_XFR_OR_CNF_CANCELLED";
212 break;
213 case CCAPI_CALL_EV_PRESERVATION:
214 statestr = "CCAPI_CALL_EV_PRESERVATION";
215 break;
216 case CCAPI_CALL_EV_CAPABILITY:
217 statestr = "CCAPI_CALL_EV_CAPABILITY";
218 break;
219 case CCAPI_CALL_EV_VIDEO_AVAIL:
220 statestr = "CCAPI_CALL_EV_VIDEO_AVAIL";
221 break;
222 case CCAPI_CALL_EV_VIDEO_OFFERED:
223 statestr = "CCAPI_CALL_EV_VIDEO_OFFERED";
224 break;
225 case CCAPI_CALL_EV_RECEIVED_INFO:
226 statestr = "CCAPI_CALL_EV_RECEIVED_INFO";
227 break;
228 case CCAPI_CALL_EV_RINGER_STATE:
229 statestr = "CCAPI_CALL_EV_RINGER_STATE";
230 break;
231 case CCAPI_CALL_EV_CONF_PARTICIPANT_INFO:
232 statestr = "CCAPI_CALL_EV_CONF_PARTICIPANT_INFO";
233 break;
234 case CCAPI_CALL_EV_MEDIA_INTERFACE_UPDATE_BEGIN:
235 statestr = "CCAPI_CALL_EV_MEDIA_INTERFACE_UPDATE_BEGIN";
236 break;
237 case CCAPI_CALL_EV_MEDIA_INTERFACE_UPDATE_SUCCESSFUL:
238 statestr = "CCAPI_CALL_EV_MEDIA_INTERFACE_UPDATE_SUCCESSFUL";
239 break;
240 case CCAPI_CALL_EV_MEDIA_INTERFACE_UPDATE_FAIL:
241 statestr = "CCAPI_CALL_EV_MEDIA_INTERFACE_UPDATE_FAIL";
242 break;
243 default:
244 break;
245 }
246
247 return statestr;
248 }
249
250 bool CC_SIPCCCallInfo::getRingerState()
251 {
252 if (CCAPI_CallInfo_getRingerState(callinfo_ref))
253 {
254 return true;
255 }
256 else
257 {
258 return false;
259 }
260 }
261
262 cc_call_attr_t CC_SIPCCCallInfo::getCallAttr()
263 {
264 return CCAPI_CallInfo_getCallAttr(callinfo_ref);
265 }
266
267 cc_call_type_t CC_SIPCCCallInfo::getCallType()
268 {
269 return CCAPI_CallInfo_getCallType(callinfo_ref);
270 }
271
272 string CC_SIPCCCallInfo::getCalledPartyName()
273 {
274 return CCAPI_CallInfo_getCalledPartyName(callinfo_ref);
275 }
276
277 string CC_SIPCCCallInfo::getCalledPartyNumber()
278 {
279 return CCAPI_CallInfo_getCalledPartyNumber(callinfo_ref);
280 }
281
282 string CC_SIPCCCallInfo::getCallingPartyName()
283 {
284 return CCAPI_CallInfo_getCallingPartyName(callinfo_ref);
285 }
286
287 string CC_SIPCCCallInfo::getCallingPartyNumber()
288 {
289 return CCAPI_CallInfo_getCallingPartyNumber(callinfo_ref);
290 }
291
292 string CC_SIPCCCallInfo::getAlternateNumber()
293 {
294 return CCAPI_CallInfo_getAlternateNumber(callinfo_ref);
295 }
296
297 CC_LinePtr CC_SIPCCCallInfo::getline ()
298 {
299 cc_lineid_t lineId = CCAPI_CallInfo_getLine(callinfo_ref);
300 return CC_SIPCCLine::wrap(lineId).get();
301 }
302
303 string CC_SIPCCCallInfo::getOriginalCalledPartyName()
304 {
305 return CCAPI_CallInfo_getOriginalCalledPartyName(callinfo_ref);
306 }
307
308 string CC_SIPCCCallInfo::getOriginalCalledPartyNumber()
309 {
310 return CCAPI_CallInfo_getOriginalCalledPartyNumber(callinfo_ref);
311 }
312
313 string CC_SIPCCCallInfo::getLastRedirectingPartyName()
314 {
315 return CCAPI_CallInfo_getLastRedirectingPartyName(callinfo_ref);
316 }
317
318 string CC_SIPCCCallInfo::getLastRedirectingPartyNumber()
319 {
320 return CCAPI_CallInfo_getLastRedirectingPartyNumber(callinfo_ref);
321 }
322
323 string CC_SIPCCCallInfo::getPlacedCallPartyName()
324 {
325 return CCAPI_CallInfo_getPlacedCallPartyName(callinfo_ref);
326 }
327
328 string CC_SIPCCCallInfo::getPlacedCallPartyNumber()
329 {
330 return CCAPI_CallInfo_getPlacedCallPartyNumber(callinfo_ref);
331 }
332
333 cc_int32_t CC_SIPCCCallInfo::getCallInstance()
334 {
335 return CCAPI_CallInfo_getCallInstance(callinfo_ref);
336 }
337
338 string CC_SIPCCCallInfo::getStatus()
339 {
340 return CCAPI_CallInfo_getStatus(callinfo_ref);
341 }
342
343 cc_call_security_t CC_SIPCCCallInfo::getSecurity()
344 {
345 return CCAPI_CallInfo_getSecurity(callinfo_ref);
346 }
347
348 cc_int32_t CC_SIPCCCallInfo::getSelectionStatus()
349 {
350 return CCAPI_CallInfo_getSelectionStatus(callinfo_ref);
351 }
352
353 string CC_SIPCCCallInfo::getGCID()
354 {
355 return CCAPI_CallInfo_getGCID(callinfo_ref);
356 }
357
358 bool CC_SIPCCCallInfo::getIsRingOnce()
359 {
360 return (CCAPI_CallInfo_getIsRingOnce(callinfo_ref) != 0);
361 }
362
363 int CC_SIPCCCallInfo::getRingerMode()
364 {
365 return CCAPI_CallInfo_getRingerMode(callinfo_ref);
366 }
367
368 cc_int32_t CC_SIPCCCallInfo::getOnhookReason()
369 {
370 return CCAPI_CallInfo_getOnhookReason(callinfo_ref);
371 }
372
373 bool CC_SIPCCCallInfo::getIsConference()
374 {
375 return (CCAPI_CallInfo_getIsConference(callinfo_ref) != 0);
376 }
377
378 set<cc_int32_t> CC_SIPCCCallInfo::getStreamStatistics()
379 {
380 CSFLogError(logTag, "CCAPI_CallInfo_getCapabilitySet() NOT IMPLEMENTED IN PSIPCC.");
381 set<cc_int32_t> stats;
382 return stats;
383 }
384
385 bool CC_SIPCCCallInfo::isCallSelected()
386 {
387 return (CCAPI_CallInfo_isCallSelected(callinfo_ref) != 0);
388 }
389
390 string CC_SIPCCCallInfo::getINFOPack()
391 {
392 return CCAPI_CallInfo_getINFOPack(callinfo_ref);
393 }
394
395 string CC_SIPCCCallInfo::getINFOType()
396 {
397 return CCAPI_CallInfo_getINFOType(callinfo_ref);
398 }
399
400 string CC_SIPCCCallInfo::getINFOBody()
401 {
402 return CCAPI_CallInfo_getINFOBody(callinfo_ref);
403 }
404
405 cc_calllog_ref_t CC_SIPCCCallInfo::getCallLogRef()
406 {
407 return CCAPI_CallInfo_getCallLogRef(callinfo_ref);
408 }
409
410 cc_sdp_direction_t CC_SIPCCCallInfo::getVideoDirection()
411 {
412 return CCAPI_CallInfo_getVideoDirection(callinfo_ref);
413 }
414
415 int CC_SIPCCCallInfo::getVolume()
416 {
417 if( pMediaData != nullptr)
418 {
419 return pMediaData->volume;
420 }
421 else
422 {
423 return -1;
424 }
425 }
426
427 bool CC_SIPCCCallInfo::isAudioMuted()
428 {
429 return (CCAPI_CallInfo_isAudioMuted(callinfo_ref) != 0);
430 }
431
432 bool CC_SIPCCCallInfo::isVideoMuted()
433 {
434 return (CCAPI_CallInfo_isVideoMuted(callinfo_ref) != 0);
435 }
436
437 string CC_SIPCCCallInfo::getSDP()
438 {
439 return CCAPI_CallInfo_getSDP(callinfo_ref);
440 }
441
442 cc_int32_t CC_SIPCCCallInfo::getStatusCode()
443 {
444 return CCAPI_CallInfo_getStatusCode(callinfo_ref);
445 }
446
447 MediaStreamTable* CC_SIPCCCallInfo::getMediaStreams() const
448 {
449 return CCAPI_CallInfo_getMediaStreams(callinfo_ref);
450 }
451
452 Timecard *CC_SIPCCCallInfo::takeTimecard()
453 {
454 return CCAPI_CallInfo_takeTimecard(callinfo_ref);
455 }
456
457 std::string CC_SIPCCCallInfo::getCandidate()
458 {
459 return CCAPI_CallInfo_getCandidate(callinfo_ref);
460 }
461
462 bool CC_SIPCCCallInfo::isMediaStateAvailable()
463 {
464 // for softphone it will always be possible to query the mute state and video direction
465 return true;
466 }
467
468
469 #define PRINT_IF_CC_CAP_TRUE(cap) ((hasFeature(cap)) ? string(#cap) + ",": "")
470 void CC_SIPCCCallInfo::generateCapabilities()
471 {
472 // If caps are already generated, no need to repeat the exercise.
473 if(!caps.empty())
474 return;
475 /*
476 CSFLogDebugS( logTag, "generateCapabilities() state=" << getCallState() <<
477 " underlyingCaps=" <<
478 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_NEWCALL) <<
479 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_ANSWER) <<
480 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_ENDCALL) <<
481 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_HOLD) <<
482 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_RESUME) <<
483 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_CALLFWD) <<
484 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_DIAL) <<
485 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_BACKSPACE) <<
486 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_SENDDIGIT) <<
487 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_TRANSFER) <<
488 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_CONFERENCE) <<
489 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_SWAP) <<
490 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_REDIAL) <<
491 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_JOIN) <<
492 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_SELECT) <<
493 PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_RMVLASTPARTICIPANT) );
494 */
495 switch(getCallState())
496 {
497 case OFFHOOK:
498 if(hasFeature(CCAPI_CALL_CAP_NEWCALL)) {
499 caps.insert(CC_CallCapabilityEnum::canOriginateCall);
500 }
501 if(hasFeature(CCAPI_CALL_CAP_ENDCALL)) {
502 caps.insert(CC_CallCapabilityEnum::canEndCall);
503 }
504 break;
505 case ONHOOK:
506 break;
507 case DIALING:
508 case PROCEED:
509 case RINGOUT:
510 if(hasFeature(CCAPI_CALL_CAP_ENDCALL)) {
511 caps.insert(CC_CallCapabilityEnum::canEndCall);
512 }
513 if(hasFeature(CCAPI_CALL_CAP_SENDDIGIT)) caps.insert(CC_CallCapabilityEnum::canSendDigit);
514 break;
515 case RINGIN:
516 if(hasFeature(CCAPI_CALL_CAP_ANSWER)) caps.insert(CC_CallCapabilityEnum::canAnswerCall);
517 break;
518 case CONNECTED:
519 if(hasFeature(CCAPI_CALL_CAP_ENDCALL)) {
520 caps.insert(CC_CallCapabilityEnum::canEndCall);
521 }
522 caps.insert(CC_CallCapabilityEnum::canSendDigit);
523 if(hasFeature(CCAPI_CALL_CAP_HOLD)) caps.insert(CC_CallCapabilityEnum::canHold);
524
525 caps.insert(CC_CallCapabilityEnum::canSetVolume);
526 if(isAudioMuted())
527 {
528 caps.insert(CC_CallCapabilityEnum::canUnmuteAudio);
529 }
530 else
531 {
532 caps.insert(CC_CallCapabilityEnum::canMuteAudio);
533 }
534
535 if ((CCAPI_CallInfo_getVideoDirection(callinfo_ref) == CC_SDP_DIRECTION_SENDRECV) ||
536 (CCAPI_CallInfo_getVideoDirection(callinfo_ref) == CC_SDP_DIRECTION_SENDONLY))
537 {
538 // sending video so video mute is possible
539 if (isVideoMuted())
540 {
541 caps.insert(CC_CallCapabilityEnum::canUnmuteVideo);
542 }
543 else
544 {
545 caps.insert(CC_CallCapabilityEnum::canMuteVideo);
546 }
547 }
548 caps.insert(CC_CallCapabilityEnum::canUpdateVideoMediaCap);
549 break;
550 case HOLD:
551 case REMHOLD:
552 caps.insert(CC_CallCapabilityEnum::canResume);
553 break;
554
555 case BUSY:
556 case REORDER:
557 if(hasFeature(CCAPI_CALL_CAP_ENDCALL)) {
558 caps.insert(CC_CallCapabilityEnum::canEndCall);
559 }
560 break;
561 case PRESERVATION:
562 if(hasFeature(CCAPI_CALL_CAP_ENDCALL)) {
563 caps.insert(CC_CallCapabilityEnum::canEndCall);
564 }
565 break;
566
567 // Not worrying about these states yet.
568 case RESUME:
569 case CONFERENCE:
570 case REMINUSE:
571 case HOLDREVERT:
572 case WHISPER:
573 case WAITINGFORDIGITS:
574 default:
575 CSFLogError( logTag, "State %d not handled in generateCapabilities()",
576 getCallState());
577 break;
578 }
579 }
580
581 bool CC_SIPCCCallInfo::hasFeature(ccapi_call_capability_e cap)
582 {
583 return (CCAPI_CallInfo_hasCapability(callinfo_ref, (cc_int32_t) cap) != 0);
584 }
585
586 void CC_SIPCCCallInfo::setMediaData(CC_SIPCCCallMediaDataPtr pMediaData)
587 {
588 this-> pMediaData = pMediaData;
589 }
590

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial