Siena can import Excel data in all its glory, but only while you are creating your app. The data is literally inserted into the app, so cannot be updated once your app has been published. (Before being published you can update your data by tapping the Refresh icon on the data sources page). This post describes a way of making your app consume updated data, after the app is done. All you need is to be able to write a .txt file to a location on your intranet or the internet.

TL;DR version

1. Save as CSV
2. Convert to JSON as .txt file
3. Put .txt file on intranet/internet somewhere
4. Create WADL file that points to this .txt file
5. Import WADL file into Siena

Here is the rather more detailed version

Firstly lets make a sample spreadsheet called Movies.xlsx which contains a simple table of the best movies out there, and call the table itself Movies.

In Excel do File / Save As a CSV file to create Movies.csv. You will likely get a warning about CSV files losing some information, but that’s ok, remember to keep the original xlsx file safe just in case. I’m sure there any many ways to convert Excel data to JSON, but the first one I found, that worked for me, was http://www.convertcsv.com/csv-to-json.htm . (This should not be taken as any kind of Microsoft endorsement of this site). Load your CSV file then click Convert CSJ to JSON, and from there click Save to Disk. This will create a .json file, I recommend renaming it to .txt as some web hosts (eg mine) are not happy delivering .json files over the internet (due to mime type configuration I think).

Next you need to put this movies.txt file on the intranet/internet using whatever method is available to you, such as FTP. Lets pretend I put this file on http://www.contoso.com/data/movies.txt (I did also try putting this on a corporate Sharepoint site, but the authentication got in the way).

Next install the WADL Generator http://social.technet.microsoft.com/Forums/en-US/82c7b717-5100-423c-aa44-effed28caf74/wadl-generator-for-project-siena?forum=projectsiena and fire it up.
Give the service a name (lets call it MovieDB), click Next. There is no authentication, so Next on that screen. We get to the functions screen, in the Name field put GetAll, and in the url field put the path to the .txt file. Click “Try It” and you should see the JSON in the window. Click Save and Next a few times, then name this file MoviesWADL.xml.

OK lets make a simple Siena app that consumes the Excel file directly, then we’ll update it to use the online version. Start up Siena, go to App Data / Data Sources / Excel and import the original Movies.xlsx file, selecting the table called Movies, then Import Data. The screen should show our data, so hit the back button to get to the canvas. Click + and add a new Text Gallery, then set its Items source to Movies, and instantly you’ll see the data in a scrollable list.

Save this Siena file, though of course in the real world you would create a fantastic app using this Movies data source. OK, lets switch the app over to the online version: back to Data Sources and delete the Movies.xlsx data. Instead click on REST and select the MoviesWADL.xml file we made earlier. To make sure it works, click the Try it button to see the data. Click Back to get to the canvas again, select the gallery we made earlier (which will be showing error triangles at this point), and change its Items property to MoviesDB!GetAll(). As if by magic the data will show up just as before, but now it is getting it live, well when the app starts up at least.

If you have multiple Excel tables you need to expose like this, create additional functions in the WADL Generator pointing to different .txt files, and give them other names. When your Excel data changes, you just have to repeat steps 1-3 above – no change in the WADL file or your app required. This method works well for data that doesn’t change very often, but if updates are required too often then you should consider creating a proper web service connected to a database, and expose a real REST API, instead of this manual conversion process.

My phone is unlocked and on a different carrier, when is my phone going to get the update?

My Lumia 920 is stuck at the gears screen after I updated/reset my phone

I have trouble with Bluetooth in my car

After the update, most of my apps don’t start

Will an unlocked Lumia 1020 work on T-Mobile (USA)?

My Lumia makes the charging sound randomly (eg in the middle of the night) when using a wireless charger

Please don’t post additional questions below, as I probably don’t know the answer and/or I am not a support service. I just don’t like repeating myself, that's all. Hope you find this useful.

Platform::String ^ DeviceName::PhoneName::get()
{
    WSADATA wsadata;
    ADDRINFOA *result = nullptr;
    int error;
    wchar_t wszName[256] = L"Unknown";
    ADDRINFOA hints = {};
 
    hints.ai_flags = AI_CANONNAME;
 
    error = WSAStartup(MAKEWORD(2,2), &wsadata);
    if (error==0)
    {
        error = ::getaddrinfo("", "0", &hints, &result);
        if (error==0)
        {
            char *name = result->ai_canonname;
            if (name!=nullptr)
            {
                MultiByteToWideChar(CP_ACP, 0, name, strlen(name), wszName, 256);
            }
        }
    }
 
    ::freeaddrinfo(result);
 
    return ref new Platform::String(wszName);
}

If you haven't used C++/CX on the phone you might need a little more info on how to hook this up, so here is the C++/CX Super-QuickStart guide by me:

Load your C# project into VS2012. Right click on the Solution then Add / New Project / Visual C++ / Windows Phone / Windows Phone Runtime Component and call it NetHelper.

In pch.h add:

#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>

Replace NetHelper.h with this simple ref class containing a single static property:

#pragma once
 
