Home/ Questions/Q 4120098
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-20T23:10:37+00:00

I’m sending messages upon detection of both discrete and continuous gestures. For continuous, UDP

  • 0

I’m sending messages upon detection of both discrete and continuous gestures. For continuous, UDP should be fine because even if a couple packets are lost, there’s so many change events that it shouldn’t matter.

I’m wondering about discrete events though, for example tap or swipe. Since there would only be a single packet sent, what is the risk that it doesn’t arrive, and the application at the other end isn’t notified of the gesture?

I understand that TCP guarantees delivery, but I’m thinking it might be too much overhead for the high frequency of messages generated from continuous gestures.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    If your only concern with TCP is the extra overhead, then I wouldn’t worry too much. Certainly, TCP has more overhead than UDP. However, the overhead isn’t that much, especially for the modest amount of data you are likely to be sending. Some quick back-of the envelope calculations:

    • Assume you want to send status information every millisecond. (Likely more often than you really need to.)

    • Assume your individual messages can easily fit within 50 bytes / each. (Likely larger than you really need.)

    • Total bandwidth 50 bytes / ms = 400 bits / ms = 400 kbps

    Even with these larger-than-necessary messages, and faster-than-needed updates, your total bandwidth is only around 5% of a slowish 802.11b wireless network. The extra overhead of TCP isn’t likely to make a big difference here.

    Personally, I tend to stick with TCP unless I have a strong reason not to. Sure, you could save some extra bits by using UDP, but to me, having the reliable delivery (including correctly ordered data, non duplicated data) is worth the extra overhead. One less thing to worry about.

    EDIT: TCP does have some other drawbacks. In particular, it can take a bit more programming effort to create the initial connection, and to parse individual messages from the byte stream. UDP can certainly make these tasks easier. However, you didn’t list programming complexity as one of your criteria, so I focused on your overhead questions instead.

    LATENCY: As noted in comments below, latency is a critical factor. In this case, UDP has some significant advantages: If a packet is dropped, TCP will wait for that packet to be retransmitted before sending others. The benefit of this approach is that data are guaranteed to arrive in the original order. (A big plus when messages must be processed sequentially.) The drawback, of course, is that there could be a significant delay for new data.

    UDP, on the other hand, will continue sending subsequent packets, even if one is dropped. The good news is that UDP reduces the latency of the remaining packets. The bad news, though, is that you must add some sort of “retry” in case discrete events are lost– if you do so, you now have cases of gestures arriving out of order, perhaps significantly so. Can your app handle a case where a “move then click” gets changed to a “click then move”? If you chose to go the UDP route, you’ll need to carefully think through all these cases to make sure it won’t cause (perhaps subtle) problems in your app.

    • 0