Windows Mobile 7

At work the concensus amongst the developers at Caplin seems to be that they like Android as a platform and there’s quite a bit of excitement about the Google Nexus One which will contain the Android 2.1 operating system.

Nexus Google One Phone

Since I’ve been involved in most of the Microsoft product development here I’m interested to see if there is any chance of Windows Mobile doing anything. I’m excited about the inclusion of Silverlight in Windows Mobile 7, as I blogged about some time back, and have just read a small piece that indicates Microsoft are keen to take gaming mobile with XBox 360 integration.

A while back, just after we’d ported StreamLink.NET to the Silverlight runtime, I took an R&D day to try to port StreamLink.NET to Windows Mobile. I made good progress but left things in a non-compiling state. More recently I had another opportunity to take a day to try and finish the work off. The codebase had moved slightly so I had to do a little more work that I’d planned and now I’m left with a single compilation error based around the .NET Compact Framework not having the WaitHandle.WaitAny method. To resolve this I’m going to have to go native or we may have to consider purchasing the fantastic Smart Device Framework.

If Windows Mobile 7 supports Silverlight then maybe you could argue that my time spent porting StreamLink.NET to Windows Mobile has been wasted? Or, maybe you would argue that any time spent developing for the Windows Mobile platform is a waste of time? Personally, I like Windows Mobile as a platform, I have a Windows Mobile phone and I think the Windows Mobile development experience in Visual Studio is second to none. For these reasons, and because competition can lead to improved products, I hope Windows Mobile 7 makes a challenge in the final furlongs of the mobile platform race.

We found this interesting as we as a company have entered the world of Flex. Our product is a Flex library API, which is part of our Caplin Xaqua offering, whereas the session discussed creating a Flex GUI application. It was good to see that there are a number of powerful Flex application frameworks and that they could easily be leveraged to use our library. The talk covered frameworks, modularisation techniques and tools that have been used by Lab49 in the various Flex projects they have been involved in.

Borre Wessell of Lab49, who gave the talk, also covered their agile development process, which sounds fairly similar to ours even though they do more consultancy and we do a mix of consultancy and product work.

It was also interesting that Borre recommended using Flash Builder 4 beta as we also found that was better with its integrated unit testing and other productivity enhancements. Tool support does seem a bit lacking in some areas for Flex – whilst there is a memory profiler as part of Flash Builder 4 the performance testing seems to be very much a manual process. We prefer to have performance tests as part of our automated processes so you can catch any regressions as early as possible.

Next week I will post my followup to my previous post about streaming technologies, which will touch on the LCDS approach compared to Caplin’s methods.

The goal of Silverlight is to provide a consistent experience across desktop and mobile phones. Developers will be able to easily optimize Silverlight applications for mobile form factors or run existing Silverlight applications on mobile phones.

The great thing about this release is that any existing Silverlight applications should work on any mobile device with Silverlight installed. The question about this is that if you design a user interface for a desktop browser how will it fit on a windows mobile browser? Well, Microsoft plan to give developers the ability to “optimize Silverlight applications for mobile form factors” which sounds like they will give us a way of dealing with the obvious UI differences between desktop and mobile platforms, as well as the underlying runtime issues.

We’ve already blogged about what impact Silverlight may have on single dealer portals. I’m really excited to see what developers can do using StreamLink for Silverlight to enable the real-time web on a windows mobile device. What opportunities might Streamlink for Silverlight Mobile enable?

Silverlight for Mobile

Read the Silverlight for Mobile FAQ for more information.

The RTD interface is small (6 methods) and Kenny Kerr has a great series of articles about RTD on his blog so I won’t repeat that information here and instead concentrate on integration to StreamLink.NET and pulling in real time data from a Caplin platform deployment.

The following walkthrough is a short example of how to do this, there’s no error checking, logging and certainly the example is nowhere near production quality, however it does demonstrate that linking up Excel and data from the Liberator is straightforward.

ServerStart is the entry point and in here we can instantiate StreamLink.NET and setup a map between the RTD topic ids and the Subject/Field information.

    public int ServerStart(IRTDUpdateEvent callback)
    {
        sl = new StreamLinkInterop();
        m_callback = callback;
        m_timer = new Timer();
        m_timer.Tick += new EventHandler(TimerEventHandler);
        m_timer.Interval = 1000;
        m_topics = new Dictionary<int, KeyValuePair<string,string>>();
        return 1;
    }

The ConnectData method validates the arguments passed through and then attempts to subscribe to the data:

public object ConnectData(int topicId,
                              ref Array strings,
                              ref bool newValues)
    {
        if (2 != strings.Length)
        {
            return "Subject and field is required";
        }

        string subject = strings.GetValue(0).ToString();
        string field = strings.GetValue(1).ToString();

        m_topics[topicId] = new KeyValuePair(subject, field);
        m_timer.Start();
        sl.Subscribe(subject, field);
        return "NO_DATA_YET";
    }

And DisconnectData will unsubscribe:

    public void DisconnectData(int topicId)
    {
        KeyValuePair pair = m_topics[topicId];

        sl.Unsubscribe(pair.Key, pair.Value);
        m_topics.Remove(topicId);
    }

