justinangel.net Blog Feed.

Pre-beta Windows 8.1 WinRT Developer APIs

Hi folks,

In this article we’ll review new developer WinRT features that’ll be released in the upcoming Windows 8 release (dubbed “Windows 8.1” / “Windows Blue”). Microsoft recently announced that during June 2013’s BUILD conference a developer preview of Windows 8.1 will be released for download. In the meanwhile many Windows 8.1 “leaked” images are available online. These “leaked” images allows us to get a sneak preview of the featuresets that’ll be announced in BUILD conference. For the length of this article we’ll go over those features.

Methodology: How was this research done?

Windows 8.1 images contain WinMD files describing their embedded Windows 8.1 developers APIs. It’s possible to get to Win8.1’s WinMD files and then compare them to the existing Windows 8 RTM WinMD files. This entire article is based upon using Reflection to see those API differences.

Download the latest Windows 8.1 “leaked” image. This article was based on an image named “9385.0.FBL_PARTNER_OUT17.130415-2049_X86FRE_CLIENT_EN-US-PL-PL-RU-RU.ISO”.
Create a bootable USB drive from the ISO file and Install it on a nearby machine.
Win8.1’s WinMD files can be found under the following directory: C:\Windows\System32\WinMetadata
Using Microsoft’s Framework Design Studio it’s then possible to compare the WinMD files from a WIndows 8.1 “leaked” image and Windows 8 RTM.

For your easy reference you can download the aforementioned WinMD folder from here: Windows 8 RTM WinMDs, Windows 8.1 9385 WinMDs.

The resulting comparison between Windows 8 and Windows 8.1 API can be downloaded from @ http://justinangel.net/storage/windows81/WinMDDelta.zip

Bluetooth 4.0 RfComm and GATT support
Point of sale: Barcode scanners and Magnetic card readers
Smart Cards
Lock screen Image Apps
VPN support for Metro apps
Scanner APIs and apps
Support for any External / USB device
Native PDF rendering in apps
Multiple screens projection support in apps
XAML/WinJS: New resolution scaling support / Super-high resolution tablets
Camera: Low-lag cameras / HDR
New Metro App Types: Appointments, LockScreen, Contacts and GeoLoc
New App Type: GeoFenced activation
New App Type: Lock screen call
New App Type: Appointments Provider
Text-to-speech
Read-write access to Camera roll, Saved pictures and playlists
XAML/WinJS: new SearchBox control
XAML/WinJS: Hubs for SemanticZoom
XAML: DatePicker and TimePicker
XAML: Flyout, MenuFlyout and SettingsMenuFlyout
XAML: AppBar simplification
XAML: DataBinding Improvements
Globalization: Currencies, Numeral systems and Numerical formatters
Other minor but important Win8.1 features
How to code Win8.1 C# apps before public beta?
How to develop Win8.1 WinJS apps before public beta?
Disclaimer: Please don’t sue me

Jump back to table of contents

Bluetooth 4.0 RfComm and GATT support

Windows 8 had no support for developers to interact with external bluetooth-enabled devices. PeerFinder was there but it wasn’t bluetooth capable. It’s a pleasant surprise to see Windows 8.1 support both RfComm bluetooth protocol and GATT bluetooth profile which are the core of Bluetooth 4.0 support.

RfComm is an underlying protocol used for communicating between two bluetooth enabled devices. RfComm is comparable to TCP in that TCP communicates between two WLAN enabled devices and RfComm is communicates between two bluetooth capable devices. RfComm can be used with the majority of bluetooth devices even if those don’t expose their own developer APIs and services. As we can see from these new Windows 8.1 types RfComm is fully supported:

In addition to RfComm Win8.1 will also have comprehensive GATT support. GATT is a core component of supporting the latest generation Bluetooth Low Energy devices. Using GATT Win8.1 can support a multitude of long-running low-power devices such as: Heart rate monitors, thermometers, glucose readers, pedometers, running speed monitors, proximity sensors and general notification devices. As we can see from the following classes there’s ample support for GATT in Windows 8.1:

With Bluetooth 4.0 support in Windows 8.1 we’ll see a many external bluetooth-enabled devices connect to WinRT. The aforementioned GattCharacteristicUuids class mentions a lot of those supported devices.

Jump back to table of contents

Point of sale: Barcode scanners and Magnetic card readers

It was previously revealed that Windows 8.1 will support Kiosk mode. Windows 8.1 has new APIs for Magnetic card readers and barcode scanners. So it’s pretty clear to say Microsoft is aiming for a new class of WinRT cash register apps (“Point of Sale”).

In the following class diagram we can see the new Win8.1 barcode scanner support. It all comes down to the ClaimedBarcodeScanner.DataRecieved event which will provide a byte[] array with the barcode data.

There’s also a BarcodeSymbologies class partially shown above that claims the API supports the following barcode systems: AusPostal, Aztec, Bookland, CanPostal, Cca, Ccb, Ccc, Chinese2of5, Codabar, Code11, Code128, Code128Parsed, Code32, Code39, Code93, CompositeAB, CompositeC, Coupon, CueCode, DataMatrix, Doccap, DutchPostal, Ean128, Ean13S, Ean8S, EanJan13, EanJan8, ExtendedBase, GS1DataBar, GS1DataBarExpanded, GS1DataBarExpandedStacked, GS1DataBarStackedOmnidirectional, Iata2of5, Image, Isbt128, Itf, JapPostal, Korean3of5, Macromicropdf, Macropdf, Matrix2of5, Maxicode, Micropdf, MicroPdf417, MicroQRCode, Msi, Ocra, Ocrb, Pdf417, QRCode, Rss14, Rssexp, Rsslim, Signature, TF, Tlc39, Trioptic39, UkPostal, Unknown, Upca, Upcas, Upcd1, Upcd2, Upcd3, Upcd4, Upcd5, Upce, Upce0, Upce1, Upces, Us4state, US4statefics, UsPlanet, UsPostNet and Webcode.

There’s also a new API for magnetic card readers which we can see below. There’s lots of goodies in this API. Starting from generic Magnetic card reader support with direct access to reading Track1-4 data. There’s also Encryption support for Triple DES blocks. And there’s even built-in support to bank cards and AAMVA vehicle driver data. Overall it seems like a great magnetic card reader API that’ll support everything from store cards, bank cards, AAMVA cards and any custom 3rd party magnetic cards.

Jump back to table of contents

Smart Cards

One of the interesting new security minded features in the Win8.1 APIs is the support for Smart Cards and pin challenges. For those who are unaware “Smart cards” is a generic name for cards with integrated circuits that help uniquely identify cards. Some well known smart cards include credit cards, debit cards, employee cards, public transit payment cards and more.

The new Smart Card API in Windows 8.1 allows us to iterate over plugged-in smart cards, challenge the user for pin card authorization, reset challenge pins and even to create or destroy cards. As anyone with a bank card knows challenging users for pin codes is quite useful in real-world scenarios.

It’s really interesting to see that the Win81 APIs allow for both day-to-day usage of smart cards and managing smart cards.

Jump back to table of contents

Lock screen Image Apps

It’s been previously reveled that Windows 8.1 apps can now set the lockscreen background image.

Windows 8.1 apps can set the lock screen image to a remote feed. While the format of the remote feed is currently unknown (RSS? Media RSS?) it’s likely to be fairly simple to implement. The beautiful part about setting the lock screen to a remote feed is that changing the picture doesn’t require running the app or any custom code on the client side.

namespace Windows.System.UserProfile 
{
    public static class LockScreen 
    {
        public static IAsyncOperation RequestSetImageFeedAsync(void syndicationFeedUri);
        public static Boolean TryRemoveImageFeed();
    }

    public enum SetImageFeedResult 
    {
        Success,
        ChangeDisabled,
        UserCanceled
    }
}

Jump back to table of contents

VPN support for Metro apps

A very common complaint for Windows 8 Metro apps is that they sometimes stop working under most VPN connections. VPNs are critical for many people including Iranian employees and remote dissidents (or is it “Iranian dissidents and remote employees”?).

It’s great to see Microsoft adding a whole new Windows.Networking.vpn namespace to help deal with VPNs in WinRT apps. The new VPN API featureset is fundamentally about sending encrypted packets. It also supports VPN routing (what goes in the VPN connection and what doesn’t), multiple VPN authentication methods (username, password, pin, smart card, credentials and more) and support for VPN namespaces. I

Despite the plethora of new VPN APIs, an open question remains as to whether WinRT Win8.1 apps will work by default on VPNs.

Jump back to table of contents

Scanner APIs and apps

Windows 8 introduced a new type of Metro apps that are associated with printers. Those apps can be used to define a custom printing configuration within the Windows 8 “devices” charm. However, scanners were conspicuously unsupported and didn’t have that level of support. Scanners weren’t usable in Metro apps and the scanner manufacturers couldn’t hook into the Win8 “devices” charm. Well, that’s going to change in Win8.1.

Using the new Windows.Devices.Scanners namespace apps can automate scanning and customizing documents from flatbed & feeder scanners. Developers can see current scanner configuration, set a few properties (auto cropping, color mode, contrast, resolution, etc) and get image files after scanning.

An open question is whether or not Scanner OEM apps written by device manufacturers will be supported in Windows 8.1. Looking at the impressive API above, I’d be surprised if they won’t be supported.

Jump back to table of contents

Support for any IO and USB device

One of the big limitations of Win8 WinRT apps is their lack of ability to interact with connected and built-in devices unless previously exposed by WinRT. It seems that’s about to change in Windows 8.1 with the introduction of the new Windows.Devices.Usb and Windows.Devices.Custom namespaces. Both of these namespace provide IOutputStream and IInputStream to any USB or IO device. It’s fair to assume it’ll be heavily gated by permissions, but it’s still a great feature that opens up new avenues for Win8.1 apps.

Below we can see the new Windows.Devices.Custom namespace with the Input & Output streams highlighted. The code to use this API would be fairly straightforward. First we’d get a DeviceID or Device selector string from existing Win8 APIs, next we’d get a CustomDevice instance and finally we’ll send over IOControlCodes the device will recognize.

Another new API that is more USB specific was introduced is the Windows.Devices.Usb namespace. Below you can see the types of USB devices supported, and where the Output and Input streams can be found.

The new USB namespace is quite verbose so I’ve highlighted only what I felt is the most self explanatory API.

Jump back to table of contents

Native PDF rendering in apps

Windows 8 developers hoping to author an alternative PDF viewer Metro app were in for quite a shock. They had to develop their own C++ PDF rendering engine. Obviously, that’s a considerable task and despite being a very common one. That’s why it’s great to see Windows 8.1 introduces built-in support for all apps to render PDF documents. Below we can see the majority of top rated PDF viewer in the Win8 store are all in-fact Desktop apps and not WInRT apps:

The new Win8.1 PDF API starts by loading a PDF file using PdfDocument.LoadFromFileAsync(), getting the total number of pages and then invoking PdfDocument.GetPage(i).RenderToStreamAsync(). Once we have the image stream it should be quite simple to add it into any app UI.

Jump back to table of contents

Multiple screens projection support in apps

Imagine watching a video on your Win8 atom-based tablet and plugging it into your TV. The tablet could duplicate the content on the TV, but it can’t choose to show one view for the TV and another view for the tablet screen. That for example is the experience for the Netflix iPad app. In windows 8 Metro apps were spectacularly single screened and only had one single active view. It seems that in Windows 8.1 developers can opt-in to create additional alternate views for projection displays.

Windows 8.1 Introduces a ProjectionManager class that allows developers to listen to projection display changes and provide multiple displays with their own unique views.

namespace Windows.UI.ViewManagement
{
    public static class ProjectionManager
    {
        public static IAsyncAction StartProjectingAsync(int projectionViewId, int anchorViewId);
        public static IAsyncAction SwapDisplaysForViewsAsync(int projectionViewId, int anchorViewId);
        public static IAsyncAction StopProjectingAsync(int projectionViewId, int anchorViewId);
        public static bool ProjectionDisplayAvailable { get; }
        public static event EventHandler<object> ProjectionDisplayAvailableChanged;
    }
}

Jump back to table of contents

XAML/WinJS: New resolution scaling support / Super-high resolution tablets

It’s possible we’ll see Win8.1 WinRT tablets sporting screens with much higher DPI then Apple’s retina even going all the way up to “4k” resolution.

Win8 supports loading different media resources in different DPIs. Essentially making it quite easy to change images and videos and create a DPI-Independent apps. This is done by specifying the same resource in multiple “scaling factors”. You can read more about scaling factors on Win8’s official blog. It’s interesting that additional scaling factors have been added to Win8.1 showing Microsoft has an expectation for higher-resolution tablets.

  public enum ResolutionScale
  {
    Invalid = 0,
    Scale100Percent = 100,
    Scale140Percent = 140,
    [Version(100859904)] Scale150Percent = 150,
    [Version(100859904)] Scale160Percent = 160,
    Scale180Percent = 180,
    [Version(100859904)] Scale225Percent = 225,
  }

As we can see the highest new scaling factor supported is 225%. That’s 25% higher DPI that Microsoft expects to run on Win8.1 WinRT tablets then on Win8 WinRT tablets. Current scaling values correspond to real resolution and DPI as follows assuming a 12.5”-13” display:

The existing 180% scaling supports 240DPI in WQHD resolution, so it’s reasonable to assume that 225% scaling would support 300DPI and even higher values. It’s possible we’ll see Win8.1 WinRT tablets sporting screens with much higher DPI then Apple’s retina even going all the way up to “4k” resolution.

Jump back to table of contents

Camera: Low-lag cameras / HDR

There are new Win8.1 APIs introduced to support “Low Lag Cameras” which could indicate Microsoft is expecting HDR capable cameras in WinRT Tablets.

As we can see below Win8.1 introduces a lot of new “Low Lag” media capture APIs:

As we can see this API will allow developers to take multiple low lag images in sequence which is a prerequisite to HDR custom stitching algorithms.

“Low Lag” cameras could mean a few things. Let’s first try to explain what Camera Lag is. In digital cameras users first see a thumbnail preview of the image being taken, they then click the “take picture” button and finally they see the final picture. The final picture is often different from the thumbnail preview as cameras need a few hundred milliseconds to actually take pictures. That time between clicking the “take picture” button and the time the picture is actually taken is called “camera lag”. Most cellphones and tablets have greater lag then other digital cameras as they don’t have a physical camera shutter. PC Magazine has a expanded explanation on this topic and more statistics.

So what’s a “Low Lag" Camera good for? First it’ll let users take better pictures due to the reduced lag. Second, it can be used for HDR. HDR is essentially taking multiple nearly identical pictures in different exposure values and stitching them together. For example, a picture with high exposure will provide better visuals for shadows; and a picture with low exposure will have bright objects such as the sun and lamps look better. By stitching the best part of each exposure value we get a much better digital picture. Low lag cameras are essential for HDR as we can’t have too much time between capturing photos or stitching them won’t be feasible. You can read more about HDR here.

Jump back to table of contents

New Metro App Types: Appointments, LockScreen, Contacts and GeoLoc

The way Metro apps are launched is often strongly associated with major featuresets in WinRT. Such Win8 featuresets include Search charm integration, Share charm integration, FileOpenPicker/FileOpenPicker integration, app2app file associations, etc. In Win8.1 the list of activation types in WinRT has been expanded to include lock screen calls, appointments provider, contacts provider and geolocation launching.

namespace Windows.ApplicationModel.Activation
{
  [Version(100794368)]
  public enum ActivationKind
  {
    Launch,
    Search,
    ShareTarget,
    File,
    Protocol,
    FileOpenPicker,
    FileSavePicker,
    CachedFileUpdater,
    ContactPicker,
    Device,
    PrintTaskSettings,
    CameraSettings,
    [Version(100859904)] RestrictedLaunch,
    [Version(100859904)] AppointmentsProvider,
    [Version(100859904)] Contact,
    [Version(100859904)] ContactsProvider,
    [Version(100859904)] LockScreenCall,
  }
}

Jump back to table of contents

New App Type: GeoFenced activation

With WIn8.1 apps can now register to be launched once the user leaves or enters a specific Geolocation area. There are many usecases this can be useful in, for example : keeping tabs that small children don’t stray too far, launching an app once entering a restaurant, etc.

The API itself is pretty straightforward. Win8.1 apps that want to be launched due to exiting or entering a GeoFence area first need to register a LocaitonTrigger the same way they’d register any other IBackgroundTrigger. Next apps need to register additional instances of the GeoFence class with a center point and a radius around that point.

There are a few puzzling open questions about this featureset. Can it be used to Geofence media content? For example, can Netflix use this to limit distribution of just some films to U.S. Markets? Another interesting open question is why limit GeoFencing to circular areas and not rectangular areas? This API seems like it’s got some evolution to do prior to be released to the general public.

Jump back to table of contents

New App Type: Lock screen call

Win8.1 will include the capability to launch VoIP apps to start/end phone calls while the OS is locked. Essentially if a user gets a skype audio call under lock screen, you we want them to first unlock their tablet and then answer; we want them to just answer audio calls with a single tap. Which is why the new LockScreenCallActivatedEventArgs makes a lot of sense. Win8.1 apps also be able to set a call title on the lock screen to show up with the default lock screen UI.

Jump back to table of contents

New App Type: Appointments Provider

Using the new AppointmentsProvider apps can add and manage additional meetings to the shared Win8.1 calendar. Using this functionality developers can integrate 3rd party calendars into the main Win8.1 calendar. The AppointmentsProvider functionality launches the app asking for appointments in a specific time-frame. Appointments may also be sent back to our app to be added, removed, replaced or launched.

With the new AppointmentProvider the ability to show the built-in calendar and individually ask the user to add, replace or launch appointments from it.

Jump back to table of contents

Text-to-speech

Windows 8 apps that integrated text-to-speech capabilities needed to use a web-based TTS service. That had the disadvantage of requiring a network connection and had some lag associated with it. Win8.1 adds text-to-speech support to WinRT apps using Microsoft’s Speech platform. The API itself is straightforward as you can se below.

As we can see above Win8.1’s text-to-speech API supports iterating over installed voicces, choosing a voice to speak, using either plain text or SSML and getting back a SpeechSynthesisStream. For example the following code snippet would say “Hello world”.

        <MediaElement x:Name="media" />

        var speech = new SpeechSynthesizer();
        var stream = await speech.SynthesizeTextToStreamAsync("Hello World");
        media.SetSource(stream, "audio/wav");
        media.Play();

Jump back to table of contents

Read-write access to Camera roll, Saved pictures and playlists

The KnownFolders class provides WinRT apps access to many windows folders such as music, pictures, documents and others. In Win8.1 The list of accessible folders expanded to contain the playlists folders, saved pictures and camera roll. That indicates that Metro Win8.1 apps can read and write from those folders.

namespace Windows.Storage
{
  public static class KnownFolders
  {
    public static StorageFolder SavedPictures { get; }
    public static StorageFolder DocumentsLibrary { get; }
    public static StorageFolder HomeGroup { get; }
    public static StorageFolder MediaServerDevices { get; }
    public static StorageFolder MusicLibrary { get; }
    public static StorageFolder PicturesLibrary { get; }
    public static StorageFolder RemovableDevices { get; }
    public static StorageFolder VideosLibrary { get; }
    public static StorageFolder ApplicationIndexedContent { get; }
    public static StorageFolder ApplicationSearchContent { get; }
    public static StorageFolder Playlists { get; }
    public static StorageFolder CameraRoll { get; }
  }
}

For example, the following code snippet successfully adds a new playlist to the Xbox Music app on Win8.1.

            var file = await KnownFolders.Playlists.CreateFileAsync("myPlaylist.wpl");
            await FileIO.WriteTextAsync(file, @"<?wpl version=""1.0""?>
<smil>
      <head>
        <title>My Playlist</title>
    </head>
    <body>
        <seq>
            <media src=""C:\Users\Justin\Music\brobob.mp3""/>
        </seq>
    </body>
</smil>");

After we run this code snippet and open Xbox Music Playlists we can see our new playlist:

Jump back to table of contents

XAML/WinJS: new SearchBox control

Win8 apps were encouraged to use the Search Charm for any in-app searching. However, many consumers don’t have any idea the search charm even exists. Microsoft seem to have recognized that trend and provided developers with an inline SearchBox control.

It’s curious that SearchBox API doesn’t offer a way of entering a list of terms to search. Which either means it’s either just a plain-old-box-of-searching or it automatically hooks up to the Search Contract. Either way in-app searching without using the Search Charm will be a big UX boost for most users.

We can use the SearchBox control either from XAML or HTML. Here’s how to use it in WinJS:

<div data-win-control="WinJS.UI.SearchBox"  data-win-options="{ placeholderText  : 'place holder', }"></div>

And when we run this code snippet we can see how the SearchBox looks like with placeholder text and when it’s focused:

Jump back to table of contents

XAML/WinJS: Hubs for SemanticZoom

In Win8 coding a UI to support Semantic Zoom was a fairly painful experience. Win8.1 introduces the Hub and HubSection controls to make it easier. The Hub control is essentially a zoomed out view of a Semantic Zoom list. There’s a great screenshot on MSDN that shows the expected difference in UI between zoomed-in state and zoomed-out:

Using the new Hub and HubSection controls we can easily build a UI like the zoomed out UI above. Here’s the WinJS code:

    <div data-win-control="WinJS.UI.Hub">
        <div data-win-control="WinJS.UI.HubSection" data-win-options="{header: 'Today'}">
            <div class="myItem">
                <div class="myText">32</div>
            </div>
        </div>
        <div data-win-control="WinJS.UI.HubSection" data-win-options="{header: 'Yesterday'}">
            <div class="myItem">
                <div class="myText">57</div>
            </div>
        </div>
        <div data-win-control="WinJS.UI.HubSection" data-win-options="{header: 'Last Week'}">
            <div class="myItem">
                <div class="myText">99</div>
            </div>
        </div>
    </div>

And when we run this we can see how using the Hub and HubSection controls makes building Semantic Zoom enabled UIs much easier.

Here’s the full class diagram for the new Hub and HubSection controls:

Jump back to table of contents

XAML: DatePicker and TimePicker

Win8 didn’t have any built-in XAML controls for DateTime selection, but did have those for WinJS. Those have been back ported to WinRT XAML API.

Using these controls will likely render the same UI that’s already available in WinJS for TimePicker and DatePicker controls.

Jump back to table of contents

XAML: Flyout, MenuFlyout and SettingsMenuFlyout

In Win8 XAML apps, it required a lot of coding to add a custom settings screen or a “hover” flyout. WinJS apps had some of that capability out of the box in Win8, but XAML apps didn’t. In Win8.1 we’ll see new XAML controls to help bridge that gap and make building hover flyouts and settings flyouts easier.

The core of this API is around creating a “Flyout” (whether it’s a MenuFlyout, SettingsFlyout or a custom Flyout). MenuFlyouts can then receive MenuFlyoutItemBase that’ll allow to easily compose menus using this new APIs. Win8’s Callisto (a 3rd party project) has a similar API which probably inspired this API. Here’s a print screen from Callisto on how a Flyout could look like:

Jump back to table of contents

XAML: AppBar simplification

When coding AppBar buttons in Win8 developers had to dig through approximately 100 custom styles for <Button /> to style the appbar correctly. That was a pain. WinJS on the other hand had AppBarButton with Icons that made it relatively easy to code for. Win8.1 introduces new AppBar controls that’ll make developing a XAML AppBar much easier.

As you can see from the code diagram above the new controls include a dedicated AppBarButton, AppBarToggleButton and an AppBarSeperator. AppBarButton and AppBarToggleButton both support an “Icon” which is an instance of the IconElement class. IconElement can be practically anything: Images, XAML markup paths, built-in symbols or any font glyph.

Here’s a code sample of how to sue the new XAML AppBar controls:

    <Page.BottomAppBar>
        <AppBar x:Name="bottomAppBar">
            <Grid>
                <AppBarButton Content="New Article">
                    <AppBarButton.Icon>
                        <SymbolIcon Symbol="Add" />
                    </AppBarButton.Icon>
                </AppBarButton>
                <AppBarSeparator />
            </Grid>
        </AppBar>
    </Page.BottomAppBar>

Jump back to table of contents

XAML: DataBinding Improvements

XAML Databindings in WPF, Silverlight 4 and Windows Phone 8 have additional features that didn’t exist for Win8 and have been backported to WIn8.1. The new properties being introduces are FallbackValue, TargetNullValue and UpdateSourceTrigger. StringFormat will not be included in Win8.1. You can read more about FallBackValue and TargetNullValue on Jason's blog.

        <TextBlock Text="{Binding Path=myProperty, 
            FallbackValue='myFallbackValue', 
            TargetNullValue='myNullValue', 
            UpdateSourceTrigger=PropertyChanged}" />

