Dragos Manolescu's (work) blog

Moved to a new home

Dragos Manolescu — Fri, 03 Aug 2012 07:14:02 GMT

You're looking at dead content. I am no longer updating this blog and have relocated to my personal web site. See you there ;)

WP7 Code: Mocking Event Streams with IEnumerable

Dragos Manolescu — Sun, 12 Dec 2010 22:40:45 GMT

A few weeks ago I showed how to represent computations involving geo locations or accelerometer readings as queries over RxLINQ event streams (i.e., IObservable collections). In both instances the event source was one of the sensors that is on board of every Windows Phone 7 device. What happens when applications querying position changed or acceleration reading changed event streams run in the emulator? As there are no physical sensors the events don’t fire. For example, the 2-D bubble level application from my previous post shows a stationary bubble. Does that mean that one cannot write location or accelerometer code and experiment with it in the emulator? Likewise, is testing in the emulator a dead end? In light of the above it would seem so. However, the duality between IObservable and IEnumerable provides an elegant way to mock event streams with any IEnumerable source. This blog post shows how to exploit the duality in the context of the 2-D bubble application. With just a few changes you should be able to run and test the application without an actual accelerometer sensor, in the emulator.

To illustrate how trivial the changes are let me start top-down rather than bottom up. Recall that the first query in the 2-D bubble level pulled the accelerometer readings into a local variable named as such; here’s a snippet from that code with the key part highlighted:

{

    var accelerometerReadings = accelerometer.GetAccEventStream();

    var x0 = (double)ellipse1.GetValue(Canvas.TopProperty) + ellipse1.Width / 2;
    var y0 = (double)ellipse1.GetValue(Canvas.LeftProperty) + ellipse1.Height / 2;

    // snip

}

The only change in RxLINQ queries entails sourcing the event stream from a different object (an instance of DataLoader). Here’s the modified code; there are no other changes to this class:

{
     var dl = new DataLoader();

     var accelerometerReadings = dl.Readings();

     var x0 = (double)ellipse1.GetValue(Canvas.TopProperty) + ellipse1.Width / 2;
     var y0 = (double)ellipse1.GetValue(Canvas.LeftProperty) + ellipse1.Height / 2;

    // snip

}

The Readings method of DataLoader provides an IObservable collection. For this example the collection represents actual accelerometer readings that have been saved to isolated storage. However this is not a requirement; the events could also represent synthetic data. As long as the information used by the RxLINQ queries is there (in this case the X and Y accelerations, as well as the timestamps) the events could be synthetic, as well as recordings of sensor readings. Here’s the DataLoader class:

public class DataLoader
{
    private IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication();
    private Stream stream;
    private StreamReader reader;
    private const string FileName = "accelerations.txt";

    public DataLoader()
    {
        stream = App.GetResourceStream(new Uri(FileName, UriKind.Relative)).Stream;
        reader = new StreamReader(stream);
    }

    public IObservable Readings()
    {

        // Read saved data into a list (IEnumerable)
        var readings = new List();
        for (var line = reader.ReadLine(); line != null; line = reader.ReadLine())
            readings.Add(new AccelerometerReading(line));

        // Convert the IEnumerable into IObservable
        var rs = readings.ToObservable(Scheduler.NewThread);

        // Sync via Thread.Sleep on a different thread
        return rs.Zip(rs.Skip(1), (l, r) =>
        {
            Thread.Sleep(TimeSpan.FromTicks(r.Timestamp.Ticks - l.Timestamp.Ticks));
            return r;
        }).ObserveOnDispatcher();
    }
}

The Readings() method populates a List with AccelerometerReading objects which have been read from a text file. RxLINQ adds the ToObservable extension method to IEnumerable such that once read, the list of recorded readings can be converted into an observable collection. The argument signals that the conversion should take place on a different thread, leaving the main thread for UI updates.

Sensor readings have a temporal element; if the code would blindly dole out readings from the IEnumerable then the query computing the motion (which used time deltas) will produce garbage. Consequently, after emitting an event, the code needs to wait until it is time to emit the next event. RxLINQ comes again to the rescue. First, the combination of Zip and Skip allows the code to Sleep between two consecutive events. (As this computation takes place on a different thread the Sleep doesn’t interfere with the UI thread.) Second, ObserveOnDispatcher() brings the (now temporally-spaced) events to the main thread, which is where the accelerometer events show up when using the actual sensor.

AccelerometerReading is a helper class that simplifies storing the accelerometer events by capturing only the X/Y/Z readings and the Timestamp in ticks. Here’s the code:

public class AccelerometerReading
    {
        public DateTimeOffset Timestamp { get; set; }
        public double X { get; set; }
        public double Y { get; set; }
        public double Z { get; set; }

        public AccelerometerReading()
        {
            //
        }

        public AccelerometerReading(AccelerometerReadingEventArgs ea)
        {
            Timestamp = ea.Timestamp;
            X = ea.X;
            Y = ea.Y;
            Z = ea.Z;
        }

        public AccelerometerReading(string line)
        {
            var elements = line.Split(';');
            if (elements.Length == 4)
            {
                Timestamp = new DateTimeOffset(new DateTime(long.Parse(elements[0])));
                X = Double.Parse(elements[1]);
                Y = Double.Parse(elements[2]);
                Z = Double.Parse(elements[3]);
            }
        }
    }

For completeness here’s a sample from the contents of the accelerations.txt file:

634262369734340000;0.00390625;-0.01171875;-1.02734375
634262369734550000;0.0078125;-0.01171875;-1.04296875
634262369734790000;0.00390625;-0.00390625;-1.03125
634262369735000000;0.00390625;-0.0078125;-1.03125
634262369735210000;-0.00390625;-0.00390625;-1.03125
634262369735440000;0.00390625;-0.0078125;-1.03125
634262369735660000;-0.00390625;-0.00390625;-1.0390625
634262369735870000;0.00390625;0.0078125;-1.03515625
634262369736100000;0.00390625;-0.00390625;-1.03125
634262369736310000;0.00390625;0;-1.02734375
634262369736540000;0;-0.00390625;-1.0390625
634262369736750000;0;0;-1.0390625
634262369736960000;0;0;-1.03125
634262369737170000;-0.00390625;0.00390625;-1.0234375
634262369737380000;-0.00390625;0.00390625;-1.0234375
634262369737610000;0;0.00390625;-1.02734375
634262369737830000;0;-0.00390625;-1.05078125
634262369738040000;-0.00390625;0.00390625;-1.03125
634262369738260000;0.00390625;0.0078125;-1.0234375
634262369738470000;0.00390625;0.0078125;-1.01953125
634262369738680000;0;0.0078125;-1.0234375
634262369738890000;0;0.00390625;-1.03125
634262369739100000;0.00390625;0.0078125;-1.0234375
634262369739310000;0.0078125;0.0078125;-1.0234375

In summary, this blog post has shown:

How to mock an IObservable (i.e., event stream) with an IEnumerable by leveraging the IObservable/IEnumerable duality,
How to read application data from isolated storage, and
How to reconstruct the temporal dimension of sensory data with RxLINQ combinators. (There are other ways of implementing the temporal spacing; for now the combination of Zip and Skip reinforces a pattern I used in previous posts.)

WP7 Code: Using the Accelerometer API

Dragos Manolescu — Mon, 01 Nov 2010 22:23:32 GMT

My previous blog posts on WP7 Code covered the GeoLocation API, a surface area that provides access to the phone’s location based on signals picked up by one of its radios. However location alone is probably not sufficient for mobile applications. This post shows how to take Windows Phone 7 applications beyond location and enable them to use additional data provided by another onboard sensor, the accelerometer.

The accelerometer is exposed in the Microsoft.Devices.Sensors namespace, and packaged in the DLL with the same name. As in the previous posts a simple application showcases the API, with the emphasis on the phone-specific aspects rather than C#/Silverlight/robustness/etc. This application looks like a bubble level. Just like I said in the past, while this code runs out of the box please don’t build a navigation system on it

Start Visual Studio (with the Windows Phone Development Tools installed) and create a new Windows Phone Application called TiltMe. Add references to Microsoft.Devices.Sensors (for the accelerometer API), and to Microsoft.Phone.Reactive and System.Observable (for RxLINQ)—the event-driven code is implemented as Rx queries. In the tradition of a utilitarian UX add the following code (highlighted) to MainPage.xaml:

The MainPage class holds the accelerometer reference in an instance variable, which gets created in the constructor. Similar to the GeoCoordinateWatcher, the page code starts the accelerometer when the page is navigated to (first override), and stops it when the page is navigated away from (second override). Stopping the sensor when it is not needed reduces the application’s power consumption, an aspect critical to battery-powered code. Don’t forget the using statement for the accelerometer’s namespace.

