conferenceservices.java.svn-base

来自「开源项目openfire的完整源程序」· SVN-BASE 代码 · 共 431 行 · 第 1/2 页

/**
 * $Revision: $
 * $Date: $
 *
 * Copyright (C) 2006 Jive Software. All rights reserved.
 *
 * This software is published under the terms of the GNU Lesser Public License (LGPL),
 * a copy of which is included in this distribution.
 */

package org.jivesoftware.spark.ui.conferences;

import org.jivesoftware.resource.Res;
import org.jivesoftware.resource.SparkRes;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.util.StringUtils;
import org.jivesoftware.smackx.ServiceDiscoveryManager;
import org.jivesoftware.smackx.bookmark.BookmarkManager;
import org.jivesoftware.smackx.muc.InvitationListener;
import org.jivesoftware.smackx.muc.MultiUserChat;
import org.jivesoftware.spark.ChatManager;
import org.jivesoftware.spark.SparkManager;
import org.jivesoftware.spark.Workspace;
import org.jivesoftware.spark.component.RolloverButton;
import org.jivesoftware.spark.plugin.ContextMenuListener;
import org.jivesoftware.spark.ui.ChatRoom;
import org.jivesoftware.spark.ui.ChatRoomButton;
import org.jivesoftware.spark.ui.ChatRoomClosingListener;
import org.jivesoftware.spark.ui.ChatRoomListener;
import org.jivesoftware.spark.ui.ChatRoomNotFoundException;
import org.jivesoftware.spark.ui.ContactGroup;
import org.jivesoftware.spark.ui.ContactItem;
import org.jivesoftware.spark.ui.ContactList;
import org.jivesoftware.spark.ui.PresenceListener;
import org.jivesoftware.spark.ui.rooms.ChatRoomImpl;
import org.jivesoftware.spark.ui.rooms.GroupChatRoom;
import org.jivesoftware.spark.ui.status.StatusBar;
import org.jivesoftware.spark.util.ModelUtil;
import org.jivesoftware.spark.util.SwingWorker;
import org.jivesoftware.spark.util.log.Log;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JMenu;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.SwingUtilities;

/**
 * Conference plugin is reponsible for the initial loading of MultiUser Chat support. To disable plugin,
 * you can remove from the plugins.xml file located in the classpath of Communicator.
 */
public class ConferenceServices {
    private static BookmarksUI bookmarksUI;

    private boolean mucSupported;

