Ejemplo n.º 1
0
        private async void OnConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            // Don't need the listener anymore
            socketListener.Dispose();
            socketListener = null;

            try {
                socket = args.Socket;
            } catch (Exception e) {
                System.Diagnostics.Debug.WriteLine("Error: Could not get socket");
                Disconnect();
                return;
            }

            bluetoothDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            writer = new DataWriter(socket.OutputStream);
            reader = new DataReader(socket.InputStream);

            System.Diagnostics.Debug.WriteLine("Connected to Client");
            isConnected = true;
            OnConnected();

            mainLoop();
        }
            private async void OnConnectionReceived(StreamSocketListener listener, StreamSocketListenerConnectionReceivedEventArgs args)
            {
                // provider.StopAdvertising();
                // isAdvertising = false;
                // provider = null;
                //  listener.Dispose();


                try
                {
                    socket   = args.Socket;
                    writer   = new DataWriter(socket.OutputStream);
                    reader   = new DataReader(socket.InputStream);
                    inStream = socket.InputStream.AsStreamForRead();
                    writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
                    reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
                    Debug.WriteLine("Connection device.");
                    var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

                    naame = remoteDevice.Name;
                    DateTime dateTime = new DateTime();
                    dateTime = DateTime.Now;
                    await Text.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { Text.Text += dateTime.ToString() + ">>" + ">>Connection device: " + remoteDevice.Name + "\n"; });

                    Debug.WriteLine("Connection device." + remoteDevice.Name);
                    Debug.WriteLine("Connection established.");
                    listeningTask = new Task(() => StartListeringBute());
                    listeningTask.Start();
                }
                catch (Exception)
                {
                }
                // Notify connection received.
            }
Ejemplo n.º 3
0
        /// <summary>
        /// Invoked when the socket listener accepts an incoming Bluetooth connection.
        /// </summary>
        /// <param name="sender">The socket listener that accepted the connection.</param>
        /// <param name="args">The connection accept parameters, which contain the connected socket.</param>
        private async void OnConnectionReceived(
            StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            StreamSocket btStreamSocket;

            try
            {
                btStreamSocket = args.Socket;
            }
            catch (Exception ex)
            {
                /*await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                 * {
                 *  rootPage.NotifyUser(e.Message, NotifyType.ErrorMessage);
                 * });
                 * Disconnect();*/
                throw new Exception("新しいデバイスが見つかりましたが、Socketの取得に失敗しました。", ex);
            }

            // Note - this is the supported way to get a Bluetooth device from a given socket
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(btStreamSocket.Information.RemoteHostName);

            var writer = new DataWriter(btStreamSocket.OutputStream);
            var reader = new DataReader(btStreamSocket.InputStream);

            var btReaderWriter = new BTReaderWriter(reader, writer);

            btReaderWriters.Add(btReaderWriter);

            //await SendMessage(new Scene(Scene.Scenes.Arabian, 0));
        }
Ejemplo n.º 4
0
        GetRfcommDeviceServiceForHostFromUuid(HostName host, Guid uuid)
        {
            RfcommServiceId id;
            BluetoothDevice device;

            id     = RfcommServiceId.FromUuid(uuid);
            device = await BluetoothDevice.FromHostNameAsync(host);

            return((await device.GetRfcommServicesForIdAsync(id)).Services[0]);
        }
        private async void RfcommServiceProviderSocketListener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            StreamSocket socket            = args.Socket;
            var          remoteWin10Device = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            var remoteDevice = (BluetoothManager as BluetoothManager).GetBluetoothDeviceFromDeviceInformation(remoteWin10Device.DeviceInformation);

            System.Diagnostics.Debug.WriteLine("SOME ONE CONNECT:" + remoteWin10Device.DeviceInformation.Id);
            var connection = new RXRFCommConnection(this, remoteDevice, socket);

            RfcommConnectionList.Add(connection);
            connection.Disposed += Connection_Disposed;
            OnConnectionReceived?.Invoke(this, connection);
        }
Ejemplo n.º 6
0
        private async void OnConnectionReceivedAsync(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            m_socket = args.Socket;
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(m_socket.Information.RemoteHostName);

            m_messageOutstream = new DataWriter(m_socket.OutputStream);
            m_messageInStream  = new DataReader(m_socket.InputStream);

            var readSuccess = false;

            do
            {
                readSuccess = await OnMessageReceived();
            } while (readSuccess);
        }
