bsmessengerbean.java

一款即时通讯软件

        if (msg == null || (jid = msg.getFromAddress()) == null) return;
        
        //String str = BSPresenceBean.getJIDHashString(jid, false);
        JID key = jid.getSimpleJID();
        //Vector jidsMsgs = (Vector) unreadMsgs.get(str);
        Vector jidsMsgs = (Vector) unreadMsgs.get(key);
        
        if (jidsMsgs == null || jidsMsgs.isEmpty() || !jidsMsgs.contains(msg)) 
            return;
        
        jidsMsgs.remove(msg);
        fireMessageRead(msg);
    }
    
    /**
     * Returns if there is some unread message for given <code>jid</code>.
     */
    public boolean isMessageWaiting(JID jid) {
        if (jid == null) return false;
        
        // gets list of messages for jid without resource
        //String str = BSPresenceBean.getJIDHashString(jid, false);
        JID key = jid.getSimpleJID();
        //Vector jidsMsgs = (Vector) unreadMsgs.get(str);
        Vector jidsMsgs = (Vector) unreadMsgs.get(key);
        
        // if the list is empty
        if (jidsMsgs == null || jidsMsgs.isEmpty()) 
            return false;
        
        // if no resource
        if (jid.getResource() == null || jid.getResource().equals(""))
            return true;
        
        // looks for messages for specified resource
        Enumeration msgs = jidsMsgs.elements();
        while (msgs.hasMoreElements()) {
            Message m = (Message) msgs.nextElement();
            if (jid.equals(m.getFromAddress()))
                return true;
        }
        
        return false;
    }
    
    /**
     * Invoked when a message packet is received.
     */
    public void receivedPacket(PacketEvent pe) {
        if (!(pe.getPacket() instanceof Message)) {
            //BSCore.logEvent(name, "warning: non-message packet received");
            return;
        }
        
        Message msg = (Message) pe.getPacket();
        if ((new String("error")).equals(msg.getType()))
            handleError(msg);
        else 
            handleMessage(msg);
    }
    
    /**
     * Stores message time-stamp.
     */
    protected void storeMessageTimeStamp(Message msg) {
        Date timeStamp = null;
        Enumeration extEnum = msg.Extensions();
        while (extEnum.hasMoreElements()) {
            Object o = extEnum.nextElement();
            if (o instanceof XDelay)
                timeStamp = History.getTime((XDelay)o);
        }
        msgTimeStamps.put(msg, (timeStamp != null)? timeStamp: new Date());
    }
    
    /**
     * Handles <code>Message</code> packet, if it doesn't contain an error.
     */
    private void handleMessage(Message msg) {
        String type = msg.getType();
        if (blockGroupChat && type != null && type.equals("groupchat"))
            return;
        
        JID jid = msg.getFromAddress();
        
        // returns if message from blocked jid is received
        //JID noResJID = new JID(jid.getUsername(), jid.getServer(), null);
        JID noResJID = jid.getSimpleJID();
        if (blockedJIDs.contains(noResJID))
            return;
        
        String body = msg.getBody();
        
        BSCore.logMessage(jid.toString(), msg.getSubject(), body);
        
        // adds the message into unread messages
        //String str = BSPresenceBean.getJIDHashString(jid, false);
        JID key = jid.getSimpleJID();
        //Vector jidsMsgs = (Vector) unreadMsgs.get(str);
        Vector jidsMsgs = (Vector) unreadMsgs.get(key);
        if (jidsMsgs == null) {
            jidsMsgs = new Vector();
            unreadMsgs.put(key, jidsMsgs);
        }
        jidsMsgs.add(msg);
        
        storeMessageTimeStamp(msg);
        
        //fireMessageReceived(jid);
        fireMessageReceived(msg);
    }
    
    /**
     * Handles <code>Message</code> packet, if it does contain an error.
     */
    private void handleError(Message msg) {
        //BSCore.logEvent(name, "error " + msg.getErrorCode() + ": " + msg.getErrorText());
        
        JID jid = msg.getFromAddress();
        
        storeMessageTimeStamp(msg);
        
        //fireMessageError(jid, msg.getErrorCode(), msg.getErrorText());
        fireMessageError(msg);
    }
    
    /**
     * Invoked when a message packet send failes.
     */
    public void sendFailed(PacketEvent pe) {
        //BSCore.logEvent(name, "error: message send failed");
    }
    
    /**
     * Invoked when a message packet is sent.
     */
    public void sentPacket(PacketEvent pe) {
    }
    
    /**
     * Starts blocking messages from given JID and its resources.
     */
    public void startBlocking(JID jid) {
        //JID noResJID = new JID(jid.getUsername(), jid.getServer(), null);
        JID noResJID = jid.getSimpleJID();
        if (!blockedJIDs.contains(noResJID))
            blockedJIDs.add(noResJID);
    }
    
    /**
     * Stops blocking messages from given JID and its resources.
     */
    public void stopBlocking(JID jid) {
        //JID noResJID = new JID(jid.getUsername(), jid.getServer(), null);
        JID noResJID = jid.getSimpleJID();
        if (blockedJIDs.contains(noResJID))
            blockedJIDs.remove(noResJID);
    }
    
    /**
     * Starts blocking groupchat messages.
     */
    public void startBlockingGroupChat() {
        blockGroupChat = true;
    }
    
    /**
     * Stops blocking blocking groupchat messages.
     */
    public void stopBlockingGroupChat() {
        blockGroupChat = false;
    }
    
    // *** message listeners ***
    
    /**
     * Adds <code>MessageListener</code> from listeners notified when
     * unread messages change.
     *
     * @see #removeMessageListener
     * @see #removeAllMessageListeners
     * @see #fireMessageReceived
     * @see #fireMessageRead
     * @see #fireMessageError
     */
    public void addMessageListener(BSMessageListener listener) {
        //assert listener != null : listener;
        if (listener == null) return;
        if (!msgListeners.contains(listener)) {
            msgListeners.addElement(listener);
        }
    }

    /**
     * Removes <code>MessageListener</code> from listeners notified when
     * unread messages change.
     *
     * @see #addMessageListener
     * @see #removeAllMessageListeners
     * @see #fireMessageReceived
     * @see #fireMessageRead
     * @see #fireMessageError
     */
    public void removeMessageListener(BSMessageListener listener) {
        //assert listener != null : listener;
        if (listener == null) return;
        msgListeners.removeElement(listener);
    }

    /**
     * Removes all listeners notified when unread messages change.
     * This can be used before to free dependencies and allow dispose of
     * all objects.
     *
     * @see #addMessageListener
     * @see #removeMessageListener
     * @see #fireMessageReceived
     * @see #fireMessageRead
     * @see #fireMessageError
     */
    public void removeAllMessageListeners() {
        msgListeners.clear();
    }

    /**
     * Notifies message listeners that message was received from 
     * <code>fromAddress</code>.
     *
     * @see #addMessageListener
     * @see #removeMessageListener
     * @see #removeAllMessageListeners
     * @see #fireMessageRead
     * @see #fireMessageError
     */
    private void fireMessageReceived(Message msg) {
        if (msg == null) return;
        String type = msg.getType();
        for (Enumeration e = msgListeners.elements(); e.hasMoreElements(); ) {
            BSMessageListener listener = (BSMessageListener) e.nextElement();
            //listener.messageRead(msg.getFromAddress());
            if (type == null || type.equals("") || type.equals(PLAIN_MESSAGE))
                listener.plainMessageReceived(msg);
            else if (type.equals("chat"))
                listener.chatMessageReceived(msg);
            else if (type.equals("groupchat"))
                listener.groupchatMessageReceived(msg);
            else if (type.equals("headline"))
                listener.headlineMessageReceived(msg);
        }
    }
    
    /**
     * Notifies message listeners that a message from 
     * <code>fromAddress</code> was read.
     *
     * @see #addMessageListener
     * @see #removeMessageListener
     * @see #removeAllMessageListeners
     * @see #fireMessageReceived
     * @see #fireMessageError
     */
    private void fireMessageRead(Message msg) {
        for (Enumeration e = msgListeners.elements(); e.hasMoreElements(); ) {
            BSMessageListener listener = (BSMessageListener) e.nextElement();
            //listener.messageRead(msg.getFromAddress());
            listener.messageRead(msg);
        }
    }
    
    /**
     * Notifies message listeners that a message to 
     * <code>toAddress</code> was not delivered because of <code>error</code>.
     *
     * @see #addMessageListener
     * @see #removeMessageListener
     * @see #removeAllMessageListeners
     * @see #fireMessageReceived
     * @see #fireMessageRead
     */
    private void fireMessageError(Message msg) {
        for (Enumeration e = msgListeners.elements(); e.hasMoreElements(); ) {
            BSMessageListener listener = (BSMessageListener) e.nextElement();
            /*listener.messageError(msg.getFromAddress(), 
                                  msg.getErrorCode(), msg.getErrorText());*/
            listener.messageError(msg);
        }
    }
    
    /**
     * Notifies message listeners that a message to 
     * <code>toAddress</code> was not delivered because of <code>error</code>.
     *
     * @see #addMessageListener
     * @see #removeMessageListener
     * @see #removeAllMessageListeners
     * @see #fireMessageReceived
     * @see #fireMessageRead
     */
    private void fireMessageError(JID toAddress, String errType, String error) {
        for (Enumeration e = msgListeners.elements(); e.hasMoreElements(); ) {
            BSMessageListener listener = (BSMessageListener) e.nextElement();
            listener.messageError(toAddress, errType, error);
        }
    }
    
    
    /**
     * Returns the newest unread message for given <code>jid</code> and
     * removes the message from list of unread. Then it notifies listeners
     * that the message was read.
     */
    /*public String popLastMessage(JID jid) {
        if (jid == null) return null;
        
        String str = BSPresenceBean.getJIDHashString(jid, false);
        Vector jidsMsgs = (Vector) unreadMsgs.get(str);
        
        if (jidsMsgs == null || jidsMsgs.isEmpty()) return null;
        
        Message msg = null;
        
        // if no resource
        if (jid.getResource() == null || jid.getResource().equals("")) {
            try {
                msg = (Message) jidsMsgs.lastElement();
            } catch (NoSuchElementException e) {
                msg = null;
            }
        }
        // else some resource
        else {
            Enumeration msgs = jidsMsgs.elements();
            while (msgs.hasMoreElements()) {
                Message m = (Message) msgs.nextElement();
                if (jid.equals(m.getFromAddress()))
                    msg = m;
            }
        }
        
        // removes the message
        jidsMsgs.remove(msg);
        fireMessageRead(jid);

        //return new String("<" + jid.toString() + "> " + msg.getBody());
        return new String(msg.getBody());
    }*/
    
    /**
     * Sends message with given <code>body</code> and <code>subject</code>
     * to given <code>jid</code>.
     */
    /*public void sendMessage(JID jid, String body, String subject, String type) {
        MessageBuilder msgBuilder = new MessageBuilder();
        if (body != null)
            msgBuilder.setBody(body);
        if (jid != null)
            msgBuilder.setToAddress(jid);
        if (subject != null)
            msgBuilder.setSubject(subject);
        if (type != null && (type.equals("chat") || type.equals("groupchat")))
            msgBuilder.setType(type);
        try {
            //msgBean.send((Message)msgBuilder.build());
            msgBean.getConnection().send(msgBuilder.build());
        } catch (InstantiationException e) {
            //BSCore.logEvent(name, "error: message builder failed");
            fireMessageError(jid, "---", "Message builder failed");
            return;
        }
    }*/
    
}