Win8.1 will also introduce a DataTemplateSelector to support databinding lists to instances of multiple types and rendering different visuals for each type. More on that in MSDN.

Jump back to table of contents

Globalization: Currencies, Numeral systems and Numerical formatters

Win8 has support to formatting dates, times and numbers based on the user’s culture. Win8.1 expands that list to support currencies, non-latin numerical systems and multiple numerical formatting functions. Each of those formatting options sounds simple before you consider the cross-cultural complexity so it’s great to see Microsoft supporting those out of the box.

Here’s an example on how Win8.1 can help our app translate to non-latin numerical systems, format currencies and help print out numbers.

    // Brazil Dollar, prints out: BZ$12345.60
    Debug.WriteLine(new CurrencyFormatter(CurrencyIdentifiers.BZD).Format(12345.6));

    // United Stats Dollar, prints out: $12345.60
    Debug.WriteLine(new CurrencyFormatter(CurrencyIdentifiers.USD).Format(12345.6));

    // Iran Rial, prints out: ????12345.60
    Debug.WriteLine(new CurrencyFormatter(CurrencyIdentifiers.IRR).Format(12345.6));

    // Arabic numerals, prints out: ??????????
    Debug.WriteLine(new NumeralSystemTranslator()
                    {
                        NumeralSystem = NumeralSystemIdentifiers.Arab
                    }.TranslateNumerals("1234567890"));

    // Thai numerals, prints out: ??????????
    Debug.WriteLine(new NumeralSystemTranslator()
                    {
                        NumeralSystem = NumeralSystemIdentifiers.Thai
                    }.TranslateNumerals("1234567890"));

    // percent formatter, prints out: 1236.789 %
    Debug.WriteLine(new PercentFormatter().Format(12.36789));

    // Permille formatter, prints out: 12367.89 ‰
    Debug.WriteLine(new PermilleFormatter().Format(12.36789));

    // Rounding formatter, prints out: 13
    Debug.WriteLine(new SignificantDigitsNumberRounder()
                    {
                        RoundingAlgorithm = RoundingAlgorithm.RoundUp,
                        SignificantDigits = 2
                    }.RoundDouble(12.3));

As we can see each language and formatting algorithm has a certain amount of complexity to it. Currency formatters change base on the currency symbol and the its location; some cultures need to format numbers in non-latin numerals; and formatting percents or rounding is also culturally specific. Having these built-in formatters is going to prove super useful to WinRT developers. Just the CurrencyFormatter alone is sure to be used by any Win8.1 app that has in-app purchase enabled for multiple markets.

Jump back to table of contents

Other minor but important Win8.1 features

There are additional smaller Win8.1 features that developers might find interesting:

XAML: TextBox, PasswordBox and SearchBox now support Watermarks and Headers.
XAML: A <SwapChainPanel /> control will be introduced to improve XAML-to-DirectX interop. It’s likely that this control will support fully interactive, high-performance DirectX “islands” to be embedded in XAML pages.
XAML: MediaElement will be get support for MediaStreamSource. MediaStreamSource is the way WPF, Silverlight and Windows Phone support custom media sources. MediaStreamSource was used by many media companies on these platforms. Win8 didn’t support MediaStreamSource instead asking developers to build C++ Media Foundation plugins. Companies with existing MediaStreamSource investments will be able to port them to Win8.1.
Media: When recording Audio, Video or Pictures developers can now set preferences such as Auto-focus, Capture Scene, Exposure, Flash, Iso speed, white balance and others.
Networking: Win8.1 PeerWatcher class will supplement PeerFinder to provide notifications when new devices are in range.
Networking: Win8.1 will provide developers with details about the current connections such as WiFi access point name, 3G data usage, cellular signals bar and more.
Netwroking: Hardcoded support for standard HTTP Headers, HTTP Verbs and HTTP protocol components have been introduced in Win8.1. That helps remove magic “http strings” from our code and make coding for REST services a lot easier.
UI: All existing Win8 TileTemplateType values are now marked as obsolete. All templates for Win8.1 app tiles are in one of three sizes: 150x150 pixels, 310x310 pixels and 310x150 pixels.
Many other features have been introduced that won’t be covered here.

Jump back to table of contents

How to code Win8.1 C# apps before public beta?

These instructions are only useful before BUILD 2013 conference (June 22nd 2013). After this date simply installing Win8.1 with the development tools will suffice.

Here are the instructions to develop on Windows 8 with Visual Studio 2012 and deploy & debug on Win8.1:

Install WIn8.1.
Enable Win8 remote debugging like you would for any Win8 machine. Install Visual Studio 2012 Remote debugging tools and run them.
Create a new Windows.WinMD that matches Win8.1 and could then be copied to a Win8 development machine. On your Win8.1 machine run the following command:
mdmerge -i c:\Windows\System32\WinMetadata\ -o c:\temp\windows.winmd /n 1
Backup your Win8 Windows.WinMD file so you could return to Win8.0 development if you choose to. The file is located @
"c:\Program Files (x86)\Windows Kits\8.0\References\CommonConfiguration\Neutral\Windows.winmd"
Finally replace your Win8 Windows.WinMD file with the Win8.1’s Windows.WinMD file.
Restart VS2012 and you can now code against Win8.1 APIs on Win8, deploy to a Win8.1 machine and debug.

Jump back to table of contents

How to develop Win8.1 WinJS apps before public beta?

These instructions are only useful before BUILD 2013 conference (June 22nd 2013). After this date simply installing Win8.1 with the development tools will suffice.

In order to code, deploy and debug Win8.1 WinJS apps from Win8 and Visual Studio 2012 follow these steps:

Find WinJS 2.0 files from your local C:\Program Files\WindowsApps folder. You’ll need to do some fancy security permission changes and then you’ll be able to copy “Microsoft.WinJS” folders.
Or you can download a copy from @ http://justinangel.net/storage/windows81/WinJS2.0Preview.zip
Create a new Win8 WinJS project in Visual Studio 2012.
Add copies of ui.js, base.js and ui-light.css to your project from the aforementioned folders.
Replace all references to ui.js, base.js and ui-light.css with references to your locally embedded files.
You can now code against WinJS 2.0 APIs on a Win8 machine, and run & debug on Win8.1.

Jump back to table of contents

Disclaimer: Please don’t sue me

The article is written to share original research on the upcoming WinRT goodness with other developers. I have no insider information what-so-ever on Windows 8.1.

This article compromises my personal conclusions from “leaked” Windows 8.1 OS Images. No NDAs were harmed in the making of this article. I do not have and never had any pre-release access to WIndows 8.1 provided to me by Microsoft or anyone else. This article was written and researched on my own time and has no affiliation with my employer.

Feedback?

Questions? Feedback? Other insights? Sound off in the comments.

Sincerely,
-- Justin Angel

All new Windows Phone 7.5 Mango APIs

Hi folks,

In this article I’d like to present all the new Windows Phone 7.5 Mango APIs. The goal is to inform developers who aren’t familiar with Mango of what new APIs are available. Since there are “1,500” new APIs we won’t be able to deep-dive into APIs with code samples. We’ll examine the new APIs and their related class diagrams. Most APIs should be fairly straightforward to professional .net developers who should be familiar with Microsoft’s API style. Each section of this article will also contain external links for those wishing to learn more about the APIs, featuresets and their usages.

How was this article composed? Who is it meant for?

This article is geared towards professional .net developers who want to learn about the WP7.5 Mango release. If you can look at a Microsoft API and figure out what it does, then this article is for you. If can’t look at an API and figure it out, then this article isn’t for you. We won’t have any samples of code usage inline in the article. Though there are external links for most topics.

Using the Framework Design Studio I compared all the WP7.0 (NoDo) assemblies with the WP7.5 (Mango) assemblies. We’ll review those changes in this article.

You can download the generated diff reports from @ http://JustinAngel.net/storage/MangoWp7ToWp71Reports.zip

How was this article composed? Who is it meant for?
Sensors API: overview, SensorBase and other supporting classes
Sensor API: Gyroscope and Compass
Sensor APIs: Combined Motion API
Sensor APIs: changes to the Accelerometer API
Camera API
Background API: overview and BackgroundTask class
Background API: Background Audio and streaming background Audio
Background API: Data Transfer APIs
Scheduling & Background API: Alarms, Reminders, Periodic Tasks and Resource Intensive Tasks
Background API: Programmatic Toast Notifications
Appointments and Contacts API: Overview
Appointments
Contacts
New Launchers and Choosers
Changes and additions to existing Launchers and Choosers
Secondary Tiles and primary tile improvements
Mixed XNA and Silverlight apps
LINQ-to-SQL and Local Database
Search Extensibility
Sockets: IP and DNS Addresses
Sockets: DNS Resolution
Sockets: Socket class and SocketAsyncEventArgs
Sockets: UDP
Shell UI: New ProgressIndicator, and changes to ApplicationBar & SystemTray
Bing Maps changes: Random XAML elements positioning
Removing Pages from the backstack frame journal
Device Information and Network Information
WebBrowser control changes: HTML5 GeoLocation and NavigationFailed event
Network Request Preference and Requirements
Xbox Live: Render Xbox Live Avatars in XNA
Xbox Live: Avatar Assets
Custom Linq Providers
Dynamically compiled Lambda Expressions and Reflection.Emit
mscorib.Extensions: SIMD/ARM-NEON XNA support
mscorlib.Extensions: Mutex
mscorlib.Extensions: INotifyPropertyChanging
mscorlib.Extensions: RSA Cryptography
Silverlight 4: Base-Class Library changes in mscorlib assembly
Silverlight 4: System.Windows Silverlight changes

Sensors API: overview, SensorBase and other supporting classes

A new overall class hierarchy has been added to support Sensor readings from various sensors. In WP7.1 we only had Acceleromators. In WP7.5 the API has also been expanded to support the Compasses, Gyroscope and combined “Motion” APIs.

As you can see the new SensorBase<TSensorReading> class is the base class for all the new sensor classes. This architecture is a very elegant solution to making Sensor APIs consistent across multiple devices.

    public abstract class SensorBase<TSensorReading> : IDisposable

        where TSensorReading : ISensorReading

    public event EventHandler<SensorReadingEventArgs<TSensorReading>> CurrentValueChanged;

        public TSensorReading CurrentValue { get; }

        public bool IsDataValid { get; }

        public TimeSpan TimeBetweenUpdates { get; set; }

        public virtual void Start();

        public virtual void Stop();

    public interface ISensorReading

        DateTimeOffset Timestamp { get; }

    public class SensorReadingEventArgs<T> : EventArgs

        where T : ISensorReading

        public T SensorReading { get; set; }

Back to the table of contents

Sensor API: Gyroscope and Compass

Two new Sensors now supported in WP7.5 are the Gyroscope and Compass APIs. They follow the pattern we just saw above of inheriting from SensorBase<ISensorReading> and implementing their own sensor reading event arguments.

    public sealed class Compass : SensorBase<CompassReading>

        public Compass();

        public static bool IsSupported { get; internal set; }

        public event EventHandler<CalibrationEventArgs> Calibrate;

    public struct CompassReading : ISensorReading

        public DateTimeOffset Timestamp { get; internal set; }

        public double HeadingAccuracy { get; internal set; }

        public double TrueHeading { get; internal set; }

        public Vector3 MagnetometerReading { get; internal set; }

        public double MagneticHeading { get; internal set; }

    public sealed class Gyroscope : SensorBase<GyroscopeReading>

        public Gyroscope();

        public static bool IsSupported { get; internal set; }

    public struct GyroscopeReading : ISensorReading

        public DateTimeOffset Timestamp { get; internal set; }

        public Vector3 RotationRate { get; internal set; }

Back to the table of contents

Sensor APIs: Combined Motion API

