Receiving confirmation

Question

Receiving confirmation

Eduardo Gomez 4,156

So, I finally finished, the Widows send data part, and I am waiting for confirmation

Windows implementation

  /// <summary>
  /// Sends raw byte data over the active RFCOMM connection and waits for acknowledgment.
  /// </summary>
  /// <param name="data">Byte array to send.</param>
  /// <returns>True if the data was sent and an acknowledgment was received, otherwise false.</returns>
  public async Task<bool> SendDataAsync(byte[] data) {
      DataWriter? writer = null;
      DataReader? reader = null;
      try {
          if(_socket == null || _socket.OutputStream == null || _socket.InputStream == null) {
              Debug.WriteLine("[WARN] SendDataAsync: socket is null or disposed");
              return false;
          }

          // --- Send Data ---
          writer = new DataWriter(_socket.OutputStream);
          writer.WriteBytes(data);
          await writer.StoreAsync();
          await writer.FlushAsync();
          Debug.WriteLine($"[INFO] Sent {data.Length} bytes: {Encoding.UTF8.GetString(data)}");

          // --- Wait for Acknowledgment ---
          reader = new DataReader(_socket.InputStream);
          reader.InputStreamOptions = InputStreamOptions.Partial;

          var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(8));

          try {
              // Read available data (flexible size)
              var bytesRead = await reader.LoadAsync(1024).AsTask(cancellationTokenSource.Token);

              if(bytesRead >= 2) {
                  string response = reader.ReadString(bytesRead).Trim();
                  Debug.WriteLine($"[INFO] Received acknowledgment: '{response}'");

                  if(response.Contains("OK")) {
                      Debug.WriteLine("[SUCCESS] Data delivery confirmed!");
                      return true;
                  }
              }
              else {
                  Debug.WriteLine($"[WARN] Received only {bytesRead} bytes, expected at least 2");
              }
          } catch(TaskCanceledException) {
              Debug.WriteLine("[ERROR] Timeout waiting for acknowledgment");
          } catch(Exception readEx) {
              Debug.WriteLine($"[ERROR] Failed to read acknowledgment: {readEx.Message}");
          }

          return false;

      } catch(Exception ex) {
          Debug.WriteLine($"[ERROR] SendDataAsync failed: {ex.Message}");
          return false;
      } finally {
          // Proper cleanup
          try {
              writer?.DetachStream();
              writer?.Dispose();
          } catch { }

          try {
              reader?.DetachStream();
              reader?.Dispose();
          } catch { }
      }
  }

Android listener

Android code

 public async Task StartListeningAsync() {
     var sppUuid = Java.Util.UUID.FromString("00001101-0000-1000-8000-00805F9B34FB");
     var serverSocket = BluetoothAdapter.DefaultAdapter.ListenUsingRfcommWithServiceRecord("SnapLabel", sppUuid);

     ShowToast("📡 Listening for Bluetooth...");

     while(true) {
         try {
             var socket = await serverSocket.AcceptAsync();
             ShowToast("🔗 Connected to PC");

             var buffer = new byte[1024];
             int bytesRead = await socket.InputStream.ReadAsync(buffer, 0, buffer.Length);
             string received = Encoding.UTF8.GetString(buffer, 0, bytesRead);
             ShowToast($"📥 Received: {received}");

             var echo = Encoding.UTF8.GetBytes("OK");
             await socket.OutputStream.WriteAsync(echo, 0, echo.Length);
             await socket.OutputStream.FlushAsync();
             ShowToast("📤 Echo sent: OK");

             await Task.Delay(1000000); // ⏳ Give Windows time to read
             socket.Close();
         } catch(Exception ex) {
             ShowToast($"❌ Error: {ex.Message}");
         }
     }
 }

VM

var success = await _bluetoothService!.SendDataAsync(Encoding.ASCII.GetBytes("Hello Printer\n"));
if(success)
{
	Debug.WriteLine("[SUCCESS] ✅ Data sent and delivery confirmed!");
}
	else 
{
    Debug.WriteLine("[FAILED] ❌ Data send failed or no confirmation received");
}

Answer accepted by question author

0 additional answers

Your answer

Answer 1

Michael Le (WICLOUD CORPORATION) 6,420 Microsoft External Staff Moderator

Hello @Eduardo Gomez ,