namespace NetHelper
{
    public ref class DeviceName sealed
    {
    public:
        static property Platform::String ^ PhoneName
        {
            Platform::String ^ get();
        }
    };
}

Replace NetHelper.cpp with the code at the start of the article, prefixed with this:

#include "pch.h"
#include "NetHelper.h"
 
using namespace NetHelper;
using namespace Platform;
 
#pragma comment(lib, "ws2_32.lib")

Build the NetHelper project.

Right click on your C# project's References tree / Add Reference / Solution / add a checkmark next to NetHelper / OK

In C# you can now using it with

var name = NetHelper.DeviceName.PhoneName;

That's it!

Firstly lets start with a trivial repro app, take the default WP8 project, add a using System.Diagnostics.Contracts, add a button, then this code:

        void TestContract(int arg)
        {
            Contract.Assert(arg == 42);
        }
 
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            TestContract(41);
        }

OK, lets F5 this in the Emulator, click the button and the process exits. If you look in the Output window you will see just this:

The program '[2192] TaskHost.exe' has exited with code -2147483645 (0x80000003).

TaskHost.exe is not your exe, its the Silverlight host that all managed apps get run in on the phone. The exit code is instantly recognizable (to crazed folks such as myself at least) as Breakpoint, ie an int 3 (in x86) was hit somewhere. OK so that's obviously not helpful, so switch to the Native debugger (remember the debugger is like Highlander, there can only be one [type]).

Same repro under the native debugger is a bit more useful, you get a MessageBox and the Output window says the same thing:

**** MessageBox invoked, title 'TaskHost.exe - Assertion failed.' ****

  Description: Assertion failed.

********

TaskHost.exe has triggered a breakpoint.

Well at least it stopped in the debugger this time, lets have a look at the callstack:

Not terribly helpful, so lets apply the Microsoft Public Symbols to this callstack:

Much better, and as with asserts, the root cause of this problem is that some code in the CLR wasn't updated for Phone, and tries to show the assert in a MessageBox which doesn't exist, so it dies. Working at Microsoft grants me certain special powers, so I used these (for good, obviously) and ran the repro with full symbols. Turns out if you go to the third frame on the callstack, and enter this into the Watch window, you can get a string containing the managed callstack of the contract failure:

(wchar_t**)($vframe+12)

(This is for x86 ie the Emulator, I have not tried this on an ARM device)

You can then use the totally awesome and brilliant Text Visualizer [you might be able to guess whose idea that feature was] to see the managed callstack that caused the contract failure. Note that there are no line numbers, ah well.

Now you know, somewhat, where the contract failure was, you can go fix it. Don't forget to switch back to the managed debugger when you want to debug that code. We can all hope this this problem (and the assert one) get fixed in the next release of the Phone tools (and it would be super-nice if we could debug both managed and native at the same time, like we have been able to do on the Desktop for a long time).

Please note that I know almost nothing about Contracts, I'm just working in an existing codebase that uses them, and I figured this out while trying to debug that code.

This makes the assert stop in the debugger, at least. If you want to know what the assert message is and where in the code it is you'll have to use the callstack, but this is a huge improvement over the in-box behavior. Thanks James!

