vijxtacallcontrol.java

Myjxta的源代码 基于JXTA的P2P即时通信系统

/*
 * Copyright (c) [2005] [Jeffrey Moore]
 *
 * Redistributions in source code form must reproduce the above copyright and 
 * this condition.
 *
 * The contents of this file are subject to the Sun Project JXTA License 
 * Version 1.1 (the "License"); you may not use this file except in compliance 
 * with the License. A copy of the License is available at 
 * http://www.jxta.org/jxta_license.html.
 *
 */

/*
 * ViJxtaCallControl.java
 *
 * Created on April 7, 2005, 9:02 AM
 */

package net.jxta.myjxta.plugins.vijxta;

import net.jxta.endpoint.MessageElement;
import net.jxta.endpoint.StringMessageElement;
import net.jxta.logging.Logging;
import net.jxta.myjxta.MyJXTA;
import net.jxta.myjxta.View;
import net.jxta.myjxta.dialog.Dialog;
import net.jxta.myjxta.dialog.DialogMessage;

import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * This class acts as a controller for a video session. Much of this class's
 * protocol handling is adapted from VoJxtaCallControl.
 *
 * @author jamoore
 */
@SuppressWarnings({"UnnecessaryUnboxing", "UnnecessaryBoxing"})
public final class ViJxtaCallControl implements DeviceMonitorControl.DeviceErrorListener {

    /**
     * Time to wait for response after a command  message is sent
     * out. Default is 10 seconds.
     */
    private static final long DEFAULT_MESSAGE_ACK_TIMEOUT = 60000;

    /**
     * Minimum time we will wait till a message ack comes back
     */
    private static final long MINIMUM_MESSAGE_ACK_TIMEOUT = 2000;
    /**
     * Timeout waiting for config request
     */
    private static final long CONFIG_WAIT_TIMOUT = 20000;

    /**
     * Tag for an element element carrying video data
     */
    public static final String TAG_IMAGE_DATA = "ImageData";

    /**
     * Element tag denoting a message containing vijxta session command data
     */
    public static final String TAG_SESSION_COMMAND = "ViJxtaSessionCommand";

    public static final String TAG_IMAGE_QUALITY_ELEMENT = "ViJxtaImageQuality";

    public static final String TAG_IMAGE_FORMAT_SIZE_ELEMENT = "ViJxtaFormatSize";

    public static final String TAG_IMAGE_FORMAT_TYPE_ELEMENT = "ViJxtaFormatType";

    public static final String TAG_IMAGE_TRANSMIT_ELEMENT = "ViJxtaTransmit";

    public static final String TAG_IMAGE_RECEIVE_ELEMENT = "ViJxtaReceive";

    public static final String TAG_ROUND_TRIP_REQUEST_TIME = "RoundTripRequestTime";

    /**
     * commands sent btn peers managing the vijxta session
     */

    public static final String COMMAND_VIJXTA_INVITE_REQUEST = "ViJxtaInviteRequest";

    public static final String COMMAND_VIJXTA_INVITE_ACCEPT = "ViJxtaInviteAccept";

    public static final String COMMAND_VIJXTA_START_REQUEST = "ViJxtaStartRequest";

    public static final String COMMAND_VIJXTA_START_ACCEPT = "ViJxtaStartAccept";

    public static final String COMMAND_VIJXTA_CONFIG_REQUEST = "ViJxtaConfigRequest";

    public static final String COMMAND_VIJXTA_CONFIG_ACCEPT = "ViJxtaConfigAccept";

    public static final String COMMAND_VIJXTA_DATA = "ViJxtaData";

    public static final String COMMAND_VIJXTA_HOLD_REQUEST = "ViJxtaHoldRequest";

    public static final String COMMAND_VIJXTA_HOLD_ACCEPT = "ViJxtaHoldAccept";

    public static final String COMMAND_VIJXTA_RESUME_REQUEST = "ViJxtaResumeRequest";

    public static final String COMMAND_VIJXTA_RESUME_ACCEPT = "ViJxtaResumeAccept";

    public static final String COMMAND_VIJXTA_HANGUP_REQUEST = "ViJxtaHangUpRequest";

    public static final String COMMAND_VIJXTA_HANGUP_ACCEPT = "ViJxtaHangUpAccept";