public partial class MainPage : PhoneApplicationPage
{
    private Accelerometer accelerometer;

    // Constructor
    public MainPage()
    {
        InitializeComponent();

        accelerometer = new Accelerometer();

        this.Loaded += new RoutedEventHandler(MainPage_Loaded);
    }

    protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
    {
        base.OnNavigatedTo(e);

        accelerometer.Start();
    }

    protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
    {
        base.OnNavigatedFrom(e);

        accelerometer.Stop();
    }

    // snip
}

Accelerometer readings surface as ReadingChanged events. The following extension method exposes AccelerometerReadingEventArgs as an Rx event stream (don’t forget the using statement for the Microsoft.Phone.Reactive namespace):

public static IObservable GetAccEventStream(this Accelerometer accelerometer)
{
    return Observable.Create(observer =>
    {
        EventHandler handler = (s, e) =>
        {
            observer.OnNext(e);

        };
        accelerometer.ReadingChanged += handler;
        return () => { accelerometer.ReadingChanged -= handler; };
    });
}

To illustrate the accelerometer readings the application shows a sphere (i.e., ellipse with gradient fill) that “falls” towards the edge of the canvas, following the phone’s orientation—2D bubble level. To avoid interfering with the startup path (and thus remove the risk of having the application being perceived as non-responsive) the code connecting the accelerometer to the sphere lies in the event handler for the page loaded even rather than the page’s constructor. It begins with a query representing the accelerometer event stream, and computations for the sphere’s initial position (modified code shown highlighted):

public MainPage()
{
    InitializeComponent();

    accelerometer = new Accelerometer();

    this.Loaded += new RoutedEventHandler(MainPage_Loaded);
}

void MainPage_Loaded(object sender, RoutedEventArgs e)
{

    var accelerometerReadings = accelerometer.GetAccEventStream();

    var x0 = (double)ellipse1.GetValue(Canvas.TopProperty) + ellipse1.Width / 2;
    var y0 = (double)ellipse1.GetValue(Canvas.LeftProperty) + ellipse1.Height / 2;

}

The sphere’s initial position, accelerometer events (which provide readings in the 3 XYZ dimensions as well as the timestamp) plugged into the laws of motion provide all the ingredients for this simple application. (A physics engine would offer a more realistic interaction; that is left as an exercise to the reader.) Before showing the Rx queries here are a few things that simplify matters. First, an Interval class whose Clip method bounds a value between the interval’s minimum and maximum. Second an extension method that allows the code to position an ellipse by providing its center. Here they are, with the extension method going into the Helpers static class:

public class Interval
{
    public double Min { get; private set; }
    public double Max { get; private set; }

    public Interval(double min, double max)
    {
        Min = min;
        Max = max;
    }

    public double Clip(double value)
    {
        if (value >= Max)
            return Max;
        if (value <= Min)
            return Min;
        return value;
    }
}

public static void SetCenter(this Ellipse ellipse, Point c)
{
    ellipse.SetValue(Canvas.LeftProperty,c.X - ellipse.Width / 2);
    ellipse.SetValue(Canvas.TopProperty, c.Y - ellipse.Height / 2);
}

With the ability to clip (such that the sphere doesn’t go off screen) and position the sphere, Rx queries implement the (simplified) calculation. The first query projects the stream of AccelerometerReadingEventArgs into a stream of objects with X, Y, and Z members having the values provided by the accelerometer, and the dt member representing the delta (in milliseconds) between the last 2 accelerometer readings. This is implemented via the Zip and Skip combinators; ObserveOnDispatcher ensures that further manipulations of the resulting IObservable stream happen on the UI thread.

var accelerationAndDts = accelerometerReadings.Zip(accelerometerReadings.Skip(1), (p, c) =>
new { X = c.X, Y = - c.Y, Z = c.Z, dt = (c.Timestamp.Subtract(p.Timestamp)).TotalMilliseconds }).ObserveOnDispatcher();

The next query uses the acceleration (X and Y) and dts as well as the sphere’s current coordinates to compute its next position. The Scan combinator injects the initial coordinates into the computation, and then carries it over subsequent events. (In Smalltalk this corresponds to the inject:into: message.)

var xclip = new Interval(0, canvas1.Width);
var yclip = new Interval(0, canvas1.Height);

var positions = accelerationAndDts.Scan(new Point(x0,y0)
               , (pos, acc) =>
                   new Point( xclip.Clip(pos.X + acc.X * 0.5 * acc.dt * acc.dt)
                            , yclip.Clip(pos.Y + acc.Y * 0.5 * acc.dt * acc.dt)
                            )
               );

The resulting stream of positions is suitable for positioning the sphere; the SetCenter extension method introduced above makes the code pretty compact:

positions.Subscribe(c => this.ellipse1.SetCenter(c));

Before showing the code let’s have a look at how the raw data might look like. Here are 256 consecutive readings (X and Y), with the device laying flat on my desk.

With the caveat that this data comes from an engineering prototype rather than a production device, here are a few things to note:

First, on this particular device the accelerometer is not calibrated. There are offset errors in both the X and Y dimensions, both of which could be eliminated via calibration.
Second, the raw sensor data has some jitter, which is probably a combination of vibrations picked up by my desk and other types of noise. Depending on your application a smoothing filter could take out the unwanted jitter.

The full code from MainPage.xaml.cs follows; building and running this application requires the XAML for the UI, and the Interval class shown above.

namespace TiltMe
{
    public partial class MainPage : PhoneApplicationPage
    {
        private Accelerometer accelerometer;

        // Constructor
        public MainPage()
        {
            InitializeComponent();

            accelerometer = new Accelerometer();

            this.Loaded += new RoutedEventHandler(MainPage_Loaded);
        }

        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            accelerometer.Start();
        }

        protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedFrom(e);

            accelerometer.Stop();
        }


        void MainPage_Loaded(object sender, RoutedEventArgs e)
        {

            var accelerometerReadings = accelerometer.GetAccEventStream();

            var x0 = (double)ellipse1.GetValue(Canvas.TopProperty) + ellipse1.Width / 2;
            var y0 = (double)ellipse1.GetValue(Canvas.LeftProperty) + ellipse1.Height / 2;

            var accelerationAndDts = accelerometerReadings.Zip(accelerometerReadings.Skip(1), (p, c) =>
                new { X = c.X, Y = - c.Y, Z = c.Z, dt = (c.Timestamp.Subtract(p.Timestamp)).TotalMilliseconds }).ObserveOnDispatcher();

            var xclip = new Interval(0, canvas1.Width);
            var yclip = new Interval(0, canvas1.Height);

            var positions = accelerationAndDts.Scan(new Point(x0,y0)
                           , (pos, acc) =>
                               new Point( xclip.Clip(pos.X + acc.X * 0.5 * acc.dt * acc.dt)
                                        , yclip.Clip(pos.Y + acc.Y * 0.5 * acc.dt * acc.dt)
                                        )
                           );

            positions.Subscribe(c => this.ellipse1.SetCenter(c));
        }
    }

    public static class Helpers
    {
        public static IObservable GetAccEventStream(this Accelerometer accelerometer)
        {
            return Observable.Create(observer =>
            {
                EventHandler handler = (s, e) =>
                {
                    observer.OnNext(e);

                };
                accelerometer.ReadingChanged += handler;
                return () => { accelerometer.ReadingChanged -= handler; };
            });
        }

        public static void SetCenter(this Ellipse ellipse, Point c)
        {
            ellipse.SetValue(Canvas.LeftProperty,c.X - ellipse.Width / 2);
            ellipse.SetValue(Canvas.TopProperty, c.Y - ellipse.Height / 2);
        }
    }

In summary, this blog post has shown:

How to get started with the Windows Phone Accelerometer API,
How to bring the accelerometer’s ReadingChanged event into the realm of Rx, and use the corresponding event stream in Rx queries, and
How to drive a canvas element based on accelerometer readings.

Perhaps a short video showing the application in action would help? Let me know…

WP7 Code: Managing Application State

Dragos Manolescu — Tue, 26 Oct 2010 23:02:30 GMT

Visual Studio and the Windows Phone Developer Tools make building software for the Windows Phone similar to building desktop or browser applications. However, beyond these similarities crafting a phone application differs fundamentally from building an application aimed at a device with a keyboard, large screen, running on AC power, and with reliable network connectivity (to name just a few differences). Mobile device users are less likely to tolerate applications that demand too much of their attention, such as taking too much time to display information or to respond to actions. Consequently developers rely on techniques that make their applications provide a good experience.

