public UniRx.IObservable <Websocket> Connection(Config config)
{
return(UniRx.Observable.Create <Websocket> (observer => {
var impl = new WebSocketSharp.WebSocket(config.url.ToString(), config.protocols);
System.EventHandler <WebSocketSharp.ErrorEventArgs> onError = (obj, e) => {
observer.OnError(new System.Exception(e.Message));
};
impl.OnError += onError;
foreach (var pr in config.coockie)
{
impl.SetCookie(new WebSocketSharp.Net.Cookie(pr.Key, pr.Value));
}
var socket = new Websocket(impl, shared_data);
impl.OnOpen += (sender, e) => {
impl.OnError -= onError;
this.shared_data.connected.Add(socket.GetHashCode(), socket);
observer.OnNext(socket);
observer.OnCompleted();
};
impl.ConnectAsync();
return new Sas.DisposeAction(() => {
});
}));
}
private IEnumerator Connect()
{
ws = new WebSocketSharp.WebSocket(new Uri(webSocketIP).ToString());
ws.OnClose += (sender, e) =>
{
Debug.Log("client disconnected");
};
ws.OnMessage += (sender, e) =>
{
lock (mInQueue) { mInQueue.Enqueue(e.RawData); }
};
ws.OnOpen += (sender, e) =>
{
IsConnected = true;
processor.OnConnected(this);
};
ws.OnError += (sender, e) => wsError = e.Message;
ws.ConnectAsync();
while (!IsConnected && wsError == null)
{
yield return(0);
}
}
public void Connect(string host)
{
m_socket = new WebSocketSharp.WebSocket(host);
m_socket.OnOpen += OnConnectedOpened;
m_socket.OnMessage += OnMessageReveived;
m_socket.OnClose += OnConnectedClose;
m_socket.OnError += OnConnectedError;
m_socket.ConnectAsync();
}
public void Connect()
{
if ((ddpConnectionState == ConnectionState.NOT_CONNECTED) ||
(ddpConnectionState == ConnectionState.DISCONNECTED) ||
(ddpConnectionState == ConnectionState.CLOSED))
{
ddpConnectionState = ConnectionState.CONNECTING;
ws.ConnectAsync();
}
}
public void Connect()
{
#if UNITY_WEBGL && !UNITY_EDITOR
m_NativeRef = SocketCreate(mUrl.ToString());
#else
m_Socket = new WebSocketSharp.WebSocket(mUrl.ToString());
m_Socket.OnMessage += (sender, e) => m_Messages.Enqueue(e.RawData);
m_Socket.OnError += (sender, e) => m_Error = e.Message;
m_Socket.ConnectAsync();
#endif
}
public IEnumerator Connect()
{
_socket = new WebSocketSharp.WebSocket(_url.ToString());
_socket.OnMessage += (sender, e) => _messages.Enqueue(e.RawData);
_socket.OnOpen += (sender, e) => _isConnected = true;
_socket.OnError += (sender, e) => Error = e.Message;
_socket.ConnectAsync();
while (!_isConnected && Error == null)
{
yield return(null);
}
}
public static void Initialize()
{
// Initialize our message handlers
_messageHandlers.Add("PRIVMSG", MessageHandlers.PRIVMSG);
_messageHandlers.Add("ROOMSTATE", MessageHandlers.ROOMSTATE);
_messageHandlers.Add("USERNOTICE", MessageHandlers.USERNOTICE);
_messageHandlers.Add("USERSTATE", MessageHandlers.USERSTATE);
_messageHandlers.Add("CLEARCHAT", MessageHandlers.CLEARCHAT);
_messageHandlers.Add("CLEARMSG", MessageHandlers.CLEARMSG);
_messageHandlers.Add("MODE", MessageHandlers.MODE);
_messageHandlers.Add("JOIN", MessageHandlers.JOIN);
// Create our websocket object and setup the callbacks
_ws = new WebSocketSharp.WebSocket("wss://irc-ws.chat.twitch.tv:443");
_ws.OnOpen += (sender, e) =>
{
Plugin.Log("Connected! Sending login info!");
_ws.Send("CAP REQ :twitch.tv/tags twitch.tv/commands twitch.tv/membership");
string username = Config.Instance.TwitchUsername;
if (username == String.Empty || Config.Instance.TwitchOAuthToken == String.Empty)
{
username = "******" + _rand.Next(10000, 1000000);
}
else
{
_ws.Send($"PASS {Config.Instance.TwitchOAuthToken}");
}
_ws.Send($"NICK {username}");
if (Config.Instance.TwitchChannelName != String.Empty)
{
_ws.Send($"JOIN #{Config.Instance.TwitchChannelName}");
}
// Display a message in the chat informing the user whether or not the connection to the channel was successful
ConnectionTime = DateTime.Now;
ChatHandler.Instance.displayStatusMessage = true;
Initialized = true;
};
_ws.OnMessage += Ws_OnMessage;
// Then start the connection
_ws.ConnectAsync();
}
public IEnumerator Connect()
{
websocket = new WebSocketSharp.WebSocket(uri.ToString());
if (!String.IsNullOrEmpty(accessToken))
{
websocket.SetCredentials("token", accessToken, true);
}
websocket.OnMessage += (sender, e) =>
{
if (capacity == 0 || events.Count < capacity)
{
lock (events)
{
events.Enqueue(e.RawData);
}
}
else
{
numDroppedEvents++;
}
};
websocket.OnOpen += (sender, e) =>
{
isConnected = true;
};
websocket.OnClose += (sender, e) =>
{
isConnected = false;
if (!e.WasClean)
{
error = e.Reason;
}
};
websocket.OnError += (sender, e) =>
{
isConnected = false;
error = e.Message;
};
websocket.ConnectAsync();
while (!isConnected && String.IsNullOrEmpty(error))
{
yield return(0);
}
}
public override void Connect(string szIp, int nPort)
{
Disconnect();
Uri pUrl = new Uri("ws://" + szIp + ":" + nPort + "/");
string szProtocol = pUrl.Scheme;
if (!szProtocol.Equals("ws") && !szProtocol.Equals("wss"))
{
throw new ArgumentException("Unsupported protocol: " + szProtocol);
}
m_hSocket = new WebSocketSharp.WebSocket(pUrl.ToString());
m_hSocket.OnMessage += (pSender, pEventArgs) => { OnRecv(pEventArgs.RawData, (UInt32)pEventArgs.RawData.Length); };
m_hSocket.OnOpen += (pSender, pEventArgs) => { m_bIsConnected = true; OnConnect(); };
m_hSocket.OnError += OnError;
m_hSocket.ConnectAsync();
}
private void MainForm_Load(object sender, EventArgs e)
{
notifyIcon.Text = this.Text;
notifyIcon.Icon = Properties.Resources.mopidy_icon_gray;
notifyIcon.Visible = true;
imageList.Images.Add(SystemIcons.Error);
imageList.Images.Add(SystemIcons.Warning);
imageList.Images.Add(SystemIcons.Information);
imageList.Images.Add(SystemIcons.Application);
imageList.Images.Add(SystemIcons.Question);
EventClient = new WebSocketSharp.WebSocket("ws://192.168.178.13:6680/mopidy/ws");
EventClient.OnOpen += Client_OnOpen;
EventClient.OnClose += Client_OnClose;
EventClient.OnError += Client_OnError;
EventClient.OnMessage += Client_OnMessage;
EventClient.ConnectAsync();
}
public void Connect(string _url, string _origin, params string[] _protocols)
{
if (NetworkState != State.Closed)
{
return;
}
mUri = new Uri(_url);
mInstance = new WebSocketSharp.WebSocket(mUri.ToString(), _protocols);
mInstance.Origin = _origin;
mInstance.SslConfiguration.ServerCertificateValidationCallback = VerifyServerCertification;
mInstance.SslConfiguration.EnabledSslProtocols = SslProtocols.Tls | SslProtocols.Ssl3;
mInstance.OnOpen += OnOpen;
mInstance.OnClose += OnClose;
mInstance.OnError += OnError;
mInstance.OnMessage += OnMessage;
mInstance.ConnectAsync();
}
public void Connect()
{
if (websocket.ReadyState == WebSocketSharp.WebSocketState.Open)
{
throw new InvalidOperationException("Socket is already open");
}
if (websocket.ReadyState == WebSocketSharp.WebSocketState.Closing)
{
throw new InvalidOperationException("Socket is closing");
}
try
{
websocket.ConnectAsync();
}
catch (Exception e)
{
throw new WebSocketException("Connection failed", e);
}
}
/// <summary>
/// Connect to server using timeout
/// </summary>
/// <returns></returns>
public void Connect()
{
// Create WebSocket instance with timeout info
socket = new WebSocketSharp.WebSocket(url.ToString());
// Listen to messages
socket.OnMessage += (sender, e) =>
{
if (e.IsPing)
{
logger.Info("Received Pong responce from server");
}
messages.Enqueue(e.RawData);
};
// Listen to connection open
socket.OnOpen += (sender, e) =>
{
logger.Debug("WebSocket opened connection");
IsConnected = true;
IsConnecting = false;
};
// Listen to errors
socket.OnError += (sender, e) =>
{
Error = e.Message;
logger.Error(e.Exception);
};
// Listen to connection close
socket.OnClose += (sender, args) =>
{
logger.Debug($"WebSocket closed connection with code [{args.Code}]. Reason: [{args.Reason}]");
IsConnected = false;
};
socket.ConnectAsync();
}
public IEnumerator Connect(Action onSucessAction = null, Action onErrorAction = null)
{
if (socket != null && (socket.IsAlive || isConnecting))
{
yield break;
}
isConnecting = true;
socket = new WebSocketSharp.WebSocket(url.ToString());
socket.AddRequestHeader(XAuthTokenHeaderKey, loginToken);
socket.OnMessage += (sender, e) => messages.Enqueue(e.RawData);
socket.OnOpen += (sender, e) =>
{
isConnecting = false;
Debug.Log("Opened WebSocket connection");
isConnected = true;
if (onSucessAction != null)
{
TaskManager.Instance.RunOnMainThread(onSucessAction);
}
};
socket.OnError += (sender, e) =>
{
isConnecting = false;
Debug.LogError("WebSocket: " + e.Message);
error = e.Message;
if (onErrorAction != null)
{
TaskManager.Instance.RunOnMainThread(onErrorAction);
}
};
socket.ConnectAsync();
while (!isConnected && error == null)
{
yield return(0);
}
}
public override void Connect()
{
_socket.ConnectAsync();
}
private void Reconnect()
{
log.Debug("Trying to reconnect websocket.");
if (isConnecting)
{
return;
}
Stop();
//close current connection
log.Debug("Trying to close old connection.");
Close();
isConnecting = true;
log.Debug("Start getting request to obtain ws address.");
var request = HttpWebClientHelper.CreateRequest(sdkMetadata, string.Format(FluxApiData.WebSocketUrl, ProjectId, reason), UserCookies);
request.Method = "GET";
request.Headers.Add("projectId", ProjectId);
try
{
var response = HttpWebClientHelper.GetResponse(request);
if (response.StatusCode == HttpStatusCode.OK)
{
var wsUrl = DataSerializer.Deserialize <WebSocketAddress>(StreamUtils.GetDecompressedResponseStream(response));
log.Debug("Connecting to Flux wss: {0}", wsUrl.Address);
webSocket = new WebSocketSharp.WebSocket(wsUrl.Address);
webSocket.WaitTime = TimeSpan.FromHours(12);
foreach (var cookie in UserCookies)
{
WebSocketSharp.Net.Cookie wsCookie = new WebSocketSharp.Net.Cookie(cookie.CookieName, cookie.CookieValue, cookie.CookieDomain);
webSocket.SetCookie(wsCookie);
}
webSocket.OnMessage += WebSocket_OnMessage;
webSocket.OnClose += WebSocket_Closed;
webSocket.OnOpen += WebSocket_Opened;
webSocket.OnError += WebSocket_OnError;
webSocket.ConnectAsync();
//start timer
RestartConnectionTimer();
}
}
catch (Exception ex)
{
log.Error(ex);
webSocketState = FluxWebSocketStates.Reconnecting;
if (ex is WebException || ex is Exceptions.ConnectionFailureException || ex is Exceptions.ServerUnavailableException)
{
var webException = ex as WebException;
if (webException != null)
{
var webResponse = (HttpWebResponse)webException.Response;
if (webResponse != null)
{
Close();
return;
}
}
log.Error("Error initializing WebSocket.");
isConnecting = false;
if (reconnectDelay * 2 < MAX_DELAY)
{
reconnectDelay *= 2;
}
else
{
reconnectDelay = MAX_DELAY;
}
RetryReconnect();
}
else
{
log.Error("Unsupported exception was caught. Websocket will be closed.");
Close();
}
}
}
