blob: 4e0739b26bf033960570c22012b34089bb30f74f [file] [log] [blame]
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001/*
kjellanderb24317b2016-02-10 07:54:43 -08002 * Copyright 2012 The WebRTC project authors. All Rights Reserved.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003 *
kjellanderb24317b2016-02-10 07:54:43 -08004 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00009 */
10
11// This file contains the PeerConnection interface as defined in
12// http://dev.w3.org/2011/webrtc/editor/webrtc.html#peer-to-peer-connections.
13// Applications must use this interface to implement peerconnection.
14// PeerConnectionFactory class provides factory methods to create
15// peerconnection, mediastream and media tracks objects.
16//
17// The Following steps are needed to setup a typical call using Jsep.
18// 1. Create a PeerConnectionFactoryInterface. Check constructors for more
19// information about input parameters.
20// 2. Create a PeerConnection object. Provide a configuration string which
21// points either to stun or turn server to generate ICE candidates and provide
22// an object that implements the PeerConnectionObserver interface.
23// 3. Create local MediaStream and MediaTracks using the PeerConnectionFactory
24// and add it to PeerConnection by calling AddStream.
25// 4. Create an offer and serialize it and send it to the remote peer.
26// 5. Once an ice candidate have been found PeerConnection will call the
27// observer function OnIceCandidate. The candidates must also be serialized and
28// sent to the remote peer.
29// 6. Once an answer is received from the remote peer, call
30// SetLocalSessionDescription with the offer and SetRemoteSessionDescription
31// with the remote answer.
32// 7. Once a remote candidate is received from the remote peer, provide it to
33// the peerconnection by calling AddIceCandidate.
34
35
36// The Receiver of a call can decide to accept or reject the call.
37// This decision will be taken by the application not peerconnection.
38// If application decides to accept the call
39// 1. Create PeerConnectionFactoryInterface if it doesn't exist.
40// 2. Create a new PeerConnection.
41// 3. Provide the remote offer to the new PeerConnection object by calling
42// SetRemoteSessionDescription.
43// 4. Generate an answer to the remote offer by calling CreateAnswer and send it
44// back to the remote peer.
45// 5. Provide the local answer to the new PeerConnection by calling
46// SetLocalSessionDescription with the answer.
47// 6. Provide the remote ice candidates by calling AddIceCandidate.
48// 7. Once a candidate have been found PeerConnection will call the observer
49// function OnIceCandidate. Send these candidates to the remote peer.
50
Henrik Kjellander15583c12016-02-10 10:53:12 +010051#ifndef WEBRTC_API_PEERCONNECTIONINTERFACE_H_
52#define WEBRTC_API_PEERCONNECTIONINTERFACE_H_
henrike@webrtc.org28e20752013-07-10 00:45:36 +000053
kwibergd1fe2812016-04-27 06:47:29 -070054#include <memory>
deadbeef3edec7c2016-12-10 11:44:26 -080055#include <ostream>
henrike@webrtc.org28e20752013-07-10 00:45:36 +000056#include <string>
kwiberg0eb15ed2015-12-17 03:04:15 -080057#include <utility>
henrike@webrtc.org28e20752013-07-10 00:45:36 +000058#include <vector>
59
Henrik Kjellander15583c12016-02-10 10:53:12 +010060#include "webrtc/api/datachannelinterface.h"
Henrik Kjellander15583c12016-02-10 10:53:12 +010061#include "webrtc/api/dtmfsenderinterface.h"
62#include "webrtc/api/jsep.h"
63#include "webrtc/api/mediastreaminterface.h"
hbos74e1a4f2016-09-15 23:33:01 -070064#include "webrtc/api/rtcstatscollector.h"
Henrik Kjellander15583c12016-02-10 10:53:12 +010065#include "webrtc/api/rtpreceiverinterface.h"
66#include "webrtc/api/rtpsenderinterface.h"
67#include "webrtc/api/statstypes.h"
68#include "webrtc/api/umametrics.h"
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000069#include "webrtc/base/fileutils.h"
phoglund@webrtc.org006521d2015-02-12 09:23:59 +000070#include "webrtc/base/network.h"
Henrik Boström87713d02015-08-25 09:53:21 +020071#include "webrtc/base/rtccertificate.h"
Henrik Boströmd03c23b2016-06-01 11:44:18 +020072#include "webrtc/base/rtccertificategenerator.h"
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000073#include "webrtc/base/socketaddress.h"
kjellandera96e2d72016-02-04 23:52:28 -080074#include "webrtc/base/sslstreamadapter.h"
nissec36b31b2016-04-11 23:25:29 -070075#include "webrtc/media/base/mediachannel.h"
deadbeef41b07982015-12-01 15:01:24 -080076#include "webrtc/p2p/base/portallocator.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000077
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000078namespace rtc {
jiayl@webrtc.org61e00b02015-03-04 22:17:38 +000079class SSLIdentity;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000080class Thread;
81}
82
83namespace cricket {
henrike@webrtc.org28e20752013-07-10 00:45:36 +000084class WebRtcVideoDecoderFactory;
85class WebRtcVideoEncoderFactory;
86}
87
88namespace webrtc {
89class AudioDeviceModule;
gyzhou95aa9642016-12-13 14:06:26 -080090class AudioMixer;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000091class MediaConstraintsInterface;
92
93// MediaStream container interface.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000094class StreamCollectionInterface : public rtc::RefCountInterface {
henrike@webrtc.org28e20752013-07-10 00:45:36 +000095 public:
96 // TODO(ronghuawu): Update the function names to c++ style, e.g. find -> Find.
97 virtual size_t count() = 0;
98 virtual MediaStreamInterface* at(size_t index) = 0;
99 virtual MediaStreamInterface* find(const std::string& label) = 0;
100 virtual MediaStreamTrackInterface* FindAudioTrack(
101 const std::string& id) = 0;
102 virtual MediaStreamTrackInterface* FindVideoTrack(
103 const std::string& id) = 0;
104
105 protected:
106 // Dtor protected as objects shouldn't be deleted via this interface.
107 ~StreamCollectionInterface() {}
108};
109
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000110class StatsObserver : public rtc::RefCountInterface {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000111 public:
nisseb36ee8d2016-12-20 03:30:00 -0800112 // TODO(nisse, hbos): Old version, not passing ownership. Should
113 // perhaps be deprecated, but since all of this is a legacy
114 // interface anyway, probably best to leave as is until this class
115 // can be deleted.
116 virtual void OnComplete(const StatsReports& reports) {}
117 virtual void OnCompleteReports(std::unique_ptr<StatsReports> reports) {
118 OnComplete(*reports);
119 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000120
121 protected:
122 virtual ~StatsObserver() {}
123};
124
deadbeef3edec7c2016-12-10 11:44:26 -0800125// Enumeration to represent distinct classes of errors that an application
deadbeef293e9262017-01-11 12:28:30 -0800126// may wish to act upon differently. These roughly map to DOMExceptions or
127// RTCError "errorDetailEnum" values in the web API, as described in the
128// comments below.
129enum class RTCErrorType {
deadbeef3edec7c2016-12-10 11:44:26 -0800130 // No error.
131 NONE,
132 // A supplied parameter is valid, but currently unsupported.
133 // Maps to InvalidAccessError DOMException.
134 UNSUPPORTED_PARAMETER,
135 // General error indicating that a supplied parameter is invalid.
136 // Maps to InvalidAccessError or TypeError DOMException depending on context.
137 INVALID_PARAMETER,
138 // Slightly more specific than INVALID_PARAMETER; a parameter's value was
139 // outside the allowed range.
140 // Maps to RangeError DOMException.
141 INVALID_RANGE,
142 // Slightly more specific than INVALID_PARAMETER; an error occurred while
143 // parsing string input.
144 // Maps to SyntaxError DOMException.
145 SYNTAX_ERROR,
146 // The object does not support this operation in its current state.
147 // Maps to InvalidStateError DOMException.
148 INVALID_STATE,
149 // An attempt was made to modify the object in an invalid way.
150 // Maps to InvalidModificationError DOMException.
151 INVALID_MODIFICATION,
152 // An error occurred within an underlying network protocol.
153 // Maps to NetworkError DOMException.
154 NETWORK_ERROR,
155 // The operation failed due to an internal error.
156 // Maps to OperationError DOMException.
157 INTERNAL_ERROR,
158};
159
deadbeef293e9262017-01-11 12:28:30 -0800160// Roughly corresponds to RTCError in the web api. Holds an error type and
161// possibly additional information specific to that error.
162//
163// Doesn't contain anything beyond a type now, but will in the future as more
164// errors are implemented.
165class RTCError {
166 public:
167 RTCError() : type_(RTCErrorType::NONE) {}
168 explicit RTCError(RTCErrorType type) : type_(type) {}
169
170 RTCErrorType type() const { return type_; }
171 void set_type(RTCErrorType type) { type_ = type; }
172
173 private:
174 RTCErrorType type_;
175};
176
deadbeef3edec7c2016-12-10 11:44:26 -0800177// Outputs the error as a friendly string.
178// Update this method when adding a new error type.
deadbeef293e9262017-01-11 12:28:30 -0800179std::ostream& operator<<(std::ostream& stream, RTCErrorType error);
deadbeef3edec7c2016-12-10 11:44:26 -0800180
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000181class PeerConnectionInterface : public rtc::RefCountInterface {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000182 public:
183 // See http://dev.w3.org/2011/webrtc/editor/webrtc.html#state-definitions .
184 enum SignalingState {
185 kStable,
186 kHaveLocalOffer,
187 kHaveLocalPrAnswer,
188 kHaveRemoteOffer,
189 kHaveRemotePrAnswer,
190 kClosed,
191 };
192
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000193 enum IceGatheringState {
194 kIceGatheringNew,
195 kIceGatheringGathering,
196 kIceGatheringComplete
197 };
198
199 enum IceConnectionState {
200 kIceConnectionNew,
201 kIceConnectionChecking,
202 kIceConnectionConnected,
203 kIceConnectionCompleted,
204 kIceConnectionFailed,
205 kIceConnectionDisconnected,
206 kIceConnectionClosed,
Guo-wei Shieh3d564c12015-08-19 16:51:15 -0700207 kIceConnectionMax,
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000208 };
209
hnsl04833622017-01-09 08:35:45 -0800210 // TLS certificate policy.
211 enum TlsCertPolicy {
212 // For TLS based protocols, ensure the connection is secure by not
213 // circumventing certificate validation.
214 kTlsCertPolicySecure,
215 // For TLS based protocols, disregard security completely by skipping
216 // certificate validation. This is insecure and should never be used unless
217 // security is irrelevant in that particular context.
218 kTlsCertPolicyInsecureNoCheck,
219 };
220
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000221 struct IceServer {
Joachim Bauch7c4e7452015-05-28 23:06:30 +0200222 // TODO(jbauch): Remove uri when all code using it has switched to urls.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000223 std::string uri;
Joachim Bauch7c4e7452015-05-28 23:06:30 +0200224 std::vector<std::string> urls;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000225 std::string username;
226 std::string password;
hnsl04833622017-01-09 08:35:45 -0800227 TlsCertPolicy tls_cert_policy = kTlsCertPolicySecure;
228
deadbeefd1a38b52016-12-10 13:15:33 -0800229 bool operator==(const IceServer& o) const {
230 return uri == o.uri && urls == o.urls && username == o.username &&
hnsl04833622017-01-09 08:35:45 -0800231 password == o.password && tls_cert_policy == o.tls_cert_policy;
deadbeefd1a38b52016-12-10 13:15:33 -0800232 }
233 bool operator!=(const IceServer& o) const { return !(*this == o); }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000234 };
235 typedef std::vector<IceServer> IceServers;
236
buildbot@webrtc.org41451d42014-05-03 05:39:45 +0000237 enum IceTransportsType {
pthatcher@webrtc.orgfd630a52015-01-14 23:19:06 +0000238 // TODO(pthatcher): Rename these kTransporTypeXXX, but update
239 // Chromium at the same time.
buildbot@webrtc.org41451d42014-05-03 05:39:45 +0000240 kNone,
241 kRelay,
242 kNoHost,
243 kAll
244 };
245
pthatcher@webrtc.orgfd630a52015-01-14 23:19:06 +0000246 // https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-08#section-4.1.1
247 enum BundlePolicy {
248 kBundlePolicyBalanced,
249 kBundlePolicyMaxBundle,
250 kBundlePolicyMaxCompat
251 };
buildbot@webrtc.org41451d42014-05-03 05:39:45 +0000252
Peter Thatcheraf55ccc2015-05-21 07:48:41 -0700253 // https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-09#section-4.1.1
254 enum RtcpMuxPolicy {
255 kRtcpMuxPolicyNegotiate,
256 kRtcpMuxPolicyRequire,
257 };
258
Jiayang Liucac1b382015-04-30 12:35:24 -0700259 enum TcpCandidatePolicy {
260 kTcpCandidatePolicyEnabled,
261 kTcpCandidatePolicyDisabled
262 };
263
honghaiz60347052016-05-31 18:29:12 -0700264 enum CandidateNetworkPolicy {
265 kCandidateNetworkPolicyAll,
266 kCandidateNetworkPolicyLowCost
267 };
268
honghaiz1f429e32015-09-28 07:57:34 -0700269 enum ContinualGatheringPolicy {
270 GATHER_ONCE,
271 GATHER_CONTINUALLY
272 };
273
Honghai Zhangf7ddc062016-09-01 15:34:01 -0700274 enum class RTCConfigurationType {
275 // A configuration that is safer to use, despite not having the best
276 // performance. Currently this is the default configuration.
277 kSafe,
278 // An aggressive configuration that has better performance, although it
279 // may be riskier and may need extra support in the application.
280 kAggressive
281 };
282
Henrik Boström87713d02015-08-25 09:53:21 +0200283 // TODO(hbos): Change into class with private data and public getters.
nissec36b31b2016-04-11 23:25:29 -0700284 // TODO(nisse): In particular, accessing fields directly from an
285 // application is brittle, since the organization mirrors the
286 // organization of the implementation, which isn't stable. So we
287 // need getters and setters at least for fields which applications
288 // are interested in.
pthatcher@webrtc.orgfd630a52015-01-14 23:19:06 +0000289 struct RTCConfiguration {
Niels Möller71bdda02016-03-31 12:59:59 +0200290 // This struct is subject to reorganization, both for naming
291 // consistency, and to group settings to match where they are used
292 // in the implementation. To do that, we need getter and setter
293 // methods for all settings which are of interest to applications,
294 // Chrome in particular.
295
Honghai Zhangf7ddc062016-09-01 15:34:01 -0700296 RTCConfiguration() = default;
297 RTCConfiguration(RTCConfigurationType type) {
298 if (type == RTCConfigurationType::kAggressive) {
Honghai Zhangaecd9822016-09-02 16:58:17 -0700299 // These parameters are also defined in Java and IOS configurations,
300 // so their values may be overwritten by the Java or IOS configuration.
301 bundle_policy = kBundlePolicyMaxBundle;
302 rtcp_mux_policy = kRtcpMuxPolicyRequire;
303 ice_connection_receiving_timeout =
304 kAggressiveIceConnectionReceivingTimeout;
305
306 // These parameters are not defined in Java or IOS configuration,
307 // so their values will not be overwritten.
308 enable_ice_renomination = true;
Honghai Zhangf7ddc062016-09-01 15:34:01 -0700309 redetermine_role_on_ice_restart = false;
310 }
Honghai Zhangbfd398c2016-08-30 22:07:42 -0700311 }
312
deadbeef293e9262017-01-11 12:28:30 -0800313 bool operator==(const RTCConfiguration& o) const;
314 bool operator!=(const RTCConfiguration& o) const;
315
nissec36b31b2016-04-11 23:25:29 -0700316 bool dscp() { return media_config.enable_dscp; }
317 void set_dscp(bool enable) { media_config.enable_dscp = enable; }
Niels Möller71bdda02016-03-31 12:59:59 +0200318
319 // TODO(nisse): The corresponding flag in MediaConfig and
320 // elsewhere should be renamed enable_cpu_adaptation.
nissec36b31b2016-04-11 23:25:29 -0700321 bool cpu_adaptation() {
322 return media_config.video.enable_cpu_overuse_detection;
323 }
Niels Möller71bdda02016-03-31 12:59:59 +0200324 void set_cpu_adaptation(bool enable) {
nissec36b31b2016-04-11 23:25:29 -0700325 media_config.video.enable_cpu_overuse_detection = enable;
Niels Möller71bdda02016-03-31 12:59:59 +0200326 }
327
nissec36b31b2016-04-11 23:25:29 -0700328 bool suspend_below_min_bitrate() {
329 return media_config.video.suspend_below_min_bitrate;
330 }
Niels Möller71bdda02016-03-31 12:59:59 +0200331 void set_suspend_below_min_bitrate(bool enable) {
nissec36b31b2016-04-11 23:25:29 -0700332 media_config.video.suspend_below_min_bitrate = enable;
Niels Möller71bdda02016-03-31 12:59:59 +0200333 }
334
335 // TODO(nisse): The negation in the corresponding MediaConfig
336 // attribute is inconsistent, and it should be renamed at some
337 // point.
nissec36b31b2016-04-11 23:25:29 -0700338 bool prerenderer_smoothing() {
339 return !media_config.video.disable_prerenderer_smoothing;
340 }
Niels Möller71bdda02016-03-31 12:59:59 +0200341 void set_prerenderer_smoothing(bool enable) {
nissec36b31b2016-04-11 23:25:29 -0700342 media_config.video.disable_prerenderer_smoothing = !enable;
Niels Möller71bdda02016-03-31 12:59:59 +0200343 }
344
honghaiz4edc39c2015-09-01 09:53:56 -0700345 static const int kUndefined = -1;
346 // Default maximum number of packets in the audio jitter buffer.
347 static const int kAudioJitterBufferMaxPackets = 50;
Honghai Zhangaecd9822016-09-02 16:58:17 -0700348 // ICE connection receiving timeout for aggressive configuration.
349 static const int kAggressiveIceConnectionReceivingTimeout = 1000;
pthatcher@webrtc.orgfd630a52015-01-14 23:19:06 +0000350 // TODO(pthatcher): Rename this ice_transport_type, but update
351 // Chromium at the same time.
Taylor Brandstettera1c30352016-05-13 08:15:11 -0700352 IceTransportsType type = kAll;
pthatcher@webrtc.orgfd630a52015-01-14 23:19:06 +0000353 // TODO(pthatcher): Rename this ice_servers, but update Chromium
354 // at the same time.
355 IceServers servers;
Taylor Brandstettera1c30352016-05-13 08:15:11 -0700356 BundlePolicy bundle_policy = kBundlePolicyBalanced;
zhihuang4dfb8ce2016-11-23 10:30:12 -0800357 RtcpMuxPolicy rtcp_mux_policy = kRtcpMuxPolicyRequire;
Taylor Brandstettera1c30352016-05-13 08:15:11 -0700358 TcpCandidatePolicy tcp_candidate_policy = kTcpCandidatePolicyEnabled;
honghaiz60347052016-05-31 18:29:12 -0700359 CandidateNetworkPolicy candidate_network_policy =
360 kCandidateNetworkPolicyAll;
Taylor Brandstettera1c30352016-05-13 08:15:11 -0700361 int audio_jitter_buffer_max_packets = kAudioJitterBufferMaxPackets;
362 bool audio_jitter_buffer_fast_accelerate = false;
363 int ice_connection_receiving_timeout = kUndefined; // ms
364 int ice_backup_candidate_pair_ping_interval = kUndefined; // ms
365 ContinualGatheringPolicy continual_gathering_policy = GATHER_ONCE;
Henrik Boström87713d02015-08-25 09:53:21 +0200366 std::vector<rtc::scoped_refptr<rtc::RTCCertificate>> certificates;
Taylor Brandstettera1c30352016-05-13 08:15:11 -0700367 bool prioritize_most_likely_ice_candidate_pairs = false;
nissec36b31b2016-04-11 23:25:29 -0700368 struct cricket::MediaConfig media_config;
htaa2a49d92016-03-04 02:51:39 -0800369 // Flags corresponding to values set by constraint flags.
370 // rtc::Optional flags can be "missing", in which case the webrtc
371 // default applies.
Taylor Brandstettera1c30352016-05-13 08:15:11 -0700372 bool disable_ipv6 = false;
373 bool enable_rtp_data_channel = false;
zhihuang9763d562016-08-05 11:14:50 -0700374 bool enable_quic = false;
htaa2a49d92016-03-04 02:51:39 -0800375 rtc::Optional<int> screencast_min_bitrate;
376 rtc::Optional<bool> combined_audio_video_bwe;
377 rtc::Optional<bool> enable_dtls_srtp;
Taylor Brandstettera1c30352016-05-13 08:15:11 -0700378 int ice_candidate_pool_size = 0;
Honghai Zhangb9e7b4a2016-06-30 20:52:02 -0700379 bool prune_turn_ports = false;
Taylor Brandstettere9851112016-07-01 11:11:13 -0700380 // If set to true, this means the ICE transport should presume TURN-to-TURN
381 // candidate pairs will succeed, even before a binding response is received.
382 bool presume_writable_when_fully_relayed = false;
Honghai Zhang4cedf2b2016-08-31 08:18:11 -0700383 // If true, "renomination" will be added to the ice options in the transport
384 // description.
385 bool enable_ice_renomination = false;
Honghai Zhangbfd398c2016-08-30 22:07:42 -0700386 // If true, ICE role is redetermined when peerconnection sets a local
387 // transport description that indicates an ICE restart.
388 bool redetermine_role_on_ice_restart = true;
deadbeef293e9262017-01-11 12:28:30 -0800389 //
390 // Don't forget to update operator== if adding something.
391 //
buildbot@webrtc.org41451d42014-05-03 05:39:45 +0000392 };
393
jiayl@webrtc.orgb18bf5e2014-08-04 18:34:16 +0000394 struct RTCOfferAnswerOptions {
395 static const int kUndefined = -1;
396 static const int kMaxOfferToReceiveMedia = 1;
397
398 // The default value for constraint offerToReceiveX:true.
399 static const int kOfferToReceiveMediaTrue = 1;
400
Honghai Zhang4cedf2b2016-08-31 08:18:11 -0700401 int offer_to_receive_video = kUndefined;
402 int offer_to_receive_audio = kUndefined;
403 bool voice_activity_detection = true;
404 bool ice_restart = false;
405 bool use_rtp_mux = true;
jiayl@webrtc.orgb18bf5e2014-08-04 18:34:16 +0000406
Honghai Zhang4cedf2b2016-08-31 08:18:11 -0700407 RTCOfferAnswerOptions() = default;
jiayl@webrtc.orgb18bf5e2014-08-04 18:34:16 +0000408
409 RTCOfferAnswerOptions(int offer_to_receive_video,
410 int offer_to_receive_audio,
411 bool voice_activity_detection,
412 bool ice_restart,
413 bool use_rtp_mux)
414 : offer_to_receive_video(offer_to_receive_video),
415 offer_to_receive_audio(offer_to_receive_audio),
416 voice_activity_detection(voice_activity_detection),
417 ice_restart(ice_restart),
418 use_rtp_mux(use_rtp_mux) {}
419 };
420
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000421 // Used by GetStats to decide which stats to include in the stats reports.
422 // |kStatsOutputLevelStandard| includes the standard stats for Javascript API;
423 // |kStatsOutputLevelDebug| includes both the standard stats and additional
424 // stats for debugging purposes.
425 enum StatsOutputLevel {
426 kStatsOutputLevelStandard,
427 kStatsOutputLevelDebug,
428 };
429
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000430 // Accessor methods to active local streams.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000431 virtual rtc::scoped_refptr<StreamCollectionInterface>
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000432 local_streams() = 0;
433
434 // Accessor methods to remote streams.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000435 virtual rtc::scoped_refptr<StreamCollectionInterface>
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000436 remote_streams() = 0;
437
438 // Add a new MediaStream to be sent on this PeerConnection.
439 // Note that a SessionDescription negotiation is needed before the
440 // remote peer can receive the stream.
perkj@webrtc.orgfd0efb62014-11-06 12:16:36 +0000441 virtual bool AddStream(MediaStreamInterface* stream) = 0;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000442
443 // Remove a MediaStream from this PeerConnection.
444 // Note that a SessionDescription negotiation is need before the
445 // remote peer is notified.
446 virtual void RemoveStream(MediaStreamInterface* stream) = 0;
447
deadbeefe1f9d832016-01-14 15:35:42 -0800448 // TODO(deadbeef): Make the following two methods pure virtual once
449 // implemented by all subclasses of PeerConnectionInterface.
450 // Add a new MediaStreamTrack to be sent on this PeerConnection.
451 // |streams| indicates which stream labels the track should be associated
452 // with.
453 virtual rtc::scoped_refptr<RtpSenderInterface> AddTrack(
454 MediaStreamTrackInterface* track,
455 std::vector<MediaStreamInterface*> streams) {
456 return nullptr;
457 }
458
459 // Remove an RtpSender from this PeerConnection.
460 // Returns true on success.
461 virtual bool RemoveTrack(RtpSenderInterface* sender) {
462 return false;
463 }
464
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000465 // Returns pointer to the created DtmfSender on success.
466 // Otherwise returns NULL.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000467 virtual rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000468 AudioTrackInterface* track) = 0;
469
deadbeef70ab1a12015-09-28 16:53:55 -0700470 // TODO(deadbeef): Make these pure virtual once all subclasses implement them.
deadbeeffac06552015-11-25 11:26:01 -0800471 // |kind| must be "audio" or "video".
deadbeefbd7d8f72015-12-18 16:58:44 -0800472 // |stream_id| is used to populate the msid attribute; if empty, one will
473 // be generated automatically.
deadbeeffac06552015-11-25 11:26:01 -0800474 virtual rtc::scoped_refptr<RtpSenderInterface> CreateSender(
deadbeefbd7d8f72015-12-18 16:58:44 -0800475 const std::string& kind,
476 const std::string& stream_id) {
deadbeeffac06552015-11-25 11:26:01 -0800477 return rtc::scoped_refptr<RtpSenderInterface>();
478 }
479
deadbeef70ab1a12015-09-28 16:53:55 -0700480 virtual std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
481 const {
482 return std::vector<rtc::scoped_refptr<RtpSenderInterface>>();
483 }
484
485 virtual std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
486 const {
487 return std::vector<rtc::scoped_refptr<RtpReceiverInterface>>();
488 }
489
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000490 virtual bool GetStats(StatsObserver* observer,
491 MediaStreamTrackInterface* track,
492 StatsOutputLevel level) = 0;
hbos74e1a4f2016-09-15 23:33:01 -0700493 // Gets stats using the new stats collection API, see webrtc/api/stats/. These
494 // will replace old stats collection API when the new API has matured enough.
hbose3810152016-12-13 02:35:19 -0800495 // TODO(hbos): Default implementation that does nothing only exists as to not
496 // break third party projects. As soon as they have been updated this should
497 // be changed to "= 0;".
498 virtual void GetStats(RTCStatsCollectorCallback* callback) {}
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000499
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000500 virtual rtc::scoped_refptr<DataChannelInterface> CreateDataChannel(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000501 const std::string& label,
502 const DataChannelInit* config) = 0;
503
504 virtual const SessionDescriptionInterface* local_description() const = 0;
505 virtual const SessionDescriptionInterface* remote_description() const = 0;
deadbeeffe4a8a42016-12-20 17:56:17 -0800506 // A "current" description the one currently negotiated from a complete
507 // offer/answer exchange.
508 virtual const SessionDescriptionInterface* current_local_description() const {
509 return nullptr;
510 }
511 virtual const SessionDescriptionInterface* current_remote_description()
512 const {
513 return nullptr;
514 }
515 // A "pending" description is one that's part of an incomplete offer/answer
516 // exchange (thus, either an offer or a pranswer). Once the offer/answer
517 // exchange is finished, the "pending" description will become "current".
518 virtual const SessionDescriptionInterface* pending_local_description() const {
519 return nullptr;
520 }
521 virtual const SessionDescriptionInterface* pending_remote_description()
522 const {
523 return nullptr;
524 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000525
526 // Create a new offer.
527 // The CreateSessionDescriptionObserver callback will be called when done.
528 virtual void CreateOffer(CreateSessionDescriptionObserver* observer,
jiayl@webrtc.orgb18bf5e2014-08-04 18:34:16 +0000529 const MediaConstraintsInterface* constraints) {}
530
531 // TODO(jiayl): remove the default impl and the old interface when chromium
532 // code is updated.
533 virtual void CreateOffer(CreateSessionDescriptionObserver* observer,
534 const RTCOfferAnswerOptions& options) {}
535
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000536 // Create an answer to an offer.
537 // The CreateSessionDescriptionObserver callback will be called when done.
538 virtual void CreateAnswer(CreateSessionDescriptionObserver* observer,
htaa2a49d92016-03-04 02:51:39 -0800539 const RTCOfferAnswerOptions& options) {}
540 // Deprecated - use version above.
541 // TODO(hta): Remove and remove default implementations when all callers
542 // are updated.
543 virtual void CreateAnswer(CreateSessionDescriptionObserver* observer,
544 const MediaConstraintsInterface* constraints) {}
545
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000546 // Sets the local session description.
547 // JsepInterface takes the ownership of |desc| even if it fails.
548 // The |observer| callback will be called when done.
549 virtual void SetLocalDescription(SetSessionDescriptionObserver* observer,
550 SessionDescriptionInterface* desc) = 0;
551 // Sets the remote session description.
552 // JsepInterface takes the ownership of |desc| even if it fails.
553 // The |observer| callback will be called when done.
554 virtual void SetRemoteDescription(SetSessionDescriptionObserver* observer,
555 SessionDescriptionInterface* desc) = 0;
556 // Restarts or updates the ICE Agent process of gathering local candidates
557 // and pinging remote candidates.
deadbeefa67696b2015-09-29 11:56:26 -0700558 // TODO(deadbeef): Remove once Chrome is moved over to SetConfiguration.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000559 virtual bool UpdateIce(const IceServers& configuration,
deadbeefa67696b2015-09-29 11:56:26 -0700560 const MediaConstraintsInterface* constraints) {
561 return false;
562 }
htaa2a49d92016-03-04 02:51:39 -0800563 virtual bool UpdateIce(const IceServers& configuration) { return false; }
deadbeef46c73892016-11-16 19:42:04 -0800564 // TODO(deadbeef): Make this pure virtual once all Chrome subclasses of
565 // PeerConnectionInterface implement it.
566 virtual PeerConnectionInterface::RTCConfiguration GetConfiguration() {
567 return PeerConnectionInterface::RTCConfiguration();
568 }
deadbeef293e9262017-01-11 12:28:30 -0800569
deadbeefa67696b2015-09-29 11:56:26 -0700570 // Sets the PeerConnection's global configuration to |config|.
deadbeef293e9262017-01-11 12:28:30 -0800571 //
572 // The members of |config| that may be changed are |type|, |servers|,
573 // |ice_candidate_pool_size| and |prune_turn_ports| (though the candidate
574 // pool size can't be changed after the first call to SetLocalDescription).
575 // Note that this means the BUNDLE and RTCP-multiplexing policies cannot be
576 // changed with this method.
577 //
deadbeefa67696b2015-09-29 11:56:26 -0700578 // Any changes to STUN/TURN servers or ICE candidate policy will affect the
579 // next gathering phase, and cause the next call to createOffer to generate
deadbeef293e9262017-01-11 12:28:30 -0800580 // new ICE credentials, as described in JSEP. This also occurs when
581 // |prune_turn_ports| changes, for the same reasoning.
582 //
583 // If an error occurs, returns false and populates |error| if non-null:
584 // - INVALID_MODIFICATION if |config| contains a modified parameter other
585 // than one of the parameters listed above.
586 // - INVALID_RANGE if |ice_candidate_pool_size| is out of range.
587 // - SYNTAX_ERROR if parsing an ICE server URL failed.
588 // - INVALID_PARAMETER if a TURN server is missing |username| or |password|.
589 // - INTERNAL_ERROR if an unexpected error occurred.
590 //
deadbeefa67696b2015-09-29 11:56:26 -0700591 // TODO(deadbeef): Make this pure virtual once all Chrome subclasses of
592 // PeerConnectionInterface implement it.
593 virtual bool SetConfiguration(
deadbeef293e9262017-01-11 12:28:30 -0800594 const PeerConnectionInterface::RTCConfiguration& config,
595 RTCError* error) {
596 return false;
597 }
598 // Version without error output param for backwards compatibility.
599 // TODO(deadbeef): Remove once chromium is updated.
600 virtual bool SetConfiguration(
deadbeef1e234612016-12-24 01:43:32 -0800601 const PeerConnectionInterface::RTCConfiguration& config) {
deadbeefa67696b2015-09-29 11:56:26 -0700602 return false;
603 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000604 // Provides a remote candidate to the ICE Agent.
605 // A copy of the |candidate| will be created and added to the remote
606 // description. So the caller of this method still has the ownership of the
607 // |candidate|.
608 // TODO(ronghuawu): Consider to change this so that the AddIceCandidate will
609 // take the ownership of the |candidate|.
610 virtual bool AddIceCandidate(const IceCandidateInterface* candidate) = 0;
611
Honghai Zhang7fb69db2016-03-14 11:59:18 -0700612 // Removes a group of remote candidates from the ICE agent.
613 virtual bool RemoveIceCandidates(
614 const std::vector<cricket::Candidate>& candidates) {
615 return false;
616 }
617
buildbot@webrtc.org1567b8c2014-05-08 19:54:16 +0000618 virtual void RegisterUMAObserver(UMAObserver* observer) = 0;
619
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000620 // Returns the current SignalingState.
621 virtual SignalingState signaling_state() = 0;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000622 virtual IceConnectionState ice_connection_state() = 0;
623 virtual IceGatheringState ice_gathering_state() = 0;
624
ivoc14d5dbe2016-07-04 07:06:55 -0700625 // Starts RtcEventLog using existing file. Takes ownership of |file| and
626 // passes it on to Call, which will take the ownership. If the
627 // operation fails the file will be closed. The logging will stop
628 // automatically after 10 minutes have passed, or when the StopRtcEventLog
629 // function is called.
630 // TODO(ivoc): Make this pure virtual when Chrome is updated.
631 virtual bool StartRtcEventLog(rtc::PlatformFile file,
632 int64_t max_size_bytes) {
633 return false;
634 }
635
636 // Stops logging the RtcEventLog.
637 // TODO(ivoc): Make this pure virtual when Chrome is updated.
638 virtual void StopRtcEventLog() {}
639
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000640 // Terminates all media and closes the transport.
641 virtual void Close() = 0;
642
643 protected:
644 // Dtor protected as objects shouldn't be deleted via this interface.
645 ~PeerConnectionInterface() {}
646};
647
648// PeerConnection callback interface. Application should implement these
649// methods.
650class PeerConnectionObserver {
651 public:
652 enum StateType {
653 kSignalingState,
654 kIceState,
655 };
656
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000657 // Triggered when the SignalingState changed.
658 virtual void OnSignalingChange(
perkjdfb769d2016-02-09 03:09:43 -0800659 PeerConnectionInterface::SignalingState new_state) = 0;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000660
Taylor Brandstetter98cde262016-05-31 13:02:21 -0700661 // TODO(deadbeef): Once all subclasses override the scoped_refptr versions
662 // of the below three methods, make them pure virtual and remove the raw
663 // pointer version.
664
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000665 // Triggered when media is received on a new stream from remote peer.
Taylor Brandstetter98cde262016-05-31 13:02:21 -0700666 virtual void OnAddStream(rtc::scoped_refptr<MediaStreamInterface> stream) {}
667 // Deprecated; please use the version that uses a scoped_refptr.
668 virtual void OnAddStream(MediaStreamInterface* stream) {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000669
670 // Triggered when a remote peer close a stream.
Taylor Brandstetter98cde262016-05-31 13:02:21 -0700671 virtual void OnRemoveStream(rtc::scoped_refptr<MediaStreamInterface> stream) {
672 }
673 // Deprecated; please use the version that uses a scoped_refptr.
674 virtual void OnRemoveStream(MediaStreamInterface* stream) {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000675
Taylor Brandstetter98cde262016-05-31 13:02:21 -0700676 // Triggered when a remote peer opens a data channel.
677 virtual void OnDataChannel(
678 rtc::scoped_refptr<DataChannelInterface> data_channel){};
679 // Deprecated; please use the version that uses a scoped_refptr.
680 virtual void OnDataChannel(DataChannelInterface* data_channel) {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000681
Taylor Brandstetter98cde262016-05-31 13:02:21 -0700682 // Triggered when renegotiation is needed. For example, an ICE restart
683 // has begun.
fischman@webrtc.orgd7568a02014-01-13 22:04:12 +0000684 virtual void OnRenegotiationNeeded() = 0;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000685
Taylor Brandstetter98cde262016-05-31 13:02:21 -0700686 // Called any time the IceConnectionState changes.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000687 virtual void OnIceConnectionChange(
perkjdfb769d2016-02-09 03:09:43 -0800688 PeerConnectionInterface::IceConnectionState new_state) = 0;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000689
Taylor Brandstetter98cde262016-05-31 13:02:21 -0700690 // Called any time the IceGatheringState changes.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000691 virtual void OnIceGatheringChange(
perkjdfb769d2016-02-09 03:09:43 -0800692 PeerConnectionInterface::IceGatheringState new_state) = 0;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000693
Taylor Brandstetter98cde262016-05-31 13:02:21 -0700694 // A new ICE candidate has been gathered.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000695 virtual void OnIceCandidate(const IceCandidateInterface* candidate) = 0;
696
Honghai Zhang7fb69db2016-03-14 11:59:18 -0700697 // Ice candidates have been removed.
698 // TODO(honghaiz): Make this a pure virtual method when all its subclasses
699 // implement it.
700 virtual void OnIceCandidatesRemoved(
701 const std::vector<cricket::Candidate>& candidates) {}
702
Peter Thatcher54360512015-07-08 11:08:35 -0700703 // Called when the ICE connection receiving status changes.
704 virtual void OnIceConnectionReceivingChange(bool receiving) {}
705
zhihuang81c3a032016-11-17 12:06:24 -0800706 // Called when a track is added to streams.
707 // TODO(zhihuang) Make this a pure virtual method when all its subclasses
708 // implement it.
709 virtual void OnAddTrack(
710 rtc::scoped_refptr<RtpReceiverInterface> receiver,
zhihuangc63b8942016-12-02 15:41:10 -0800711 const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {}
zhihuang81c3a032016-11-17 12:06:24 -0800712
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000713 protected:
714 // Dtor protected as objects shouldn't be deleted via this interface.
715 ~PeerConnectionObserver() {}
716};
717
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000718// PeerConnectionFactoryInterface is the factory interface use for creating
719// PeerConnection, MediaStream and media tracks.
720// PeerConnectionFactoryInterface will create required libjingle threads,
721// socket and network manager factory classes for networking.
722// If an application decides to provide its own threads and network
723// implementation of these classes it should use the alternate
724// CreatePeerConnectionFactory method which accepts threads as input and use the
Taylor Brandstetter0c7e9f52015-12-29 14:14:52 -0800725// CreatePeerConnection version that takes a PortAllocator as an
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000726// argument.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000727class PeerConnectionFactoryInterface : public rtc::RefCountInterface {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000728 public:
wu@webrtc.org97077a32013-10-25 21:18:33 +0000729 class Options {
730 public:
Guo-wei Shieha7446d22016-01-11 15:27:03 -0800731 Options()
732 : disable_encryption(false),
733 disable_sctp_data_channels(false),
734 disable_network_monitor(false),
735 network_ignore_mask(rtc::kDefaultNetworkIgnoreMask),
jbauchcb560652016-08-04 05:20:32 -0700736 ssl_max_version(rtc::SSL_PROTOCOL_DTLS_12),
737 crypto_options(rtc::CryptoOptions::NoGcm()) {}
wu@webrtc.org97077a32013-10-25 21:18:33 +0000738 bool disable_encryption;
739 bool disable_sctp_data_channels;
honghaiz023f3ef2015-10-19 09:39:32 -0700740 bool disable_network_monitor;
phoglund@webrtc.org006521d2015-02-12 09:23:59 +0000741
742 // Sets the network types to ignore. For instance, calling this with
743 // ADAPTER_TYPE_ETHERNET | ADAPTER_TYPE_LOOPBACK will ignore Ethernet and
744 // loopback interfaces.
745 int network_ignore_mask;
Joachim Bauch04e5b492015-05-29 09:40:39 +0200746
747 // Sets the maximum supported protocol version. The highest version
748 // supported by both ends will be used for the connection, i.e. if one
749 // party supports DTLS 1.0 and the other DTLS 1.2, DTLS 1.0 will be used.
750 rtc::SSLProtocolVersion ssl_max_version;
jbauchcb560652016-08-04 05:20:32 -0700751
752 // Sets crypto related options, e.g. enabled cipher suites.
753 rtc::CryptoOptions crypto_options;
wu@webrtc.org97077a32013-10-25 21:18:33 +0000754 };
755
756 virtual void SetOptions(const Options& options) = 0;
buildbot@webrtc.org41451d42014-05-03 05:39:45 +0000757
deadbeef41b07982015-12-01 15:01:24 -0800758 virtual rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
759 const PeerConnectionInterface::RTCConfiguration& configuration,
760 const MediaConstraintsInterface* constraints,
kwibergd1fe2812016-04-27 06:47:29 -0700761 std::unique_ptr<cricket::PortAllocator> allocator,
Henrik Boströmd03c23b2016-06-01 11:44:18 +0200762 std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
hbosd7973cc2016-05-27 06:08:53 -0700763 PeerConnectionObserver* observer) = 0;
buildbot@webrtc.org41451d42014-05-03 05:39:45 +0000764
htaa2a49d92016-03-04 02:51:39 -0800765 virtual rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
766 const PeerConnectionInterface::RTCConfiguration& configuration,
kwibergd1fe2812016-04-27 06:47:29 -0700767 std::unique_ptr<cricket::PortAllocator> allocator,
Henrik Boströmd03c23b2016-06-01 11:44:18 +0200768 std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
hbosd7973cc2016-05-27 06:08:53 -0700769 PeerConnectionObserver* observer) = 0;
htaa2a49d92016-03-04 02:51:39 -0800770
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000771 virtual rtc::scoped_refptr<MediaStreamInterface>
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000772 CreateLocalMediaStream(const std::string& label) = 0;
773
774 // Creates a AudioSourceInterface.
775 // |constraints| decides audio processing settings but can be NULL.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000776 virtual rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource(
htaa2a49d92016-03-04 02:51:39 -0800777 const cricket::AudioOptions& options) = 0;
778 // Deprecated - use version above.
779 virtual rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000780 const MediaConstraintsInterface* constraints) = 0;
781
perkja3ede6c2016-03-08 01:27:48 +0100782 // Creates a VideoTrackSourceInterface. The new source take ownership of
htaa2a49d92016-03-04 02:51:39 -0800783 // |capturer|.
perkja3ede6c2016-03-08 01:27:48 +0100784 virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
htaa2a49d92016-03-04 02:51:39 -0800785 cricket::VideoCapturer* capturer) = 0;
786 // A video source creator that allows selection of resolution and frame rate.
787 // |constraints| decides video resolution and frame rate but can
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000788 // be NULL.
htaa2a49d92016-03-04 02:51:39 -0800789 // In the NULL case, use the version above.
perkja3ede6c2016-03-08 01:27:48 +0100790 virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000791 cricket::VideoCapturer* capturer,
792 const MediaConstraintsInterface* constraints) = 0;
793
794 // Creates a new local VideoTrack. The same |source| can be used in several
795 // tracks.
perkja3ede6c2016-03-08 01:27:48 +0100796 virtual rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack(
797 const std::string& label,
798 VideoTrackSourceInterface* source) = 0;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000799
800 // Creates an new AudioTrack. At the moment |source| can be NULL.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000801 virtual rtc::scoped_refptr<AudioTrackInterface>
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000802 CreateAudioTrack(const std::string& label,
803 AudioSourceInterface* source) = 0;
804
wu@webrtc.orga9890802013-12-13 00:21:03 +0000805 // Starts AEC dump using existing file. Takes ownership of |file| and passes
806 // it on to VoiceEngine (via other objects) immediately, which will take
wu@webrtc.orga8910d22014-01-23 22:12:45 +0000807 // the ownerhip. If the operation fails, the file will be closed.
ivocd66b44d2016-01-15 03:06:36 -0800808 // A maximum file size in bytes can be specified. When the file size limit is
809 // reached, logging is stopped automatically. If max_size_bytes is set to a
810 // value <= 0, no limit will be used, and logging will continue until the
811 // StopAecDump function is called.
812 virtual bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes) = 0;
wu@webrtc.orga9890802013-12-13 00:21:03 +0000813
ivoc797ef122015-10-22 03:25:41 -0700814 // Stops logging the AEC dump.
815 virtual void StopAecDump() = 0;
816
ivoc14d5dbe2016-07-04 07:06:55 -0700817 // This function is deprecated and will be removed when Chrome is updated to
818 // use the equivalent function on PeerConnectionInterface.
819 // TODO(ivoc) Remove after Chrome is updated.
ivocc1513ee2016-05-13 08:30:39 -0700820 virtual bool StartRtcEventLog(rtc::PlatformFile file,
821 int64_t max_size_bytes) = 0;
ivoc14d5dbe2016-07-04 07:06:55 -0700822 // This function is deprecated and will be removed when Chrome is updated to
823 // use the equivalent function on PeerConnectionInterface.
824 // TODO(ivoc) Remove after Chrome is updated.
ivoc112a3d82015-10-16 02:22:18 -0700825 virtual bool StartRtcEventLog(rtc::PlatformFile file) = 0;
826
ivoc14d5dbe2016-07-04 07:06:55 -0700827 // This function is deprecated and will be removed when Chrome is updated to
828 // use the equivalent function on PeerConnectionInterface.
829 // TODO(ivoc) Remove after Chrome is updated.
ivoc112a3d82015-10-16 02:22:18 -0700830 virtual void StopRtcEventLog() = 0;
831
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000832 protected:
833 // Dtor and ctor protected as objects shouldn't be created or deleted via
834 // this interface.
835 PeerConnectionFactoryInterface() {}
836 ~PeerConnectionFactoryInterface() {} // NOLINT
837};
838
839// Create a new instance of PeerConnectionFactoryInterface.
Taylor Brandstettera8415fe2016-03-23 10:38:07 -0700840//
841// This method relies on the thread it's called on as the "signaling thread"
842// for the PeerConnectionFactory it creates.
843//
844// As such, if the current thread is not already running an rtc::Thread message
845// loop, an application using this method must eventually either call
846// rtc::Thread::Current()->Run(), or call
847// rtc::Thread::Current()->ProcessMessages() within the application's own
848// message loop.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000849rtc::scoped_refptr<PeerConnectionFactoryInterface>
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000850CreatePeerConnectionFactory();
851
852// Create a new instance of PeerConnectionFactoryInterface.
Taylor Brandstettera8415fe2016-03-23 10:38:07 -0700853//
danilchape9021a32016-05-17 01:52:02 -0700854// |network_thread|, |worker_thread| and |signaling_thread| are
855// the only mandatory parameters.
Taylor Brandstettera8415fe2016-03-23 10:38:07 -0700856//
857// If non-null, ownership of |default_adm|, |encoder_factory| and
858// |decoder_factory| are transferred to the returned factory.
danilchape9021a32016-05-17 01:52:02 -0700859rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
860 rtc::Thread* network_thread,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000861 rtc::Thread* worker_thread,
862 rtc::Thread* signaling_thread,
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000863 AudioDeviceModule* default_adm,
864 cricket::WebRtcVideoEncoderFactory* encoder_factory,
865 cricket::WebRtcVideoDecoderFactory* decoder_factory);
866
gyzhou95aa9642016-12-13 14:06:26 -0800867// Create a new instance of PeerConnectionFactoryInterface with external audio
868// mixer.
869//
870// If |audio_mixer| is null, an internal audio mixer will be created and used.
871rtc::scoped_refptr<PeerConnectionFactoryInterface>
872CreatePeerConnectionFactoryWithAudioMixer(
873 rtc::Thread* network_thread,
874 rtc::Thread* worker_thread,
875 rtc::Thread* signaling_thread,
876 AudioDeviceModule* default_adm,
877 cricket::WebRtcVideoEncoderFactory* encoder_factory,
878 cricket::WebRtcVideoDecoderFactory* decoder_factory,
879 rtc::scoped_refptr<AudioMixer> audio_mixer);
880
danilchape9021a32016-05-17 01:52:02 -0700881// Create a new instance of PeerConnectionFactoryInterface.
882// Same thread is used as worker and network thread.
danilchape9021a32016-05-17 01:52:02 -0700883inline rtc::scoped_refptr<PeerConnectionFactoryInterface>
884CreatePeerConnectionFactory(
885 rtc::Thread* worker_and_network_thread,
886 rtc::Thread* signaling_thread,
887 AudioDeviceModule* default_adm,
888 cricket::WebRtcVideoEncoderFactory* encoder_factory,
889 cricket::WebRtcVideoDecoderFactory* decoder_factory) {
890 return CreatePeerConnectionFactory(
891 worker_and_network_thread, worker_and_network_thread, signaling_thread,
892 default_adm, encoder_factory, decoder_factory);
893}
894
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000895} // namespace webrtc
896
Henrik Kjellander15583c12016-02-10 10:53:12 +0100897#endif // WEBRTC_API_PEERCONNECTIONINTERFACE_H_