This post shows how to extend the GeoFencing application to save and restore application state. Doing so in applications that need time to initialize can lower their launch time, one of the first thing their users will notice. The application state for the GeoFencing application comprises the perimeter’s center and radius. Preserving them across invocations allows the application to display information before acquiring a location fix (which, depending on the environment, could take a while). In addition to improving the perceived responsiveness storing the information about the perimeter also offers a better experience, allowing users to leave the application and then restart it without dropping the data.

Start by adding to the project a class representing the saved perimeter data (make sure you reference the System.Runtime.Serialization.dll which holds the namespace with the same name):

using System.Device.Location;
using System.Runtime.Serialization;

namespace GeoFencing
{
    [DataContract]
    public class PersistentRecord
    {
        [DataMember]
        public GeoCoordinate PerimeterCenter { get; set; }
        [DataMember]
        public double PerimeterRadius { get; set; }
    }
}

For this example I chose simple XML serialization—probably not a good choice if you’re dealing with lots of data and/or blobs.

Add a static property to the App class for holding the perimeter data. Next extend the Application_Activated, Application_Deactivated, and Application_Closing default implementations (template method) to load from/save to the PhoneApplicationService’s dictionary (to be picked up by a tombstoned application instance), or save it to the application’s isolated storage (to be picked up by a new application instance). The SavePersistentData method does all the work involving isolated storage.

// Code to execute when the application is launching (eg, from Start)
// This code will not execute when the application is reactivated
private void Application_Launching(object sender, LaunchingEventArgs e)
{
}

// Code to execute when the application is activated (brought to foreground)
// This code will not execute when the application is first launched
private void Application_Activated(object sender, ActivatedEventArgs e)
{
    if (PhoneApplicationService.Current.State.ContainsKey("GeoFencing"))
    {
        State = (PersistentRecord)PhoneApplicationService.Current.State["GeoFencing"];
    }
}

// Code to execute when the application is deactivated (sent to background)
// This code will not execute when the application is closing
private void Application_Deactivated(object sender, DeactivatedEventArgs e)
{
    if (State != null)
    {
        PhoneApplicationService.Current.State["GeoFencing"] = State;
        SavePersistentData();
    }
}

// Code to execute when the application is closing (eg, user hit Back)
// This code will not execute when the application is deactivated
private void Application_Closing(object sender, ClosingEventArgs e)
{
    if (State != null)
    {
        SavePersistentData();
    }
}

public static PersistentRecord State { get; set; }

private static void SavePersistentData()
{
    using (var store = IsolatedStorageFile.GetUserStoreForApplication())
    {
        using (var stream = store.CreateFile("center.dat"))
        {
            var serializer = new DataContractSerializer(typeof(PersistentRecord));
            serializer.WriteObject(stream, State);
        }
    }
}

Note that the default implementation of Application_Launching stays the same (do nothing). Application_Launching is on the critical path for startup. Consequently file I/O +deserialization (or anything else that has the potential of slowing down launch times) doesn’t belong there. An asynchronous invocation (hint: Rx) from the MainPage ctor is a better alternative. First here’s the method that reads the saved information from isolated storage (App class). While it won’t win any robustness awards (that’s left as an exercise for the reader) it does illustrate the point.

public static bool TryReadState(out PersistentRecord savedState)
{
    using (var store = IsolatedStorageFile.GetUserStoreForApplication())
    {
        IsolatedStorageFileStream stream = null;
        savedState = default(PersistentRecord);
        try
        {
            if (store.FileExists("center.dat"))
            {
                using (stream = store.OpenFile("center.dat", System.IO.FileMode.Open))
                {
                    var serializer = new DataContractSerializer(typeof(PersistentRecord));
                    savedState = (PersistentRecord)serializer.ReadObject(stream);
                }
                return (true);
            }

        }
        catch (System.IO.IOException)
        {
            // swallow
        }
        catch (System.IO.IsolatedStorage.IsolatedStorageException)
        {
            // swallow
        }
        catch (SerializationException)
        {
            store.DeleteFile("center.dat");
        }
        return false;
    }
}

The final updates to the MainPage.xaml.cs enable it to read and use the saved perimeter information. The following Rx query (placed after InitializeComponent) surfaces the saved state as an IObservable. The Start method invokes TryReadState asynchronously ,and ObserveOnDispatcher brings the events into the main (UI) thread. As there is at most one persistent record Take(1) drops everything else after that.

var savedStates = Observable.Start(() =>
{
    if (App.State != null)
    {
        return App.State;
    }
    else
    {
        PersistentRecord savedState;
        var isOk = App.TryReadState(out savedState);
        return isOk ? savedState : default(PersistentRecord);
    }
}).Where(e => e != null).ObserveOnDispatcher().Take(1);

The next change entails merging the stream corresponding to the radius position with the restored value provided by the App instance (either from the PhoneApplicationService or isolated storage):

var radii = this.slider1.GetValueChangedEventStream().Select(e => e.NewValue).StartWith(50)
.Merge(savedStates.Select(s => s.PerimeterRadius));

When either the perimeter’s center or radius change (via user input) a new PersistentRecord instance is set on the App object. The CombineLatest combinator provides an elegant solution for this:

centers.CombineLatest(radii, (l, r) => new { Center = l, Radius = r }).Subscribe(crs =>
    {
        App.State = new PersistentRecord { PerimeterCenter = crs.Center
                                         , PerimeterRadius = crs.Radius
                                         };
    });

The subsequent UI updates and distance computations (Rx queries) must use either the saved value or, upon the arrival of the first reading, the values from the geolocation subsystem. The TakeUntil combinator passes through the saved information until the arrival of the first center setting, extracted via the Select combinator :

var savedOrAcquiredCenters = centers.Publish(cs => cs.Merge(savedStates.Select(s => s.PerimeterCenter).TakeUntil(cs)));

The code for MainPage.xaml.cs follows. Building and running the application requires the XAML for the UI, as well as the App. xaml.cs and the PersistentRecord class.

public partial class MainPage : PhoneApplicationPage
{
    private GeoCoordinateWatcher gcw;
    public GeoCoordinateWatcher Gcw
    {
        get
        {
            if (gcw == null)
                gcw = new GeoCoordinateWatcher { MovementThreshold = 0.0 };
            return gcw;
        }
    }

    // Constructor
    public MainPage()
    {
        InitializeComponent();

        geoFenceButton.IsEnabled = false;
        slider1.IsEnabled = false;

        var savedStates = Observable.Start(() =>
        {
            if (App.State != null)
            {
                return App.State;
            }
            else
            {
                PersistentRecord savedState;
                var isOk = App.TryReadState(out savedState);
                return isOk ? savedState : default(PersistentRecord);
            }
        }).Where(e => e != null).ObserveOnDispatcher().Take(1);

        var positionUpdates = from sc in Gcw.GetStatusChangedEventStream()
                              where sc.Status == GeoPositionStatus.Ready
                              from pos in Gcw.GetPositionChangedEventStream()
                              let location = pos.Position.Location
                              where (!Double.IsNaN(location.Latitude) && !Double.IsNaN(location.Longitude) && location.HorizontalAccuracy <= 100.0)
                              select location;

        positionUpdates.Take(1).Subscribe(_ => geoFenceButton.IsEnabled = true);

        positionUpdates.Subscribe(l =>
        {
            this.hereTextBlock.Text = string.Format( "{0:###.00000000N;###.00000000S;0}, {1:###.00000000E;###.00000000W;0}"
                                                   , l.Latitude
                                                   , l.Longitude
                                                   );
        });

        var clicks = this.geoFenceButton.GetClickEventStream();

        clicks.Take(1).Subscribe(_ =>
            {
                this.slider1.IsEnabled = true;
            });

        var centers = positionUpdates.Publish(updates => from position in updates
                                                         from click in clicks.Take(1).TakeUntil(updates)
                                                         select position);

        var radii = this.slider1.GetValueChangedEventStream().Select(e => e.NewValue).StartWith(50)
                        .Merge(savedStates.Select(s => s.PerimeterRadius));

        centers.CombineLatest(radii, (l, r) => new { Center = l, Radius = r }).Subscribe(crs =>
            {
                App.State = new PersistentRecord { PerimeterCenter = crs.Center
                                                 , PerimeterRadius = crs.Radius
                                                 };
            });

        var savedOrAcquiredCenters = centers.Publish(cs => cs.Merge(savedStates.Select(s => s.PerimeterCenter).TakeUntil(cs)));

        savedOrAcquiredCenters.Subscribe(center =>
            {
                centerTextBlock.Text = string.Format("{0:###.00000000N;###.00000000S;0}, {1:###.00000000E;###.00000000W;0}", center.Latitude, center.Longitude);
            }
            );

        radii.Take(2).Subscribe(r => this.slider1.Value = r);

        radii.Subscribe(radius =>
            {
                this.fenceTextBlock.Text = string.Format("Perimeter radius {0:####.00}m",radius);
            });

        var distancesFromCenter = positionUpdates.CombineLatest(savedOrAcquiredCenters, (p, c) => p.GetDistanceTo(c)).DistinctUntilChanged();

        var distancesToFence = distancesFromCenter.CombineLatest(this.slider1.GetValueChangedEventStream(), (d, radius) => radius.NewValue - d);
        distancesToFence.Subscribe(distanceToFence =>
            {
                var msg = string.Empty;
                if (distanceToFence >= 0)
                {
                    msg = string.Format("{0:####.00}m from the fence", this.slider1.Value - distanceToFence);
                    distanceTextBlock.Foreground = new SolidColorBrush(Colors.Green);
                }
                else
                {
                     msg = string.Format("{0:####.00}m outside the fenced perimeter", Math.Abs(distanceToFence));
                     distanceTextBlock.Foreground = new SolidColorBrush(Colors.Red);
                }
                this.distanceTextBlock.Text = msg;
            });
    }

In summary, this post has shown:

How to tap into the application’s lifecycle via the methods exposed by the App class
How to use Observable.Start to asynchronously execute an Action, and bring the results to the UI thread with ObserveOnDispatcher
How to leverage Rx to combine events from several event streams

WP7 Code: Geofencing with the GeoLocation API and Rx

Dragos Manolescu — Wed, 13 Oct 2010 18:48:00 GMT

Besides providing geographical coordinates, computing distances, and making reverse geocoding service requests Windows Phone 7 can also signal when it is moved outside of a perimeter. The buzzword for this scenario is Geofencing, and this post shows how to implement it (when the geofence is circular) with the WP7 GeoLocation API and Rx.

An utilitarian UI will do just fine for a first exploration of geofencing. The UI starts from the default Windows Phone Application template and adds 6 textblocks (some of which are static labels), a slider, and a button inside the ContentPanel. The code follows below, with the portion added to the default template in green:

Next add references to System.Devices.Sensors (for GeoLocation), and System.Observable and Microsoft.Phone.Reactive (for Rx). I will also be using the GeoLocation library from my previous post so add a Project reference as well.

For a (slight) change of style I’ll expose the GeoCoordinateWatcher instance as a property of the MainPage class. Here’s the relevant code:

public partial class MainPage : PhoneApplicationPage
{

