// Demux the call event to the right PeerConnection
void PeerConnectionCtx::onCallEvent_m(ccapi_call_event_e aCallEvent,
CSF::CC_CallPtr aCall,
CSF::CC_CallInfoPtr aInfo) {
CSFLogDebug(logTag, "onCallEvent()");
PeerConnectionWrapper pc(aCall->getPeerConnection());
if (!pc.impl()) // This must be an event on a dead PC. Ignore
return;
CSFLogDebug(logTag, "Calling PC");
pc.impl()->onCallEvent(aCallEvent, aCall, aInfo);
}
void
PeerConnectionImpl::onCallEvent(ccapi_call_event_e aCallEvent,
CSF::CC_CallPtr aCall, CSF::CC_CallInfoPtr aInfo)
{
PC_AUTO_ENTER_API_CALL_NO_CHECK();
MOZ_ASSERT(aCall.get());
MOZ_ASSERT(aInfo.get());
cc_call_state_t event = aInfo->getCallState();
std::string statestr = aInfo->callStateToString(event);
if (CCAPI_CALL_EV_CREATED != aCallEvent && CCAPI_CALL_EV_STATE != aCallEvent) {
CSFLogDebug(logTag, "%s: **** CALL HANDLE IS: %s, **** CALL STATE IS: %s",
__FUNCTION__, mHandle.c_str(), statestr.c_str());
return;
}
switch (event) {
case SETLOCALDESC:
case UPDATELOCALDESC:
mLocalSDP = aInfo->getSDP();
break;
case SETREMOTEDESC:
case ADDICECANDIDATE:
mRemoteSDP = aInfo->getSDP();
break;
case CONNECTED:
CSFLogDebug(logTag, "Setting PeerConnnection state to kActive");
ChangeReadyState(kActive);
break;
default:
break;
}
nsCOMPtr<IPeerConnectionObserver> pco = do_QueryReferent(mPCObserver);
if (!pco) {
return;
}
PeerConnectionObserverDispatch* runnable =
new PeerConnectionObserverDispatch(aInfo, this, pco);
if (mThread) {
mThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
return;
}
runnable->Run();
delete runnable;
}
void
PeerConnectionImpl::onCallEvent(ccapi_call_event_e aCallEvent,
CSF::CC_CallPtr aCall, CSF::CC_CallInfoPtr aInfo)
{
PC_AUTO_ENTER_API_CALL_NO_CHECK();
MOZ_ASSERT(aCall.get());
MOZ_ASSERT(aInfo.get());
cc_call_state_t event = aInfo->getCallState();
std::string statestr = aInfo->callStateToString(event);
if (CCAPI_CALL_EV_CREATED != aCallEvent && CCAPI_CALL_EV_STATE != aCallEvent) {
CSFLogDebugS(logTag, ": **** CALL HANDLE IS: " << mHandle <<
": **** CALL STATE IS: " << statestr);
return;
}
switch (event) {
case SETLOCALDESC:
case UPDATELOCALDESC:
mLocalSDP = aInfo->getSDP();
break;
case SETREMOTEDESC:
case UPDATEREMOTEDESC:
mRemoteSDP = aInfo->getSDP();
break;
case CONNECTED:
CSFLogDebugS(logTag, "Setting PeerConnnection state to kActive");
ChangeReadyState(kActive);
break;
default:
break;
}
if (mPCObserver) {
PeerConnectionObserverDispatch* runnable =
new PeerConnectionObserverDispatch(aInfo, this, mPCObserver);
if (mThread) {
mThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
return;
}
runnable->Run();
}
}
void PeerConnectionCtx::onCallEvent(ccapi_call_event_e aCallEvent,
CSF::CC_CallPtr aCall,
CSF::CC_CallInfoPtr aInfo) {
// This is called on a SIPCC thread.
//
// We cannot use SyncRunnable to main thread, as that would deadlock on
// shutdown. Instead, we dispatch asynchronously. We copy getPeerConnection(),
// a "weak ref" to the PC, which is safe in shutdown, and CC_CallInfoPtr (an
// nsRefPtr) is thread-safe and keeps aInfo alive.
nsAutoPtr<std::string> pcDuped(new std::string(aCall->getPeerConnection()));
// DISPATCH_NORMAL with duped string
nsresult rv = gMainThread->Dispatch(WrapRunnableNM(&onCallEvent_m, pcDuped,
aCallEvent, aInfo),
NS_DISPATCH_NORMAL);
if (NS_FAILED(rv)) {
CSFLogError( logTag, "%s(): Could not dispatch to main thread", __FUNCTION__);
}
}