RefreshData will retrieve the current image for the subscribed data:

    public Array RefreshData(ref int topicCount)
    {
        object[,] data = new object[2, m_topics.Count];

        int index = 0;

        foreach (int topicId in m_topics.Keys)
        {
            data[0, index] = topicId;
            KeyValuePair pair = m_topics[topicId];
            data[1, index] = sl.GetData(pair.Key, pair.Value);

            ++index;
        }

        topicCount = m_topics.Count;

        m_timer.Start();
        return data;
    }

Because Excel polls for the data we’ve got to have a cache within our RTD server so that data is available when Excel calls in, for the purposes of this exercise we’re only considering Record data without market depth or history so our cache can be really simple:

    public class RecordType1Cache
    {
        Dictionary fieldMap = new Dictionary();

        public RecordType1Cache()
        {
        }

        public void Update(IRecordEvent evt)
        {
            foreach ( IField field in evt.Fields.Values )
            {
                fieldMap[field.Name] = field.Value;
            }
        }

        public string GetFieldValue(string fieldName)
        {
            if (fieldMap.ContainsKey(fieldName))
            {
                return fieldMap[fieldName];
            }
            return "NO_FIELD_AVAILABLE";
        }
    }

The only missing part is the StreamLinkInterop class which integrates with StreamLink, this needs to implement the public methods we saw earlier: Subscribe, Unsubscribe and GetData as well as the IRecordSubscriptionListener interface from StreamLink.NET since we want to receive record updates. When an update is received we put it into our cache and return immediately.

There’s a couple of maps which allows finding the RecordType1Cache object from both the StreamLink side (using the IRecordSubscription as the key) and from the RTD side (using a subscription name as the key).

The connection to the server is setup in the constructor for code simplification purposes. The servername is hard coded so you’ll probably need to change it or find a way to configure it if you use this code as a base for your own project.

    public class StreamLinkInterop : IRecordSubscriptionListener
   {
        StreamLink myStreamLink;
        Dictionary cache = new Dictionary();
        Dictionary subscriptionLookup = new Dictionary();

        public StreamLinkInterop()
        {
            IStreamLinkConfiguration config = SimpleConfiguration.CreateType2Connection("liberator", 8080);
            myStreamLink = new StreamLink(config);
            myStreamLink.CredentialsProvider = new PasswordCredentialsProvider("admin", "admin");
            myStreamLink.StreamLinkProvider.Connect();
        }

        public void Terminate()
        {
            myStreamLink.StreamLinkProvider.Disconnect();
        }

        public void Subscribe(string subject, string field)
        {
            string name = subject + ";" + field;

            IRecordSubscriptionParameters rparams = myStreamLink.StreamLinkProvider.ParametersFactory.CreateRecordSubscriptionParameters(new string[] { field } );
            ISubscription sub = myStreamLink.StreamLinkProvider.CreateRecordSubscription(this, subject , rparams);

            cache[sub] = new RecordType1Cache();
            subscriptionLookup[name] = sub;
            sub.Subscribe();
        }

        public void Unsubscribe(string subject, string field)
        {
            string name = subject + ";" + field;

            if (subscriptionLookup.ContainsKey(name))
            {
                ISubscription sub = subscriptionLookup[name];
                sub.Unsubscribe();
                cache.Remove(sub);
                subscriptionLookup.Remove(name);
            }
        }
       public string GetData(string subject, string field)
        {
            string name = subject + ";" + field;
            if (subscriptionLookup.ContainsKey(name))
            {
                ISubscription sub = subscriptionLookup[name];
                return cache[sub].GetFieldValue(field);
            }
            return "UNKNOWN+SUBJECT";
        }

        #region IRecordSubscriptionListener Members

        public void RecordType2Updated(Caplin.StreamLink.Subscription.ISubscription subscription, IRecordType2Event ev)
        {
        }

        public void RecordType3Updated(Caplin.StreamLink.Subscription.ISubscription subscription, IRecordType3Event ev)
        {
        }

        public void RecordUpdated(Caplin.StreamLink.Subscription.ISubscription subscription, IRecordEvent ev)
        {
            if (cache.ContainsKey(subscription))
            {
                cache[subscription].Update(ev);
            }
        }

        #endregion

        #region ISubscriptionListener Members

        public void SubscriptionErrorReceived(Caplin.StreamLink.Subscription.ISubscription subscription, Caplin.StreamLink.Subscription.ISubscriptionErrorEvent ev)
        {
        }

        public void SubscriptionStatusUpdated(Caplin.StreamLink.Subscription.ISubscription subscription, Caplin.StreamLink.Subscription.ISubscriptionStatusEvent ev)
        {
        }

        #endregion
    }

To pull data into excel into excel use a formula along the following lines: =RTD("com.caplin.excel",,"/I/MSFT.O", "BID"). The data in the cell will update periodically (by default every 2000ms). This period can be changed using either a registry setting or using VBA, details can be found at MSDN.