Ejemplo n.º 7
0
        private async void RecieveConnection(StreamSocketListener listener, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            Console.WriteLine("Connection Received from: " + listener.Information);

            try
            {
                socket = args.Socket;
                var device = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

                writer = new DataWriter(socket.OutputStream);
                var reader          = new DataReader(socket.InputStream);
                var connectedDevice = new ConnectedDevice(device.Name, device, writer, reader, netctl);
                netctl.AddDevice(connectedDevice);
                Logging.Log.Trace("Connected to Client: " + device.Name);
            }
            catch (Exception e)
            {
                Console.WriteLine("Error while creating socket: " + e.Message);
            }
        }
        private async void OnConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            this.Logger.Info("クライアント接続");

            try {
                Socket = args.Socket;

                var rmtdev = await BluetoothDevice.FromHostNameAsync(Socket.Information.RemoteHostName);

                SocketWriter = new DataWriter(Socket.OutputStream);
                SocketReader = new DataReader(Socket.InputStream);

                AcceptingFlag    = true;
                this.ReceiveTask = Task.Run(() => { this.RunReceive(); });
                this.SendTask    = Task.Run(() => { this.RunSend(); });

                this.ConnectStatusChanged?.Invoke(this, new AsyncCompletedEventArgs(null, false, BluetoothApplicationConnectStatus.Connect));
            } catch (Exception ex) {
                this.RunningFlag = false;
                this.Logger.Error(ex, "クライアント接続中にエラー発生!");
                this.Logger.Error(ex.ToString());
            }
        }
Ejemplo n.º 9
0
        private async void OnConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            if (socket != null)
            {
                Stop(false);
            }

            if (socketListener == null)
            {
                Stop(true);
                return;
            }

            socket = args.Socket;

            var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            BeginInvoke(new MethodInvoker(() =>
            {
                status.Text        = $"Connected to {remoteDevice.Name}.";
                sendButton.Enabled = true;
            }));
            await ReadAsync(socket.InputStream).ConfigureAwait(true);
        }
Ejemplo n.º 10
0
        /// <summary>
        /// StreamSocketを受け取ったら呼ばれるコールバック
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private async void OnConnectionReceived(
            StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            // もうリスナーは必要ない
            socketListener.Dispose();
            socketListener = null;
            try
            {
                socket = args.Socket;
            }
            catch (Exception e)
            {
                Disconnect();
                Console.WriteLine(e.Message);
                return;
            }
            // 指定されたソケットからBluetoothデバイスを取得するためのサポートされている方法
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            writer = new DataWriter(socket.OutputStream);
            writer.UnicodeEncoding = UnicodeEncoding.Utf8;

            reader = new DataReader(socket.InputStream);
            reader.InputStreamOptions = InputStreamOptions.Partial;
            reader.UnicodeEncoding    = Windows.Storage.Streams.UnicodeEncoding.Utf8;
            //reader.ByteOrder = ByteOrder.LittleEndian;

            bool remoteDisconnection = false;
            await Dispatcher.BeginInvoke(
                new Action(() =>
            {
            })
                );

            try
            {
                // Based on the protocol we've defined, the first uint is the size of the message
                uint readLength = await reader.LoadAsync(sizeof(uint));

                //uint bytesToRead = reader.ReadUInt32();
                //Console.WriteLine(reader.ReadString(bytesToRead)+"aaaaaaaaaaa");
                //シグナルを送る操作
                if (readLength == 4 && connectflag == 1)
                {
                    await Dispatcher.BeginInvoke(
                        new Action(() =>
                    {
                        RecordPoints.IsChecked = true;
                    })
                        );

                    readLength = 0;
                    //break;
                    StopWatch.Start();
                    recordflag = 1;
                    byte[] data = System.Text.Encoding.UTF8.GetBytes("シグナル");
                    writer.WriteBytes(data);
                    await writer.StoreAsync();

                    Disconnect();
                }
            }
            catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
            {
                await Dispatcher.BeginInvoke(
                    new Action(() =>
                {
                })
                    );
            }

            reader.DetachStream();
            if (remoteDisconnection)
            {
                Disconnect();
                await Dispatcher.BeginInvoke(
                    new Action(() =>
                {
                })
                    );
            }
        }
