bspresencebean.java

一款即时通讯软件

package edu.ou.kmi.buddyspace.core;

/*
 * BSPresenceBean.java
 *
 * Project: BuddySpace
 * (C) Copyright Knowledge Media Institute 2002
 *
 *
 * Created on 18 July 2002, 12:03
 */

import java.util.*;
import org.jabber.jabberbeans.*;
import org.jabber.jabberbeans.util.*;
//import org.jabber.jabberbeans.Extension.*;

/**
 * <code>BSPresenceBean</code> provides presence handling.
 * It relies on <code>BSConnectionBean</code>, which must be set after each
 * reconnection.
 *
 * @author  Jiri Komzak, Knowledge Media Institute, Open University, United Kingdom
 */
public class BSPresenceBean implements PacketListener, ConnectionListener {
    protected Hashtable curPresences;
    protected ConnectionBean connection = null;
    protected final String name = "Presence";
    protected Vector presenceListeners;
    protected JID myJID = null;
    protected boolean connected = false;
    protected BSIndividualPresences individualPresences = null;

    /**
     * Constructor
     */
    BSPresenceBean() {
        curPresences = new Hashtable();
        individualPresences = new BSIndividualPresences(this);
        presenceListeners = new Vector();
    }

    /**
     * Constructor, which sets existing and connected <code>ConnectionBean</code>.
     * Then this is registered as listener for packet events.
     */
    BSPresenceBean(ConnectionBean connection) {
        this();
        setConnection(connection);
    }

    /**
     * Sets existing and connected <code>ConnectionBean</code>.
     * Then this is registered as listener for packet and connection events.
     */
    protected void setConnection(ConnectionBean connection) {
        if (this.connection != null) {
            this.connection.delPacketListener(this);
            this.connection.delConnectionListener(this);
        }
        this.connection = connection;
        if (connection != null) {
            connection.addPacketListener(this);
            connection.addConnectionListener(this);
        }
        curPresences.clear();
        individualPresences.clearAll();
    }

    /**
     * Returns currently used <code>ConnectionBean</code>.
     */
    protected ConnectionBean getConnection() {
        return connection;
    }

    /**
     * Returns if connected.
     */
    public boolean isConnected() {
        return connected;
    }

    /**
     * Returns <code>Enumeration</code> of current presences.
     * Items are of <code>BSPresenceInfo</code> type. If the JID is not
     * contained in this, it is not available.
     */
    public Enumeration entries() {
        return curPresences.elements();
    }

    /**
     * Stores given presence info.
     * This method should be used for access to presence storage.
     */
    protected void storePresence(BSPresenceInfo pi) {

        JID jid;
        if (pi == null || (jid = pi.getJID()) == null)
            return;

        //String str = getJIDHashString(jid, false);
        JID key = jid.getSimpleJID();
        BSPresencesOfJID jp = getJIDPresences(jid);

        // if no record yet and is available
        if (jp == null && pi.isOnline()) {
            jp = new BSPresencesOfJID(pi);
            //curPresences.put(str, jp);
            curPresences.put(key, jp);
        }
        // if there is already a record
        else {
            // changes the presence
            jp.changePresence(pi);
            // if got totally unavailable
            if (!jp.isAvailable())
                //curPresences.remove(str);
                curPresences.remove(key);
        }
    }

    /**
     * Sets current JID.
     */
    public void setMyJID(JID jid) {
        myJID = jid;
    }

    /**
     * Sets current presence and sends it to server.
     */
    public void setMyPresence(boolean available, String show,
                              String status, int priority) {

        //if (myJID == null) return;
        BSPresenceInfo pi = new BSPresenceInfo(myJID, available, show, status);
        pi.setPriority(priority);
        pi.setIsMyself(true);
        storePresence(pi);
        firePresenceChanged(pi);
        individualPresences.refreshPresences();
        sendPresence(pi, null);
    }


    /**
     * Returns current presence of this resource.
     */
    public BSPresenceInfo getMyPresence() {
        if (myJID == null) return null;
        return getResourcePresence(myJID);
    }


    /**
     * Sets <code>jid</code>'s current presence inside this bean.
     * This doesn't send anything to server, just sets internal value
     * (for internal hacks like conferencing,...)
     */
    public void setPresence(JID jid, boolean available, String show,
                            String status, int priority) {

        BSPresenceInfo pi = new BSPresenceInfo(jid, available, show, status);
        pi.setPriority(priority);

        storePresence(pi);

        firePresenceChanged(pi);
    }