An additional new type of Sensor readings is the new “Motion” API which takes input from all other available sensors and provides sensor-independent motion information. It’s recommended developers use this API whenever applicable to allow apps to work on as many devices as possible regardless of low-level supported sensors.

    public sealed class Motion : SensorBase<MotionReading>

        public Motion();

        public static bool IsSupported { get; internal set; }

        public event EventHandler<CalibrationEventArgs> Calibrate;

    public struct MotionReading : ISensorReading

    {

         public DateTimeOffset Timestamp { get; internal set; }

         public AttitudeReading Attitude { get; internal set; }

         public Vector3 DeviceAcceleration { get; internal set; }

         public Vector3 Gravity { get; internal set; }

         public Vector3 DeviceRotationRate { get; internal set; }

    public struct AttitudeReading : ISensorReading

        public DateTimeOffset Timestamp { get; internal set; }

        public float Yaw { get; internal set; }

        public float Pitch { get; internal set; }

        public float Roll { get; internal set; }

        public Quaternion Quaternion { get; internal set; }

        public Matrix RotationMatrix { get; internal set; }

Back to the table of contents

Sensor APIs: changes to the Accelerometer API

The original API for WP7 Accelerometer was written back when there was only one Sensor API to support. As you’ve seen there is a new Sensor architectureand some elements of the Accelerometer API are now obsolete in favour of the new Sensor API conventions.

    public sealed class Accelerometer : SensorBase<AccelerometerReading>
    {
        public static bool IsSupported { get; internal set; }

        public SensorState State { get; }

        [Obsolete("use CurrentValueChanged")]
        public event EventHandler<AccelerometerReadingEventArgs> ReadingChanged;
    }

    public struct AccelerometerReading : ISensorReading

        public DateTimeOffset Timestamp { get; internal set; }

        public Vector3 Acceleration { get; internal set; }

For more reading on the Sensor APIs and how to use them see MSDN’s section on Sensors for Windows Phone.

Back to the table of contents

Camera API

Managed camera access for non-OEM apps has been added as part of the Mango release. You can read more about how to use this API on MSDN @ Camera and Photos for Windows Phone.

It’s easy to see that the core of this new API is the newly exposed Camera class and its inheriting class PhotoCamera that’s used for still shots.

    public abstract class Camera : IDisposable

        public static bool IsCameraTypeSupported(CameraType type);

        public CameraType CameraType { get; protected set; }

        public IEnumerable<Size> AvailableResolutions { get; }

        public Size Resolution { get; set; }

        public Size PreviewResolution { get; }

        public double Orientation { get; }

        public event EventHandler<CameraOperationCompletedEventArgs> Initialized;

        public void Dispose();

    public sealed class PhotoCamera : Camera

        public PhotoCamera(CameraType type);

        public PhotoCamera();

        public void Focus();

        public void FocusAtPoint(double x, double y);

        public void CancelFocus();

        public void GetPreviewBufferArgb32(int[] pixelData);

        public void GetPreviewBufferY(byte[] pixelData);

        public void GetPreviewBufferYCbCr(byte[] pixelData);

        public bool IsFlashModeSupported(FlashMode mode);

        public void CaptureImage();

        public bool IsFocusSupported { get; }

        public bool IsFocusAtPointSupported { get; }

        public YCbCrPixelLayout YCbCrPixelLayout { get; }

        public FlashMode FlashMode { get; set; }

        public event EventHandler<CameraOperationCompletedEventArgs> AutoFocusCompleted;

        public event EventHandler CaptureStarted;

        public event EventHandler<ContentReadyEventArgs> CaptureThumbnailAvailable;

        public event EventHandler<ContentReadyEventArgs> CaptureImageAvailable;

        public event EventHandler<CameraOperationCompletedEventArgs> CaptureCompleted;

There are a few new event handlers and Enums used in PhotoCamera and Camera classes.

    public enum CameraType

        Primary,

        FrontFacing,

    public enum FlashMode

        On = 1,

        Off = 2,

        Auto = 3,

        RedEyeReduction = 4,

    public class CameraOperationCompletedEventArgs : EventArgs

        public CameraOperationCompletedEventArgs(bool succeeded, Exception exception);

        public Exception Exception { get; }

        public bool Succeeded { get; }

    public sealed class ContentReadyEventArgs : EventArgs

        public Stream ImageStream { get; }

Video cameras as enabled as an extension method on VideoBrush through CameraVideoBrushExtensions.

    public static class CameraVideoBrushExtensions

        public static void SetSource(this VideoBrush brush, Camera camera);

CameraButtons expose static events related to the shutter button.

    public static class CameraButtons

        public static event EventHandler ShutterKeyPressed;

        public static event EventHandler ShutterKeyHalfPressed;

        public static event EventHandler ShutterKeyReleased;

A preview of the current image in the camera is available via the PhotoCamera.GetPreviewBufferYCbCr() method. The information describing the contents of that preview is available through the YCbCrPixelFormat class.

    public sealed class YCbCrPixelLayout

        public int RequiredBufferSize { get; internal set; }

        public int YPitch { get; internal set; }

        public int YXPitch { get; internal set; }

        public int YOffset { get; internal set; }

        public int CbPitch { get; internal set; }

        public int CbXPitch { get; internal set; }

        public int CbOffset { get; internal set; }

        public int CrPitch { get; internal set; }

        public int CrXPitch { get; internal set; }

        public int CrOffset { get; internal set; }

The last API for the Camera Mango featureset is the addition of the MediaLibrary.SavePictureToCameraRoll() method. With it developers can create custom camera apps that save to the same location as the WP7 built-in camera app.

    public sealed class MediaLibrary : IDisposable

        public MediaLibrary();

        public MediaLibrary(MediaSource mediaSource);

        public void Dispose();

        public Picture SavePictureToCameraRoll(string name, byte[] imageBuffer);

        public Picture SavePictureToCameraRoll(string name, Stream source);

        public Picture SavePicture(string name, byte[] imageBuffer);

        public Picture SavePicture(string name, Stream source);

        public Picture GetPictureFromToken(string token);

        public AlbumCollection Albums { get; }

        public ArtistCollection Artists { get; }

        public GenreCollection Genres { get; }

        public bool IsDisposed { get; }

        public MediaSource MediaSource { get; }

        public PictureCollection Pictures { get; }

        public PlaylistCollection Playlists { get; }

        public PictureAlbum RootPictureAlbum { get; }

        public PictureCollection SavedPictures { get; }

        public SongCollection Songs { get; }

Back to the table of contents

Background API: overview and BackgroundTask class

There are new background processing related featuresets in mango: Audio, scheduled tasks, background transfers and toasts. As you can see from the diagram above there’s a common base class BackgroundAgent used by the 2 music streaming background agents and the 1 scheduled task background agent. Note that background transfers doesn’t have it’s own publicly exposed background agent.

    public abstract class BackgroundAgent

        protected internal BackgroundAgent();

        protected void NotifyComplete();

        protected void Abort();

        protected internal virtual void OnCancel();

As with the rest of the featuresets we’ll be discussing in this article, we won’t review how to create a background agent. Read more on background agents on MSDN’s Background Agents for Windows Phone.

Back to the table of contents

Background API: Background Audio and streaming background Audio

As part of the new Mango featureset to support audio playback while apps are in the background there are 2 new background agents we can inherit from and implement. First is the AudioPlayerAgent that can be used for any media type Windows Phone can directly play from a Uri. The second background agent is AudioStreamingAgent for otherwise unsupported streaming media formats that need some pre-processing (such as shoutcast, icecast and RTSP) using a custom Silverlight MediaStreamSource.

    public class AudioPlayerAgent : BackgroundAgent

        protected virtual void OnUserAction(

            BackgroundAudioPlayer player, AudioTrack track,

            UserAction action, object param);

        protected virtual void OnPlayStateChanged(BackgroundAudioPlayer player,

            AudioTrack track, PlayState playState);

        protected virtual void OnError(BackgroundAudioPlayer player, AudioTrack track,

            Exception error, bool isFatal);

    public class AudioStreamingAgent : BackgroundAgent

        protected virtual void OnBeginStreaming(AudioTrack track, AudioStreamer streamer);

        protected internal override void OnCancel();

As we can see both of these are based on having an AudioTrack instance that contains information on the currently playing audio.

    public class AudioTrack : IEditableObject

        public AudioTrack();

   public AudioTrack(Uri source, string title, string artist, string album, Uri albumArt);

        public AudioTrack(Uri source, string title, string artist, string album,

            Uri albumArt, string tag, EnabledPlayerControls enabledControls);

        public void BeginEdit();

        public void CancelEdit();

        public void EndEdit();

        public Uri Source { get; set; }

        public string Title { get; set; }

        public string Artist { get; set; }

        public string Album { get; set; }

        public string Tag { get; set; }

        public Uri AlbumArt { get; set; }

        public EnabledPlayerControls PlayerControls { get; set; }

        public TimeSpan Duration { get; }

    [Flags]

    public enum EnabledPlayerControls : long

        None = 0,

        SkipNext = 1,

        SkipPrevious = 2,

        FastForward = 4,

        Rewind = 8,

        Pause = 16,

        All = Pause | Rewind | FastForward | SkipPrevious | SkipNext,

The AudioPlayerAgent receives notifications whenever a user action happens (in the top media bar) and the playback status has changed.

    public enum PlayState

        Unknown,

        Stopped,

        Paused,

        Playing,

        BufferingStarted,

        BufferingStopped,

        TrackReady,

        TrackEnded,

        Rewinding,

        FastForwarding,

        Shutdown,

        Error,

    public enum UserAction

        Stop = 1,

        Pause = 2,

        Play = 3,

        SkipNext = 4,

        SkipPrevious = 5,

        FastForward = 6,

        Rewind = 7,

        Seek = 8,

Whenever the playstate changes or a user action has occurred, the background agent can respond interacting directly with audio playback through the BackgroundAudioPlayer.

    public sealed class BackgroundAudioPlayer

        public void Play();

        public void Pause();

        public void Stop();

        public void FastForward();

        public void Rewind();

        public void SkipNext();

        public void SkipPrevious();

        public void Close();

        public static BackgroundAudioPlayer Instance { get; }

        public PlayState PlayerState { get; }

        public AudioTrack Track { get; set; }

        public TimeSpan Position { get; set; }

        public double BufferingProgress { get; }

        public bool CanPause { get; }

        public bool CanSeek { get; }

        public double Volume { get; set; }

        public Exception Error { get; }

        public event EventHandler PlayStateChanged;

We previously mentioned there are two background audio agents. The first used for straight up Uri playback, and the other for custom MediaStreamSource playback. For the latter you’ll have to use an AudioStreamer in order to provide the MediaStreamSource.

    public sealed class AudioStreamer

        public void SetSource(MediaStreamSource source);

For more information on how to implement mango background audio playback see MSDN’s Background Audio Overview for Windows Phone.

Back to the table of contents

Background API: Data Transfer APIs

As part of the mango featureset that allows apps to download and upload files while the app is in the background, developers can add new BackgroundTrasnferRequests to the BackgroundTransferService. The BackgroundTransferService will then schedule the download/upload transfers based on the overall transfer queue and network requirements.

    public static class BackgroundTransferService

        public static BackgroundTransferRequest Find(string requestId);

        public static void Add(BackgroundTransferRequest request);

        public static void Remove(BackgroundTransferRequest request);

        public static IEnumerable<BackgroundTransferRequest> Requests { get; }

    public sealed class BackgroundTransferRequest : IDisposable

        public BackgroundTransferRequest(Uri requestUri);

        public BackgroundTransferRequest(Uri requestUri, Uri downloadLocation);

        public void Dispose();

        public string RequestId { get; }

        public Uri RequestUri { get; }

        public string Tag { get; set; }

        public Uri DownloadLocation { get; set; }

        public Uri UploadLocation { get; set; }

        public IDictionary<string, string> Headers { get; }

        public string Method { get; set; }

        public TransferPreferences TransferPreferences { get; set; }

        public TransferStatus TransferStatus { get; }

        public Exception TransferError { get; }

        public long TotalBytesToReceive { get; }

        public long TotalBytesToSend { get; }

        public long BytesReceived { get; }

        public long BytesSent { get; }

        public long StatusCode { get; }

        public event EventHandler<BackgroundTransferEventArgs> TransferStatusChanged;

        public event EventHandler<BackgroundTransferEventArgs> TransferProgressChanged;

    public enum TransferPreferences

        None,

        AllowCellular,

        AllowBattery,

        AllowCellularAndBattery,

By signing up to events on the BackgroundTransferRequest events it’s possible to receive notifications whenever the download/upload status changes and their respective status.

    public sealed class BackgroundTransferEventArgs : EventArgs

        public BackgroundTransferEventArgs(BackgroundTransferRequest request);

        public BackgroundTransferRequest Request { get; }

    public enum TransferStatus

        None,

        Transferring,

        Waiting,

        WaitingForWiFi,

        WaitingForExternalPower,

        WaitingForExternalPowerDueToBatterySaverMode,

        WaitingForNonVoiceBlockingNetwork,

        Paused,

        Completed,

        Unknown,

    public sealed class BackgroundTransferInternalException : SystemException

Back to the table of contents

Scheduling & Background API: Alarms, Reminders, Periodic Tasks and Resource Intensive Tasks

Using the new scheduling API it’s possible to add scheduled reminder, alarms and tasks. Using the ScheduledActionService we can add, retrieve and test any of the aforementioned tasks.

    public sealed class ScheduledActionService

        public static void Add(ScheduledAction action);

        public static ScheduledAction Find(string name);

        public static IEnumerable<T> GetActions<T>() where T : ScheduledAction;

        public static void Remove(string name);

        public static void Replace(ScheduledAction action);

        public static void LaunchForTest(string name, TimeSpan delay);

    public sealed class SchedulerServiceException : SystemException

To add Alarms or Reminders simply instantiate those classes and add them to the ScheduleActionService. For more on this topic see MSDN’s Alarms and Reminders Overview for Windows Phone.

    public abstract class ScheduledNotification : ScheduledAction

        public virtual string Content { get; set; }

        public RecurrenceInterval RecurrenceType { get; set; }

        public virtual string Title { get; set; }

    public enum RecurrenceInterval

        None,

        Daily,

        Weekly,

        Monthly,

        EndOfMonth,

        Yearly,

    public sealed class Alarm : ScheduledNotification

        public Alarm(string name);

        public Uri Sound { get; set; }

        public override string Title { get; set; }

    public sealed class Reminder : ScheduledNotification

        public Reminder(string name);

        public Uri NavigationUri { get; set; }

It’s also possible to create scheduled tasks where we can execute arbitrary code in a ScheduleTaskAgent.

    public abstract class ScheduledTaskAgent : BackgroundAgent

        protected internal abstract void OnInvoke(ScheduledTask task);

        [EditorBrowsable(EditorBrowsableState.Never)]

        protected internal override sealed void OnCancel();

To schedule running a ScheduleTaskAgent use either a PeriodicTask or for more resource intensive tasks (execution time, WiFi-only, device lock, etc) use the ResourceIntensiveTask. Both inherit from ScheduledTask. For more on this topic and the distinction between resource intensive and non-resource intensive tasks see MSDN’s Background Agents Overview for Windows Phone.

    public abstract class ScheduledTask : ScheduledAction
    {
         public override DateTime BeginTime { get; set; }



         public override DateTime ExpirationTime { get; set; }
         public string Description { get; set; }


         public DateTime LastScheduledTime { get; internal set; }

         public AgentExitReason LastExitReason { get; internal set; }
    }

    public enum AgentExitReason

        None,

        Completed,

        Aborted,

        MemoryQuotaExceeded,

        ExecutionTimeExceeded,

        UnhandledException,

        Terminated,

        Other,

    public sealed class PeriodicTask : ScheduledTask

        public PeriodicTask(string name);

    public sealed class ResourceIntensiveTask : ScheduledTask

        public ResourceIntensiveTask(string name);

Back to the table of contents

Background API: Programmatic Toast Notifications

Using the new ShellToast class it is possible for background agents to show a toast notification that’ll act as a deep link back to the application. It’s important to mention that this API will not work for in-app notifications, and will only show toast notifications when invoked from a background agent. For more on that see Den Delimarsky’s ShellToast on Windows Phone.

    public class ShellToast

        public void Show();

        public string Title { get; set; }

        public string Content { get; set; }

        public Uri NavigationUri { get; set; }

Back to the table of contents

Appointments and Contacts API: Overview

Using the new PhoneDataSharingContext classes it’s possible to search for Appointments and Contacts on the phone, register for a search completed events and check the EventsArgs for the results. We can see the parallels between Appointments and Contacts from the class diagram above. Even though they are both independent they both share the same search-driven architecture. The resulting Contact and Appointment classes are very informative so we’ll address each in its own section in this article.

    public class PhoneDataSharingContext

        protected PhoneDataSharingContext(string baseUri);

        protected IEnumerable<T> ExecuteRequest<T>(string query);

        protected string BaseUri { get; }

Both Appointments and Contacts’ search allow to filter based on user accounts with the relevant classes shown here:

    public sealed class Account

        public string Name { get; internal set; }

        public StorageKind Kind { get; internal set; }

    public enum StorageKind

        Phone,

        WindowsLive,

        Outlook,

        Facebook,

        Other,

For more on how to access Appointments and Contacts see MSDN’s Contacts and Calendar for Windows Phone.

Back to the table of contents

Appointments

As we’ve previously mentioned access to Appointments starts of with searching for appointments, registering for the async results events and iterating over the EventArgs results.

    public sealed class Appointments : PhoneDataSharingContext

        public const int DefaultMaximumItems = 100;

        public void SearchAsync(DateTime startTimeInclusive, DateTime endTimeInclusive,

           object state);

        public void SearchAsync(DateTime startTimeInclusive, DateTime endTimeInclusive,

           int maximumItems, object state);

        public void SearchAsync(DateTime startTimeInclusive, DateTime endTimeInclusive,

           Account account, object state);

        public void SearchAsync(DateTime startTimeInclusive, DateTime endTimeInclusive,

           int maximumItems, Account account, object state);

        public IEnumerable<Account> Accounts { get; }

        public event EventHandler<AppointmentsSearchEventArgs> SearchCompleted;

    public sealed class AppointmentsSearchEventArgs : EventArgs

        public DateTime StartTimeInclusive { get; internal set; }

        public DateTime EndTimeInclusive { get; internal set; }

        public IEnumerable<Appointment> Results { get; internal set; }

        public object State { get; internal set; }

The appointments themselves can be accessed after the search is complete.

    public sealed class Appointment

        public string Subject { get; internal set; }

        public string Location { get; internal set; }

        public DateTime StartTime { get; internal set; }

        public DateTime EndTime { get; internal set; }

        public bool IsAllDayEvent { get; internal set; }

        public AppointmentStatus Status { get; internal set; }

        public string Details { get; internal set; }

        public Attendee Organizer { get; internal set; }

        public IEnumerable<Attendee> Attendees { get; }

        public bool IsPrivate { get; internal set; }

        public Account Account { get; internal set; }

    public enum AppointmentStatus

        Free,

        Tentative,

        Busy,

        OutOfOffice,

    public sealed class Attendee

        public string DisplayName { get; internal set; }

        public string EmailAddress { get; internal set; }

Back to the table of contents

Contacts

Contacts use the same async search pattern used for appointments.

    public sealed class Contacts : PhoneDataSharingContext

        public void SearchAsync(string filter, FilterKind filterKind, object state);

        public IEnumerable<Account> Accounts { get; }

        public event EventHandler<ContactsSearchEventArgs> SearchCompleted;

    public sealed class ContactsSearchEventArgs : EventArgs

        public FilterKind FilterKind { get; internal set; }

        public string Filter { get; internal set; }

        public IEnumerable<Contact> Results { get; internal set; }

        public object State { get; internal set; }

When searching for contacts it’s possible to filter the search based on name, phone number, email address and whether the contact tile is pinned to the phone home screen.

    public enum FilterKind

        None,

        PinnedToStart,

        EmailAddress,

        PhoneNumber,

        DisplayName,

The results of a search for contacts is the Contact class which references many additional supporting classes.

    public sealed class Contact

        public Stream GetPicture();

        public string DisplayName { get; internal set; }

        public CompleteName CompleteName { get; internal set; }

        public IEnumerable<ContactPhoneNumber> PhoneNumbers { get; }

        public IEnumerable<ContactEmailAddress> EmailAddresses { get; }

        public IEnumerable<ContactAddress> Addresses { get; }

        public IEnumerable<ContactCompanyInformation> Companies { get; }

        public IEnumerable<string> Websites { get; }

        public IEnumerable<string> SignificantOthers { get; }

        public IEnumerable<string> Children { get; }

        public IEnumerable<string> Notes { get; }

        public IEnumerable<DateTime> Birthdays { get; }

        public bool IsPinnedToStart { get; internal set; }

        public IEnumerable<Account> Accounts { get; }

    public sealed class CompleteName

        public string FirstName { get; internal set; }

        public string YomiFirstName { get; internal set; }

        public string LastName { get; internal set; }

        public string YomiLastName { get; internal set; }

        public string MiddleName { get; internal set; }

        public string Title { get; internal set; }

        public string Nickname { get; internal set; }

        public string Suffix { get; internal set; }

    public sealed class ContactPhoneNumber

       public string PhoneNumber { get; internal set; }

        public PhoneNumberKind Kind { get; internal set; }

        public IEnumerable<Account> Accounts { get; }

    public enum PhoneNumberKind

        Mobile,

        Home,

        Work,

        Company,

        Pager,

        HomeFax,

        WorkFax,

    public sealed class ContactEmailAddress

        public string EmailAddress { get; internal set; }

        public EmailAddressKind Kind { get; internal set; }

        public IEnumerable<Account> Accounts { get; }

    public enum EmailAddressKind

        Personal,

        Work,

        Other,

    public sealed class ContactAddress

        public CivicAddress PhysicalAddress { get; internal set; }

        public AddressKind Kind { get; internal set; }

        public IEnumerable<Account> Accounts { get; }

    public sealed class ContactCompanyInformation

        public string CompanyName { get; internal set; }

        public string YomiCompanyName { get; internal set; }

        public string OfficeLocation { get; internal set; }

        public string JobTitle { get; internal set; }

        public IEnumerable<Account> Accounts { get; }

Back to the table of contents

New Launchers and Choosers

There are 8 new Launchers & Choosers in Mango and we’ll review all of them in this section.

The ShareStatusTask and ShareLinkTask share content on social media accounts the user has previously linked to (facebook, twitter, windows live, etc). For more on how to use the sharing tasks see MSDN’s How to: Use the Share Status Task for Windows Phone and How to: Use the Share Link Task for Windows Phone.

    public abstract class ShareTaskBase

        public void Show();

    public sealed class ShareStatusTask : ShareTaskBase

        public string Status { get; set; }

    public sealed class ShareLinkTask : ShareTaskBase

        public Uri LinkUri { get; set; }

        public string Title { get; set; }

        public string Message { get; set; }

The ConnectionSettingsTask allows apps to launch into 4 settings screen on the phone: Airplane Mode, WiFi Settings, Bluetooth Settings and Cellular & Data settings. For a sample on how to use this task see MSDN’s How to: Use the Connection Settings Task for Windows Phone.

    public sealed class ConnectionSettingsTask

        public void Show();

        public ConnectionSettingsType ConnectionSettingsType { get; set; }

    public enum ConnectionSettingsType

        WiFi,

        Bluetooth,

        Cellular,

        AirplaneMode,

The BingMapsTask launches the map application with a specific latitude and longitude combination or just a search term. For instructions on how to use this task see MSDN’s How to: Use the Bing Maps Task for Windows Phone.

    public sealed class BingMapsTask

        public void Show();

        public GeoCoordinate Center { get; set; }

        public string SearchTerm { get; set; }

        public double ZoomLevel { get; set; }

The BingMapsDirectionsTask launches the maps app with driving directions between two latitude and longitude coordinates. For instructions on how to use this task see MSDN’s How to: Use the Bing Maps Directions Task for Windows Phone.

    public sealed class BingMapsDirectionsTask

        public void Show();

        public LabeledMapLocation Start { get; set; }

        public LabeledMapLocation End { get; set; }

    public sealed class LabeledMapLocation

        public LabeledMapLocation();

        public LabeledMapLocation(string label, GeoCoordinate location);

        public string Label { get; set; }

        public GeoCoordinate Location { get; set; }

The GameInviteTask is an API that can only be used by previously approved Xbox Live titles (currently there are less than 100 of those) to start multiplayer gaming sessions. For more on this task see MSDN’s How to: Use the Game Invite Task for Windows Phone.

    public sealed class GameInviteTask : ChooserBase<TaskEventArgs>

        public override void Show();

        public string SessionId { get; set; }

The SaveRingtoneTask launches a save dialog for a new phone ringtone based on a Uri. Note that even though the Uri can point to any file Uri there are very specific requirements for the audio file that you’ll want to make sure your ringtone meets. For more information on this task and the aforementioned requirements see MSDN’s How to: Use the Save Ringtone Task for Windows Phone.

    public sealed class SaveRingtoneTask : ChooserBase<TaskEventArgs>

        public override void Show();

        public Uri Source { get; set; }

        public string DisplayName { get; set; }

        public bool IsShareable { get; set; }

The AddressChooserTask allows the user to select an address from their contacts list. For more information on how to use this task see MSDN’s How to: Use the Address Chooser Task for Windows Phone.

    public sealed class AddressChooserTask : ChooserBase<AddressResult>

        public override void Show();

    public sealed class AddressResult : TaskEventArgs

        public AddressResult();

        public AddressResult(TaskResult taskResult);

        public string Address { get; internal set; }

        public string DisplayName { get; internal set; }

The SaveContactTask shows the user a pre-populated new contact dialogue and will return if the user actually created a new contact or not. For more on how to use this task see MSDN’s How to: Use the Save Contact Task for Windows Phone.

    public sealed class SaveContactTask : ChooserBase<SaveContactResult>

        public override void Show();

        public string FirstName { get; set; }

        public string LastName { get; set; }

        public string MiddleName { get; set; }

        public string Nickname { get; set; }

        public string Suffix { get; set; }

        public string Company { get; set; }

        public string Title { get; set; }

        public string MobilePhone { get; set; }

        public string HomePhone { get; set; }

        public string WorkPhone { get; set; }

        public string PersonalEmail { get; set; }

        public string WorkEmail { get; set; }

        public string OtherEmail { get; set; }

        public string HomeAddressStreet { get; set; }

        public string HomeAddressCity { get; set; }

        public string HomeAddressState { get; set; }

        public string HomeAddressZipCode { get; set; }

        public string HomeAddressCountry { get; set; }

        public string WorkAddressStreet { get; set; }

        public string WorkAddressCity { get; set; }

        public string WorkAddressState { get; set; }

        public string WorkAddressZipCode { get; set; }

        public string WorkAddressCountry { get; set; }

        public string Website { get; set; }

        public string Notes { get; set; }

        public string JobTitle { get; set; }

    public class SaveContactResult : TaskEventArgs

        public SaveContactResult();

        public SaveContactResult(TaskResult taskResult);

Back to the table of contents

Changes and additions to existing Launchers and Choosers

With Mango a few of the existing Launchers and Choosers have received new features. We’ll review these changes in this section.

The MediaPlayerLauncher task can now specify the Orientation of the video player. When trying to playback videos recorded on mobile devices the new portrait setting would be extremely useful.

    public class MediaPlayerLauncher

        public void Show();

        public Uri Media { get; set; }

        public MediaPlaybackControls Controls { get; set; }

        public MediaLocationType Location { get; set; }

        public MediaPlayerOrientation Orientation { get; set; }

    public enum MediaPlayerOrientation

        Landscape,

        Portrait,

The EmailComposeTask now allows develoepers to specify suggested BCC emails and the CodePage to be used in globalization scenarios.

    public sealed class EmailComposeTask

        public void Show();

        public string Body { get; set; }

        public string Bcc { get; set; }

        public string Cc { get; set; }

        public int? CodePage { get; set; }

        public string Subject { get; set; }

        public string To { get; set; }

The EmailResult class which is returned from the EmailAddressChooserTask now also contains a DisplayName and in addition to the email address chosen by the user.

    public class EmailResult : TaskEventArgs

        public EmailResult();

        public EmailResult(TaskResult taskResult);

        public string Email { get; internal set; }

        public string DisplayName { get; internal set; }

The WebBrowserTask now uses a strongly-typed Uri type property instead of a loosely typed String Url property. For any apps upgraded to Mango that use WebBrowserTask there should be a build warning asking you to switch to the new task.

    public sealed class WebBrowserTask

        public void Show();

        [Obsolete("Please use Uri property")]

        public string URL { get; set; }

        public Uri Uri { get; set; }

Back to the table of contents

Secondary Tiles and primary tile improvements

Using the new StandardTileData and adding those the ShellTile.Create() static method it is possible to add secondary tiles that deep link into application.

    public abstract class ShellTileData

        public string Title { get; set; }

    public class StandardTileData : ShellTileData

        public int? Count { get; set; }

        public Uri BackgroundImage { get; set; }

        public string BackContent { get; set; }

        public string BackTitle { get; set; }

        public Uri BackBackgroundImage { get; set; }

    public sealed class ShellTile

        public static void Create(Uri navigationUri, ShellTileData initialData);

        public void Update(ShellTileData data);

        public void Delete();

        public static string ConvertToXMLFormat(string str);

        public Uri NavigationUri { get; }

        public static IEnumerable<ShellTile> ActiveTiles { get; }

An interesting hidden feature of this API is that it allows to also modify the primary tile pinned to the phone home page. So if the application itself is pinned to the homepage it’ll be in the ShellTile.ActiveTiles. That’s extremely useful if you want to add a background image and text to the primary tile. More on that is available on Pavel Yosifovich’s blog post Dynamic Live Tiles in Windows Phone 7.

Another change introduced in Mango is adding an overload for ShellTileSchedule so it can work with secondary tiles. Using this new API it is possible to set an interval in which the secondary tile images are updated from a remote server.

    public class ShellTileSchedule

        public ShellTileSchedule();

        public ShellTileSchedule(ShellTile tileId);

        public void Start();

        public void Stop();

        public UpdateRecurrence Recurrence { get; set; }

        public int MaxUpdateCount { get; set; }

        public DateTime StartTime { get; set; }

        public UpdateInterval Interval { get; set; }

        public Uri RemoteImageUri { get; set; }

For more on secondary tiles see MSDN’s Tiles for Windows Phone.

Back to the table of contents

Mixed XNA and Silverlight apps

With Mango we can now have apps that run both Silverlight content and XNA content. There are two core usecases for this API we need to think about: (1) Adding Silverlight Content (e.g. a menu system) to an XNA game (2) Adding XNA content (e.g. a 3d image) to a Silverlight app. Thinking about these 2 usecases makes it easier to understand the new API introduced for this featureset.

The first step in creating a mixed XNA and Silverlight app is to make sure that SharingMode=True whenever we have mixed content rendering on the screen.

    public static class GraphicsDeviceExtensions

        public static void SetSharingMode(this GraphicsDevice device, bool enabled);

Use the UIElementRenderer to setup Silverlight elements to render in mixed mode.

    public class UIElementRenderer : IDisposable

     public UIElementRenderer(UIElement rootElement, int textureWidth, int textureHeight);

        public void Render();

        protected virtual void Dispose(bool disposing);

        public void Dispose();

        public UIElement Element { get; }

        public Texture2D Texture { get; }

We would also have to invoke the UIElementRenderer.Render() within our game loop. Use the new GamerTimer timer for your game loop in mixed mode apps.

    public sealed class GameTimer : IDisposable

        public static void SuppressFrame();

        public static void ResetElapsedTime();

        public void Start();

        public void Stop();

        public void Dispose();

        public int DrawOrder { get; set; }

        public int FrameActionOrder { get; set; }

        public TimeSpan UpdateInterval { get; set; }

        public int UpdateOrder { get; set; }

        public event EventHandler<GameTimerEventArgs> Draw;

        public event EventHandler<EventArgs> FrameAction;

        public event EventHandler<GameTimerEventArgs> Update;

    public sealed class GameTimerEventArgs : EventArgs

        public GameTimerEventArgs();

        public GameTimerEventArgs(TimeSpan totalTime, TimeSpan elapsedTime);

        public TimeSpan ElapsedTime { get; }

        public TimeSpan TotalTime { get; }

For XNA apps that use GraphicsDeviceManager they’ll need to switch over and use the new SharedGraphicsDeviceManager class.

    public class SharedGraphicsDeviceManager : IGraphicsDeviceService,

                                               IDisposable,

                                               IApplicationService,

                                               IApplicationLifetimeAware

        public static readonly int DefaultBackBufferHeight;

        public static readonly int DefaultBackBufferWidth;

        public void ApplyChanges();

        void IDisposable.Dispose();

        void IApplicationService.StartService(ApplicationServiceContext context);

        void IApplicationService.StopService();

        void IApplicationLifetimeAware.Starting();

        void IApplicationLifetimeAware.Started();

        void IApplicationLifetimeAware.Exiting();

        void IApplicationLifetimeAware.Exited();

        public static SharedGraphicsDeviceManager Current { get; }

        public GraphicsDevice GraphicsDevice { get; }

        public GraphicsProfile GraphicsProfile { get; set; }

        public int MultiSampleCount { get; set; }

        public SurfaceFormat PreferredBackBufferFormat { get; set; }

        public int PreferredBackBufferHeight { get; set; }

        public int PreferredBackBufferWidth { get; set; }

        public DepthFormat PreferredDepthStencilFormat { get; set; }

        public PresentInterval PresentationInterval { get; set; }

        public RenderTargetUsage RenderTargetUsage { get; set; }

        public bool SynchronizeWithVerticalRetrace { get; set; }

        public event EventHandler<EventArgs> DeviceCreated;

        public event EventHandler<EventArgs> DeviceDisposing;

        public event EventHandler<EventArgs> DeviceReset;

        public event EventHandler<EventArgs> DeviceResetting;

        public event EventHandler<EventArgs> Disposed;

For more information on how to setup mixed XNA and Silverlight apps see AppHub’s guide for XNA devs using mixed mode apps, Peter Kuhn’s guide for Silverlight devs using mixed mode apps and AppHub’s sample Paddle Battle game.

Back to the table of contents

LINQ-to-SQL and Local Database

As part of Mango Linq-to-SQL running on SQL CE is now supported. Linq2SQL is huge and contains a lot of classes that are new to WP7. We can’t possibly cover all the API for those classes in this article so we’ll just see a huge class diagram and move on. For more information on the core Linq-to-SQL API see MSDN’s Local Database for Windows Phone.

There are however a few Linq-to-SQL APIs that are WP7 specific and we’ll cover those in a bit more depth. All these Linq2SQL WP7 specific APIs are part of the new Microsoft.Phone.Data.Linq and Microsoft.Phone.Data.Linq.Mapping namespaces.

The DatabaseSchemaUpdater is used to make sure that different versions of the application could upgrade the previously installed databases from older versions. When a database is first created it gets the DatabaseSchemaVersion of 0 or any other value you’d like to give it. It is then possible to use that version number to programmatically add database objects (tables, columns, etc) and update the schema version.

    public sealed class DatabaseSchemaUpdater

        public void AddTable<T>();

        public void AddColumn<T>(string columnPropertyName);

        public void AddIndex<T>(string indexName);

        public void AddAssociation<T>(string associationPropertyName);

        public void Execute();

        public DataContext Context { get; }

        public int DatabaseSchemaVersion { get; set; }

    public static class Extensions

        public static DatabaseSchemaUpdater CreateDatabaseSchemaUpdater(

           this DataContext dataContext);

The next part of WP7 specific Linq-to-SQL API is adding support for database Indexes which doesn’t exist in the desktop version of Linq-to-SQL. This is an important feature since there is no other way to execute DDL (i.e. “create index” statements) on the WP7 SQL CE database. If you expect a high volume of data in a SQL CE Table it’s best to optimize for query scenarios and index the “where” SQL SELECT query columns.

    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]

    public sealed class IndexAttribute : Attribute

        public string Name { get; set; }

        public bool IsUnique { get; set; }

        public string Columns { get; set; }

    public abstract class MetaIndex

        public abstract string IndexName { get; }

        public abstract ReadOnlyCollection<MetaIndexedColumn> Columns { get; }

        public abstract bool IsUnique { get; }

        public abstract MetaType DeclaringType { get; }

    public abstract class MetaIndexedColumn

        public abstract MetaDataMember Column { get; }

        public abstract SortOrder SortOrder { get; }

    public enum SortOrder

        Ascending,

        Descending,