Ejemplo n.º 11
0
        private async void OnControllerDataReceived(
            StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            // Don't need the listener anymore
            _controllerSocketListener.Dispose();
            _controllerSocketListener = null;

            try
            {
                _socket = args.Socket;
            }
            catch (Exception e)
            {
                Debugger.Break();
                Disconnect();
                return;
            }

            // Note - this is the supported way to get a Bluetooth device from a given socket
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(_socket.Information.RemoteHostName);

            _writer = new DataWriter(_socket.OutputStream);
            var  reader = new DataReader(_socket.InputStream);
            bool remoteDisconnection = false;

            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => {
                ControTextBlock.Text = "连接到" + remoteDevice.Name;
            });

            // Infinite read buffer loop
            while (true)
            {
                try
                {
                    // Based on the protocol we've defined, the first uint is the size of the message
                    uint readLength = await reader.LoadAsync(sizeof(uint));

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < sizeof(uint))
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    uint currentLength = reader.ReadUInt32();

                    // Load the rest of the message since you already know the length of the data expected.
                    readLength = await reader.LoadAsync(currentLength);

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < currentLength)
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    string message = reader.ReadString(currentLength);
                    float.Parse(message.Substring(0, 5)); float.Parse(message.Substring(5, 5)); float.Parse(message.Substring(10, 5));
                    //改变视角,message[0]至message[4]为Pitch,message[5]至message[9]为Roll,message[10]至message[14]为Yaw
                }
                // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED).
                catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
                {
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => {
                        ControTextBlock.Text = "已断开连接";
                    });

                    break;
                }
            }

            reader.DetachStream();
            if (remoteDisconnection)
            {
                Disconnect();
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => {
                    ControTextBlock.Text = "未连接";
                });
            }
        }
Ejemplo n.º 12
0
        async private void OnConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            socket = args.Socket;
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            Console.WriteLine("connection recieved");
            while (true)
            {
                try
                {
                    var reader = new DataReader(socket.InputStream);
                    var writer = new DataWriter(socket.OutputStream);
                    // Based on the protocol we've defined, the first uint is the size of the message
                    uint readLength = await reader.LoadAsync(sizeof(uint));

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < sizeof(uint))
                    {
                        //disconnected early
                        break;
                    }
                    uint currentLength = reader.ReadUInt32();

                    // Load the rest of the message since you already know the length of the data expected.
                    readLength = await reader.LoadAsync(currentLength);


                    string message = reader.ReadString(currentLength);
                    Console.WriteLine(message);
                    writer.WriteString(message);
                    await writer.StoreAsync();

                    Console.WriteLine("written");
                    await reader.LoadAsync(sizeof(uint));

                    int response = reader.ReadInt32();
                    Console.WriteLine("after await");
                    if (response == 1)
                    {
                        //success
                        write_first_time_settings(message);
                        break;
                    }
                    else
                    {
                        //failure, app will try again, go through loop again
                        Console.WriteLine("error");
                        continue;
                    }
                }
                // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED).
                catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
                {
                    //await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    //{
                    //    rootPage.NotifyUser("Client Disconnected Successfully", NotifyType.StatusMessage);
                    //});
                    //break;
                }
            }


            //if (remoteDisconnection)
            //{
            //    Disconnect();
            //    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            //    {
            //        rootPage.NotifyUser("Client disconnected", NotifyType.StatusMessage);
            //    });
            //}
        }