Thank you for reaching out. I'm glad to hear that your development is going well.

An established connection was aborted by the software in your host machine.

This indicates that the remote computer actively closed the connection. This usually happens when there is no application on the receiving end listening for that specific Bluetooth connection, or if a security setting (like a firewall) blocked it.

not Auth or socket

And the error you see on your phone's Bluetooth terminal app suggests that the app itself was not able to properly accept the incoming connection or data, which is consistent with the issue.

To get a true confirmation of delivery, you need to implement a simple acknowledgment protocol. The concept is similar to a "ping" as you mentioned. After your application sends data, it should wait for the receiving application to send a confirmation message back.

I have modified your SendDataAsync method to include this logic. It will now send the data and then wait up to 5 seconds for a simple "OK" text response from the remote device.

// ...existing code...
        /// <summary>
        /// Sends raw byte data over the active RFCOMM connection and waits for a simple acknowledgment.
        /// </summary>
        /// <param name="data">Byte array to send.</param>
        /// <returns>True if the data was sent and an acknowledgment was received, otherwise false.</returns>
        public async Task<bool> SendDataAsync(byte[] data) {
            DataWriter? writer = null;
            DataReader? reader = null;
            try {
                if(_socket == null || _socket.OutputStream == null || _socket.InputStream == null) {
                    Debug.WriteLine("[WARN] SendDataAsync: socket is null or disposed");
                    return false;
                }
 
                // --- Sending Data ---
                writer = new DataWriter(_socket.OutputStream);
                writer.WriteBytes(data);
                await writer.StoreAsync();
                await writer.FlushAsync();
                writer.DetachStream(); // Prevent writer from closing the stream
 
                // --- Waiting for Acknowledgment (ACK) ---
                reader = new DataReader(_socket.InputStream);
                reader.InputStreamOptions = InputStreamOptions.Partial; // Read data as it comes
 
                // Set a timeout for waiting for the ACK
                var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(5));
               
                // Expecting a 2-byte "OK" response
                uint expectedAckLength = 2;
                var bytesRead = await reader.LoadAsync(expectedAckLength).AsTask(cancellationTokenSource.Token);
 
                if (bytesRead >= expectedAckLength) {
                    string response = reader.ReadString(bytesRead);
                    if (response == "OK") {
                        Debug.WriteLine("[INFO] Acknowledgment 'OK' received.");
                        reader.DetachStream();
                        return true;
                    }
                }
               
                Debug.WriteLine("[WARN] Did not receive expected acknowledgment.");
                return false;
 
            } catch (TaskCanceledException) {
                Debug.WriteLine("[ERROR] SendDataAsync timed out waiting for acknowledgment.");
                return false;
            } catch(Exception ex) {
                Debug.WriteLine($"[ERROR] SendDataAsync failed: {ex.Message}");
                return false;
            } finally {
                // Dispose writer but not reader, as its stream is detached
                writer?.Dispose();
                // Do not dispose the reader directly if you detached the stream,
                // as the underlying socket stream should remain open.
            }
        }
 
 
        /// <summary>
// ...existing code...