Back to the table of contents

Search Extensibility

If your app has dynamic server data it’s a great idea to expose a few bing consumable XML files on the server that would deep link into your app from the WP7 search. There’s very little new API for the Mango feature that lets WP7 search deep link into apps. The client side changes involve adding the appropriate <Extension> tags to the WmAppManifest and <ExtensionInfo> tags to the Extras file.

Most of the work for this feature would have to happen on the server-side to expose XML files with the appropriate search data and deep links.

For more on this feature see MSDN’s Search Extensibility for Windows Phone.

Back to the table of contents

Sockets: IP and DNS Addresses

Sockets are a pretty large API and most devs will only work with frameworks based on this API. For these reasons we’ll skip the C# definitions for classes in this namespace and instead focus on overall featuresets and class diagrams.

As Sockets are all about direct communication between WP7 and a remote machine DNS and IP addresses classes have been introduced to Mango.

Back to the table of contents

Sockets: DNS Resolution

The DNS resolution API is WP7-specific and is used to convert from a DnsEndPoint (host name and port) to a more specific IPEndPoint that is used by Sockets.

Back to the table of contents

Sockets: Socket class and SocketAsyncEventArgs

The Socket class is used to connect to an IPEndPoint and then send & receive SocketAsyncEventArgs from that Socket.

Back to the table of contents

Sockets: UDP

As part of Silverlight 4 UDP support for single-source and multi-source communication has been added to WP7.

Back to the table of contents

Shell UI: New ProgressIndicator, and changes to ApplicationBar & SystemTray

There are parts of the application UI that are actually part of the OS shell. The top “SystemTray” and the bottom “ApplicationBar” are two such UI elements.