The first, best Microsoft keyboard was the classic Natural Keyboard, released in 1994. It had a great feel, it was my introduction to the ergonomic layout and it was built to last. I still have four of these in my possession, and would still be using them if I hadn’t switched to the NKP when it was released in 1999. The NKP added media keys and USB support, and although the feel wasn’t quite as good it was a worthy successor. I am still using this keyboard today, the very same item, some fourteen years later. (I don't think I have any other piece of electronics I am still using from that long ago). Like I said, these keyboards were built very well indeed. Those of us who worship the NKP, and we are a substantial band, hoard them. They stopped being manufactured long ago, so it is important to keep the ones we have working, and to hoard any that we see being careless tossed aside by others. These keyboards can and do get filthy after years of use, which acts as a handy deterrent to anyone else wanting to use our machines. I thought my main keyboard was bad (check out the space bar in particular), but then I saw two co-workers NKPs. They looked disgusting, but still work perfectly and will only be taken from their owners from their cold, dead hands.

Mine: not bad for 14yr old hardware

Pete's:

At some point the MS keyboard team seem to lose their collective minds, frankly. They re-arranged the cursor pad from an inverted T to an actual cross, as if moving those keys around wouldn’t matter. They introduced the incredibly annoying F-lock feature, designed to really tick off everyone that used function keys (a tradition that is still going strong, see later). There were even attempts to rearrange Insert/Delete/Home/End layout as well. Over the years the quality of the keyboards just seemed to not be there any more, though this I’m guessing may be related to the falling MSRPs for keyboards in general. For home use I tried a Natural Ergonomic Keyboard 4000 a while ago. It’s kind of a black-colored leather-trimmed successor to the NKP, but the feel was mushy in comparison, and the build quality was missing. After a few months of light use at home the Q-T section actually creaked when I pressed those keys, so I quit using it and gave it to my kids. I got a “fresh” NKP out from my stash and use that instead now. Some co-workers on my team are using these 4000 models, but they don’t look very good as the lettering wears off the keys (I’ve never seen any lettering worn off an NKP).

The keyboard madness continues somewhat into this decade: the Surface’s Touch keyboard doesn’t have them at all, but that’s ok as no-one is going to use that for serious work (eg Visual Studio). However the Surface Type keyboard, which is intended for more serious work, does have function keys, but they default to media usage: you have to actually press the FN key every time you want to use a function key as, well, a function key. The Lenovo Yoga has a similar bizarre feature, but that can be overridden via a BIOS setting.

Will Microsoft ever better the NKP? What will its legions of fans do when their NKPs finally fail (or their kids pour something into them, a more likely scenario)? Will function keys still exist in a decade's time? Who knows. I think I know what keyboard I'll be using though.

[This post is my personal opinion as some guy producing Windows Phone apps, and should not be taken as any kind of Microsoft endorsement for this company or its products]

Flurry is an analytics engine that you add to your app and then it reports as much or as little as you would like it to about your app, within about four hours. It is very easy to use (its documentation consists of a tiny text file), it works very well, and its web site lets you grok the information in an easy to use way. Oh and it is totally free!

Getting Started

First off sign up on the site and you can register your application and get a unique key for it. Download the Windows Phone Flurry SDK and add a reference to their assembly in your project. Add a couple of calls to your Application class per their documentation and you already have the basics: you will now know how many new users you have, how long they use your app, in what country they are, what phone and what version they are using, and lots of other information. Those of us accustomed to the glacial performance of the App Hub system and web site, with its inexplicable reporting delays, will be especially pleased with all aspects of the Flurry system. Apart from the default data collection, the data that I find most important is ship-asserts and basic analytics.

Basic Analytics

I report when any page in the app is visited, sometimes with an additional argument. I also report which buttons are clicked as well, to determine which features customers are using and which they are not. I use the Flurry LogEvent API for this, with arguments of “Button”, the page name (“LittleWatson" in the example below) and then the name of the button itself.

Ship Asserts

There are points in my code where I have ship-asserts: they are similar to regular asserts, but actually exist in release builds. Before Flurry they would generate emails, based on an extended version of my LittleWatson code, but I learned when I first added Flurry to the beta version of my app that even beta testers often don’t bother to send those emails (I instrumented LittleWatson itself, see the graph above). So now I report ship-asserts, often with additional useful data, via Flurry. Flurry has a limit of 255 characters per argument but I often have data larger than that I want to see, so I use this code so I can still see all of the data:

internal static void ShipAssert(string name, string item, string value)
{
    const int max = 250;
    List<FlurryWP7SDK.Models.Parameter> items = new List<FlurryWP7SDK.Models.Parameter>();
    if (value == null)
        value = "<null>";
 
    if (value.Length < max)
    {
        items.Add(new FlurryWP7SDK.Models.Parameter(item, value));
    }
    else
    {
        // chop up long values
        int chunk = 0;
        for (int i = 0; i < value.Length; i += max)
        {
            int len = Math.Min(value.Length - i, max);
            string key = item;
            if (chunk != 0)
                key = item + "_" + chunk.ToString();
            items.Add(new FlurryWP7SDK.Models.Parameter(key, value.Substring(i, len)));
            chunk++;
        }
    }
    FlurryWP7SDK.Api.LogEvent(name, items, false);
}

On the Flurry web site if you Export as CSV on an Event it will gather together the _1, _2 etc chunks for you (though not in order), you can’t see this in the default view. Two of my ship-asserts led me to find bugs that I had no idea existed: no-one had emailed me directly or via LittleWatson, and no-one reported it in Reviews (which is a terrible way to report bugs IMHO).

Version

By default Flurry reports the version of the app by reading it from AppManifest.xml. However in my apps I always leave that at 1.0.0.0 and update the versions in AssemblyInfo.cs, so I set this version explicitly via their API. It is important to do this as soon as possible, else some data will be reported as coming from version 1.0.0.0 erroneously. I also change the version number reported for Debug, Beta and Trial apps, and Flurry produces handy graphs based on the version:

// Get the Version, as set in AssemblyInfo.cs
private static string _version;
internal static string Version
{
    get
    {
        if (_version == null)
        {
            string name = System.Reflection.Assembly.GetExecutingAssembly().FullName;
            _version = new System.Reflection.AssemblyName(name).Version.ToString();
        }
        return _version;
    }
}
 
private string FLURRY_KEY;
 
// call this from Application_Launching and Application_Activated
private void InitFlurry()
{
    FlurryWP7SDK.Api.StartSession(FLURRY_KEY);
    string ver;
#if DEBUG
    ver = "D" + App.Version;
#elif BETA
    ver = "B" + App.Version;
#else
    ver = App.Version;
#endif
    FlurryWP7SDK.Api.SetVersion(ver);
}

LittleWatson

Flurry also has a mechanism to report crashes, so I added it to my existing LittleWatson code. I will probably disable LittleWatson-generated emails in the next update, except in beta builds as beta users sometimes add additional information (e.g. the repro) when they send
them.

Beta testing

I think it is very important to beta test with Flurry enabled, so you can be sure you are reporting the right things in the right way, and that you find the resulting data genuinely useful before you ship your app. I use a different application key for beta versions and release versions, as I have a lot less users of the former than the latter and it is easier to detect anomalies (eg spikes in asserts) in the beta version when the amount of data (and users) is small. It also means that I can easily remove the beta data when it becomes obsolete or was generated by a bug in my reporting code in the beta itself.

Opting Out

As with any app that collects data from users, I highly recommend letting the user opt-out of this data collection. Although all data collected is anonymous, it is a simple courtesy to allow customers to not send it. I have a simple checkbox in my app to do this. Sure, you lose data from those who choose to opt-out, but those same users can hardly complain if you don’t fix an issue that they didn’t even inform you about by disabling the option.

Support

The support folks at Flurry were very responsive on the only occasion I had need of them: I had a beta tester in Europe telling me the app crashed on startup after a timezone change. I could not repro this myself, so I took a look at the callstacks from the App Hub (after the requisite two-day delay) and could see that the crash was in Flurry itself, so I reported it to them. In a few weeks there was an update to the Flurry SDK to fix this issue.

Conclusion

I highly recommend adding Flurry support to your Windows Phone application if you want to know more about your users and how they use your application, so you can fix and improve it.

Note that this code requires the C# Async CTP for Phone to be installed in order to compile and run, get if from here. Once installed copy the AsyncCtpLibrary_Phone.dll to your project and add it as a Reference. Note that the recommendation is for asynchronous methods to end with the word "Async", but I chose to add an underscore in there to make it totally obvious which methods are async. Feel free to totally ignore my convention. You will also need to add a using from System.Threading.Tasks to your cs files to use it.

So here is the code from the test app:

private void buttonMedia_Click(object sender, RoutedEventArgs e)
{
    // Find all Media Servers
    string item = "urn:schemas-upnp-org:device:MediaServer:1";
 
    // Disable button while scanning
    buttonMedia.IsEnabled = false;
 
    ScanNetwork(item, (newservice) =>
        {
            if (newservice != null)
            {
                TestMediaBrowseAsync(newservice);
            }
            else
            {
                // Finished scan, so re-enable button
                buttonMedia.IsEnabled = true;
            }
        });
}
 
private void ScanNetwork(string item, Action<string> FoundCallback)
{
    UPnP.Scanner finder = new UPnP.Scanner();
 
    finder.FindDevices(item, 3, (findresult) =>
    {
        Dispatcher.BeginInvoke(() =>
        {
            if (findresult == null)
            {
                FoundCallback(null);
            }
            else
            {
                // Got a response
                var newservice = UPnP.Scanner.GetSSDPLocation(findresult);
                if (IsNewLocation(newservice))
                {
                    FoundCallback(newservice);
                }
            }
        });
    });
}
 
async void TestMediaBrowseAsync(string uri)
{
    var device = await UPnP.Device.Create_Async(uri);
    var contentdir = device.FindService("urn:upnp-org:serviceId:ContentDirectory");
    if (contentdir != null)
    {
        ContentDirectory cd = new ContentDirectory(contentdir);
        var cdresult = await cd.Browse("0", "BrowseMetadata", "*", (uint)0, (uint)1, "");
 
        Debug.WriteLine("Found device: " + device.FriendlyName);
        if (cdresult.Error == null)
        {
            Debug.WriteLine("Number={0}, Total={1}, UpdateID={2}, Result={3}\n",
                cdresult.NumberReturned,
                cdresult.TotalMatches,
                cdresult.UpdateID,
                cdresult.Result);
        }
        else
        {
            Debug.WriteLine("ERROR: {0} on BrowseMetadata call", cdresult.Error.Message);
        }
    }
}
 
private List<string> RootDevicesSoFar = new List<string>();
 
// Have we seen this before?
private bool IsNewLocation(string location)
{
    if (location == null)
        return false;
 
    if (!RootDevicesSoFar.Contains(location))
    {
        RootDevicesSoFar.Add(location);
        return true;
    }
    else
    {
        return false;
    }
}

Note that if run on the emulator it will NOT find the media server on the same machine for me, I have to run this code on an actual device to find shared media. (I can find Sonos gear just fine from the emulator). I have no explanation for this. YMMV as they say.

Now we'll jump back to the bottom of the stack: Part 1s function returned us the raw results of an SSDP discovery, so from that we need to find the http: address of the description file:

// SSDP response handler, returns location of xml file, or null
public static string GetSSDPLocation(string response)
{
    var dict = ParseSSDPResponse(response);
    if (dict != null && dict.ContainsKey("location"))
        return dict["location"];
    else
        return null;
}
 
// Probably not exactly compliant with RFC 2616 but good enough for now
private static Dictionary<string, string> ParseSSDPResponse(string response)
{
    StringReader reader = new StringReader(response);
 
    string line = reader.ReadLine();
    if (line != "HTTP/1.1 200 OK")
        return null;
 
    Dictionary<string, string> result = new Dictionary<string, string>();
 
    for (; ; )
    {
        line = reader.ReadLine();
        if (line == null)
            break;
        if (line != "")
        {
            int colon = line.IndexOf(':');
            if (colon < 1)
            {
                return null;
            }
            string name = line.Substring(0, colon).Trim();

            string value = line.Substring(colon + 1).Trim();
            if (string.IsNullOrEmpty(name))
            {
                return null;
            }
            result[name.ToLowerInvariant()] = value;
        }
    }
    return result;
}

So here is my basic Device class:

namespace UPnP
{
    public class Device
    {
        XElement Dom;
        Uri BaseUri;
        const string NS = "urn:schemas-upnp-org:device-1-0";
 
        public static async Task<Device> Create_Async(string uri)
        {
            var xml = await new WebClient().DownloadStringTaskAsync(uri);
            var dom = XElement.Parse(xml);
            if (dom.GetDefaultNamespace() != "urn:schemas-upnp-org:device-1-0")
            {
                Debug.WriteLine("Bad default namespace " + dom.GetDefaultNamespace());
                return null;
            }
 
            Device device = new Device(uri, dom);
            return device;
        }
 
        private Device(string uri, XElement dom)
        {
            this.Dom = dom;
            this.BaseUri = new Uri(uri, UriKind.Absolute);
        }
 
        public string FriendlyName
        {
            get
            {
                return (string)Dom.Descendants(XName.Get("friendlyName", NS)).FirstOrDefault();
            }
        }
 
        public string FindService(string urn)
        {
            var service = from item in Dom.Descendants(XName.Get("service", NS))
                          where (string)item.Element(XName.Get("serviceId", NS)) == urn
                          select new
                          {
                              ServiceType = (string)item.Element(XName.Get("serviceType", NS)),
                              ServiceId = (string)item.Element(XName.Get("serviceId", NS)),
                              SCP = (string)item.Element(XName.Get("SCPDURL", NS)),
                              ControlURL = (string)item.Element(XName.Get("controlURL", NS))
                          };
 
            // The ControlURL is relative to the base uri
            return service != null ? BaseUri.GetComponents(UriComponents.SchemeAndServer, UriFormat.Unescaped) + service.First().ControlURL : null;
        }
 
    }
 
}

The Create_Async method is the only public way to make a device: pass it a uri that points to the device's description xml file, and it will load it into an XML document then return a new Device object to the caller. The FindService method can then be used to get a specific service from the device. There isn't much else to this class except a helper property to get the FriendlyName of the device. (Please excuse my LINQ: it is probably not remotely the best way of doing this, but my LINQ level is such that if it gets any results, its good enough for me).

Next is to get a Service object from the uri that the Device returns to invoke Actions upon it. I modelled this behavior on the way WCF does this, with the idea that some automated tool runs against the service's xml file and generates helper classes for each action (and the necessary types). However I don't have such a tool ready yet, so I hand-rolled a couple of actions, and coded them such that an automated tool should have no problem generating them. UPNP Actions have input args and output args, so I chose to return the output args in a strongly-typed struct for each action, along with any error information, just like WCF. So here is the Service code, which won't necessarily make sense until you see the sample action later on:

namespace UPnP
{
    public class Service
    {
        private string Address;
        private string ServiceType;
 
        // Every Action needs to have an instance of this information, which encapsulates all the data
        // necessary to make a call
        public struct ActionInfo
        {
            public string name;
            public string[] argnames;
            public int outargs;
        };
 
        // Every Action that has any OUT arguments needs to have a type inherited from this one, containing
        // each OUT argument as a member
        public class ActionResult
        {
            public Exception Error;             // Stores last error returned
 
            // Override this to convert an array of strings into the desired type
            public virtual void Fill(string[] rawdata)
            {
                Debug.Assert(rawdata.Length == 0);      // will fire if failed to override for non-empty results
            }
 
 
            // Helper methods
            //
            protected bool ParseBool(string item)
            {
                return item == "1";
            }
        };
 
        protected Service(string uri, string type)
        {
            this.Address = uri;
            this.ServiceType = type;
        }
 
        public async Task<ActionResult> Action_Async(ActionInfo actionInfo, object[] args, ActionResult actionResult)
        {
            actionResult.Error = null;
 
            try
            {
                StringBuilder soap = new StringBuilder("<u:" + actionInfo.name + " xmlns:u=\"" + ServiceType + "\">");
                int currentarg = 0;
 
                if (args != null)
                {
                    foreach (var arg in args)
                    {
                        soap.AppendFormat("<{0}>{1}</{0}>", actionInfo.argnames[currentarg++], FormatArg(arg));
                    }
                }
                soap.AppendFormat("</u:{0}>", actionInfo.name);
 
                var result = await SOAPRequest_Async(new Uri(Address), soap.ToString(), actionInfo.name);
 
                // TODO handle errors from services here
 
                if (actionInfo.outargs != 0)
                {
                    // Children of u:<VERB>Response are the result we want
                    XName xn = XName.Get(actionInfo.name + "Response", ServiceType);
 
                    var items = from item in result.Descendants(xn).Descendants()
                                select (string)item.Value;
 
                    // Check that we have at least the expected number of results
                    if (items.Count() < actionInfo.outargs)
                        throw new ArgumentException();
 
                    actionResult.Fill(items.ToArray());
                }
            }
            catch (Exception ex)
            {
                actionResult.Error = ex;
            }
 
            return actionResult;
        }
 
        private async Task<XElement> SOAPRequest_Async(Uri target, string soap, string action)
        {
            string req = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
            "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">" +
            "<s:Body>" +
            soap +
            "</s:Body>" +
            "</s:Envelope>";
            HttpWebRequest r = (HttpWebRequest)HttpWebRequest.Create(target);
 
            // We only ever need to do this over non-cellular networks
            r.SetNetworkPreference(NetworkSelectionCharacteristics.NonCellular);
            r.Method = "POST";
            byte[] b = Encoding.UTF8.GetBytes(req);
            r.Headers["SOAPACTION"] = "\"" + ServiceType + "#" + action + "\"";
            r.ContentType = "text/xml; charset=\"utf-8\"";
            var stream = await r.GetRequestStreamAsync();
            stream.Write(b, 0, b.Length);
            stream.Close();                 // else will get "Not Supported"
 
            WebResponse resp;
            try
            {
                resp = await r.GetResponseAsync();
            }
            catch (System.Net.WebException ex)
            {
                throw ConvertException(ex);
            }
 
            var st = resp.GetResponseStream();
            st.Seek(0, SeekOrigin.Begin);
            return XElement.Load(st);
        }
 
        public class UPnPException : Exception
        {
            public int ErrorCode
            {
                get;
                private set;
            }
 
            public override string Message
            {
                get
                {
                    return "UPnP Error " + ErrorCode.ToString();
                }
            }
            internal UPnPException(int error)
            {
                ErrorCode = error;
            }
        }
 
        // If an exception is really a UPNP error, convert it
        private Exception ConvertException(WebException ex)
        {
            WebResponse resp = ex.Response;
            string error = ex.Message;
 
            if (resp != null)
            {
                using (Stream respstream = resp.GetResponseStream())
                {
                    respstream.Seek(0, SeekOrigin.Begin);
                    TextReader reader = new StreamReader(respstream, Encoding.UTF8);
                    error = reader.ReadToEnd();
                    // This can be a UPnP error
                    // TODO actually parse the XML
                    int errstart = error.IndexOf("<errorCode>");
                    int errend = error.IndexOf("</errorCode>");
                    if ((errstart != -1) && (errend != -1))
                    {
                        error = "UPnP ERROR:" + error.Substring(errstart + 11, errend - errstart - 11);
                        return new UPnPException(int.Parse(error.Substring(errstart + 11, errend - errstart - 11)));
                    }
                }
            }
            return ex;
        }
 
        private string FormatArg(object obj)
        {
            string result;
 
            if (obj == null)
                result = "";
            else if (obj is string)
                result = UPnP.Utility.XmlEscape(obj.ToString());
            else if (obj is bool)
                result = (bool)(obj) ? "1" : "0";
            else
                result = Convert.ChangeType(obj, obj.GetType(), CultureInfo.InvariantCulture).ToString();
 
            return result;
        }
 
    }
 
}

So now for the first Action, which is the Browse method on the ContentDirectory service, which you can read all about in the UPnP spec. It has six input args and four output args:

    public class ContentDirectory : UPnP.Service
    {
        public ContentDirectory(string uri)
            : base(uri, "urn:schemas-upnp-org:service:ContentDirectory:1")
        {
        }
 
        private static UPnP.Service.ActionInfo Browse_Info = new UPnP.Service.ActionInfo()
        {
            name = "Browse",
            argnames = new string[] { "ObjectID", "BrowseFlag", "Filter", "StartingIndex", "RequestedCount", "SortCriteria" },
            outargs = 4,
        };
        public class Browse_Result : UPnP.Service.ActionResult
        {
            public string Result;
            public uint NumberReturned;
            public uint TotalMatches;
            public uint UpdateID;
 
            public override void Fill(string[] rawdata)
            {
                Result = rawdata[0];
                NumberReturned = uint.Parse(rawdata[1]);
                TotalMatches = uint.Parse(rawdata[2]);
                UpdateID = uint.Parse(rawdata[3]);
            }
        }
        public async Task<Browse_Result> Browse(string ObjectID, string BrowseFlag, string Filter, uint StartingIndex, uint RequestedCount, string SortCriteria)
        {
            return await base.Action_Async(Browse_Info, new object[] { ObjectID, BrowseFlag, Filter, StartingIndex, RequestedCount, SortCriteria }, new Browse_Result()) as Browse_Result;
        }
    }
}

The Browse method bundles up the input args into an array of objects and passes them to the base class. The result is packaged into a Browse_Result class containing the output arguments, all with the same names as declared in the service's xml. To round this off here is a little utility method used by the soap encoder:

namespace UPnP
{
    public class Utility
    {
        // Emulate http://msdn.microsoft.com/en-us/library/system.security.securityelement.escape.aspx
        // SecurityElement.Escape
        public static string XmlEscape(string input)
        {
            return input.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;").Replace("\"", "&quot;").Replace("\'", "&apos;");
        }
    }
}

