callmanager.java.svn-base

开源项目openfire的完整源程序

/**
 * $Revision: $
 * $Date: $
 *
 * Copyright (C) 2007 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.sparkplugin.ui.call;

import net.java.sipmack.sip.Call;
import net.java.sipmack.sip.InterlocutorUI;
import net.java.sipmack.sip.event.CallListener;
import net.java.sipmack.sip.event.CallStateEvent;
import net.java.sipmack.softphone.SoftPhoneManager;
import net.java.sipmack.softphone.listeners.InterlocutorListener;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smackx.packet.VCard;
import org.jivesoftware.spark.ChatManager;
import org.jivesoftware.spark.SparkManager;
import org.jivesoftware.spark.component.tabbedPane.SparkTab;
import org.jivesoftware.spark.component.tabbedPane.SparkTabbedPaneListener;
import org.jivesoftware.spark.phone.PhoneManager;
import org.jivesoftware.spark.ui.ChatContainer;
import org.jivesoftware.spark.ui.ChatRoom;
import org.jivesoftware.spark.util.SwingWorker;
import org.jivesoftware.sparkimpl.plugin.alerts.SparkToaster;

import javax.swing.JOptionPane;

import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.HashMap;
import java.util.Map;

import org.jivesoftware.spark.plugin.phone.resource.PhoneRes;

/**
 *
 */
public class CallManager implements InterlocutorListener {

    private static CallManager singleton;
    private static final Object LOCK = new Object();

    private SoftPhoneManager softPhone;

    private final Map<String, PhonePanel> calls = new HashMap<String, PhonePanel>();

    private Presence offPhonePresence;

    private Map<InterlocutorUI, SparkToaster> toasters = new HashMap<InterlocutorUI, SparkToaster>();

    /**
     * Returns the singleton instance of <CODE>CallManager</CODE>,
     * creating it if necessary.
     * <p/>
     *
     * @return the singleton instance of <Code>CallManager</CODE>
     */
    public static CallManager getInstance() {
        // Synchronize on LOCK to ensure that we don't end up creating
        // two singletons.
        synchronized (LOCK) {
            if (null == singleton) {
                CallManager controller = new CallManager();
                singleton = controller;
                return controller;
            }
        }
        return singleton;
    }


    private CallManager() {
        softPhone = SoftPhoneManager.getInstance();
        softPhone.addInterlocutorListener(this);

        SparkManager.getChatManager().getChatContainer().addSparkTabbedPaneListener(new SparkTabbedPaneListener() {
            public void tabRemoved(SparkTab tab, Component component, int index) {
                removePhonePanel(component);
            }

            public void tabAdded(SparkTab tab, Component component, int index) {

            }

            public void tabSelected(SparkTab tab, Component component, int index) {
            }

            public void allTabsRemoved() {
            }


            public boolean canTabClose(SparkTab tab, Component component) {
                PhonePanel phonePanel = null;
                if (component instanceof PhonePanel) {
                    phonePanel = (PhonePanel) component;
                }

                if (phonePanel == null && component instanceof ChatRoom) {
                    final ChatRoom chatRoom = (ChatRoom) component;
                    Component rightComponent = chatRoom.getSplitPane().getRightComponent();
                    if (rightComponent instanceof PhonePanel) {
                        phonePanel = (PhonePanel) rightComponent;
                    }
                }

                if (phonePanel == null) {
                    return true;
                }

                if (component instanceof PhonePanel) {
                    final InterlocutorUI ic = phonePanel.getActiveCall();
                    if (ic.getCallState().equals(Call.CONNECTED)) {
                        // Prompt to close this window
                        int ok = JOptionPane.showConfirmDialog(component, PhoneRes.getIString("phone.closeconfirm"), PhoneRes.getIString("phone.confirmation"), JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
                        boolean close = (ok == JOptionPane.YES_OPTION);
                        if (close) {
                            // End Call
                            softPhone.getDefaultGuiManager().hangup(ic);
                            return true;
                        } else {
                            return false;
                        }
                    }
                }

                return true;
            }
        });
    }


    public void busy() {

    }

    private void showIncomingCall(final InterlocutorUI ic) {
        final SparkToaster toasterManager = new SparkToaster();
        toasters.put(ic, toasterManager);
        final IncomingCallUI incomingCall = new IncomingCallUI(ic);
        toasterManager.setToasterHeight(230);
        toasterManager.setToasterWidth(300);
        toasterManager.setDisplayTime(500000000);

        toasterManager.showToaster(PhoneRes.getIString("phone.incomingcall"), incomingCall);
        toasterManager.hideTitle();

        toasterManager.setHidable(false);

        incomingCall.getAcceptButton().addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                SparkManager.getMainWindow().toFront();
                closeToaster(ic);
                SoftPhoneManager.getInstance().getDefaultGuiManager().answer();

            }
        });

        incomingCall.getRejectButton().addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                closeToaster(ic);
                SoftPhoneManager.getInstance().getDefaultGuiManager().hangup(ic);
            }
        });
    }

    private void showOutgoingCall(final InterlocutorUI ic) {
        final SparkToaster toasterManager = new SparkToaster();
        toasters.put(ic, toasterManager);
        final OutgoingCallUI incomingCall = new OutgoingCallUI(ic);
        toasterManager.setToasterHeight(230);
        toasterManager.setToasterWidth(300);
        toasterManager.setDisplayTime(500000000);
        toasterManager.setHidable(false);

        toasterManager.showToaster(PhoneRes.getIString("phone.incomingcall"), incomingCall);
        toasterManager.hideTitle();

        incomingCall.getRejectButton().addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                closeToaster(ic);
                SoftPhoneManager.getInstance().getDefaultGuiManager().hangup(ic);
            }
        });
    }


    public void interlocutorAdded(final InterlocutorUI interlocutorUI) {

        Presence current = SparkManager.getWorkspace().getStatusBar().getPresence();

        // Set offline presence if necessary.
        if (offPhonePresence == null || !(current.getType().equals(Presence.Type.available) && current.getStatus().equals("On Phone") && current.getMode().equals(Presence.Mode.away))) {
            offPhonePresence = current;
        }

        // Send on phone presence
        Presence onPhonePresence = new Presence(Presence.Type.available, "On Phone", -1, Presence.Mode.away);
        SparkManager.getSessionManager().changePresence(onPhonePresence);

        interlocutorUI.getCall().addStateChangeListener(new CallListener() {
            public void callStateChanged(CallStateEvent evt) {
                final String callState = evt.getNewState();

                String callNumber = interlocutorUI.getCall().getNumber();
                callNumber = SoftPhoneManager.getNumbersFromPhone(callNumber);
                PhonePanel panel = calls.get(callNumber);

                if (callState.equals(Call.CONNECTED)) {
                    closeToaster(interlocutorUI);
                    showCallAnswered(interlocutorUI);
                } else if (callState.equals(Call.DISCONNECTED)) {
                    closeToaster(interlocutorUI);

                    if (panel != null) {
                        panel.callEnded();
                    }

                    PhoneManager.getInstance().removeCurrentCall(callNumber);