/** Start the network listening thread. */ void start() { this.running = true; Thread thread = new Thread(this, "IceConnector@" + hashCode()); thread.setDaemon(true); thread.start(); }
/** * Creates and starts the {@link #sendKeepAliveMessageThread} which is to send STUN keep-alive * <tt>Message</tt>s to the STUN server associated with the <tt>StunCandidateHarvester</tt> of * this instance in order to keep the <tt>Candidate</tt>s harvested by this instance alive. */ private void createSendKeepAliveMessageThread() { synchronized (sendKeepAliveMessageSyncRoot) { Thread t = new SendKeepAliveMessageThread(this); t.setDaemon(true); t.setName(getClass().getName() + ".sendKeepAliveMessageThread: " + hostCandidate); boolean started = false; sendKeepAliveMessageThread = t; try { t.start(); started = true; } finally { if (!started && (sendKeepAliveMessageThread == t)) sendKeepAliveMessageThread = null; } } }
/** * Runs in {@link #sendKeepAliveMessageThread} to notify this instance that * <tt>sendKeepAliveMessageThread</tt> is about to exit. */ private void exitSendKeepAliveMessageThread() { synchronized (sendKeepAliveMessageSyncRoot) { if (sendKeepAliveMessageThread == Thread.currentThread()) sendKeepAliveMessageThread = null; /* * Well, if the currentThread is finishing and this instance is * still to send keep-alive messages, we'd better start another * Thread for the purpose to continue the work that the * currentThread was supposed to carry out. */ if ((sendKeepAliveMessageThread == null) && (sendKeepAliveMessageInterval != SEND_KEEP_ALIVE_MESSAGE_INTERVAL_NOT_SPECIFIED)) { createSendKeepAliveMessageThread(); } } }
/** * Runs in {@link #sendKeepAliveMessageThread} and sends STUN keep-alive <tt>Message</tt>s to the * STUN server associated with the <tt>StunCandidateHarvester</tt> of this instance. * * @return <tt>true</tt> if the method is to be invoked again; otherwise, <tt>false</tt> */ private boolean runInSendKeepAliveMessageThread() { synchronized (sendKeepAliveMessageSyncRoot) { // Since we're going to #wait, make sure we're not canceled yet. if (sendKeepAliveMessageThread != Thread.currentThread()) return false; if (sendKeepAliveMessageInterval == SEND_KEEP_ALIVE_MESSAGE_INTERVAL_NOT_SPECIFIED) { return false; } // Determine the amount of milliseconds that we'll have to #wait. long timeout; if (sendKeepAliveMessageTime == -1) { /* * If we're just starting, don't just go and send a new STUN * keep-alive message but rather wait for the whole interval. */ timeout = sendKeepAliveMessageInterval; } else { timeout = sendKeepAliveMessageTime + sendKeepAliveMessageInterval - System.currentTimeMillis(); } // At long last, #wait if necessary. if (timeout > 0) { try { sendKeepAliveMessageSyncRoot.wait(timeout); } catch (InterruptedException iex) { } /* * Apart from being the time to send the STUN keep-alive * message, it could be that we've experienced a spurious * wake-up or that we've been canceled. */ return true; } } sendKeepAliveMessageTime = System.currentTimeMillis(); try { sendKeepAliveMessage(); } catch (StunException sex) { logger.log(Level.INFO, "Failed to send STUN keep-alive message.", sex); } return true; }