There's quite a lot of code here, following user request all the source and a simple sample are on Codeplex now.

The beta submission process today looks like this:

• Submit your app in the App Hub as a beta app
• At some random point in time (1-8 hours in my experience) you receive an email from Windows Phone Marketplace claiming it is available to your beta testers, including a zune: link
• You try the zune: link and it says “sorry this item is no longer available in this marketplace” and you curse
• At some other random point in time (2-24 hours in my experience) the link will start working
• You send email to your beta testers for them to beat on your app

What follows is a simple PC tool I wrote that at least will tell me when the download is available. There isn’t much I can do about the delay in getting the email, but once the email arrives I copy the appid out of the link (the appid is the guid portion), paste it into this fugly WinForms app, and click Wait.

I won’t insult you (or embarrass myself) by showing you the WinForms code, but here is the crucial part:

private void button1_Click(object sender, EventArgs e)
{
    Guid appid;
    string guid = textBox1.Text;
    if (!Guid.TryParse(guid, out appid))
    {
        MessageBox.Show("Not a valid guid");
    }
    else
    {
        string uri = "http://catalog.zune.net/v3.3/en-us/apps/" + guid + "?store=Zest&clientType=WinMobile+7.1";
        this.Text = "Waiting now...";
 
        for (; ; )
        {
            try
            {
                string result = new WebClient().DownloadString(uri);
                Debug.WriteLine("Download found at " + DateTime.Now.ToString());
                break;
            }
            catch (Exception ex)
            {
            }
            // Wait for 10 minutes
            System.Threading.Thread.Sleep(10 * 60 * 1000);
        }
 
        this.Text = "Found it!";
    }
}

