vijxtacallcontrol.java

用jxse开发的一个p2p通讯软件 有聊天 文件共享 视频3大功能

    public void initSession() {
        if (this.isLocallyInitiated()) {
            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("locally inititated");
            }

            this.sendCommand(COMMAND_VIJXTA_INVITE_REQUEST, COMMAND_VIJXTA_INVITE_ACCEPT);

            this.setProtocolState(SESSION_VIJXTA_INVITE_REQUEST_SENT);

            generalTimer.schedule(roundTripTimerTask, this.ROUND_TRIP_INTERVAL, this.ROUND_TRIP_INTERVAL);
        } else {
            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("NOT locally inititated");
            }
        }
    }

    public int getLocalVideoSourceType() {

        return localVideoSourceType;
    }


    public void setLocalVideoSourceType(int localVideoSourceType) {

        this.localVideoSourceType = localVideoSourceType;

        if (this.localVideoSourceType == LOCAL_DEVICE && this.isJMFPresent) {

            this.localMonitorControl = new LocalDeviceMonitorControl(this);

        } else if (this.localVideoSourceType == NETWORKED_DEVICE) {

            this.localMonitorControl = new NetworkedDeviceMonitorControl(this);

        } else if (this.localVideoSourceType == NO_DEVICE) {

            this.localMonitorControl = new NoDeviceMonitorControl(this);
        }

        this.localMonitorControl.addErrorListener(this);
    }

    public String getErrorMessage() {

        return this.errorMessage;
    }

    private void setErrorMessage(String errorMessage) {

        this.errorMessage = errorMessage;
    }


    public void deviceErrorEncountered(String errorString) {

        setErrorMessage(errorString);

        this.destroy();
    }

    /**
     * Executes the session protocol logic.
     * <p/>
     * basic order of operations:
     * SessionInviteRequest -->
     * <-- SessionInviteAccept
     * CallConfigRequest -->
     * <-- CallConfigAccept
     * CallStartRequest -->
     * <-- CallStartAccept
     * CallHangupRequest -->
     * <-- CallHangupAccept
     * SessionEndRequest -->
     * <-- SessionEndAccept
     * <p/>
     * The Peer to Send an invitation controls the session start and call start.
     * After this either peer may place the call on hold. Once on hold only the
     * peer to place the call on hold may resume the call. CallHangup may be
     * performed by either peer. Quality elements are added to startcall
     * commands. Video data messages are not squenced and do not require ack's.
     * Session logic is limited to two peers. Protocol state is used as an
     * event notification mechanism and to determine protocol command order.
     * This is not an adaptive protocol. Strict order of operations is observed
     */
    public void callControl(String command, DialogMessage msg) {

        if (COMMAND_VIJXTA_INVITE_REQUEST.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " + COMMAND_VIJXTA_INVITE_REQUEST +
                        " received");
            }

            if (getProtocolState() == SESSION_VIJXTA_DISCONNECTED) {

                setProtocolState(SESSION_VIJXTA_INVITE_REQUEST_RECEIVED);

                sendCommand(COMMAND_VIJXTA_INVITE_ACCEPT);

                setProtocolState(SESSION_VIJXTA_INVITE_ACCEPT_SENT);

                // from here a config ui starts and we wait for a a config req

                generalTimer.schedule(roundTripTimerTask, this.ROUND_TRIP_INTERVAL, this.ROUND_TRIP_INTERVAL);

            } else {

                postProtocolStateException(SESSION_VIJXTA_DISCONNECTED);

            }


        } else if (COMMAND_VIJXTA_INVITE_ACCEPT.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " + COMMAND_VIJXTA_INVITE_ACCEPT +
                        " received");
            }

            if (getProtocolState() == SESSION_VIJXTA_INVITE_REQUEST_SENT) {

                updateAckThread(command);

                setProtocolState(SESSION_VIJXTA_INVITE_ACCEPT_RECEIVED);

                // wait as user configs

            } else {

                postProtocolStateException(SESSION_VIJXTA_INVITE_REQUEST_SENT);

            }

        } else if (COMMAND_VIJXTA_CONFIG_REQUEST.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " + COMMAND_VIJXTA_CONFIG_REQUEST +
                        " received");
            }

            if (getProtocolState() == SESSION_VIJXTA_INVITE_ACCEPT_SENT) {

                parseConfigMessage(msg);

                setProtocolState(SESSION_VIJXTA_CONFIG_REQUEST_RECEIVED);

                localActionConfigRequestReceived(msg);


            } else {

                postProtocolStateException(SESSION_VIJXTA_INVITE_ACCEPT_SENT);

            }

        } else if (COMMAND_VIJXTA_CONFIG_ACCEPT.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " + COMMAND_VIJXTA_CONFIG_ACCEPT +
                        " received");
            }

            if (getProtocolState() == SESSION_VIJXTA_CONFIG_REQUEST_SENT) {

                updateAckThread(command);

                parseConfigMessage(msg);

                setProtocolState(SESSION_VIJXTA_CONFIG_ACCEPT_RECEIVED);

                localActionConfigAcceptReceived(msg);

            } else {

                postProtocolStateException(SESSION_VIJXTA_CONFIG_REQUEST_SENT);

            }

        } else if (COMMAND_VIJXTA_START_REQUEST.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " + COMMAND_VIJXTA_START_REQUEST +
                        " received");
            }

            if (getProtocolState() == SESSION_VIJXTA_CONFIG_ACCEPT_SENT) {

                setProtocolState(SESSION_VIJXTA_START_REQUEST_RECEIVED);


            } else {

                postProtocolStateException(SESSION_VIJXTA_CONFIG_ACCEPT_SENT);


            }

        } else if (COMMAND_VIJXTA_START_ACCEPT.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " + COMMAND_VIJXTA_START_ACCEPT +
                        " received");
            }

            if (getProtocolState() == SESSION_VIJXTA_START_REQUEST_SENT) {

                updateAckThread(command);

                setProtocolState(SESSION_VIJXTA_START_ACCEPT_RECEIVED);

                setProtocolState(SESSION_VIJXTA_INCALL);

            } else {

                postProtocolStateException(SESSION_VIJXTA_START_REQUEST_SENT);

            }

        } else if (COMMAND_VIJXTA_HOLD_REQUEST.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " + COMMAND_VIJXTA_HOLD_REQUEST +
                        " received");
            }


            if (getProtocolState() == SESSION_VIJXTA_INCALL) {


                setProtocolState(SESSION_VIJXTA_HOLD_REQUEST_RECEIVED);

                sendCommand(COMMAND_VIJXTA_HOLD_ACCEPT, null);

                setProtocolState(SESSION_VIJXTA_HOLD_ACCEPT_SENT);

                //place call on hold - we did not initiate the hold

                localActionHoldCall(false);

                setProtocolState(SESSION_VIJXTA_HOLDING);

            } else {

                postProtocolStateException(SESSION_VIJXTA_INCALL);

            }

        } else if (COMMAND_VIJXTA_HOLD_ACCEPT.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " + COMMAND_VIJXTA_HOLD_ACCEPT +
                        " received");
            }

            if (getProtocolState() == SESSION_VIJXTA_HOLD_REQUEST_SENT) {

                updateAckThread(command);

                setProtocolState(SESSION_VIJXTA_HOLD_ACCEPT_RECEIVED);
                //place call on hold - we initiate the hold
                localActionHoldCall(true);

                setProtocolState(SESSION_VIJXTA_HOLDING);

            } else {

                postProtocolStateException(SESSION_VIJXTA_HOLD_REQUEST_SENT);

            }

        } else if (COMMAND_VIJXTA_RESUME_REQUEST.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " + COMMAND_VIJXTA_RESUME_REQUEST +
                        " received");
            }

            if (getProtocolState() == SESSION_VIJXTA_HOLDING) {

                setProtocolState(SESSION_VIJXTA_RESUME_REQUEST_RECEIVED);

                sendCommand(COMMAND_VIJXTA_RESUME_ACCEPT, null);

                setProtocolState(SESSION_VIJXTA_RESUME_ACCEPT_SENT);

                // resume call
                localActionResumeCall();

                setProtocolState(SESSION_VIJXTA_INCALL);

            } else {


                postProtocolStateException(SESSION_VIJXTA_HOLDING);

            }

        } else if (COMMAND_VIJXTA_RESUME_ACCEPT.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " + COMMAND_VIJXTA_RESUME_ACCEPT +
                        " received");
            }

            if (getProtocolState() == SESSION_VIJXTA_RESUME_REQUEST_SENT) {

                updateAckThread(command);

                setProtocolState(SESSION_VIJXTA_RESUME_ACCEPT_RECEIVED);

                // resume call
                localActionResumeCall();

                setProtocolState(SESSION_VIJXTA_INCALL);

            } else {

                postProtocolStateException(SESSION_VIJXTA_RESUME_REQUEST_SENT);

            }

        } else if (COMMAND_VIJXTA_HANGUP_REQUEST.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " + COMMAND_VIJXTA_HANGUP_REQUEST +
                        " received");
            }


            if (getProtocolState() == SESSION_VIJXTA_INCALL) {

                setProtocolState(SESSION_VIJXTA_HANGUP_REQUEST_RECEIVED);

                sendCommand(COMMAND_VIJXTA_HANGUP_ACCEPT, null);

                setProtocolState(SESSION_VIJXTA_HANGUP_ACCEPT_SENT);

                // hangup call - stop transfering data
                localActionEndCall();

                setProtocolState(SESSION_VIJXTA_ENDED);

                if (roundTripTimerTask != null) {

                    roundTripTimerTask.cancel();

                }
            } else {

                postProtocolStateException(SESSION_VIJXTA_INCALL);

            }

        } else if (COMMAND_VIJXTA_HANGUP_ACCEPT.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " + COMMAND_VIJXTA_HANGUP_ACCEPT +
                        " received");
            }


            if (getProtocolState() == SESSION_VIJXTA_HANGUP_REQUEST_SENT) {

                updateAckThread(command);

                setProtocolState(SESSION_VIJXTA_HANGUP_ACCEPT_RECEIVED);

                //hang up call
                localActionEndCall();

                sendCommand(COMMAND_VIJXTA_DISCONNECT_REQUEST, COMMAND_VIJXTA_DISCONNECT_ACCEPT);

                setProtocolState(SESSION_VIJXTA_DISCONNECT_REQUEST_SENT);


            } else {

                postProtocolStateException(SESSION_VIJXTA_HANGUP_REQUEST_SENT);


            }

        } else if (COMMAND_VIJXTA_DISCONNECT_REQUEST.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("callControl : " +
                        COMMAND_VIJXTA_DISCONNECT_REQUEST + " received");
            }

            if (getProtocolState() == SESSION_VIJXTA_ENDED) {

                setProtocolState(SESSION_VIJXTA_DISCONNECT_REQUEST_RECEIVED);

                sendCommand(COMMAND_VIJXTA_DISCONNECT_ACCEPT, null);

                setProtocolState(SESSION_VIJXTA_DISCONNECT_ACCEPT_SENT);

                //disconnect from host - close window no more calls from this tab

                if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                    LOG.info("Disconnecting");

                }

                localActionEndSession();

                setProtocolState(SESSION_VIJXTA_DISCONNECTED);

            } else {
                // the other side is going down... kill session
                // this is the non graceful shutdown withthe protocol being in any state
                setProtocolState(SESSION_VIJXTA_DISCONNECT_REQUEST_RECEIVED);

                sendCommand(COMMAND_VIJXTA_DISCONNECT_ACCEPT, null);

                setProtocolState(SESSION_VIJXTA_DISCONNECT_ACCEPT_SENT);

                //disconnect from host - close window no more calls from this tab
                localActionEndSession();

                setProtocolState(SESSION_VIJXTA_DISCONNECTED);


                postProtocolStateException(SESSION_VIJXTA_ENDED);
                if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {


                    LOG.info("Ungraceful disconnect received...Going Down");
                }
            }

        } else if (COMMAND_VIJXTA_DISCONNECT_ACCEPT.equals(command)) {