Interpret "double tap" from TouchLocation stream using Rx - windows-phone-7

Question

I have an IObservable<TouchLocation> and am trying to derive gestures from it.
Was able to pull out Taps but having trouble wrapping my head around Double Tap.
TouchLocation has Position and State so Tap is derived by aggregating these based upon two criteria.
1) Position doesn't move more than 10px in any direction (allow for some movement but isn't a drag)
2) Starts on an event with "Pressed" state and continues until one comes in with "Released" state
3) Where the "release" happens within 1 second of the "press"
Now I have an IObservable<List<TouchLocation>> (result of the aggregation) and need to produce the double tap.
How can I return the first gesture (to produce the initial tap) and then substitute the second for a double tap gesture, but only if a second Tap is received before a 1 second timer. If received after the timer then it should also be a simple Tap.

Answer 1

A fun problem.
// Setup some parameters
var singleTapInterval = TimeSpan.FromSeconds(0.5);
var dblTapInterval = TimeSpan.FromSeconds(1);
// the source of touches
IObservable<TouchLocation> txs;
// Get single taps
// 0, 1, but no more than
// 2 touches in the timespan
IObservable<TouchLocation> taps = txs.Buffer(2,singleTapInterval)
.Where(touches => touches.Count == 2 &&
touches[0].state == "Pressed" &&
touches[1].state == "Released" &&
distance(touches) < distanceThreshold)
.Select(touches => touches[1]);
// now detect double taps
IObservable<TapKind> dbltaps = taps.Buffer(2,dblTapInterval)
.Where(taps => taps.Count == 2)
.Select(_ => TapKind.SingleTap);
// detect single taps - taps must be _slower_ than the dblTapInterval
// for this to work
IObservable<TapKind> singletaps = taps.Throttle(dblTapInterval)
.Select(_ => TapKind.SingleTap);
// compbine the two, so we see either tap condition
IObservable<TapKind> interestingTaps = dbltaps.Merge(singletaps);

Answer 2

I think the best answer I can give you is "don't do that".
XNA has a built-in mechanism for providing tap, double-tap, and other gestures. These match the system-wide gesture behaviour and are vastly more preferable to implementing your own gesture recogniser.
See this document on MSDN for an explanation of how to use the built-in gesture functionality. It's basically a case of setting TouchPanel.EnabledGestures, polling IsGestureAvailable, and then calling ReadGesture.

Answer 3

Went back to the beginning and realized I'd been vastly overcomplicating it... thanks to Scott for helping reset my approach!
"target" is an IObservable<TouchLocation> (in an extension method).
This setup handles sending the first event (so we don't lose the first event while the zip is pending), ignores holds (tap that takes more than 1 second), replaces the second tap with double tap (but only if it happened within 1 second of the tap) and covers a new req that I didn't realize before which makes sure that double tap only follows a tap and never another double tap (4 taps was producing Tap | DTap | DTap | DTap and now is Tap | DTap | Tap | DTap which is correct behavior)
Will probably simplify this down a bit more but this is pre-refactor working version:
var grouped = (from t in target
group t by t.Id into groups
select groups);
var presses = (from g in grouped
from t in g
where t.State == TouchLocationState.Pressed
select t).Timestamp();
var releases = (from g in grouped
from t in g
where t.State == TouchLocationState.Released
select t).Timestamp();
var pressAndRelease = presses.Zip(releases, (press, release) =>
{
return new { Press = press, Release = release };
})
.Where(pr =>
{
var delta = (pr.Release.Timestamp - pr.Press.Timestamp).TotalSeconds;
return delta < 1;
})
.Timestamp();
var zipped = pressAndRelease.Zip(pressAndRelease.Skip(1), (prev, cur) =>
{
return new { Previous = prev, Current = cur };
});
pressAndRelease.TakeUntil(zipped).Subscribe(a =>
{
Debug.WriteLine("FIRST TAP!");
});
var wasDoubleTap = false;
zipped.Subscribe(a =>
{
var delta = (a.Current.Timestamp - a.Previous.Timestamp).TotalSeconds;
if (wasDoubleTap || delta > 1)
{
Debug.WriteLine("TAP");
wasDoubleTap = false;
}
else
{
Debug.WriteLine("DOUBLE TAP!");
wasDoubleTap = true;
}
});