/**
* Saves the direction parameter (if there is one)
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onConnect(Streamwide_Engine_Events_Event $event)
{
$okSignal = $event->getParam('signal');
$params = $okSignal->getParams();
if (array_key_exists('direction', $params)) {
$this->_direction = $params['direction'];
}
}
/**
* Send a RING signal to the SIP call leg
*
* @return void
*/
protected function _sendRing()
{
// retrieve the OK signal from the event object
$okSignal = $this->_event->getParam('signal');
// get a reference to the SIP call leg
$sipCallLeg = $this->_widget->getLeftCallLeg();
// send the RING signal
$ringSignal = Streamwide_Engine_Signal::factory(Streamwide_Engine_Signal::RING, $sipCallLeg->getName(), $okSignal->getParams());
$ringSignal->send();
}
/**
* Send PROGRESS to the SIP call leg
*
* @return void
*/
protected function _sendProgress()
{
// extract the OK signal parameters
$okSignal = $this->_event->getParam('signal');
$params = $okSignal->getParams();
// get a reference to the SIP call leg
$sipCallLeg = $this->_widget->getLeftCallLeg();
// send the PROGRESS signal to the SIP call leg
$progressSignal = Streamwide_Engine_Signal::factory(Streamwide_Engine_Signal::PROGRESS, $sipCallLeg->getName(), array('proto' => 'SIP', 'sdp' => $params['sdp']));
$progressSignal->send();
}
/**
* @see Engine/Call/Leg/Streamwide_Engine_Call_Leg_Connexant#onSignalReceived()
*/
public function onSignalReceived(Streamwide_Engine_Events_Event $event)
{
$eventType = $event->getEventType();
$signal = $event->getParam('signal');
switch ($eventType) {
case Streamwide_Engine_Events_Event::MOVED:
return $this->_handleMovedSignal($signal);
case Streamwide_Engine_Events_Event::SDP:
return $this->_handleSdpSignal($signal);
case Streamwide_Engine_Events_Event::OKMOVED:
return $this->_handleOkMovedSignal($signal);
case Streamwide_Engine_Events_Event::FAILMOVED:
return $this->_handleFailMovedSignal($signal);
case Streamwide_Engine_Events_Event::CHILD:
return $this->_handleChildSignal($signal);
}
return null;
}
/**
* Handle the receival of a signal from SW Engine
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onSignalReceived(Streamwide_Engine_Events_Event $event)
{
$eventType = $event->getEventType();
$signal = $event->getParam('signal');
switch ($eventType) {
case Streamwide_Engine_Events_Event::FAIL:
return $this->_handleFailSignal($signal);
case Streamwide_Engine_Events_Event::OK:
return $this->_handleOkSignal($signal);
case Streamwide_Engine_Events_Event::PROK:
return $this->_handleProkSignal($signal);
case Streamwide_Engine_Events_Event::RING:
return $this->_handleRingSignal($signal);
case Streamwide_Engine_Events_Event::PROGRESS:
return $this->_handleProgressSignal($signal);
case Streamwide_Engine_Events_Event::CHILD:
return $this->_handleChildSignal($signal);
}
return null;
}
/**
* @see Engine/Call/Leg/Streamwide_Engine_Call_Leg_Connexant#onSignalReceived()
*/
public function onSignalReceived(Streamwide_Engine_Events_Event $event)
{
$eventType = $event->getEventType();
$signal = $event->getParam('signal');
// delegate to internal methods to handle the OK and FAIL signals
switch ($eventType) {
case Streamwide_Engine_Events_Event::OK:
return $this->_handleOkSignal($signal);
case Streamwide_Engine_Events_Event::FAIL:
return $this->_handleFailSignal($signal);
case Streamwide_Engine_Events_Event::CHILD:
return $this->_handleChildSignal($signal);
case Streamwide_Engine_Events_Event::SDP:
return $this->_handleSdpSignal($signal);
case Streamwide_Engine_Events_Event::OKSDP:
return $this->_handleOkSdpSignal($signal);
case Streamwide_Engine_Events_Event::FAILSDP:
return $this->_handleFailSdpSignal($signal);
}
return null;
}
/**
* Handle the EOF signal from SW Engine
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onEof(Streamwide_Engine_Events_Event $event)
{
// raise the eofReceived flag
$this->_eofReceived = true;
// clear the playlist (if this option is activated)
$this->clearPlaylist();
// mark the widget as READY
$this->_stateManager->setState(self::STATE_READY);
// dispatch a PLAYER_FINISHED event
$signal = $event->getParam('signal');
$event = new Streamwide_Engine_Events_Event(Streamwide_Engine_Events_Event::FINISHED);
$event->setParam('signal', $signal);
$this->dispatchEvent($event);
}
/**
* Callback to respond to the TIMEOUT SW Engine signal
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onTimeout(Streamwide_Engine_Events_Event $event)
{
if (!$this->isArmed()) {
return $this->dispatchErrorEvent(self::ALREADY_ARMED_ERR_CODE);
}
// mark the timer as READY
$this->_stateManager->setState(self::STATE_READY);
// lower the flag so, that the next call to arm() will
// generate a new name
$this->_nameGenerated = false;
// dispatch a TIMEOUT_TIMER_TIMEOUT event
$signal = $event->getParam('signal');
$event = new Streamwide_Engine_Events_Event(Streamwide_Engine_Events_Event::TIMEOUT);
$event->setParam('signal', $signal);
$this->dispatchEvent($event);
}
/**
* Callback. Called when the transfer is successful. Will notify the call leg
* that emitted the TRANSFER request, attempt to kill it and dispatch
* a TRANSFERRED event
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onTransferSuccess(Streamwide_Engine_Events_Event $event)
{
$this->_connector->reset();
$okTransfer = Streamwide_Engine_Signal::factory(Streamwide_Engine_Signal::OKTRANSFER, $this->_transferSource->getName());
if (false === $okTransfer->send()) {
$this->dispatchErrorEvent(self::OKTRANSFER_SIGNAL_SEND_ERR_CODE);
return;
}
$kill = Streamwide_Engine_Signal::factory(Streamwide_Engine_Signal::KILL, $this->_transferSource->getName());
if (false === $kill->send()) {
$this->dispatchErrorEvent(self::KILL_SIGNAL_SEND_ERR_CODE);
return;
}
$signal = $event->getParam('signal');
$event = new Streamwide_Engine_Events_Event(Streamwide_Engine_Events_Event::TRANSFERRED);
$event->setParam('signal', $signal);
$this->dispatchEvent($event);
}
/**
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onSignalRelayed(Streamwide_Engine_Events_Event $event)
{
$signal = $event->getParam('signal');
switch ($signal->getName()) {
case Streamwide_Engine_Signal::TRANSFER:
$this->_handleTransferSignal($signal);
break;
case Streamwide_Engine_Signal::OKTRANSFER:
$this->_handleOkTransferSignal($signal);
break;
case Streamwide_Engine_Signal::FAILTRANSFER:
$this->_handleFailTransferSignal($signal);
break;
}
}
/**
* Handles the FAIL event
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
protected function _handleFailEvent(Streamwide_Engine_Events_Event $event)
{
// Make sure to unsubscribe the event listeners as early as possible.
// In case of retry the call legs names will be regenerated so the
// event listeners MUST be recreated. In case of letting the decorated
// widget handle the FAIL signal we also need to remove the event listeners
$this->_unsubscribeFromEngineEvents();
$signal = $event->getParam('signal');
$params = $signal->getParams();
$code = null;
if (array_key_exists('code', $params)) {
$code = $params['code'];
}
if (null !== $code && !$this->isOutgoingStopCode($code)) {
$this->_failEvent = $event;
return $this->_connect();
}
$this->_widget->removeEventListener(Streamwide_Engine_Events_Event::ERROR, array('callback' => array($this, 'onError')));
$this->_widget->triggerErrorEventOnRemoteSipFailure(true);
return $this->_widget->onSignalReceived($event);
}
/**
* Deal with a key press from the user
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onKeyPressed(Streamwide_Engine_Events_Event $event)
{
$key = $event->getParam('receivedKey');
$promptType = $event->getContextParam('promptType');
if ($this->_isEndKey($key)) {
$this->_timer->reset();
$this->_mediaPlayer->reset();
$this->_dtmfHandler->reset();
$event = new Streamwide_Engine_Events_Event(Streamwide_Engine_Events_Event::FINISHED);
$event->setParam('number', $this->_number);
$this->dispatchEvent($event);
} else {
$this->_number .= $key;
$this->_rearmTimer();
if (null !== $promptType) {
if (self::PROMPT_INVITE === $promptType) {
if ($this->_shouldStopPromptingOnDtmf()) {
$this->_mediaPlayer->stop();
}
} else {
$this->_mediaPlayer->stop();
}
}
}
}
public function onWordRecognized(Streamwide_Engine_Events_Event $event)
{
$signal = $event->getParam('signal');
$params = $signal->getParams();
if ($params['word'] === '@') {
$this->dispatchErrorEvent(self::ASR_RECOGNITION_FAILURE_ERR_CODE);
return;
}
$event = new Streamwide_Engine_Events_Event(Streamwide_Engine_Events_Event::WORD_RECOGNIZED);
$event->setParam('signal', $signal);
$this->dispatchEvent($event);
}
/**
* Checks to see if a relay session can be ended by searching the received
* event type in the relay session parameters array.
* If found the relay session is ended, if not nothing happens.
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
protected function _endRelaySession(Streamwide_Engine_Events_Event $event)
{
if ($this->_isRelaySessionEndingEvent($event->getEventType())) {
$this->_isRelaySessionStarted = false;
$relaySessionEndedEvt = new Streamwide_Engine_Events_Event(Streamwide_Engine_Events_Event::RELAY_SESSION_ENDED);
$relaySessionEndedEvt->setParam('signal', $event->getParam('signal'));
return $this->dispatchEvent($relaySessionEndedEvt);
}
}
/**
* Handles an event triggered by the receiving of a signal
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onSignalReceived(Streamwide_Engine_Events_Event $event)
{
$signal = $event->getParam('signal');
$remote = $signal->getRemote();
$params = $signal->getParams();
if (!is_array($params) || empty($params) || !array_key_exists('sdp', $params)) {
$message = 'No "sdp" parameter found in the "%s" signal. Signal will be skipped';
trigger_error(sprintf($message, $signal->getName()), E_USER_NOTICE);
return;
}
if ($remote === $this->getLeftCallLeg()->getName()) {
$source = 'left';
} elseif ($remote === $this->getRightCallLeg()->getName()) {
$source = 'right';
} else {
$message = 'Unexpected source for "%s" signal. Signal will be skipped';
trigger_error(sprintf($message, $signal->getName()), E_USER_NOTICE);
return;
}
$this->_updateRtpProxyCallLeg($params['sdp'], $source);
$modifiedSdp = $this->_modifySdp($params['sdp'], $source);
$params['sdp'] = $modifiedSdp;
$signal->setParams($params);
$event->setParam('signal', $signal);
}
/**
* We have received ENDOFFAX, we need to check it's "ok" parameter to see if
* everything went fine
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onEndOfFax(Streamwide_Engine_Events_Event $event)
{
$signal = $event->getParam('signal');
$params = $signal->getParams();
$this->_forcedFaxNegotiator->reset();
$this->_unsubscribeFromEngineEvents();
if (array_key_exists('ok', $params) && $params['ok'] === 'true') {
return $this->dispatchEvent(new Streamwide_Engine_Events_Event(Streamwide_Engine_Events_Event::FAX_SENT));
}
return $this->dispatchErrorEvent(self::FAX_NOT_SENT_ERR_CODE);
}
/**
* The transfer has failed. We need to dispatch an ERROR event
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onTransferFailure(Streamwide_Engine_Events_Event $event)
{
$this->_unsubscribeFromEngineEvents();
$this->_stateManager->setState(self::STATE_READY);
$signal = $event->getParam('signal');
$params = $signal->getParams();
$failureCode = isset($params['code']) ? $params['code'] : null;
$this->dispatchErrorEvent(self::TRANSFER_FAILED_ERR_CODE, array('failureCode' => $failureCode, 'signal' => $signal));
}
/**
* Handles a key press (delegates to internal methods)
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onKeyPressed(Streamwide_Engine_Events_Event $event)
{
$eventType = $event->getEventType();
$key = $event->getParam('receivedKey');
$promptType = $event->getContextParam('promptType');
switch ($eventType) {
case Streamwide_Engine_Events_Event::KEY:
$this->_handleValidKey($key, $promptType);
break;
case Streamwide_Engine_Events_Event::UNEXPECTED_KEY:
$this->_handleInvalidKey($key, $promptType);
break;
}
}
/**
* Handle a DTMF signal
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onDtmf(Streamwide_Engine_Events_Event $event)
{
// if the handler is not in the listening state we should not treat the event
if (!$this->isListening()) {
return null;
}
// extract the source of the DTMF signal
$signal = $event->getParam('signal');
$remote = $signal->getRemote();
// check to see if we have an allowed source
if (!$this->_isAllowedDtmfSource($remote)) {
return null;
}
// extract the DTMF value
$params = $signal->getParams();
$dtmf = $params['dtmf'];
// add the received dtmf to the received dtmfs list
$this->_receivedDtmfs[] = $dtmf;
// check if the limit is reached
if ($this->_isLimitReached()) {
$this->stopListening();
}
// if the dtmf is "treatable" add it to the handled dtmfs list and dispatch
// a KEY event
if ($this->_isAllowedDtmf($dtmf)) {
$this->_handledDtmfs[] = $dtmf;
if ($this->_canDtmfStopListeningProcess($dtmf)) {
$this->stopListening();
}
$event = new Streamwide_Engine_Events_Event(Streamwide_Engine_Events_Event::KEY);
$event->setParam('receivedKey', $dtmf);
$event->setParam('source', $remote);
$event->setParam('signal', $signal);
$this->dispatchEvent($event);
} else {
if ($this->_canDtmfStopListeningProcess($dtmf, false)) {
$this->stopListening();
}
if ($this->_shouldSignalWrongKey()) {
// if the handler is set to signal unexpected keys, dispatch an DTMF_HANDLER_UNEXPECTED_KEY event
$event = new Streamwide_Engine_Events_Event(Streamwide_Engine_Events_Event::UNEXPECTED_KEY);
$event->setParam('receivedKey', $dtmf);
$event->setParam('source', $remote);
$event->setParam('signal', $signal);
$this->dispatchEvent($event);
}
}
}
/**
* We have received a FAXPAGE from SW Engine we need to save the current fax page
*
* @param Streamwide_Engine_Events_Event $event
* @return void
*/
public function onFaxPage(Streamwide_Engine_Events_Event $event)
{
$signal = $event->getParam('signal');
$params = $signal->getParams();
if (isset($params['filename'])) {
$this->_pages[] = $params['filename'];
}
$event = new Streamwide_Engine_Events_Event(Streamwide_Engine_Events_Event::FAX_PAGE_RECEIVED);
$event->setParam('filename', $params['filename']);
$event->setParam('receivedFaxPagesCount', count($this->_pages));
return $this->dispatchEvent($event);
}
