blob: 1fd8f51799978aafb66f2fb9f2c4f68718884676 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
/*
* SIP Communicator, the OpenSource Java VoIP and Instant Messaging client.
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package net.java.sip.communicator.impl.protocol.jabber;
import java.net.*;
import java.util.*;
import net.java.sip.communicator.impl.protocol.jabber.extensions.jingle.*;
import net.java.sip.communicator.service.protocol.*;
import net.java.sip.communicator.service.protocol.media.*;
/**
* <tt>TransportManager</tt>s gather local candidates for incoming and outgoing
* calls. Their work starts by calling a start method which, using the remote
* peer's session description, would start the harvest. Calling a second wrapup
* method would deliver the candidate harvest, possibly after blocking if
* it has not yet completed.
*
* @author Emil Ivov
*/
public abstract class TransportManagerJabberImpl
extends TransportManager<CallPeerJabberImpl>
{
/**
* The generation of the candidates we are currently generating
*/
private int currentGeneration = 0;
/**
* The ID that we will be assigning to our next candidate. We use
* <tt>int</tt>s for interoperability reasons (Emil: I believe that GTalk
* uses <tt>int</tt>s. If that turns out not to be the case we can stop
* using <tt>int</tt>s here if that's an issue).
*/
private static int nextID = 1;
/**
* Creates a new instance of this transport manager, binding it to the
* specified peer.
*
* @param callPeer the {@link CallPeer} whose traffic we will be taking
* care of.
*/
protected TransportManagerJabberImpl(CallPeerJabberImpl callPeer)
{
super(callPeer);
}
/**
* Returns the <tt>InetAddress</tt> that is most likely to be to be used
* as a next hop when contacting the specified <tt>destination</tt>. This is
* an utility method that is used whenever we have to choose one of our
* local addresses to put in the Via, Contact or (in the case of no
* registrar accounts) From headers.
*
* @param peer the CallPeer that we would contact.
*
* @return the <tt>InetAddress</tt> that is most likely to be to be used
* as a next hop when contacting the specified <tt>destination</tt>.
*
* @throws IllegalArgumentException if <tt>destination</tt> is not a valid
* host/IP/FQDN
*/
@Override
protected InetAddress getIntendedDestination(CallPeerJabberImpl peer)
{
return peer.getProtocolProvider().getNextHop();
}
/**
* Returns the ID that we will be assigning to the next candidate we create.
*
* @return the next ID to use with a candidate.
*/
protected String getNextID()
{
return Integer.toString(nextID++);
}
/**
* Returns the generation that our current candidates belong to.
*
* @return the generation that we should assign to candidates that we are
* currently advertising.
*/
protected int getCurrentGeneration()
{
return currentGeneration;
}
/**
* Increments the generation that we are assigning candidates.
*/
protected void incrementGeneration()
{
currentGeneration++;
}
/**
* Starts transport candidate harvest. This method should complete rapidly
* and, in case of lengthy procedures like STUN/TURN/UPnP candidate harvests
* are necessary, they should be executed in a separate thread. Candidate
* harvest would then need to be concluded in the {@link #wrapupHarvest()}
* method which would be called once we absolutely need the candidates.
*
* @param theirOffer a media description offer that we've received from the
* remote party and that we should use in case we need to know what
* transports our peer is using.
* @param ourAnswer the content descriptions that we should be adding our
* transport lists to (although not necessarily in this very instance).
*
* @throws OperationFailedException if we fail to allocate a port number.
*/
public abstract void startCandidateHarvest(
List<ContentPacketExtension> theirOffer,
List<ContentPacketExtension> ourAnswer)
throws OperationFailedException;
/**
* Starts transport candidate harvest. This method should complete rapidly
* and, in case of lengthy procedures like STUN/TURN/UPnP candidate harvests
* are necessary, they should be executed in a separate thread. Candidate
* harvest would then need to be concluded in the {@link #wrapupHarvest()}
* method which would be called once we absolutely need the candidates.
*
* @param ourOffer the content descriptions that we should be adding our
* transport lists to (although not necessarily in this very instance).
*
* @throws OperationFailedException if we fail to allocate a port number.
*/
public abstract void startCandidateHarvest(
List<ContentPacketExtension> ourOffer)
throws OperationFailedException;
/**
* Notifies the transport manager that it should conclude candidate
* harvesting as soon as possible an return the lists of candidates
* gathered so far.
*
* @return the content list that we received earlier (possibly cloned into
* a new instance) and that we have updated with transport lists.
*/
public abstract List<ContentPacketExtension> wrapupHarvest();
}
|