Of course you could extend this idea to emit a loud beeping sound, or send yourself or your beta testers an email, or even turn it into a Phone app with a background agent and Live Tile notification. (If you do the latter, be sure to send me a beta!).

7.0 Apps

I only do Mango apps myself these days: if you are still creating 7.0 apps, change the url to use 3.2 and 7.0 instead of 3.3 and 7.1.

Detecting Non Beta Apps

This same idea can also be used to detect when an update to a non-beta app is available, but it requires a little more work: you will need to parse the string returned from DownloadString for the current version, and trigger your alarm only when it has changed. This is left as an exercise for the reader.

In an ideal world the App hub would publish beta apps in minutes from submission, but until it does I hope this tool proves useful.

Earlier in the year I picked up a 2006 Cayenne and for audio and navigation it came with PCM (Porsche Communication Management System). This is an over-priced, deeply underperforming piece of equipment. I shall save my large list of rants about it for another day, suffice to say it was a $4k or so option when new and offered no Bluetooth and no auxiliary audio inputs, to name but two critical missing features. This steaming pile of technology was fitted to Porsches from 2004 to 2009 and I can only hope that whoever was responsible for it is no longer with the company (or Harman/Becker who were the offending OEM). I suffered with it for many months, using a Zune RF car kit as the only way to get music into it, and by breaking the law using my phone directly on occasion. Finally with the release of Mango I knew that the expanded Bluetooth features of the phone should combine with a good head unit to solve all of my audio woes, and more, so I went shopping.

