bsgroupchatbean.java

一款即时通讯软件

            Extension e = (Extension) exts.nextElement();
            // if browse extension
            if (e instanceof IQBrowse) {
                IQBrowse b = (IQBrowse) e;
                String category = b.getCategory();
                // if item is user category
                if (category.equals("user"))
                    handleIQBrowseUser(b, ri);
                // else if item is conference category
                else if (category.equals("conference")) {
                    String extName = b.getName();
                    String type = b.getType();
                    fireRoomMessage(ri.roomJID, "room \"" + extName + "\" is of type \"" + type + "\"");
                    Enumeration enum = b.children();
                    // for all elements inside
                    while (enum.hasMoreElements()) {
                        BrowseItem bi = (BrowseItem) enum.nextElement();
                        category = bi.getCategory();
                        // if user
                        if (category.equals("user"))
                            handleIQBrowseUser(bi, ri);
                    } // for all BrowseItems
                } //if conference
            } //if IQBrowse
        } //for all extensions
    }*/

    /** Handles IQ browse user item */
    /*private void handleIQBrowseUser(BrowseItem b, BSConfRoomInfo ri) {
        String extName = b.getName();
        JID jid = b.getJID();
        String type = b.getType();
        //String hashJID = BSPresenceBean.getJIDHashString(jid, true);
        // if type == remove
        if (type != null && type.equals("remove")) {
            // removes the user
            //extName = (String) ri.nicks.get(hashJID);
            extName = (String) ri.nicks.get(jid);
            //ri.nicks.remove(hashJID);
            presenceBean.setPresence(jid, false, null, null, 0);
            //fireRoomMessage(ri.roomJID, extName + " left the room");
        }
        // else adds the user
        else {
            //ri.nicks.put(hashJID, extName);
            ri.nicks.put(jid, extName);
            presenceBean.setPresence(jid, true, null, null, 0);
            //fireRoomMessage(ri.roomJID, extName + " entered the room");
        }
    }*/

    /** Sets logged after receiving IQ result for creating/joining IQ set */
    private void setLogged(InfoQuery iq, BSConfRoomInfo ri) {
        Enumeration exts = iq.Extensions();

        while (exts.hasMoreElements()) {
            Extension e = (Extension) exts.nextElement();
            // if conference extension, sets information about the room
            /*if (e instanceof IQConf) {
                IQConf c = (IQConf) e;
                ri.setRoomName(c.getRoomName());
                ri.setMyJID(JID.fromString(c.getID()));
                fireSetMyJID(ri.roomJID, JID.fromString(c.getID()));
                fireRoomMessage(ri.roomJID, "logged into room \"" + c.getRoomName() + "\"");
                ri.setState(BSConfRoomInfo.LOGGED);
            }*/
        }
    }

    /** Sends invitation into given room to given JID */
    public boolean sendInvitation(JID toAddress, JID roomJID, String subject, String body) {
        if (toAddress == null || roomJID == null)
            return false;

        XConferenceBuilder confBuilder = new XConferenceBuilder();
        confBuilder.setAddress(roomJID);
        MessageBuilder msgBuilder = new MessageBuilder();
        msgBuilder.setToAddress(toAddress);
        if (body != null)
            msgBuilder.setBody(body);
        if (subject != null)
            msgBuilder.setSubject(subject);
        try {
            msgBuilder.addExtension(confBuilder.build());
            //msgBean.send((Message)msgBuilder.build());
            msgBean.getConnection().send(msgBuilder.build());
        } catch (InstantiationException e) {
            fireError(roomJID, "", "message builder failed");
            BSCore.logEvent(name, "error: message builder failed");
            return false;
        }
        return true;
    }

    /** called if a packet is not successfully sent (for instance, if the connection
     * dies while the packet is queued, or a packet is sent while disconnected).
     *
     * @param pe PacketEvent for the failed send
     */
    public void sendFailed(PacketEvent pe) {
    }

    /** called whenever a local client sends a packet, after the sending
     * is successful
     *
     * @param pe PacketEvent that has just been sent
     */
    public void sentPacket(PacketEvent pe) {
    }

    /** Returns users inside given room */
    public Enumeration getRoster(JID roomJID) {
        if (presenceBean == null) {
            return (new Vector()).elements();
        }

        //roomJID = JID.fromString(roomJID.toString().toLowerCase());
        return presenceBean.getAllPresences(roomJID);
    }

    /** Returns nick of given JID */
    public String getNick(JID jid) {
        String nick = null;
        //String str = BSPresenceBean.getJIDHashString(jid, false);
        JID key = jid.getSimpleJID();
        //BSConfRoomInfo ri = (BSConfRoomInfo) rooms.get(str.toLowerCase());
        BSConfRoomInfo ri = (BSConfRoomInfo) rooms.get(key);
        if (ri != null) {
            //str = BSPresenceBean.getJIDHashString(jid, true);
            //nick = (String) ri.nicks.get(str);
            nick = (String) ri.nicks.get(jid);
        }
        if (nick == null)
            nick = jid.getResource();
        return nick;
    }


    /** Changes the nick name  */
    public void changeNick(JID roomJID, String newNick) {
        JID key = roomJID.getSimpleJID();
        BSConfRoomInfo ri = (BSConfRoomInfo) rooms.get(key);
        if (ri == null) return;
        JID jid = new JID(roomJID.getUsername(), roomJID.getServer(), newNick);
        sendPresence(ri.myPresence, jid);
    }


    // *** presence events handling ***

    /** <code>BSPresenceListener</code> function - gets nick and sends farther */
    public void presenceChanged(BSPresenceInfo pi) {
        if (pi == null || pi.getJID() == null) return;

        //String hashJID = BSPresenceBean.getJIDHashString(pi.getJID(), false);
        JID key = pi.getJID().getSimpleJID();
        //BSConfRoomInfo ri = (BSConfRoomInfo) rooms.get(hashJID.toLowerCase());
        BSConfRoomInfo ri = (BSConfRoomInfo) rooms.get(key);
        if (ri == null) return;

        //hashJID = BSPresenceBean.getJIDHashString(pi.getJID(), true);
        //String extName = (String) ri.nicks.get(hashJID);
        String extName = getNick(pi.getJID());

        firePresenceChanged(pi.getJID(), extName, pi);
    }

    /** <code>BSPresenceListener</code> function - clears all presences */
    public void presencesCleared() {
        if (presenceBean == null) return;
        // for all rooms
        Enumeration ris = rooms.elements();
        while (ris.hasMoreElements()) {
            BSConfRoomInfo ri = (BSConfRoomInfo) ris.nextElement();
            // for all presences in room
            Enumeration presences = getRoster(ri.roomJID);
            while (presences.hasMoreElements()) {
                BSPresenceInfo pi = (BSPresenceInfo) presences.nextElement();
                presenceBean.setPresence(pi.getJID(), false, null, null, 0);
                BSPresenceInfo newPi = new BSPresenceInfo(pi.getJID(), false, null, null);
                firePresenceChanged(pi.getJID(), getNick(pi.getJID()), newPi);
            }
        }
    }

    /** <code>BSPresenceListener</code> function - empty implementation */
    public void subscriptionApproved(JID jid) { }
    /** <code>BSPresenceListener</code> function - empty implementation */
    public void subscriptionRequested(JID jid) { }

    /** <code>BSPresenceListener</code> function - error */
    public void presenceError(Presence p) {
        JID key = p.getFromAddress().getSimpleJID();
        BSConfRoomInfo ri = (BSConfRoomInfo) rooms.get(key);

        if (ri == null) return;

        fireError(ri.roomJID, p.getErrorCode(), p.getErrorText());
    }

    // *** conference listeners ***

    /**
     * Adds <code>BSConfListener</code> from listeners notified when
     * conference event appears.
     *
     * @see #removeConfListener
     * @see #removeAllConfListeners
     * @see #fireConfReceived
     */
    public void addConfListener(BSConfListener listener) {
        //assert listener != null : listener;
        if (listener == null) return;
        if (!confListeners.contains(listener)) {
            confListeners.addElement(listener);
        }
    }

    /**
     * Removes <code>BSConfListener</code> from listeners notified when
     * conference event appears.
     *
     * @see #addConfListener
     * @see #removeAllConfListeners
     * @see #fireConfReceived
     */
    public void removeConfListener(BSConfListener listener) {
        //assert listener != null : listener;
        if (listener == null) return;
        confListeners.removeElement(listener);
    }

    /**
     * Removes all listeners notified when conference event appears.
     * This can be used before to free dependencies and allow dispose of
     * all objects.
     *
     * @see #addConfListener
     * @see #removeConfListener
     * @see #fireConfReceived
     */
    public void removeAllConfListeners() {
        confListeners.clear();
    }


    /**
     * Adds <code>BSConfConsumer</code> from consumers notified when
     * conference event appears.
     *
     * @see #removeConfListener
     * @see #removeAllConfListeners
     * @see #fireConfReceived
     */
    public void addConfConsumer(BSConfConsumer consumer) {
        //assert listener != null : listener;
        if (consumer == null) return;
        if (!confConsumers.contains(consumer, 0)) {
            confConsumers.addLast(consumer, 0);
        }
    }

    /**
     * Removes <code>BSConfConsumer</code> from consumers notified when
     * conference event appears.
     *
     * @see #addConfListener
     * @see #removeAllConfListeners
     * @see #fireConfReceived
     */
    public void removeConfConsumer(BSConfConsumer consumer) {
        //assert listener != null : listener;
        if (consumer == null) return;
        confConsumers.remove(consumer, 0);
    }

    /**
     * Removes all consumers notified when conference event appears.
     * This can be used before to free dependencies and allow dispose of
     * all objects.
     *
     * @see #addConfListener
     * @see #removeConfListener
     * @see #fireConfReceived
     */
    public void removeAllConfConsumers() {
        confConsumers.clear();
    }

    /**
     * Notifies conference cunsumers and listeners that groupchat message arrived.
     *
     * @see #addConfListener
     * @see #removeConfListener
     * @see #removeAllConfListeners
     */
    protected void fireGroupMessage(JID fromAddress, String nick, String body) {
        for (Enumeration e = confConsumers.getConsumers(); e.hasMoreElements(); ) {
            BSConfConsumer consumer = (BSConfConsumer) e.nextElement();
            if (BSConsumationResult.DONE == consumer.groupMessage(fromAddress, nick, body).value)
                return;
        }
        for (Enumeration e = confListeners.elements(); e.hasMoreElements(); ) {
            BSConfListener listener = (BSConfListener) e.nextElement();
            listener.groupMessage(fromAddress, nick, body);
        }
    }

    /**
     * Notifies conference listeners that message from room arrived.
     *
     * @see #addConfListener
     * @see #removeConfListener
     * @see #removeAllConfListeners
     */
    protected void fireRoomMessage(JID roomJID, String body) {
        for (Enumeration e = confConsumers.getConsumers(); e.hasMoreElements(); ) {
            BSConfConsumer consumer = (BSConfConsumer) e.nextElement();
            if (BSConsumationResult.DONE == consumer.roomMessage(roomJID, body).value)
                return;
        }
        for (Enumeration e = confListeners.elements(); e.hasMoreElements(); ) {
            BSConfListener listener = (BSConfListener) e.nextElement();
            listener.roomMessage(roomJID, body);
        }
    }

    /**
     * Notifies conference listeners that private message arrived.
     *
     * @see #addConfListener
     * @see #removeConfListener
     * @see #removeAllConfListeners
     */
    protected void firePrivateMessage(JID fromAddress, String nick, String body) {
        for (Enumeration e = confConsumers.getConsumers(); e.hasMoreElements(); ) {
            BSConfConsumer consumer = (BSConfConsumer) e.nextElement();
            if (BSConsumationResult.DONE == consumer.privateMessage(fromAddress, nick, body).value)
                return;
        }
        for (Enumeration e = confListeners.elements(); e.hasMoreElements(); ) {
            BSConfListener listener = (BSConfListener) e.nextElement();
            listener.privateMessage(fromAddress, nick, body);
        }
    }

    /**
     * Notifies conference listeners that presence of nick in room changed.
     *
     * @see #addConfListener
     * @see #removeConfListener
     * @see #removeAllConfListeners
     */
    protected void firePresenceChanged(JID fromAddress, String nick, BSPresenceInfo pi) {
        for (Enumeration e = confConsumers.getConsumers(); e.hasMoreElements(); ) {
            BSConfConsumer consumer = (BSConfConsumer) e.nextElement();
            if (BSConsumationResult.DONE == consumer.presenceChanged(fromAddress, nick, pi).value)
                return;
        }
        for (Enumeration e = confListeners.elements(); e.hasMoreElements(); ) {
            BSConfListener listener = (BSConfListener) e.nextElement();
            listener.presenceChanged(fromAddress, nick, pi);
        }
    }

    /**
     * Notifies conference listeners that invitation into room arrived.
     *
     * @see #addConfListener
     * @see #removeConfListener
     * @see #removeAllConfListeners
     */
    protected void fireInvitation(JID fromAddress, JID roomJID,
                                  String subject, String body) {

        for (Enumeration e = confConsumers.getConsumers(); e.hasMoreElements(); ) {
            BSConfConsumer consumer = (BSConfConsumer) e.nextElement();
            if (BSConsumationResult.DONE == consumer.invitation(fromAddress, roomJID, subject, body).value)
                return;
        }
        for (Enumeration e = confListeners.elements(); e.hasMoreElements(); ) {
            BSConfListener listener = (BSConfListener) e.nextElement();
            listener.invitation(fromAddress, roomJID, subject, body);
        }
    }

    /**
     * Notifies conference listeners that error occured.
     *
     * @see #addConfListener
     * @see #removeConfListener
     * @see #removeAllConfListeners
     */
    protected void fireError(JID roomJID, String errCode, String errMsg) {
        for (Enumeration e = confConsumers.getConsumers(); e.hasMoreElements(); ) {
            BSConfConsumer consumer = (BSConfConsumer) e.nextElement();
            if (BSConsumationResult.DONE == consumer.error(roomJID, errCode, errMsg).value)
                return;
        }
        for (Enumeration e = confListeners.elements(); e.hasMoreElements(); ) {
            BSConfListener listener = (BSConfListener) e.nextElement();
            listener.error(roomJID, errCode, errMsg);
        }
    }


    /**
     * Notifies conference listeners about myJID in conference. This can be
     * taken as successful room entering.
     *
     * @see #addConfListener
     * @see #removeConfListener
     * @see #removeAllConfListeners
     */
    protected void fireSetMyJID(JID roomJID, JID myJID) {
        for (Enumeration e = confConsumers.getConsumers(); e.hasMoreElements(); ) {
            BSConfConsumer consumer = (BSConfConsumer) e.nextElement();
            if (BSConsumationResult.DONE == consumer.setMyJID(roomJID, myJID).value)
                return;
        }
        for (Enumeration e = confListeners.elements(); e.hasMoreElements(); ) {
            BSConfListener listener = (BSConfListener) e.nextElement();
            listener.setMyJID(roomJID, myJID);
        }
    }

}