The ApplicationBar class has added support to show the ApplicationBar as collapsed (similar to how it’s shown in the Music & Video hub) and specify the height used for both the default and minimal mode.

    public sealed class ApplicationBar : IApplicationBar

    {
         public ApplicationBar();

         public bool IsVisible { get; set; }

         public double Opacity { get; set; }

         public bool IsMenuEnabled { get; set; }

         public Color BackgroundColor { get; set; }

         public Color ForegroundColor { get; set; }

         public ApplicationBarMode Mode { get; set; }

         public double DefaultSize { get; }

         public double MiniSize { get; }
 
         public IList Buttons { get; }

         public IList MenuItems { get; }

         public event EventHandler<ApplicationBarStateChangedEventArgs> StateChanged;

    public interface IApplicationBar

        bool IsVisible { get; set; }

        double Opacity { get; set; }

        bool IsMenuEnabled { get; set; }

        Color BackgroundColor { get; set; }

        Color ForegroundColor { get; set; }

        ApplicationBarMode Mode { get; set; }

        double DefaultSize { get; }

        double MiniSize { get; }

        IList Buttons { get; }

        IList MenuItems { get; }

        event EventHandler<ApplicationBarStateChangedEventArgs> StateChanged;

    public enum ApplicationBarMode

        Default,

        Minimized,

The SystemTray previously only had an IsVisible property to hide the top bar. The main reason why app developers hid the top bar in apps was due to a theme colour clash. So with Mango you can use your brand colours on the SystemTray by setting the new attached dependency properties. As a reminder a pattern of a static GetFoo, SetFoo and FooProperty members is an attached dependency property pattern.

    public class SystemTray : DependencyObject

        public static readonly DependencyProperty IsVisibleProperty;

        public static readonly DependencyProperty OpacityProperty;

        public static readonly DependencyProperty ForegroundColorProperty;

        public static readonly DependencyProperty BackgroundColorProperty;

        public static readonly DependencyProperty ProgressIndicatorProperty;

        public SystemTray();

        public static void SetIsVisible(DependencyObject element, bool isVisible);

        public static bool GetIsVisible(DependencyObject element);

        public static void SetOpacity(DependencyObject element, double opacity);

        public static double GetOpacity(DependencyObject element);

        public static void SetForegroundColor(DependencyObject element, Color color);

        public static Color GetForegroundColor(DependencyObject element);

        public static void SetBackgroundColor(DependencyObject element, Color color);

        public static Color GetBackgroundColor(DependencyObject element);

        public static void SetProgressIndicator(DependencyObject element,

           ProgressIndicator progressIndicator);

        public static ProgressIndicator GetProgressIndicator(DependencyObject element);

        public static bool IsVisible { get; set; }

        public static double Opacity { get; set; }

        public static Color ForegroundColor { get; set; }

        public static Color BackgroundColor { get; set; }

        public static ProgressIndicator ProgressIndicator { get; set; }

A SystemTray.ProgressBar can be set to show a unified WP7 UI for any in-app process progress taking place (e.g. web requests). An example of how to do so can be found on MSDN’s ProgressIndicator Class.

    public class ProgressIndicator : DependencyObject

        public static readonly DependencyProperty IsVisibleProperty;

        public static readonly DependencyProperty IsIndeterminateProperty;

        public static readonly DependencyProperty TextProperty;

        public static readonly DependencyProperty ValueProperty;

        public ProgressIndicator();

        public bool IsVisible { get; set; }

        public bool IsIndeterminate { get; set; }

        public string Text { get; set; }

        public double Value { get; set; }

Back to the table of contents

Bing Maps changes: Random XAML elements positioning

With Mango the Bing Maps SDK has had only 1 change in it. Attached Dependency properties have been added to the MapPlayer class that allow to position random XAML elements in a latitude and longitude coordinate or relative to the rest of the map.

    public sealed class MapLayer : MapLayerBase, IProjectable

        public static readonly DependencyProperty PositionProperty;

        public static readonly DependencyProperty PositionRectangleProperty;

        public static readonly DependencyProperty PositionOriginProperty;

        public static readonly DependencyProperty PositionOffsetProperty;

        public MapLayer();

        public override void AddChild(UIElement element, GeoCoordinate location);

        public override void AddChild(UIElement element, GeoCoordinate location,

           Point offset);

        public override void AddChild(UIElement element, GeoCoordinate location,

           PositionOrigin origin);

        public override void AddChild(UIElement element, LocationRect locationRect);

        public static GeoCoordinate GetPosition(DependencyObject dependencyObject);

        public static void SetPosition(DependencyObject dependencyObject,

           GeoCoordinate position);

        public static LocationRect GetPositionRectangle(

           DependencyObject dependencyObject);

        public static void SetPositionRectangle(DependencyObject dependencyObject,

           LocationRect rect);

        public static PositionOrigin GetPositionOrigin(

           DependencyObject dependencyObject);

        public static void SetPositionOrigin(DependencyObject dependencyObject,

           PositionOrigin origin);

        public static Point GetPositionOffset(DependencyObject dependencyObject);

        public static void SetPositionOffset(DependencyObject dependencyObject,

           Point point);

        public void ProjectionUpdated(ProjectionUpdateLevel updateLevel);

        public MapBase ParentMap { get; }

Back to the table of contents

Removing Pages from the backstack frame journal

A common requirement in NoDo was to block the automatic frame navigation from navigating back into certain pages (e.g. splash page, registration page, etc). There are a few tricks in NoDo that allowed for a decent UX in the absence of any API for directly controlling the backstack. With Mango it is now possible to remove the last page from the back stack.

    public sealed class NavigationService

        public bool Navigate(Uri source);

        public void GoForward();

        public void GoBack();

        public void StopLoading();

        public JournalEntry RemoveBackEntry();

        public Uri Source { get; set; }

        public Uri CurrentSource { get; internal set; }

        public bool CanGoForward { get; }

        public bool CanGoBack { get; }

        public IEnumerable<JournalEntry> BackStack { get; }

        public event NavigationFailedEventHandler NavigationFailed;

        public event NavigatingCancelEventHandler Navigating;

        public event NavigatedEventHandler Navigated;

        public event NavigationStoppedEventHandler NavigationStopped;

        public event FragmentNavigationEventHandler FragmentNavigation;

        public event EventHandler<JournalEntryRemovedEventArgs> JournalEntryRemoved;

    public sealed class JournalEntry : DependencyObject

        public Uri Source { get; set; }

    public sealed class JournalEntryRemovedEventArgs : EventArgs

        public JournalEntry Entry { get; }

    public class PhoneApplicationFrame : Frame

        public static readonly DependencyProperty OrientationProperty;

        public PhoneApplicationFrame();

        public JournalEntry RemoveBackEntry();

        public PageOrientation Orientation { get; internal set; }

        public IEnumerable<JournalEntry> BackStack { get; }

        public event EventHandler<OrientationChangedEventArgs> OrientationChanged;

        public event EventHandler<ObscuredEventArgs> Obscured;

        public event EventHandler Unobscured;

        public event EventHandler<CancelEventArgs> BackKeyPress;

        public event EventHandler<JournalEntryRemovedEventArgs> JournalEntryRemoved;

Pages can respond to being removed from the back stack by overriding the new OnRemovedFromJournal method.

    public class PhoneApplicationPage : Page

        public static readonly DependencyProperty SupportedOrientationsProperty;

        public static readonly DependencyProperty OrientationProperty;

        public static readonly DependencyProperty ApplicationBarProperty;

        public PhoneApplicationPage();

        protected virtual void OnOrientationChanged(OrientationChangedEventArgs e);

        protected virtual void OnBackKeyPress(CancelEventArgs e);

        protected virtual void OnRemovedFromJournal(JournalEntryRemovedEventArgs e);

        public SupportedPageOrientation SupportedOrientations { get; set; }

        public PageOrientation Orientation { get; set; }

        public IApplicationBar ApplicationBar { get; set; }

        public IDictionary<string, object> State { get; }

        public event EventHandler<OrientationChangedEventArgs> BeginLayoutChanged;

        public event EventHandler<OrientationChangedEventArgs> OrientationChanged;

        public event EventHandler<CancelEventArgs> BackKeyPress;

Back to the table of contents

Device Information and Network Information

The new DeviceStatus class has strongly-typed properties that can be used to replace the older DeviceExtendedProperties and it also has previously unavailable device information properties.

    public static class DeviceStatus

        public static bool IsKeyboardDeployed { get; }

        public static bool IsKeyboardPresent { get; }

        public static PowerSource PowerSource { get; }

        public static long ApplicationCurrentMemoryUsage { get; }

        public static long ApplicationPeakMemoryUsage { get; }

        public static long ApplicationMemoryUsageLimit { get; }

        public static long DeviceTotalMemory { get; }

        public static string DeviceName { get; }

        public static string DeviceFirmwareVersion { get; }

        public static string DeviceHardwareVersion { get; }

        public static string DeviceManufacturer { get; }

        public static event EventHandler KeyboardDeployedChanged;

        public static event EventHandler PowerSourceChanged;

    public enum PowerSource

        Battery,

        External,

The new DeviceNetworkInformation class exposes information about the network status of the mobile device.

    public static class DeviceNetworkInformation

        public static void ResolveHostNameAsync(

            DnsEndPoint endPoint, NetworkInterfaceInfo networkInterface,

            NameResolutionCallback callback, object context);

        public static void ResolveHostNameAsync(DnsEndPoint endPoint,

            NameResolutionCallback callback, object context);

        public static bool IsCellularDataRoamingEnabled { get; }

        public static bool IsWiFiEnabled { get; }

        public static bool IsCellularDataEnabled { get; }

        public static string CellularMobileOperator { get; }

        public static bool IsNetworkAvailable { get; }

        public static event EventHandler<NetworkNotificationEventArgs>

                                                 NetworkAvailabilityChanged;

    public sealed class NetworkNotificationEventArgs : EventArgs

        public NetworkNotificationType NotificationType { get; }

        public NetworkInterfaceInfo NetworkInterface { get; }

The new MediaCapabilities exposes information on whether or not smooth adaptive video streaming is supported on the current device or not.

    public static class MediaCapabilities

        public static bool IsMultiResolutionVideoSupported { get; }

Back to the table of contents

WebBrowser control changes: HTML5 GeoLocation and NavigationFailed event

The WebBrowser control in Mango supports HTML5 GeoLocation after setting IsGeolocationEnabled=True. It also has a new NavigationFailed event.

    public sealed class WebBrowser : Control

        public static readonly DependencyProperty SourceProperty;

        public static readonly DependencyProperty BaseProperty;

        public static readonly DependencyProperty IsScriptEnabledProperty;

        public static readonly DependencyProperty IsGeolocationEnabledProperty;

        public WebBrowser();

        public override void OnApplyTemplate();

        public void Navigate(Uri uri);

        public void Navigate(Uri uri, byte[] postData, string additionalHeaders);

        public void NavigateToString(string html);

        public object InvokeScript(string scriptName, params string[] args);

        public object InvokeScript(string scriptName);

        public string SaveToString();

        public Uri Source { get; set; }

        public string Base { get; set; }

        public bool IsScriptEnabled { get; set; }

        public bool IsGeolocationEnabled { get; set; }

        public event EventHandler<NavigatingEventArgs> Navigating;

        public event EventHandler<NavigationEventArgs> Navigated;

        public event LoadCompletedEventHandler LoadCompleted;

        public event NavigationFailedEventHandler NavigationFailed;

        public event EventHandler<NotifyEventArgs> ScriptNotify;

Back to the table of contents

Network Request Preference and Requirements

The new WebRequestExtensions and SocketExtensions classes define extension methods that can be used to associate a specific network interface (e.g. 3G vs. WiFi) with specific network requests.

    public static class WebRequestExtensions

        public static void SetNetworkPreference(this WebRequest request,

            NetworkSelectionCharacteristics preference);

        public static void SetNetworkRequirement(this WebRequest request,

            NetworkSelectionCharacteristics requirement);

        public static NetworkInterfaceInfo GetCurrentNetworkInterface(

            this WebRequest request);

    public static class SocketExtensions

        public static void SetNetworkPreference(this Socket socket,

             NetworkSelectionCharacteristics preference);

        public static void SetNetworkRequirement(this Socket socket,

             NetworkSelectionCharacteristics requirement);

        public static NetworkInterfaceInfo GetCurrentNetworkInterface(

             this Socket socket);

        public static void AssociateToNetworkInterface(this Socket socket,

             NetworkInterfaceInfo networkInterface);

Back to the table of contents

Xbox Live: Render Xbox Live Avatars in XNA

With the introduction of Microsoft.Xna.Framework.Avatar assembly it is now possible for Xbox Live Titles to render Xbox Live Avatars using the new AvatarRenderer class. Note, only Xbox Live Titles can use this functionality. Because of that limited subset of apps that have access to this functionality and because of the sheer size of the new assembly we’ll only briefly glance at a class diagram and move on.

Back to the table of contents

Xbox Live: Avatar Assets

Xbox Live-titles (and only xbox live titles) can now take advantage of the new SignedInGamerExtensions and award assets to Xbox Live Avatars. Again, this feature is only available for Xbox-Live titles.

    public static class SignedInGamerExtensions

        public static IAsyncResult BeginAwardAvatarAssets(this SignedInGamer gamer,

            string[] assetKeys, AsyncCallback callback, object state);

        public static void EndAwardAvatarAssets(this SignedInGamer gamer,

            IAsyncResult result);

        public static void AwardAvatarAssets(this SignedInGamer gamer,

            string[] assetKeys);

Back to the table of contents

Custom Linq Providers

A core piece of LINQ that has been missing from NoDo was the ability to create custom Linq Providers. With Mango the IQueryProvider and IQueryable interfaces have been added. With the new support for custom LINQ providers it is now possible to use one of the many open source LINQ providers. for more on implementing a custom LINQ provider and the importance of IQueryProvider see Matt Warren’s LINQ: Building an IQueryable Provider.

    public interface IQueryProvider

        IQueryable CreateQuery(Expression expression);

        IQueryable<TElement> CreateQuery<TElement>(Expression expression);

        object Execute(Expression expression);

        TResult Execute<TResult>(Expression expression);

    public interface IQueryable : IEnumerable

        Expression Expression { get; }

        Type ElementType { get; }

        IQueryProvider Provider { get; }

The additional classes of EnurableQuery, EnurableQuery<T>, EnurableExecutor, EnumrableExecutor<T> and Queryable are all helper classes used when implementing a custom LINQ provider. We won’t expend on them further in this blog post.

Back to the table of contents

Dynamically compiled Lambda Expressions and Reflection.Emit

A small chunk of Refleciton.Emit has been added to Mango in order to enable the Expression.Compile() method. Using Expression.Compile() it is possible to build at runtime an expression tree, compile it and then execute it. All at runtime. We’ll only examine the change to LambdaExpression in greater detail. For more information on this topic see MSDN’s Expression(TDelegate).Compile Method.

    public class LambdaExpression : Expression

        public Delegate Compile();

        public Expression Body { get; }

        public ReadOnlyCollection<ParameterExpression> Parameters { get; }

Back to the table of contents

mscorib.Extensions: SIMD/ARM-NEON XNA support

Mango allows to accelerate calculation operations on SIMD/ARM-NEON capable devices. Which means that XNA calculations on Vector, Matrix and other types would be somewhat faster. To take advantage of this new feature apply the attribute wit he SIMD flag on the relevant assemblies. For more on this see Enable SIMD support in Mango.

    [AttributeUsage(AttributeTargets.Assembly)]

    public sealed class CodeGenerationAttribute : Attribute

        public CodeGenerationAttribute(CodeGenerationFlags flags);

        public int CodeGenerationFlags { get; }

    [Flags]

    public enum CodeGenerationFlags

        EnableFPIntrinsicsUsingSIMD = 1,

Back to the table of contents

mscorlib.Extensions: Mutex

A trimmed down version of Mutex wait handle class has been added to Mango.

    public sealed class Mutex : WaitHandle

        public Mutex(bool initiallyOwned, string name);

        public void ReleaseMutex();

        public override bool WaitOne();

        public override bool WaitOne(int millisecondsTimeout);

Back to the table of contents

mscorlib.Extensions: INotifyPropertyChanging

The INotifyProperyChanging interface has been added as part of Mango. This API is the counterpart for the existing INotifyPropertyChanged interface. Currently the only feature using this new interface is Linq-to-SQL, but we could definitely take advantage of it for other 3rd party usages. For more on that see Claus Konrad’s WP7/7.1: Where is INotifiyPropertyChanging defined?.

    public interface INotifyPropertyChanging

        event PropertyChangingEventHandler PropertyChanging;

    public delegate void PropertyChangingEventHandler(object sender,

         PropertyChangingEventArgs e);

    public class PropertyChangingEventArgs : EventArgs

        public PropertyChangingEventArgs(string propertyName);

        public virtual string PropertyName { get; }

Back to the table of contents

mscorlib.Extensions: RSA Cryptography

With Mango the RsaCryptoServiceProvider has been added to enable asymmetric encryption and decryption. For more information on how to use RsaCryptoServiceProvider with a custom server backend see Dustin Horne’s Asymmetric Encryption and Signing with RSA in Silverlight.

Back to the table of contents

Silverlight 4: Base-Class Library changes in mscorlib assembly

WP7 NoDo was based on Silverlight 3. With the release Mango all the changes done in Silverlight 4 were migrated back to WP7. Most of the changes are in the System.Windows assembly (Silverlight) and the majority of other changes are in the mscorlib BCL (base class library) assembly. All the changes made in Silverlight 4 to the BCL were additions of new members to existing classes. The one exception to that is the removal of the TaiwanCalender class from Mango. The class diagram and code snippets below contain only the new members added to the BCL in Mango.

    public sealed class AppDomain

        public Assembly[] GetAssemblies();

    public static class BitConverter

        public static Int64 DoubleToInt64Bits(Double value);

        public static Double Int64BitsToDouble(Int64 value);

    public static class GC

        public static Int32 MaxGeneration { get; }

    public sealed class Guid

        public static Guid Parse(String input);

        public static Guid ParseExact(String input, String format);

        public static Boolean TryParse(String input, out Guid result);

        public static Boolean TryParseExact(String input, String format, out Guid result);

    public sealed class String

        public static String Concat(IEnumerable<String> values);

        public static String Concat<T>(IEnumerable<T> values);

        public static Boolean IsNullOrWhiteSpace(String value);

        public static String Join(String separator, IEnumerable<String> values);

        public static String Join<T>(String separator, IEnumerable<T> values);

        public static String Join(String separator, params Object[] values);

    public sealed class TimeSpan

        public String ToString(String format);

        public String ToString(String format, IFormatProvider formatProvider);

        public static TimeSpan Parse(String input, IFormatProvider formatProvider);

        public static TimeSpan ParseExact(String input, String[] formats,

            IFormatProvider formatProvider);

        public static TimeSpan ParseExact(String input, String format,

            IFormatProvider formatProvider);

        public static TimeSpan ParseExact(String input, String format,

            IFormatProvider formatProvider, TimeSpanStyles styles);

        public static TimeSpan ParseExact(String input, String[] formats,

            IFormatProvider formatProvider, TimeSpanStyles styles);

        public static Boolean TryParse(String input,

            IFormatProvider formatProvider, out TimeSpan result);

        public static Boolean TryParseExact(String input, String format,

            IFormatProvider formatProvider, out TimeSpan result);

        public static Boolean TryParseExact(String input, String[] formats,

            IFormatProvider formatProvider, out TimeSpan result);

        public static Boolean TryParseExact(String input, String format,

            IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result);

        public static Boolean TryParseExact(String input, String[] formats,

            IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result);

    public abstract class Type

        public Boolean IsNested { get; }

    public sealed class Version

        public static Version Parse(String input);

        public static Boolean TryParse(String input, out Version result);

    public interface ISymbolDocumentWriter

        void SetCheckSum(Guid algorithmId, Byte[] checkSum);

        void SetSource(Byte[] source);

    [FlagsAttribute]

    public enum TimeSpanStyles

        None,

        AssumeNegative

    public class FileStream : Stream, IDisposable

        public virtual void Flush(Boolean flushToDisk);

    public abstract class Stream : IDisposable

        public void CopyTo(Stream destination);

        public void CopyTo(Stream destination, Int32 bufferSize);

    public sealed class IsolatedStorageFile : IDisposable

        public void CopyFile(String sourceFileName, String destinationFileName);

        public void CopyFile(String sourceFileName, String destinationFileName,

            Boolean overwrite);

        public DateTimeOffset GetCreationTime(String path);

        public DateTimeOffset GetLastAccessTime(String path);

        public DateTimeOffset GetLastWriteTime(String path);

        public void MoveDirectory(String sourceDirectoryName,

             String destinationDirectoryName);

        public void MoveFile(String sourceFileName, String destinationFileName);

    public class IsolatedStorageFileStream : FileStream

        public override void Flush(Boolean flushToDisk);

    public sealed class StringBuilder

        public StringBuilder Clear();

    public static class Interlocked

        public static Object CompareExchange(ref Object location1, Object value,

            Object comparand);

    public static class Monitor

        public static void Enter(Object obj, ref Boolean lockTaken);

        public static void TryEnter(Object obj, ref Boolean lockTaken);

        public static void TryEnter(Object obj, TimeSpan timeout, ref Boolean lockTaken);

        public static void TryEnter(Object obj, Int32 millisecondsTimeout,

            ref Boolean lockTaken);

Back to the table of contents

Silverlight 4: System.Windows Silverlight changes

Silverlight 4 is it’s own product release and quite an extensive one at that. We’ll briefly cover the new API added to the System.Windows assembly as part of the Mango upgrade to Silverlight 4. For those of you interested in more details on Silverlight 4 changes from Silverlight 3 see Tim Heuer’s Silverlight 4 Beta – A guide to the new features. Please note, the API we’ll see in this section is the API that was added in Mango and not all the API in these classes.

In the System.Collections.ObjectModel namespace we’ve got new constructors for the ObservableCollection class that allow to easy convert a standard List<T> to an ObservableCollection<T>.

    public class ObservableCollection<T>

        public ObservableCollection<T>(List list);

        public ObservableCollection<T>(IEnumerable collection);

In the System.ComponentModel namespace we’ve got a few new APIs for databinding and some additions to design-time.

    public sealed class AlternateContentPropertyAttribute : Attribute

        public AlternateContentPropertyAttribute();

    public sealed class DataErrorsChangedEventArgs : EventArgs

        public DataErrorsChangedEventArgs(String propertyName);

        public String PropertyName { get; }

    public static class DesignerProperties

        public static Boolean RefreshOnlyXmlnsDefinitionsOnAssemblyReplace

            get;

    public interface ICollectionViewFactory

        ICollectionView CreateView();

    public interface IDataErrorInfo

        String Error { get; }

        String this[String columnName] { get; }

    public interface IEditableCollectionView

        Boolean CanAddNew { get; }

        Boolean CanCancelEdit { get; }

        Boolean CanRemove { get; }

        Boolean IsAddingNew { get; }

        Boolean IsEditingItem { get; }

        NewItemPlaceholderPosition NewItemPlaceholderPosition { get; set; }

        Object CurrentAddItem { get; }

        Object CurrentEditItem { get; }

        Object AddNew();

        void CancelEdit();

        void CancelNew();

        void CommitEdit();

        void CommitNew();

        void EditItem(Object item);

        void Remove(Object item);

        void RemoveAt(Int32 index);

    public interface INotifyDataErrorInfo

        Boolean HasErrors { get; }

        IEnumerable GetErrors(String propertyName);

        event EventHandler ErrorsChanged;

    public interface ISupportInitialize

        void BeginInit();

        void EndInit();

    public enum NewItemPlaceholderPosition

        None,

        AtEnd

There are quite a bit of peer automation related changes in the System.Windows.Automation.* namespaces, but since Automation Peers are not supported on WP7 there’s no point in going over those in any great detail.

In the System.Windows namespace we have a few changes: Support for the new Tap & Hold & DoubleTap events, programmatic control of the Clipboard, Right-To-Left support and a few others. There are also a few “junk” changes to support features that aren’t supported in Mango and we won’t review those here.

    public static class Clipboard {

        public static Boolean ContainsText();

        public static String GetText();

        public static void SetText(String text);

    public class DependencyObjectCollection<T>

        public virtual sealed Int32 IndexOf(T item);

        public virtual sealed void Insert(Int32 index, T item);

        public event NotifyCollectionChangedEventHandler CollectionChanged;

    public enum FlowDirection {

        LeftToRight,

        RightToLeft

    public abstract class FrameworkElement : UIElement {

        public FlowDirection FlowDirection { get; set; }

        public static readonly DependencyProperty FlowDirectionProperty;

    public abstract class UIElement : DependencyObject

        public event EventHandler DoubleTap;

        public event EventHandler Hold;

        public event EventHandler Tap;

        public event TextCompositionEventHandler TextInput;

        public event TextCompositionEventHandler TextInputStart;

        public event TextCompositionEventHandler TextInputUpdate;

        public static readonly DependencyProperty AllowDropProperty;

        public static readonly RoutedEvent DoubleTapEvent;

        public static readonly RoutedEvent HoldEvent;

        public static readonly RoutedEvent TapEvent;

        public static readonly RoutedEvent TextInputEvent;

        public static readonly RoutedEvent TextInputStartEvent;

        public static readonly RoutedEvent TextInputUpdateEvent;

    public sealed class VisualStateGroup : DependencyObject

        public VisualState CurrentState { get; }

The System.Windows.Controls and System.Windows.Controls.Primitives namespace has a few changes in it: The new ViewBox control, addition of ellipsis (“…”) text trimming to TextBlock, MVVM Button Commanding support, Video playback MediaElement timed markers and a few other features. The really interesting changes here is the introduction of a WP7 API for ScrollViewer.ManipulationMode for fine-tuned scrolling support on the phone. The ScrollViewer additions are exclusive to WP7 Mango.

    public class ListBox

        public void SelectAll();

    public sealed class MediaElement : FrameworkElement

        public TimelineMarkerCollection Markers { get; }

        public event TimelineMarkerRoutedEventHandler MarkerReached;

    public sealed class PasswordBox : Control

        public Double BaselineOffset { get; }

    public sealed class ScrollViewer : ContentControl

        public ManipulationMode ManipulationMode { get; set; }

        public static ManipulationMode GetManipulationMode(DependencyObject element);

        public static void SetManipulationMode(DependencyObject element,

            ManipulationMode manipulationMode);

        public static readonly DependencyProperty ManipulationModeProperty;

    public enum ManipulationMode

        Control,

        System

    public sealed class TextBlock

        public Double BaselineOffset { get; }

        public TextTrimming TextTrimming { get; set; }

        public static readonly DependencyProperty TextTrimmingProperty;

    public class TextBox : Control

        public Double BaselineOffset { get; }

    public sealed class Viewbox : FrameworkElement

        public Viewbox();

        public Stretch Stretch { get; set; }

        public StretchDirection StretchDirection { get; set; }

        public UIElement Child { get; set; }

        public static readonly DependencyProperty StretchDirectionProperty;

        public static readonly DependencyProperty StretchProperty;

    public enum StretchDirection

        UpOnly,

        DownOnly,

        Both

In System.Windows.Documents a new RichTextBox control and many supporting classes have been added. We won’t review this control and it’s associated classes in-depth. For more information on this control see MSDN’s RichTextBox Overview.

In System.Windows.Data namespace there’s really one thing we care about: The addition of 5 new properties to the {Binding} syntax. There’s also a few other “junk” changes that aren’t applicable for WP7. which we won’t review here.

    public class Binding : BindingBase

        public Boolean ValidatesOnDataErrors { get; set; }

        public Boolean ValidatesOnNotifyDataErrors { get; set; }

    public abstract class BindingBase

        public Object FallbackValue { get; set; }

        public Object TargetNullValue { get; set; }

        public String StringFormat { get; set; }

A big part of the changes done in System.Windows.Media namespace is around the introduction of VideoSink and AudioSink. In WP7 these provide access to the Microphone and Camera which are available through more phone specific APIs so it’s best to avoid these if possible.

There are few interesting changes in the System.Windows.Media namespace: support for Playready DRM DomainAcquirer, support for RichTextBox support for all fonts, The VideoBrush and a VisualTreeHelper.GetOpenPopups() method.

    public class DomainAcquirer

        public DomainAcquirer();

        public String ChallengeCustomData { get; set; }

        [SecuritySafeCriticalAttribute]

        public void CancelAsync();

        public void JoinDomainAsync(Guid serviceId, Guid accountId, Uri domainServerUrl,

            String friendlyName);

        public void LeaveDomainAsync(Guid serviceId, Guid accountId, Uri domainServerUrl);

        public event EventHandler JoinDomainCompleted;

        public event EventHandler LeaveDomainCompleted;

        protected virtual void OnCancel();

        protected virtual void OnJoinDomain(Stream joinChallenge, Uri domainServerUri);

        protected virtual void OnLeaveDomain(Stream leaveChallenge, Uri domainServerUri);

        protected void SetJoinDomainResponse(Stream domainResponse);

        protected void SetLeaveDomainResponse(Stream domainResponse);

    public class DomainOperationCompletedEventArgs : AsyncCompletedEventArgs

        public Guid AccountId { get; }

        public Guid ServiceId { get; }

        public String ResponseCustomData { get; }

    public static class Fonts

        public static ICollection SystemTypefaces { get; }

    public class Typeface

        public Boolean TryGetGlyphTypeface(out GlyphTypeface glyphTypeface);

    public sealed class GlyphTypeface

        public Double Version { get; }

        public String FontFileName { get; }

    public sealed class VideoBrush : TileBrush

        public VideoBrush();

        public String SourceName { get; set; }

        public void SetSource(CaptureSource source);

        public void SetSource(MediaElement source);

        public static readonly DependencyProperty SourceNameProperty;

    public static class VisualTreeHelper

        public static IEnumerable GetOpenPopups();

The System.Windows.Input namespace has a few interesting additions as-well: 2 new input scopes have been added, fine-grained control of IME (use of Latin keyboards for Asian languages input) and a few other changes.

    public sealed class GestureEventArgs : RoutedEventArgs

        public GestureEventArgs();

        public Boolean Handled { get; set; }

        public Point GetPosition(UIElement relativeTo);

    public enum ImeConversionModeValues

        Alphanumeric,

        Native,

        Katakana,

        FullShape,

        Roman,

        CharCode,

        NoConversion,

        Eudc,

        Symbol,

        Fixed,

        DoNotCare

    public sealed class InputMethod : DependencyObject

        public static ImeConversionModeValues GetPreferredImeConversionMode(

            DependencyObject target);

        public static InputMethodState GetPreferredImeState(

            DependencyObject target);

        public static void SetPreferredImeConversionMode(

            DependencyObject target, ImeConversionModeValues value);

        public static void SetPreferredImeState(

            DependencyObject target, InputMethodState value);

    public enum InputMethodState

        Off,

On,

        DoNotCare

    public enum InputScopeNameValue

        NumericPassword,

        Formula

Back to the table of contents

Feedback? Leave a comment!

Feedback? Thoughts? Suggestions? Sound off in the comments!

Sincerely,

-- Justin Angel, Principal Engineer @ Nokia WP7

MetroBlog: Windows8 Metro Styled Blog

Hi folks,

As you might have noticed my blog has undergone a metamorphosis and is now Windows 8 Metro style inspired. It’s also no longer in Silverlight.

What are the top 2 features of this blog?

One of the top two features I’m quite excited about is a home page with flipping tiles. If you haven’t seen it yet head on over to http://JustinAngel.net and have a look.

Another feature I’m quite enamored with are the interactive sidebar charms:

What’s the complete featurelist?

Posting from Windows Live Writer
Tiles Home Page

Flipping animation
TwitPic Tiles
Twitter tile
Article Tile with Topsy Counter
Category Tiles

Sliding Charms Sidebar

Sliding animation
Social Networks Sharing
Interactive Search
Inline Feeds
Contact details

Metro Inspired UI pages

Home Page
Category List
Articles

Hierarchal article comments
Back office Management
RSS 2.0 and Atom 1.0 Feeds
User Friendly URLs
SEO: Site Map and Robots.txt
Google Analytics
Full Source code

What technologies were used?

ASP.Net MVC3 Razor View Engine: User interface front end.

ASP.Net Dynamic Data: The back office management portal.

HeadJS: Used to load Javascript files in parallel and add HTML5 cross-browser support with some poly-fills.

jQuery: Javascript minimum bar.

jQuery.Templates: Used to render hierarchical comments at the client side.

jQuery.Validate: Used to validate comments at the client side.

jQuery.QuickFlip: Used to create the flipping home page tiles.

jQuery.highlightText: Used to highlight text during searches.

SQL Server 2008: Database.

Entity Framework: Database OR/M.

MSTest: Unit testing framework.

RhinoMocks: Unit Test mocking.

Unity: Inversion of control framework.

WCF Syndication Services: RSS 2.0 and Atom 1.0 feeds.

Starbucks: Supplier of caffeine.

What happened to your Silverlight blog?

I consider my online presence to be a playground I can use to experiment with. It’s all about trying new things and figuring out what works and what doesn’t. I consider my Silverlight blog to be a huge success, it worked for 2 years and with the exception of some minor justifiable UX complaints I really liked it.

You shouldn’t read anything into my personal technology choices. I rewrote this blog because I felt like it.

Feel free download the Silverlight Weblog @ http://silverlightweblog.codeplex.com/

Is MetroBlog open source?

Yes it is. The source code is open source under MS-PL and can be downloaded from codeplex @ http://MetroBlog.codeplex.com

Tell me more about your home page tiles…

The home page actually displays data from multiple data sources (Blog posts, Twitter, TwitPic and Topsy). And by using flipping tiles I’m able to convey more data in the same screen real-estate.

Over here you can see where the latest blog posts come from:

And the Twitter counter comes from http://topsy.com.

Next we’ve got the Category tiles for the home page:

Another data source is TwitPic showing the latest TwitPics on my account:

And finally there’s a tile with my latest tweet:

The combination of that rich data in a cohesive UX is something that I’m quite happy about.

Thank You!

I’d like to thank the beta testers who helped make this blog significantly better.

I’d also like to thank every single open source developer who contributed to the frameworks I’m using.

Comments? Thoughts? Feedback? Something sucks?

Sound off in the comments! Please, I really could use your feedback.

Sincerely,

-- Justin Angel

Reverse Engineering and Modifying Windows 8 apps

Hi folks,

In this article I’ll share the results of ad-hoc security vulnerabilities research I’ve done on windows 8 apps deployment. Specifically, we’ll discuss fundamental design flaws that allow to Reverse Engineer Win8 apps, modification of installed apps and the negative implications on Intellectual Property rights protection, Licensing models and overall PC security. Finally we’ll discuss some creative ideas on how to mitigate these security issues.

Meet the mother-load: C:\Program Files\Applications

All Windows 8 applications in the developer preview are installed under the clandestine C:\Program Files\Applications location. I will hazard a guess and say that once the Windows App Store goes online it will install all apps under that folder. Currently the folder is an invisible one and cannot be accessed from Windows Explorer user interface on a new Win8 developer preview install.

Here’s an example of some of the 29 apps Win8 apps installed on the Win8 developer preview:

And here’s the hidden folder backing it up:

Gaining Access to C:\Program Files\Applications

In essence you’ll need to navigate to that folder, hit “Security Tab” and set yourself up as the owner. Let me walk you through that process step-by-step.

1. Type in “C:\Program Files\Applications” in the Windows Explorer address bar and hit enter.

2. Observe in shock and dismay the system dialogue saying you don’t own a folder on your own machine. Hit “Continue”.

3. After hitting “Continue”, you’ll be confronted by the following dialogue:

Do not hit “close”, instead click the “security tab” link.

4. In the following system dialogue click “advanced”.

5. Click the “change” link in the owner security field.

6. Add in your live ID or windows 8 user name to the “select user or group” system dialogue.

7. Click “OK”, Click “OK”, Click “Ok”.

8. Type in “C:\Program Files\Applications” in the Windows Explorer address bar and hit enter. You now have access to the Applications folder.

What type of apps ship with Windows 8?

Looking at this folder it’s fairly easy to determine what type of apps ship with Windows 8 developer preview.

What’s in C:\Program Files\Applications?

For HTML apps the folder contains all of their source code and it can modified.

For C# apps the folder contains the XAML source code and a compiled reverse-engineerable and modifiable version of the C# code.

For C++ directX apps the folder contains compiled binaries. Honestly, C++ isn’t my specialty so I’ll avoid discussing it at any great length.

Reverse Engineering HTML & Javscript & CSS Win8 apps

There’s a fundamental design flaw in the concept of HTML apps. HTML, Javascript and CSS are all interpreted languages, and not compiled languages. Meaning you have to ship the source code for your app instead of shipping compiled binaries. That puts the Intellectual Property of anyone choosing to write any HTML & JS & CSS only app for any platform under risk.

For example, here’s the HTML source code for the Tweet@rama Win8 app code:

And here’s the tweet@rama Javascript code that does the actual posting to Twitter:

Modifying HTML & Javscript & CSS Win8 apps

Part of the problem with interpreted languages is that they don’t compile until the very instance they are executed. Which allows evil-doers to edit the code prior to execution.

For example, here’s a print screen of the tweet@rama default app;

Let’s modify the HTML, Javascript and CSS for this application: (for the sake of brevity we’ll only walkthrough a simple HTML change)

By modifying the HTML & CSS & Javascript source code we can change the visual design to something a bit more visually pleasing:

Notice that we’ve changed both the design and behaviour of the app by modifying the source code. The new design has a different title, and the new behaviour is using the picture of the logged in user as the background. We have the power to completely change both the visual design and the executing source code of HTML & CSS & JS win8 apps.

New breed of viruses?

Any unauthorized malware that gains access to C:\Program Files\Applications could potentially modify source code to execute in malicious ways. Since this is the direction Win8 apps are taking writing this type of viruses is likely to become a growth industry.

For example we could look at the tweet@rama app once again. The most valuable asset that app has is our twitter oauth credentials. A virus would be able to modify the tweet@rama source code so once it executes it retrieves those credentials and sends those to a malicious remote endpoint. The following code interjected into the Javascript code of tweet@rama would do just that:

New breed of cracks?

Any unauthorized executable that gains access to C:\Program Files\Applications could potentially modify source code to workaround Windows Store app purchasing and licensing logic. The whole concept of Trials and feature purchases are based on Javascript, C# or C++ code invoking Windows 8 RuntimeTime APIs for the Windows Store. Any change to that code could potentially change the purchasing and licensing logic for that app.

For example, In BUILD conference Microsoft’s Arik Cohen demonstrated (35:25) the following code that performs a Javascript check for isTrial.

It would be a trivial endavour to manually edit this Javascript file and remove the “licenseInformation.isTrial” check. And by doing so removing Trial restrictions from this sample Win8 app.
If this set of problems are not mitigated, app piracy through app modification for Windows Store apps will likely become quite prevalent.

Reverse Engineering C# + XAML Win8 apps

C# code is shipped in compiled EXE & DLL binaries. XAML is shipped as plain text source code. That makes both forms of code extremely susceptible to reverse engineering.

For example, we could open up the “Memories” (C# WinRT XAML app) MainPage.xaml in KaXaml and see the XAML source code:

Using JetBrains dotPeek it would be possible to see the C# source code for the Memories app:

Modifying C# + XAML Win8 apps

The XAML for Win8 apps is stored in plain-text and can be edited from any text editing tool. The .net binaries are unsigned and thus can be edit using the MSIL Weaving tool Reflexil.

For example, here’s the “Memories” C# XAML app shipping with Windows 8 developer preview:

Editing the XAML is fairly trivial since it’s stored as a plain text file:

Editing C# can be done using Reflector’s Reflxil MSIL Editor:

With some light modifications to the XAML and C# code we can change the display and behaviour of the app:

Reverse Engineering C++ Win8 apps

I’ll confess to not being a strong C++ developer (gasp!) so I’ll keep this brief by showing C++ apps are also susceptible to reverse engineering. It appears that Microsoft’s Store app is written in C++. The most important asset that app would have are the endpoints for the Microsoft store. Opening the C:\Windows\System32\WinStore\WinStoreUI.dll in notepad and searching for “https” addresses reveals the following URL:

Following the http://go.microsoft.com/fwlink/?LinkId=195322&clcid=0x409 URL leads to a currently inactive URL of https://services.apps.microsoft.com/browse. I would hazard a guess that this is the URL currently being used to test the Windows App Store.

What have we conclusively proven during this blog post?

Keeping in mind that Windows 8 is only an alpha developer release, we’ve seen a couple of disturbing things:

It is possible to reverse engineer and modify HTML, JavaScript and CSS code shipped in Win8 apps.
It is possible to reverse engineer and modify C#/VB.Net source code shipping with Win8 apps.
It is possible to reverse engineer and modify XAML source code shipping with Win8 apps.
It is possible to (at some limited level?) reverse engineer C++ Win8 apps.

Can Microsoft completely solve this problem?

No. In my opinion, apps shipping as part of all app stores will always be vulnerable at some limited level to reverse engineering and modification.

Can Microsoft mitigate this problem?

Yes, Microsoft can make apps significantly more temper-proof and pile a lot of hardships on those seeking to reverse engineer and modify Win8 apps. Assuming malicious code and people can’t access C:\Program Files\Applications seems naïve at best.

Here are few suggestions for what some of those potential aforementioned hardships might be:

Obfuscate C#/VB.Net projects by default: .net projects default to shipping with unobfuscated source code. If Microsoft is serious about introducing a Windows App store obfuscation has to be turned on by default for all .net project, not just a nice-to-have addon like it is right now. The VS2011 team should investigate and integrate an obfuscation solution directly into the product and turn it on for all new .net projects. This would make it harder to reverse engineer .net apps.
Minify HTML, Javascript and CSS projects by default: With the joys of desktop deployment web developers will likely forsake Javascript, HTML and CSS minification. Again, a good path forward here is to make sure all HTML, Jacascript and CSS code is minified by default. This step would make it harder to reverse engineer HTML apps.
Strongly sign all .net assemblies by default: Strong-signing has been part of the .net framework for 10 years now. Turn it on by default with a unique developer license certificate for all Win8 .net apps. Make sure Win8 AppContainers only run signed apps, don’t even have a hidden registry key to enable unsigned apps (like WP7 does). That would make it harder to modify .net apps.
Checksum HTML, Javascript and CSS project before startup: Even if it’s unpreventable that modifying Win8 HTML apps would take place, run a checksum on all files before loading the app into memory. That would make it harder to modify Win8 HTML apps. It sounds like AppBlockMap.xml is supposed to do something similar, but it doesn’t seem to work.
Don’t store App’s executing files as plain-old files on the user’s hard-drive: It shouldn’t be possible to even see the files shipping with an app by default using just Windows Explorer. A lossless compressed folder with DRM protection would be a good step forward here. This should make it harder to reverse engineer Win8 apps.

tl;dr: If Microsoft doesn’t undertake the aforementioned steps or comparable ones it’s not because it can’t, it’s because it doesn’t want to. If Microsoft chooses to ignore this problem for the remaining one year (?) development lifecycle for Windows 8 then it’s not because it couldn’t solve these problems.

Visual Studio 2011 App Deployment

Apps deployed by Visual Studio 2011 do not get deployed to C:\Program Files\Applications but rather get deployed to C:\Users\<UserName>\AppxLayouts.

The alternate location for Visual Studio app deployment and all other app deployment are controlled by the registry folder HKEY_CURRENT_USER\Software\Classes\Local Settings\Software\Microsoft\Windows\CurrentVersion\AppModel.

Feedback

Have questions about the methodologies used in this article?
Have more interesting workarounds you’ve tried and like to share?
Have interesting suggestions for the Microsoft folks on how to help mitigate this problem?

Sound off in the comments!

-- Justin Angel

(Disclaimer: this article represents research I undertook on my own and is unsanctioned by any organizations or corporations I might be related with.)

Windows Phone 7 Marketplace Statistics

Hi folks,

We’re all on constant voyage to better understand Windows Phone 7 and its delicate Consumer<->Developer balance. As part of that education I’ve download all Windows Phone 7 marketplace XAPs, performed analysis on them and am now sharing statistics with you.

Downloading the WP7 Marketplace

Some of you must be thinking to yourselves “Self, how exactly did Justin download all WP7 XAPs? And is that ‘ethical’?". For the last year or so it’s been well known among WP7 developers that the WP7 marketplace API allows to freely download XAPs. By employing basic network profiling on the Zune Desktop client it’s possible to find the endpoints allowing users to download XAPs.

WPCentral did an article on the topic, and so has WMPowerUser.

Using the techniques described by Brandon Watson’s “Crawling the Windows Phone Marketplace” blog post and Den Delimarsky’s “Windows Phone Marketplace (free apps) in your pocket” blog post I downloaded the entire WP7 marketplace to my local machine for the purpose of producing statistics.

Is the Marketplace API permanently public?

No. Starting with Mango all WP7 XAPs downloaded from the Zune Catalogue are going to be DRM encrypted. So, Mid-August was a great time to start downloading the marketplace and perform freeform analytics. In the Mango versions of the Zune Catalogue XAPs are still downloadable, but cannot be explored since they’re DRM protected.

I suspect this blog post is going to be the first and last independent analysis performed by a 3rd party on the Windows Phone 7 marketplace.

Statistic #0: How Many apps in the marketplace?

We often here numbers on the quantity of the overall Windows Phone 7 Marketplace. Latest numbers shared on a multitude of websites called out 30,000+ apps in the WP7 marketplace. Unfortunately, I could not locate all these apps through the Zune Catalogue. That means that either everyone has the wrong number, or I did something wrong.

In this blog post we will only be analyzing 24,505 applications available on August 14th 2011. Those are either all WP7 apps, or these are hopefully a representative sample group of the entire WP7 marketplace. One option is that the WP7 marketplace has 6,000 apps than previously publicized by 3rd parties.

Statistic #1: Obfuscated Apps vs. Not obfuscated apps

Since the current WP7 marketplace allows downloading XAPs you might ask yourself “Hey myself, Justin is making me uncomfortable. My apps aren’t obfuscated. Am I alone?”. Rest assured that you are in-fact not alone and ~~97%~~ 85.5% of Marketplace apps aren’t obfuscated. For those unaware Obfuscation is essentially scrambling source code prior to shipping it with the goal of making it difficult to reverse engineer. Apps that are obfuscated would be significantly harder to reverse engineer.

The common (and only?) obfuscation tool for WP7 is DotObfuscator. ~~The use of DotObfuscator often leaves files with the “DotObfuscator” brand in the final XAP. As a result we can easily iterate over all XAPs and see which one is obfuscated and which is not.~~

Update 10/3/2010: Sebastian Holst of PreEmptive has done a similar analysis to mine by downloading the entire WP7 Marketplace and found the real number of obfuscated XAPs to be 14.5% of the entire WP7 marketplace. Instead of looking for XAPs with “Dotfuscator” files , Sebastian looked for the [DotfuscatorAttribute] in the app binaries. That’s a significantly better metric to measure the total number of obfuscated apps in the WP7 marketplace. Read more about Sebastian’s analysis on his great blog post on the topic.

Statistic #2: Silverlight vs. XNA

When discussing the Windows Phone 7 dev ecosystem there’s always the friendly collaboration between XNA devs and Silverlight devs. The way I understand the XNA and Silverlight divide is that XNA is great for games and Silverlight is great for everything else.

The question then arises, what’s the adoption of both technologies in the Windows Phone 7 Marketplace?

Silverlight accounts for 90%~ of the Windows Phone 7 marketplace and XNA accounts for 10%.

It’s important for me personally to note that this isn’t a victory or something to lord over XNA devs. XNA is an important piece of the WP7 ecosystem and a critical part of the consumer landscape. As a friend of mine anecdotally said “All the great informative apps in the world don’t matter if you don’t have Angry Birds”.

Statistic #3: Programming Language of choice

Ever since .net came into existence there has been a healthy tension between C# and VB.Net developers. By looking at which XAPs contain Microsoft.VisualBasic.dll and FSharp.Core.dll we can learn what programming language is used by WP7 apps.

With the entire WP7 marketplace only 1% of apps is written in VB.Net. Additionally, amongst Top 2,000 WP7 apps there no apps written in VB.Net or F#.

One possible explanation to this disparity between C# and VB.Net & F# is that the WP7 V1 tools didn’t officially support VB.Net and F#. While it was technically possible to develop WP7 apps with VB.Net and F#, it wasn’t supported as a project type in the default WP7 V1 developer tools installation. Mango developer tools will be shipping with full WP7 VB.Net support. With that, we’ll likely see am uptake in VB.Net WP7 adoption. I hope.

Statistic #4: Cloned Apps

The following issue is a bit more complex to understand. There are a group of apps in the marketplace that are essentially the same app published multiple times with slightly different behaviour or data. In essence each XAP contains DLLs and if 2 XAPs have the same DLLs then they will be functionally quite similar.

By comparing the contents of all Windows Phone 7 XAPs with each other we can determine which apps are “cloned” with some limited certainty.

The WP7 Marketplace has 925 clones apps repeating themselves all in total 6,881 times. Roughly 20%+ of the WP7 marketplace is the same app published many times. For example the top cloned WP7 app repeats itself 570 times, the 2nd top cloned WP7 app repeats itself 553 times and the 3rd top cloned WP7 app repeats itself 408 times.

By counting each cloned WP7 apps just once, we can reveal that there are only 18,549 unique apps in the WP7 marketplace.

Side-note: Why clone apps?

Let’s avoid a witch-hunt right here and now. There are perfectly legitimate reasons to clone apps.

Books / Magazines: All mobiles marketplaces currently do not perform a content catalogue based search for apps. When searching a mobile marketplace for “Ulysess” unless that exact pharse is in the title or description of an App you won’t find the masterpiece written by Lord Alfred Tennyson. App vendors are thus forced to create multiple apps with the same execution paths and slightly different name and data.
DIY apps: Many organizations want a simple no-frills WP7 RSS based app. By using the same codebase and slightly different RSS points we’re effectively lowering the barrier of entrance into a mobile marketplace.
Lite vs. Full vs. Trial vs. Free apps: The WP7 marketplace does a bad job highlighting Trial apps. Bill Reiss eloquently penned that case a few months ago. WP7 App developers are forced to ship multiple versions of the same app for better searchability in the WP7 Marketplace.
Many other valid reasons exist to why apps are cloned.

For a good example I point to the “Traffic Cameras” apps that does make sense to highlight their unique localization. The core issue is the lack of support in Mobile Marketplaces for the concept of app “flavours”.

Side Note: “But Justin, What about iPhone? It’s magical!”

On June 16th 2011 WWDC conference Apple shared with iOS devs the following information:

Note how the “Books” category takes up 14% of the iOS marketplace. That’s approximately 60,000 apps. Anyone thinking there are 60,000 kindle/ibooks competitors on iOS is on crack. These are all cloned apps.

Based on http://www.windowsphoneapplist.com/stats/ the WP7 “Books”category has the same 15% share as it has on iOS.

Statistic #5: Publisher contribution to the overall marketplace

When looking at the entire Windows Phone 7 app landscape we get the rare opportunity to ask: Who contributes more? Single app developers or companies publishing 50+ apps?

Well, the answer is surprising in terms of quantity The Micro-publishers and Small Publishers each publishing less than 10 apps account for 60%+ of the WP7 Marketplace size. The larger publishers only contribute 1/3 of the total size of the WP7 marketplace.

But in terms of quantity what is the relative contribution of each of publishers to the top 2000 apps? (hopefully measuring app quality)

Exactly 75% of the top 2,000 “popular” WP7 apps are created by publishers shipping 10 or less apps. Proving once again that focusing in on a few defined objectives leads to better overall quality.

Both the smaller publishers and the larger publishers are important parts of the WP7 developer ecosystem. Without the smaller publishers we wouldn’t have as many quality titles; and without the larger publishers we would lack the reach to appeal to all consumers.

Statistic #6: Top 55 Windows Phone 3rd party libraries

Another interesting developer question that could only be answered from inspecting XAPs is: Who Da Man?

Many of us work to create 3rd Party frameworks in the WP7 ecosystem to be used by other developers. Some work for commercial companies, and others do so just for passion and joy. By inspecting the content of all WP7 marketplace XAPs we can know how many times each assembly is used.

Windows Phone 7 Top optional assemblies, in descending usage order

If you’re unfamiliar with any of these frameworks, stop being ignorant and click the link.

Microsoft’s WP7 Controls SDK: Ships with the WP7 developers tools and must be consumed by all apps using Panoramas and/or Pivots.
Microsoft.Phone.Controls.dll is used 14,848 apps.
Microsoft’s WP7 Silverlight Toolkit: Ships with a bunch of useful controls.
Microsoft.Phone.Controls.Toolkit.dll is used by 11,169 apps.
Microsoft’s Expression Blend Behaviours and Triggers: Great for integrating visual designers and creative developers into WP7 user experience design.
System.Windows.Interactivity.dll is used by 6,010 apps.
Microsoft.Expression.Interactions.dll is used by 4,150 apps.
Microsoft’s Advertising SDK for WP7: Microsoft’s own Advertising infrastructure for WP7 PubCenter.
Microsoft.Advertising.Mobile.UI.dll is used by 5,760 apps.
Microsoft.Advertising.Mobile.dll is used by 869 apps.
Microsoft.Advertising.Mobile.Xna.dll is used by 707 apps.
Microsoft’s Bing Maps WP7 SDK: Fully featured interactive Bing Maps control for WP7 apps.
Microsoft.Phone.Controls.Maps.dll is used by 2,235 apps.
Peter Torr’s LazyListBox: Workaround the terribleness of WP7 and NoDo Scrolling performance by using LazyListBox.
LazyListBox.dll is used by 1,364 apps.
UIExtensionMethods.dll is used by 1,362 apps.
Simon Mourier’s HTML Agility Pack: “HTML parser that builds a read/write DOM tree”.
HtmlAgilityPack.dll is used by 1,331 apps.
Laurent Bugnion’s MVVM Light: “The MVVM Light Toolkit is a set of components helping people to get started in the Model - View - ViewModel pattern in Silverlight and WPF”. My personal MVVM Toolkit of preference.
GalaSoft.MvvmLight.WP7.dll is used by 1,320 apps.
GalaSoft.MvvmLight.Extras.WP7.dll is used by 1,243 apps.
Flurry’s Ads and Analytics SDK: “Flurry Analytics delivers powerful insight into how consumers interact with your mobile applications in real-time. Performance-based traffic acquisition and monetization network”.
FlurryWP7SDK.dll is used by 1,283 apps.
James Newton-King’s JSON.net: The premiere JSON framework used by WP7 developers. It’s awesome. Stop using the built-in stuff.
Newtonsoft.Json.WindowsPhone.dll is used by 1,082 apps.
Newtonsoft.Json.Silverlight.dll is used by 584 apps.

For comparison WP7’s native JSON Framework is nearly completely abandoned by WP7 devs:
System.Runtime.Serialization.Json.dll is used by 12 apps.
Microsoft’s Clint Rutkas's Coding4Fun Tools: Awesome controls built by the good people at Coding4Fun.
Coding4Fun.Phone.Controls.dll is used by 800 apps.
Coding4Fun.Phone.Controls.Toolkit.dll is used by 305 apps.
Coding4Fun.Phone.Site.Controls.dll is used by 164 apps.
Daniel Crenna’s Hammock: The premiere REST framework used by WP7 developers. “Hammock's philosophy is simple: REST, easy.”
Hammock.WindowsPhone.dll is used by 741 apps.
David Anson’s Phone Performance Helpers: Shipping with DeferredLoadListBox and LowProfileImageLoader David’s code has been invaluable in many apps creating scrollable lists with Images.
PhonePerformance.dll is used by 705 apps.
Microsoft’s WCF RSS Library: The premiere RSS framework used by WP7 developers.
System.ServiceModel.Syndication.dll is used by 670 apps.
Microsoft’s Smooth Streaming Player (SSME): WP7 Smooth Streaming video player.
Microsoft.Web.Media.SmoothStreaming.dll is used by 604 apps.
Jim Zimmerman and Microsoft’s Nathan Totten’s Facebook C# SDK: “The Facebook C# SDK helps .Net developers build web, desktop, Silverlight, and Windows Phone 7 applications that integrate with Facebook.”
Facebook.dll is used by 603 apps.
Microsoft’s Alex Yakhnin Unofficial Windows Phone 7 Controls and Components: Custom controls for WP7: List Picker, Scrollable TextBlock, Progress Indicator and Picker Box.
Phone.Controls.dll is used by 564 apps.
Telerik’s WP7 SDK: “RadControls for Windows Phone are designed to speed up the development of Windows Phone apps and provide an array of controls and capabilities that are not available in the UI Toolbox for Windows Phone 7 and not even in the OS.”
Telerik.Windows.Core.dll is used by 557 apps.
Telerik.Windows.Controls.Primitives.dll is used by 555 apps.
Telerik.Windows.Controls.Input.dll is used by 367 apps.
Telerik.Windows.Data.dll is used by 194 apps.
Telerik.Windows.Controls.DataVisualization.dll is used by 124 apps.
Telerik.Windows.Controls.Chart.dll is used by 27 apps.
Google’s AdMob WP7 SDK: WP7 ad provider from Google.
Google.AdMob.Ads.WindowsPhone7.dll is used by 542 apps.
Sebastian Stehle’s ImageTools: “ImageTools for Silverlight is a library, which provides additional functionality for loading, saving and manipulation images from different sources and with different formats.”
ImageTools.dll is used by 490 apps.
PhoneCodeContractsAssemblies.dll is used by 480 apps. (used by ImageTools and exclusively consumed by ImageTools.)
ImageTools.IO.Png.dll is used by 457 apps.
ImageTools.IO.Gif.dll is used by 454 apps.
ImageTools.Utils.dll is used by 454 apps.
ImageTools.IO.Bmp.dll is used by 208 apps.
ImageTools.IO.Jpeg.dll is used by 193 apps.
ImageTools.Controls.dll is used by 122 apps.
ImageTools.Filtering.dll is used by 42 apps.
Microsoft’s Silverlight Desktop Controls SDK: The Silverlight Desktop Toolkit and Silverlight Desktop SDK .
System.Windows.Controls.dll is used by 484 apps.
System.Windows.Controls.Layout.Toolkit.dll is used by 191 apps.
SharpDevelop’s #ziplib: “Zip, GZip, Tar and BZip2 library written entirely in C# for the .NET platform.”
ICSharpCode.SharpZLib.Phone.dll is used by 432 apps.
ICSharpCode.SharpZipLib.WindowsPhone.dll is used by 406 apps.
ICSharpCode.SharpZipLib.Silverlight.dll is used by 14 apps.
Microsoft’s Expression Blend PathListBox: “Contains a list of items that are laid out along one or more paths.”
Microsoft.Expression.Controls.Fxg.dll is used by 395 apps.
Microsoft’s MEF on WP7: Damon Payne recompiled Microsoft’s Composition framework to WP7.
System.ComponentModel.Composition.dll is used by 398 apps.
System.ComponentModel.Composition.Initialization.dll is used by 393 apps.
Microsoft’s Michael Scherotter’s Silverlight Analytics Framework: “Extensible Web Analytics Framework for Microsoft Silverlight, WPF, and Windows Phone 7 Applications.”
Microsoft.WebAnalytics.dll is used by 373 apps.
Google.WebAnalytics.dll is used by 363 apps. (Google Analytics support)
Microsoft.WebAnalytics.Behaviors.dll is used by 231 apps.
Microsoft.WebAnalytics.Navigation.dll is used by 35 apps.
Microsoft.WebAnalytics.Controls.dll is used by 12 apps.
Matt Lacey’s Tombstone Helper: Super simple UI Tombstoning support. “Adds extension methods to PhoneApplicationPage so you don't have to worry about maintaining the state of a page in your app if it gets tombstoned.”
TombstoneHelper.dll is used by 307 apps.
Jeremy Likness’s Sterling OODB: Top Local Storage DB for WP7. “Sterling is a lightweight NoSQL object-oriented database for .Net 4.0, Silverlight 4 and 5, and Windows Phone 7 that works with your existing class structures.”
Wintellect.Sterling.WindowsPhone.dll is used by 294 apps.
Wintellect.Sterling.WindowsPhone.IsolatedStorage.dll is used by 40 apps.
Microsoft Research’s Code Contracts [PDF]: “Contracts allow you to express preconditions, postconditions and object invariants in your code for runtimechecking, static analysis, and documentation.”
Microsoft.Contracts.dll is used by 292 apps.
Microsoft’s XML Serialization: "Contains classes that are used to serialize objects into XML format documents or streams.”
System.Xml.Serialization.dll is used by 218 apps.
Alan Mendelevich’s AdDuplex SDK: “So, you have a great Windows Phone app or game and you are ready to make a million selling it or showing ads in it. That's great. The key to success is getting people to see your great app. That's where AdDuplex comes in. Promote your app for free by helping fellow developers promote theirs.”
AdDuplex.AdControl.Silverlight.dll is used by 216 apps.
AdDuplex.Xna.dll is used by 50 apps.
Noah Hart’s C#-SQLite: “C#-SQLite is an independent reimplementation of the SQLite software library. SQLite is a software library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine.”
Community.CsharpSqlite.WP.dll is used by 206 apps.
Community.CsharpSqlite.SqlLiteClient.WP7.dll is used by 38 apps.
Davide Zordan, Laurent Bugnion and David Kelley’s WP7 MultiTouch Framework: “Silverlight / Windows Phone Behaviors and WPF samples implementing Multi-Touch Manipulation (Gestures) and Inertia.”
MultiTouch.Behaviors.WP7.dll is used by 206 apps.
José Ángel’s Widget Library for WP7: “Create Windows Phone 7 apps using HTML, CSS and Javascript over the WebBroweser control inside the phone.”
WidgetLibrary.dll is used by 200 apps.
Microsoft’s Media Platform Player Framework for WP7: Great drag & drop fully featured video player for WP7 that supports EVERYTHING (Smooth Streaming, subtitles, audio tracks, 3D and just about anything video related).
Microsoft.SilverlightMediaFramework.Compatibility.Phone.dll is used by 189 apps.
Microsoft.SilverlightMediaFramework.Core.Phone.dll is used by 189 apps.
Microsoft.SilverlightMediaFramework.Plugins.Phone.dll is used by 189 apps.
Microsoft.SilverlightMediaFramework.Plugins.Progressive.Phone.dll is used by 189 apps.
Microsoft.SilverlightMediaFramework.Utilities.Phone.dll is used by 189 apps.
Microsoft.SilverlightMediaFramework.Plugins.SmoothStreaming.Phone.dll is used by 180 apps.
Microsoft.SilverlightMediaFramework.Plugins.TimedText.Phone.dll is used by 170 apps.
Daniel Crenna’s TweetSharp: “TweetSharp is a Twitter API library that greatly simplifies the task of adding Twitter to your desktop, web, and mobile applications.”
TweetSharp.WindowsPhone.dll is used 175 apps.
Microsoft’s WCF Data Services: “… enables the creation and consumption of OData services for the web (formerly known as ADO.NET Data Services).”
System.Data.Services.Client.dll is used by 170 apps.
John Sheehan’s RestSharp: “Simple REST and HTTP API client for .net. RestSharp works best as the foundation for a proxy class for your API.”
RestSharp.WindowsPhone.dll is used by 154 apps.
René Schulte’s WriteableBitmapEx: “The WriteableBitmapEx library is a collection of extension methods for Silverlight's WriteableBitmap. GDI+ like drawing functionality for the WriteableBitmap. Support for desktop and Windows Phone Silverlight.”
WriteableBitmapExWinPhone.dll is used by 141 apps.
WriteableBitmapEx.dll is used by 65 apps.
Microsoft’s Rx (Reactive eXtensions) DevLabs release: Essentially Linq to events state-machine. It’s important to note that only the DevLabs release is ranked here, not the embedded release.
System.Reactive.dll DevLabs release is used by 135 apps.
Manfred Dalmeijer’s aldarIT SuperAds: “A Free Multiple Ad-Network Silverlight Control for Windows Phone 7. Support for: Admob, PubCenter (Microsoft Advertising), Smaato, ZestADZ and MobFox.”
AldarIT.SuperAds.dll is used by 118 apps.
Sergey Barskiy’s Windows Phone 7 Database: “This project implements a Isolated Storage (IsolatedStorage) based database for Windows Phone 7. The database consists of table object, each one supporting any number of columns. Use this as persistence engine for Windows Phone 7 Silverlight (and XNA) applications.”
SilverlightPhoneDatabase.dll is used by 118 apps.
Rob Eisenberg’s Calburn.Micro: “A small, yet powerful framework designed for WPF, Silverlight and WP7. It implements a variety of UI patterns for solving real-world problems. Patterns that are highlighted include MVVM (Presentation Model), MVP and MVC.”
Caliburn.Micro.dll is used by 111 apps.
Microsoft’s Windows Phone Shake Gestures Library: “The Shake Gesture Library enables developers to register for ‘shake gesture’ events in their applications. You can configure how strong you want your end user to shake, for how long, and in which direction to generate shake events.”
ShakeGestures.dll is used by 111 apps.
Rgelb’s adMob for Windows Phone 7: “This project aims to provide Windows Phone 7 developers an opportunity to monetize their free applications using AdMob.”
adMob7.dll is used by 97 apps.
Microsoft P&P’s Prism: “Prism provides guidance designed to help you more easily design and build rich, flexible, and easy-to-maintain Windows Presentation Foundation (WPF) desktop applications, Silverlight Rich Internet Applications (RIAs), and Windows Phone 7 applications.”
Microsoft.Practices.Prism.Interactivity.dll is used by 94 apps.
Microsoft.Practices.Prism.dll is used by 70 apps.
Karl Seguin’s Mogade Windows Phone : “Mogade is a free service web-based service which allows game developers to quickly enchance their games with auxiliary functionality (such as leaderboards).”
Mogade.WindowsPhone.Core.dll is used by 88 apps.
Mogade.WindowsPhone.dll is used by 86 apps.
Simon McKenzie’s ExifLib: “ExifLib simply reads Exif tags (i.e., camera model, date picture taken, shutter speed etc.) from JPEG files”
ExifLib.dll is used by 86 apps.
Jeff Brand’s SlickThought WP7 Trial Manager: “TrialManager is a simple piece of code that you can add to any WP7 project to help manage the behavior of your trial apps. TrialManager will also make it easier to simulate you application running in Trial mode when creating your apps.”
SlickThought.Phone.dll is used by 86 apps.
amCharts Quick Charts for Windows Phone 7: “Quick Charts is an easy to use, fast set of charting controls for WPF, Silverlight and Windows Phone 7. And it's FREE and Open Source (Ms-PL)!”
AmCharts.Windows.QuickCharts.WP.dll is used by 85 apps.
Shawn Wildermuth’s PhoneyTools: “This is a project that contains several classes and controls for use with Windows Phone 7 applications.”
AgiliTrain.PhoneyTools.dll is used by 59 apps.
Romeo Dumitrescu’s Windows Phone 7 Isolated Storage Explorer: “WP7 Isolated Storage Explorer is a tool designed to help developers and testers interact with the isolated storage file for Silverlight Windows Phone 7 applications. The explorer can work both as a desktop application for testers or integrated in Visual Studio for developers.”
IsolatedStorageExplorer.dll is used by 57 apps.
Jeff Weber and Ian Qvist’s Farseer Physics Engine: “Farseer Physics Engine is a collision detection system with realistic physics responses. This means you can create a game or robotic simulation easily using the engine and the associated tools. Everything from simple hobby games to complex simulation systems is possible with Farseer Physics Engine.”
FarseerPhysicsXNA.dll is used by 54 apps.
FarseerPhysics.dll is used by 29 apps.
FarseerPhysicsWP7.dll is used by 12 apps.
FarseerPhysicsPhone.dll is used by 4 apps.
MobFox Windows Phone 7 SDK: “MobFox is world's highest-paying mobile advertising network for US & EU Traffic on iPhone, Android, Windows Phone 7 applications and mobile websites. Instead of working with hundreds of different advertisers and networks, we concentrate on placing the most engaging and most paying premium ads on your applications or mobile websites.”
MobFox.Ads.dll is used by 47 apps.
Damian Karzon’s DropNet: “.NET Client library for the Dropbox API.”
DropNet.WindowsPhone.dll is used by 44 apps.
Pawel Idzikowski’s sharpSerializer: “sharpSerializer is an open source XML and binary serializer for .NET Framework, .NET Compact Framework and Silverlight.”
Polenter.SharpSerializer.Silverlight.dll is used by 40 apps.

Update 10/3/2010: With the new numbers regarding the use of Dotfuscator it appears 14.5% of the marketplace is PreEmpetive’s solutions for obfuscation and 2.6% of the marketplace for instrumentation. Earning Dotfuscator a rightful place as top framework #4.

Who Da Man?

I’ve created a new Twitter list with all the creators of the top WP7 3rd party libraries. Fellow it at @ http://twitter.com/#!/JustinAngel/top-wp7-frameworks-devs

Can I see report breakdowns and the technique used to generate them?

Yes. I’ve posted the reports generated for the entire marketplace, the same reports for top 2,000 WP7 apps and the source code used to generate reports.
If you’ve got a 3rd party framework you can see specific usage numbers in these detailed reports.

Get the reports and analytics source code @ http://JustinAngel.net/storage/WP7MarketplaceAnalysis.zip

Can you share raw data or how to download the entire marketplace?

No. There are security, legal and piracy implications to sharing data of that granularity.

However, an independent report isn’t meaningful unless it’s potentially corroborated by others. So, If I’m personally acquainted with you (let’s say you’re a Silverlight MVP or someone like that) feel free to ping me and I’ll share all code needed to download the WP7 marketplace and run these reports. If any such endeavour is ever undertaken up by anyone, I’ll update this blog post.

Can I get a custom statistic?

Yes. Sound off in the comments! I can always generate more informative statistics based on your requests. Don’t be shy, if you have questions I’d love to help out.

Any feedback?

Thoughts? Feedback? Feel free to sound off in the comments! I’d love to hear from you folks.

-- Justin Angel

Windows Phone 7 Development Best Practices Wiki

Hi Folks,

This is a short blog post to share with you my latest project: Windows Phone 7 Development Best Practices Wiki.

What’s this Wiki about?

“This document represents current consensus around development best practices for Windows Phone 7.
These best practices are collaboratively developed and discussed by the WP7 developers community. As such, anyone may contribute.”

Who’s the Wiki’s target audience?

“Experienced Silverlight, WPF or WP7 Developers. This is not an introduction level document.”

What topics are covered?

Feedback? Comments?

If you have general feedback on the wiki please open up a new discussion on the Discussion page.

For anything else, feel free to sound off in the comments for this blog post.

Sicnerely,

-- Justin Angel

Windows Phone 7 “Neurons” App

Hi Folks,

I’d like to share some general specifics around my latest endeavour: the Windows Phone 7 app “Neurons”.

What is “Neurons” all about? What does it actually do?

"Neurons" streams TED Talks, The RSA (and RSA Animate), FORA.tv and Science Dump to your Windows Phone 7. You can view the latest talks from each of these knowledgeable sources or Search for more talks. Feel free to share talks you liked via Facebook, Twitter or email.

I got distracted, show me some pretty pictures!

Neurons Panorama

In-app video player

Search Page and Facebook Share

OK, Now show me a cool video!

Live preview of the “Neurons” Youtube video: (In Silverlight)

[SimpleVideo:source=http://justinangel.net/storage/NeuronsVideoProject3.wmv|width=800|height=480]

“That’s hot, post the codez? ;)”

Announcing here for the first time, I’m open sourcing Neurons under the Ms-PL license.
Go to http://Neurons.codeplex.com and get the latest source code.

There are some minor differences between the source code that shipped with Neurons V1.0 on the Windows Phone marketplace and the source code on codeplex. Mostly owing to my own wish to avoid violating some terms-of-usage by sharing out my private developer key. More on that on the codeplex website.

What did you learn from this project?

I’ll share technical specifics in a later blog post. I’ve started working on that one and it’s 30+ pages long.

My most important takeaway is that it is possible to develop an entire production level app in a single weekend. Neurons’ first line of code was written on Friday afternoon and it went out to beta testers on Monday morning.

Why did you develop this project?

My primary mobile device is changing from an iPhone to a WP7 device. That was a tough decision for me to make since I do use my iPhone quite often and use it to it’s fullest extent.

4 iPhone apps I frequently use were exclusively used to view these type of inspiring and educational videos.

The prospect of leaving these apps behind when migrating to WP7 convinced me to be proactive and assure that this content will be available on WP7.
I also wanted to provide a consistent meaningful experience instead of the fragmented subpar experience on the iPhone.
I’m very lucky that WP7 development is simple enough to have been able to achieve both of these goals in a single weekend.

Thank You!

First and foremost, I’d like to thank the content providers who unbeknownst to them helped make this app a reality.
The whole goal of this app is to show content from these great sources of knowledge and learning, and just get out of the way.

I’d also like to thank the beta testers who volunteered to test this app and make it to what it is today.

András Velvárt - @vbandi
Gergely Orosz - @GergelyOrosz
Chris Welsh - @ChrisWalshie
Indrajit Chakrabarty - @indyfromoz
Martin Plante - @MartinPlante
Daren May - @darenmay
@keendarkmarvel
@slashxxx

I’d also like to thank the creators of the following frameworks that were used in this application.

Microsoft Silverlight Media Framework – Video player and media infrastructure.
MVVM Light Toolkit – MVVM framework.
Ninject – IoC framework.
Microsoft Silverlight for Windows Phone Toolkit – WP7 UI Controls!

Questions? Comments? Leave a comment!

I’d love to hear feedback on this project, things that could be improved, or any questions on the process of developing this application.

Sincerely,

-- Justin Angel

Windows Phone 7 supports VB.Net and F#

Hi Folks,

In this article we’ll review Windows Phone 7 support for the Visual Basic .Net and F# programming languages.
Our goal is to demonstrate that Windows Phone 7 can indeed support F# and VisualBasic.Net code libraries and user controls.

You can get the sample project we’ve build in this article @ http://JustinAngel.net/storage/WP7.Languages.zip

Why?! Why has Microsoft forsaken us?!

Reading about VB.Net & F# Windows Phone 7 support online can be quite misleading.

On the official MSDN WP7 forums we can find the following quote:

“Windows Phone 7 currently is supported only for C#” - Mark Chamberlain

During Windows Phone 7 jumpstart webcasts an audience member asked about VB.Net support and was answered:

“I'm afraid Visual Basic is not supported for WP7 dev” - Andy Wigley

On the official Silverlight WP7 forums we can find many questions asking about WP7 VB.net support with answers like:

Q: “Can I develop applications with VB.NET for Windows Phone 7?”

A: “No, You can't.”

TechRepublic tech blog is quoted in saying:

“The only language that will work up front is C#; VB.NET developers need not apply.” TechRepublic

And Canadian Heritage and official Languages Minister, the Honourable MP James Moore said:

“My dog wears a conservative party raincoat”

All of the aforementioned statements, with the exception of that last one, are all patently false. And that last statement is just plain embarrassing.
Windows Phone 7 does indeed support Visual Basic .Net and F# and has done so since day #1.

Windows Phone 7 Applications are C#

The one statement that can made and is factually true is that during the WP7 Beta the only language supported for the WP7 application project itself is C#.
Which means absolutely nothing, since a WP7 application can just refer to a F# Silverlight 3 library or VB.Net Silverlight 3 library.

Using F# in Windows Phone 7

Let’s go over how to setup a simple “hello world” WP7 app with F#.

1) Create a new C# Windows Phone 7 application.

2) Add a F# Silverlight 3 project to the solution.

3) Open up the module1.fs file and write some F# code.
For this basic sample we’ll make do with a simple non-UI sample of returning “Hello world”.

module WP7FSharpLibrary
 
type myClass = class
    new () as this = {}
    member s.myMethod() =
        "OMG! Windows Phone 7 is running F# code!"
end 

3) Add a reference from your WP7 app to the new F# library and build the solution.

4) in the C# WP7 application, initialize your F# class and invoke the proper members.

        // Constructor
        public MainPage()
        {
            InitializeComponent();
 
            var FSharpClass = new WP7FSharpLibrary.myClass();
            ContentGrid.Children.Add(new TextBlock() { Text = FSharpClass.myMethod()});
        }

