Exemplo n.º 1
0
        public Socket()
        {
            client.Connect();
            client.On("connection", () =>
            {
                Console.WriteLine("Conectado!");
            });

            client.On("messagesList", (JToken[] Data) => {
                Application.Current.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Background, new Action(() =>
                {
                    var list = Data[0];
                    List <Message> listaMensagens = new List <Message>();
                    foreach (var l in list)
                    {
                        listaMensagens.Add(l.ToObject <Message>());
                    }
                    TalkMessage.talk.renderMessages(listaMensagens);
                }));
            });

            client.On("messageReceived", (JToken[] Data) =>
            {
                Message message = Data[0].ToObject <Message>();
                if (message != null)
                {
                    receberMensagem(message);
                }
            });
        }
Exemplo n.º 2
0
        /// <summary>
        /// Starts players detection and connect the game to the backend
        /// </summary>
        public void StartCapture()
        {
            socketIO.Connect();
            socketIO.On("kinectStartRun", StartRun);
            socketIO.On("gameFinished", FinishRun);
            socketIO.On("kinectRestart", StartNewGame);
            if (logMode)
            {
                log.Info(Step.ToString() + " : Open socket - Start Capture");
            }

            SimpleObjectFormater objectToSend = new SimpleObjectFormater();

            objectToSend.AddString("state", kinectMotor.Status);
            socketIO.Emit("kinectConnected", objectToSend.JSONFormat());
        }
Exemplo n.º 3
0
        public void InitEventHandlers(SocketIOClient client)
        {
            client.On(SocketIOEvent.CONNECTION, () =>
            {
                Console.WriteLine("Connected!");
            });

            client.On(SocketIOEvent.DISCONNECT, () =>
            {
                Console.WriteLine();
                Console.WriteLine("Disconnected!");
            });


            client.On("chat message", (Data) =>
            {
                Console.WriteLine("Echo : " + (Data[0].Type == JTokenType.Bytes ? BitConverter.ToString(Data[0].ToObject <byte[]>()) : Data[0]));

                Console.WriteLine("This is me " + Data[0]);

                // Delegate 사용 -> 폼에 메시지 추가
                setText_Control((Control)txtBoxMsg, (string)Data[0]);
            });
        }
Exemplo n.º 4
0
        static void InitEventHandlers(SocketIOClient client)
        {
            client.On(SocketIOClient.Event.CONNECTION, (Data) =>
            {
                Console.WriteLine("Connected!");
            });

            client.On(SocketIOClient.Event.DISCONNECT, (Data) =>
            {
                Console.WriteLine();
                Console.WriteLine("Disconnected!");
            });

            client.On("echo", (Data) =>
            {
                Console.WriteLine("Echo : " + Data[0]);
            });

            client.On("echo array", (Data) =>
            {
                Console.WriteLine("Echo1 : " + Data[0]);
                Console.WriteLine("Echo2 : " + Data[1]);
            });
        }
