286 lines
12 KiB
C#
286 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using Normal.Realtime.Native;
|
|
|
|
namespace Normal.Realtime.Native {
|
|
public class Client : IDisposable {
|
|
//// Class
|
|
private static volatile int __numberOfClients = 0;
|
|
private static readonly object __numberOfClientsLock = new Object();
|
|
private static void SetUpNetworkStackIfNeeded() {
|
|
lock (__numberOfClientsLock) {
|
|
if (__numberOfClients == 0)
|
|
Plugin.ClientSetUpNetworkStack();
|
|
__numberOfClients++;
|
|
}
|
|
}
|
|
|
|
private static void TearDownNetworkStackIfNeeded() {
|
|
lock (__numberOfClientsLock) {
|
|
__numberOfClients--;
|
|
if (__numberOfClients == 0)
|
|
Plugin.ClientTearDownNetworkStack();
|
|
}
|
|
}
|
|
|
|
public static UInt64 GenerateSecureClientIdentifier() {
|
|
return Plugin.ClientGenerateSecureClientIdentifier();
|
|
}
|
|
|
|
// Events
|
|
public delegate void PersistenceMessageReceived(Client client, int sender, byte[] data, bool reliable);
|
|
public delegate void RPCMessageReceived(Client client, byte[] data, bool reliable);
|
|
public delegate void AudioOutputStreamCreated(Client client, AudioOutputStream audioOutputStream);
|
|
public delegate void AudioOutputStreamClosed(Client client, AudioOutputStream audioOutputStream);
|
|
|
|
public event PersistenceMessageReceived persistenceMessageReceived;
|
|
public event RPCMessageReceived rpcMessageReceived;
|
|
public event AudioOutputStreamCreated audioOutputStreamCreated;
|
|
public event AudioOutputStreamClosed audioOutputStreamClosed;
|
|
|
|
// Pointer to native class
|
|
private IntPtr _nativeClient = IntPtr.Zero;
|
|
|
|
private List<AudioInputStream> _audioInputStreams;
|
|
private List<AudioOutputStream> _audioOutputStreams;
|
|
|
|
//// Instance
|
|
public Client() {
|
|
// Set up network stack if needed
|
|
SetUpNetworkStackIfNeeded();
|
|
|
|
// Create a native Client instance and save the pointer here.
|
|
_nativeClient = Plugin.ClientCreate();
|
|
RegisterCallbacks();
|
|
|
|
// Lists to hold the audio streams
|
|
_audioInputStreams = new List<AudioInputStream>();
|
|
_audioOutputStreams = new List<AudioOutputStream>();
|
|
}
|
|
|
|
// NOTE: This may not be called on the same thread that we created the native client with. It's recommended Dispose() is called manually to prevent any issues.
|
|
~Client() {
|
|
// Clean up unmanaged code
|
|
Dispose(false);
|
|
}
|
|
|
|
// Ideally called whenever someone is done using a client.
|
|
public void Dispose() {
|
|
Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
private void Dispose(bool disposing) {
|
|
if (_nativeClient != IntPtr.Zero) {
|
|
// Unregister callbacks
|
|
UnregisterCallbacks();
|
|
|
|
// Dispose of all audio streams
|
|
foreach (AudioInputStream audioInputStream in _audioInputStreams)
|
|
audioInputStream.Dispose();
|
|
_audioInputStreams.Clear();
|
|
foreach (AudioOutputStream audioOutputStream in _audioOutputStreams)
|
|
audioOutputStream.Dispose();
|
|
_audioOutputStreams.Clear();
|
|
|
|
// Delete client
|
|
Plugin.ClientDelete(_nativeClient);
|
|
|
|
// Prevents any further calls to the native plugin
|
|
_nativeClient = IntPtr.Zero;
|
|
|
|
// Tear down network stack if needed
|
|
TearDownNetworkStackIfNeeded();
|
|
}
|
|
}
|
|
|
|
// Callbacks
|
|
private void RegisterCallbacks() {
|
|
// Persistence
|
|
Plugin.ClientRegisterPersistenceMessageReceivedCallback(_nativeClient);
|
|
Plugin.clientPersistenceMessageReceived += ReceivedPersistenceMessageCallback;
|
|
|
|
// RPC
|
|
Plugin.ClientRegisterRPCMessageReceivedCallback(_nativeClient);
|
|
Plugin.clientRPCMessageReceived += ReceivedRPCMessageCallback;
|
|
|
|
// Audio
|
|
// Tell the plugin to start piping audioOutputStreamCreated callbacks through the clientAudioOutputStreamCreated event.
|
|
// NOTE: By registering for callbacks, the native interface is going to allocate an AudioOutputStream strong reference
|
|
// for us. We need to ensure we call ClientDeleteAudioOutputStream() on all pointers we receive when we're done with them.
|
|
// Luckily, the AudioOutputStream C# wrapper takes care of this in its dispose method.
|
|
Plugin.ClientRegisterAudioOutputStreamCreatedCallback(_nativeClient);
|
|
Plugin.ClientRegisterAudioOutputStreamClosedCallback(_nativeClient);
|
|
|
|
// Register for the event (Note: this is static, so it fires for all clients)
|
|
Plugin.clientAudioOutputStreamCreated += AudioOutputStreamCreatedCallback;
|
|
Plugin.clientAudioOutputStreamClosed += AudioOutputStreamClosedCallback;
|
|
}
|
|
|
|
private void UnregisterCallbacks() {
|
|
// Persistence
|
|
Plugin.ClientUnregisterPersistenceMessageReceivedCallback(_nativeClient);
|
|
Plugin.clientPersistenceMessageReceived -= ReceivedPersistenceMessageCallback;
|
|
|
|
// RPC
|
|
// TODO: If multiple clients are created, and one is destroyed. All persistence messages will stop because we're unregister the callback
|
|
Plugin.ClientUnregisterRPCMessageReceivedCallback(_nativeClient);
|
|
Plugin.clientRPCMessageReceived -= ReceivedRPCMessageCallback;
|
|
|
|
// Audio
|
|
Plugin.ClientUnregisterAudioOutputStreamCreatedCallback(_nativeClient);
|
|
Plugin.ClientUnregisterAudioOutputStreamClosedCallback(_nativeClient);
|
|
Plugin.clientAudioOutputStreamCreated -= AudioOutputStreamCreatedCallback;
|
|
Plugin.clientAudioOutputStreamClosed -= AudioOutputStreamClosedCallback;
|
|
}
|
|
|
|
// Network Statistics
|
|
public NetworkInfo GetNetworkStatistics() {
|
|
if (_nativeClient == IntPtr.Zero)
|
|
throw RealtimeNativeException.NativePointerIsNull("Client");
|
|
|
|
NetworkInfo networkInfo;
|
|
Plugin.ClientGetNetworkStatistics(_nativeClient, out networkInfo);
|
|
return networkInfo;
|
|
}
|
|
|
|
// Connect / Disconnect
|
|
public void Connect(UInt64 clientIdentifier, byte[] connectToken) {
|
|
if (_nativeClient == IntPtr.Zero)
|
|
throw RealtimeNativeException.NativePointerIsNull("Client");
|
|
|
|
// TODO: Connect/Disconnect need to fail gracefully if called multiple times.
|
|
Plugin.ClientConnect(_nativeClient, clientIdentifier, connectToken, connectToken.Length);
|
|
}
|
|
|
|
public void Disconnect() {
|
|
if (_nativeClient == IntPtr.Zero)
|
|
throw RealtimeNativeException.NativePointerIsNull("Client");
|
|
|
|
Plugin.ClientDisconnect(_nativeClient);
|
|
}
|
|
|
|
// Tick
|
|
public int Tick() {
|
|
if (_nativeClient == IntPtr.Zero)
|
|
throw RealtimeNativeException.NativePointerIsNull("Client");
|
|
|
|
// TODO: ClientTick should do its own deltaTime calculation. It will be more precise and will prevent the client and server from getting out of sync.
|
|
return Plugin.ClientTick(_nativeClient);
|
|
}
|
|
|
|
// Metadata
|
|
public int ClientIndex() {
|
|
if (_nativeClient == IntPtr.Zero)
|
|
throw RealtimeNativeException.NativePointerIsNull("Client");
|
|
|
|
return Plugin.ClientGetClientIndex(_nativeClient);
|
|
}
|
|
|
|
public double RoomTime() {
|
|
if (_nativeClient == IntPtr.Zero)
|
|
throw RealtimeNativeException.NativePointerIsNull("Client");
|
|
|
|
return Plugin.ClientGetRoomTime(_nativeClient);
|
|
}
|
|
|
|
// Persistence
|
|
public bool SendPersistenceMessage(byte[] data, int dataLength, bool reliable) {
|
|
if (_nativeClient == IntPtr.Zero)
|
|
throw RealtimeNativeException.NativePointerIsNull("Client");
|
|
|
|
return Plugin.ClientSendPersistenceMessage(_nativeClient, data, dataLength, reliable);
|
|
}
|
|
|
|
void ReceivedPersistenceMessageCallback(IntPtr nativeClient, int sender, byte[] data, bool reliable) {
|
|
if (nativeClient != _nativeClient)
|
|
return;
|
|
|
|
if (persistenceMessageReceived != null)
|
|
persistenceMessageReceived(this, sender, data, reliable);
|
|
}
|
|
|
|
// RPC
|
|
public bool SendRPCMessage(byte[] data, int dataLength, bool reliable) {
|
|
if (_nativeClient == IntPtr.Zero)
|
|
throw RealtimeNativeException.NativePointerIsNull("Client");
|
|
|
|
return Plugin.ClientSendRPCMessage(_nativeClient, data, dataLength, reliable);
|
|
}
|
|
|
|
void ReceivedRPCMessageCallback(IntPtr nativeClient, int sender, byte[] data, bool reliable) {
|
|
if (nativeClient != _nativeClient)
|
|
return;
|
|
|
|
if (rpcMessageReceived != null)
|
|
rpcMessageReceived(this, data, reliable);
|
|
}
|
|
|
|
// Audio
|
|
public AudioInputStream CreateAudioInputStream(bool voice, int sampleRate, int channels) {
|
|
if (_nativeClient == IntPtr.Zero)
|
|
throw RealtimeNativeException.NativePointerIsNull("Client");
|
|
|
|
if (sampleRate <= 0)
|
|
throw new ArgumentException("Attempting to create audio stream with invalid sample rate (" + sampleRate + ").");
|
|
if (channels <= 0)
|
|
throw new ArgumentException("Attempting to create audio stream with an invalid number of channels (" + channels + ").");
|
|
|
|
IntPtr nativeAudioInputStream = Plugin.ClientCreateAudioInputStream(_nativeClient, voice, sampleRate, channels);
|
|
|
|
AudioInputStream audioInputStream = new AudioInputStream(nativeAudioInputStream);
|
|
_audioInputStreams.Add(audioInputStream);
|
|
|
|
return audioInputStream;
|
|
}
|
|
|
|
void AudioOutputStreamCreatedCallback(IntPtr nativeClient, IntPtr nativeAudioOutputStream, IntPtr nativeAudioOutputStreamIdentifier) {
|
|
// This method is fired for every client, ignore events meant for other clients
|
|
if (nativeClient != _nativeClient)
|
|
return;
|
|
|
|
AudioOutputStream audioOutputStream = new AudioOutputStream(nativeAudioOutputStream, nativeAudioOutputStreamIdentifier);
|
|
_audioOutputStreams.Add(audioOutputStream);
|
|
|
|
// Fire event
|
|
if (audioOutputStreamCreated != null)
|
|
audioOutputStreamCreated(this, audioOutputStream);
|
|
}
|
|
|
|
void AudioOutputStreamClosedCallback(IntPtr nativeClient, IntPtr nativeAudioOutputStreamIdentifier) {
|
|
// This method is fired for every client, ignore events meant for other clients
|
|
if (nativeClient != _nativeClient)
|
|
return;
|
|
|
|
AudioOutputStream audioOutputStreamToClose = null;
|
|
foreach (AudioOutputStream audioOutputStream in _audioOutputStreams) {
|
|
// Find the matching audio output stream.
|
|
if (audioOutputStream.AudioOutputStreamMatchesIdentifier(nativeAudioOutputStreamIdentifier)) {
|
|
audioOutputStreamToClose = audioOutputStream;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (audioOutputStreamToClose != null) {
|
|
// Fire event
|
|
if (audioOutputStreamClosed != null)
|
|
audioOutputStreamClosed(this, audioOutputStreamToClose);
|
|
|
|
// Dispose of AudioOutputStream
|
|
_audioOutputStreams.Remove(audioOutputStreamToClose);
|
|
audioOutputStreamToClose.Dispose();
|
|
}
|
|
}
|
|
|
|
public AudioOutputStream GetAudioOutputStream(int clientID, int streamID) {
|
|
// Find the matching audio output stream.
|
|
foreach (AudioOutputStream audioOutputStream in _audioOutputStreams) {
|
|
if (audioOutputStream.ClientID() == clientID && audioOutputStream.StreamID() == streamID)
|
|
return audioOutputStream;
|
|
}
|
|
|
|
// Nothing found
|
|
return null;
|
|
}
|
|
}
|
|
}
|