When we run our app we can clearly see that F# executes in Windows Phone 7 without a hitch.

It’s also possible to have F# initialize various UI elements and create the UI for us.
But that really isn’t where functional programming normally excels in, so I’ll avoid demoing that worst practice.

Using a Visual Basic .Net UserControl in a Windows Phone 7

1) Create a new C# Windows Phone 7 application.

2) Add a VisualBasic.net Silverlight 3 project to the solution.

3) Add a new UserControl to your Silverlight 3 VB.Net project.

In our case we’ll add a simple user control with a <ListBox /> that has a few items.

Partial Public Class SL3VbNetUserControl
    Inherits UserControl
 
    Public Sub New 
        InitializeComponent()
 
        Me.DataContext = {"Hello from VB.Net on WP7!", "World", "Foo", "Bar", "Baz"}
    End Sub
 
End Class
 

<UserControl x:Class="WP7.VisualBasicNet.SL3VbNetUserControl"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
   xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
   mc:Ignorable="d"
   d:DesignHeight="300" d:DesignWidth="400">
 
    <Grid x:Name="LayoutRoot">
        <ListBox ItemsSource="{Binding}" />
    </Grid>
</UserControl>
 

4) Add a reference from the WP7 app to the new VB.Net library and build.

5) Add the new SL3 VB.Net UserControl to your MainPage in the WP7 project.

