001/**
002 *
003 * Copyright 2003-2006 Jive Software.
004 *
005 * Licensed under the Apache License, Version 2.0 (the "License");
006 * you may not use this file except in compliance with the License.
007 * You may obtain a copy of the License at
008 *
009 *     http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018package org.jivesoftware.smackx.jingleold.nat;
019
020import java.util.ArrayList;
021import java.util.Collections;
022import java.util.Iterator;
023import java.util.List;
024import java.util.logging.Logger;
025
026import org.jivesoftware.smack.SmackException;
027import org.jivesoftware.smack.SmackException.NotConnectedException;
028import org.jivesoftware.smack.XMPPException;
029import org.jivesoftware.smack.packet.IQ;
030import org.jivesoftware.smackx.jingleold.ContentNegotiator;
031import org.jivesoftware.smackx.jingleold.JingleActionEnum;
032import org.jivesoftware.smackx.jingleold.JingleException;
033import org.jivesoftware.smackx.jingleold.JingleNegotiator;
034import org.jivesoftware.smackx.jingleold.JingleNegotiatorState;
035import org.jivesoftware.smackx.jingleold.JingleSession;
036import org.jivesoftware.smackx.jingleold.listeners.JingleListener;
037import org.jivesoftware.smackx.jingleold.listeners.JingleTransportListener;
038import org.jivesoftware.smackx.jingleold.packet.Jingle;
039import org.jivesoftware.smackx.jingleold.packet.JingleContent;
040import org.jivesoftware.smackx.jingleold.packet.JingleTransport;
041import org.jivesoftware.smackx.jingleold.packet.JingleTransport.JingleTransportCandidate;
042
043/**
044 * Transport negotiator.
045 * <p/>
046 * <p/>
047 * This class is responsible for managing the transport negotiation process,
048 * handling all the stanza(/packet) interchange and the stage control.
049 *
050 * @author Alvaro Saurin <alvaro.saurin@gmail.com>
051 */
052public abstract class TransportNegotiator extends JingleNegotiator {
053
054        private static final Logger LOGGER = Logger.getLogger(TransportNegotiator.class.getName());
055
056        // The time we give to the candidates check before we accept or decline the
057    // transport (in milliseconds)
058    public final static int CANDIDATES_ACCEPT_PERIOD = 4000;
059
060    // The session this nenotiator belongs to
061    //private final JingleSession session;
062
063    // The transport manager
064    private final TransportResolver resolver;
065
066    // Transport candidates we have offered
067    private final List<TransportCandidate> offeredCandidates = new ArrayList<TransportCandidate>();
068
069    // List of remote transport candidates
070    private final List<TransportCandidate> remoteCandidates = new ArrayList<TransportCandidate>();
071
072    // Valid remote candidates
073    private final List<TransportCandidate> validRemoteCandidates = new ArrayList<TransportCandidate>();
074
075    // Accepted Remote Candidates
076    private final List<TransportCandidate> acceptedRemoteCandidates = new ArrayList<TransportCandidate>();
077
078    // The best local candidate we have offered (and accepted by the other part)
079    private TransportCandidate acceptedLocalCandidate;
080
081    // The thread that will report the result to the other end
082    private Thread resultThread;
083
084    // Listener for the resolver
085    private TransportResolverListener.Resolver resolverListener;
086
087    private ContentNegotiator parentNegotiator;
088
089    /**
090    * Default constructor.
091    *
092    * @param session            The Jingle session
093    * @param transResolver The JingleTransportManager to use
094    */
095    public TransportNegotiator(JingleSession session, TransportResolver transResolver, ContentNegotiator parentNegotiator) {
096        super(session);
097
098        resolver = transResolver;
099        this.parentNegotiator = parentNegotiator;
100
101        resultThread = null;
102    }
103
104    /**
105     * Get a new instance of the right TransportNegotiator class with this
106     * candidate.
107     *
108     * @return A TransportNegotiator instance
109     */
110    public abstract JingleTransport getJingleTransport(TransportCandidate cand);
111
112    /**
113     * Return true if the transport candidate is acceptable for the current
114     * negotiator.
115     *
116     * @return true if the transport candidate is acceptable
117     */
118    public abstract boolean acceptableTransportCandidate(TransportCandidate tc, List<TransportCandidate> localCandidates);
119
120    /**
121     * Obtain the best local candidate we want to offer.
122     *
123     * @return the best local candidate
124     */
125    public final TransportCandidate getBestLocalCandidate() {
126        return resolver.getPreferredCandidate();
127    }
128
129    /**
130     * Set the best local transport candidate we have offered and accepted by
131     * the other endpoint.
132     *
133     * @param bestLocalCandidate the acceptedLocalCandidate to set
134     */
135    private void setAcceptedLocalCandidate(TransportCandidate bestLocalCandidate) throws XMPPException {
136        for (int i = 0; i < resolver.getCandidateCount(); i++) {
137            //TODO FIX The EQUAL Sentence
138            if (resolver.getCandidate(i).getIp().equals(bestLocalCandidate.getIp())
139                    && resolver.getCandidate(i).getPort() == bestLocalCandidate.getPort()) {
140                acceptedLocalCandidate = resolver.getCandidate(i);
141                return;
142            }
143        }
144        LOGGER.fine("BEST: ip=" + bestLocalCandidate.getIp() + " port=" + bestLocalCandidate.getPort() + " has not been offered.");
145        //throw new XMPPException("Local transport candidate has not be offered.");
146    }
147
148    /**
149     * Get the best accepted local candidate we have offered.
150     *
151     * @return a transport candidate we have offered.
152     */
153    public TransportCandidate getAcceptedLocalCandidate() {
154        return acceptedLocalCandidate;
155    }
156
157    /**
158     *  Called from above to start the negotiator during a session-initiate.
159     */
160    protected void doStart() {
161
162        try {
163            sendTransportCandidatesOffer();
164            setNegotiatorState(JingleNegotiatorState.PENDING);
165        } catch (Exception e) {
166            // TODO Auto-generated catch block
167            e.printStackTrace();
168        }
169
170    }
171
172    /**
173     * Called from above to session-terminate.
174     */
175    public void close() {
176        super.close();
177
178    }
179
180    /**
181     *  Return a JingleTransport that best reflects this transport negotiator.
182     */
183    public JingleTransport getJingleTransport() {
184        return getJingleTransport(getBestRemoteCandidate());
185    }
186
187    public List<TransportCandidate> getOfferedCandidates() {
188        return offeredCandidates;
189    }
190
191    /**
192     * Obtain the best common transport candidate obtained in the negotiation.
193     *
194     * @return the bestRemoteCandidate
195     */
196    public abstract TransportCandidate getBestRemoteCandidate();
197
198    /**
199     * Get the list of remote candidates.
200     *
201     * @return the remoteCandidates
202     */
203    private List<TransportCandidate> getRemoteCandidates() {
204        return remoteCandidates;
205    }
206
207    /**
208     * Add a remote candidate to the list. The candidate will be checked in
209     * order to verify if it is usable.
210     *
211     * @param rc a remote candidate to add and check.
212     */
213    private void addRemoteCandidate(TransportCandidate rc) {
214        // Add the candidate to the list
215        if (rc != null) {
216            if (acceptableTransportCandidate(rc, offeredCandidates)) {
217                synchronized (remoteCandidates) {
218                    remoteCandidates.add(rc);
219                }
220
221                // Check if the new candidate can be used.
222                checkRemoteCandidate(rc);
223            }
224        }
225    }
226
227    /**
228     * Add a offered candidate to the list.
229     *
230     * @param rc a remote candidate we have offered.
231     */
232    private void addOfferedCandidate(TransportCandidate rc) {
233        // Add the candidate to the list
234        if (rc != null) {
235            synchronized (offeredCandidates) {
236                offeredCandidates.add(rc);
237            }
238        }
239    }
240
241    /**
242     * Check asynchronously the new transport candidate.
243     *
244     * @param offeredCandidate a transport candidates to check
245     */
246    private void checkRemoteCandidate(final TransportCandidate offeredCandidate) {
247        offeredCandidate.addListener(new TransportResolverListener.Checker() {
248            public void candidateChecked(TransportCandidate cand, final boolean validCandidate) {
249                if (validCandidate) {
250                    if (getNegotiatorState() == JingleNegotiatorState.PENDING)
251                        addValidRemoteCandidate(offeredCandidate);
252                }
253            }
254
255            public void candidateChecking(TransportCandidate cand) {
256            }
257
258        });
259        offeredCandidate.check(resolver.getCandidatesList());
260    }
261
262    /**
263     * Return true if the transport is established.
264     *
265     * @return true if the transport is established.
266     */
267    private boolean isEstablished() {
268        return getBestRemoteCandidate() != null && getAcceptedLocalCandidate() != null;
269    }
270
271    /**
272     * Return true if the transport is fully established.
273     *
274     * @return true if the transport is fully established.
275     */
276    public final boolean isFullyEstablished() {
277        return (isEstablished() && ((getNegotiatorState() == JingleNegotiatorState.SUCCEEDED) || (getNegotiatorState() == JingleNegotiatorState.FAILED)));
278    }
279
280    /**
281     * Launch a thread that checks, after some time, if any of the candidates
282     * offered by the other endpoint is usable. The thread does not check the
283     * candidates: it just checks if we have got a valid one and sends an Accept
284     * in that case.
285     */
286    private void delayedCheckBestCandidate(final JingleSession js, final Jingle jin) {
287        //
288        // If this is the first insertion in the list, start the thread that
289        // will send the result of our checks...
290        //
291        if (resultThread == null && !getRemoteCandidates().isEmpty()) {
292            resultThread = new Thread(new Runnable() {
293
294                public void run() {
295
296                    // Sleep for some time, waiting for the candidates checks
297
298                    int totalTime = (CANDIDATES_ACCEPT_PERIOD + TransportResolver.CHECK_TIMEOUT);
299                    int tries = (int) Math.ceil(totalTime / 1000);
300
301                    for (int i = 0; i < tries - 1; i++) {
302                        try {
303                            Thread.sleep(1000);
304                        } catch (InterruptedException e) {
305                            e.printStackTrace();
306                        }
307
308                        // Once we are in pending state, look for any valid remote
309                        // candidate, and send an "accept" if we have one...
310                        TransportCandidate bestRemote = getBestRemoteCandidate();
311                        //State state = getState();
312
313                        if ((bestRemote != null)
314                                && ((getNegotiatorState() == JingleNegotiatorState.PENDING))) {
315                            // Accepting the remote candidate
316                            if (!acceptedRemoteCandidates.contains(bestRemote)) {
317                                Jingle jout = new Jingle(JingleActionEnum.CONTENT_ACCEPT);
318                                JingleContent content = parentNegotiator.getJingleContent();
319                                content.addJingleTransport(getJingleTransport(bestRemote));
320                                jout.addContent(content);
321
322                                // Send the packet
323                                try {
324                                    js.sendFormattedJingle(jin, jout);
325                                }
326                                catch (NotConnectedException e) {
327                                    throw new IllegalStateException(e);
328                                }
329                                acceptedRemoteCandidates.add(bestRemote);
330                            }
331                            if ((isEstablished()) && (getNegotiatorState() == JingleNegotiatorState.PENDING)) {
332                                setNegotiatorState(JingleNegotiatorState.SUCCEEDED);
333                                try {
334                                    triggerTransportEstablished(getAcceptedLocalCandidate(), bestRemote);
335                                }
336                                catch (NotConnectedException e) {
337                                    throw new IllegalStateException(e);
338                                }
339                                break;
340                            }
341                        }
342                    }
343
344                    // Once we are in pending state, look for any valid remote
345                    // candidate, and send an "accept" if we have one...
346                    TransportCandidate bestRemote = getBestRemoteCandidate();
347
348                    if (bestRemote == null) {
349                        boolean foundRemoteRelay = false;
350                        for (TransportCandidate candidate : remoteCandidates) {
351                            if (candidate instanceof ICECandidate) {
352                                ICECandidate iceCandidate = (ICECandidate) candidate;
353                                if (iceCandidate.getType().equals("relay")) {
354                                    //TODO Check if the relay is reacheable
355                                    addValidRemoteCandidate(iceCandidate);
356                                    foundRemoteRelay = true;
357                                }
358                            }
359                        }
360
361                        // If not found, check if we offered a relay. If yes, we should accept any remote candidate.
362                        // We should accept the Public One if we received it, otherwise, accepts any.
363                        if (!foundRemoteRelay) {
364                            boolean foundLocalRelay = false;
365                            for (TransportCandidate candidate : offeredCandidates) {
366                                if (candidate instanceof ICECandidate) {
367                                    ICECandidate iceCandidate = (ICECandidate) candidate;
368                                    if (iceCandidate.getType().equals("relay")) {
369                                        foundLocalRelay = true;
370                                    }
371                                }
372                            }
373                            if (foundLocalRelay) {
374                                boolean foundRemotePublic = false;
375                                for (TransportCandidate candidate : remoteCandidates) {
376                                    if (candidate instanceof ICECandidate) {
377                                        ICECandidate iceCandidate = (ICECandidate) candidate;
378                                        if (iceCandidate.getType().equals(ICECandidate.Type.srflx)) {
379                                            addValidRemoteCandidate(iceCandidate);
380                                            foundRemotePublic = true;
381                                        }
382                                    }
383                                }
384                                if (!foundRemotePublic) {
385                                    for (TransportCandidate candidate : remoteCandidates) {
386                                        if (candidate instanceof ICECandidate) {
387                                            ICECandidate iceCandidate = (ICECandidate) candidate;
388                                            addValidRemoteCandidate(iceCandidate);
389                                        }
390                                    }
391                                }
392                            }
393                        }
394                    }
395
396                    for (int i = 0; i < 6; i++) {
397                        try {
398                            Thread.sleep(500);
399                        } catch (InterruptedException e) {
400                            e.printStackTrace();
401                        }
402
403                        bestRemote = getBestRemoteCandidate();
404                        //State state = getState();
405                        if ((bestRemote != null)
406                                && ((getNegotiatorState() == JingleNegotiatorState.PENDING))) {
407                            if (!acceptedRemoteCandidates.contains(bestRemote)) {
408                                Jingle jout = new Jingle(JingleActionEnum.CONTENT_ACCEPT);
409                                JingleContent content = parentNegotiator.getJingleContent();
410                                content.addJingleTransport(getJingleTransport(bestRemote));
411                                jout.addContent(content);
412
413                                // Send the packet
414                                try {
415                                    js.sendFormattedJingle(jin, jout);
416                                }
417                                catch (NotConnectedException e) {
418                                    throw new IllegalStateException(e);
419                                }
420                                acceptedRemoteCandidates.add(bestRemote);
421                            }
422                            if (isEstablished()) {
423                                setNegotiatorState(JingleNegotiatorState.SUCCEEDED);
424                                break;
425                            }
426                        }
427                    }
428
429                    if (getNegotiatorState() != JingleNegotiatorState.SUCCEEDED) {
430                        try {
431                            session
432                                    .terminate("Unable to negotiate session. This may be caused by firewall configuration problems.");
433                        } catch (Exception e) {
434                            e.printStackTrace();
435                        }
436                    }
437                }
438            }, "Waiting for all the transport candidates checks...");
439
440            resultThread.setName("Transport Resolver Result");
441            resultThread.start();
442        }
443    }
444
445    /**
446     * Add a valid remote candidate to the list. The remote candidate has been
447     * checked, and the remote
448     *
449     * @param remoteCandidate a remote candidate to add
450     */
451    private void addValidRemoteCandidate(TransportCandidate remoteCandidate) {
452        // Add the candidate to the list
453        if (remoteCandidate != null) {
454            synchronized (validRemoteCandidates) {
455                LOGGER.fine("Added valid candidate: " + remoteCandidate.getIp() + ":" + remoteCandidate.getPort());
456                validRemoteCandidates.add(remoteCandidate);
457            }
458        }
459    }
460
461    /**
462     * Get the list of valid (ie, checked) remote candidates.
463     *
464     * @return The list of valid (ie, already checked) remote candidates.
465     */
466    final ArrayList<TransportCandidate> getValidRemoteCandidatesList() {
467        synchronized (validRemoteCandidates) {
468            return new ArrayList<TransportCandidate>(validRemoteCandidates);
469        }
470    }
471
472    /**
473     * Get an iterator for the list of valid (ie, checked) remote candidates.
474     *
475     * @return The iterator for the list of valid (ie, already checked) remote
476     *         candidates.
477     */
478    public final Iterator<TransportCandidate> getValidRemoteCandidates() {
479        return Collections.unmodifiableList(getRemoteCandidates()).iterator();
480    }
481
482    /**
483     * Add an offered remote candidate. The transport candidate can be unusable:
484     * we must check if we can use it.
485     *
486     * @param rc the remote candidate to add.
487     */
488    private void addRemoteCandidates(List<TransportCandidate> rc) {
489        if (rc != null) {
490            if (rc.size() > 0) {
491                for (TransportCandidate aRc : rc) {
492                    addRemoteCandidate(aRc);
493                }
494            }
495        }
496    }
497
498    /**
499     * Parse the list of transport candidates from a Jingle packet.
500     *
501     * @param jin The input jingle packet
502     */
503    private List<TransportCandidate> obtainCandidatesList(Jingle jingle) {
504        List<TransportCandidate> result = new ArrayList<TransportCandidate>();
505
506        if (jingle != null) {
507            // Get the list of candidates from the packet
508            for (JingleContent jingleContent : jingle.getContentsList()) {
509                if (jingleContent.getName().equals(parentNegotiator.getName())) {
510                    for (JingleTransport jingleTransport : jingleContent.getJingleTransportsList()) {
511                        for (JingleTransportCandidate jingleTransportCandidate : jingleTransport.getCandidatesList()) {
512                            TransportCandidate transCand = jingleTransportCandidate.getMediaTransport();
513                            result.add(transCand);
514                        }
515                    }
516                }
517            }
518        }
519
520        return result;
521    }
522
523    /**
524     * Send an offer for a transport candidate
525     *
526     * @param cand
527     * @throws NotConnectedException 
528     */
529    private synchronized void sendTransportCandidateOffer(TransportCandidate cand) throws NotConnectedException {
530        if (!cand.isNull()) {
531            // Offer our new candidate...
532            addOfferedCandidate(cand);
533            JingleContent content = parentNegotiator.getJingleContent();
534            content.addJingleTransport(getJingleTransport(cand));
535            Jingle jingle = new Jingle(JingleActionEnum.TRANSPORT_INFO);
536            jingle.addContent(content);
537
538            // We SHOULD NOT be sending packets directly.
539            // This circumvents the state machinery.
540            // TODO - work this into the state machinery.
541            session.sendFormattedJingle(jingle);
542        }
543    }
544
545    /**
546     * Create a Jingle stanza(/packet) where we announce our transport candidates.
547     *
548     * @throws XMPPException
549     * @throws SmackException 
550     */
551    private void sendTransportCandidatesOffer() throws XMPPException, SmackException {
552        List<TransportCandidate> notOffered = resolver.getCandidatesList();
553
554        notOffered.removeAll(offeredCandidates);
555
556        // Send any unset candidate
557        for (Object aNotOffered : notOffered) {
558            sendTransportCandidateOffer((TransportCandidate) aNotOffered);
559        }
560
561        // .. and start a listener that will send any future candidate
562        if (resolverListener == null) {
563            // Add a listener that sends the offer when the resolver finishes...
564            resolverListener = new TransportResolverListener.Resolver() {
565                public void candidateAdded(TransportCandidate cand) throws NotConnectedException {
566                    sendTransportCandidateOffer(cand);
567                }
568
569                public void end() {
570                }
571
572                public void init() {
573                }
574            };
575
576            resolver.addListener(resolverListener);
577        }
578
579        if (!(resolver.isResolving() || resolver.isResolved())) {
580            // Resolve our IP and port
581            LOGGER.fine("RESOLVER CALLED");
582            resolver.resolve(session);
583        }
584    }
585
586    /**
587     * Dispatch an incoming packet. The method is responsible for recognizing
588     * the stanza(/packet) type and, depending on the current state, deliverying the
589     * stanza(/packet) to the right event handler and wait for a response.
590     *
591     * @param iq the stanza(/packet) received
592     * @return the new Jingle stanza(/packet) to send.
593     * @throws XMPPException
594     * @throws SmackException 
595     */
596    public final List<IQ> dispatchIncomingPacket(IQ iq, String id) throws XMPPException, SmackException {
597        List<IQ> responses = new ArrayList<IQ>();
598        IQ response = null;
599
600        if (iq != null) {
601            if (iq.getType().equals(IQ.Type.error)) {
602                // Process errors
603                setNegotiatorState(JingleNegotiatorState.FAILED);
604                triggerTransportClosed(null);
605                // This next line seems wrong, and may subvert the normal closing process.
606                throw new JingleException(iq.getError().getDescriptiveText());
607            } else if (iq.getType().equals(IQ.Type.result)) {
608                // Process ACKs
609                if (isExpectedId(iq.getStanzaId())) {
610                    response = receiveResult(iq);
611                    removeExpectedId(iq.getStanzaId());
612                }
613            } else if (iq instanceof Jingle) {
614                // Get the action from the Jingle packet
615                Jingle jingle = (Jingle) iq;
616                JingleActionEnum action = jingle.getAction();
617
618                switch (action) {
619                    case CONTENT_ACCEPT:
620                        response = receiveContentAcceptAction(jingle);
621                        break;
622
623                    case CONTENT_MODIFY:
624                        break;
625
626                    case CONTENT_REMOVE:
627                        break;
628
629                    case SESSION_INFO:
630                        break;
631
632                    case SESSION_INITIATE:
633                        response = receiveSessionInitiateAction(jingle);
634                        break;
635
636                    case SESSION_ACCEPT:
637                        response = receiveSessionAcceptAction(jingle);
638                        break;
639
640                    case TRANSPORT_INFO:
641                        response = receiveTransportInfoAction(jingle);
642                        break;
643
644                    default:
645                        break;
646                }
647            }
648        }
649
650        if (response != null) {
651            addExpectedId(response.getStanzaId());
652            responses.add(response);
653        }
654
655        return responses;
656    }
657
658    /**
659     * The other endpoint has partially accepted our invitation: start
660     * offering a list of candidates.
661     *
662     * @return an IQ packet
663     * @throws XMPPException
664     * @throws SmackException 
665     */
666    private Jingle receiveResult(IQ iq) throws XMPPException, SmackException {
667        Jingle response = null;
668
669        sendTransportCandidatesOffer();
670        setNegotiatorState(JingleNegotiatorState.PENDING);
671
672        return response;
673    }
674
675    /**
676     *  @param jingle
677     *  @param jingleTransport
678     *  @return the iq
679     * @throws SmackException 
680     */
681    private IQ receiveSessionInitiateAction(Jingle jingle) throws XMPPException, SmackException {
682        IQ response = null;
683
684        // Parse the Jingle and get any proposed transport candidates
685        //addRemoteCandidates(obtainCandidatesList(jin));
686
687        // Start offering candidates
688        sendTransportCandidatesOffer();
689
690        // All these candidates will be checked asyncronously. Wait for some
691        // time and check if we have a valid candidate to use...
692        delayedCheckBestCandidate(session, jingle);
693
694        // Set the next state
695        setNegotiatorState(JingleNegotiatorState.PENDING);
696
697        return response;
698    }
699
700    /**
701     *  @param jingle
702     *  @param jingleTransport
703     *  @return the iq
704     */
705    private IQ receiveTransportInfoAction(Jingle jingle) throws XMPPException {
706        IQ response = null;
707
708        // Parse the Jingle and get any proposed transport candidates
709        //addRemoteCandidates(obtainCandidatesList(jin));
710
711        //        // Start offering candidates
712        //        sendTransportCandidatesOffer();
713        //
714        //        // All these candidates will be checked asyncronously. Wait for some
715        //        // time and check if we have a valid candidate to use...
716        //        delayedCheckBestCandidate(session, jingle);
717        //
718        //        // Set the next state
719        //        setNegotiatorState(JingleNegotiatorState.PENDING);
720
721        // Parse the Jingle and get any proposed transport candidates
722        addRemoteCandidates(obtainCandidatesList(jingle));
723
724        // Wait for some time and check if we have a valid candidate to
725        // use...
726        delayedCheckBestCandidate(session, jingle);
727
728        response = session.createAck(jingle);
729
730        return response;
731    }
732
733    /**
734     * One of our transport candidates has been accepted.
735     *
736     * @param jin The input packet
737     * @return a Jingle packet
738     * @throws XMPPException an exception
739     * @see org.jivesoftware.smackx.jingleold.JingleNegotiator.State#eventAccept(org.jivesoftware.smackx.jingleold.packet.Jingle)
740     */
741    private IQ receiveContentAcceptAction(Jingle jingle) throws XMPPException {
742        IQ response = null;
743
744        // Parse the Jingle and get the accepted candidate
745        List<TransportCandidate> accepted = obtainCandidatesList(jingle);
746        if (!accepted.isEmpty()) {
747
748            for (TransportCandidate cand : accepted) {
749                LOGGER.fine("Remote acccepted candidate addr: " + cand.getIp());
750            }
751
752            TransportCandidate cand = (TransportCandidate) accepted.get(0);
753            setAcceptedLocalCandidate(cand);
754
755            if (isEstablished()) {
756                LOGGER.fine(cand.getIp() + " is set active");
757                //setNegotiatorState(JingleNegotiatorState.SUCCEEDED);
758            }
759        }
760        return response;
761    }
762
763    /**
764     *  @param jingle
765     *  @return the iq
766     */
767    private IQ receiveSessionAcceptAction(Jingle jingle) {
768        IQ response = null;
769
770        LOGGER.fine("Transport stabilished");
771        //triggerTransportEstablished(getAcceptedLocalCandidate(), getBestRemoteCandidate());
772
773        //setNegotiatorState(JingleNegotiatorState.SUCCEEDED);
774
775        return response;
776    }
777
778    /**
779     * Trigger a Transport session established event.
780     *
781     * @param local  TransportCandidate that has been agreed.
782     * @param remote TransportCandidate that has been agreed.
783     * @throws NotConnectedException 
784     */
785    private void triggerTransportEstablished(TransportCandidate local, TransportCandidate remote) throws NotConnectedException {
786        List<JingleListener> listeners = getListenersList();
787        for (JingleListener li : listeners) {
788            if (li instanceof JingleTransportListener) {
789                JingleTransportListener mli = (JingleTransportListener) li;
790                LOGGER.fine("triggerTransportEstablished " + local.getLocalIp() + ":" + local.getPort() + " <-> "
791                        + remote.getIp() + ":" + remote.getPort());
792                mli.transportEstablished(local, remote);
793            }
794        }
795    }
796
797    /**
798     * Trigger a Transport closed event.
799     *
800     * @param cand current TransportCandidate that is cancelled.
801     */
802    private void triggerTransportClosed(TransportCandidate cand) {
803        List<JingleListener> listeners = getListenersList();
804        for (JingleListener li : listeners) {
805            if (li instanceof JingleTransportListener) {
806                JingleTransportListener mli = (JingleTransportListener) li;
807                mli.transportClosed(cand);
808            }
809        }
810    }
811
812    // Subclasses
813
814    /**
815     * Raw-UDP transport negotiator
816     *
817     * @author Alvaro Saurin <alvaro.saurin@gmail.com>
818     */
819    public static final class RawUdp extends TransportNegotiator {
820
821        /**
822         * Default constructor, with a JingleSession and transport manager.
823         *
824         * @param js  The Jingle session this negotiation belongs to.
825         * @param res The transport resolver to use.
826         */
827        public RawUdp(JingleSession js, final TransportResolver res, ContentNegotiator parentNegotiator) {
828            super(js, res, parentNegotiator);
829        }
830
831        /**
832         * Get a TransportNegotiator instance.
833         */
834        public org.jivesoftware.smackx.jingleold.packet.JingleTransport getJingleTransport(TransportCandidate bestRemote) {
835            org.jivesoftware.smackx.jingleold.packet.JingleTransport.RawUdp jt = new org.jivesoftware.smackx.jingleold.packet.JingleTransport.RawUdp();
836            jt.addCandidate(new org.jivesoftware.smackx.jingleold.packet.JingleTransport.RawUdp.Candidate(bestRemote));
837            return jt;
838        }
839
840        /**
841         * Obtain the best common transport candidate obtained in the
842         * negotiation.
843         *
844         * @return the bestRemoteCandidate
845         */
846        public TransportCandidate getBestRemoteCandidate() {
847            // Hopefully, we only have one validRemoteCandidate
848            ArrayList<TransportCandidate> cands = getValidRemoteCandidatesList();
849            if (!cands.isEmpty()) {
850                LOGGER.fine("RAW CAND");
851                return (TransportCandidate) cands.get(0);
852            } else {
853                LOGGER.fine("No Remote Candidate");
854                return null;
855            }
856        }
857
858        /**
859         * Return true for fixed candidates.
860         */
861        public boolean acceptableTransportCandidate(TransportCandidate tc, List<TransportCandidate> localCandidates) {
862            return tc instanceof TransportCandidate.Fixed;
863        }
864    }
865
866    /**
867     * Ice transport negotiator.
868     *
869     * @author Alvaro Saurin <alvaro.saurin@gmail.com>
870     */
871    public static final class Ice extends TransportNegotiator {
872
873        /**
874         * Default constructor, with a JingleSession and transport manager.
875         *
876         * @param js  The Jingle session this negotiation belongs to.
877         * @param res The transport manager to use.
878         */
879        public Ice(JingleSession js, final TransportResolver res, ContentNegotiator parentNegotiator) {
880            super(js, res, parentNegotiator);
881        }
882
883        /**
884         * Get a TransportNegotiator instance.
885         *
886         * @param candidate
887         */
888        public org.jivesoftware.smackx.jingleold.packet.JingleTransport getJingleTransport(TransportCandidate candidate) {
889            org.jivesoftware.smackx.jingleold.packet.JingleTransport.Ice jt = new org.jivesoftware.smackx.jingleold.packet.JingleTransport.Ice();
890            jt.addCandidate(new org.jivesoftware.smackx.jingleold.packet.JingleTransport.Ice.Candidate(candidate));
891            return jt;
892        }
893
894        /**
895         * Obtain the best remote candidate obtained in the negotiation so far.
896         *
897         * @return the bestRemoteCandidate
898         */
899        public TransportCandidate getBestRemoteCandidate() {
900            ICECandidate result = null;
901
902            ArrayList<TransportCandidate> cands = getValidRemoteCandidatesList();
903            if (!cands.isEmpty()) {
904                int highest = -1;
905                ICECandidate chose = null;
906                for (TransportCandidate transportCandidate : cands) {
907                                        if (transportCandidate instanceof ICECandidate) {
908                                                ICECandidate icecandidate = (ICECandidate) transportCandidate;
909                                                if (icecandidate.getPreference() > highest) {
910                                                        chose = icecandidate;
911                                                        highest = icecandidate.getPreference();
912                                                }
913                    }
914                }
915                result = chose;
916            }
917
918            if (result != null && result.getType().equals("relay"))
919                LOGGER.fine("Relay Type");
920
921            return result;
922        }
923
924        /**
925         * Return true for ICE candidates.
926         */
927        public boolean acceptableTransportCandidate(TransportCandidate tc, List<TransportCandidate> localCandidates) {
928            return tc instanceof ICECandidate;
929        }
930    }
931}