    private GeoCoordinateWatcher gcw;
    public GeoCoordinateWatcher Gcw
    {
        get
        {
            if (gcw == null)
                gcw = new GeoCoordinateWatcher { MovementThreshold = 10.0 };
            return gcw;
        }
    }
    // snip

The page navigation overrides (To and From) start and stop the geolocation subsystem:

protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
    base.OnNavigatedTo(e);

    Gcw.Start();
}

protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
{
    base.OnNavigatedFrom(e);

    Gcw.Stop();
}

The code begins by disabling the button and slider controls. A first Rx query provides a stream of location events by joining the geolocation status changed event stream with the position changed event stream, and filtering out readings with horizaontal accuracy greater than 100m (below). Note that since Rx lazily evaluates the query, building it on the startup critical path (i.e., the MainPage constructor) doesn’t really do anything besides getting the query in place.

geoFenceButton.IsEnabled = false;
slider1.IsEnabled = false;

var positionUpdates = from sc in Gcw.GetStatusChangedEventStream()
                      where sc.Status == GeoPositionStatus.Ready
                      from pos in Gcw.GetPositionChangedEventStream()
                      let location = pos.Position.Location
                      where (!Double.IsNaN(location.Latitude) && !Double.IsNaN(location.Longitude) && location.HorizontalAccuracy <= 100.0)
                      select location;

As soon as the position updates start trickling in the code enables the button (for the first position update via the Take operator), and displays the current location (lat/long) in the appropriate text box. Here are the subscribers for these event streams:

positionUpdates.Take(1).Subscribe(_ => geoFenceButton.IsEnabled = true);

positionUpdates.Subscribe(l =>
{
    this.hereTextBlock.Text = string.Format( "{0:###.00000000N;###.00000000S;0}, {1:###.00000000E;###.00000000W;0}"
                                           , l.Latitude
                                           , l.Longitude
                                           );
});

Tapping the button causes the application to use the current position as the perimeter’s center—hence enabling the button only after the position becomes available. This requires bringing button Click events into the realm of Rx, and then a query that for each tap pulls the most recent position. The query updates the appropriate text box with the center’s position. The code is below, with the extension method first (put it in a static Helpers class) followed by the event stream code (put it into MainPage). Just like the code above, the first button click event enables additional UI elements—in this case the slider control—and sets their initial value to 50.

public static IObservable GetClickEventStream(this Button button)
{
    return Observable.Create(observable =>
    {
        RoutedEventHandler handler = (s, e) =>
        {
            observable.OnNext(e);
        };
        button.Click += handler;
        return () => { button.Click -= handler; };
    });
}

var clicks = this.geoFenceButton.GetClickEventStream();

            clicks.Take(1).Subscribe(_ =>
                {
                    this.slider1.IsEnabled = true;
                    this.slider1.Value = 50.0;
                });

            var centers = positionUpdates.Publish(updates => from position in updates
                                                             from click in clicks.Take(1).TakeUntil(updates)
                                                             select position);

            centers.Subscribe(center =>
                {
                    centerTextBlock.Text = string.Format("{0:###.00000000N;###.00000000S;0}, {1:###.00000000E;###.00000000W;0}", center.Latitude, center.Longitude);
                }
                );

The slider determines the perimeter’s radius. As with other UI controls such as the button, the events it raises can be used in Rx queries. Here’s the extension method that does the bridging between RoutedPropertyChangedEventArgs and IObservable> (and goes in the Helpers class), followed by the code that updates the UI element with the radius selected via the slider (and goes in the MainPage constructor):

public static IObservable> GetValueChangedEventStream(this Slider slider)
{
    return Observable.Create>(observable =>
        {
            RoutedPropertyChangedEventHandler handler = (s,e) =>
                {
                    observable.OnNext(e);
                };
            slider.ValueChanged += handler;
            return () => { slider.ValueChanged -= handler; };
        });
}

var radii = this.slider1.GetValueChangedEventStream();

radii.Subscribe(radius =>
    {
        this.fenceTextBlock.Text = string.Format("Perimeter radius {0:####.00}m",radius.NewValue);
    });

The last two queries compute the distance from the perimeter’s center, and the distance to the fence. The first query uses the CombineLatest operator to return the (Haversine) distance from the center to the current position. Note that I use the GetDistanceTo method rather than the homegrown version shown in the previous posts—thanks for the feedback! The second query computes the distance to the fence by subtracting the latest distance from center from the latest radius value from the slider. The subscriber to this last stream updates the appropriate text box with a message, changing the text color depending on where the current location lies with respect to the fence. Here’s the code:

var distancesFromCenter = positionUpdates.CombineLatest(centers, (p, c) => p.GetDistanceTo(c)).DistinctUntilChanged();

var distancesToFence = distancesFromCenter.CombineLatest(this.slider1.GetValueChangedEventStream(), (d, radius) => radius.NewValue - d);
distancesToFence.Subscribe(distanceToFence =>
    {
        var msg = string.Empty;
        if (distanceToFence >= 0)
        {
            msg = string.Format("{0:####.00}m from the fence", this.slider1.Value - distanceToFence);
            distanceTextBlock.Foreground = new SolidColorBrush(Colors.Green);
        }
        else
        {
             msg = string.Format("{0:####.00}m outside the fenced perimeter", Math.Abs(distanceToFence));
             distanceTextBlock.Foreground = new SolidColorBrush(Colors.Red);
        }
        this.distanceTextBlock.Text = msg;
    });

The code for MainPage.xaml.cs follows. To build and run the application you’ll need the XAML as well as the GeoLocation library from my reverse Geocoding post.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using Microsoft.Phone.Controls;
using Microsoft.Phone.Reactive;
using System.Device.Location;
using GeoLocation;

namespace GeoFencing
{
    public partial class MainPage : PhoneApplicationPage
    {

        private GeoCoordinateWatcher gcw;
        public GeoCoordinateWatcher Gcw
        {
            get
            {
                if (gcw == null)
                    gcw = new GeoCoordinateWatcher { MovementThreshold = 10.0 };
                return gcw;
            }
        }
        // snip