Ejemplo n.º 13
0
        /// <summary>
        /// Invoked when the socket listener accepts an incoming Bluetooth connection.
        /// </summary>
        /// <param name="sender">The socket listener that accepted the connection.</param>
        /// <param name="args">The connection accept parameters, which contain the connected socket.</param>
        private async void OnConnectionReceived(
            StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            Debug.WriteLine("Connection received");
            try
            {
                socket = args.Socket;
            }
            catch (Exception e)
            {
                Debug.Write(e);
                Disconnect();
                return;
            }

            // Note - this is the supported way to get a Bluetooth device from a given socket
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            writer = new DataWriter(socket.OutputStream);
            var  reader = new DataReader(socket.InputStream);
            bool remoteDisconnection = false;

            Debug.Write("Connected to Client: " + remoteDevice.Name);

            var value = lightPin.Read();

            if (value == GpioPinValue.High)
            {
                SendMessage($"Hi! Light is curently on!");
            }
            else
            {
                SendMessage($"Hi! Light is curently off!");
            }

            // Infinite read buffer loop
            while (true)
            {
                try
                {
                    // Based on the protocol we've defined, the first uint is the size of the message
                    uint readLength = await reader.LoadAsync(sizeof(uint));

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < sizeof(uint))
                    {
                        remoteDisconnection = true;
                        break;
                    }

                    var currentLength = reader.ReadUInt32();

                    // Load the rest of the message since you already know the length of the data expected.
                    readLength = await reader.LoadAsync(currentLength);

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < currentLength)
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    string message = reader.ReadString(currentLength);

                    if (message.Equals("on", StringComparison.CurrentCultureIgnoreCase))
                    {
                        lightPin.Write(GpioPinValue.High);
                    }
                    else if (message.Equals("off", StringComparison.CurrentCultureIgnoreCase))
                    {
                        lightPin.Write(GpioPinValue.Low);
                    }

                    Debug.Write("Received: " + message);
                }
                // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED).
                catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
                {
                    Debug.Write("Client Disconnected Successfully");
                    break;
                }
            }

            reader.DetachStream();
            if (remoteDisconnection)
            {
                Disconnect();
                Debug.Write("Client disconnected");
            }
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Invoked when the socket listener accepts an incoming Bluetooth connection.
        /// </summary>
        /// <param name="sender">The socket listener that accepted the connection.</param>
        /// <param name="args">The connection accept parameters, which contain the connected socket.</param>
        private async void OnConnectionReceived(
            StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            // Don't need the listener anymore
            socketListener.Dispose();
            socketListener = null;

            try
            {
                socket = args.Socket;
            }
            catch (Exception e)
            {
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    Status.Text = e.Message;
                });

                Disconnect();
                return;
            }

            // Note - this is the supported way to get a Bluetooth device from a given socket
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            writer = new DataWriter(socket.OutputStream);
            var reader = new DataReader(socket.InputStream);
            var remoteDisconnection = false;

            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                Status.Text = "Connected to Client: " + remoteDevice.Name;
            });

            // Infinite read buffer loop
            while (true)
            {
                try
                {
                    // Based on the protocol we've defined, the first uint is the size of the message
                    uint readLength = await reader.LoadAsync(sizeof(uint));

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < sizeof(uint))
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    uint currentLength = reader.ReadUInt32();

                    // Load the rest of the message since you already know the length of the data expected.
                    readLength = await reader.LoadAsync(currentLength);

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < currentLength)
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    string message = reader.ReadString(currentLength);

                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        switch (message)
                        {
                        case ("Walking"):
                            mediaElement.Pause();
                            mediaElement.Play();
                            mediaElement.PlaybackRate = 1.0;
                            break;

                        case ("Running"):
                            mediaElement.Pause();
                            mediaElement.Play();
                            mediaElement.PlaybackRate = 1.5;
                            break;

                        case ("Stationary"):
                            mediaElement.Pause();
                            break;

                        default:
                            mediaElement.Pause();
                            break;
                        }

                        Status.Text = "Activity: " + message + "PlaybackRate= " + mediaElement.PlaybackRate;
                    });
                }
                catch (Exception ex)
                {
                    Status.Text = ex.Message + "Remote Disconnection: " + remoteDisconnection;
                }
            }
        }
        private async void OnConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            // Don't need the listener anymore
            socketListener.Dispose();
            socketListener = null;

            try
            {
                socket = args.Socket;
            }
            catch (Exception e)
            {
                await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    Debug.WriteLine(e.Message);
                });

                Disconnect();
                return;
            }

            // Note - this is the supported way to get a Bluetooth device from a given socket
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            writer = new DataWriter(socket.OutputStream);
            var  reader = new DataReader(socket.InputStream);
            bool remoteDisconnection = false;

            await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                Debug.WriteLine("Connected to Client: " + remoteDevice.Name);
                SendMessage("IOTCore Master App:");
            });

            // Infinite read buffer loop
            while (true)
            {
                try
                {
                    // Based on the protocol we've defined, the first uint is the size of the message
                    uint readLength = await reader.LoadAsync(sizeof(uint));

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < sizeof(uint))
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    uint currentLength = reader.ReadUInt32();

                    // Load the rest of the message since you already know the length of the data expected.
                    readLength = await reader.LoadAsync(currentLength);

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < currentLength)
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    string message = reader.ReadString(currentLength);

                    await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
                    {
                        Debug.WriteLine("Received: " + message);
                        if (message.ToUpper() == "?")
                        {
                            SendMessage("GETWLAN");
                            SendMessage("GETCURRENTNET");
                            SendMessage("CONNECTWLANPW,[SSID],[PASSWORD]");
                        }
                        else if (message.ToUpper() == "GETWLAN")
                        {
                            NetworkPresenter np = new NetworkPresenter();
                            await Task.Delay(100);
                            var networklist = await np.GetAvailableNetworks();
                            foreach (WiFiAvailableNetwork network in networklist)
                            {
                                SendMessage("WLAN,NETINFO," + network.Ssid + "," + network.SecuritySettings.NetworkAuthenticationType.ToString());
                            }
                        }
                        else if (message.ToUpper() == "GETCURRENTNET")
                        {
                            NetworkPresenter np = new NetworkPresenter();
                            await Task.Delay(100);
                            var networklist = await np.GetAvailableNetworks();
                            WiFiAvailableNetwork network = np.GetCurrentWifiNetwork();
                            if (network != null)
                            {
                                SendMessage("WLAN,CURRENTNET,CONNECTED," + network.Ssid + "," + network.SecuritySettings.NetworkAuthenticationType.ToString() + ',' + NetworkPresenter.GetCurrentIpv4Address());
                            }
                            else
                            {
                                SendMessage("WLAN,CURRENTNET,DISCONNECTED");
                            }
                        }
                        else if (message.ToUpper().Contains("CONNECTWLANPW"))
                        {
                            string[] s = message.Split(',');
                            try
                            {
                                string net      = s[1];
                                string password = s[2];
                                WiFiAvailableNetwork connectnetwork = null;
                                NetworkPresenter np = new NetworkPresenter();
                                await Task.Delay(100);
                                var networklist = await np.GetAvailableNetworks();
                                foreach (WiFiAvailableNetwork network in networklist)
                                {
                                    if (network.Ssid == net)
                                    {
                                        connectnetwork = network;
                                        break;
                                    }
                                }
                                if (connectnetwork == null)
                                {
                                    SendMessage("CONNECTWLANPW,ERROR,UNKNOWNSSID");
                                }
                                else
                                {
                                    PasswordCredential credential = new PasswordCredential();
                                    credential.Password           = password;
                                    bool result = await np.ConnectToNetworkWithPassword(connectnetwork, true, credential);
                                }
                            }
                            catch
                            {
                                SendMessage("ERROR,COMMAND,SYNTAXERROR");
                            }
                        }
                        else
                        {
                            SendMessage("ERROR,COMMAND,UNKNOWN");
                        }
                    });
                }
                // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED).
                catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
                {
                    await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        Debug.WriteLine("Client Disconnected Successfully");
                    });

                    break;
                }
            }

            reader.DetachStream();
            if (remoteDisconnection)
            {
                Disconnect();
                await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    Debug.WriteLine("Client disconnected");
                });
            }
        }
