bspresencebean.java

一款即时通讯软件

        // gets list of presences for jid without resource
        BSPresencesOfJID jp = getJIDPresences(jid);
        // if no list
        if (jp == null) {
            return (new Vector()).elements();
        }
        else {
            return jp.getAllPresences();
        }
    }

    /**
     * Returns Enumeration of <code>BSPresenceInfo</code>s
     * for all my resources except this one.
     */
    public Enumeration getMyResourcesPresences() {
        if (myJID == null) {
            return (new Vector()).elements();
        }

        // gets list of presences for jid without resource
        BSPresencesOfJID jp = getJIDPresences(myJID);
        // if no list
        if (jp == null) {
            return (new Vector()).elements();
        }
        else {
            Enumeration enumeration = jp.getAllPresences();
            Vector v = new Vector();
            while (enumeration.hasMoreElements()) {
                BSPresenceInfo pi = (BSPresenceInfo) enumeration.nextElement();
                //if (!myJID.equals(pi.getJID()))
                    v.add(pi);
            }
            return v.elements();
        }
    }

    /**
     * Clears the current presences.
     * This function is typically called after disconnecting.
     */
    public void clear() {
        curPresences.clear();
        firePresencesCleared();
    }

    /**
     * Frees all object bindings to allow object destroy
     */
    protected void prepareToDestroy() {
        removeAllPresenceListeners();
        if (connection != null) {
            connection.delPacketListener(this);
            connection.delConnectionListener(this);
            connection = null;
        }
    }

    // *** HELPING METHODS ***

    /**
     * Returns string used as a key in roster hashtable.
     * @deprecated use <code>JID.hashCode()</code> instead
     */
    public static String getJIDHashString(JID jid, boolean useResource) {
        if (jid == null)
            return "";

        String username = jid.getUsername();
        String result;
        if (username != null)
            result = new String(username + "@" + jid.getServer());
        else
            result = new String(jid.getServer());
        if (useResource && jid.getResource() != null)
            result = result + "/" + jid.getResource();
        return result;
    }

    /**
     * Returns JID without resource.
     * @deprecated use <code>JID.getSimpleJID()</code> instead
     */
    public static JID getJidWithoutRes(JID jid) {
        return (jid == null)? null :
                              new JID(jid.getUsername(), jid.getServer(), null);
    }

    // *** LISTENER METHODS ***

    /**
     * Invoked when a packet arrives.
     */
    public void receivedPacket(PacketEvent pe) {
        if (!(pe.getPacket() instanceof Presence)) {
            return;
        }

        Presence p = (Presence) pe.getPacket();
        String type = p.getType();
        JID jid = p.getFromAddress();

        // if JID is null
        if (jid == null)
            return;

        if (type != null && type.equals("subscribe")) {
            fireSubscriptionRequested(jid);
            return;
        }

        if (type != null && type.equals("subscribed")) {
            fireSubscriptionApproved(jid);
            return;
        }

        if (type != null && type.equals("error")) {
            firePresenceError(p);
            return;
        }

        if (type != null && !type.equals("available") &&
            !type.equals("") && !type.equals("unavailable"))
            return;

        // gets list of presences of jid without resource
        //String str = this.getJIDHashString(jid, false);
        JID key = jid.getSimpleJID();
        BSPresencesOfJID jp = getJIDPresences(jid);

        // if unavailable
        if (type != null && type.equals("unavailable")) {
            if (jp == null) return;
            // changes the presence
            jp.changePresence(p);
            // if got totally unavailable
            if (!jp.isAvailable())
                //curPresences.remove(str);
                curPresences.remove(key);
        }

        // if no record yet and is not unavailable
        else if (jp == null && (type == null || !type.equals("unavailable"))) {
            jp = new BSPresencesOfJID(p);
            //curPresences.put(str, jp);
            curPresences.put(key, jp);
        }

        // if there is already a record
        else {
            // changes the presence
            jp.changePresence(p);
            // if got totally unavailable
            if (!jp.isAvailable()) {
                //curPresences.remove(str);
                curPresences.remove(key);
            }
        }

        firePresenceChanged(new BSPresenceInfo(p));
    }

    /**
     * Invoked when a packet send failes.
     */
    public void sendFailed(PacketEvent pe) {
    }

    /**
     * Invoked when a packet is sent.
     */
    public void sentPacket(PacketEvent pe) {
    }

    /**
     * Invoked when connection changes.
     * If disconnected, clears the presences and fires their change.
     */
    public void connectionChanged(ConnectionEvent ce) {
        ConnectionEvent.EState connState = ce.getState();
        if (connState != ConnectionEvent.STATE_CONNECTED) {
            myJID = null;
            connected = false;
            curPresences.clear();
            firePresencesCleared();
        }
        else
            connected = true;
    }

    // *** presence listeners ***

    /**
     * Adds <code>BSPresenceListener</code> to listeners notified when
     * presence state of some of buddies changes.
     *
     * @see #removePresenceListener
     * @see #removeAllPresenceListeners
     * @see #firePresenceChanged
     * @see #fireSubscriptionRequested
     * @see #fireSubscriptionApproved
     */
    public void addPresenceListener(BSPresenceListener listener) {
        //assert listener != null : listener;
        if (listener == null) return;
        if (!presenceListeners.contains(listener)) {
            presenceListeners.addElement(listener);
        }
    }

    /**
     * Removes <code>BSPresenceListener</code> to listeners notified when
     * presence state of some of buddies changes.
     *
     * @see #addPresenceListener
     * @see #removeAllPresenceListeners
     * @see #firePresenceChanged
     * @see #fireSubscriptionRequested
     * @see #fireSubscriptionApproved
     */
    public void removePresenceListener(BSPresenceListener listener) {
        //assert listener != null : listener;
        if (listener == null) return;
        presenceListeners.removeElement(listener);
    }

    /**
     * Removes all listeners notified when presence state of some of buddies changes.
     * This can be used before to free dependencies and allow dispose of
     * all objects.
     *
     * @see #addPresenceListener
     * @see #removePresenceListener
     * @see #firePresenceChanged
     * @see #fireSubscriptionRequested
     * @see #fireSubscriptionApproved
     */
    public void removeAllPresenceListeners() {
        presenceListeners.clear();
    }

    /**
     * Notifies presence listeners about presence state of some of buddies change.
     *
     * @see #addPresenceListener
     * @see #removePresenceListener
     * @see #removeAllPresenceListeners
     * @see #fireSubscriptionRequested
     * @see #fireSubscriptionApproved
     */
    private void firePresenceChanged(BSPresenceInfo pi) {
        for (Enumeration e = presenceListeners.elements(); e.hasMoreElements(); ) {
            BSPresenceListener listener = (BSPresenceListener) e.nextElement();
            listener.presenceChanged(pi);
        }
    }

    /**
     * Notifies presence listeners about presence subscription request.
     *
     * @see #addPresenceListener
     * @see #removePresenceListener
     * @see #removeAllPresenceListeners
     * @see #firePresenceChanged
     * @see #fireSubscriptionApproved
     */
    private void fireSubscriptionRequested(JID jid) {
        for (Enumeration e = presenceListeners.elements(); e.hasMoreElements(); ) {
            BSPresenceListener listener = (BSPresenceListener) e.nextElement();
            listener.subscriptionRequested(jid);
        }
    }

    /**
     * Notifies presence listeners about presence subscription confirmation.
     *
     * @see #addPresenceListener
     * @see #removePresenceListener
     * @see #removeAllPresenceListeners
     * @see #firePresenceChanged
     * @see #fireSubscriptionRequested
     */
    private void fireSubscriptionApproved(JID jid) {
        for (Enumeration e = presenceListeners.elements(); e.hasMoreElements(); ) {
            BSPresenceListener listener = (BSPresenceListener) e.nextElement();
            listener.subscriptionApproved(jid);
        }
    }

    /**
     * Notifies presence listeners about clearing of all presences.
     *
     * @see #addPresenceListener
     * @see #removePresenceListener
     * @see #removeAllPresenceListeners
     * @see #firePresenceChanged
     * @see #fireSubscriptionRequested
     */
    private void firePresencesCleared() {
        for (Enumeration e = presenceListeners.elements(); e.hasMoreElements(); ) {
            BSPresenceListener listener = (BSPresenceListener) e.nextElement();
            listener.presencesCleared();
        }
    }

    /**
     * Notifies presence listeners about presence error.
     *
     * @see #addPresenceListener
     * @see #removePresenceListener
     * @see #removeAllPresenceListeners
     * @see #firePresenceChanged
     * @see #fireSubscriptionRequested
     */
    private void firePresenceError(Presence p) {
        for (Enumeration e = presenceListeners.elements(); e.hasMoreElements(); ) {
            BSPresenceListener listener = (BSPresenceListener) e.nextElement();
            //listener.presenceError(p);
        }
    }

}