        // Constructor
        public MainPage()
        {
            InitializeComponent();

            geoFenceButton.IsEnabled = false;
            slider1.IsEnabled = false;

            var positionUpdates = from sc in Gcw.GetStatusChangedEventStream()
                                  where sc.Status == GeoPositionStatus.Ready
                                  from pos in Gcw.GetPositionChangedEventStream()
                                  let location = pos.Position.Location
                                  where (!Double.IsNaN(location.Latitude) && !Double.IsNaN(location.Longitude) && location.HorizontalAccuracy <= 100.0)
                                  select location;

            positionUpdates.Take(1).Subscribe(_ => geoFenceButton.IsEnabled = true);

            positionUpdates.Subscribe(l =>
            {
                this.hereTextBlock.Text = string.Format( "{0:###.00000000N;###.00000000S;0}, {1:###.00000000E;###.00000000W;0}"
                                                       , l.Latitude
                                                       , l.Longitude
                                                       );
            });

            var clicks = this.geoFenceButton.GetClickEventStream();

            clicks.Take(1).Subscribe(_ =>
                {
                    this.slider1.IsEnabled = true;
                    this.slider1.Value = 50.0;
                });

            var centers = positionUpdates.Publish(updates => from position in updates
                                                             from click in clicks.Take(1).TakeUntil(updates)
                                                             select position);

            centers.Subscribe(center =>
                {
                    centerTextBlock.Text = string.Format("{0:###.00000000N;###.00000000S;0}, {1:###.00000000E;###.00000000W;0}", center.Latitude, center.Longitude);
                }
                );

            var radii = this.slider1.GetValueChangedEventStream();

            radii.Subscribe(radius =>
                {
                    this.fenceTextBlock.Text = string.Format("Perimeter radius {0:####.00}m",radius.NewValue);
                });

            var distancesFromCenter = positionUpdates.CombineLatest(centers, (p, c) => p.GetDistanceTo(c)).DistinctUntilChanged();

            var distancesToFence = distancesFromCenter.CombineLatest(this.slider1.GetValueChangedEventStream(), (d, radius) => radius.NewValue - d);
            distancesToFence.Subscribe(distanceToFence =>
                {
                    var msg = string.Empty;
                    if (distanceToFence >= 0)
                    {
                        msg = string.Format("{0:####.00}m from the fence", this.slider1.Value - distanceToFence);
                        distanceTextBlock.Foreground = new SolidColorBrush(Colors.Green);
                    }
                    else
                    {
                         msg = string.Format("{0:####.00}m outside the fenced perimeter", Math.Abs(distanceToFence));
                         distanceTextBlock.Foreground = new SolidColorBrush(Colors.Red);
                    }
                    this.distanceTextBlock.Text = msg;
                });
        }

        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            Gcw.Start();
        }

        protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedFrom(e);

            Gcw.Stop();
        }

static class Helpers
    {
        public static IObservable GetClickEventStream(this Button button)
        {
            return Observable.Create(observable =>
            {
                RoutedEventHandler handler = (s, e) =>
                {
                    observable.OnNext(e);
                };
                button.Click += handler;
                return () => { button.Click -= handler; };
            });
        }

        public static IObservable> GetValueChangedEventStream(this Slider slider)
        {
            return Observable.Create>(observable =>
                {
                    RoutedPropertyChangedEventHandler handler = (s,e) =>
                        {
                            observable.OnNext(e);
                        };
                    slider.ValueChanged += handler;
                    return () => { slider.ValueChanged -= handler; };
                });
        }
    }
}

Here’s a screenshot showing the phone within the geofenced perimeter:

In summary, this post has shown:

How to perform computations on two event streams using the CombineLatest operator
How to use Rx with a slider and button control
How to implement geofencing using Windows Phone 7’s geolocation API and Rx queries

WP7 Code: Reverse GeoCoding with the Bing Maps Service

Dragos Manolescu — Thu, 07 Oct 2010 00:29:33 GMT

My previous blog posts showed how to obtain location as an event stream from the Windows Phone 7 GeoLocation API, and how to translate lat/long position readings into distances. Here I show how to build an application that combines data from the phone’s geolocation subsystem with data from the cloud. In effect it is a data mashup running in your pocket, and powered by a battery :)

I will be (re)using some of the code from the previous applications. As this is their 3rd use it makes sense to pull the common functionality into a class library. Create a new Windows Phone Application project, and then add a Windows Phone Class Library to it. Add the following classes to this library (they require a few additional references that are not included by default):

using System;
using System.Device.Location;
using Microsoft.Phone.Reactive;

namespace GeoLocation
{
    public static class LocationHelpers
    {
        public static IObservable GetStatusChangedEventStream(this GeoCoordinateWatcher watcher)
        {
            return Observable.Create(observer =>
            {
                EventHandler handler = (s, e) =>
                {
                    observer.OnNext(e);
                };
                watcher.StatusChanged += handler;
                return () => { watcher.StatusChanged -= handler; };
            }
            );
        }

        public static IObservable> GetPositionChangedEventStream(this GeoCoordinateWatcher watcher)
        {
            return Observable.Create>(observable =>
            {
                EventHandler> handler = (s, e) =>
                {
                    observable.OnNext(e);
                };
                watcher.PositionChanged += handler;
                return () => { watcher.PositionChanged -= handler; };
            }
            );
        }
    }
}

and

using System;
using System.Device.Location;

namespace GeoLocation
{
    public enum DistanceIn { Miles, Kilometers };

    public static class Haversine
    {

        public static double Between(this DistanceIn @in, GeoPosition here, GeoPosition there)
        {
            var r = (@in == DistanceIn.Miles) ? 3960 : 6371;
            var dLat = (there.Location.Latitude - here.Location.Latitude).ToRadian();
            var dLon = (there.Location.Longitude - here.Location.Longitude).ToRadian();
            var a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) +
                    Math.Cos(here.Location.Latitude.ToRadian()) * Math.Cos(there.Location.Latitude.ToRadian()) *
                    Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
            var c = 2 * Math.Asin(Math.Min(1, Math.Sqrt(a)));
            var d = r * c;
            return d;
        }

        private static double ToRadian(this double val)
        {
            return (Math.PI / 180) * val;
        }
    }
}

Now to the main application code. Just like the previous applications the UI is minimalistic :) Add the following XAML (in green) within the ContentPanel Grid control:

The application holds a GeoCoordinateWatcher in an instance variable, and stops it when the user navigates away from the page:

namespace ReverseGeoCode
{
    public partial class MainPage : PhoneApplicationPage
    {
        private GeoCoordinateWatcher gcw;

        public MainPage()
        {
            InitializeComponent();
        }

        protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
        {
             base.OnNavigatedFrom(e);

            gcw.Stop();
        }

The OnNavigatedTo override starts the geolocation subsystem. It also prepares the UI (disabling the button), and then updates it in response to the events from the GeoLocationWatcher instance. Similar to the previous examples the implementation leverages RxLINQ. Here’s the code:

protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
    base.OnNavigatedTo(e);

    if (gcw == null)
        gcw = new GeoCoordinateWatcher { MovementThreshold = 0.0 };

    gcw.Start();

    geoCodeButton.IsEnabled = false;

    var statusChanges = gcw.GetStatusChangedEventStream().Select(sc =>
        {
            var message=string.Empty;
            var isReady=false;
            switch (sc.Status)
            {
                case GeoPositionStatus.Disabled:
                    message = "Disabled";
                    break;
                case GeoPositionStatus.Initializing:
                    message = "Initializing";
                    break;
                case GeoPositionStatus.NoData:
                    message = "No data";
                    break;
                case GeoPositionStatus.Ready:
                    message = "Ready, waiting for update...";
                    isReady = true;
                    break;
                default:
                    break;
            }
            return new { isReady, message };
        });

    statusChanges.Subscribe(sc =>
        {
            statusTextBlock.Text = sc.message;
        });

    var positionUpdates = from sc in statusChanges
                          where sc.isReady
                          from pos in gcw.GetPositionChangedEventStream()
                          let location = pos.Position.Location
                          where (!Double.IsNaN(location.Latitude) && !Double.IsNaN(location.Longitude) && location.HorizontalAccuracy <= 100.0)
                          select location;

    positionUpdates.Take(1).Subscribe(_ =>
        {
            geoCodeButton.IsEnabled = true;
        });