    public static final String COMMAND_VIJXTA_DISCONNECT_REQUEST = "ViJxtaDisconnectRequest";

    public static final String COMMAND_VIJXTA_DISCONNECT_ACCEPT = "ViJxtaDisconnectAccept";

    public static final String COMMAND_VIJXTA_ROUND_TRIP_REQUEST = "ViJxtaRoundTripRequest";

    public static final String COMMAND_VIJXTA_ROUND_TRIP_ACCEPT = "ViJxtaRoundTripAccept";


    /**
     * internal session state
     */


    public static final int SESSION_VIJXTA_DISCONNECTED = 10;

    public static final int SESSION_VIJXTA_DISCONNECTING = 11;

    public static final int SESSION_VIJXTA_CONNECTED = 12;

    public static final int SESSION_VIJXTA_CONNECTING = 13;

    public static final int SESSION_VIJXTA_STARTING = 20;

    public static final int SESSION_VIJXTA_STARTED = 30;

    public static final int SESSION_VIJXTA_ENDING = 40;

    public static final int SESSION_VIJXTA_ENDED = 50;

    public static final int SESSION_VIJXTA_INCALL = 100;

    public static final int SESSION_VIJXTA_HOLDING = 110;

    public static final int SESSION_VIJXTA_DISCONNECT_REQUEST_SENT = 210;

    public static final int SESSION_VIJXTA_DISCONNECT_REQUEST_RECEIVED = 220;

    public static final int SESSION_VIJXTA_DISCONNECT_ACCEPT_SENT = 230;

    public static final int SESSION_VIJXTA_DISCONNECT_ACCEPT_RECEIVED = 240;

    public static final int SESSION_VIJXTA_RESUME_REQUEST_SENT = 250;

    public static final int SESSION_VIJXTA_RESUME_REQUEST_RECEIVED = 260;

    public static final int SESSION_VIJXTA_RESUME_ACCEPT_SENT = 270;

    public static final int SESSION_VIJXTA_RESUME_ACCEPT_RECEIVED = 280;

    public static final int SESSION_VIJXTA_HOLD_ACCEPT_SENT = 290;

    public static final int SESSION_VIJXTA_HOLD_ACCEPT_RECEIVED = 310;

    public static final int SESSION_VIJXTA_HOLD_REQUEST_SENT = 320;

    public static final int SESSION_VIJXTA_HOLD_REQUEST_RECEIVED = 330;

    public static final int SESSION_VIJXTA_START_REQUEST_SENT = 340;

    public static final int SESSION_VIJXTA_START_REQUEST_RECEIVED = 350;

    public static final int SESSION_VIJXTA_START_ACCEPT_SENT = 360;

    public static final int SESSION_VIJXTA_START_ACCEPT_RECEIVED = 370;

    public static final int SESSION_VIJXTA_CONFIG_REQUEST_SENT = 470;

    public static final int SESSION_VIJXTA_CONFIG_REQUEST_RECEIVED = 480;

    public static final int SESSION_VIJXTA_CONFIG_ACCEPT_SENT = 490;

    public static final int SESSION_VIJXTA_CONFIG_ACCEPT_RECEIVED = 500;

    public static final int SESSION_VIJXTA_HANGUP_ACCEPT_RECEIVED = 380;

    public static final int SESSION_VIJXTA_HANGUP_ACCEPT_SENT = 390;

    public static final int SESSION_VIJXTA_HANGUP_REQUEST_RECEIVED = 410;

    public static final int SESSION_VIJXTA_HANGUP_REQUEST_SENT = 420;

    public static final int SESSION_VIJXTA_INVITE_REQUEST_SENT = 430;

    public static final int SESSION_VIJXTA_INVITE_REQUEST_RECEIVED = 440;

    public static final int SESSION_VIJXTA_INVITE_ACCEPT_SENT = 450;

    public static final int SESSION_VIJXTA_INVITE_ACCEPT_RECEIVED = 460;

    public int protocolState = SESSION_VIJXTA_DISCONNECTED;

    public static final int MINIMUM_QUALITY = 0;

    public static final int MAXIMUM_QUALITY = 10;

    public static final int DEFAULT_QUALITY = 1;