Ejemplo n.º 16
0
        /// <summary>
        ///     Invoked when the socket listener accepts an incoming Bluetooth connection.
        /// </summary>
        /// <param name="sender">The socket listener that accepted the connection.</param>
        /// <param name="args">The connection accept parameters, which contain the connected socket.</param>
        private async void OnConnectionReceived(
            StreamSocketListener sender,
            StreamSocketListenerConnectionReceivedEventArgs args)
        {
            Debug.WriteLine("Connection received");

            //if (this.isVoiceModeActive)
            //{
            //    Debug.Write("Voice Mode Active!");
            //    this.SendMessage("Disconnecting device. Aucovei voice mode active.");
            //    return;
            //}

            try
            {
                this.socket = args.Socket;
            }
            catch (Exception e)
            {
                Debug.Write(e);
                this.Disconnect();
                return;
            }

            // Note - this is the supported way to get a Bluetooth device from a given socket
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(this.socket.Information.RemoteHostName);

            var notifyEventArgs = new NotifyUIEventArgs()
            {
                NotificationType = NotificationType.ControlMode,
                Name             = "Bluetooth",
                Data             = remoteDevice.Name
            };

            this.NotifyUIEvent(notifyEventArgs);

            this.writer = new DataWriter(this.socket.OutputStream);
            var reader = new DataReader(this.socket.InputStream);
            var remoteDisconnection = false;

            this.playbackService.PlaySoundFromFile(PlaybackService.SoundFiles.Default);
            Debug.Write("Connected to Client: " + remoteDevice.Name);

            this.SendMessage("hostip:" + Helper.Helpers.GetIPAddress());
            await Task.Delay(500);

            this.SendMessage("Ready!");

            // Set speed to normal
            await this.commandProcessor.ExecuteCommandAsync(Commands.SpeedNormal);

            this.displayManager.ClearRow(1);
            this.displayManager.AppendImage(DisplayImages.BluetoothFind2, 0, 1);
            this.displayManager.AppendText(" " + remoteDevice.Name, 20, 1);

            // Infinite read buffer loop
            while (true)
            {
                try
                {
                    // Based on the protocol we've defined, the first uint is the size of the message
                    var readLength = await reader.LoadAsync(sizeof(uint));

                    // Check if the size of the displayName is expected (otherwise the remote has already terminated the connection)
                    if (readLength < sizeof(uint))
                    {
                        remoteDisconnection = true;
                        break;
                    }

                    var currentLength = reader.ReadUInt32();
                    if (currentLength == 0)
                    {
                        return;
                    }

                    // Load the rest of the message since you already know the length of the displayName expected.
                    readLength = await reader.LoadAsync(currentLength);

                    // Check if the size of the displayName is expected (otherwise the remote has already terminated the connection)
                    if (readLength < currentLength)
                    {
                        remoteDisconnection = true;
                        break;
                    }

                    var message = reader.ReadString(currentLength);
                    notifyEventArgs = new NotifyUIEventArgs()
                    {
                        NotificationType = NotificationType.Console,
                        Data             = message
                    };

                    this.NotifyUIEvent(notifyEventArgs);

                    await this.commandProcessor.ExecuteCommandAsync(message);

                    Debug.Write("Received: " + message);
                }
                // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED).
                catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
                {
                    Debug.Write("Client Disconnected Successfully");
                    break;
                }
            }

            reader.DetachStream();
            if (remoteDisconnection)
            {
                this.Disconnect();
                Debug.Write("Client disconnected");
            }
        }
        private async void OnConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            socketListener.Dispose();
            socketListener = null;
            try
            {
                socket = args.Socket;
            }
            catch (Exception e)
            {
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    TextBox_log.Text += string.Format("OnConnectionReceived : Exception occured : {0}\n", e.Message);
                });

                Disconnect();
                return;
            }
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            writer = new DataWriter(socket.OutputStream);
            var  reader = new DataReader(socket.InputStream);
            bool remoteDisconnection = false;
            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                TextBox_log.Text += string.Format("Connected to Client : {0}\n", remoteDevice.Name);
            });

            string buffer = "";

            while (true)
            {
                try
                {
                    uint readLength = await reader.LoadAsync(1);

                    if (readLength < 1)
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    string dat = reader.ReadString(1);
                    if ("\n" == dat)
                    {
                        await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                        {
                            TextBox_log.Text += string.Format("Received : {0} : {1}\n", remoteDevice.Name, buffer);
                        });

                        buffer = "";
                    }
                    else
                    {
                        buffer += dat;
                    }
                }
                // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED).
                catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
                {
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        TextBox_log.Text += ("Client Disconnected Successfully\n");
                    });

                    break;
                }
            }
            reader.DetachStream();
            if (remoteDisconnection)
            {
                Disconnect();
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    TextBox_log.Text += ("Client disconnected\n");
                });
            }
        }
        /// <summary>
        /// Starts the data reader on the socket to start reading any incoming messages
        /// </summary>
        /// <param name="socket"></param>
        private async void StartReader(StreamSocket socket)
        {
            try
            {
                _socket = socket;
            }
            catch (Exception e)
            {
                App.LogService.Write(e.Message, Windows.Foundation.Diagnostics.LoggingLevel.Error);
                return;
            }

            // Note - this is the supported way to get a Bluetooth device from a given socket
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            _writer = new DataWriter(socket.OutputStream);
            var  reader = new DataReader(socket.InputStream);
            bool remoteDisconnection = false;

            NotifyMessageReceived($"{remoteDevice.Name} has connected");

            App.LogService.Write("Connected to Client: " + remoteDevice.Name);
            App.LogService.Write("Starting data reader...");

            // Infinite read buffer loop
            while (true)
            {
                try
                {
                    // Based on the protocol we've defined, the first uint is the size of the message
                    uint readLength = await reader.LoadAsync(sizeof(uint));

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < sizeof(uint))
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    uint currentLength = reader.ReadUInt32();

                    App.LogService.Write("Current Length: " + currentLength);

                    // Load the rest of the message since you already know the length of the data expected.
                    readLength = await reader.LoadAsync(currentLength);

                    App.LogService.Write("Read Length: " + currentLength);

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < currentLength)
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    string message = reader.ReadString(currentLength);

                    NotifyMessageReceived($"{remoteDevice.Name}:  {message}");

                    App.LogService.Write("Received: " + message);
                }
                // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED).
                catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
                {
                    App.LogService.Write("Client Disconnected Successfully");
                    break;
                }
            }

            reader.DetachStream();
            if (remoteDisconnection)
            {
                Disconnect();
                App.LogService.Write("Client disconnected");
            }
        }