    positionUpdates.Subscribe(l =>
            {
                statusTextBlock.Text = string.Format("Location acquired (+/-{0}m)", l.HorizontalAccuracy);
                locationTextBlock.Text = string.Format( "{0:###.0000N;###.0000S;0}, {1:###.0000E;###.0000W;0}"
                                                      , l.Latitude
                                                      , l.Longitude
                                                      );
            });
}

The statusChanges query projects the GeoPositionStatusChangedEventArgs event stream into a stream of (bool,string) pairs, with the bool indicating whether the geolocation system is ready (i.e., does it have a locked location), and the string its status in a user-friendly manner.The statusChanges subscriber updates the UI with the appropriate message. (Other resources/blogs show how to update the UI with data binding so I’m not doing it here.)

The positionUpdates query joins the status changes event stream with the location changes event stream, extracts the location from the position (via let), and projects the result into a location event stream. The two where clauses filter out unwanted status changes (e.g., GeoPositionStatus.Initializing) and location readings (e.g., HorizontalAccuracy over 100 meters).

The first event from this event stream enables the geoCodeButton. The Take combinator pulls a specified number of events—in this case just 1.

Finally, the last subscriber to the positionUpdates query updates the UI with the accuracy and lat/long from the location pushed by the phone’s geolocation subsystem.

At this point the application, though not a mashup, works with data provided solely by the device. See the following screenshot for a sample.

The last bit to add is a component that pulls data from the cloud. With the location information readily available the Bing Maps GeoCode Service provides an easy way to do just that. So let’s extend the code to issue ReverseGeocodeRequests and translate the lat/long into street addresses. Note that using Bing Services requires a Bing Maps Key (if you don’t already have one); authoritative information here.

To add a GeoCode service client to the project go to the project’s references, right-click, and select Add Service Reference:

Enter dev.virtualearth.net/webservices/v1/geocodeservice/geocodeservice.svc in the Address box (more info here), and GeoCodeService as the Namespace:

This will query the service/wsdl and add the corresponding files to the solution (under the hood VisualStudio does all the code generation):

Add using GeoCode.GeoCodeService; to the MainPage.xaml.cs file and the following instance variable and property to the MainPage class:

private GeocodeServiceClient geoCodeClient;
public GeocodeServiceClient GeoCodeClient
{
    get
    {
        if (null == geoCodeClient)
        {
            var binding = new BasicHttpBinding(BasicHttpSecurityMode.Transport);
            binding.MaxReceivedMessageSize = int.MaxValue;
            binding.MaxBufferSize = int.MaxValue;
            var serviceUri = new UriBuilder(@"dev.virtualearth.net/webservices/v1/geocodeservice/geocodeservice.svc");
            serviceUri.Scheme = Uri.UriSchemeHttps;
            serviceUri.Port = -1;
            geoCodeClient = new GeocodeServiceClient(binding, new EndpointAddress(serviceUri.Uri));
        }
        return geoCodeClient;
    }
}

As this is a cloud service the response arrives asynchronously. Rx allows one to regard this as an event stream, and query it via LINQ. First add the following extension method to the Helpers class. It is the same pattern as with location changed events.

public static class Helpers
{
    public static IObservable GetGeocodeCompletedEventStream(this GeocodeServiceClient gcss)
    {
        return Observable.Create(observable =>
            {
                EventHandler handler = (s, e) =>
                    {
                        observable.OnNext(e);
                    };
                gcss.ReverseGeocodeCompleted += handler;
                return () => { gcss.ReverseGeocodeCompleted -= handler; };
            });
    }
}

Next add the following method to MainPage.xaml.cs—don’t forget to replace the uppercase text with your own Bing Maps App Id:

    private void ResolveAddressFor(GeoCoordinate p)
    {
        geoCodeButton.IsEnabled = false;
        var request = new ReverseGeocodeRequest();
        request.Credentials = new Credentials { ApplicationId = @"REPLACE WITH YOUR OWN APP ID" };
        request.Location = new Location { Latitude = p.Latitude, Longitude = p.Longitude };
        request.ExecutionOptions = new ExecutionOptions { SuppressFaults = true };

        var results = from geoCodeResponse in GeoCodeClient.GetGeocodeCompletedEventStream()
                      where geoCodeResponse.Result.ResponseSummary.StatusCode == ResponseStatusCode.Success
                      select geoCodeResponse.Result;

        results.Subscribe(result =>
            {
                var msg = string.Empty;
                switch (result.Results.Count)
                {
                    case 0:
                        msg = @"No results";
                        break;
                    case 1:
                        msg = string.Format("{0}", result.Results.First().DisplayName);
                        break;
                    default:
                        msg = string.Format("(1/{0}) {1}", result.Results.Count, result.Results.First().DisplayName);
                        break;
                }
                addressTextBlock.Text = msg;
            });

        var errors = from geoCodeResponse in GeoCodeClient.GetGeocodeCompletedEventStream()
                     where geoCodeResponse.Result.ResponseSummary.StatusCode != ResponseStatusCode.Success
                     select geoCodeResponse.Result;
        errors.Subscribe(result =>
            {
                addressTextBlock.Text = string.Format("Error: {0}", result.ResponseSummary.FaultReason);
                this.GeoCodeClient.CloseAsync();
            });

        results.Merge(errors).Subscribe(_ => geoCodeButton.IsEnabled = true);

        this.GeoCodeClient.ReverseGeocodeAsync(request);
    }
}

This method prepares the web service request. The key pieces include the location information provided by the phone’s geolocation subsystem, and the application ID that identifies you to the Bing service. The results RxLINQ query leverages the extension method that bridges between .NET events and Rx event streams, selecting only successful responses. The results subscriber updates the UI with the first resolved address. Likewise, the errors RxLINQ query selects unsuccessful events, and its subscriber updates the UI with the fault reason. Finally, upon a successful or an error response (via the Rx Merge combinator) the code updates the UI by (re)enabling the button (which is disabled at the beginning of the method). In effect, the UI signals that Bing maps is servicing the request and prevents the user from triggering a new request during this time. Finally, the method invokes the ReverseGeocodeAsync method on the service client. This is where the code leverages the cloud.

To complete the puzzle, upon each tap of the geoCodeButton the code must take the last location reading, invoke the Bing Map Geocode service passing the location information, and update the UI accordingly. The following extension method (add it to the helpers class) brings the button’s click events into the Rx realm:

public static IObservable GetClickEventStream(this Button button)
{
    return Observable.Create(observable =>
    {
        RoutedEventHandler handler = (s, e) =>
        {
            observable.OnNext(e);
        };
        button.Click += handler;
        return () => { button.Click -= handler; };
    });
}

The Rx piece de resistance is the query that updates the UI. The tricky bit stems from using the latest location information, which updates as often as the clauses in the positionUpdates query evaluate to true. Initially I stored the latest location into an instance variable, and had button click events update the UI with that information. However my friend, colleague, and Rx founding father Erik Meijer suggested a more elegant approach that accomplishes the same without side-effects. Here are the queries that tie button clicks and location updates—add this snippet at the end of the OnNavigatedTo method:

var buttonClicks = geoCodeButton.GetClickEventStream();

var latestLocations = positionUpdates.Publish(updates => from position in updates
                                            from click in buttonClicks.Take(1).TakeUntil(updates)
                                            select position);

latestLocations.Subscribe(l =>
    ResolveAddressFor(l)
    );

The TakeUntil combinator synchronizes the button click with the location changed event stream; the Publish operator allows the updates stream to appear in two different places without duplicating the effects of any potential side-effects. In case it’s too hard to put together all the above pieces the complete code for MainPage.xaml.cs follows. To run it you need the XAML as well as the Bing Maps GeoCode service reference (with the appropriate application ID):

using System;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using Microsoft.Phone.Controls;
using System.Device.Location;
using Microsoft.Phone.Reactive;
using GeoLocation;
using GeoCode.GeoCodeService;
using System.ServiceModel;

namespace ReverseGeoCode
{
    public partial class MainPage : PhoneApplicationPage
    {
        private GeoCoordinateWatcher gcw;

        private GeocodeServiceClient geoCodeClient;
        public GeocodeServiceClient GeoCodeClient
        {
            get
            {
                if (null == geoCodeClient)
                {
                    var binding = new BasicHttpBinding(BasicHttpSecurityMode.Transport);
                    binding.MaxReceivedMessageSize = int.MaxValue;
                    binding.MaxBufferSize = int.MaxValue;
                    var serviceUri = new UriBuilder(@"dev.virtualearth.net/webservices/v1/geocodeservice/geocodeservice.svc");
                    serviceUri.Scheme = Uri.UriSchemeHttps;
                    serviceUri.Port = -1;
                    geoCodeClient = new GeocodeServiceClient(binding, new EndpointAddress(serviceUri.Uri));
                }
                return geoCodeClient;
            }
        }
        public MainPage()
        {
            InitializeComponent();
        }

        protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
        {
             base.OnNavigatedFrom(e);

            gcw.Stop();
        }

        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            if (gcw == null)
                gcw = new GeoCoordinateWatcher { MovementThreshold = 0.0 };

            gcw.Start();

            geoCodeButton.IsEnabled = false;

