blob: 1e889f1033feddb95820ec7fa53245b75f1d7d37 (
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
/*
* 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.util.*;
import net.java.sip.communicator.impl.protocol.jabber.extensions.jingle.*;
import net.java.sip.communicator.service.neomedia.*;
import net.java.sip.communicator.service.protocol.*;
/**
* A {@link TransportManagerJabberImpl} implementation that would only gather a
* single candidate pair (i.e. RTP and RTCP).
*
* @author Emil Ivov
*/
public class RawUdpTransportManager
extends TransportManagerJabberImpl
{
/**
* This is where we keep our answer between the time we get the offer and
* are ready with the answer;
*/
private List<ContentPacketExtension> cpeList;
/**
* 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 RawUdpTransportManager(CallPeerJabberImpl callPeer)
{
super(callPeer);
}
/**
* 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 void startCandidateHarvest(List<ContentPacketExtension> theirOffer,
List<ContentPacketExtension> ourAnswer)
throws OperationFailedException
{
for(ContentPacketExtension content : theirOffer)
{
RtpDescriptionPacketExtension rtpDesc
= (RtpDescriptionPacketExtension)content
.getFirstChildOfType(RtpDescriptionPacketExtension.class);
StreamConnector connector = getStreamConnector(
MediaType.parseString( rtpDesc.getMedia()));
RawUdpTransportPacketExtension ourTransport
= createTransport(connector);
//now add our transport to our answer
ContentPacketExtension cpExt
= findContentByName(ourAnswer, content.getName());
//it might be that we decided not to reply to this content
if(cpExt == null)
continue;
cpExt.addChildExtension(ourTransport);
}
this.cpeList = ourAnswer;
}
/**
* 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 ourAnswer the content list that should tell us how many stream
* connectors we actually need.
*
* @throws OperationFailedException in case we fail allocating ports
*/
public void startCandidateHarvest(
List<ContentPacketExtension> ourAnswer)
throws OperationFailedException
{
for(ContentPacketExtension content : ourAnswer)
{
RtpDescriptionPacketExtension rtpDesc
= (RtpDescriptionPacketExtension)content
.getFirstChildOfType(RtpDescriptionPacketExtension.class);
StreamConnector connector = getStreamConnector(
MediaType.parseString( rtpDesc.getMedia()));
RawUdpTransportPacketExtension ourTransport
= createTransport(connector);
//now add our transport to our answer
ContentPacketExtension cpExt
= findContentByName(ourAnswer, content.getName());
cpExt.addChildExtension(ourTransport);
}
this.cpeList = ourAnswer;
}
/**
* Creates a raw udp transport element according to the specified stream
* <tt>connector</tt>
*
* @param connector the connector that we'd like to describe within the
* transport element.
*
* @return a {@link RawUdpTransportPacketExtension} containing the RTP and
* RTCP candidates of the specified {@link StreamConnector}.
*/
private RawUdpTransportPacketExtension createTransport(
StreamConnector connector)
{
RawUdpTransportPacketExtension ourTransport
= new RawUdpTransportPacketExtension();
// create and add candidates that correspond to the stream connector
// rtp
CandidatePacketExtension rtpCand = new CandidatePacketExtension();
rtpCand.setComponent(CandidatePacketExtension.RTP_COMPONENT_ID);
rtpCand.setGeneration(getCurrentGeneration());
rtpCand.setID(getNextID());
rtpCand.setIP(connector.getDataSocket().getLocalAddress()
.getHostAddress());
rtpCand.setPort(connector.getDataSocket().getLocalPort());
rtpCand.setType(CandidateType.host);
ourTransport.addCandidate(rtpCand);
// rtcp
CandidatePacketExtension rtcpCand = new CandidatePacketExtension();
rtcpCand.setComponent(CandidatePacketExtension.RTCP_COMPONENT_ID);
rtcpCand.setGeneration(getCurrentGeneration());
rtcpCand.setID(getNextID());
rtcpCand.setIP(connector.getControlSocket().getLocalAddress()
.getHostAddress());
rtcpCand.setPort(connector.getControlSocket().getLocalPort());
rtcpCand.setType(CandidateType.host);
ourTransport.addCandidate(rtcpCand);
return ourTransport;
}
/**
* Simply returns the list of local candidates that we gathered during the
* harvest. This is a raw udp transport manager so there's no real wraping
* up to do.
*
* @return the list of local candidates that we gathered during the
* harvest.
*/
public List<ContentPacketExtension> wrapupHarvest()
{
return cpeList;
}
/**
* Looks through the <tt>cpExtList</tt> and returns the {@link
* ContentPacketExtension} with the specified name.
*
* @param cpExtList the list that we will be searching for a specific
* content.
* @param name the name of the content element we are looking for.
* @return the {@link ContentPacketExtension} with the specified name or
* <tt>null</tt> if no such content element exists.
*/
private ContentPacketExtension findContentByName(
List<ContentPacketExtension> cpExtList,
String name)
{
for(ContentPacketExtension cpExt : cpExtList)
{
if(cpExt.getName().equals(name))
return cpExt;
}
return null;
}
}
|
