Category

Development Platform
Home > SourceCode/Document > Multimedia program > VOIP program > View Code
MessageProcessor.java
Package: SIP-applet-phone.zip　[view]
Upload User: liulanlin
Upload Date: 2017-12-08
Package Size: 1274k
Code Size: 34k
Category:

VOIP program

Development Platform:

Java

MessageProcessor.java：Code Content
  1. /*
  2.  * MessageProcessor.java
  3.  *
  4.  * Created on November 17, 2003, 5:52 PM
  5.  */
  7. package gov.nist.applet.phone.ua;
  9. import java.text.ParseException;
  10. import javax.sip.InvalidArgumentException;
  11. import javax.sip.SipException;
  12. import javax.sip.Transaction;
  13. import javax.sip.SipFactory;
  14. import javax.sip.ServerTransaction;
  15. import javax.sip.ClientTransaction;
  16. import javax.sip.message.Request;
  17. import javax.sip.message.Response;
  18. import javax.sip.message.MessageFactory;
  19. import javax.sip.address.AddressFactory;
  20. import javax.sip.address.Address;
  21. import javax.sip.address.SipURI;
  22. import javax.sip.address.URI;
  23. import javax.sip.header.AcceptHeader;
  24. import javax.sip.header.CallInfoHeader;
  25. import javax.sip.header.ContentTypeHeader;
  26. import javax.sip.header.HeaderFactory;
  27. import javax.sip.header.FromHeader;
  28. import javax.sip.header.ToHeader;
  29. import javax.sip.header.ExpiresHeader;
  30. import javax.sip.header.RouteHeader;
  31. import javax.sip.header.RecordRouteHeader;
  32. import javax.sip.header.ContactHeader;
  34. import java.util.ListIterator;
  35. import java.util.LinkedList;
  36. import java.util.Iterator;
  38. import gov.nist.applet.phone.media.MediaManager;
  39. import gov.nist.applet.phone.media.messaging.VoicePlayer;
  40. import gov.nist.applet.phone.media.messaging.VoiceRecorder;
  41. import gov.nist.applet.phone.ua.call.*;
  42. import gov.nist.applet.phone.ua.pidf.parser.PresenceTag;
  43. import gov.nist.applet.phone.ua.pidf.parser.XMLpidfParser;
  44. import gov.nist.applet.phone.ua.presence.*;
  45. /**
  46.  * Handler of a major part of sip messages
  47.  * 
  48.  * @author  DERUELLE Jean
  49.  */
  50. public class MessageProcessor {
  52. /**
  53.  * The SipFactory instance used to create the SipStack and the Address
  54.  * Message and Header Factories.
  55.  */
  56. SipFactory sipFactory;
  58. /**
  59.  * The AddressFactory used to create URLs ans Address objects.
  60.  */
  61. AddressFactory addressFactory;
  63. /**
  64.  * The HeaderFactory used to create SIP message headers.
  65.  */
  66. HeaderFactory headerFactory;
  68. /**
  69.  * The Message Factory used to create SIP messages.
  70.  */
  71. MessageFactory messageFactory;
  73. /**
  74.  * The MessageListener used to handle incoming messages
  75.  */
  76. MessageListener messageListener;
  77. /**
  78.  * the configuration
  79.  */
  80. private Configuration configuration;
  81. VoicePlayer voicePlayer = null;
  82. /**
  83.  * 
  84.  */
  85. MessengerManager messengerManager;
  87. VoiceMessagingTask voiceMessagingTask;
  88.         
  89.         CallManager callManager;
  93. class VoiceMessagingTask implements Runnable {
  94. Thread voiceMessagingThread = null;
  95. String contactAddress = null;
  96. protected static final String STARTED = "Started";
  97. protected static final String STOPPED = "Stopped";
  98. String state = STOPPED;
  100. public VoiceMessagingTask(String contactAddress) {
  101. this.contactAddress = contactAddress;
  102. }
  104. public synchronized void start() {
  105. if (voiceMessagingThread == null) {
  106. voiceMessagingThread = new Thread(this);
  107. }
  108. state = STARTED;
  109. voiceMessagingThread.start();
  110. }
  112. public synchronized void stop() {
  113. state = STOPPED;
  114. }
  116. public void run() {
  117. while (state.equals(STARTED)) {
  118. try {
  119. byte[] buffer = VoiceRecorder.getInstance().getRecord();
  120. if (buffer != null)
  121. messengerManager.sendVoiceMessage(
  122. contactAddress,
  123. buffer);
  124. voiceMessagingThread.sleep(
  125. Configuration.latency4VoiceMessaging);
  126. } catch (Exception ex) {
  127. ex.printStackTrace();
  128. }
  129. }
  130. }
  131. }
  133. /**
  134.  * 
  135.  */
  136. protected void startVoiceMessagingSchedule(String callee) {
  137. //schedule to send the voice messages every 2 sec.
  138. VoiceRecorder.getInstance().initialize();
  139. VoiceRecorder.getInstance().start();
  140. voiceMessagingTask = new VoiceMessagingTask(callee);
  141. voiceMessagingTask.start();
  142. }
  144. /**
  145.  * 
  146.  */
  147. protected void stopVoiceMessagingSchedule() {
  148. //Stop the voice messages schedule and the voiceRecorder
  149. voiceMessagingTask.stop();
  150. VoiceRecorder.getInstance().stop();
  151. if (!VoiceRecorder.isClosed())
  152. VoiceRecorder.getInstance().close();
  153. }
  155. /** Creates a new instance of MessageProcessor 
  156.  * @param callListener - the sip Listener used to handle incoming messages
  157.  */
  158. public MessageProcessor(MessageListener messageListener) {
  159. voicePlayer = new VoicePlayer();
  160. this.messageListener = messageListener;
  161. this.addressFactory = MessageListener.addressFactory;
  162. this.sipFactory = MessageListener.sipFactory;
  163. this.headerFactory = MessageListener.headerFactory;
  164. this.messageFactory = MessageListener.messageFactory;
  165. this.configuration = messageListener.getConfiguration();
  166. this.messengerManager = messageListener.sipMeetingManager;
  167. }
  169. /**********************************************************************/
  170. /*                                                                    */
  171. /*                    Handling request messages                       */
  172. /*                                                                    */
  173. /**********************************************************************/
  175. /**
  176.  * Process the INVITE received request
  177.  * @param serverTransaction - the server transaction associated with the request
  178.  * @param invite - the request 
  179.  */
  180. public void processInvite(
  181. ServerTransaction serverTransaction,
  182. Request invite) {
  183. //Strip out the callee
  184. SipURI calleeURI =
  185. (SipURI) ((FromHeader) invite.getHeader(FromHeader.NAME))
  186. .getAddress()
  187. .getURI();
  188. String callee =
  189. "sip:" + calleeURI.getUser() + "@" + calleeURI.getHost();
  190. // Note that IM Calls are always accepted but VOICE calls may be rejected as there is
  191. // only one Voice line.
  192. try {
  193. CallManager callManager =
  194. messageListener.sipMeetingManager.getCallManager();
  195. //The audio device cannot be shared so if the user is already
  196. //in a call, a busy here is sent back
  197. if (callManager.isAlreadyInAudioCall()) {
  198. Response busyHere =
  199. (Response) MessageListener.messageFactory.createResponse(
  200. Response.BUSY_HERE,
  201. invite);
  202. //If the user has put an URL for the BUSY we add i in the CALL-Info
  203.    if(messageListener.getConfiguration().httpBusy!=null){
  204. CallInfoHeader callInfoHeader=
  205. MessageListener.headerFactory.createCallInfoHeader(
  206.    MessageListener.addressFactory.createURI(
  207.    messageListener.getConfiguration().httpBusy));
  208.    busyHere.addHeader(callInfoHeader);
  209.   }
  210.   System.out.println("send response : " + busyHere.toString());
  211.   serverTransaction.sendResponse(busyHere);
  212. } else {
  213.                                 
  214. Response ringing =
  215. (Response) MessageListener.messageFactory.createResponse(
  216. Response.RINGING,
  217. invite);
  218. // System.out.println("send response : "+ringing.toString());
  219. serverTransaction.sendResponse(ringing);
  220. AudioCall audioCall = new AudioCall(messageListener);
  221. audioCall.setCallee(callee);
  222. audioCall.setDialog(serverTransaction.getDialog());
  223. audioCall.setStatus(AudioCall.INCOMING_CALL);
  224. System.out.println(
  225. "Audio Call created : "
  226. + audioCall.getDialog().getDialogId());
  227. callManager.addAudioCall(audioCall);
  228. //Check if someone is inviting us to voice messaging
  229. //or regular RTP media session
  230. boolean voiceMessaging = false;
  231. ContentTypeHeader contentTypeHeader =
  232. (ContentTypeHeader) invite.getHeader(
  233. ContentTypeHeader.NAME);
  234. if (contentTypeHeader == null) {
  235. ListIterator acceptHeaderList =
  236. invite.getHeaders(AcceptHeader.NAME);
  237. while (acceptHeaderList.hasNext() && !voiceMessaging) {
  238. AcceptHeader acceptHeader =
  239. (AcceptHeader) acceptHeaderList.next();
  240. if (acceptHeader
  241. .getContentSubType()
  242. .equalsIgnoreCase("gsm")
  243. || acceptHeader.getContentSubType().equalsIgnoreCase(
  244. "x-gsm"))
  245. voiceMessaging = true;
  246. }
  247. }
  248. audioCall.setVoiceMesaging(voiceMessaging);
  249. // The SDP tool will be created when you send OK.
  250. messageListener.sipMeetingManager.notifyObserversNewCallStatus(
  251. audioCall);
  252. }
  253. } catch (SipException se) {
  254. se.printStackTrace();
  255. } catch (ParseException pe) {
  256. pe.printStackTrace();
  257. }catch (InvalidArgumentException iae) {
  258.                         iae.printStackTrace();
  259.                 } 
  261. }
  263. /**
  264.  * Process the BYE received request
  265.  * @param serverTransaction - the server transaction associated with the request
  266.  * @param bye - the bye request 
  267.  */
  268. public void processBye(ServerTransaction serverTransaction, Request bye) {
  269. CallManager callManager =
  270. messageListener.sipMeetingManager.getCallManager();
  271. //Find the matching call
  272. Call call =
  273. callManager.findCall(serverTransaction.getDialog().getDialogId());
  275. if (call == null) return;
  276. //Send OK
  277. try {
  278. Response ok =
  279. (Response) MessageListener.messageFactory.createResponse(
  280. Response.OK,
  281. bye);
  282. serverTransaction.sendResponse(ok);
  283. if (call instanceof AudioCall) {
  284. AudioCall audioCall = (AudioCall) call;
  285. audioCall.setStatus(AudioCall.NOT_IN_A_CALL);
  286. messageListener.sipMeetingManager.notifyObserversNewCallStatus(
  287. audioCall);
  288. if (audioCall.getVoiceMessaging()) {
  289. stopVoiceMessagingSchedule();
  290. } else {
  291. audioCall.getMediaManager().stopMediaSession();
  292. }
  293. //Remove the call
  294. System.out.println(
  295. "Audio Call removed : " + call.getDialog().getDialogId());
  296. callManager.removeAudioCall(audioCall);
  297. } else {
  298. IMCall imCall = (IMCall) call;
  299. //Remove the call
  300. System.out.println(
  301. "IM Call removed : " + call.getDialog().getDialogId());
  302. callManager.removeIMCall(imCall);
  303. }
  304. } catch (SipException se) {
  305. se.printStackTrace();
  306. } catch (ParseException pe) {
  307. pe.printStackTrace();
  308. }catch (InvalidArgumentException iae) {
  309.                         iae.printStackTrace();
  310.                 } 
  311. }
  313. /**
  314.  * Process the ACK received request
  315.  * @param serverTransaction - the server transaction associated with the request
  316.  * @param ack - the ack request 
  317.  */
  318. public void processAck(ServerTransaction serverTransaction, Request ack) {
  319. CallManager callManager =
  320. messageListener.sipMeetingManager.getCallManager();
  321. //Strip out the callee
  322. SipURI calleeURI =
  323. (SipURI) ((FromHeader) ack.getHeader(FromHeader.NAME))
  324. .getAddress()
  325. .getURI();
  326. String callee =
  327. "sip:" + calleeURI.getUser() + "@" + calleeURI.getHost();
  328. //Find the Audio call
  329. AudioCall call = callManager.findAudioCall(callee);
  330. if (call != null) {
  331. if (!call.getVoiceMessaging())
  332. call.getMediaManager().startMediaSession(false);
  333. else
  334. startVoiceMessagingSchedule(callee);
  335. call.setStatus(AudioCall.IN_A_CALL);
  336. messageListener.sipMeetingManager.notifyObserversNewCallStatus(
  337. call);
  338. }
  339. }
  341. /**
  342.  * Process the CANCEL received request
  343.  * @param serverTransaction - the server transaction associated with the request
  344.  * @param cancel - the cancel request 
  345.  */
  346. public void processCancel(
  347. ServerTransaction serverTransaction,
  348. Request cancel) {
  349. CallManager callManager =
  350. messageListener.sipMeetingManager.getCallManager();
  351. //Strip out the callee
  352. SipURI calleeURI =
  353. (SipURI) ((FromHeader) cancel.getHeader(FromHeader.NAME))
  354. .getAddress()
  355. .getURI();
  356. String callee =
  357. "sip:" + calleeURI.getUser()
  358. + "@"
  359. + calleeURI.getHost().trim().toLowerCase();
  360. //Find the Audio call
  361. AudioCall call = callManager.findAudioCall(callee);
  362. //Send OK
  363. try {
  364. Response ok =
  365. (Response) MessageListener.messageFactory.createResponse(
  366. Response.OK,
  367. cancel);
  368. serverTransaction.sendResponse(ok);
  369. call.setStatus(AudioCall.CANCEL);
  370. messageListener.sipMeetingManager.notifyObserversNewCallStatus(
  371. call);
  372. System.out.println(
  373. "Audio Call removed : " + call.getDialog().getDialogId());
  374. callManager.removeAudioCall(call);
  375. } catch (SipException se) {
  376. se.printStackTrace();
  377. } catch (ParseException pe) {
  378. pe.printStackTrace();
  379. }catch (InvalidArgumentException iae) {
  380.                         iae.printStackTrace();
  381.                 } 
  383. }
  385. /**
  386.  * Process the MESSAGE received request. MESSAGE may be handled statefully or
  387.  * statelessly.
  388.  * @param serverTransaction - the server transaction associated with the request
  389.  * @param message - the request 
  390.  */
  391. public void processMessage(
  392. ServerTransaction serverTrans,
  393. Request message) {
  394.                     
  395.                ServerTransaction serverTransaction = null;
  397.                 try {
  399.                     serverTransaction = 
  400. (serverTrans == null? 
  401. messageListener.sipProvider.getNewServerTransaction(message): 
  402. serverTrans);
  403.                 } catch (javax.sip.TransactionAlreadyExistsException ex) {
  404.                     ex.printStackTrace();
  405.                     return;
  406.                 } catch (javax.sip.TransactionUnavailableException ex1) {
  407.                     ex1.printStackTrace();
  408.                     return;
  409.                 }
  410.                            
  412.                        
  414. //Send OK
  415. try {
  416. String sender = null;
  417. Address address =
  418. ((FromHeader) message.getHeader(FromHeader.NAME)).getAddress();
  419. if (address.getURI().isSipURI()) {
  420. SipURI sipURI = ((SipURI) address.getURI());
  421. String host = sipURI.getHost();
  422. String user = sipURI.getUser();
  423. sender = user + "@" + host;
  424. }
  425.                         
  426. //Getting the sdp body for creating the response
  427. //This sdp body will present what codec has been chosen
  428. //and on which port every media will be received
  429. ContentTypeHeader contentTypeHeader =
  430. (ContentTypeHeader) message.getHeader(ContentTypeHeader.NAME);
  431. if (contentTypeHeader == null
  432. || contentTypeHeader.getContentType() == null
  433. || contentTypeHeader.getContentSubType() == null)
  434. return;
  435. String subType = contentTypeHeader.getContentSubType();
  436. //If we have a voice messaging plays it
  437. if (contentTypeHeader.getContentType().equals("audio")) {
  438. if (contentTypeHeader.getContentSubType().equals("x-gsm")
  439. || contentTypeHeader.getContentSubType().equals("gsm")) {
  440. Response ok =
  441. (
  442. Response) MessageListener
  443. .messageFactory
  444. .createResponse(
  445. Response.OK,
  446. message);
  447. ToHeader toHeader =
  448. (ToHeader) message.getHeader(ToHeader.NAME);
  449. if (toHeader.getTag() == null)
  450. toHeader.setTag(
  451. new Integer((int) (Math.random() * 10000))
  452. .toString());
  453. serverTransaction.sendResponse(ok);
  454. byte[] voiceMessage = message.getRawContent();
  455. //if(!voicePlayer.isInitialized())
  456. voicePlayer.initialize(voiceMessage);
  457. /*else
  458. voicePlayer.setData(voiceMessage);*/
  459. voicePlayer.play();
  460. message.removeContent();
  461. } else {
  462. System.out.println(
  463. "Cannot handle this codec "
  464. + contentTypeHeader.getContentSubType());
  465. }
  466. } else if (
  467. contentTypeHeader.getContentType().equals("text")
  468. && contentTypeHeader.getContentSubType().equals("plain")) {
  469. Response ok =
  470. (Response) MessageListener.messageFactory.createResponse(
  471. Response.OK,
  472. message);
  473. ToHeader toHeader = (ToHeader) message.getHeader(ToHeader.NAME);
  474. if (toHeader.getTag() == null) {
  475. toHeader.setTag(
  476. new Integer((int) (Math.random() * 10000)).toString());
  477.                                         IMCall imcall = this.messengerManager.callManager.findIMCall(sender);
  478.                                         if (imcall == null) {
  479.                                                 imcall = new IMCall(sender);
  480.                                                 imcall.setDialog(serverTransaction.getDialog());
  481.                                                 this.messengerManager.callManager.addIMCall(imcall);
  482.                                         } else imcall.setDialog(serverTransaction.getDialog());
  483.                                 }
  484. serverTransaction.sendResponse(ok);
  485. String content = new String(message.getRawContent());
  486. FromHeader fromHeader =
  487. (FromHeader) message.getHeader(FromHeader.NAME);
  488. messageListener.sipMeetingManager.notifyObserversIMReceived(
  489. content,
  490. sender);
  491. } else {
  492. // send a Not Acceptable here message.
  493. Response notok =
  494. (Response) MessageListener.messageFactory.createResponse(
  495. Response.NOT_ACCEPTABLE,
  496. message);
  497. ToHeader toHeader = (ToHeader) message.getHeader(ToHeader.NAME);
  498. serverTransaction.sendResponse(notok);
  499. System.out.println(
  500. "Cannot handle this content Type " + contentTypeHeader);
  501. }
  502.                         
  503. message.removeContent();
  504. } catch (SipException se) {
  505. se.printStackTrace();
  506. } catch (ParseException pe) {
  507. pe.printStackTrace();
  508. }catch (InvalidArgumentException iae) {
  509.                         iae.printStackTrace();
  510.                 } 
  512. }
  514. /**
  515.  * Process the SUBSCRIBE received request
  516.  * @param serverTransaction - the server transaction associated with the request
  517.  * @param subscribe - the request 
  518.  */
  519. public void processSubscribe(
  520. ServerTransaction serverTransaction,
  521. Request subscribe) {
  522. Address address =
  523. ((FromHeader) subscribe.getHeader(FromHeader.NAME)).getAddress();
  524. String sender = null;
  525. if (address.getURI().isSipURI()) {
  526. SipURI sipURI = ((SipURI) address.getURI());
  527. String host = sipURI.getHost();
  528. String user = sipURI.getUser();
  529. sender = user + "@" + host;
  530. }
  531. Subscriber subscriber = new Subscriber(sender);
  532. subscriber.setDialog(serverTransaction.getDialog());
  533. messageListener.sipMeetingManager.notifySubscribe(subscriber);
  534. }
  536. /**
  537.  * Process the NOTIFY received request
  538.  * @param serverTransaction - the server transaction associated with the request
  539.  * @param notify - the request 
  540.  */
  541. public void processNotify(
  542. ServerTransaction serverTransaction,
  543. Request notify) {
  544. //Send OK
  545. try {
  546. Response ok =
  547. (Response) MessageListener.messageFactory.createResponse(
  548. Response.OK,
  549. notify);
  550. ToHeader toHeader = (ToHeader) notify.getHeader(ToHeader.NAME);
  551. if (toHeader.getTag() == null)
  552. toHeader.setTag(
  553. new Integer((int) (Math.random() * 10000)).toString());
  554. serverTransaction.sendResponse(ok);
  556. Address address =
  557. ((FromHeader) notify.getHeader(FromHeader.NAME)).getAddress();
  558. String sender = null;
  559. if (address.getURI().isSipURI()) {
  560. SipURI sipURI = ((SipURI) address.getURI());
  561. String host = sipURI.getHost();
  562. String user = sipURI.getUser();
  563. sender = user + "@" + host;
  564. }
  565. ContentTypeHeader contentTypeHeader =
  566. (ContentTypeHeader) notify.getHeader(ContentTypeHeader.NAME);
  567. if (contentTypeHeader != null) {
  568. String xmlType = contentTypeHeader.getContentSubType();
  570. if (xmlType.equals("xpidf+xml")) {
  571. String pidfContent = new String(notify.getRawContent());
  572. int endDocIndex = pidfContent.indexOf("<presence>");
  573. pidfContent = pidfContent.substring(endDocIndex);
  574. XMLpidfParser pidfParser = new XMLpidfParser();
  575. pidfParser.parsePidfString(pidfContent);
  576. PresenceTag presenceTag = pidfParser.getPresenceTag();
  577. presenceTag.setAddress(sender);
  578. messageListener.sipMeetingManager.notifyPresence(
  579. presenceTag);
  580. }
  581. }
  582. } catch (SipException se) {
  583. se.printStackTrace();
  584. } catch (ParseException pe) {
  585. pe.printStackTrace();
  586. }catch (InvalidArgumentException iae) {
  587.                         iae.printStackTrace();
  588.                 } 
  589. }
  591. /**
  592.  * After a
  593.  * @param clientTransaction
  594.  * @param response
  595.  */
  596. public void processRequestTerminated(
  597. ClientTransaction clientTransaction,
  598. Response response) {
  600. }
  602. /**********************************************************************/
  603. /*                                                                    */
  604. /*                    Handling response messages                      */
  605. /*                                                                    */
  606. /**********************************************************************/
  608. /**
  609.  * Process the Not found received response
  610.  * @param clientTransaction - the client transaction associated with the response
  611.  * @param notFound - the not found response
  612.  */
  613. public void processNotFound(
  614. ClientTransaction clientTransaction,
  615. Response notFound) {
  617. }
  619. /**
  620.  * Process the Not Implemented received response
  621.  * @param clientTransaction - the client transaction associated with the response
  622.  * @param notImplemented - the not found response
  623.  */
  624. public void processNotImplemented(
  625. ClientTransaction clientTransaction,
  626. Response notImplemented) {
  628. }
  630. /**
  631.  * Process the Trying received response
  632.  * @param clientTransaction - the client transaction associated with the response
  633.  * @param trying - the trying response
  634.  */
  635. public void processTrying(
  636. ClientTransaction clientTransaction,
  637. Response trying) {
  638. CallManager callManager =
  639. messageListener.sipMeetingManager.getCallManager();
  640. //Strip out the callee
  641. SipURI calleeURI =
  642. (SipURI) ((ToHeader) trying.getHeader(ToHeader.NAME))
  643. .getAddress()
  644. .getURI();
  645. String callee =
  646. "sip:" + calleeURI.getUser() + "@" + calleeURI.getHost();
  647. //Find the Audio call
  648. AudioCall call = callManager.findAudioCall(callee);
  649. if (call != null) {
  650. call.setStatus(AudioCall.TRYING);
  651. messageListener.sipMeetingManager.notifyObserversNewCallStatus(
  652. call);
  653. }
  654. }
  656. /**
  657.  * Process the Ringing received response
  658.  * @param clientTransaction - the client transaction associated with the response
  659.  * @param ringing - the ringing response
  660.  */
  661. public void processRinging(
  662. ClientTransaction clientTransaction,
  663. Response ringing) {
  664. CallManager callManager =
  665. messageListener.sipMeetingManager.getCallManager();
  666. //Strip out the callee
  667. SipURI calleeURI =
  668. (SipURI) ((ToHeader) ringing.getHeader(ToHeader.NAME))
  669. .getAddress()
  670. .getURI();
  671. String callee =
  672. "sip:" + calleeURI.getUser() + "@" + calleeURI.getHost();
  673. //Find the Audio call
  674. AudioCall call = callManager.findAudioCall(callee);
  675. call.setStatus(AudioCall.RINGING);
  676. messageListener.sipMeetingManager.notifyObserversNewCallStatus(call);
  677. }
  679. /**
  680.  * Process the OK received response for a REGISTER 
  681.  * @param clientTransaction - the client transaction associated with the response
  682.  * @param registerOK - the OK received response for a REGISTER 
  683.  */
  684. public void processRegisterOK(
  685. ClientTransaction clientTransaction,
  686. Response registerOK) {
  687. FromHeader fromHeader =
  688. ((FromHeader) registerOK.getHeader(FromHeader.NAME));
  689. Address address = fromHeader.getAddress();
  690. ExpiresHeader expires = registerOK.getExpires();
  691. if (expires != null && expires.getExpires() == 0) {
  692. if (messageListener.sipMeetingManager.reRegisterFlag)
  693. // This is an OK for a cleared registration.
  694. messageListener.sipMeetingManager.register();
  695. else
  696. messageListener.sipMeetingManager.setRegisterStatus(
  697. RegisterStatus.NOT_REGISTERED);
  698. } else {
  699. messageListener.sipMeetingManager.setRegisterStatus(
  700. RegisterStatus.REGISTERED);
  701. }
  702. }
  704. /**
  705.  * Process the OK received response for a BYE
  706.  * @param clientTransaction - the client transaction associated with the response
  707.  * @param byeOK - the OK received response for a BYE
  708.  */
  709. public void processByeOK(
  710. ClientTransaction clientTransaction,
  711. Response byeOK) {
  712. CallManager callManager =
  713. messageListener.sipMeetingManager.getCallManager();
  714. //Find the Audio call
  715. Call call =
  716. callManager.findCall(clientTransaction.getDialog().getDialogId());
  717. if (call instanceof AudioCall) {
  718. AudioCall audioCall = (AudioCall) call;
  719. audioCall.setStatus(AudioCall.NOT_IN_A_CALL);
  720. messageListener.sipMeetingManager.notifyObserversNewCallStatus(
  721. audioCall);
  722. /*if(audioCall.getVoiceMessaging()){
  723. stopVoiceMessagingSchedule();
  724. }
  725. else{
  726. audioCall.getMediaManager().stopMediaSession();
  727. }*/
  728. System.out.println(
  729. "Audio Call removed : " + call.getDialog().getDialogId());
  730. //Remove the call
  731. callManager.removeAudioCall(audioCall);
  732. } else {
  733. IMCall imCall = (IMCall) call;
  734. //Remove the call
  735. System.out.println(
  736. "IM Call removed : " + call.getDialog().getDialogId());
  737. callManager.removeIMCall(imCall);
  738. }
  739. }
  741. /**
  742.  * Process the OK received response for a CANCEL
  743.  * @param clientTransaction - the client transaction associated with the response
  744.  * @param cancelOK - the OK received response for a CANCEL
  745.  */
  746. public void processCancelOK(
  747. ClientTransaction clientTransaction,
  748. Response cancelOK) {
  749. CallManager callManager =
  750. messageListener.sipMeetingManager.getCallManager();
  751. //Strip out the callee
  752. SipURI calleeURI =
  753. (SipURI) ((ToHeader) cancelOK.getHeader(ToHeader.NAME))
  754. .getAddress()
  755. .getURI();
  756. String callee =
  757. "sip:"
  758. + calleeURI.getUser()
  759. + "@"
  760. + calleeURI.getHost().trim().toLowerCase();
  761. //Find the Audio call
  762. AudioCall call = callManager.findAudioCall(callee);
  763. call.setStatus(AudioCall.NOT_IN_A_CALL);
  764. messageListener.sipMeetingManager.notifyObserversNewCallStatus(call);
  765. callManager.removeAudioCall(call);
  766. }
  768. /**
  769.  * Process the OK received response for a MESSAGE
  770.  * @param clientTransaction - the client transaction associated with the response
  771.  * @param cancelOK - the OK received response for a MESSAGE
  772.  */
  773. public void processMessageOK(
  774. ClientTransaction clientTransaction,
  775. Response messageOK) {
  777. }
  779. /**
  780.  * Process the OK received response for a SUBSCRIBE
  781.  * @param clientTransaction - the client transaction associated with the response
  782.  * @param cancelOK - the OK received response for a MESSAGE
  783.  */
  784. public void processSubscribeOK(
  785. ClientTransaction clientTransaction,
  786. Response subscribeOK) {
  787. messageListener.sipMeetingManager.presenceAllowed = true;
  788. Address address =
  789. ((FromHeader) subscribeOK.getHeader(FromHeader.NAME)).getAddress();
  790. String sender = null;
  791. if (address.getURI().isSipURI()) {
  792. SipURI sipURI = ((SipURI) address.getURI());
  793. String host = sipURI.getHost();
  794. String user = sipURI.getUser();
  795. sender = user + "@" + host;
  796. }
  797. /*Subscriber subscriber = new Subscriber(sender);
  798. subscriber.setDialog(clientTransaction.getDialog());
  799. messageListener.sipMeetingManager.getPresentityManager().
  800. sendNotifyToSubscriber(
  801. subscriber,
  802. "open",
  803. "online");*/
  804. }
  806. /**
  807.  * Process the OK received response for a SUBSCRIBE
  808.  * @param clientTransaction - the client transaction associated with the response
  809.  * @param cancelOK - the OK received response for a MESSAGE
  810.  */
  811. public void processSubscribeAccepted(
  812. ClientTransaction clientTransaction,
  813. Response subscribeAccepted) {
  814. messageListener.sipMeetingManager.presenceAllowed = true;
  815. /*Address address=((FromHeader)subscribeOK.getHeader(FromHeader.NAME)).getAddress();
  816. String sender=null;
  817. if(address.getURI().isSipURI()){
  818. SipURI sipURI=((SipURI)address.getURI());
  819. String host=sipURI.getHost();
  820. String user=sipURI.getUser();
  821. sender=user+"@"+host;
  822. }*/
  823. /*Subscriber subscriber = new Subscriber(sender);
  824. subscriber.setDialog(clientTransaction.getDialog());
  825. messageListener.sipMeetingManager.getPresentityManager().
  826. sendNotifyToSubscriber(
  827. subscriber,
  828. "open",
  829. "online");*/
  830. }
  832. /**
  833.  * Process the OK received response for a INVITE
  834.  * @param clientTransaction - the client transaction associated with the response
  835.  * @param inviteOK - the OK received response for a INVITE
  836.  */
  837. public void processInviteOK(
  838. ClientTransaction clientTransaction,
  839. Response inviteOK) {
  840. CallManager callManager =
  841. messageListener.sipMeetingManager.getCallManager();
  842. //Strip out the callee
  843. SipURI calleeURI =
  844. (SipURI) ((ToHeader) inviteOK.getHeader(ToHeader.NAME))
  845. .getAddress()
  846. .getURI();
  847. String callee =
  848. "sip:" + calleeURI.getUser() + "@" + calleeURI.getHost();
  849. //Find the Audio call
  850. AudioCall call = callManager.findAudioCall(callee);
  851. //Send ACK
  852. try {
  853. Request ack =
  854. (Request) clientTransaction.getDialog().createRequest(
  855. Request.ACK);
  856. //ack.setRequestURI(calleeURI);
  857. System.out.println("Sending ACK : n" + ack.toString());
  858. try {
  859. clientTransaction.getDialog().sendAck(ack);
  860. } catch (SipException ex) {
  861. System.out.println("Could not send out the ACK request! ");
  862. ex.printStackTrace();
  863. }
  864. //messageListener.sipProvider.sendRequest(ack);                        
  865. } catch (SipException ex) {
  866. ex.printStackTrace();
  867. }
  868. ContentTypeHeader contentTypeHeader =
  869. (ContentTypeHeader) inviteOK.getHeader(ContentTypeHeader.NAME);
  870. // no content type header means other end does not support sdp.
  871. if (contentTypeHeader != null) {
  872. String type = contentTypeHeader.getContentType();
  873. String subType = contentTypeHeader.getContentSubType();
  874. //System.out.println("the other end answer us with "+subType);         
  875. messageListener.sipMeetingManager.notifyObserversNewCallStatus(
  876. call);
  877. if (type.equals("application") && subType.equals("sdp")) {
  878. //Start the media session
  879. MediaManager mediaManager = call.getMediaManager();
  880. call.setVoiceMesaging(false);
  881. mediaManager.prepareMediaSession(
  882. new String(inviteOK.getRawContent()));
  883. mediaManager.startMediaSession(true);
  884. }
  885. } else {
  886. // else start the media messaging session.
  887. ListIterator it = inviteOK.getHeaders(AcceptHeader.NAME);
  888. while (it.hasNext()) {
  889. AcceptHeader next = (AcceptHeader) it.next();
  890. if (next.getContentType().equals("audio")
  891. && (next.getContentSubType().equals("gsm")
  892. || next.getContentSubType().equals("x-gsm"))) {
  893. call.setVoiceMesaging(true);
  894. //schedule to send the voice messages every 2 sec.
  895. startVoiceMessagingSchedule(callee);
  896. } else if (
  897. next.getContentType().equals("text")
  898. && next.getContentSubType().equals("plain")) {
  899. // TODO -- textMessaging.setTextMessaging(true);
  900. }
  901. }
  902. }
  903. call.setStatus(AudioCall.IN_A_CALL);
  904. messageListener.sipMeetingManager.notifyObserversNewCallStatus(call);
  905. }
  907. /**
  908.  * Process the Busy here response
  909.  * @param clientTransaction - the client transaction associated with the response
  910.  * @param busyhere - the Busy here response
  911.  */
  912. public void processBusyHere(
  913. ClientTransaction clientTransaction,
  914. Response busyHere) {
  915. CallManager callManager =
  916. messageListener.sipMeetingManager.getCallManager();
  917. //Strip out the callee
  918. SipURI calleeURI =
  919. (SipURI) ((ToHeader) busyHere.getHeader(ToHeader.NAME))
  920. .getAddress()
  921. .getURI();
  922. String callee =
  923. "sip:" + calleeURI.getUser() + "@" + calleeURI.getHost();
  924. Call call =
  925. callManager.findCall(clientTransaction.getDialog().getDialogId());
  926. if (call instanceof AudioCall) {
  927. //Strip out the Call info Header
  928. CallInfoHeader callInfoHeader=(CallInfoHeader)busyHere.getHeader(CallInfoHeader.NAME);
  929. URI uri=callInfoHeader.getInfo();
  930. ((AudioCall)call).setURL(uri);
  931. call.setStatus(AudioCall.BUSY);
  932. messageListener.sipMeetingManager.notifyObserversNewCallStatus(
  933. call);
  934. System.out.println(
  935. "Audio Call removed : " + call.getDialog().getDialogId());
  936. callManager.removeAudioCall((AudioCall) call);
  937. }
  938. }
  940. /**
  941.  * Process the temporary Unavailable response
  942.  * @param clientTransaction - the client transaction associated with the response
  943.  * @param temporaryUnavailable - the temporary Unavailable response
  944.  */
  945. public void processUnavailable(
  946. ClientTransaction clientTransaction,
  947. Response temporaryUnavailable) {
  948. CallManager callManager =
  949. messageListener.sipMeetingManager.getCallManager();
  950. //Find the call
  951. Call call =
  952. callManager.findCall(clientTransaction.getDialog().getDialogId());
  953. if (call instanceof AudioCall) {
  954. AudioCall audioCall = (AudioCall) call;
  955. audioCall.setStatus(Call.TEMPORARY_UNAVAILABLE);
  956. messageListener.sipMeetingManager.notifyObserversNewCallStatus(
  957. audioCall);
  958. System.out.println(
  959. "Audio Call removed : " + call.getDialog().getDialogId());
  960. callManager.removeAudioCall(audioCall);
  961. } else if (call instanceof IMCall) {
  962. IMCall imCall = (IMCall) call;
  963. imCall.setStatus(Call.TEMPORARY_UNAVAILABLE);
  964. messageListener.sipMeetingManager.notifyObserversNewCallStatus(
  965. imCall);
  966. System.out.println(
  967. "IM Call removed : " + call.getDialog().getDialogId());
  968. callManager.removeIMCall(imCall);
  969. }
  970. }
  973. /**
  974.  * Process the 407 - Proxy Authentication Required
  975.  * @param clientTransaction - the client transaction associated with the response
  976.  * @param proxyAuthenticationRequired - the temporary Unavailable response
  977.  */
  978. public void processProxyAuthenticationRequired(
  979. ClientTransaction clientTransaction,
  980. Response proxyAuthenticationRequired) {
  981. messageListener.sipMeetingManager.setRegisterStatus(
  982. RegisterStatus.PROXY_AUTHENTICATION_REQUIRED);
  983. }
  985. /**
  986.  * Process the 405 - Method Not Allowed
  987.  * @param clientTransaction - the client transaction associated with the response
  988.  * @param proxyAuthenticationRequired - the temporary Unavailable response
  989.  */
  990. public void processMethodNotAllowed(
  991. ClientTransaction clientTransaction,
  992. Response methodNotAllowed) {
  993. messageListener.sipMeetingManager.presenceAllowed = false;
  994. }
  996. /**********************************************************************/
  997. /*                                                                    */
  998. /*                    Handling timeout messages                       */
  999. /*                                                                    */
  1000. /**********************************************************************/
  1002. /**
  1003.  * Process the timed out MESSAGE
  1004.  * @param message - the timedout request 
  1005.  */
  1006. public void processTimedOutMessage(Request message) {
  1007. ToHeader toHeader = (ToHeader) (message.getHeader(ToHeader.NAME));
  1008. Address address = toHeader.getAddress();
  1009. if (address.getURI().isSipURI()) {
  1010. SipURI toURI = (SipURI) address.getURI();
  1011. messageListener.sipMeetingManager.notifyObserversIMReceived(
  1012. new String(message.getRawContent())
  1013. + " has not been delivered successfully",
  1014. toURI.getUser() + "@" + toURI.getHost());
  1015. }
  1016. SipURI toUri = ((SipURI)((ToHeader) message.getHeader(ToHeader.NAME)).getAddress().getURI());
  1017.                 String id = toUri.getUser() + "@" + toUri.getHost();
  1018.                 this.callManager.removeIMCall(id);
  1019.                 
  1020. }
  1022. /**
  1023.  * Process the timed out REGISTER
  1024.  * @param message - the timedout request 
  1025.  */
  1026. public void processTimedOutRegister(Request register) {
  1027. messageListener.sipMeetingManager.setRegisterStatus(
  1028. RegisterStatus.NOT_REGISTERED);
  1029. }
  1031. /**
  1032.  * Process the timed out REGISTER
  1033.  * @param message - the timedout request 
  1034.  */
  1035. public void processTimedOutInvite(Request invite) {
  1036. messageListener.sipMeetingManager.setRegisterStatus(
  1037. AudioCall.NOT_IN_A_CALL);
  1038. }
  1040. /**
  1041.  * Process the Timeout received request
  1042.  * @param transaction - the transaction associated with the request
  1043.  * @param timeout - the timeout request
  1044.  */
  1045. public void processTimeout(Transaction transaction, Request timeout) {
  1047. }
  1048. }