It became obvious very quickly that Apple totally owns the in-car audio experience right now: every head unit has as a built-in or optional feature of iPhone/iPod support. The power of that big proprietary connecter is huge, and that combined with the massive worldwide presence of the devices has resulted in excellent support.  How can a Mango phone possibly complete, with a lowly micro-usb jack and a tiny percentage of Apple’s market share? Without any wires, that is how, via the Bluetooth standard, as you will see.

Andy's Bluetooth Tests

Here are the Bluetooth tests that I performed and that I recommend you perform in choosing your next head unit (or new vehicle for that matter) if these things are similarly important to you:

• First off pair your phone with the head unit under test. Get someone to call you, and verify the audio is routed over the speakers, and you can reply. This I call the Voice Test, and requires the most basic BT support from a head unit.
• Next play the radio on the unit, and get someone who is in your Contact list to send you a text message. This should cause the radio to mute, and then the phone should announce via the car speaker something like “Message from Chris”. You can reply “Read it” and the message is read. You can also reply to text messages by speaking. This I call the Text Test, and for me is the single most important BT test, and one of my most favorite Mango features.
• I remain a Zune fan (go here for the installation of same into my Boxster) but of course I can fit a bunch of tunes on my phone too. At minimum I needed a head unit with an analog audio input (so I could connect via the phone’s headphone jack), but a stretch goal for this plan was to play music from my phone wirelessly, over Bluetooth. This I call the Music Test.
• When music is being streamed from your phone for the Music Test, it is obviously useful to be able to Pause, Next Track etc, in my case from the steering wheel controls. I call this the Control Test.
• When you use an Apple device and cable it to one of these head units you are able to see what is being played (the artist name, track etc). This is possible with Bluetooth too, and I call this the Metadata Test.