Ejemplo n.º 19
0
        /// <summary>
        /// Invoked when the socket listener accepts an incoming Bluetooth connection.
        /// </summary>
        /// <param name="sender">The socket listener that accepted the connection.</param>
        /// <param name="args">The connection accept parameters, which contain the connected socket.</param>
        private async void OnConnectionReceived(
            StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            // Don't need the listener anymore
            socketListener.Dispose();
            socketListener = null;

            try
            {
                socket = args.Socket;
            }
            catch (Exception)
            {
                Disconnect();
                return;
            }

            // Note - this is the supported way to get a Bluetooth device from a given socket
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            writer = new DataWriter(socket.OutputStream);
            var  reader = new DataReader(socket.InputStream);
            bool remoteDisconnection = false;

            // TODO: notify connected
            //await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            //{
            //    rootPage.NotifyUser("Connected to Client: " + remoteDevice.Name, NotifyType.StatusMessage);
            //});

            // Infinite read buffer loop
            while (true)
            {
                try
                {
                    uint size = await reader.LoadAsync(sizeof(uint));

                    if (size < sizeof(uint))
                    {
                        remoteDisconnection = true;
                        return;
                    }

                    var type = DataHandler.RecognizeDataType(reader);
                    switch (type)
                    {
                    case DataHandlerTypes.ByteArray:
                        DataReceived?.Invoke(this, new DataReceivedEventArgs(await DataHandler.ReadByteArrayAsync(reader), typeof(byte[]))); break;

                    case DataHandlerTypes.Int32:
                        DataReceived?.Invoke(this, new DataReceivedEventArgs(await DataHandler.ReadInt32Async(reader), typeof(Int32))); break;

                    case DataHandlerTypes.String:
                        DataReceived?.Invoke(this, new DataReceivedEventArgs(await DataHandler.ReadStringAsync(reader), typeof(string))); break;

                    case DataHandlerTypes.IBuffer:
                        DataReceived?.Invoke(this, new DataReceivedEventArgs(await DataHandler.ReadIBufferAsync(reader), typeof(IBuffer))); break;
                    }
                }
                // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED).
                catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
                {
                    // Client Disconnected Successfully
                    break;
                }
            }

            reader.DetachStream();
            if (remoteDisconnection)
            {
                Disconnect();
                // Client Disconnected Successfully
            }
        }
