public static bool Start(Action fnConexion, Action fnEnd, Dictionary <string, Action <object> > handlers)
{
if (handlers.Count == 0)
{
return(false);
}
Debug.Log("Comienza initSocketio()");
try
{
IO.Options opciones = new IO.Options();
opciones.ExtraHeaders.Add("jwt", UserDataScript.getInfo("token"));
opciones.ExtraHeaders.Add("operacion", op);
foreach (KeyValuePair <string, string> entry in args)
{
opciones.ExtraHeaders.Add(entry.Key, entry.Value);
}
socket = IO.Socket(ENDPOINT, opciones);
foreach (KeyValuePair <string, Action <object> > entry in handlers)
{
socket.On(entry.Key, entry.Value);
}
socket.On(QSocket.EVENT_DISCONNECT, (reason) => { Debug.Log("Disconnected: " + reason + " \n" + Environment.StackTrace); PlayersDataScript.eliminarPartida(); fnEnd(); });
socket.On(QSocket.EVENT_RECONNECT, () => { Debug.Log("Reconnected"); });
socket.On(QSocket.EVENT_CONNECT, () => { Debug.Log("Connected"); fnConexion(); });
}catch (Exception e) {
Debug.Log("Exception: " + e);
}
return(true);
}
/// <summary>
/// Subscribe to the events emitted by the block chain.
/// </summary>
/// <param name="regex">Regular Expression to define which events to subscribe to.</param>
/// <param name="callback">Callback function to define the action on the received event.</param>
public void subscribeEvents(Action <object> callback)
{
int retryCount = 0;
string json = "{\"token\" : \"" + apiToken + "\"}";
var opts = new IO.Options {
Path = "/subscribe"
};
socket = IO.Socket("https://api.staging.xooa.io", opts);
Console.WriteLine(socket.GetHashCode());
socket.On(Socket.EVENT_CONNECT, (data) => {
Console.WriteLine("Connected");
Console.WriteLine(data);
socket.Emit("authenticate", JObject.Parse(json));
});
socket.On("authenticated", (data) => {
Console.WriteLine("Authorized");
});
socket.On(Socket.EVENT_CONNECT_ERROR, (data) => {
Console.WriteLine("Connection Error");
Console.WriteLine(data);
socket.Emit(Socket.EVENT_RECONNECT);
});
socket.On(Socket.EVENT_RECONNECT, () => {
if (retryCount <= retries)
{
Console.WriteLine("---Reconnecting---");
retryCount++;
socket.Connect();
}
else
{
Console.WriteLine("Exceeded maximum number of retries allowed");
}
});
socket.On(Socket.EVENT_MESSAGE, (data) => {
Console.WriteLine("Message");
Console.WriteLine(data);
});
socket.On("event", (data) =>
{
Console.WriteLine("event");
Console.WriteLine(data);
JObject jsonData = JObject.Parse(data.ToString());
Console.WriteLine(data);
callback(jsonData);
});
}
public void Open(string url)
{
Debug.Log("SocketIO: connecting to:" + url);
IO.Options opts = new IO.Options();
opts.Transports = ImmutableList <string> .Empty.Add("polling");
Socket socket = IO.Socket(url, opts);
socket.On(Socket.EVENT_CONNECT, () =>
{
Debug.Log("SocketIO: connected!");
this.socket = socket;
InitHandlers();
this.OnConnect();
});
socket.On(Socket.EVENT_CONNECT_ERROR, (msg) =>
{
Debug.Log("SocketIO: connect error!");
this.OnConnectError("error:" + msg);
});
socket.On(Socket.EVENT_DISCONNECT, () =>
{
Debug.Log("SocketIO: disconnected!");
this.OnDisconnect();
this.socket = null;
});
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
this.item = (History)e.Parameter;
var setting = ApplicationData.Current.LocalSettings;
var opts = new IO.Options();
Dictionary <string, string> dictionary = new Dictionary <string, string>();
dictionary.Add("token", setting.Values["AccessToken"].ToString());
opts.Query = dictionary;
socket = IO.Socket(_URL, opts);
socket.Connect();
JObject obj = new JObject();
obj["userId"] = item.UserId;
obj["userName"] = item.UserName;
socket.On(Socket.EVENT_CONNECT, () =>
{
socket.Emit("joinroom", obj);
});
socket.On("joinroom", (data) =>
{
var s = (JObject)data;
});
}
public async Task ConnectAsync(string hostname, int port, Context context)
{
_conversationsRecords = await SqlHelper <ConversationsRecords> .CreateAsync();
_context = context;
try {
var options = new IO.Options {
ForceNew = true,
Reconnection = true,
Secure = false,
//Transports = new string[] { EngineIO.Client.Transports.PollingXHR.TransportName},
Query = $"token={Utils.GetDefaults("Token")}&imei={Utils.GetDeviceIdentificator(Application.Context)}"
};
Socket = IO.Socket(hostname, options);
Socket.On(Socket.EventConnect, OnConnect);
Socket.On(Socket.EventDisconnect, OnDisconnect);
Socket.On(Socket.EventConnectError, OnConnectError);
Socket.On(Socket.EventConnectTimeout, OnConnectTimeout);
//_socket.On(Manager.EventTransport, OnTransport);
Socket.On("conversation", OnConversation);
Socket.On("chat request", OnChatRequest);
Socket.On("chat accepted", OnChatAccepted);
Socket.On("chat rejected", OnChatRejected);
Socket.On("Error", OnError);
Socket.Connect();
//Client = _socket;
} catch (Exception e) {
Log.Error("WSConnectionError: ", e.ToString());
}
}
public override async void Connect(string server, string port, string client_name)
{
Debug.WriteLine("SympleSignaller:Connect: " + server + " " + port + " " + client_name);
if (_socket != null)
{
string err = "the client socket is not null";
Messenger.Broadcast(SympleLog.LogError, err);
throw new Exception(err);
}
_myPeerData.user = client_name;
_myPeerData.name = client_name;
string fullUrl = server + ":" + port;
bool options_secure = (fullUrl != null && (fullUrl.IndexOf("https") == 0 || fullUrl.IndexOf("wss") == 0));
Uri socketUri = new Uri(fullUrl);
var ioOptions = new IO.Options();
ioOptions.Secure = options_secure;
ioOptions.Port = socketUri.Port;
ioOptions.Hostname = socketUri.Host;
ioOptions.IgnoreServerCertificateValidation = true;
_socket = IO.Socket(fullUrl, ioOptions);
_socket.On(Socket.EVENT_CONNECT, SocketOnConnect);
_socket.On(Socket.EVENT_ERROR, SocketOnError);
_socket.On("connecting", SocketOnConnecting);
_socket.On(Socket.EVENT_RECONNECTING, SocketOnReconnecting);
_socket.On("connect_failed", SocketOnConnectFailed);
_socket.On(Socket.EVENT_DISCONNECT, SocketOnDisconnect);
Debug.WriteLine("SympleSignaller:Connect: finished setting up socket");
}
public SympleClient(JObject options) : base()
{
this.options = options;
options["url"] = options["url"] ?? "http://localhost:4000";
options["secure"] = (options["url"] != null && (options["url"].ToString().IndexOf("https") == 0 || options["url"].ToString().IndexOf("wss") == 0));
options["token"] = null;
this.peer = options["peer"] as JObject ?? new JObject();
this.peer["rooms"] = options["peer"]["rooms"] ?? new JArray();
this.roster = new SympleRoster(this);
this.socket = null;
Uri socketUri = new Uri(options["url"].ToString());
ioOptions = new IO.Options();
ioOptions.Secure = (bool)options["secure"];
ioOptions.Port = socketUri.Port;
ioOptions.Hostname = socketUri.Host;
ioOptions.IgnoreServerCertificateValidation = true;
Messenger.Broadcast(SympleLog.LogTrace, "done initing SympleClient, values: ");
Messenger.Broadcast(SympleLog.LogTrace, "this.peer: " + this.peer.ToString());
}
private bool EstablishSocketConnection()
{
if (!cxToken.IsCancellationRequested)
{
var options = new IO.Options()
{
Reconnection = true,
AutoConnect = true,
QueryString = "UrlToken=" + this.socketEndpointOptions.URLToken,
Upgrade = true,
ForceNew = true,
Multiplex = false,
Transports = new List <string> {
WebSocket.NAME, Polling.NAME
}
};
this.mySocket = IO.Socket(new Uri(this.socketEndpointOptions.EndpointURL), options);
this.mySocket.On(Socket.EVENT_CONNECT, () =>
{
this.isConnected = true;
waitHandle.Set();
});
this.mySocket.On(Socket.EVENT_CONNECT_ERROR, (data) => { throw new CognigyConnectionException(ConnectionErrorType.ConnectionError, data.ToString()); });
this.mySocket.On(Socket.EVENT_CONNECT_TIMEOUT, (data) => { Debug.LogError(data); throw new CognigyConnectionException(ConnectionErrorType.ConnectionTimeout, Convert.ToString(data)); });
this.mySocket.On(Socket.EVENT_ERROR, (data) => { Debug.LogError(data); throw new CognigyAIException(AIErrorType.Error, Convert.ToString(data)); });
this.mySocket.On(EVENT_EXCEPTION, (data) => { Debug.LogError(data); throw new CognigyAIException(AIErrorType.Exception, Convert.ToString(data)); });
this.mySocket.On(Socket.EVENT_DISCONNECT, (data) => { Debug.Log("-- [COGNIGY.AI] Socket Client disconnected --"); this.isConnected = false; });
this.mySocket.On(EVENT_OUTPUT, (data) =>
{
if (OnOutput != null)
{
JObject response = JObject.FromObject(data);
if (response["type"].ToString() == "output")
{
OnOutput(this, new FlowOutputEventArgs(BuildFlowOutput(response["data"])));
}
}
});
if (CustomWaitHandle.CancelableWaitOne(waitHandle, millisecondsTimeout, cxToken))
{
return(true);
}
else //Timeout
{
Disconnect();
throw new CognigyConnectionException(ConnectionErrorType.ConnectionTimeout, "No answer from server received");
}
}
else
{
throw new CognigyOperationCanceledException();
}
}
private void OnConnect()
{
ConnectionStatus = "connectAttempt";
Regex rgx = new Regex("^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$");
if (!rgx.IsMatch(ServerAddress))
{
System.Windows.MessageBox.Show("Wrong Address format", "Error");
ConnectionStatus = "disconnected";
return;
}
IO.Options op = new IO.Options
{
Reconnection = false
};
socket = IO.Socket("http://" + ServerAddress + ":" + SERVER_PORT, op);
socket.On(Socket.EVENT_CONNECT, () =>
{
ConnectionStatus = "connecting";
});
socket.On(Socket.EVENT_CONNECT_TIMEOUT, () =>
{
System.Windows.MessageBox.Show("Connection timeout", "Error");
ConnectionStatus = "disconnected";
});
socket.On(Socket.EVENT_CONNECT_ERROR, () =>
{
System.Windows.MessageBox.Show("Connection error", "Error");
ConnectionStatus = "disconnected";
});
}
public static void Main(string[] args)
{
string bearer_token = string.Empty;
var options = new IO.Options
{
ForceNew = true,
Query = new Dictionary <string, string> {
{ "access_token", TOKEN }
}
};
var socket = IO.Socket(BASE_URL, options);
socket.On(Socket.EVENT_CONNECT, () =>
{
bearer_token = "Bearer " + socket.Io().EngineSocket.Id + TOKEN;
OnConnect(bearer_token);
});
socket.On(Socket.EVENT_CONNECT_ERROR, (error) =>
{
OnConnectError(error);
});
Console.ReadKey();
}
private void Connect()
{
var options = new IO.Options()
{
IgnoreServerCertificateValidation = true, AutoConnect = true, ForceNew = true
};
socket = IO.Socket("https://" + Class1.config.ipa + ":3000", options);
// 接続時のイベント
socket.On(Socket.EVENT_CONNECT, async() =>
{
// UIとは別スレッドなので Dispatcher を利用する
await Dispatcher.BeginInvoke(new Action(() =>
{
Class1.config.con = "Connected";
Check();
}));
});
// "msg" 受信時
socket.On("message", async(data) =>
{
// UIとは別スレッドなので Dispatcher を利用する
await Dispatcher.BeginInvoke(new Action(() =>
{
TxtBox2.Text = Convert.ToString(data);
Class1.config.cnt++;
Check();
}));
});
}
// Need to be called only once, to connect to the server
// and configure
public void SetupSocket()
{
IO.Options options = new IO.Options();
options.Timeout = 2;
socket = IO.Socket("http://localhost:3000", options);
socket.On(Socket.EVENT_CONNECT, () => {
connected = true;
Message msg = new Message(ConnectionToServer.name, JsonConvert.SerializeObject(new ConnectionToServer()));
socket.Emit("userId", JsonConvert.SerializeObject(msg));
});
socket.On(Socket.EVENT_CONNECT_ERROR, () => { Debug.Log("Connection Timeout"); });
socket.On(Connection.name, (data) => {
string jsonMsg = data.ToString();
Message msg = JsonConvert.DeserializeObject <Message>(jsonMsg);
Connection handle = JsonConvert.DeserializeObject <Connection>(msg.jsonData);
connectionEventCallbacks(handle.id, handle.connection);
});
socket.On(UpdatePosition.name, UpdatePositionHandle);
socket.On(Vote.name, VoteHandle);
socket.On(Fire.name, (data) => {
string jsonMsg = data.ToString();
Message msg = JsonConvert.DeserializeObject <Message>(jsonMsg);
Fire handle = JsonConvert.DeserializeObject <Fire>(msg.jsonData);
fireEventCallbacks(handle.id);
});
}
private void socketIoManager()
{
// aqui ficam as configurações que nós definimos no back-end
// nada de mais, mas sem elas não tem como fazer a conexão
var option = new IO.Options()
{
Path = "/socket/",
AutoConnect = true,
};
// aqui vc instancia o soket passando as configurações
// com essa instancia vc consegue escutar as conexões e mandar informacoes
// aqui vc coloca o endereço da api
var socket = IO.Socket("http://localhost:0000", option);
// esse evento só checa se a conexao foi feita
socket.On(Socket.EVENT_CONNECT, () =>
{
Console.WriteLine("Connected");
System.Diagnostics.Debug.WriteLine("Connected");
});
////////////////////////////////////////////////////////////////////////////////
// esse evento escuta todas as mensagens mandadas para esse chat
// com o id da conversa você está participando
var chatId = "49c3e4c0-9936-11ea-b8a9-5b7fcb8fc688";
var mensagemss = new { texto = "", chatId = "" };
socket.On("leadsOnline", (leads) =>
{
Console.WriteLine(leads);
});
socket.On("digitando-chat-" + chatId, (leads) =>
{
Console.WriteLine(leads);
});
socket.On("usuariosOnline", (usuarios) =>
{
Console.WriteLine(usuarios);
});
// esse é o evento que fica escutando as respostas do chat
socket.On("chegouMensagem-chat", (mensagem) =>
{
// convertendo porcamente só para mostrar o objeto javascript em um objeto c#
var json = Newtonsoft.Json.JsonConvert.SerializeObject(mensagem);
var msg = JsonConvert.DeserializeAnonymousType((string)json, mensagemss);
// verificando o id do chat
if (String.Equals(msg.chatId, chatId))
{
// mostrando a mensagem do chat
Console.WriteLine(msg.texto);
}
});
}
static void Main(string[] args)
{
var options = new IO.Options {
IgnoreServerCertificateValidation = true, AutoConnect = true, ForceNew = true
};
options.Transports = ImmutableList.Create <string>("websocket");
var socket = IO.Socket("http://127.0.0.1:3030", options);
socket.On(Socket.EVENT_ERROR, (error) =>
{
Console.WriteLine("Generic error {0}", error);
});
socket.On(Socket.EVENT_CONNECT_ERROR, (error) =>
{
Console.WriteLine("Connect error {0}", error);
});
socket.On(Socket.EVENT_CONNECT, (data) =>
{
Console.WriteLine("Connected {0}", data);
});
socket.On(Socket.EVENT_MESSAGE, (message) =>
{
Console.WriteLine("Message arrived {0}", message);
});
socket.On("channel created", (message) =>
{
Console.WriteLine("Message arrived for create new {0}", message);
});
socket.On("channel updated", (message) =>
{
Console.WriteLine("Message arrived for updated data {0}", message);
});
// credentials
var credentials = new JObject();
credentials["username"] = "******";
credentials["password"] = "******";
credentials["strategy"] = "local";
socket.On("reauthentication-error", (message) => {
socket.Emit("authenticate", (error, context) => {
Console.WriteLine("reauthenticated");
}, credentials);
});
socket.Emit("authenticate", (error, context) => {
Console.WriteLine("authenticated");
}, credentials);
Console.ReadKey();
}
public ISocket GetSocket(string uri, string query)
{
var opts = new IO.Options();
opts.QueryString = query;
var sock = IO.Socket($"{uri}", opts);
return(new Socket(sock));
}
private static Socket CreateSocket(int id)
{
var options = new IO.Options();
//options.Transports = ImmutableList.Create("polling");
options.ExtraHeaders = new Dictionary <string, string>()
{
{ "token", "123xyz" }
};
var socket = IO.Socket("http://localhost:8000", options);
socket.On(Socket.EVENT_CONNECT, () =>
{
Console.WriteLine(id + " Connected");
});
socket.On(Socket.EVENT_DISCONNECT, () =>
{
Console.WriteLine(id + " Disconnected");
});
socket.On(Socket.EVENT_MESSAGE, (data) =>
{
Console.WriteLine(id + " received: " + data);
socket.Send("ack");
socket.Send(data);
});
socket.On("execute", new Acks2ListenerImpl((job, cb) =>
{
Console.WriteLine(id + " received: Execute " + job);
var iack = (IAck)cb;
iack.Call("received");
var fakeJob = Task <bool> .Factory.StartNew(() =>
{
Thread.Sleep(5000);
return(true);
});
bool success = fakeJob.Result;
var result = new
{
id = ((dynamic)job).id,
success = success
};
Console.WriteLine("Emitting job complete");
socket.Emit("complete", JsonConvert.SerializeObject(result));
}));
socket.On(Socket.EVENT_ERROR, (err) =>
{
Console.WriteLine($"Error: {err}");
});
return(socket);
}
public WebSocket()
{
if (string.IsNullOrEmpty(Properties.Settings.Default.WebSocketUrl))
{
new ArgumentNullException("WebSocket URLが設定されていません。");
}
var options = new IO.Options();
//// JWT Token
//if (Model.WebAPI != null && !string.IsNullOrEmpty(Model.WebAPI.token))
//{
// options.ExtraHeaders.Add("Authorization", string.Format("Bearer {0}", Model.WebAPI.token));
//}
socket = IO.Socket(Properties.Settings.Default.WebSocketUrl, options);
socket.On(Socket.EVENT_CONNECT, (data) =>
{
logger.Debug($"EVENT_CONNECT {data}");
JObject jout = JObject.FromObject(new { channel = "BroadcastChannel" });
socket.Emit("subscribe", jout);
});
socket.On(Socket.EVENT_CONNECT_ERROR, (data) =>
{
logger.Debug($"EVENT_CONNECT_ERROR {data}");
});
socket.On(Socket.EVENT_CONNECT_TIMEOUT, (data) =>
{
logger.Debug($"EVENT_CONNECT_TIMEOUT {data}");
});
socket.On(Socket.EVENT_DISCONNECT, (data) =>
{
logger.Debug($"EVENT_DISCONNECT {data}");
});
socket.On(Socket.EVENT_ERROR, (data) =>
{
logger.Debug($"EVENT_ERROR {data}");
});
socket.On(Socket.EVENT_MESSAGE, (data) =>
{
logger.Debug($"EVENT_MESSAGE {data}");
});
// プレゼンス情報の更新イベント
socket.On("App\\Events\\PresenceUpdated", new PresenceUpdateEvent(this));
}
private void SetupMeshbluConnection()
{
var opts = new IO.Options();
opts.Port = _config.MeshbluPort;
opts.ForceNew = true;
opts.Secure = true;
opts.IgnoreServerCertificateValidation = true;
_socket = Quobject.SocketIoClientDotNet.Client.IO.Socket(_config.MeshbluUrl, opts);
}
private IO.Options CreateOptions()
{
var options = new IO.Options();
options.Port = 3000;
options.Hostname = "http://localhost";
options.ForceNew = true;
//log.Info("Please add to your hosts file: 127.0.0.1 " + options.Hostname);
return(options);
}
protected IO.Options CreateOptionsSecure()
{
var log = LogManager.GetLogger(Global.CallerName());
var config = ConfigBase.Load();
var options = new IO.Options();
options.Port = config.server.ssl_port;
options.Hostname = config.server.hostname;
log.Info("Please add to your hosts file: 127.0.0.1 " + options.Hostname);
options.Secure = true;
options.IgnoreServerCertificateValidation = true;
return(options);
}
public LinkIO connect(Action listener)
{
IO.Options opts = new IO.Options();
Dictionary <String, String> query = new Dictionary <String, String>();
query.Add("user", user);
if (id != "")
{
query.Add("id", id);
}
opts.Query = query;
opts.AutoConnect = false;
socket = IO.Socket("http://" + serverIP, opts);
socket.On("users", (e) =>
{
if (userInRoomChangedListener != null)
{
userInRoomChangedListener.Invoke(((JArray)e).ToObject <List <User> >());
}
});
socket.On(Socket.EVENT_CONNECT, () =>
{
connected = true;
listener.Invoke();
});
socket.On(Socket.EVENT_DISCONNECT, () =>
{
connected = false;
});
socket.On("event", (Object o) =>
{
JObject evt = (JObject)o;
String eventName = (String)evt.SelectToken("type");
if (eventListeners.ContainsKey(eventName))
{
eventListeners[eventName].Invoke(new Event(evt));
}
});
socket.Connect();
return(this);
}
static void Main(string[] args)
{
//testnsspi();
var config = new IO.Options
{
Transports = ImmutableList.Create(WebSocket.NAME /*, Polling.NAME*/),
ForceNew = true,
AutoConnect = false,
Timeout = 60000,
ReconnectionDelay = 5000,
ReconnectionDelayMax = 5000,
ReconnectionAttempts = 0
};
var url = new Uri("https://socketlab.screenmeet.com");
var manager = new Manager(url, config);
var socket = manager.Socket(url.LocalPath);
socket.On(Socket.EVENT_CONNECT, () =>
{
Console.WriteLine("Connected");
})
.On(Socket.EVENT_DISCONNECT, () =>
{
Console.WriteLine("Disconnected");
})
.On(Socket.EVENT_CONNECT_ERROR, data =>
{
Console.WriteLine($"Connect Error: {data}");
})
.On(Socket.EVENT_ERROR, data =>
{
Console.WriteLine($"Error: {data}");
})
.On("message", data =>
{
Console.WriteLine(data);
});
socket.Connect();
socket.Emit("message", () => { }, "test 12345");
Thread.Sleep(2000);
socket.Emit("message", () => { }, "test 64578");
Console.ReadLine();
}
protected IO.Options CreateOptions()
{
var log = LogManager.GetLogger(Global.CallerName());
var config = ConfigBase.Load();
var options = new IO.Options();
options.Port = config.server.port;
options.Hostname = config.server.hostname;
options.ForceNew = true;
log.Info("Please add to your hosts file: 127.0.0.1 " + options.Hostname);
return(options);
}
private void Init(string path, string query)
{
if (query != null)
{
var opts = new IO.Options()
{
Query = query
};
sock = IO.Socket(path, opts);
}
else
{
sock = IO.Socket(path);
}
}
internal void ShowGameView(LoginResponse loginResponse)
{
IO.Options options = new IO.Options {
AutoConnect = false
};
//IO.Options options = null;
clientsocket = IO.Socket(Globals.URLWITHPORTNO, options);
clientsocket.Connect();
GameView gameView = new GameView(this, clientsocket, loginResponse);
gameView.Parent = tableLayoutPanel1;
tableLayoutPanel1.Controls.Add(gameView);
this.Size = gameView.MaximumSize;
}
IO.Options CreateDefaultOptions()
{
IO.Options options = new IO.Options();
options.QueryString = String.Format("{0}={1}&{2}={3}&{4}={5}",
PID_KEY,
Process.GetCurrentProcess().Id.ToString(),
SDK_VERSION_KEY,
GameLiftServerAPI.GetSdkVersion().Result,
FLAVOR_KEY,
FLAVOR
);
options.AutoConnect = false;
options.ForceNew = true;
options.Transports = System.Collections.Immutable.ImmutableList.Create("websocket");
return(options);
}
public SocketManager(bool isOffline)
{
this.IsOffline = isOffline;
if (!this.IsOffline)
{
IO.Options op = new IO.Options
{
Reconnection = false
};
Socket = IO.Socket("http://" + SERVER_ADDRESS + ":" + SERVER_PORT, op);
//InitializeOns();
}
else
{
this.UserName = "******";
this.SessionID = "offlineSessionId";
}
this.Compteur = 0;
}
IO.Options CreateDefaultOptions()
{
IO.Options options = new IO.Options();
options.QueryString = String.Format("{0}={1}&{2}={3}&{4}={5}",
PID_KEY,
Process.GetCurrentProcess().Id.ToString(),
SDK_VERSION_KEY,
GameLiftServerAPI.GetSdkVersion().Result,
FLAVOR_KEY,
FLAVOR
);
options.AutoConnect = false;
options.Transports = new List <string>()
{
"websocket"
};
return(options);
}
static void Main(string[] args)
{
var opts = new IO.Options {
ForceNew = true, Upgrade = true
};
var socket = IO.Socket("https://streams.dapowerplay.com?apikey=xxxxx-xxxx-xxxx-xxxx-xxxxxxxx&apisecret=xxxxx-xxxxxxx-xxxxxxx-xxxxxxx", opts);
//example parameters
var jsonParams = JsonConvert.DeserializeObject("[{ product: 'trades', exchange: 'bitstamp', base: 'BTC', quote: 'USD'}]");
socket.On(Socket.EVENT_CONNECT, d =>
{
Console.WriteLine("Connected!");
socket.Emit("subscribe", (err, stream) => { }, jsonParams);
});
socket.On("trades", trades => { Console.WriteLine(trades); });
Console.ReadLine();
}
/// <summary>
/// Toggle on and off subscription to automatic
/// BIM update from cloud. Return true when subscribed.
/// </summary>
public static bool ToggleSubscription()
{
if (null != _event)
{
Util.Log("Unsubscribing...");
_socket.Disconnect();
_socket = null;
_bimUpdater = null;
_event.Dispose();
_event = null;
Util.Log("Unsubscribed.");
}
else
{
Util.Log("Subscribing...");
_bimUpdater = new BimUpdater();
var options = new IO.Options()
{
IgnoreServerCertificateValidation = true,
AutoConnect = true,
ForceNew = true
};
_socket = IO.Socket(_url, options);
_socket.On(Socket.EVENT_CONNECT, ()
=> Util.Log("Connected"));
_socket.On("transform", data
=> Enqueue(data));
_event = ExternalEvent.Create(_bimUpdater);
Util.Log("Subscribed.");
}
return(null != _event);
}