Now to get a bit technical: each feature used in my Tests require one or more Bluetooth profiles, and different head units support different profiles (and different versions of those profiles). I do not pretend to be an expert in this, but to handle my tests above a head unit must support the following protocols:

• Voice Test: HFP (Hands Free Profile)
• Text Test: Unknown profile
• Music Test: A2DP (Advanced Audio Distribution Profile)
• Control Test: AVRCP 1.3 (Audio/Video Remote Control Profile)
• Metadata Test: AVRCP 1.3

Note that there are other Bluetooth features that I don’t care about so did not test, such as phone book download (which uses the OPP Profile). Also missing is making a phone call, I very seldom do that from the car, but if that is important to you then I urge you to test it before you buy.

Some things can be immediately determined from a spec sheet, for example if the unit does not support A2DP then obviously it cannot pass the Music Test  and the Control and Metadata tests are irrelevant. The hardest one to determine is the Text Test: it isn’t clear which profile(s) it requires and it is the hardest test to pass (as you’ll see in my results later). Reading the specification sheets for a given head unit will tell you little about how well it will work with a Mango phone, you have to either try it yourself, or find someone who has already tried it. A list of head units that failed my tests can be found later, but to skip to the chase I highly recommend three JVC units.

Decision Time: JVC

So after trying out several options, I ended up with the JVC KW-NT50HDT which is a double-DIN touch screen LCD screen system with navigation. The KW-NT30HDT is probably a fiscally more sensible choice: the only difference is lifetime traffic data (which it gets from the HD radio data stream), and so far at least in the Seattle area this has not proved to be as useful as the DOT bitmap which has earned a shortcut on the home screen of my phone. This was connected to the existing amplifier and speaker system, as well as the steering wheel controls, and this is no mean feat. One of the many annoying features of the PCM system is that it is entirely digital using fiber optics to communicate between devices: this makes it overly difficult to get any kind of analog signal into or out of the system. Fortunately it is not impossible, if you go to an installer who knows what they are doing. It’s not cheap though.