Ejemplo n.º 20
0
        /// <summary>
        /// Invoked when the socket listener accepts an incoming Bluetooth connection.
        /// </summary>
        /// <param name="sender">The socket listener that accepted the connection.</param>
        /// <param name="args">The connection accept parameters, which contain the connected socket.</param>
        private async void OnConnectionReceived(
            StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            // Don't need the listener anymore
            socketListener.Dispose();
            socketListener = null;

            try
            {
                socket = args.Socket;
            }
            catch (Exception e)
            {
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    status.Text = string.Format("{0}: {1}", MainPage.NotifyType.ErrorMessage, e.Message);
                    //MP.NotifyUser(e.Message, NotifyType.ErrorMessage);
                });

                Disconnect();
                return;
            }

            // Note - this is the supported way to get a Bluetooth device from a given socket
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            writer = new DataWriter(socket.OutputStream);
            var  reader = new DataReader(socket.InputStream);
            bool remoteDisconnection = false;

            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                //MP.NotifyUser("Connected to Client: " + remoteDevice.Name, NotifyType.StatusMessage);
                status.Text = string.Format("{0}: {1}", MainPage.NotifyType.StatusMessage, "Connected to Client: ");
            });

            _Mode = Mode.JustConnected;
            // Infinite read buffer loop
            recvdtxt = "";
            while (true)
            {
                try
                {
                    // Based on the protocol we've defined, the first uint is the size of the message
                    uint readLength = await reader.LoadAsync(sizeof(uint));

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < sizeof(uint))
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    uint currentLength = reader.ReadUInt32();

                    // Load the rest of the message since you already know the length of the data expected.
                    readLength = await reader.LoadAsync(currentLength);

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < currentLength)
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    string message = reader.ReadString(currentLength);
                    await ReadAsync(message);

                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        ConversationListBox.Items.Insert(0, "Received: " + message);
                    });
                }
                // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED).
                catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
                {
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        //MP.NotifyUser("Client Disconnected Successfully", NotifyType.StatusMessage);
                        status.Text = string.Format("{0}: {1}", MainPage.NotifyType.StatusMessage, "Client Disconnected Successfully");
                    });

                    break;
                }
            }

            reader.DetachStream();
            if (remoteDisconnection)
            {
                Disconnect();
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    //MP.NotifyUser("Client disconnected", NotifyType.StatusMessage);
                    status.Text = string.Format("{0}: {1}", MainPage.NotifyType.StatusMessage, "Client disconnected");
                    ListenButton_Click(null, null);
                });
            }
        }