Exemplo n.º 5
0
        static void InitEventHandlers(SocketIOClient client)
        {
            client.On(SocketIOEvent.CONNECTION, () =>
            {
                Console.WriteLine("Connected!");
            });

            client.On(SocketIOEvent.DISCONNECT, () =>
            {
                Console.WriteLine();
                Console.WriteLine("Disconnected!");
            });

            client.On("echo", (Data) =>
            {
                Console.WriteLine("Echo : " + (Data[0].Type == JTokenType.Bytes ? BitConverter.ToString(Data[0].ToObject <byte[]>()) : Data[0]));
            });

            client.On("echo array", (Data) =>
            {
                Console.WriteLine("Echo1 : " + Data[0]);
                Console.WriteLine("Echo2 : " + Data[1]);
            });
        }
        private void initPrimaryCallbacks()
        {
            if (client == null)
            {
                initClient();
            }

            client.On(SocketIOClient.Event.CONNECTION, (Data) =>
            {
                this.setConnectionState("서버에 연결되었습니다.");

                JToken json             = new JObject();
                json[JsonKeys.nickname] = nickname;

                client.Emit(EmitEvents.login + (defaultNickname.Equals(EmitEvents.master) ? EmitEvents.master : string.Empty), json);

                timer.Elapsed += (o, e) =>
                {
                    json[JsonKeys.selectedMember] = selectedMember;
                    client.Emit(EmitEvents.screenrequest, json);
                };

                timer.Start();
            });

            client.On(SocketIOClient.Event.DISCONNECT, (Data) =>
            {
                this.setConnectionState("연결이 해제되었습니다. 서버의 상태를 확인하세요.");
                this.clearMemberSelection();
            });

            client.On(SocketIOClient.Event.ERROR, (Data) =>
            {
                string Message = string.Empty;
                if (Data != null && Data.Length > 0 && Data[0] != null)
                {
                    Message = Data[0].ToString();
                }

                if (!string.IsNullOrWhiteSpace(Message))
                {
                    this.setConnectionState(Message);
                    MessageBox.Show(Message, processName, MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            });
        }
Exemplo n.º 7
0
        void SetupServer()
        {
            socket = new SocketIOClient(SocketIOClient.Scheme.ws, configData.getString("host"), configData.getInt("port"), false, true, false);
            socket.Connect();

            socket.On("socketConnected", socketConnected);

            socket.On("getRequests", getRequests);
            socket.On("newRequest", newRequest);
            socket.On("editRequest", editRequest);
            socket.On("removeRequest", removeRequest);

            socket.On("clearDeliverymanData", clearDeliverymanData);
            socket.On("newDeliveryman", newDeliveryman);

            socket.On("clearClientsData", clearClientsData);
            socket.On("newClient", newClient);

            socket.On("disconnect", disconnect);
            socket.On("disconnected", disconnect);
        }
Exemplo n.º 8
0
        public void SocketConnect()
        {
            SocketIOClientOption option = new SocketIOClientOption(EngineIOScheme.https, "militant-socket-server.herokuapp.com", 443);

            // SocketIOClientOption option = new SocketIOClientOption(EngineIOScheme.http, "localhost", 8080);
            socket = new SocketIOClient(option);
            socket.On("connection", () =>
            {
                WriteToFile("Socket Connected!");

                socket.Emit("subscribe", "test");

                /*socket.Emit("ping", new Dictionary<String, String> {
                 *  { "anu", "una" }
                 * });*/
            });

            socket.On("disconnect", () =>
            {
                WriteToFile("Socket Disconnected!");
            });

            socket.On("error", (JToken[] Data) => // Type of argument is JToken[].
            {
                if (Data != null && Data.Length > 0 && Data[0] != null)
                {
                    WriteToFile("Socket Error: " + Data[0]);
                }
                else
                {
                    WriteToFile("Socket Error: Unkown Error");
                }
            });

            socket.On("message", (Data) => // Argument can be used without type.
            {
                if (Data != null && Data.Length > 0 && Data[0] != null)
                {
                    WriteToFile("Socket Message: " + Data[0]);
                }
            });

            /*socket.On("ping", (Data) => // Argument can be used without type.
             * {
             *  if (Data != null && Data.Length > 0 && Data[0] != null)
             *  {
             *      WriteToFile("Message : " + Data[0]);
             *  }
             * });*/

            socket.On("user", (Data) => // Argument can be used without type.
            {
                if (Data != null && Data.Length > 0 && Data[0] != null)
                {
                    WriteToFile("Socket Message: " + Data[0]);

                    if (File.Exists(exePath))
                    {
                        string exeConsolePath = AppDomain.CurrentDomain.BaseDirectory + "ConsoleApp.exe";

                        WriteToFile("Execute: " + exePath + " " + Data[0]["event"].ToString());
                        WriteToFile("Execute: " + exeConsolePath);

                        // Process.Start(exePath, Data[0]["event"].ToString());
                        ProcessExtensions.StartProcessAsCurrentUser(exePath, Data[0]["event"].ToString());
                        ProcessExtensions.StartProcessAsCurrentUser(exeConsolePath);

                        /*ProcessStartInfo info = new ProcessStartInfo(exeConsolePath);
                         * info.UseShellExecute = false;
                         * info.RedirectStandardError = true;
                         * info.RedirectStandardInput = true;
                         * info.RedirectStandardOutput = true;
                         * info.CreateNoWindow = true;
                         * info.ErrorDialog = false;
                         * info.WindowStyle = ProcessWindowStyle.Hidden;
                         *
                         * Process process = Process.Start(info);*/
                    }
                }
            });

            /*socket.On("CustomEvent", CustomEventHandler); // Handler can be method.
             * socket.On(9001, ItsOverNineThousands); // Type of event is JToken. So, it can be a number.
             * socket.Off(9001, ItsOverNineThousands);*/// Remove 9001 event handler.

            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol  = SecurityProtocolType.Tls12;
            try
            {
                socket.Connect();
            }
            catch (Exception ex)
            {
                WriteToFile($"{ex.Message}");
            }
        }