I must say I am very happy with the JVC+Mango experience. First of course I get my favorite music and playlists onto my phone via the desktop Zone software, then start playing something on the phone and pause it. After I start the car it takes a few seconds for the Bluetooth to pair, then I can select BT Audio then Play, and that is it: wireless high quality music. The JVC displays all of the metadata (except the album art which is a limitation of AVRCP) and I can use my steering wheel buttons to navigate tracks. It even displays the state of my phone’s battery, which is handy as streaming audio is going to put some additional load on it for sure. When I turn the ignition off the phone automatically pauses my music, until I return the next day when it will resume where it left off. Just like the Zune in my Boxster, but wirelessly. Bliss:

There are other features of the JVC not directly related to Mango that I also appreciate, such as a USB port on the front which can charge your phone or take a memory stick full of music, and it shows all metadata including album art in this case. It also has a rear AV input which I use for my Zune, an input for backup camera that I had installed at the same time, and a very nice navigation system from Navteq. All of this is fast and easy to use, i.e. it bears no similarity to the PCM system it replaced: I had to get the instructions out just to use the radio on the PCM.

Life is not entirely perfect in Mango-land for Bluetooth though and there remain a few gaps. For example while the built-in media player works very well over Bluetooth, third-party applications that use a BackgroundAudioAgent do not work so smoothly. (You can tell which apps these are as you can control Play/Pause/Next/Prev with the lock screen down using the Universal Volume Control or UVC). The UVC is not really connected to Bluetooth, so while you can sometimes Pause/Play those apps from the head unit (and steering wheel) you cannot change tracks. You also get no metadata at all sent to the head unit. For tethered Apple hardware the JVC supports iheartradio and many other units support Pandora by building it into the head unit itself, which is clearly not a sustainable model even for Apple, so Microsoft has an opportunity to improve the support for arbitrary 3rd party applications over Bluetooth here:

Although I installed my Zune myself in the Boxster, I was not about to attempt to install this lot into the Cayenne, so I went to Benchmark Motoring for it. I highly recommend them, speak to Justin if you pay them a visit. For reference all my testing was done on a Dell Venue Pro, which had a deservedly poor Bluetooth reputation before the BSP update that Dell shipped around the NoDo timeframe. Since that update mine has been rock solid.

A final note about Zune: sadly SoundGate products are no more, so connecting a Zune to a head unit via a quality connection is even more of a challenge. Fortunately I did score one of the last ZNCBLPAK kits on the planet and had it installed along with everything else. Although my Zune for music is more or less obsolete now in the Cayenne, it can do video through the JVC which might keep the kids occupied for a while on occasion.

Known Andy-Compatible Units

• JVC KW-NT50HDT
• JVC KW-NT30HD
• JVC KD-A925BT

Known Andy-Incompatible Units

• Alpine INA-W900BT: Voice Test passed. Text Test failed, no A2DP support so all other tests N/A
• Kenwood DNX9980HD: Voice Test passed. Text Test failed, except while running the Music Test! (which passed)
• Kenwood KIV-BT900: Voice Test passed, Text Test failed. Can directly control a wired Zune though!
• Dension Gateway 500: Every test fails (even Voice!) except Music.

A Comment about Comments

Please don’t post comments asking me if device XYZ is compatible: everything I know about compatibility is listed here. On the other hand if you have tried Mango on some other hardware and can share your test results in a comment that would be much appreciated.