    /**
     * Sends given presence to given JID
     */
    public void sendPresence(BSPresenceInfo pi, JID toAddress) {
        if (connection == null || pi == null) return;

        try {
            Presence p = pi.getPresencePacket(toAddress);
            connection.send(p);
        } catch (InstantiationException e) {
            BSCore.logEvent(name, "presence builder failed\n");
        }

        if (toAddress == null)
            sendIndividualPresences(individualPresences.getItems());
    }

    /**
     * Sends subscription request to given JID.
     */
    public void sendSubscriptionRequest(JID jid) {
        if (connection == null || jid == null) return;

        PresenceBuilder presenceBuilder = new PresenceBuilder();
        presenceBuilder.setToAddress(jid);
        presenceBuilder.setType("subscribe");

        try {
            connection.send(presenceBuilder.build());
        } catch (InstantiationException e) {
            BSCore.logEvent(name, "presence builder failed\n");
        }
    }

    /**
     * Sends subscription confirmation to given JID.
     */
    public void sendSubscriptionApproved(JID jid) {
        if (connection == null || jid == null) return;

        PresenceBuilder presenceBuilder = new PresenceBuilder();
        presenceBuilder.setToAddress(jid);
        presenceBuilder.setType("subscribed");

        try {
            connection.send(presenceBuilder.build());
        } catch (InstantiationException e) {
            BSCore.logEvent(name, "presence builder failed\n");
        }
    }


    /** Sends individual presences according to the Enumeration */
    public void sendIndividualPresences(Enumeration individualPresences) {
        while (individualPresences != null && individualPresences.hasMoreElements()) {
            BSIndividualPresences.BSIndividualPresenceItem ipi =
               (BSIndividualPresences.BSIndividualPresenceItem) individualPresences.nextElement();
            if (ipi.presence == null || ipi.jid == null) continue;
            try {
                Presence p = ipi.presence.getPresencePacket(ipi.jid);
                connection.send(p);
            } catch (InstantiationException e) {
                BSCore.logEvent(name, "presence builder failed\n");
            }
        }
    }


    /** Returns the used individual presences */
    public BSIndividualPresences getIndividualPresences() {
        return individualPresences;
    }


    /**
     * Returns <code>BSPresencesOfJID</code> for given JID.
     */
    protected BSPresencesOfJID getJIDPresences(JID jid) {
        // gets list of presences for jid without resource
        //String str = getJIDHashString(jid, false);
        //return (BSPresencesOfJID) curPresences.get(str);
        if (jid == null) return null;
        return (BSPresencesOfJID) curPresences.get(jid.getSimpleJID());
    }

    /**
     * Returns <code>BSPresenceInfo</code> for specified JID without resource.
     * The "best" presence of all resources is returned.
     */
    public BSPresenceInfo getPresence(JID jid) {
        if (jid == null)
            return null;

        // gets list of presences for jid without resource
        BSPresencesOfJID jp = getJIDPresences(jid);
        BSPresenceInfo pi;

        // no list for jid
        if (jp == null) {
            pi = null;
        }
        // else some list, gets the best presence
        else {
            pi = jp.getBestPresence();
        }

        // if that's my JID and my resource
        //JID jidWORes = getJidWithoutRes(jid);
        //JID myJIDWORes = getJidWithoutRes(myJID);
        JID jidWORes = jid.getSimpleJID();
        //if (myJIDWORes != null && myJIDWORes.equals(jidWORes)) {
        if (myJID != null && jidWORes != null && jidWORes.equals(myJID.getSimpleJID())) {
            if (pi == null)
                pi = new BSPresenceInfo(myJID, false, null, null);
            else
                pi = new BSPresenceInfo(pi.getJID(), pi.isOnline(),
                                        pi.getShow(), pi.getStatus());
            pi.setIsMyself(true);
        }

        return pi;
    }

    /**
     * Returns <code>BSPresenceInfo</code> for specified JID with resource.
     * If resource is empty returns the best presence for JID withour resource.
     */
    public BSPresenceInfo getResourcePresence(JID jid) {
        if (jid == null)
            return null;

        // gets list of presences for jid without resource
        BSPresencesOfJID jp = getJIDPresences(jid);
        BSPresenceInfo pi;
        // if no list
        if (jp == null) {
            pi = null;
        }
        else {
            pi = jp.getJIDPresence(jid);
        }
        return pi;
    }

    /**
     * Returns Enumeration of <code>BSPresenceInfo</code>s
     * for all resources of specified JID.
     */
    public Enumeration getAllPresences(JID jid) {
        if (jid == null) {
            return (new Vector()).elements();
        }