.#messageprocessor.java.1.18

It is Java for SIP phone

				  call.getDialog().getDialogId());
				callManager.removeIMCall(imCall);
			}
        }
        catch (SipException se) {                        
            se.printStackTrace();            
        }
        catch (ParseException pe) {                        
            pe.printStackTrace();            
        }        
    }

    /**
     * Process the ACK received request
     * @param serverTransaction - the server transaction associated with the request
     * @param ack - the ack request 
     */
    public void processAck(ServerTransaction serverTransaction, Request ack)
    {
		CallManager callManager=messageListener.sipMeetingManager.getCallManager();
		//Strip out the callee
		SipURI calleeURI=
			(SipURI)((FromHeader)ack.getHeader(FromHeader.NAME))
				.getAddress().getURI();
		String callee="sip:"+calleeURI.getUser()+"@"+calleeURI.getHost();
		//Find the Audio call
		AudioCall call=callManager.findAudioCall(callee);
		if(call!=null){
			if(!call.getVoiceMessaging())
				call.getMediaManager().startMediaSession(false);
			else
				startVoiceMessagingSchedule(callee);
			call.setStatus(AudioCall.IN_A_CALL);	        		
			messageListener.sipMeetingManager.notifyObserversNewCallStatus(call);			
		}    	
    }

    /**
     * Process the CANCEL received request
     * @param serverTransaction - the server transaction associated with the request
     * @param cancel - the cancel request 
     */
    public void processCancel(ServerTransaction serverTransaction,
                       Request cancel)
    {
		CallManager callManager=messageListener.sipMeetingManager.getCallManager();
		//Strip out the callee
		SipURI calleeURI=
			(SipURI)((FromHeader)cancel.getHeader(FromHeader.NAME))
				.getAddress().getURI();
		String callee="sip:"+calleeURI.getUser()+"@"+calleeURI.getHost().trim().toLowerCase();		
		//Find the Audio call
		AudioCall call=callManager.findAudioCall(callee);
        //Send OK
        try {        	        	
            Response ok = (Response) MessageListener.messageFactory.createResponse(
                    Response.OK,cancel);	
			serverTransaction.sendResponse(ok);
			call.setStatus(AudioCall.CANCEL);	        		
			messageListener.sipMeetingManager.notifyObserversNewCallStatus(call);
			System.out.println("Audio Call removed : "+
				call.getDialog().getDialogId());
			callManager.removeAudioCall(call);            
        }
        catch (SipException se) {                        
            se.printStackTrace();            
        }
        catch (ParseException pe) {                        
            pe.printStackTrace();            
        }
        
    }

	/**
	 * Process the MESSAGE received request
	 * @param serverTransaction - the server transaction associated with the request
	 * @param message - the request 
	 */
	public void processMessage(ServerTransaction serverTransaction, Request message)
	{
		
		//Send OK
		try {
			String sender=null;
			Address address=((FromHeader)message.getHeader(FromHeader.NAME)).getAddress();
			if(address.getURI().isSipURI()){
				SipURI sipURI=((SipURI)address.getURI());
				String host=sipURI.getHost();
				String user=sipURI.getUser();
				sender=user+"@"+host;
			}
			//Getting the sdp body for creating the response
		  	//This sdp body will present what codec has been chosen
		  	//and on which port every media will be received
		  	ContentTypeHeader contentTypeHeader=
				(ContentTypeHeader)message.getHeader(ContentTypeHeader.NAME);
			if (contentTypeHeader == null || contentTypeHeader.getContentType() == null || 
			  contentTypeHeader.getContentSubType() == null ) return;
		  	String subType=contentTypeHeader.getContentSubType();
		  	//If we have a voice messaging plays it
		  	if ( contentTypeHeader.getContentType().equals("audio") ) {
				if ( contentTypeHeader.getContentSubType().equals("x-gsm") ||
					contentTypeHeader.getContentSubType().equals("gsm") ){
					Response ok = (Response) MessageListener.messageFactory.createResponse(
						Response.OK,message);
					ToHeader toHeader=(ToHeader)message.getHeader(ToHeader.NAME);
					if (toHeader.getTag()==null)
						toHeader.setTag(new Integer((int)(Math.random() * 10000)).toString());
					serverTransaction.sendResponse(ok);		
					byte[] voiceMessage=message.getRawContent();					
					//if(!voicePlayer.isInitialized())
						voicePlayer.initialize(voiceMessage);
					/*else					
						voicePlayer.setData(voiceMessage);*/						
					voicePlayer.play();		
					message.removeContent();
		  		} else {
					System.out.println("Cannot handle this codec " + contentTypeHeader.getContentSubType());
				}
			} else if (contentTypeHeader.getContentType().equals("text") 	  
				&& contentTypeHeader.getContentSubType().equals("plain")) {
				Response ok = (Response) MessageListener.messageFactory.createResponse(
					Response.OK,message);
				ToHeader toHeader=(ToHeader)message.getHeader(ToHeader.NAME);
				if (toHeader.getTag()==null)
					toHeader.setTag(new Integer((int)(Math.random() * 10000)).toString());
				serverTransaction.sendResponse(ok);		
				String content = new String(message.getRawContent());
				FromHeader fromHeader = (FromHeader) message.getHeader(FromHeader.NAME);
				messageListener.sipMeetingManager.notifyObserversIMReceived(content,sender);
			} else {
				// send a Not Acceptable here message.
				Response notok = (Response) MessageListener.messageFactory.createResponse(
					Response.NOT_ACCEPTABLE,message);
				ToHeader toHeader=(ToHeader)message.getHeader(ToHeader.NAME);
				serverTransaction.sendResponse(notok);		
				System.out.println("Cannot handle this content Type " + contentTypeHeader);
			}
			message.removeContent();
		}
		catch (SipException se) {                        
			se.printStackTrace();            
		}
		catch (ParseException pe) {                        
			pe.printStackTrace();            
		}
	}
		
	/**
	 * Process the SUBSCRIBE received request
	 * @param serverTransaction - the server transaction associated with the request
	 * @param subscribe - the request 
	 */
	public void processSubscribe(ServerTransaction serverTransaction, Request subscribe)
	{
		Address address=((FromHeader)subscribe.getHeader(FromHeader.NAME)).getAddress();
		String sender=null;
		if(address.getURI().isSipURI()){
			SipURI sipURI=((SipURI)address.getURI());
			String host=sipURI.getHost();
			String user=sipURI.getUser();
			sender=user+"@"+host;
		}		
		Subscriber subscriber = new Subscriber(sender);
		subscriber.setDialog(serverTransaction.getDialog());
		messageListener.sipMeetingManager.notifySubscribe(subscriber);				
	}
	
	/**
	 * Process the NOTIFY received request
	 * @param serverTransaction - the server transaction associated with the request
	 * @param notify - the request 
	 */
	public void processNotify(ServerTransaction serverTransaction, Request notify)
	{
		//Send OK
		try {
			Response ok = (Response) MessageListener.messageFactory.createResponse(
					Response.OK,notify);
			ToHeader toHeader=(ToHeader)notify.getHeader(ToHeader.NAME);
			if (toHeader.getTag()==null)
				toHeader.setTag(new Integer((int)(Math.random() * 10000)).toString());
			serverTransaction.sendResponse(ok);
					
			Address address=((FromHeader)notify.getHeader(FromHeader.NAME)).getAddress();
			String sender=null;
			if(address.getURI().isSipURI()){
				SipURI sipURI=((SipURI)address.getURI());
				String host=sipURI.getHost();
				String user=sipURI.getUser();
				sender=user+"@"+host;
			}						
			ContentTypeHeader contentTypeHeader=(ContentTypeHeader)
									notify.getHeader(ContentTypeHeader.NAME);
			if(contentTypeHeader!=null){									
				String xmlType=contentTypeHeader.getContentSubType(); 
		
				if (xmlType.equals("xpidf+xml") ) {
					String pidfContent=new String(notify.getRawContent());
					int endDocIndex=pidfContent.indexOf("<presence>");
					pidfContent=pidfContent.substring(endDocIndex);
					XMLpidfParser pidfParser=new XMLpidfParser();
					pidfParser.parsePidfString(pidfContent);
					PresenceTag presenceTag=pidfParser.getPresenceTag();			
					presenceTag.setAddress(sender);
					messageListener.sipMeetingManager.notifyPresence(presenceTag);
				}	
			}
		}
		catch (SipException se) {                        
			se.printStackTrace();            
		}
		catch (ParseException pe) {                        
			pe.printStackTrace();            
		}
	}
	
	/**
	 * After a
	 * @param clientTransaction
	 * @param response
	 */
	public void processRequestTerminated(
					ClientTransaction clientTransaction,
				        Response response){
		
							
	}
		
    /**********************************************************************/
    /*                                                                    */
    /*                    Handling response messages                      */
    /*                                                                    */
    /**********************************************************************/
    
    
    /**
     * Process the Not found received response
     * @param clientTransaction - the client transaction associated with the response
     * @param notFound - the not found response
     */
    public void processNotFound(ClientTransaction clientTransaction, Response notFound)
    {
     
    }

    /**
     * Process the Not Implemented received response
     * @param clientTransaction - the client transaction associated with the response
     * @param notImplemented - the not found response
     */
    public void processNotImplemented(ClientTransaction clientTransaction,
                               Response notImplemented)
    {

    }
        
    /**
     * Process the Trying received response
     * @param clientTransaction - the client transaction associated with the response
     * @param trying - the trying response
     */
    public void processTrying(ClientTransaction clientTransaction, Response trying)
    {
		CallManager callManager=messageListener.sipMeetingManager.getCallManager();
		//Strip out the callee
		SipURI calleeURI=
			(SipURI)((ToHeader)trying.getHeader(ToHeader.NAME))
				.getAddress().getURI();
		String callee="sip:"+calleeURI.getUser()+"@"+calleeURI.getHost();		
		//Find the Audio call
		AudioCall call=callManager.findAudioCall(callee);
		if(call!=null){		
			call.setStatus(AudioCall.TRYING);	        		
			messageListener.sipMeetingManager.notifyObserversNewCallStatus(call);
		}            
    }
    
    /**
     * Process the Ringing received response
     * @param clientTransaction - the client transaction associated with the response
     * @param ringing - the ringing response
     */
    public void processRinging(ClientTransaction clientTransaction, Response ringing)
    {
		CallManager callManager=messageListener.sipMeetingManager.getCallManager();
		//Strip out the callee
		SipURI calleeURI=
			(SipURI)((ToHeader)ringing.getHeader(ToHeader.NAME))
				.getAddress().getURI();
		String callee="sip:"+calleeURI.getUser()+"@"+calleeURI.getHost();
		//Find the Audio call
		AudioCall call=callManager.findAudioCall(callee);
		call.setStatus(AudioCall.RINGING);	        		
		messageListener.sipMeetingManager.notifyObserversNewCallStatus(call);        
    }
    
    /**
     * Process the OK received response for a REGISTER 
     * @param clientTransaction - the client transaction associated with the response
     * @param registerOK - the OK received response for a REGISTER 
     */
    public void processRegisterOK(ClientTransaction clientTransaction, Response registerOK)
    {                 
        FromHeader fromHeader =
            ( (FromHeader) registerOK.getHeader(FromHeader.NAME));
        Address address = fromHeader.getAddress();
        ExpiresHeader expires = registerOK.getExpires();        
        if (expires != null && expires.getExpires() == 0) {
	  if ( messageListener.sipMeetingManager.reRegisterFlag) 
	    // This is an OK for a cleared registration.
	    messageListener.sipMeetingManager.register();
	  else
            messageListener.sipMeetingManager.setRegisterStatus(RegisterStatus.NOT_REGISTERED);        
        } else {