    public static final long SECOND = 1000;

    public static final long MINUTE = SECOND * 60;

    public static final long HOUR = MINUTE * 60;

    public static final String TIME_SEPARATOR = ":";

    private long messageAckTimeout = DEFAULT_MESSAGE_ACK_TIMEOUT;

    public static final int NO_DEVICE = 0;

    public static final int LOCAL_DEVICE = 1;

    public static final int NETWORKED_DEVICE = 2;

    private int localVideoSourceType = NO_DEVICE;

    private long roundTrip = 0;

    private Dialog viJxtaDialog = null;

    private View myJxtaView = null;

    private MyJXTA myJxtaController = null;

    private DialogMessage templateMessage = null;

    private ViJxtaDialogView viJxtaView = null;

    private static final int PIPE_CONNECT_SLEEP_TIME = 200;

    private boolean sessionPersisted = false;

    protected boolean remotePeerReceive = false;

    protected boolean remotePeerTransmit = false;

    private String sessionFileName = null;

    static final Logger LOG = Logger.getLogger(ViJxtaCallControl.class.getName());

    private long callStartTime = 0;

    private long callEndTime = 0;

    private long callElapsedTime = 0;


    private RemoteMonitorControl remoteMonitorControl = null;


    private DeviceMonitorControl localMonitorControl = null;

    private boolean locallyInitiated = false;

    private ReceivedMessageTimeoutThread receiveTimeoutThread = null;

    /**
     * started on command message dispatch. waits for ack to message (notofy)
     * then dies
     */
    private MessageAckThread messageAckThread = null;

    private MyLock configStateLock = null;

    private Hashtable<Integer, String> sessionStateTable = null;

    private Timer generalTimer = null;

    private final long ROUND_TRIP_INTERVAL = 1000; // in ms

    private TimerTask roundTripTimerTask = null;

    private boolean isJMFPresent = false;

    private String errorMessage = null;

    private final boolean configMessageReceived = false;

    private TimerTask configWaitTimerTask = null;

    private boolean configured = false;