            var statusChanges = gcw.GetStatusChangedEventStream().Select(sc =>
                {
                    var message=string.Empty;
                    var isReady=false;
                    switch (sc.Status)
                    {
                        case GeoPositionStatus.Disabled:
                            message = "Disabled";
                            break;
                        case GeoPositionStatus.Initializing:
                            message = "Initializing";
                            break;
                        case GeoPositionStatus.NoData:
                            message = "No data";
                            break;
                        case GeoPositionStatus.Ready:
                            message = "Ready, waiting for update...";
                            isReady = true;
                            break;
                        default:
                            break;
                    }
                    return new { isReady, message };
                });

            statusChanges.Subscribe(sc =>
                {
                    statusTextBlock.Text = sc.message;
                });

            var positionUpdates = from sc in statusChanges
                                  where sc.isReady
                                  from pos in gcw.GetPositionChangedEventStream()
                                  let location = pos.Position.Location
                                  where (!Double.IsNaN(location.Latitude) && !Double.IsNaN(location.Longitude) && location.HorizontalAccuracy <= 100.0)
                                  select location;

            positionUpdates.Take(1).Subscribe(_ =>
                {
                    geoCodeButton.IsEnabled = true;
                });

            positionUpdates.Subscribe(l =>
                    {
                        statusTextBlock.Text = string.Format("Location acquired (+/-{0}m)", l.HorizontalAccuracy);
                        locationTextBlock.Text = string.Format( "{0:###.0000N;###.0000S;0}, {1:###.0000E;###.0000W;0}"
                                                              , l.Latitude
                                                              , l.Longitude
                                                              );
                    });

            var buttonClicks = geoCodeButton.GetClickEventStream();

            var latestLocations = positionUpdates.Publish(updates => from position in updates
                                                        from click in buttonClicks.Take(1).TakeUntil(updates)
                                                        select position);

            latestLocations.Subscribe(l =>
                ResolveAddressFor(l)
                );
        }

        private void ResolveAddressFor(GeoCoordinate p)
        {
            geoCodeButton.IsEnabled = false;
            var request = new ReverseGeocodeRequest();
            request.Credentials = new Credentials { ApplicationId = @"REPLACE WITH YOUR OWN APP ID" };
            request.Location = new Location { Latitude = p.Latitude, Longitude = p.Longitude };
            request.ExecutionOptions = new ExecutionOptions { SuppressFaults = true };

            var results = from geoCodeResponse in GeoCodeClient.GetGeocodeCompletedEventStream()
                          where geoCodeResponse.Result.ResponseSummary.StatusCode == ResponseStatusCode.Success
                          select geoCodeResponse.Result;

            results.Subscribe(result =>
                {
                    var msg = string.Empty;
                    switch (result.Results.Count)
                    {
                        case 0:
                            msg = @"No results";
                            break;
                        case 1:
                            msg = string.Format("{0}", result.Results.First().DisplayName);
                            break;
                        default:
                            msg = string.Format("(1/{0}) {1}", result.Results.Count, result.Results.First().DisplayName);
                            break;
                    }
                    addressTextBlock.Text = msg;
                });

            var errors = from geoCodeResponse in GeoCodeClient.GetGeocodeCompletedEventStream()
                         where geoCodeResponse.Result.ResponseSummary.StatusCode != ResponseStatusCode.Success
                         select geoCodeResponse.Result;
            errors.Subscribe(result =>
                {
                    addressTextBlock.Text = string.Format("Error: {0}", result.ResponseSummary.FaultReason);
                    this.GeoCodeClient.CloseAsync();
                });

            results.Merge(errors).Subscribe(_ => geoCodeButton.IsEnabled = true);

            this.GeoCodeClient.ReverseGeocodeAsync(request);
        }
    }

    public static class Helpers
    {
        public static IObservable GetClickEventStream(this Button button)
        {
            return Observable.Create(observable =>
            {
                RoutedEventHandler handler = (s, e) =>
                {
                    observable.OnNext(e);
                };
                button.Click += handler;
                return () => { button.Click -= handler; };
            });
        }

        public static IObservable GetGeocodeCompletedEventStream(this GeocodeServiceClient gcss)
        {
            return Observable.Create(observable =>
                {
                    EventHandler handler = (s, e) =>
                        {
                            observable.OnNext(e);
                        };
                    gcss.ReverseGeocodeCompleted += handler;
                    return () => { gcss.ReverseGeocodeCompleted -= handler; };
                });
        }
    }
}

Here’s the screenshot with the address information for the coordinates picked up in my office (it looks like not all the address information is available):

In summary, this post has shown:

How to use RxLINQ queries for UI updates,
How to use RxLINQ queries for cloud services’ results, and
How to mash up Windows Phone 7 GeoLocation data with data provided by Bing Map Geocode service.

WP7 Code: Distance Computations with the GeoLocation API

Dragos Manolescu — Wed, 29 Sep 2010 23:51:05 GMT

In my previous post I showed the most interesting code fragments for a location-aware Windows Phone 7 application. The code generates an event stream corresponding to location readings from the phone’s location subsystem. However, there are many applications that instead of lat/long readings need to compute the traveled distance (for example, when driving, biking, running, or hiking). This post shows how to convert the position readings from the Windows Phone location subsystem into distance measurements.

To begin with remember that motion on earth’s surface occurs on a(n approximate) sphere rather than on a plane. Consequently Euclidean geometry no longer does it; instead, the Haversine formula provides the distance between 2 locations. As implementing Haversine in C# has nothing to do with the phone I will reuse some code surfaced by a Web search. The implementation’s use of C# extension methods is in line with what I used to bridge between .NET events and RxLINQ event streams. In addition, they make the code read like English, which is pretty neat. The C# Haversine code follows, with the argument types updated to match those from the WP7 GeoLocation API:

public enum DistanceIn { Miles, Kilometers };

public static class Haversine
{

    public static double Between(this DistanceIn @in, GeoPosition here, GeoPosition there)
    {
        var r = (@in == DistanceIn.Miles) ? 3960 : 6371;
        var dLat = (there.Location.Latitude - here.Location.Latitude).ToRadian();
        var dLon = (there.Location.Longitude - here.Location.Longitude).ToRadian();
        var a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) +
                Math.Cos(here.Location.Latitude.ToRadian()) * Math.Cos(there.Location.Latitude.ToRadian()) *
                Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
        var c = 2 * Math.Asin(Math.Min(1, Math.Sqrt(a)));
        var d = r * c;
        return d;
    }

    private static double ToRadian(this double val)
    {
        return (Math.PI / 180) * val;
    }
}

Start with the application from my previous blog post and change the XAML (MainPage.xaml) to include a text block and a button in the content panel (new code in green):

Next wire the button such that taps (i.e., Click events) start or stop the GeoLocationWatcher. As clicks are asynchronous events RxLINQ provides an elegant solution to deal with them. First add to the Helpers class an extension method that brings Click events into the realm of Rx:

public static IObservable GetClickEventStream(this Button button)
{
    return Observable.Create(observable =>
        {
            RoutedEventHandler handler = (s, e) =>
                {
                    observable.OnNext(e);
                };
            button.Click += handler;
            return () => { button.Click -= handler; };
        });
}

Next remove the gcw.Start() from OnNavigatedTo override and add an RxLINQ query and subscriber to the button click event stream (new code in green):

protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
    base.OnNavigatedTo(e);

    if (gcw == null)
        gcw = new GeoCoordinateWatcher();

    ShowGeoLocation();
}

// snip