Important: For this to work, the application on the receiving device (e.g., your phone's Bluetooth terminal app or a custom app on another computer) must be programmed to read the incoming data and then immediately send the two characters OK back over the same connection.

I hope this helps. Let me know if you have any further questions.

Eduardo Gomez 4,156

Thanks, I implemented it, but I need help

I created a small listener, that is attach to android as soon as I launch it

      public async Task StartListeningAsync() {
          var sppUuid = Java.Util.UUID.FromString("00001101-0000-1000-8000-00805F9B34FB");
          var serverSocket = BluetoothAdapter.DefaultAdapter.ListenUsingRfcommWithServiceRecord("SnapLabel", sppUuid);

          ShowToast("📡 Listening for Bluetooth...");

          while(true) {
              try {
                  var socket = await serverSocket.AcceptAsync();
                  ShowToast("🔗 Connected to PC");

                  var buffer = new byte[1024];
                  int bytesRead = await socket.InputStream.ReadAsync(buffer, 0, buffer.Length);
                  string received = Encoding.UTF8.GetString(buffer, 0, bytesRead);
                  ShowToast($"📥 Received: {received}");

                  var echo = Encoding.UTF8.GetBytes("OK");
                  await socket.OutputStream.WriteAsync(echo, 0, echo.Length);
                  await socket.OutputStream.FlushAsync();

                  ShowToast("📤 Echo sent: OK");

                  socket.Close();
              } catch(Exception ex) {
                  ShowToast($"❌ Error: {ex.Message}");
              }
          }
      }

and then I register it in the constructor

 #region Constructor  
       if(DeviceInfo.Platform == DevicePlatform.Android) {
         _ = _bluetoothService.StartListeningAsync(); // fire-and-forget
     }

snd then when I press the button

            _bluetoothService!.SendDataAsync((Encoding.ASCII.GetBytes("Hello Printer\n")));
            var echo = await _bluetoothService.ReceiveDataAsync();
            Debug.WriteLine($"[Echo] Received: {Encoding.UTF8.GetString(echo)}");

I never see data received

Michael Le (WICLOUD CORPORATION) 6,420 Microsoft External Staff Moderator

Thank you, @Eduardo Gomez , for providing the additional details about your implementation.

It seems like there might be a timing issue between the listener and sender:

Your Android listener sends "OK" and immediately calls socket.Close()
By the time Windows tries to read the acknowledgment, the Android side has already terminated the connection
The connection is being closed before the acknowledgment can be properly received

You can try adding a small delay after sending the acknowledgment before closing the socket to give Windows enough time to read the response.

public async Task StartListeningAsync() {
    var sppUuid = Java.Util.UUID.FromString("00001101-0000-1000-8000-00805F9B34FB");
    var serverSocket = BluetoothAdapter.DefaultAdapter.ListenUsingRfcommWithServiceRecord("SnapLabel", sppUuid);
 
    ShowToast("📡 Listening for Bluetooth...");
 
    while(true) {
        try {
            var socket = await serverSocket.AcceptAsync();
            ShowToast("🔗 Connected to PC");
 
            var buffer = new byte[1024];
            int bytesRead = await socket.InputStream.ReadAsync(buffer, 0, buffer.Length);
            string received = Encoding.UTF8.GetString(buffer, 0, bytesRead);
            ShowToast($"📥 Received: {received}");
 
            // Send acknowledgment
            var echo = Encoding.UTF8.GetBytes("OK");
            await socket.OutputStream.WriteAsync(echo, 0, echo.Length);
            await socket.OutputStream.FlushAsync();
            ShowToast("📤 Echo sent: OK");
 
            // Wait before closing to allow Windows to read the response
            await Task.Delay(2000);
            socket.Close();
           
        } catch(Exception ex) {
            ShowToast($"❌ Error: {ex.Message}");
        }
    }
}

/// <summary>
/// Sends raw byte data over the active RFCOMM connection and waits for acknowledgment.
/// </summary>
/// <param name="data">Byte array to send.</param>
/// <returns>True if the data was sent and an acknowledgment was received, otherwise false.</returns>
public async Task<bool> SendDataAsync(byte[] data) {
    DataWriter? writer = null;
    DataReader? reader = null;
    try {
        if(_socket == null || _socket.OutputStream == null || _socket.InputStream == null) {
            Debug.WriteLine("[WARN] SendDataAsync: socket is null or disposed");
            return false;
        }
 
        // --- Send Data ---
        writer = new DataWriter(_socket.OutputStream);
        writer.WriteBytes(data);
        await writer.StoreAsync();
        await writer.FlushAsync();
        Debug.WriteLine($"[INFO] Sent {data.Length} bytes: {Encoding.UTF8.GetString(data)}");
 
        // --- Wait for Acknowledgment ---
        reader = new DataReader(_socket.InputStream);
        reader.InputStreamOptions = InputStreamOptions.Partial;
 
        var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(8));
       
        try {
            // Read available data (flexible size)
            var bytesRead = await reader.LoadAsync(1024).AsTask(cancellationTokenSource.Token);
           
            if (bytesRead >= 2) {
                string response = reader.ReadString(bytesRead).Trim();
                Debug.WriteLine($"[INFO] Received acknowledgment: '{response}'");
               
                if (response.Contains("OK")) {
                    Debug.WriteLine("[SUCCESS] Data delivery confirmed!");
                    return true;
                }
            } else {
                Debug.WriteLine($"[WARN] Received only {bytesRead} bytes, expected at least 2");
            }
        } catch (TaskCanceledException) {
            Debug.WriteLine("[ERROR] Timeout waiting for acknowledgment");
        } catch (Exception readEx) {
            Debug.WriteLine($"[ERROR] Failed to read acknowledgment: {readEx.Message}");
        }
       
        return false;
 
    } catch(Exception ex) {
        Debug.WriteLine($"[ERROR] SendDataAsync failed: {ex.Message}");
        return false;
    } finally {
        // Proper cleanup
        try {
            writer?.DetachStream();
            writer?.Dispose();
        } catch { }
       
        try {
            reader?.DetachStream();
            reader?.Dispose();
        } catch { }
    }
}

