presentitymanager.java

基于JAINSIP的一个proxy源码

	    if (content instanceof String) {
		newBody = (String)content;
	    } else  if (content instanceof byte[] ) {
		newBody = new String((byte[])content);
	    }


	    //get oldBody from notifier
	    String oldBody = notifier.getFullState();

	    if (oldBody.length()>0) {
		//Merge the old and new body.

		//parse old body
		xmlCpimParser.parseCPIMString(oldBody.trim());
		PresenceTag oldPresenceTag=xmlCpimParser.getPresenceTag();
		Vector oldTupleTagList=oldPresenceTag.getTupleTagList();

		//parse new body, generate a list of all id's
		xmlCpimParser.parseCPIMString(newBody.trim());
		PresenceTag newPresenceTag=xmlCpimParser.getPresenceTag();
		if (newPresenceTag==null) {
		    System.out.println
		    ("ERROR: The incoming presence Tag is null!!!");
		    return Response.BAD_REQUEST;
		}
		Vector newTupleTagList=newPresenceTag.getTupleTagList();  

		//Iterate through the old list and update old Tuples
		for(int i=0; i<oldTupleTagList.size(); i++) {
		    TupleTag oldTupleTag = (TupleTag)oldTupleTagList.get(i);
		    String tupleId = oldTupleTag.getId(); 
		    for(int j=0; j<newTupleTagList.size(); j++) {
			TupleTag newTag = (TupleTag)newTupleTagList.get(j);
			if (newTag.getId().equals(tupleId)) {
			    //replace the old tuple with the new
			    oldTupleTagList.setElementAt
			     ((Object)newTupleTagList.remove(j), i);
			    break;
			}
		    }
		}

		//add new tuples
		while(!newTupleTagList.isEmpty()) {
		    TupleTag newTT = (TupleTag)newTupleTagList.remove(0);
		    oldPresenceTag.addTupleTag(newTT);
		}

		newBody = oldPresenceTag.toString();
	    }

	    
	    //Update the notifier
	    notifier.setFullState(newBody);

	    //Update subscribers. Should be partial update someday
	    Collection notifiersSubscriberKeys = notifier.getSubscribers();
	    Iterator it = notifiersSubscriberKeys.iterator();
	    while (it.hasNext()) {
		String dialogId = (String)it.next();
	        if (ProxyDebug.debug)
		    ProxyDebug.println("getting subscriber for " + dialogId );
		Subscriber subscriber = (Subscriber)subscribers.get(dialogId);
		subscriber.updateNotifyBody(newBody);
	    }
	    
	    
	}

	return responseCode;
    }



    /** Processes incoming notify requests from virtual subscribers. 
     *
     */
    public synchronized int processNotify(Request request, Dialog dialog) {
	
	int responseCode;

	//Check event. If not recognized, return 489 BAD_EVENT	
	
	String dialogId = dialog.getDialogId();
	VirtualSubscription virtualSubscription = (VirtualSubscription)virtualSubscriptions.get(dialogId);
	if(virtualSubscription == null)
	    return Response.CALL_OR_TRANSACTION_DOES_NOT_EXIST;
	
	SubscriptionStateHeader subscriptionStateHeader = 
	    (SubscriptionStateHeader)request.getHeader(SubscriptionStateHeader.NAME);
	String subscriptionState = subscriptionStateHeader.getState();

	
	//check if event is understood, else send 489 (Bad Event)
	EventHeader eventHeader = (EventHeader)request.getHeader(EventHeader.NAME);
	if ((eventHeader==null) || !(eventHeader.getEventType().equalsIgnoreCase("presence")))
	    return Response.BAD_EVENT;
	
	
	//update subscriptionState
	String oldState = virtualSubscription.getSubscriptionState();
	virtualSubscription.setSubscriptionState(subscriptionState);
	
	
	//if Subscription-State has expires-parameter, update expirestime
	if (subscriptionStateHeader.getParameter("expires") != null) {
	    int expires = subscriptionStateHeader.getExpires();
	    virtualSubscription.setExpiresTime(expires);
	}
	
	//if body exist, update body
	Object content = request.getContent();
	String    text = null;
	if (content instanceof String) {
	    text = (String)content;
	} else  if (content instanceof byte[] ) {
	    text = new String((byte[])content);
	}
       
	responseCode = virtualSubscription.processNotify(text);
	
	
	//if subscription-state was "terminated", check for retry-parameter and behave accordingly
	
	if (responseCode == Response.OK) {
	    //update vs's subscribers body (a single virtual subscription state cannot effect a whole subscriber)
	    Collection subSubscribers = virtualSubscription.getSubscribers();
	    Iterator it = subSubscribers.iterator();
	    while (it.hasNext()) {
		Subscriber s = (Subscriber)it.next();
		s.updateNotifyBody(text);
	    }
	    
	}
	 
	return responseCode;



    }



    //*****************************
    //   Other Methods
    //*****************************
    

 
    /**
     * @param notifierURI cleaned SipURI as found in a SUBSCRIBE To-header 
     */
    public boolean hasNotifier(String notifierURI) {
	return notifiers.containsKey(notifierURI);
    }
    

    /**
     * @param notifierURI cleaned SipURI as found in a SUBSCRIBE To-header 
     * @param subscriberURI cleaned SipURI as found in a SUBSCRIBE To-header 
     */
    protected synchronized boolean hasSubscriber(String notifierURI, String subscriberURI) {
	Notifier notifier=(Notifier)notifiers.get(notifierURI);
	return notifier.hasSubscriber(subscriberURI);
    }






    //*****************************
    //   UTILITY METHODS
    //*****************************
    

    /** Subscribers come in many flavours. This method determines which Subscriber subclass
     *  should be created and creates it.
     *  @return A type-casted Subscriber object or null if the headers in the subscription were
     *          ambigous or insufficient.
     */
    private Subscriber createSubscriber(Request request, String subscriberKey, Dialog dialog, int expires) {

	
	//Examine event header, this determines the type of subscriber
	EventHeader eventHeader = (EventHeader)request.getHeader(EventHeader.NAME);
	String event;
	if (eventHeader == null) {
	    return null;
	} else {
	    event = eventHeader.getEventType();
	}



	if(event.equalsIgnoreCase("presence")) {

	    boolean partialNotification = false;
	    ListIterator acceptHeadersIterator = (ListIterator)request.getHeaders(AcceptHeader.NAME);

	    while (acceptHeadersIterator.hasNext()) {
		String subtype = ((AcceptHeader)acceptHeadersIterator.next()).getContentSubType();
		
		if (subtype.equalsIgnoreCase("pidf-partial+xml")) {
		    partialNotification = true;
		    break;
		}
	    }
	    
	    return new SubscriberPresence(subscriberKey, dialog, expires, partialNotification);

	} else if (event.equalsIgnoreCase("watcher.presence")) {
	    //get notifier
	    //get winfo file
	    //SubscriberWinfo subscriberWinfo = new SubscriberWinfo(subscriberKey, dialog, expires, winfoFile);
	    return new Subscriber(subscriberKey, dialog, expires);
	}

	
	return null;

    }


    private boolean isResourceListSubscriber(Request request) {
	EventHeader eventHeader = (EventHeader)request.getHeader(EventHeader.NAME);
	String event;
	if ((eventHeader == null) || !(eventHeader.getEventType().equalsIgnoreCase("presence"))) {
	    return false;
	} else {
	    ListIterator supportedHeadersIterator = (ListIterator)request.getHeaders(SupportedHeader.NAME);
	    while (supportedHeadersIterator.hasNext()) {
		String header = ((SupportedHeader)supportedHeadersIterator.next()).toString();
		if (header.indexOf("resourceList")>0) {
		    return true;
		}
	    }
	}
	return false;
    }


    
    /**
     * Returns the value of a named header
     */
    protected  String getKey(Message message,String header) {
        try{
            Address address=null;
            if (header.equals("From") ) {
                FromHeader fromHeader=(FromHeader)
		message.getHeader(FromHeader.NAME);
                address=fromHeader.getAddress();
                
            }
            else
                if (header.equals("To") ) {
                    ToHeader toHeader=(ToHeader)message.getHeader(ToHeader.NAME);
                    address=toHeader.getAddress();
 
                }
                
            javax.sip.address.URI cleanedUri=null;
            if (address==null) {
                cleanedUri= getCleanUri( ((Request)message).getRequestURI());
            }
            else {
                // We have to build the key, all
                // URI parameters MUST be removed:
                cleanedUri = getCleanUri(address.getURI());
            }
            
            if (cleanedUri==null) return null;
            
            String  keyresult=cleanedUri.toString();
            ProxyDebug.println("DEBUG, PresenceServer, getKey(), the key is: " + 
            keyresult);
            return keyresult.toLowerCase();
            
        }
        catch(Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * Helper for getKey. Removes parameters from URI
     */
    protected static URI getCleanUri(URI uri) {
        if (uri instanceof SipURI) {
            SipURI sipURI=(SipURI)uri.clone();
            
            Iterator iterator=sipURI.getParameterNames();
            while (iterator!=null && iterator.hasNext()) {
                String name=(String)iterator.next();
                sipURI.removeParameter(name);
            }
            return  sipURI;
        }
        else return  uri;
    }






    public void run() {
        while (this.isRunning) {
	    try {
		Thread.sleep(1000); //millisecs 
	    } catch (InterruptedException ex) {

	    }
            if (!this.isRunning) return;
	    
	    int expires = 0;
	    synchronized (subscribers) {
			
		Iterator sit = subscribers.values().iterator();
		while(sit.hasNext()) {
		    Subscriber s = (Subscriber)sit.next();

		    if (s.hasExpired()) {
			s.setSubscriptionState("terminated");
			//add reason=timeout parameter
			presenceServer.sendNotifyRequest(s);
			continue;
		    } 

		    if (s.isTerminated()) {
			sit.remove();
			continue;
		    }

		    if (s.sendNotify()) { 
			presenceServer.sendNotifyRequest(s);
			ProxyDebug.println("Thread::Sending notify");
		    }
			    
		    //collect max expiresTime for possible server resubscription
		    int thisExpires = s.getExpiresTime();
		    if (thisExpires > expires) { 
			expires = thisExpires;
		    }
		}
	    }//end subscribers

	    synchronized (notifiers) {
		Iterator nit = notifiers.values().iterator();
		while (nit.hasNext()) {
		    Notifier n = (Notifier)nit.next();
		    if (n.hasExpired()) {
			System.out.println("removing NOTIIFER");
			nit.remove();
		    }
		}
	    } //end notifiers

	    synchronized (virtualSubscriptions) {
		Iterator vit = virtualSubscriptions.values().iterator();
		while (vit.hasNext()) {
		    VirtualSubscription vs = (VirtualSubscription)vit.next();
		    if (vs.hasNoSubscribers()) {
			vit.remove();
		    }
		    if (vs.needToResubscribe()) {
			presenceServer.sendSubscribeRequest(vs.getURI(), 
							    vs.getRequiredExpiresTime(), 
							    vs.getDialog());
		    }
		}
	    } //end virtualSubscriptions


	}
    }



}