bsrosterbean.java

一款即时通讯软件

        
        try {
            rosterBean.addRosterItem(rib.build());
            return true;
        } catch (InstantiationException e) {
            return false;
        }
    }
    
    /**
     * Returns true if there is a contact in roster with given JID.
     */
    public boolean isJIDInRoster(JID jid) {
        String str = getRosterItemHashString(jid, "", false);
        RosterItem old = (RosterItem) curRoster.get(str);
        return old != null;
    }
    
    /**
     * Returns true if there is subscription to presence of given JID.
     */
    public boolean isSubscriptionToJID(JID jid) {
        String str = getRosterItemHashString(jid, "", false);
        RosterItem old = (RosterItem) curRoster.get(str);
        if (old == null) return false;
        String subscr = old.getSubscriptionType();
        return (subscr != null && (subscr.equals("to") || subscr.equals("both")));
    }
    
    /**
     * Returns <code>Iterator</code> over all groups in roster.
     */
    public Iterator getGroups() {
        Enumeration contacts = curRoster.elements();
        //Hashtable groups = new Hashtable();
        TreeSet groups = new TreeSet();
        while (contacts.hasMoreElements()) {
            RosterItem ri = (RosterItem) contacts.nextElement();
            Enumeration itemGroups = ri.enumerateGroups();
            // for all groups of roster element
            while (itemGroups != null && itemGroups.hasMoreElements()) {
                String gr = (String) itemGroups.nextElement();
                groups.add(gr);
            }
        }
        return groups.iterator();
    }
    
    /**
     * Returns <code>Enumeration</code> over all JIDs in given group.
     */
    public Enumeration getJIDsInGroup(String groupName) {
        Vector groupJids = new Vector();
        
        Enumeration contacts = curRoster.elements();
        while (contacts.hasMoreElements()) {
            RosterItem ri = (RosterItem) contacts.nextElement();
            Enumeration itemGroups = ri.enumerateGroups();
            
            // for all groups of roster element
            while (itemGroups != null && itemGroups.hasMoreElements()) {
                String gr = (String) itemGroups.nextElement();
                
                if (((groupName == null || groupName.equals("")) && gr == null)
                    || (groupName != null && groupName.equals(gr))) {
                    JID j = ri.getJID();
                    
                    if (!groupJids.contains(j))
                        groupJids.add(j);
                }
            }
        }
        
        return groupJids.elements();
    }

    // *** help functions ***
    
    /**
     * Returns string used as a key in roster hashtable.
     */
    public String getRosterItemHashString(JID jid, String group, boolean useGroup) {
        if (jid == null)
            return (group != null)? group : "";
        
        /*String res = new String((useGroup? group + "/" : "")
                                + jid.getUsername() + "@" + jid.getServer());*/
        String res = new String((useGroup? group + "/" : "")
                                + jid.getSimpleJID().normalize());
        return res;
    }

    // *** roster events ***
    
    /**
     * The changedRoster event is fired when there has been a change to the
     * roster state.
     */
    public void changedRoster(Roster roster) {
        BSCore.logEvent(name, "changed roster");
        Enumeration items = roster.items();
        // for all items
        while (items != null && items.hasMoreElements()) {
            RosterItem i = (RosterItem) items.nextElement();
            // if removed
            if ("remove".equals(i.getSubscriptionType())) {
                // removes the item from roster
                curRoster.remove(getRosterItemHashString(i.getJID(), "", false));
            }
            // else added or changed
            else {
                RosterItem old = (RosterItem) curRoster.put(getRosterItemHashString(i.getJID(), "", false), i);
            }
        }
        
        fireChangedRoster(roster);
    }
    

    /**
     * The replacedRoster event is fired when a completely new roster has
     * replaced the existing one.
     */
    public void replacedRoster(Roster roster) {
        BSCore.logEvent(name, "replaced roster");
        curRoster.clear();
        Enumeration items = roster.items();
        // for all items
        while (items != null && items.hasMoreElements()) {
            RosterItem i = (RosterItem) items.nextElement();
            //curRoster.put(i.getJID(), i);
            curRoster.put(getRosterItemHashString(i.getJID(), "", false), i);
        }
        fireReplacedRoster(roster);
        //showRoster();
    }
    
    /**
     * Returns friendly name of the <code>JID</code> according to appropriate
     * <code>RosterItem</code>.
     */
    public String getFriendlyName(JID jid) {
        if (jid == null) return null;
        
        String str = getRosterItemHashString(jid, "", false);
        RosterItem item = (RosterItem) curRoster.get(str);
        
        if (item == null) return null;
        
        return item.getFriendlyName();
    }
    
    // *** roster listeners ***
    
    /**
     * Adds <code>RosterListener</code> from listeners notified when
     * roster changes.
     *
     * @see #removeRosterListener
     * @see #removeAllRosterListeners
     * @see #fireChangedRoster
     * @see #fireReplacedRoster
     */
    public void addRosterListener(RosterListener listener) {
        //assert listener != null : listener;
        if (listener == null) return;
        if (!rosterListeners.contains(listener)) {
            rosterListeners.addElement(listener);
        }
    }

    /**
     * Removes <code>RosterListener</code> from listeners notified when
     * roster changes.
     *
     * @see #addRosterListener
     * @see #removeAllRosterListeners
     * @see #fireChangedRoster
     * @see #fireReplacedRoster
     */
    public void removeRosterListener(RosterListener listener) {
        //assert listener != null : listener;
        if (listener == null) return;
        rosterListeners.removeElement(listener);
    }

    /**
     * Removes all listeners notified when roster changes.
     * This can be used before to free dependencies and allow dispose of
     * all objects.
     *
     * @see #addRosterListener
     * @see #removeRosterListener
     * @see #fireChangedRoster
     * @see #fireReplacedRoster
     */
    public void removeAllRosterListeners() {
        rosterListeners.clear();
    }

    /**
     * Notifies roster listeners about roster change.
     *
     * @see #addRosterListener
     * @see #removeRosterListener
     * @see #removeAllRosterListeners
     * @see #fireReplacedRoster
     */
    private void fireChangedRoster(Roster roster) {
        for (Enumeration e = rosterListeners.elements(); e.hasMoreElements(); ) {
            RosterListener listener = (RosterListener) e.nextElement();
            listener.changedRoster(roster);
        }
    }
    
    /**
     * Notifies roster listeners about roster replace.
     *
     * @see #addRosterListener
     * @see #removeRosterListener
     * @see #removeAllRosterListeners
     * @see #fireChangedRoster
     */
    private void fireReplacedRoster(Roster roster) {
        for (Enumeration e = rosterListeners.elements(); e.hasMoreElements(); ) {
            RosterListener listener = (RosterListener) e.nextElement();
            listener.replacedRoster(roster);
        }
    }
    
    /**
     * Invoked when connection changes. 
     * If disconnected, clears the roster and fires its change.
     */
    public void connectionChanged(ConnectionEvent ce) {
        ConnectionEvent.EState connState = ce.getState();
        if (connState != ConnectionEvent.STATE_CONNECTED) {
            curRoster.clear();
            RosterBuilder rb = new RosterBuilder();
            try {
                Roster r = new Roster(rb);
                fireReplacedRoster(new Roster(rb));
            } catch (java.lang.InstantiationException e) {
                return;
            }
        }
    }
    
}