Updated button click handler:

// Remove the separate ReceiveDataAsync call - it's now handled inside SendDataAsync
var success = await _bluetoothService!.SendDataAsync(Encoding.ASCII.GetBytes("Hello Printer\n"));
 
if (success) {
    Debug.WriteLine("[SUCCESS] ✅ Data sent and delivery confirmed!");
    // Update UI to show success
} else {
    Debug.WriteLine("[FAILED] ❌ Data send failed or no confirmation received");
    // Update UI to show failure
}

I hope this helps.

Eduardo Gomez 4,156 Reputation points

2025-10-07T08:10:13.2466667+00:00
I am doing everything you tell me, but I get

also changed the code, and posted Android and windows implementations

This is what I am doing for testing

Run the app on my Android device (With the latest modifications)

Stop the app on my phone, until visual studio deploys it on the computer

Once is running on the computer, I start it on my phone, and I can see the toast "Listening for messages"

On my app on Windows, I scan for devices, connect to my phone (I can see on my Bluetooth settings that my phone is connected)

I click the button to send the data

[INFO] Sent 14 bytes: Hello Printer The thread 41672 has exited with code 0 (0x0). Exception thrown: 'System.Threading.Tasks.TaskCanceledException' in System.Private.CoreLib.dll [ERROR] Timeout waiting for acknowledgment [FAILED] ❌ Data send failed or no confirmation received

Project link

https://github.com/eduardoagr/SnapLabel
Michael Le (WICLOUD CORPORATION) 6,420 Reputation points Microsoft External Staff Moderator

2025-10-07T11:02:38.2833333+00:00

I think the data is sent through a different socket than one your Android listener is waiting on. You may need to verify this. Also, please give me some time to look at your repository.
Eduardo Gomez 4,156 Reputation points

2025-10-07T11:11:59.65+00:00

OK thank you so much, I will check if I am sending data to other socket, but is strange becouse I am using the deviceId
Eduardo Gomez 4,156 Reputation points

2025-10-07T11:12:58.8933333+00:00

Also it could be that I don't know how to test it
Eduardo Gomez 4,156 Reputation points

2025-10-07T18:12:59.3+00:00

I just push a new version of the app, now the problem is that it only works one time.

I send the message from my app to the phone, and I received it perfectly, but if I send another one, I receive error timeout.

This was only for testing, because I am going to send QR code to a thermal printer, I hope is not too much trouble
Michael Le (WICLOUD CORPORATION) 6,420 Reputation points Microsoft External Staff Moderator

2025-10-08T11:18:00.3733333+00:00

Unfortunately, this is way out of my scope to handle properly. Continuing this discussion would make the thread comment section much longer and harder to track.

I strongly advise you to review the architecture of this Bluetooth implementation class. From what I can see, there are two different socket objects being used when you only need one to maintain the connection.

Additionally, every time you send a request, StartListeningAsync creates new sockets in an infinite loop but never properly closes them, which will definitely cause memory leaks and connection issues. The Android listener socket and the client connection socket are conflicting with each other, and the lack of proper resource management is causing your timeout errors.

If you have any other questions, I recommend creating a new thread with a more focused scope. Thank you for understanding.
Eduardo Gomez 4,156 Reputation points

2025-10-08T13:34:11.08+00:00

Tank you
Michael Le (WICLOUD CORPORATION) 6,420 Reputation points Microsoft External Staff Moderator

2025-10-09T03:40:50.2066667+00:00

Thank you. I would really appreciate it if you could confirm the answer in case others encounter the same issue.

Share via

Receiving confirmation

0 additional answers

Your answer