    public ConferenceServices() {
        ServiceDiscoveryManager manager = ServiceDiscoveryManager.getInstanceFor(SparkManager.getConnection());
        mucSupported = manager.includesFeature("http://jabber.org/protocol/muc");

        if (mucSupported) {
            // Add an invitation listener.
            addInvitationListener();

            addChatRoomListener();

            addPopupListeners();

            // Add Join Conference Button to StatusBar
            // Get command panel and add View Online/Offline, Add Contact
            StatusBar statusBar = SparkManager.getWorkspace().getStatusBar();
            JPanel commandPanel = SparkManager.getWorkspace().getCommandPanel();

            RolloverButton joinConference = new RolloverButton(SparkRes.getImageIcon(SparkRes.CONFERENCE_IMAGE_16x16));
            joinConference.setToolTipText(Res.getString("message.join.conference.room"));
            commandPanel.add(joinConference);
            joinConference.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    ConferenceRoomBrowser rooms = new ConferenceRoomBrowser(bookmarksUI, getDefaultServiceName());
                    rooms.invoke();
                }
            });

            // Add Presence Listener to send directed presence to Group Chat Rooms.
            PresenceListener presenceListener = new PresenceListener() {
                public void presenceChanged(final Presence presence) {
                    SwingUtilities.invokeLater(new Runnable() {
                        public void run() {
                            for (ChatRoom room : SparkManager.getChatManager().getChatContainer().getChatRooms()) {
                                if (room instanceof GroupChatRoom) {
                                    final Presence p = new Presence(presence.getType(), presence.getStatus(), presence.getPriority(), presence.getMode());

                                    GroupChatRoom groupChatRoom = (GroupChatRoom)room;
                                    String jid = groupChatRoom.getMultiUserChat().getRoom();

                                    p.setTo(jid);
                                    SparkManager.getConnection().sendPacket(p);
                                }
                            }
                        }
                    });
                }
            };

            SparkManager.getSessionManager().addPresenceListener(presenceListener);
        }
    }

    /**
     * Adds an invitation listener to check for any MUC invites.
     */
    private static void addInvitationListener() {
        // Add Invite Listener
        MultiUserChat.addInvitationListener(SparkManager.getConnection(), new InvitationListener() {
            public void invitationReceived(final XMPPConnection conn, final String room, final String inviter, final String reason, final String password, final Message message) {
                SwingUtilities.invokeLater(new Runnable() {
                    public void run() {
                        Collection<RoomInvitationListener> listeners = new ArrayList<RoomInvitationListener>(SparkManager.getChatManager().getInvitationListeners());
                        for (RoomInvitationListener listener : listeners) {
                            boolean handle = listener.handleInvitation(conn, room, inviter, reason, password, message);
                            if (handle) {
                                return;
                            }
                        }

                        // Make sure the user is not already in the room.
                        try {
                            SparkManager.getChatManager().getChatContainer().getChatRoom(room);
                            return;
                        }
                        catch (ChatRoomNotFoundException e) {
                            // Ignore :)
                        }

                        final GroupChatInvitationUI invitationUI = new GroupChatInvitationUI(room, inviter, password, reason);

                        String bareJID = StringUtils.parseBareAddress(inviter);
                        try {
                            ChatRoom chatRoom = SparkManager.getChatManager().getChatContainer().getChatRoom(bareJID);

                            // If the ChatRoom exists, add an invitation UI.
                            chatRoom.getTranscriptWindow().addComponent(invitationUI);

                            // Notify user of incoming invitation.
                            chatRoom.increaseUnreadMessageCount();

                            chatRoom.scrollToBottom();

                            SparkManager.getChatManager().getChatContainer().fireNotifyOnMessage(chatRoom);
                        }
                        catch (ChatRoomNotFoundException e) {
                            // If it doesn't exists. Create a new Group Chat Room
                            // Create the Group Chat Room
                            final MultiUserChat chat = new MultiUserChat(SparkManager.getConnection(), room);

                            GroupChatRoom groupChatRoom = new GroupChatRoom(chat);
                            groupChatRoom.getSplitPane().setDividerSize(5);
                            groupChatRoom.getVerticalSlipPane().setDividerLocation(0.6);
                            groupChatRoom.getSplitPane().setDividerLocation(0.6);

                            String roomName = StringUtils.parseName(room);
                            groupChatRoom.setTabTitle(roomName);
                            groupChatRoom.getToolBar().setVisible(true);

                            SparkManager.getChatManager().getChatContainer().addChatRoom(groupChatRoom);
                            groupChatRoom.getTranscriptWindow().addComponent(invitationUI);

                            // Notify user of incoming invitation.
                            groupChatRoom.increaseUnreadMessageCount();

                            groupChatRoom.scrollToBottom();

                            SparkManager.getChatManager().getChatContainer().fireNotifyOnMessage(groupChatRoom);
                        }
                        // If no listeners handled the invitation, default to generic invite.
                        //new ConversationInvitation(conn, room, inviter, reason, password, message);
                    }
                });

            }
        });
    }

    /**
     * Persists bookmarked data, if any.
     */
    public void shutdown() {
        if (!mucSupported) {
            return;
        }
    }

    /**
     * Load all bookmarked data.
     */
    public void loadConferenceBookmarks() {
        final Workspace workspace = SparkManager.getWorkspace();

        final SwingWorker bookmarkLoader = new SwingWorker() {

            public Object construct() {
                try {
                    BookmarkManager manager = BookmarkManager.getBookmarkManager(SparkManager.getConnection());