-
Notifications
You must be signed in to change notification settings - Fork 4
/
FishyWebRTC.cs
517 lines (487 loc) · 14.7 KB
/
FishyWebRTC.cs
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
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
#if ENABLE_WEBRTC && (UNITY_STANDALONE || UNITY_WEBGL || UNITY_SERVER || UNITY_EDITOR)
using FishNet.Managing;
using FishNet.Managing.Logging;
using FishNet.Managing.Transporting;
using System;
using System.Runtime.CompilerServices;
using UnityEngine;
using System.Collections.Generic;
using cakeslice.SimpleWebRTC;
namespace FishNet.Transporting.FishyWebRTC
{
[DisallowMultipleComponent]
public class FishyWebRTC : Transport
{
[SerializeField]
/// <summary>
/// ICE servers (STUN or TURN) to use.
/// </summary>
[Tooltip("ICE servers (STUN or TURN) to use. Use Google's server only for testing purposes!")]
public List<Common.ICEServer> iceServers = new List<Common.ICEServer>(){
new Common.ICEServer(){
url = "stun:stun2.l.google.com:19302"
}
};
const string serverOnlyException = "Hosting as a client is not implemented!";
#region Serialized.
[Header("Channels")]
/// <summary>
/// Maximum transmission unit for this transport.
/// </summary>
[Tooltip("Maximum transmission unit for the unreliable channel.")]
[Range(MINIMUM_MTU, MAXIMUM_MTU)]
[SerializeField]
private int _mtu = 1023;
[Header("Server")]
/// <summary>
/// Allowed domain origin.
/// </summary>
[Tooltip("Allowed domain origin.")]
[SerializeField]
private string _origin = "*";
/// <summary>
/// Port to use.
/// </summary>
[Tooltip("Port to use.")]
[SerializeField]
private ushort _port = 7770;
/// <summary>
/// Maximum number of players which may be connected at once.
/// </summary>
[Tooltip("Maximum number of players which may be connected at once.")]
[Range(1, 9999)]
[SerializeField]
private int _maximumClients = 2000;
[Header("Client")]
/// <summary>
/// Address to connect.
/// </summary>
[Tooltip("Use HTTPS for signaling.")]
[SerializeField]
private bool _HTTPS = false;
/// <summary>
/// Address to connect.
/// </summary>
[Tooltip("Signaling address to connect.")]
[SerializeField]
private string _clientAddress = "127.0.0.1";
/// <summary>
/// Port to connect.
/// </summary>
[Tooltip("If you want to connect to the signaling server without a port.")]
[SerializeField]
private bool _noClientPort = false;
#endregion
#region Private.
#if !UNITY_WEBGL || UNITY_EDITOR
/// <summary>
/// Server socket and handler.
/// </summary>
private Server.ServerSocket _server = new Server.ServerSocket();
#endif
/// <summary>
/// Client socket and handler.
/// </summary>
private Client.ClientSocket _client = new Client.ClientSocket();
#endregion
#region Const.
/// <summary>
/// Minimum UDP packet size allowed.
/// </summary>
private const int MINIMUM_MTU = 576;
/// <summary>
/// Maximum UDP packet size allowed.
/// </summary>
private const int MAXIMUM_MTU = ushort.MaxValue;
#endregion
#region Initialization and unity.
protected void OnDestroy()
{
Shutdown();
}
#endregion
#region ConnectionStates.
/// <summary>
/// Gets the address of a remote connection Id.
/// </summary>
/// <param name="connectionId"></param>
/// <returns></returns>
public override string GetConnectionAddress(int connectionId)
{
#if !UNITY_WEBGL || UNITY_EDITOR
return _server.GetConnectionAddress(connectionId);
#else
throw new Exception(serverOnlyException);
#endif
}
/// <summary>
/// Called when a connection state changes for the local client.
/// </summary>
public override event Action<ClientConnectionStateArgs> OnClientConnectionState;
/// <summary>
/// Called when a connection state changes for the local server.
/// </summary>
public override event Action<ServerConnectionStateArgs> OnServerConnectionState;
/// <summary>
/// Called when a connection state changes for a remote client.
/// </summary>
public override event Action<RemoteConnectionStateArgs> OnRemoteConnectionState;
/// <summary>
/// Gets the current local ConnectionState.
/// </summary>
/// <param name="server">True if getting ConnectionState for the server.</param>
public override LocalConnectionState GetConnectionState(bool server)
{
#if !UNITY_WEBGL || UNITY_EDITOR
if (server)
return _server.GetConnectionState();
else
#endif
return _client.GetConnectionState();
}
/// <summary>
/// Gets the current ConnectionState of a remote client on the server.
/// </summary>
/// <param name="connectionId">ConnectionId to get ConnectionState for.</param>
public override RemoteConnectionState GetConnectionState(int connectionId)
{
#if !UNITY_WEBGL || UNITY_EDITOR
return _server.GetConnectionState(connectionId);
#else
throw new Exception(serverOnlyException);
#endif
}
/// <summary>
/// Handles a ConnectionStateArgs for the local client.
/// </summary>
/// <param name="connectionStateArgs"></param>
public override void HandleClientConnectionState(ClientConnectionStateArgs connectionStateArgs)
{
OnClientConnectionState?.Invoke(connectionStateArgs);
}
/// <summary>
/// Handles a ConnectionStateArgs for the local server.
/// </summary>
/// <param name="connectionStateArgs"></param>
public override void HandleServerConnectionState(ServerConnectionStateArgs connectionStateArgs)
{
OnServerConnectionState?.Invoke(connectionStateArgs);
}
/// <summary>
/// Handles a ConnectionStateArgs for a remote client.
/// </summary>
/// <param name="connectionStateArgs"></param>
public override void HandleRemoteConnectionState(RemoteConnectionStateArgs connectionStateArgs)
{
OnRemoteConnectionState?.Invoke(connectionStateArgs);
}
#endregion
#region Iterating.
/// <summary>
/// Processes data received by the socket.
/// </summary>
/// <param name="server">True to process data received on the server.</param>
public override void IterateIncoming(bool server)
{
#if !UNITY_WEBGL || UNITY_EDITOR
if (server)
_server.IterateIncoming();
else
#endif
_client.IterateIncoming();
}
/// <summary>
/// Processes data to be sent by the socket.
/// </summary>
/// <param name="server">True to process data received on the server.</param>
public override void IterateOutgoing(bool server)
{
#if !UNITY_WEBGL || UNITY_EDITOR
if (server)
_server.IterateOutgoing();
else
#endif
_client.IterateOutgoing();
}
#endregion
#region ReceivedData.
/// <summary>
/// Called when client receives data.
/// </summary>
public override event Action<ClientReceivedDataArgs> OnClientReceivedData;
/// <summary>
/// Handles a ClientReceivedDataArgs.
/// </summary>
/// <param name="receivedDataArgs"></param>
public override void HandleClientReceivedDataArgs(ClientReceivedDataArgs receivedDataArgs)
{
OnClientReceivedData?.Invoke(receivedDataArgs);
}
/// <summary>
/// Called when server receives data.
/// </summary>
public override event Action<ServerReceivedDataArgs> OnServerReceivedData;
/// <summary>
/// Handles a ClientReceivedDataArgs.
/// </summary>
/// <param name="receivedDataArgs"></param>
public override void HandleServerReceivedDataArgs(ServerReceivedDataArgs receivedDataArgs)
{
OnServerReceivedData?.Invoke(receivedDataArgs);
}
#endregion
#region Sending.
/// <summary>
/// Sends to the server or all clients.
/// </summary>
/// <param name="channelId">Channel to use.</param>
/// <param name="segment">Data to send.</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override void SendToServer(byte channelId, ArraySegment<byte> segment)
{
SanitizeChannel(ref channelId);
_client.SendToServer(channelId, segment);
}
/// <summary>
/// Sends data to a client.
/// </summary>
/// <param name="channelId"></param>
/// <param name="segment"></param>
/// <param name="connectionId"></param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override void SendToClient(byte channelId, ArraySegment<byte> segment, int connectionId)
{
#if !UNITY_WEBGL || UNITY_EDITOR
SanitizeChannel(ref channelId);
_server.SendToClient(channelId, segment, connectionId);
#endif
}
#endregion
#region Configuration.
/// <summary>
/// How long in seconds until either the server or client socket must go without data before being timed out.
/// </summary>
/// <param name="asServer">True to get the timeout for the server socket, false for the client socket.</param>
/// <returns></returns>
public override float GetTimeout(bool asServer)
{
return -1f;
}
/// <summary>
/// Returns the maximum number of clients allowed to connect to the server. If the transport does not support this method the value -1 is returned.
/// </summary>
/// <returns></returns>
public override int GetMaximumClients()
{
#if !UNITY_WEBGL || UNITY_EDITOR
return _server.GetMaximumClients();
#else
throw new Exception(serverOnlyException);
#endif
}
/// <summary>
/// Sets maximum number of clients allowed to connect to the server. If applied at runtime and clients exceed this value existing clients will stay connected but new clients may not connect.
/// </summary>
/// <param name="value"></param>
public override void SetMaximumClients(int value)
{
#if !UNITY_WEBGL || UNITY_EDITOR
if (_server.GetConnectionState() != LocalConnectionState.Stopped)
{
if (base.NetworkManager.CanLog(LoggingType.Warning))
Debug.LogWarning($"Cannot set maximum clients when server is running.");
}
else
{
_maximumClients = value;
}
#else
throw new Exception(serverOnlyException);
#endif
}
/// <summary>
/// Sets which address the client will connect to.
/// </summary>
/// <param name="address"></param>
public override void SetClientAddress(string address)
{
_clientAddress = address;
}
/// <summary>
/// Gets which address the client will connect to.
/// </summary>
public override string GetClientAddress()
{
return _clientAddress;
}
/// <summary>
/// Sets which address the server will bind to.
/// </summary>
/// <param name="address"></param>
public override void SetServerBindAddress(string address, IPAddressType addressType) { }
/// <summary>
/// Gets which address the server will bind to.
/// </summary>
/// <param name="address"></param>
public override string GetServerBindAddress(IPAddressType addressType)
{
return "localhost";
}
/// <summary>
/// Sets which port to use.
/// </summary>
/// <param name="port"></param>
public override void SetPort(ushort port)
{
_port = port;
}
/// <summary>
/// Gets which port to use.
/// </summary>
/// <param name="port"></param>
public override ushort GetPort()
{
return _port;
}
#endregion
#region Start and stop.
/// <summary>
/// Starts the local server or client using configured settings.
/// </summary>
/// <param name="server">True to start server.</param>
public override bool StartConnection(bool server)
{
#if !UNITY_WEBGL || UNITY_EDITOR
if (server)
return StartServer();
else
#endif
return StartClient(_clientAddress);
}
/// <summary>
/// Stops the local server or client.
/// </summary>
/// <param name="server">True to stop server.</param>
public override bool StopConnection(bool server)
{
#if !UNITY_WEBGL || UNITY_EDITOR
if (server)
return StopServer();
else
#endif
return StopClient();
}
/// <summary>
/// Stops a remote client from the server, disconnecting the client.
/// </summary>
/// <param name="connectionId">ConnectionId of the client to disconnect.</param>
/// <param name="immediately">True to abrutly stp the client socket without waiting socket thread.</param>
public override bool StopConnection(int connectionId, bool immediately)
{
#if !UNITY_WEBGL || UNITY_EDITOR
return StopClient(connectionId, immediately);
#else
throw new Exception(serverOnlyException);
#endif
}
/// <summary>
/// Stops both client and server.
/// </summary>
public override void Shutdown()
{
//Stops client then server connections.
StopConnection(false);
StopConnection(true);
}
#region Privates.
/// <summary>
/// Starts server.
/// </summary>
private bool StartServer()
{
#if !UNITY_WEBGL || UNITY_EDITOR
_server.Initialize(this, _mtu);
return _server.StartConnection(iceServers, _port, _maximumClients, _origin);
#else
throw new Exception(serverOnlyException);
#endif
}
/// <summary>
/// Stops server.
/// </summary>
private bool StopServer()
{
#if !UNITY_WEBGL || UNITY_EDITOR
return _server.StopConnection();
#else
throw new Exception(serverOnlyException);
#endif
}
/// <summary>
/// Starts the client.
/// </summary>
/// <param name="address"></param>
private bool StartClient(string address)
{
_client.Initialize(this, _mtu);
return _client.StartConnection(iceServers, address, _HTTPS, _port, _noClientPort);
}
/// <summary>
/// Stops the client.
/// </summary>
private bool StopClient()
{
return _client.StopConnection();
}
#if !UNITY_WEBGL || UNITY_EDITOR
/// <summary>
/// Stops a remote client on the server.
/// </summary>
/// <param name="connectionId"></param>
/// <param name="immediately">True to abrutly stp the client socket without waiting socket thread.</param>
private bool StopClient(int connectionId, bool immediately)
{
return _server.StopConnection(connectionId, immediately);
}
#endif
#endregion
#endregion
#region Channels.
/// <summary>
/// If channelId is invalid then channelId becomes forced to reliable.
/// </summary>
/// <param name="channelId"></param>
private void SanitizeChannel(ref byte channelId)
{
if (channelId < 0 || channelId >= TransportManager.CHANNEL_COUNT)
{
if (NetworkManager.CanLog(LoggingType.Warning))
Debug.LogWarning($"Channel of {channelId} is out of range of supported channels. Channel will be defaulted to reliable.");
channelId = 0;
}
}
/// <summary>
/// Gets the MTU for a channel. This should take header size into consideration.
/// For example, if MTU is 1200 and a packet header for this channel is 10 in size, this method should return 1190.
/// </summary>
/// <param name="channel"></param>
/// <returns></returns>
public override int GetMTU(byte channel)
{
return _mtu;
}
#endregion
#region Editor.
#if UNITY_EDITOR || UNITY_EDITOR
private void OnValidate()
{
if (_mtu < 0)
_mtu = MINIMUM_MTU;
else if (_mtu > MAXIMUM_MTU)
_mtu = MAXIMUM_MTU;
}
#endif
#endregion
}
}
#endif