Example #1
0
        private async void ConnectDisconnect_Click(object sender, RoutedEventArgs e)
        {
            ConnectDisconnect.IsEnabled = false;
            try
            {
                if (socket != null)
                {
                    pingTimer.Dispose();
                    pingTimer = null;
                    // Close method is available for StreamSocket, but only callable from the WinRT implementation - NOT from C#
                    socket.Dispose();
                    socket     = null;
                    State.Text = "Disconnected";
                    ConnectDisconnect.Content = "Connect";
                }
                else
                if (!string.IsNullOrEmpty(ServerURI.Text))
                {
                    socket               = new StreamSocket();
                    controller           = socket.Control;
                    controller.KeepAlive = true;

                    var netendpoint = new HostName(ServerURI.Text);
                    await socket.ConnectAsync(netendpoint, Port.Text);

                    State.Text = "Connected";
                    ConnectDisconnect.Content = "Disconnect";
                    pingTimer = new Timer(TimerMethod, this, 5000, 5000);


                    IAsyncAction asyncAction = Windows.System.Threading.ThreadPool.RunAsync(
                        async(workItem) =>
                    {
                        byte[] bob = new byte[200];

                        while (workItem.Status != AsyncStatus.Canceled)
                        {
                            await socket.InputStream.ReadAsync(bob.AsBuffer(), 200, InputStreamOptions.Partial);
                            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
                                                      () =>
                            {
                                State.Text = "Read " + bob[0];
                            });
                        }
                    });
                }
            }
            catch (Exception exception)
            {
                State.Text = exception.Message;
            }
            finally
            {
                ConnectDisconnect.IsEnabled = true;
            }
        }
Example #2
0
        async private Task receiveFile(PeerInformation device)
        {
            started = true;

            //-----------------------------------------------------------------------tworzenie socketu i strumieni
            try
            {
                socket = new Windows.Networking.Sockets.StreamSocket();
                StreamSocketControl control = socket.Control;
                control.KeepAlive = true;

                await socket.ConnectAsync(device.HostName,
                                          "{00001101-0000-1000-8000-00805f9b34fb}",
                                          SocketProtectionLevel.BluetoothEncryptionAllowNullAuthentication);

                reader = new DataReader(socket.InputStream);
                writer = new DataWriter(socket.OutputStream);
            }
            catch (Exception e)
            {
                disconnect();
                System.Diagnostics.Debug.WriteLine(e.StackTrace);
                popupDialog("Wystąpił błąd połączenia!\nPowrót");
                return;
            }

            //-----------------------------------------------------------------------tworzenie nowego pliku
            try
            {
                file = await Windows.Storage.KnownFolders.PicturesLibrary.CreateFileAsync(
                    fileName, CreationCollisionOption.GenerateUniqueName);
            }
            catch (Exception e)
            {
                disconnect();
                System.Diagnostics.Debug.WriteLine(e.StackTrace);
                popupDialog("Wystąpił błąd podczas tworzenia pliku!\nPowrót");
                return;
            }

            //-----------------------------------------------------------------------strumien pliku
            try
            {
                stream = await file.OpenAsync(FileAccessMode.ReadWrite);
            }
            catch (Exception e)
            {
                disconnect();
                System.Diagnostics.Debug.WriteLine(e.StackTrace);
                popupDialog("Wystąpił błąd dostępu do pliku!\nPowrót");
                return;
            }

            long count = fileSize / bufferSize;
            long rest  = fileSize - (count * bufferSize);
            uint bytesRead;

            progress.Maximum = fileSize;

            await System.Threading.Tasks.Task.Delay(50);

            //-----------------------------------------------------------------------przesylanie danych
            try
            {
                for (int i = 0; i < count; ++i)
                {
                    bytesRead = await reader.LoadAsync(bufferSize);

                    buffer = reader.ReadBuffer(bytesRead);
                    await stream.WriteAsync(buffer);

                    progress.Value += (int)bytesRead;
                    writer.WriteBoolean(true);
                    await writer.StoreAsync();
                }
                if (rest != 0)
                {
                    bytesRead = await reader.LoadAsync((uint)rest);

                    buffer = reader.ReadBuffer(bytesRead);
                    await stream.WriteAsync(buffer);

                    progress.Value += (int)bytesRead;
                    writer.WriteBoolean(true);
                    await writer.StoreAsync();
                }
            }
            catch (Exception e)
            {
                deleteFile();
                disconnect();
                System.Diagnostics.Debug.WriteLine(e.StackTrace);
                popupDialog("Wystąpił błąd podczas przesyłania danych!\nPowrót");
                return;
            }

            disconnect();
            popupDialog("Pobieranie zakończone!\nPowrót");
        }