<!--ContentPanel - place additional content here-->
<Grid x:Name="ContentGrid" Grid.Row="1">
    <VisualBasicNet:SL3VbNetUserControl xmlns:VisualBasicNet="clr-namespace:WP7.VisualBasicNet;assembly=WP7.VisualBasicNet" />
</Grid>

6) If we try and run the project at this state, we’ll see the following build warning:

Warning 1 The primary reference "d:\visual studio 2010\Projects\WP7.Languages\WP7.VisualBasicNet\Bin\Debug\WP7.VisualBasicNet.dll" could not be resolved because it has an indirect dependency on the framework assembly "Microsoft.VisualBasic, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" which could not be resolved in the currently targeted framework. "Silverlight,Version=v4.0,Profile=WindowsPhone". To resolve this problem, either remove the reference "d:\visual studio 2010\Projects\WP7.Languages\WP7.VisualBasicNet\Bin\Debug\WP7.VisualBasicNet.dll" or retarget your application to a framework version which contains "Microsoft.VisualBasic, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35". WP7.Languages

Make sure to add a reference from the WP7 app to Microsoft.VisualBasic.dll, and that it is marked as “Copy Local = False”.
On my dev box the DLL is found @ c:\Program Files (x86)\Microsoft Silverlight\4.0.50524.0\Microsoft.VisualBasic.dll

Right click on the “Microsoft.VisualBasic” reference, choose “properties” and set “Copy Local” to false”.

After that change we can run our project and the Visual Basic .Net Silverlight 3 UserControl just shows up in our Windows Phone 7 project.

Obviously, after adding the Windows Phone 7 dlls to our VB.Net project we would be able to do anything a C# project can: GPS Location, Push Notifications, Accelerometer, Navigation, etc.

Fin

Windows Phone 7 supports all 3 main .Net 4.0 programming languages: C#, VisualBasic.Net and F#.
While C# alone is supported during the WP7 beta as the root WP7 application, it’s a small hindrance which we can easily be overcome.

In the aftermath of this blog post I expect both F# developers and VB.Net developers to produce some kick-ass WP7 apps. Yeah, I’m looking at you there.

Feedback

Feel free to sound off in the comments. What are your thoughts on this topic?
Is this an unbearable burden to follow this 5 simple steps? Is it exactly what you were looking for?
Are there any caveats you know off and would like to share with everyone?

Sincerely,

-- Justin Angel

TFS2010 WP7 Continuous Integration

Hi Folks,

In this blog post we’ll cover how to set up automated (nightly?) builds on a Team Foundation 2010 Build Server for Windows Phone 7 projects.
The core challenge we’ll face is not having Visual Studio, Windows Phone 7 Tools or Windows Phone 7 SDK installed on the Build Server.

You can get a sample project with all the modifications discussed in this blog post at: http://JustinAngel.net/Storage/Justin.WindowsPhone.BuildFromLocalFiles.zip

Prerequisite Reading

There’s a blog post that I highly recommend you’ll read before embarking on this quest.

Building Silverlight 3 and Silverlight 4 applications on a .NET 3.5 build machine by Jeff Wilcox
In the linked article Jeff explains how to setup a TFS Build Server for Silverlight.
The blog post you are currently reading is heavily influenced by Mr. Wilcox approach to setting up a build server. Mainly because the writer of this blog post was schooled in the “Wilcox School of Application Packaging and offensive driving”.
If you’d like to setup a Continuous Integration in TFS for a Silverlight project, please read Mr. Wilcox’s article. This blog post only deals with WP7 projects.

The Problem – We don’t have WP7 Installed on a Build Server

Imagine this situation, you’re in a company that has multiple Windows Phone 7 projects on the same build server. Or maybe you’re hosting your TFS2010 Build server and multiple companies are using the same server.
Some project could be prototypes, and some projects could be completely different projects.

All of these projects are using different versions of the WP7 Tools.
If we were talking about Silverlight projects we would be talking about Silverlight 2, Silverlight 3 and Silverlight 4 projects.
In WP7’s case it would be different beta shipped at different months for the Windows Phone 7 developer tools.
However, since a server can only have 1 version installed at any given point in time – one project upgrading the server build version breaks all other projects.

For instance, in Vertigo we’ve got multiple Windows Phone 7 projects we’re working on for different customers.
We can’t guarantee that these multiple projects which are on different schedules with different deliverables will all upgrade together.