public void ShowGeoLocation()
{
    var statusChanges = from statusChanged in gcw.GetStatusChangedEventStream()
                        where statusChanged.Status == GeoPositionStatus.Ready
                        select statusChanged;

    button1.GetClickEventStream().Scan( false
                                      , (isStarted, _) =>
                                       {
                                           if (isStarted)
                                               gcw.Stop();
                                           else
                                               gcw.Start();
                                           return !isStarted;
                                       }).Subscribe(isStarted => button1.Content = isStarted ? "Stop" : "Start" );

The Scan operator allows the query to carry state from one Click event to the other. Each click event starts or stops the GeoLocationWatcher instance depending on the accumulator’s value, and then toggles it. The subscriber updates the button’s content accordingly.

Next the code must ensure that the distance computations takes into account only readings that have different lat/long values. The DistinctUntilChanged RxLINQ operator with a comparator that considers only the Latitude and Longitude values provides an elegant solution to the deduplication problem. Here’s the comparator’s code:

public class PositionComparator : IEqualityComparer>
{

    public bool Equals(GeoPosition x, GeoPosition y)
    {
        return (x.Location.Latitude == y.Location.Latitude && x.Location.Longitude == y.Location.Longitude);
    }

    // snip
}

And here’s the updated positions query (new code in green):

var positions = (from position in positionChanges
where position.Location.HorizontalAccuracy <= 100
select position).DistinctUntilChanged(new PositionComparator());

Computing distances requires two points. An elegant solution to using the current and previous location events is to combine the location event stream with itself such that every event pair represents the current and previous coordinates. The RxLINQ Zip operator combines the event streams, and the Skip operator provides the shift required for this pairing. Here’s the query that computes the distance in Km (for imperial units replace Kilometers with Miles):

var distances = positions.Zip(positions.Skip(1), (l, r) => DistanceIn.Kilometers.Between(r, l));

Finally, the Scan operator applied to the distances event stream computes the total distance; the accumulator’s initial value is 0.0, and the display shows meters:

var distance = distances.Scan(0.0, (a, e) => a + e);

distance.Subscribe(d => this.textBlock1.Text = string.Format("Distance so far {0:00.000} m",d*1000));

In summary, this post has shown:

How to convert Windows Phone 7 lat/long readings into distances,
How to use RxLINQ queries for UI (button click events), and
How to perform calculations on adjacent elements in an event stream via the Zip and Skip operators.

WP7 Code: Using the GeoLocation API

Dragos Manolescu — Tue, 21 Sep 2010 23:40:31 GMT

I’m kicking off a series of blog posts focused on writing Windows Phone 7 code with one of the APIs that will probably attract many developers interested in getting their feet wet: GeoLocation. Building this code requires:

The Windows Phone Developer Tools, fresh off the press as of September 16.
The Windows Phone Development documentation from MSDN.

Before I begin, a few things to be aware of. First, the samples are not intended to be production code. In other words, don’t use this code in your avionics system. Second, I emphasize Windows Phone code at the expense of other aspects. For example, while data binding may provide an elegant solution to updating GUI elements, I’m leaving its implementation as an exercise to the reader :) Caveat emptor.

Enough prose, let’s write some code. Start by opening a new Windows Phone Application in Visual Studio. This will create the necessary directories and unfold the appropriate templates. Add a TextBlock to the Grid called ContentPanel; the XAML will look similar to the following (new content in green):

Next add a reference to the assembly holding the GeoLocation API (System.Device), and the appropriate using directive:

using System.Device.Location;

As Windows Phone 7 includes the .NET Reactive Framework (Rx) I will be using it for event-based code. To that end add references to System.Observable and Microsoft.Phone.Reactive, and the appropriate using directive:

using Microsoft.Phone.Reactive;

An instance of GeoLocationWatcher held in an instance variable of the MainPage class provides access to the location information. The OnNavigatedTo and OnNavigatedFrom methods ensure that the location watcher is started when the page opens, and stopped when it is abandoned.

public partial class MainPage : PhoneApplicationPage
{
    GeoCoordinateWatcher gcw;

    // Constructor
    public MainPage()
    {
        InitializeComponent();
    }

    protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
    {
        base.OnNavigatedTo(e);

        if (gcw == null)
            gcw = new GeoCoordinateWatcher();

        gcw.Start();

        ShowGeoLocation();
    }

    protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
    {
        base.OnNavigatedFrom(e);

        if (gcw != null)
            gcw.Stop();
    }

    // snip

The ShowGeoLocation method contains code that updates the UI (i.e., text box) with the location information. Before covering that code let’s go over a couple of helper methods that convert the .NET events raised by the GeoLocationWatcher class into Rx event streams. The first event of interest is StatusChanged. It signals when the location subsystem is ready and thus able to provide location information. The second event is PositionChanged, which signals whenever the position of the device, as determined by the location subsystem, changes. The following extension methods provide the corresponding event streams:

public static class Helpers
{
    public static IObservable GetStatusChangedEventStream(this GeoCoordinateWatcher watcher)
    {
        return Observable.Create(observer =>
            {
                EventHandler handler = (s, e) =>
                    {
                        observer.OnNext(e);
                    };
                watcher.StatusChanged += handler;
                return () => { watcher.StatusChanged -= handler; };
            }
        );
    }

    public static IObservable> GetPositionChangedEventStream(this GeoCoordinateWatcher watcher)
    {
        return Observable.Create>(observable =>
            {
                EventHandler> handler = (s, e) =>
                    {
                        observable.OnNext(e);
                    };
                watcher.PositionChanged += handler;
                return () => { watcher.PositionChanged -= handler; };
            }
        );
    }
}

If you’re building an application that needs to determine the position just once (e.g., what’s around me based on where I’m at) then the following sequence of queries does just that, updating the contents of the text box with the location information:

public void ShowGeoLocation()
{
    var statusChanges = from statusChanged in gcw.GetStatusChangedEventStream()
                        where statusChanged.Status == GeoPositionStatus.Ready
                        select statusChanged;

    var positionChanges = from s in statusChanges
                          from position in gcw.GetPositionChangedEventStream()
                          select position.Position;

    var positions = from position in positionChanges
                         where position.Location.HorizontalAccuracy <= 100
                         select position;

    positions.Take(1).Subscribe(firstLocationFix =>
        {
            textBlock1.Text = string.Format("{0},{1}"
                                   , firstLocationFix.Location.Latitude
                                   , firstLocationFix.Location.Longitude
                                   );
        }
    );

}

The first query (statusChanges) represents an event stream comprised of status changed events signaling that the location subsystem is ready. The second query (positionChanges) is a join between statusChanges and position changed events; this ensures that the latter is gated by the former. Finally, the third query (positions) filters the position changes based on the horizontal accuracy of each reading. The accuracy depends on how the location subsystem determines the location, and the code above discard readings below 100m accuracy. The last statement updates the UI with the first reading satisfying the (composed by now) queries:

Filtering of StatusChanged events by Status property
Joining between filtered StatusChanged events and LocationChanged events
Filtering of resulting LocationChanged events by HorizontalAccuracy property

What if you’re building an application that needs the series of location events (e.g., turn-by-turn navigation) rather than just one location? The Rx queries shown above remain unchanged. The only change involves how the event stream is consumed. The Take method is gone, and Action argument updates the text box contents. Here’s the ShowGeoLocation code, with the updated statement in green:

public void ShowGeoLocation()
{
    var statusChanges = from statusChanged in gcw.GetStatusChangedEventStream()
                        where statusChanged.Status == GeoPositionStatus.Ready
                        select statusChanged;

    var positionChanges = from s in statusChanges
                          from position in gcw.GetPositionChangedEventStream()
                          select position.Position;

    var positions = from position in positionChanges
                         where position.Location.HorizontalAccuracy <= 100
                         select position;

    positions.Subscribe(position =>
        {
            textBlock1.Text = string.Format( "{0},{1}"
                                           , position.Location.Latitude
                                           , position.Location.Longitude
                                           );
        }
    );

}

Even though the displayed latitude and longitude values may not change, the read values might change. To illustrate that the final update to this code adds a sequence number to the display. It also displays the horizontal accuracy. The code implements the sequence with the Scan operator (which applies an accumulator over the events) and an anonymous class encapsulating the sequence number. Here’s the ShowGeoLocation code, with the updated statement in green:

public void ShowGeoLocation()
{
    var statusChanges = from statusChanged in gcw.GetStatusChangedEventStream()
                        where statusChanged.Status == GeoPositionStatus.Ready
                        select statusChanged;

    var positionChanges = from s in statusChanges
                          from position in gcw.GetPositionChangedEventStream()
                          select position.Position;

    var positions = from position in positionChanges
                         where position.Location.HorizontalAccuracy <= 1000
                         select position;

   positions.Scan(new { i = 0
                                      , p = default(GeoPosition)
                                      },
                  (a,e) => new { i = a.i + 1
                                         , p = e }
                 ).Subscribe(e =>
        {
            textBlock1.Text = string.Format( "{0}:{1},{2}@{3}"
                                                                   , e.i
                                                                   , e.p.Location.Latitude
                                                                   , e.p.Location.Longitude
                                                                   , e.p.Location.HorizontalAccuracy
                                                                   );
        }
    );

}

In summary, this post has shown:

How to get started with the Windows Phone GeoLocation API,
How to convert the StatusChanged and PositionChanged events into Rx event streams, and
How to write LINQ queries against them.

Coming Soon: Windows Phone 7 Blog Posts

Dragos Manolescu — Wed, 08 Sep 2010 10:38:40 GMT

It’s been an embarrassingly long time since my last post on this blog. Several cool projects in the Windows Phone 7 team kept me busy. Now that we shipped the bits I’d like to revive this blog with snippets on writing Windows Phone 7 code. Stay tuned for posts with WP7 Code in the title :)

Web Sandbox available under the Apache License

Dragos Manolescu — Wed, 28 Jan 2009 01:36:00 GMT

Earlier today we announced releasing the runtime code of the Web Sandbox available under the Open Source Apache License 2.0. The announcement has already been picked up by the blogosphere. Should you head over to the site check out the Web Slices samples we added with this release: weather and traffic.