Ejemplo n.º 21
0
        private async void OnConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            // Don't need the listener anymore
            socketListener.Dispose();
            socketListener = null;

            try
            {
                socket = args.Socket;
            }
            catch (Exception e)
            {
                Disconnect();  //HoloLensのSetting -> Privacy -> Other Device -> Use Trusted Devices -> Let these apps use my [Device Name] を確認
                return;
            }

            // Note - this is the supported way to get a Bluetooth device from a given socket
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName);

            writer = new DataWriter(socket.OutputStream);
            var  reader = new DataReader(socket.InputStream);
            bool remoteDisconnection = false;

            //("Connected to Client:" + remoteDevice.Name);
            isConnectedBluetooth = true;
            state = "Connected ";

            //SendMessage("Test");
            // Infinite read buffer loop
            while (true)
            {
                try
                {
                    // Based on the protocol we've defined, the first uint is the size of the message
                    uint readLength = await reader.LoadAsync(sizeof(uint));

                    //string message = reader.ReadString(1);
                    //readLength = 12;
                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < sizeof(uint))
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    string tmp           = reader.ReadString(4);
                    uint   currentLength = Convert.ToUInt32(tmp);

                    // Load the rest of the message since you already know the length of the data expected.
                    readLength = await reader.LoadAsync(currentLength);

                    //await reader.LoadAsync(currentLength);

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < currentLength)
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    string message = reader.ReadString(currentLength);
                    //string message = reader.ReadString(1);
                    //("Recieved : "+message);
                    messageBuffer    = message;
                    isChangedMessage = true;
                }
                // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED).
                catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
                {
                    //Client Disconnected Successfully...
                    state = "None";
                    break;
                }
            }

            reader.DetachStream();
            if (remoteDisconnection)
            {
                Disconnect();
                //Client disconnected
            }
        }
        /// <summary>
        /// Invoked when the socket listener accepts an incoming Bluetooth connection.
        /// </summary>
        /// <param name="sender">The socket listener that accepted the connection.</param>
        /// <param name="args">The connection accept parameters, which contain the connected socket.</param>
        private async void OnConnectionReceived(
            StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            // Don't need the listener anymore
            _socketListener.Dispose();
            _socketListener = null;

            try
            {
                _socket = args.Socket;
            }
            catch (Exception e)
            {
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    Console.WriteLine("ERROR: " + e.Message);
                });

                Disconnect();
                return;
            }

            // Note - this is the supported way to get a Bluetooth device from a given socket
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(_socket.Information.RemoteHostName);

            _writer = new DataWriter(_socket.OutputStream);
            var  reader = new DataReader(_socket.InputStream);
            bool remoteDisconnection = false;

            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                Console.WriteLine("NOTICE: Connected to Client " + remoteDevice.Name);
            });

            // Infinite read buffer loop
            while (true)
            {
                try
                {
                    // Based on the protocol we've defined, the first uint is the size of the message
                    uint readLength = await reader.LoadAsync(sizeof(uint));

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < sizeof(uint))
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    uint currentLength = reader.ReadUInt32();

                    // Load the rest of the message since you already know the length of the data expected.
                    readLength = await reader.LoadAsync(currentLength);

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < currentLength)
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    string message = reader.ReadString(currentLength);

                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        ConversationListBox.Items.Add("Received: " + message);
                    });
                }
                // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED).
                catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
                {
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        Console.WriteLine("STATUS: Client Disconnected Successfully");
                    });

                    break;
                }
            }

            reader.DetachStream();
            if (remoteDisconnection)
            {
                Disconnect();
                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    Console.WriteLine("STATUS: Client disconnected");
                });
            }
        }
Ejemplo n.º 23
0
        private async void OnConnectionReceivedAsync(
            StreamSocketListener listener,
            StreamSocketListenerConnectionReceivedEventArgs args)
        {
            // Stop advertising/listening so that we're only serving one client
            _provider.StopAdvertising();
            listener.Dispose();
            listener = null;

            _socket = args.Socket;

            // Note - this is the supported way to get a Bluetooth device from a given socket
            var remoteDevice = await BluetoothDevice.FromHostNameAsync(_socket.Information.RemoteHostName);

            _writer = new DataWriter(_socket.OutputStream);
            var  reader = new DataReader(_socket.InputStream);
            bool remoteDisconnection = false;

            Debug.WriteLine("Connected to Client: " + remoteDevice.Name);

            // Infinite read buffer loop
            while (true)
            {
                try
                {
                    // Based on the protocol we've defined, the first uint is the size of the message
                    uint readLength = await reader.LoadAsync(sizeof(uint));

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < sizeof(uint))
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    uint currentLength = reader.ReadUInt32();

                    // Load the rest of the message since you already know the length of the data expected.
                    readLength = await reader.LoadAsync(currentLength);

                    // Check if the size of the data is expected (otherwise the remote has already terminated the connection)
                    if (readLength < currentLength)
                    {
                        remoteDisconnection = true;
                        break;
                    }
                    string message = reader.ReadString(currentLength);

                    var parameter = JsonConvert.DeserializeObject <RemoteParameter>(message);

                    string serializedData = await CommandReceived(parameter);
                }
                // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED).
                catch (Exception ex) when((uint)ex.HResult == 0x800703E3)
                {
                    Debug.WriteLine("Client Disconnected Successfully");
                    break;
                }
            }

            reader.DetachStream();
            if (remoteDisconnection)
            {
                Disconnect();
                Debug.WriteLine("Client disconnected");
            }
        }