The Solution – Don’t install WP7 Tools at all, use local resources

Since the problem here is that our WP7 projects have a dependency on installed software, let’s make sure we sever all of these ties.
The ties between our projects and installed WP7 Tools are built into our MSBuild scripts. We’ll be focusing our efforts in this blog post on those MSBuild scripts.

1. Setup an “ExternalDependencies”/”ExternalTools” directory in source control.
As my own best practice, I establish a “Build” directory nested underneath that folder, and underneath it a “WP7_<Version>” folder. But these two last folders are just my own personal convention.

2. Drag & drop the contents of the WP7 MSBuild central directory into the “ExternalDependencies/Build/WP7_<Version>” folder.
On a x64 dev machine the folder is located on: C:\Program Files (x86)\MSBuild\Microsoft\Silverlight for Phone\v4.0

3. Create another nested folder named “Reference Assemblies” and copy the entire WP7 SDK into it.
On a x64 dev machine the WP7 SDK folder is located at: C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\Silverlight\v4.0\Profile\WindowsPhone

4. In the folder holding the default *.targets files (“ExternalDependencies/Build/MSBuild_WP7_Apri10”), add a new <companyName.WP7.Version>.Targets file.
In this example the file is named “Vertigo.WP7.April10.targets”.

Paste in the following MSBuild script:

<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <SilverlightBuildResources>$(CompileTimeSolutionDir)ExternalDependencies\Build\MSBuild_WP7_Apr10\</SilverlightBuildResources>
    <TargetFrameworkDirectory>$(SilverlightBuildResources)Reference Assemblies\</TargetFrameworkDirectory>
    <TargetFrameworkSDKDirectory>$(SilverlightBuildResources)Reference Assemblies\</TargetFrameworkSDKDirectory>
    <_TargetFrameworkSDKDirectoryItem>$(SilverlightBuildResources)Reference Assemblies\</_TargetFrameworkSDKDirectoryItem>
    <_FullFrameworkReferenceAssemblyPaths>$(SilverlightBuildResources)Reference Assemblies\;</_FullFrameworkReferenceAssemblyPaths>
    <_TargetFrameworkDirectories>$(SilverlightBuildResources)Reference Assemblies\;</_TargetFrameworkDirectories>
    <SilverlightRuntimeVersion>3.0.40624.0</SilverlightRuntimeVersion>
  </PropertyGroup>
  <Import Project="Microsoft.Silverlight.WindowsPhone.Overrides.targets" />
  <Import Project="Microsoft.Silverlight.CSharp.targets" />
</Project>

5. Open up the “Microsoft.Silverlight.Common.targets” file (from “ExternalDependencies/Build/MSBuild_WP7_Apri10”) and comment out Lines 78-92.
The reason we have to do this edit, is because the default WP7 MSBuild script from Microsoft accidently uses registry settings instead of relaying on local values.

        <!--<GetSilverlightFrameworkPath 
            RegistryBase="$(FrameworkRegistryBaseWithVersion)"
            RuntimePathRegistryKey="$(RuntimePathRegistryKey)"
            RuntimeVersionRegistryKey="$(RuntimeVersionRegistryKey)"
        > 
            <Output TaskParameter="SilverlightPath" PropertyName="TargetFrameworkDirectory" Condition="'$(TargetFrameworkDirectory)' == ''"/>
            <Output TaskParameter="SilverlightSDKPaths" ItemName="_TargetFrameworkSDKDirectoryItem" Condition="'$(TargetFrameworkSDKDirectory)' == ''"/>
            <Output TaskParameter="SilverlightRuntimeVersion" PropertyName="SilverlightRuntimeVersion" Condition="'$(SilverlightRuntimeVersion)' == ''"/>
        </GetSilverlightFrameworkPath>-->
 
        <!-- Reset some items from the above task. Will remove when we merge with SL build system -->
        <PropertyGroup>
            <!--<_FullFrameworkReferenceAssemblyPaths>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetPathToStandardLibraries($(TargetFrameworkIdentifier), $(TargetFrameworkVersion), ''))</_FullFrameworkReferenceAssemblyPaths>-->
            <!--<TargetFrameworkDirectory>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetPathToStandardLibraries($(TargetFrameworkIdentifier), $(TargetFrameworkVersion), $(TargetFrameworkProfile)))</TargetFrameworkDirectory>-->
        </PropertyGroup>

6. For every WP7 Project that needs to use local resources, we’ll have to edit the *.csproj file and replace the 2 default <Import> XML elements.

Right Click on your project and choose “Edit Project File”:

BTW, The “Edit Project file” context menu item comes from Visual Studio 2010 PowerCommands.
If you don’t have those installed, you’ll have to manually choose “Unload Project –> Edit File” on each project.
Thanks to Allen Newton who told me about PowerCommands!

In the *.csproj we’ll see the 2 default <Imports>:

<Import Project="$(MSBuildExtensionsPath)\Microsoft\Silverlight for Phone\$(TargetFrameworkVersion)\Microsoft.Silverlight.$(TargetFrameworkProfile).Overrides.targets" />
<Import Project="$(MSBuildExtensionsPath)\Microsoft\Silverlight for Phone\$(TargetFrameworkVersion)\Microsoft.Silverlight.CSharp.targets" />

We’ll comment out these <Import> elements and include our new <Import> with some flavouring to make Blend 4 RC to work with it well.

  <!-- This MSBuild script compensates for Blend Design time having the wrong SolutionDir -->
  <PropertyGroup>
    <MissingExternalDependenciesBlendDesignTimehack>false</MissingExternalDependenciesBlendDesignTimehack>
    <MissingExternalDependenciesBlendDesignTimehack Condition="!Exists('$(SolutionDir)ExternalDependencies')">true</MissingExternalDependenciesBlendDesignTimehack>
    <CompileTimeSolutionDir Condition="'$(MissingExternalDependenciesBlendDesignTimehack)'!='true'">$(SolutionDir)</CompileTimeSolutionDir>
    <CompileTimeSolutionDir Condition="'$(MissingExternalDependenciesBlendDesignTimehack)'=='true'">$(SolutionDir)..\</CompileTimeSolutionDir>
  </PropertyGroup>
  <Import Project="$(CompileTimeSolutionDir)ExternalDependencies\Build\MSBuild_WP7_Apr10\Vertigo.WP7.Apr10.targets" />
  <!--<Import Project="$(MSBuildExtensionsPath)\Microsoft\Silverlight for Phone\$(TargetFrameworkVersion)\Microsoft.Silverlight.$(TargetFrameworkProfile).Overrides.targets" />-->
  <!--<Import Project="$(MSBuildExtensionsPath)\Microsoft\Silverlight for Phone\$(TargetFrameworkVersion)\Microsoft.Silverlight.CSharp.targets" />-->
 

7. We’re done.
Checkin to the server and as long as all files are in source control and all paths are correct the project will build on a server with no Windows Phone 7 Tools.

Setting up a new TFS Automated Build

In terms of setting up a new TFS2010 Build Definition for WP7, it’ll all plain old setup and pretty easy & straightforward.

There’s one major caveat we should call out: Make sure to set the build agent to X86.

If this step if not followed we’ll see a myriad of cryptic errors, like these ones:

If you’re interested in more information about this issue please read TFS2010 Build failed -- “Microsoft.Silverlight.Common.targets (104): The Silverlight 4 SDK is not installed” by Benjamin Day.

Summary

You can get a sample project with all the modifications discussed in this blog post @ http://JustinAngel.net/Storage/Justin.WindowsPhone.BuildFromLocalFiles.zip

Here’s a summary of the changes we needed to make in order for our project to run build successfully on a WP7-less TFS2010 Build server:

Fin

We’ve talked about why we it’s a smart move to avoid installing SDKs on our Build Server.
Additionally we’ve shown how to setup a WP7 project to run on a Build Server that doesn’t have WP7 Tools installed at all.

Hopefully this blog post will help you on your way to Continuous Integration for Windows Phone 7.

What are your thoughts on this topic? Was this blog post useful?

Sincerely,

-- Justin Angel

Windows Phone 7 – Emulator Automation

Hi Folks,

In this next blog post we’ll review how to automate the Windows Phone 7 Emulator and what are some real-world usages this technique.

This blog post is the second blog post in a series of unrelated advanced Windows Phone 7 blog posts.
The previous blog post in this series is “Windows Phone 7 – Unlocked ROMs”.

Why is Windows Phone 7 Automation Important?

Currently, the Windows Phone 7 Emulator can only launch developer packages (XAPs) from inside Visual Studio 2010.
Meaning, if we’ve got a XAP we can’t get the emulator to load it without Visual Studio.

As we’ve seen in a previous blog post the emulator can be launched and even installed on machines that do not have Visual Studio. More on that here.
Let’s consider that in order to load XAPs into the Emulator we currently have to use Visual Studio.

The problem is – How do we load XAPs into WP7 Emulators and Devices without using Visual Studio?

So how does our Build Server run nightly tests? Or how do our customers see our applications?

Customers and Build servers don't have Visual Studio 2010 installed.

So, how can we deploy XAPs to an emulator running on these machines?

Quit your Jibber-Jabber, show me how to automate the WP7 emulator!

Let’s create a new solution with a Console Application and a Windows Phone 7 Project.

We’ll use the ConsoleApplication as our automation harness that can run on any computer with the .Net framework.
The WindowsPhone Application is the application whose deployment we’ll automate.

The CoreCon 10 WP7 API

The secret sauce for WP7 Automation is the CoreCon API.
These CoreCon DLLs have been in deep hibernation since 2007 when they last got a major upgrade.
For WP7 Tools the CoreCon API has been updated and are used by Visual Studio 2010 when deploying applications to WP7 devices and emulators.

Let’s add a reference to Microsoft.SmartDevice.Connectivity.dll from the CoreCon API.
On a x64 developer box, the DLL can be found at: C:\Program Files (x86)\Common Files\microsoft shared\Phone Tools\CoreCon\10.0\Bin\Microsoft.Smartdevice.Connectivity.dll

Now that we have the CoreCon DLL reference in place, we can start automating WP7.

Here’s the User Experience we’re aiming for in this demo:

We’ll have to build the following workflow:

We’ll start off by getting an instance of the WP7 CoreCon SDK instance to work with:

// Get CoreCon WP7 SDK
DatastoreManager dsmgrObj = new DatastoreManager(1033);
 
Platform WP7SDK = dsmgrObj.GetPlatforms().Single(p => p.Name == "New Windows Mobile 7 SDK");

Next up we’ll have to get a reference to either a WP7 physical device or a WP7 Emulator.
This demo will use the emulator, but if we set “useEmulator = false” this demo will try and connect to a physical WP7 device.

// Get Emulator / Device

bool useEmulator = true;
Device WP7Device = null;
if (useEmulator)
    WP7Device = WP7SDK.GetDevices().Single(d => d.Name == "Windows Phone 7 Emulator");
else
    WP7Device = WP7SDK.GetDevices().Single(d => d.Name == "Windows Phone 7 Device");

Now we’ll launch the WP7 Emulator/Device.
Note that the default WP7 Emulator Image is the one we’ll launch into, and in a previous blog post I’ve explained how to use the Unlocked ROM as the default ROM.

// Connect to WP7 Emulator / Device
Console.WriteLine("Connecting to Windows Phone 7 Emulator/Device...");
WP7Device.Connect();
Console.WriteLine("Windows Phone 7 Emulator/Device Connected...");

Next, we’ll have to check if our application is already installed, and if it is – we’ll uninstall it.
Since the the UpdateApplication Method in the current CoreCon API doesn’t work, this is our best bet on easily updating installed apps.

In order to Install or Uninstall our application, we’ll need it’s Application Product Identifier (GUID).
We can get the application GUID from the Properties/WMAppManifest.xml file.

We’ll write the code to check if an application is installed, and if it is – we’ll uninstall it.

Guid appID = new Guid("{5e75bba1-fbf6-463c-94ac-fa4a78f8fd12}");
RemoteApplication app;
if (WP7Device.IsApplicationInstalled(appID))
{
    Console.WriteLine("Uninstalling sample XAP to Windows Phone 7 Emulator/Device...");
 
    app = WP7Device.GetApplication(appID);
    app.Uninstall();
 
    Console.WriteLine("Sample XAP Uninstalled from Windows Phone 7 Emulator/Device...");
}

At this point, we’ll install our XAP.
In order to do that, we’ll need 3 pieces of information:
1. The location of our XAP.
2. The Application GUID.
3. The location of the application icon.

// Install XAP
Console.WriteLine("Installing sample XAP to Windows Phone 7 Emulator/Device...");
 
app = WP7Device.InstallApplication(
    appID,
    appID,
    "NormalApp",
    @"D:\visual studio 2010\Projects\ConsoleApplication1\WindowsPhoneApplication1\ApplicationIcon.png",
    @"D:\visual studio 2010\Projects\ConsoleApplication1\WindowsPhoneApplication1\Bin\Debug\WindowsPhoneApplication1.xap");
 
Console.WriteLine("Sample XAP installed to Windows Phone 7 Emulator...");

The last step is to actually launch our application.

// Launch Application 
Console.WriteLine("Launching sample app on Windows Phone 7 Emulator...");
app.Launch();
Console.WriteLine("Launched sample app on Windows Phone 7 Emulator...");

We’re done. And indeed when we run our sample application the app runs as expected:

So What is WP7 Automation good for?

There’s a lot of good use cases: Automating Unit tests, Loading Nightly builds into the emulator and even letting customers use the WP7 Emulator.
There’s really a plethora of reasons and situations WP7 Automation can prove useful in and it’s up to you to figure it out for your projects.

For instance in Vertigo, we’re using the WP7 Automation harness to run the WP7 Emulator on multi-touch laptops that our customers have.
So Vertigo’s customers, as part of an iterative process, get access to our current build without having to install or use Visual Studio 2010.

Access to Isolated Storage

One use-case in particular interests me, which is automating running all unit tests in the project after a Continuous Integration nightly build.

We can pretty much do all of the work to automate WP7 tests using WP7 Automation we’ve seen so far, but how do we get results into application? Or get instructions in?

The easiest method I can think off is communicate through cold storage – read & write files into Isolated Storage.

We’ll start off by writing a file into our WP7 Application IsoStore.
Remember that this code executes in the WP7 Emulator/Device.

public MainPage()
{
    InitializeComponent();
 
    SupportedOrientations = SupportedPageOrientation.Portrait | SupportedPageOrientation.Landscape;
 
    using (var isoStore = IsolatedStorageFile.GetUserStoreForApplication())
    using (var sw = new StreamWriter(isoStore.OpenFile("Foo.txt", FileMode.OpenOrCreate, FileAccess.Write)))
    {
        sw.Write("Hello WP7! (Written from WP7 IsoStore, read by Console Harness!)");
    }
}

Basically, We’ve written a Foo.txt file into our IsoStore and added some text into it.

Next, we would have used the RemoteIsolatedStorage class and get access to the emulator IsoStore, but that has not been enabled yet in CoreCon10.

We would have used RemoteApplication.GetIsolatedStorage() but that has not been implemented yet.

We’ll use a FileDeployer class instead.
There’s some reflection magic associated with getting a copy of a FileDeployer class that can be used for our application.

Thread.Sleep(10000);
//app.GetIsolatedStore(); <-- Throws NotImplementedException
object ConManServer = WP7Device.GetType().GetField("mConmanServer", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(WP7Device);
FileDeployer f = (FileDeployer)typeof(FileDeployer).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic)[0].Invoke(new object[] { ConManServer });

Next, we’ll copy the Foo.txt file from the application isolated storage into our local binary folder and read it into the console:

f.ReceiveFile(@"\Applications\Data\" + appID + @"\data\isolatedstore\Foo.txt", @"\Foo.txt");
 
Console.WriteLine("\t" + File.ReadAllText(@"foo.txt"));

When we run this sample we can see the text written from IsoStore showing up on our console.

And we’re done, we’ve esteblished a two-way communication channel between WP7 Emulator/Device and Managed .net code.

Console WP7 Automation Harness Source Code

Here’s the source code we’ve built in this project:

// Get CoreCon WP7 SDK
DatastoreManager dsmgrObj = new DatastoreManager(1033);
 
Platform WP7SDK = dsmgrObj.GetPlatforms().Single(p => p.Name == "New Windows Mobile 7 SDK");
 
// Get Emulator / Device
bool useEmulator = true;
Device WP7Device = null;
if (useEmulator)
    WP7Device = WP7SDK.GetDevices().Single(d => d.Name == "Windows Phone 7 Emulator");
else
    WP7Device = WP7SDK.GetDevices().Single(d => d.Name == "Windows Phone 7 Device");
 
// Connect to WP7 Emulator / Device
Console.WriteLine("Connecting to Windows Phone 7 Emulator/Device...");
WP7Device.Connect();
Console.WriteLine("Windows Phone 7 Emulator/Device Connected...");
 
 
Guid appID = new Guid("{5e75bba1-fbf6-463c-94ac-fa4a78f8fd12}");
RemoteApplication app;
if (WP7Device.IsApplicationInstalled(appID))
{
    Console.WriteLine("Uninstalling sample XAP to Windows Phone 7 Emulator/Device...");
 
    app = WP7Device.GetApplication(appID);
    app.Uninstall();
 
    Console.WriteLine("Sample XAP Uninstalled from Windows Phone 7 Emulator/Device...");
}
 
// Install XAP
Console.WriteLine("Installing sample XAP to Windows Phone 7 Emulator/Device...");
 
app = WP7Device.InstallApplication(
    appID,
    appID,
    "NormalApp",
    @"D:\visual studio 2010\Projects\ConsoleApplication1\WindowsPhoneApplication1\ApplicationIcon.png",
    @"D:\visual studio 2010\Projects\ConsoleApplication1\WindowsPhoneApplication1\Bin\Debug\WindowsPhoneApplication1.xap");
 
Console.WriteLine("Sample XAP installed to Windows Phone 7 Emulator...");
 
// Launch Application 
Console.WriteLine("Launching sample app on Windows Phone 7 Emulator...");
app.Launch();
Console.WriteLine("Launched sample app on Windows Phone 7 Emulator...");
 
Console.WriteLine("Reading Foo.txt Isolated Storage file:");
 
Thread.Sleep(10000);
//app.GetIsolatedStore(); <-- Throws NotImplementedException
object ConManServer = WP7Device.GetType().GetField("mConmanServer", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(WP7Device);
FileDeployer f = (FileDeployer)typeof(FileDeployer).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic)[0].Invoke(new object[] { ConManServer });
f.ReceiveFile(@"\Applications\Data\" + appID + @"\data\isolatedstore\Foo.txt", @"\Foo.txt");
 
Console.WriteLine("\t" + File.ReadAllText(@"foo.txt"));
 
Console.ReadLine();

Fin

In this blog post we’ve talked about why Automating the WP7 Emulator and Device deployment process is important and how to go about doing that.
Hopefully now you know how to automate WP7 XAP Deployment.

In the next blog post in this series we’ll talk about setting up a Continuous Integration build for WP7.

Are there any other use cases for WP7 Automation?
Are you planning on using this technique somewhere?
Was this a good blog post? Sound off in the comments.

Sincerely,

-- Justin Angel

justinangel.net Blog Feed.

Pre-beta Windows 8.1 WinRT Developer APIs

Methodology: How was this research done?

Table of Contents

Bluetooth 4.0 RfComm and GATT support

Point of sale: Barcode scanners and Magnetic card readers

Smart Cards

Lock screen Image Apps

VPN support for Metro apps

Scanner APIs and apps

Support for any IO and USB device

Native PDF rendering in apps

Multiple screens projection support in apps

XAML/WinJS: New resolution scaling support / Super-high resolution tablets

Camera: Low-lag cameras / HDR

New Metro App Types: Appointments, LockScreen, Contacts and GeoLoc

New App Type: GeoFenced activation

New App Type: Lock screen call

New App Type: Appointments Provider

Text-to-speech

Read-write access to Camera roll, Saved pictures and playlists

XAML/WinJS: new SearchBox control

XAML/WinJS: Hubs for SemanticZoom

XAML: DatePicker and TimePicker

XAML: Flyout, MenuFlyout and SettingsMenuFlyout

XAML: AppBar simplification

XAML: DataBinding Improvements

Globalization: Currencies, Numeral systems and Numerical formatters

Other minor but important Win8.1 features

How to code Win8.1 C# apps before public beta?

How to develop Win8.1 WinJS apps before public beta?

Disclaimer: Please don’t sue me

Feedback?

All new Windows Phone 7.5 Mango APIs

How was this article composed? Who is it meant for?

Table of Contents

Sensors API: overview, SensorBase and other supporting classes

Sensor API: Gyroscope and Compass

Sensor APIs: Combined Motion API

Sensor APIs: changes to the Accelerometer API

Camera API

Background API: overview and BackgroundTask class

Background API: Background Audio and streaming background Audio

Background API: Data Transfer APIs

Scheduling & Background API: Alarms, Reminders, Periodic Tasks and Resource Intensive Tasks

Background API: Programmatic Toast Notifications

Appointments and Contacts API: Overview

Appointments

Contacts

New Launchers and Choosers

Changes and additions to existing Launchers and Choosers

Secondary Tiles and primary tile improvements

Mixed XNA and Silverlight apps

LINQ-to-SQL and Local Database

Search Extensibility

Sockets: IP and DNS Addresses

Sockets: DNS Resolution

Sockets: Socket class and SocketAsyncEventArgs

Sockets: UDP

Shell UI: New ProgressIndicator, and changes to ApplicationBar & SystemTray

Bing Maps changes: Random XAML elements positioning

Removing Pages from the backstack frame journal

Device Information and Network Information

WebBrowser control changes: HTML5 GeoLocation and NavigationFailed event

Network Request Preference and Requirements

Xbox Live: Render Xbox Live Avatars in XNA

Xbox Live: Avatar Assets

Custom Linq Providers

Dynamically compiled Lambda Expressions and Reflection.Emit

mscorib.Extensions: SIMD/ARM-NEON XNA support

mscorlib.Extensions: Mutex

mscorlib.Extensions: INotifyPropertyChanging

mscorlib.Extensions: RSA Cryptography

Silverlight 4: Base-Class Library changes in mscorlib assembly

Silverlight 4: System.Windows Silverlight changes

Feedback? Leave a comment!

MetroBlog: Windows8 Metro Styled Blog

What are the top 2 features of this blog?

What’s the complete featurelist?

What technologies were used?