    /**
     * Creates a new instance of VijxtaCallControl
     */
    public ViJxtaCallControl(ViJxtaDialogView vijxtaView, View p_view, Dialog dialog, boolean locallyInitiated) {

        LOG.setLevel(Level.INFO);

        this.viJxtaView = vijxtaView;

        this.viJxtaDialog = dialog;

        this.locallyInitiated = locallyInitiated;

        this.configStateLock = new MyLock();

        this.configStateLock.setLocked(true);

        this.sessionStateTable = new Hashtable<Integer, String>();
        sessionStateTable.put(new Integer(SESSION_VIJXTA_CONFIG_ACCEPT_RECEIVED), "SESSION_VIJXTA_CONFIG_ACCEPT_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_CONFIG_ACCEPT_SENT), "SESSION_VIJXTA_CONFIG_ACCEPT_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_CONFIG_REQUEST_RECEIVED), "SESSION_VIJXTA_CONFIG_REQUEST_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_CONFIG_REQUEST_SENT), "SESSION_VIJXTA_CONFIG_REQUEST_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_CONNECTED), "SESSION_VIJXTA_CONNECTED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_CONNECTING), "SESSION_VIJXTA_CONNECTING");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_DISCONNECTED), "SESSION_VIJXTA_DISCONNECTED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_DISCONNECTING), "SESSION_VIJXTA_DISCONNECTING");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_DISCONNECT_ACCEPT_RECEIVED), "SESSION_VIJXTA_DISCONNECT_ACCEPT_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_DISCONNECT_ACCEPT_SENT), "SESSION_VIJXTA_DISCONNECT_ACCEPT_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_DISCONNECT_REQUEST_RECEIVED), "SESSION_VIJXTA_DISCONNECT_REQUEST_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_ENDED), "SESSION_VIJXTA_ENDED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_DISCONNECT_REQUEST_SENT), "SESSION_VIJXTA_DISCONNECT_REQUEST_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_ENDING), "SESSION_VIJXTA_ENDING");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_HANGUP_ACCEPT_RECEIVED), "SESSION_VIJXTA_HANGUP_ACCEPT_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_HANGUP_ACCEPT_SENT), "SESSION_VIJXTA_HANGUP_ACCEPT_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_HANGUP_REQUEST_RECEIVED), "SESSION_VIJXTA_HANGUP_REQUEST_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_HANGUP_REQUEST_SENT), "SESSION_VIJXTA_HANGUP_REQUEST_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_HOLDING), "SESSION_VIJXTA_HOLDING");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_HOLD_ACCEPT_RECEIVED), "SESSION_VIJXTA_HOLD_ACCEPT_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_HOLD_ACCEPT_SENT), "SESSION_VIJXTA_HOLD_ACCEPT_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_HOLD_REQUEST_RECEIVED), "SESSION_VIJXTA_HOLD_REQUEST_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_HOLD_REQUEST_SENT), "SESSION_VIJXTA_HOLD_REQUEST_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_INCALL), "SESSION_VIJXTA_INCALL");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_INVITE_ACCEPT_RECEIVED), "SESSION_VIJXTA_INVITE_ACCEPT_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_INVITE_ACCEPT_SENT), "SESSION_VIJXTA_INVITE_ACCEPT_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_INVITE_REQUEST_RECEIVED), "SESSION_VIJXTA_INVITE_REQUEST_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_INVITE_REQUEST_SENT), "SESSION_VIJXTA_INVITE_REQUEST_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_RESUME_ACCEPT_RECEIVED), "SESSION_VIJXTA_RESUME_ACCEPT_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_RESUME_ACCEPT_SENT), "SESSION_VIJXTA_RESUME_ACCEPT_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_RESUME_REQUEST_RECEIVED), "SESSION_VIJXTA_RESUME_REQUEST_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_RESUME_REQUEST_SENT), "SESSION_VIJXTA_RESUME_REQUEST_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_STARTED), "SESSION_VIJXTA_STARTED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_STARTING), "SESSION_VIJXTA_STARTING");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_START_ACCEPT_RECEIVED), "SESSION_VIJXTA_START_ACCEPT_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_START_ACCEPT_SENT), "SESSION_VIJXTA_START_ACCEPT_SENT");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_START_REQUEST_RECEIVED), "SESSION_VIJXTA_START_REQUEST_RECEIVED");
        sessionStateTable.put(new Integer(SESSION_VIJXTA_START_REQUEST_SENT), "SESSION_VIJXTA_START_REQUEST_SENT");

        // wait for pipes to connect
        if (this.viJxtaDialog != null) {
            new Thread(new Runnable() {

                public void run() {
                    while (!ViJxtaCallControl.this.viJxtaDialog.isConnected()) {
                        try {
                            Thread.sleep(PIPE_CONNECT_SLEEP_TIME);
                            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                                LOG.info("Waiting for is connected ");
                            }
                        }
                        catch (InterruptedException ignored) {
                            //ignored
                        }
                    }
                }
            }, getClass().getName() + ":isConnected").start();
        }


        this.myJxtaView = p_view;

        this.myJxtaController = p_view.getControl();


        if (!this.viJxtaDialog.isConnected()) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("Constructor : ViJxtaDialog NOT connected!! Resources released. Module Shutdown.");
            }

        } else {
            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("Constructor : ViJxtaDialog Connected!! Obtaining Resources. Starting Module");
            }

            // tests for presence of jmf.jar

            try {
                this.isJMFPresent = LocalDeviceMonitorControl.isJMFPresent();

            } catch (Exception x) {

                x.printStackTrace();

                isJMFPresent = false;

            } catch (Error e) {

                e.printStackTrace();

                isJMFPresent = false;

            }


            this.remoteMonitorControl = new RemoteMonitorControl(this);

            templateMessage = new DialogMessage(this.viJxtaDialog.getGroup()
                    .getPeerGroup().getPeerName(), null, this.viJxtaDialog.getGroup()
                    .getPeerGroup().getPeerGroupID().toString(), this.viJxtaDialog
                    .getGroup().getPeerGroup().getPeerGroupName());

            generalTimer = new Timer(true);

            roundTripTimerTask = new TimerTask() {

                public void run() {

                    localActionSendRoundTripRequest();
                }
            };


        }

    }//constructor


    /**
     * Returns the Dialog that this module is attched.
     */
    public Dialog getDialog() {

        return this.viJxtaDialog;
    }