Alex Golesh's Blog About Silverlight Development

What’s New in Windows Phone 8 (6 out of 8)–Location services and maps

Alex Golesh — Tue, 06 Nov 2012 15:56:35 GMT

Windows Phone 8 brings long awaited updates to location services and brand new map control (with associated services) which is based on Nokia maps.

Location services

So what’s new in location services. First of all – the new WinRT API which is shared with Windows 8. To use location services application must declare the following capability in application manifest:

     <Capability Name="ID_CAP_LOCATION" />

The “main” class – Geolocator – belongs to Windows.Devices.Geolocation namespace and enables location tracking in good old “events” way and also new async model as follows:

    Geoposition currentPosition = await geoLocator.GetGeopositionAsync();

    // or

    Geoposition currentPosition = await geoLocator.GetGeopositionAsync(TimeSpan.FromMinutes(1), TimeSpan.FromSeconds(30));

Note: geoLocator is an instance of Geolocator object. Second call limits the results age and awaiting timeout.

The object itself could be activated as follows:

    if (geoLocator == null)

    {

        geoLocator = new Windows.Devices.Geolocation.Geolocator();

        geoLocator.DesiredAccuracy = Windows.Devices.Geolocation.PositionAccuracy.High; //Request high accuracy from GPS device

        geoLocator.DesiredAccuracyInMeters = 1; //Must have very precise for walking/running/biking tracking. Could use values of 50-100 for car

        geoLocator.ReportInterval = 1000; //1 second between updates usually is needed for constant updates for scenarios such as walking/running/biking tracking.

        geoLocator.StatusChanged += geoLoc_StatusChanged; //Subscribe for status changes

        geoLocator.PositionChanged += geoLoc_PositionChanged; //Subscribe for continues position changes updates

    }

The PositionChanged result brings information such as CivicAddress, Coordinate information with Latitude, Longitude, Speed, Heading, Accuracy, Altitude, etc. fields which crucial for location-aware applications.

Sample code snippet for PositionChanged event:

    if (position.CivicAddress != null)

        Debug.WriteLine(string.Format("City = {0}, Postal Code = {1}, State = {2}, Country = {3}",

                                      position.CivicAddress.City, 

                                      position.CivicAddress.PostalCode, 

                                      position.CivicAddress.State, 

                                      position.CivicAddress.Country));

    Dispatcher.BeginInvoke(() =>

    {

        txtLat.Text = position.Coordinate.Latitude.ToString();

        txtLon.Text = position.Coordinate.Longitude.ToString();

        txtSpeed.Text = position.Coordinate.Speed.HasValue ? position.Coordinate.Speed.ToString() : "UNKNOWN";

        txtHeading.Text = position.Coordinate.Heading.HasValue ? position.Coordinate.Heading.ToString() : "UNKNOWN";

    });

Note: this sample code simply outputs the info on screen. While this change in API is interesting, the real power comes with ability to track the location when application is not active – works in background.

Background Execution

As you probably remember, on Windows Phone only one app runs in the foreground – the one which is visible on screen. When user navigates away from an app (either by pressing the Start button or by launching another app) the current app is suspended and may be terminated and tombstoned. In Windows Phone 8, a location-tracking app can continue to run in the background after the user navigates away, as long as the app continues to actively track location. This feature is absolutely must for scenarios such as an app that provides turn-by-turn directions. Let’s see how to enable the background execution.

First of all – to work in background the application must actively track the location: use Geolocator.

Also, to successfully use the Geolocator application must declare location capability (ID_CAP_LOCATION) as described above.

Next, application must require background execution in DefaultTask definition in application manifest as follows:

    <DefaultTask Name="_default" NavigationPage="MainPage.xaml">

      <BackgroundExecution>

        <ExecutionType Name="LocationTracking" />

      </BackgroundExecution>

    </DefaultTask>

Note: If more than one application requires background execution, only last one will be allowed to work in background. All previous/other “background executions” will be stopped.

Last, but not least, the application must handle RunningInBackground event which raised when location-tracking application transitions to background. When this event is raised, the application should stop all tasks that are not related to location tracking, including updates to the app’s UI. Subscribing to this even is done through App.xaml:

    <shell:PhoneApplicationService

        Launching="Application_Launching" Closing="Application_Closing"

        Activated="Application_Activated" Deactivated="Application_Deactivated"

        RunningInBackground="PhoneApplicationService_RunningInBackground"/>

Handling the event in code:

    public static bool isRunningInBackground = false;

    private void PhoneApplicationService_RunningInBackground(object sender, RunningInBackgroundEventArgs e)

    {

        isRunningInBackground = true;

        //Stop all unnecessary processes

    }

    private void Application_Activated(object sender, ActivatedEventArgs e)

    {

        isRunningInBackground = false;

    }

In my simple scenario, the location updates from background execution will be used to update application’s main tile:

    FlipTileData ftd = new FlipTileData()

    {

        Count = updatesCount,

        Title = "Position updated",

        BackTitle = position.Coordinate.Timestamp.ToLocalTime().ToString(),

        BackContent = string.Format("New position is LAT: {0}, LON: {1}",

                              position.Coordinate.Latitude,

                              position.Coordinate.Longitude),

        WideBackContent = string.Format("New position is LAT: {0}, LON: {1}. Moving with speed of {2} m/s with course of {3}°",

                              position.Coordinate.Latitude,

                              position.Coordinate.Longitude,

                              position.Coordinate.Speed.HasValue ? position.Coordinate.Speed.ToString() : "UNKNOWN",

                              position.Coordinate.Heading.HasValue ? position.Coordinate.Heading.ToString() : "UNKNOWN"),

    };

    mainTile.Update(ftd);

Those updates produces the following results:

Note: please see the video at the end of this post to see the application working in background

Maps

In additional to great improvements to location services described above, Windows Phone 8 switches map component to Nokia maps. The new control could be found in Microsoft.Phone.Maps.Controls namespace (Microsoft.Phone.Maps assembly) and could be instantiated either from XAML or code behind. Sample XAML initialization:

    <Controls:Map HorizontalAlignment="Center" VerticalAlignment="Center"

                  Width="450" Height="400" x:Name="map"

                  PedestrianFeaturesEnabled="True" LandmarksEnabled="True" ZoomLevel="17"/>

Note: the controls namespace defined in XAML’s header file as follows:

    xmlns:Controls="clr-namespace:Microsoft.Phone.Maps.Controls;assembly=Microsoft.Phone.Maps"

Once defined, the map’s properties could be also altered from code behind:

    map.Pitch = 40;

Map supports different cartographic modes (Road, Hybrid, Areal, Terrain), color modes (Light, Dark), presenting landmarks/pedestrian features, pitch and rotation:

In addition, map supports multiple overlay layers which could be presented over map (car icon on image above) as follows:

    BitmapImage bitmapImage = new BitmapImage(new Uri("/Images/car.png", UriKind.Relative));

    Image img = new Image();

    img.Source = bitmapImage;

    mapOverlay = new MapOverlay();

    mapOverlay.PositionOrigin = new Point(0.5, 0.5);

    mapOverlay.Content = img;

    mapOverlay.GeoCoordinate = map.Center;

    MapLayer MyLayer = new MapLayer();

    MyLayer.Add(mapOverlay);

    map.Layers.Add(MyLayer);

Last, the map provides services, such as GeocodeQuery, ReverseGeocodeQuery and RouteQuery. Latter could be used to calculate (and display on ap) route between two given geo coordinates as follows:

    RouteQuery routeQuery = new RouteQuery();

    routeQuery.QueryCompleted += routeQuery_QueryCompleted;

    void routeQuery_QueryCompleted(object sender, QueryCompletedEventArgs<Route> e)

    {

        Route theRoute = e.Result;

        MapRoute calculatedMapRoute = new MapRoute(theRoute);

        map.AddRoute(calculatedMapRoute);

    }

    private void btnShowRoute_Click(object sender, RoutedEventArgs e)

    {

        if (!routeQuery.IsBusy)

        {

            List<GeoCoordinate> routeCoordinates = new List<GeoCoordinate>();

            routeCoordinates.Add(new GeoCoordinate(48.860339, 2.337599)); //Eiffel Tower coordinates

            routeCoordinates.Add(new GeoCoordinate(48.8583, 2.2945)); //Louvre coordinates

            routeQuery.Waypoints = routeCoordinates;

            routeQuery.QueryAsync();

            map.Center = new GeoCoordinate(48.8583, 2.2945); //Center map on first coordinates

        }

    }

Clicking the “Show Route” button calculates the route and shows it on map:

The navigation instructions are also available and could be presented to user as follows:

    //...

    List<string> legsList = new List<string>();

    foreach (RouteLeg leg in MyRoute.Legs)

    {

       foreach (RouteManeuver routeManeuver in leg.Maneuvers)

       {

          legsList.Add(routeManeuver.InstructionText);

       }

    }

    //lstRouteList is a list showing the legs

    lstRouteList.ItemsSource = legsList;

Working sample application video:

Sample location aware application

Next time I will blog about in-app-purchases (IAP) and new Windows.ApplicationModel.Store namespace shared with Windows 8.

Stay tuned,

Alex

What’s New in Windows Phone 8 (5 out of 8)–Quick tip: creating hybrid applications

Alex Golesh — Mon, 05 Nov 2012 20:30:02 GMT

One important feature in Windows Phone 8 is ability to develop high performance applications using Direct3D graphics and C++. While this feature clearly targets game developers, many applications could also gain performance combining native code with C++ components. Moreover, even when developing XAML/C# applications, it is possible to fully leverage modern GPU in Windows Phone 8 device by mixing XAML flexibility with Direct3D graphics.

Note: Pure native development using Direct3D are not covered in this post.

Let’s overview two other options: first is to use Direct3D graphics is XAML/C# application. Windows Phone 8 SDK provides very good starting point for such application:

Application created with this template combines standard Windows Phone 8 XAML application and WinRT native component. To integrate Direct3D surface into managed application, use new DrawingSurface XAML element. As standard XAML element it supports all standard XAML properties incl. Projection and RenderTransform and plays nicely with other XAML elements in layout. The following code snippet, for example, produce image below:

     <Grid x:Name="LayoutRoot" Background="Transparent">

        <DrawingSurface x:Name="DrawingSurface">

            <DrawingSurface.Projection>

                <PlaneProjection CenterOfRotationX=".5" CenterOfRotationY=".5" CenterOfRotationZ=".5" 

                                    RotationX="-30" RotationY="30" RotationZ="30"/>

            </DrawingSurface.Projection>

            <DrawingSurface.RenderTransformOrigin>

                <Point X=".5" Y=".5"/>

            </DrawingSurface.RenderTransformOrigin>

            <DrawingSurface.RenderTransform>

                <CompositeTransform Rotation="-25" ScaleX=".7" ScaleY="-1" TranslateY="20"/>

            </DrawingSurface.RenderTransform>

        </DrawingSurface>

        <Canvas>

            <TextBlock x:Name="textBlock" Text="Hello from Windows Phone 8!" HorizontalAlignment="Center" VerticalAlignment="Top" FontSize="25"

                        Canvas.Top="100" Canvas.Left="500"/>

        </Canvas>

        <Button Content="About" VerticalAlignment="Bottom" HorizontalAlignment="Center" Click="Button_Click_1"/>

    </Grid>

The whole idea of this “mix” is very similar to hybrid Silverlight & XNA applications introduces back in Windows Phone 7.5.

The DrawingSurface is initialized with Windows Phone Runtime object that implements the IDrawingSurfaceProvider interface. The default templates provides sample of such component which implements 3D cube render. For more info please refer to documentation.

Second option available for developers is to integrate/reuse native code containing business logic with Windows 8 other other platforms. Also, in many cases integrating native code (especially for complex algorithmic manipulations) could add noticeable performance boost to application. Let’s see how to achieve this.

My sample application uses “heavy” math calculations as managed component:

    namespace ManagedLibrary

    {

        public class ManagedCalculator

        {

            public long Factorial(long n)

            {

                long nfac = 1;

                for (int i = 2; i < n + 1; i++)

                {

                    nfac *= i;

                }

                return nfac;

            }

        }

    }

As you see, this code calculates factorial for given number.

Note: the factorial calculation was not implemented as recursive function to be fully compatible with native code presented below.

The managed library used to calculate the factorials – let’s pretend it is a part of application’s business logic – as follows:

    ManagedCalculator calc = new ManagedCalculator();

    System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();

    long ticks = 0;

    for (int j = 0; j < numOfTrials; j++)

    {

        sw.Start();

        for (int i = 0; i < maxRuns; i++)

            calc.Factorial(rnd.Next(maxFactorialOf));

        sw.Stop();

        ticks += sw.ElapsedTicks;

        sw.Reset();

    }

    txtManaged.Text = "Average calculation time was " + ticks / numOfTrials + " ticks";

This code snippet invokes factorial calclation for fandom number given number of runs (maxRuns) for known number of trials (numOfTrials) and caluclates average runtime (in ticks).

Let’s have exact same functionality as managed WinRT component. To do it, we need to add new project and reference it from the applcation:

The header file for this component looks super simple:

    namespace NativeLibrary

    {

        public ref class NativeCalculator sealed

        {

        public:

            NativeCalculator();

            int64 Factorial(int64 n);

        };

    }

And implemntation class is also very simple:

    #include "pch.h"

    #include "NativeLibrary.h"

    using namespace NativeLibrary;

    using namespace Platform;

    NativeCalculator::NativeCalculator()

    {

    }

    int64 NativeCalculator::Factorial(int64 n)

    {

        long nfac=1;

        for(int i=2; i < n+1; i++)

        { 

            nfac *= i; 

        }

        return nfac;

    }

Note, that factorial code is exact the same as in managed code.

Once native component is ready it could be referenced from main app:

and used as standard managed component:

    NativeCalculator calc = new NativeCalculator();

    System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();

    //Warm up run

    calc.Factorial(10);

    long ticks = 0;

    for (int j = 0; j < numOfTrials; j++)

    {

        sw.Start();

        for (int i = 0; i < maxRuns; i++)

            calc.Factorial(rnd.Next(maxFactorialOf));

        sw.Stop();

        ticks += sw.ElapsedTicks;

        sw.Reset();

    }

    txtNative.Text = "Average calculation time was " + ticks / numOfTrials + " ticks";

Note, that again, only difference is the type of created object.

Runnig this application reveals interesting facts – the bigger number we are trying to calculate factorial for, the bigger gain in performance we are getting with native code.

With maxFactorialOf = 10 the results are not in favor of native code:

If setting the maxFactorialOf = 100, the results are different and while still comparable, the native code clearly wins:

Setting maxFactorialOf = 1000 shows, that native is clearly faster – in this case almost twice faster than managed code:

Setting maxFactorialOf = 10000 allwos native code shine and beat native code completely:

Does it means, that all calculations (even smallest one) should be moved to managed code, just because it is faster? Not necessary. If you are migrating from another platform and have logic already written using native code then the answer probably yes (giving the fact, that native development not as easy as managed one). If you already using managed code your probably not necessary will gain major performance boost just by rewriting some of the business logic as native library. You could try, but “your mileage may vary”. One thing is for sure – it could introduce more bugs related to new native component.

That’s it for this post. Next time I will blog about location services and new map functionality.

Stay tuned,

Alex

What’s New in Windows Phone 8 (4 out of 8)–Protocol handler and file extensions

Alex Golesh — Fri, 02 Nov 2012 16:23:01 GMT

This post is dedicated to new extensibility feature – ability to associate file extension and protocol type to automatically launch your app when another app launches a specific file type or URI. When launched, a deep link URI is used to send the file (a reference to the file) or URI to application. You can also use the association launching API to launch another app in the same way.

File type association is useful when your app need automatically launch on invoking specific file type from email attachment, NFC tag, text message, another application.

Protocol association is useful when your application need automatically launch on invoking specific URI, such as mailto://, http://, etc.

File associations

Registration to file type (file extension) achieved via FileTypeAssociation element in Extensions element of application manifest. The following code snippet registers application to handle files with “.smpl” and “.sample” extensions:

     <FileTypeAssociation Name="SampleLaunch" TaskID="_default" NavUriFragment="fileToken=%s">

      <!--<Logos>

        <Logo Size="Small">small.png</Logo>

        <Logo Size="Medium">medium.png</Logo>

        <Logo Size="Large">large.png</Logo>

      </Logos>-->

      <SupportedFileTypes>

        <FileType>.smpl</FileType>

        <FileType>.sample</FileType>

      </SupportedFileTypes>

    </FileTypeAssociation>

Please note optional Logos section (commented in sample) – this section lists an image file to appear beside a file. The files in this section sized/used as follows:

Size	Image dimensions	Usage
Small	33x33	Email attachments
Medium	69x69	Office hub files list
Large	176x176	IE download list

When the application is launched to handle a particular file type, a deep link URI passed to the application. The URI looks like the following:

    /FileTypeAssociation?fileToken={TOKEN_GUID}

Within the URI, the FileTypeAssociation string designates that the source of the URI is a file association and the fileToken parameter contains the file token GUID. Those parameters could be easily parsed and rerouted to internal handler page.

Usually, to handle multiple URI types application defines URI mapper class which parses the inbounding URI and reroutes to application’s page. The sample URI mapper class to handle such URI could look like the following code snippet:

    class CustomUriMapper : UriMapperBase

    {

        private static string TargetFilePageName = "FilePage.xaml";

        private static string FileTemplate = "/FileTypeAssociation?fileToken=";

        public override Uri MapUri(Uri uri)

        {

            string tempUri = HttpUtility.UrlDecode(uri.ToString());

            if (tempUri.Contains("/FileTypeAssociation"))

                    return GetFileMappedUri(tempUri);

            return uri;

        }

        private Uri GetMappedUri(string uri)

        {

            //...

        }

    }

Note: this code is partial, application logic is omitted for code brevity.

To URI mapper class used in app by assigning it to RootFrame.UriMapper property in App.xaml.cs after initializing RootFrame object:

    //...

    RootFrame = new PhoneApplicationFrame();

    RootFrame.Navigated += CompleteInitializePhoneApplication;

    RootFrame.UriMapper = new CustomUriMapper();

    // Handle navigation failures

    RootFrame.NavigationFailed += RootFrame_NavigationFailed;

    //..

Once application launched from file association, the URI mapper will intercept the URI and reroute (in sample code above) to FilePage.xaml page. To open the file by received file association, use SharedStorageAccessManager from Windows.Phone.Storage.SharedAccess namespace. SharedStorageAccessManager provides access to files that have been shared with a file association:

    //Get token from query string

    string fileToken = NavigationContext.QueryString["ID"];

    //Resolve filename

    var filename = SharedStorageAccessManager.GetSharedFileName(fileToken);

    //Copy file to local folder

    var file = await SharedStorageAccessManager.CopySharedFileAsync(Windows.Storage.ApplicationData.Current.LocalFolder,

                                                                        fileToken + ".smpl", Windows.Storage.NameCollisionOption.ReplaceExisting,

                                                                        fileToken);

    //Open local file

    var content = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);

    //...

Testing file association is easy with Launcher class from System.Windows namespace. It provides LaunchFileAsync function which starts default app associated with specified file type:

    StorageFile recipeFile = await local.GetFileAsync("SampleFile.smpl");

    if (null != recipeFile)

        await Windows.System.Launcher.LaunchFileAsync(recipeFile);

Note: this functionality is launched from another application which serves as tester app for real application.

Protocol associations

A protocol association allows your app to automatically launch when another app launches a special URI. This special URI could look like the following (using in sample for this post):

    sample://showSample?ID=1004

To handle protocol, application must manifest new extra in application manifest must (in Extras section):

    <Protocol Name="sample" TaskID="_default" NavUriFragment="encodedLaunchUri=%s" />

In this code snippet “sample” is the name of custom protocol which will be used to launch the application.

Once user clicks on hyper link with this protocol, or other application invokes navigation to such protocol the application starts with following deep link URI passed to the application:

    /Protocol?encodedLaunchUri=sample://showSample/?ID=1234

Like in file association scenario, it is easy to intercept such links with URI mapper and reroute to internal page in application:

    public override Uri MapUri(Uri uri)

    {

        string tempUri = HttpUtility.UrlDecode(uri.ToString());

        if (tempUri.Contains("/Protocol"))

            return GetMappedUri(tempUri);

        return uri;

    }

    private Uri GetMappedUri(string uri)

    {

        //...

    }

The major difference from file association is that the amount information in URI is much more limited than in file.

To test the application you can create simple HTML file and host on some webhosting (for example this post uses the following HTML file hosted at http://www.alexgolesh.com/sample.html:

    <!DOCTYPE html>

    <html xmlns="http://www.w3.org/1999/xhtml" >

    <head>

        <title>Sample launcher</title>

    </head>

    <body>

        <h1>Protocol and File extenstion handlers sample</h1>

        <div>

            <h2>This section invokes "sample://" protocol for my blog sample.</h2>

            <a href="sample://showSample?ID=1234">Click here to launch blog sample</a>

        </div>

    </body>

    </html>

Alternatively, protocol handler can be invoking using same Launcher class from System.Windows namespace as for file association. It provides LaunchUriAsync function which starts default app associated with protocol:

    Uri uri = new Uri("sample://showSample?ID=1004");

    Windows.System.Launcher.LaunchUriAsync(uri);

Note: this functionality is launched from another application which serves as tester app for real application.

Working sample presented at the following vide

Video of file associations and protocol handler sample

Next time I will blog about hybrid applications which combines native and managed code together.

Stay tuned,

Alex

What’s New in Windows Phone 8 (3 out of 8)–Voice Recognition

Alex Golesh — Thu, 01 Nov 2012 17:17:00 GMT

This post dedicated to additional interesting feature in Windows Phone 8 – voice recognition and speech synthesizing.

Speech synthesizing

Let’s start from speech synthesizing. The functionality localized in Windows.Phone.Speech.Synthesis namespace. Using classes in this namespace you can create text-to-speech (TTS) scenarios in your application. The functionality enables read some document identified by URI, string of text with SSML markup or plain text. My sample focuses on plain text scenario.

Class responsible for speech synthesizing is SpeechSynthesizer. To speak plain text use code snippet below:

SpeechSynthesizer synth = new SpeechSynthesizer();

await synth.SpeakTextAsync("Hello from Windows Phone 8");

Speech synthesizer supports changing speech voice from system installed voice. The following code snippet select random voice and speaks out greeting text using this voice:

var voices = Windows.Phone.Speech.Synthesis.InstalledVoices.All;

int voiceNumber = rnd.Next(voices.Count);

synth.SetVoice(voices[voiceNumber]);

CultureInfo ci = new CultureInfo(voices[voiceNumber].Language);

string lang = ci.EnglishName;

int pos = ci.EnglishName.IndexOf("(");

if (pos > 0)

    lang = lang.Substring(0, pos - 1);

await synth.SpeakTextAsync("Hello from voice of " + voices[voiceNumber].DisplayName +

                            ". I'm a " + voices[voiceNumber].Gender +

                            ". I'm specializing in " + lang + " language");

Sometimes, like in snippet above speech process could take some time. In case your application logic needs to cancel speech process, it is advised to use IAsyncOperation instead of new await keyword. The following code demonstrates this approach – user presented with message box and same text synthesized using SpeechSynthesizer. When user closes MessageBox the speech stops:

SpeechSynthesizer synth = new SpeechSynthesizer();

string theMessage = "Pages updated. From outside the app, press and hold the Start button and say 'Blog Sample show me last page'";

try

    var task = synth.SpeakTextAsync(theMessage);

    MessageBox.Show(theMessage);

    task.Cancel();

catch (TaskCanceledException TaskEx)

    //Ignore the error - expected when cancelling the task

catch (Exception ex)

    //Some other error...

    //...

Now, let’s move to speech recognition.

Speech Recognition

Speech recognition support for applications based on defined list of voice commands and grammars. Also built-in grammar is available. Voice commands and user-defined grammars could be used to build in-app navigation, while built-in grammars could be used to build short message dictation or in-app/web search queries functionality.

Voice commands file is an XML file which defines a list of commands application listens to. Before using speech recognition application must initialize voice commands from file or from code using APIs described later. Voice commands file looks like the following code snippet:

<?xml version="1.0" encoding="utf-8" ?>

<VoiceCommands xmlns="http://schemas.microsoft.com/voicecommands/1.0">

  <CommandSet xml:lang="en-us" Name="NavigationCommands">

    <CommandPrefix>Blog Sample</CommandPrefix>

    <Example>Show (Page Number) page</Example>

    <Command Name="showPage">

      <Example>Show me (some) page</Example>

      <ListenFor>[Show] [me] {pageNames} page</ListenFor>

      <ListenFor>Go to {pageNames} page </ListenFor>

      <Feedback>Navigating to {pageNames} page...</Feedback>

      <Navigate Target="/ThePage.xaml"/>

    </Command>

    <Command Name="showAboutPage">

      <Example>Show me the About Page</Example>

      <ListenFor>show [me] the about page</ListenFor>

      <ListenFor>the about page</ListenFor>

      <Feedback>Showing you the About page...</Feedback>

      <Navigate Target="About.xaml"/>

    </Command>

    <PhraseList Label="pageNames">

      <Item>First</Item>

      <Item>Second</Item>

      <Item>Third</Item>

    </PhraseList>

  </CommandSet>

  <!-- Other CommandSets for other languages -->

</VoiceCommands>

Few “special” elements on such file:

{} - Contains the reference to a value from corresponding PhraseList

[] – Designates optional word or words.

Note: for complete reference of available options for VoiceCommand files refer to documentation.

Grammar files also defines the words and phrases that an application will recognize in speech input. Like voice commands, grammars are also using the XML formatted file defined by the Speech Recognition Grammar Specification (SRGS) Version 1.0. Also this file should be loaded before using grammars or initialized from code behind. Sample grammar file looks like:

<?xml version="1.0" encoding="utf-8" ?>

<grammar version="1.0" xml:lang="en-US" root="sampleCommand" tag-format="semantics/1.0" xmlns="http://www.w3.org/2001/06/grammar"

         xmlns:sapi="http://schemas.microsoft.com/Speech/2002/06/SRGSExtensions">

  <rule id="sampleCommand" scope="public">

    Navigate to

    <one-of>

      <item> page </item>

      <item> item </item>

    </one-of>

    <item repeat="0-1"> in the </item>

    <ruleref uri="#pages"/>

    <one-of>

      <item repeat="0-1"> pages </item>

      <item repeat="0-1"> items </item>

    </one-of>

  </rule>

  <rule id="pages" scope="public">

    <one-of>

      <item> Interesting </item>

      <item> Boring </item>

      <item> New </item>

      <item> Old </item>

      <item> Personal </item>

    </one-of>

  </rule>

</grammar>

Note: For complete descriptions of SRGS grammar elements, refer to documentation.

Now let’s see how to use those files from within application.

To use voice recognition, the application must declare the following capabilities (in application manifest):

<Capability Name="ID_CAP_SPEECH_RECOGNITION" />

<Capability Name="ID_CAP_MICROPHONE" />

Let’s see how to initialize speech recognizer with Voice Commands file:

try

    // Set the path to the Voice Command Definition (VCD) file.

    String path = Windows.ApplicationModel.Package.Current.InstalledLocation.Path + "\\VoiceCommands.xml";

    Uri uri = new Uri(path, UriKind.Absolute);

    // Load the VCD file.

    await Windows.Phone.Speech.VoiceCommands.VoiceCommandService.InstallCommandSetsFromFileAsync(uri);

    //...

catch (Exception ex)

    //...

From now on the application’s commands are available for phone-wide speech commands. This means, that user could long press windows key and say something like: “Blog Sample show second page” or “Blog Sample Go to Third page”. As result to recognized text, the page defined Navigate element of voice command file will be invoked. Also, user could ask phone “What can I say?” and receive list of available commands incl. the applications registered using voice commands:

As response to recognized text system provides visual and spoken response:

As mentioned before, the page in the app is invoked. Navigation context holds information which helps to support voice recognition scenarios. In case of voice initiated navigation the query string contains recognized voice command (“voiceCommandName”), recognition result (“reco”) and recognized text in PhraseList named element. In case of voice command file defined above, the query string contains the following values:

voiceCommandName = showPage

reco = Blog Sample Show Third page

pageName = Third

Note, that italic information provided based on VCD file.

This information could be used while processing navigation arguments in OnNavigatedTo function as follows:

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

    base.OnNavigatedTo(e);

    if (NavigationContext.QueryString.ContainsKey("voiceCommandName"))

        string voiceCommandName = NavigationContext.QueryString["voiceCommandName"];

        switch (voiceCommandName)

            case "showPage":

                string pageNumber = NavigationContext.QueryString["pageNames"];

                PageTitle.Text = pageNumber + " page";

                break;

            case //...

            //...

            default:

                break;

Last, but not least – modifications to voice commands once loaded. In some case application manipulates with dynamic data which should be exposed in VCD file. In such case the commands list could be dynamically updated as follows:

try

    IReadOnlyDictionary<String, VoiceCommandSet> collectionOfCommandSets = VoiceCommandService.InstalledCommandSets;

    VoiceCommandSet targetCommandSet = collectionOfCommandSets["NavigationCommands"];

    String[] updatedPagesList = { "First", "Second", "Third", "Fourth", "Fifth",

                                    "Other", "Interesting", "Boring", "Last" };

    await targetCommandSet.UpdatePhraseListAsync("pageNames", updatedPagesList);

    //...

catch (Exception ex)

    //...

Notes: The “NavigationCommands” is the name of CommandSet in loaded VCD file and “pageNames” is the PhraseList label in VCD file.

Now let’s see how to recognize the speech from within the application.

Speech recognizers located in Windows.Phone.Speech.Recognition namespace. There are two of them: SpeechRecognizerUI and SpeechRecognizer. SpeechRecognizerUI provides built-in experience while listening to the speech and can show system confirmation after recognition. SpeechRecognizer enables user-defined speech scenarios as it doesn’t show any UI. Before first usage of speech recognizer it must be initialized. Also custom grammar/voice commands should be loaded, otherwise built-in system grammar will be used.

Note: Built-in dictation and web search grammars are large files and they are reside online (not on the phone). The performance may not be as fast as with custom, on-phone grammars.

While initializing speech recognizer application can provide various options, like text to be shown on system UI (in case of SpeechRecognizerUI), showing recognition confirmations (voice and textual), etc.

SpeechRecognizerUI recognizer;

bool speechInitialized = false;

List<string> pagesList = new List<string>();

//...

private void InitializePagesList()

    pagesList.Add("First");

    pagesList.Add("Second");

    pagesList.Add("Third");

    pagesList.Add("Fourth");

    pagesList.Add("Fifth");

private void InitializeSpeechRecognition()

    if (this.speechInitialized)

        return;

try

        speechInitialized = true;

        recognizer = new SpeechRecognizerUI();

        recognizer.Settings.ListenText = "Navigate to which page?";

        recognizer.Settings.ExampleText = "For example, 'First' or 'Second'";

        recognizer.Settings.ShowConfirmation = true;

        recognizer.Recognizer.Grammars.AddGrammarFromList("pages", pagesList);

    catch (Exception ex)

        //...

Alternatively, application could initialize speech recognition from SRGS file (instead of using AddGrammarFromList):

string path = Package.Current.InstalledLocation.Path + "\\CostomSRGSGrammars.xml";

Uri customGrammar = new Uri(path, UriKind.Absolute);

recoWithUI.Recognizer.Grammars.AddGrammarFromUri("appCommands", customGrammar);

await recoWithUI.Recognizer.PreloadGrammarsAsync();

Once speech recognizer initialized and configured it could be started as follows:

var recoResult = await recognizer.RecognizeWithUIAsync();

The recognition result provides ResultStatus and RecognitionResult which among other information holds recognized Text and TextConfidence and RuleName. Those parameters could be used in application logic. Next code snippet uses Text and TextConfidence for navigation purposes:

var url = string.Format("/ThePage.xaml?recognizedPage={0}&confidence={1}",

                        recoResult.RecognitionResult.Text,

                        recoResult.RecognitionResult.TextConfidence);

NavigationService.Navigate(new Uri(url, UriKind.Relative));

It it important to mention, that application can use more than one speech recognizer object and each once could be initialized with its own grammars.

That is all about voice recognition and speech synthesizing in Windows Phone 8.

Next time I will show how to associate application with file extension and handle custom protocol.

Stay tuned,

Alex

What’s New in Windows Phone 8 (2 out of 8)–Lock Screen

Alex Golesh — Wed, 31 Oct 2012 18:17:43 GMT

In previous post I described how to enrich user experience by customizing application tiles. In this post I will show how to enable your application to present some information on phone’s lock screen.

In Windows Phone 8 applications could provide 3 pieces of info on lock screen: application’s icon, count and text. On screenshot below my sample application provides icon, count and some text:

If application selected by user, the lock screen could show app icon defined in app manifest, count and text pulled directly from the application's primary tile. The secondary tiles does not have an impact on lock screen.

Let’s see how to achieve it. First of all – icon presented on lock screen must be 24x24 transparent PNG image with white pixels (plus transparent pixels obviously). Once such image created, add it to the application and then open application manifest using XML editor as follows (right click on manifest file and select “Open With…”:

Then select XML (Text) Editor:

Locate “DeviceLockImageURI” element (within PrimaryToken/Template definition) and specify path to the image:

     <DeviceLockImageURI IsRelative="true" IsResource="false">Images\lock_icon.png</DeviceLockImageURI>

To enable application icon and count add new Extensions element and new Extension as follows:

    <Extensions>

      <Extension ExtensionName="LockScreen_Notification_IconCount" ConsumerID="{111DFF24-AA15-4A96-8006-2BFF8122084F}" TaskID="_default" />

    </Extensions>

Note:Extension element must be next to Tokens element.

If you plan to provide lock screen with text updates, add the following Extension element to the Extensions section:

    <Extension ExtensionName="LockScreen_Notification_TextField" ConsumerID="{111DFF24-AA15-4A96-8006-2BFF8122084F}" TaskID="_default" />

Note:Your application could use multiple extension elements, but consider providing only those, which are really used by the application.

Also note: As the text pulled directly from the application's primary tile, cyclic tile template shouldn’t be used with LockScreen_Notification_TextField extension as it has no text.

Once application with extensions in manifest deployed to device, user can select the application in Settings/Lock Screen section – application name will be available for selection at notifications sections (detailed and quick status):

Note: the settings should be done by user from Settings menu and cannot be defined form code.

Lock screen Background

In addition to information presented above, Windows Phone 8 application could be then chosen lock screen background provider application, so that application can provide the lock screen background.

To enable this functionality your application must declare additional Extension in application manifest (could be used with or without other lock screen extensions):

    <Extension ExtensionName="LockScreen_Background" ConsumerID="{111DFF24-AA15-4A96-8006-2BFF8122084F}" TaskID="_default" />

Once defined (after deployment) user will be able to choose your application form list of the applications with same functionality on the device:

In addition to this manual method the default lock screen provide could also be changed from code. Let’s see how to request provide lock screen background from code:

    //Check if application already lock screen background provider

    if (!LockScreenManager.IsProvidedByCurrentApplication)

    {

        //No, request to be active lockscreen wallpaper provider

        var res = await LockScreenManager.RequestAccessAsync();

        if (res == LockScreenRequestResult.Granted)

        {

            //Request approved

            //...

        }

        else

        {

            //Request rejected

            //...

        }

    }

The code snippet checks if lock screen already provided by current application, and if not raises request. This request is raised to user as following message box (system provided):

User approval equivalent to Settings change.

Note: user can change this at any time using Settings screen, thus before setting actual background the app should change it it is still current provider.

Now, let’s see how to set lock screen background:

    if (LockScreenManager.IsProvidedByCurrentApplication)

    {

        string fileName = "ms-appx:///Images/WP1.JPG";

        Uri uri = new Uri(fileName, UriKind.RelativeOrAbsolute);

        LockScreen.SetImageUri(uri);

        //Lock screen background set

        //...

    }

This code snippet verifies that application is still active lock screen background provider and invokes LockScreen.SetImageUri function which changes the background.

In addition, the LockScreen class provides access to current background image URI by LockScreen.GetImageUri function.

Simulation Dashboard

New version of Windows Phone Emulator and SDK provides new tool called Simulation Dashboard which enables simulation of various network conditions, lock screen and reminders. This tool located in Tools menu in Visual Studio:

Use radio buttons in Lock Screen section to simulate locking the screen on emulator.

That’s it for now. Next time I will show how to integrate voice recognition into your application.

Stay tuned,

Alex

What’s New in Windows Phone 8 (1 out of 8)–Tiles

Alex Golesh — Tue, 30 Oct 2012 18:33:00 GMT

One of the most noticeable feature of Windows Phone 8 is change of main screen with 3 different tile types:

Each tile could be one out from 3 types available sizes – small, normal and wide. Also, each type could be form 3 different types – Iconic, Flip and Cycle.

All 3 sizes and all 3 types are available for 3rd party developers. Let’s see how to use this interesting feature in the application.

So what are the sizes? The sizes are:

Small

Medium

Wide

What about 3 types? The types are:

Flip – this tile flips from front to back exposing front and back content

Iconic – this tile mimics Metro design

Cycle – this tile cycles through collection of local images (up to nine images could be defined)

It is important to mention, that all “interesting” tile functionality such as cycling images and flipping available only for medium and wide tiles. In case of Flip/Cycle tiles, small tile shows static image as defined in application manifest (see below).

To switch between different tile sizes tap and hold on the tile. In addition to “unpin” icon from previous version new version shows additional icon which enables size change:

Working with the tiles

Main tile type (template) is defined via application manifest:

Also manifest is used to enable support for wide tile (“Support for large Tiles” checkbox) and define initial tile graphics. It is important to define main tile type which suites best your application’s needs as it cannot be changed later.

For best results it is important to provide tile graphics according to expected sizes, though wrongly sized graphics will be presented anyway with possible visual distortions. The sizes are:

Tile Size	Flip Tile	Cycle Tile	Iconic Tile
Small	159x159	159x159	110x110
Medium	336x336	33x336	202x202
Wide	691x336	691x336	N/A

The content of main tile could be changed from code, though, as mentioned before, the tile template couldn’t be changed. The following code snippet changes the content of main app tile:

var mainTile = ShellTile.ActiveTiles.FirstOrDefault();

if (mainTile != null)

    IconicTileData tileData = new IconicTileData()

        Count = 73,

        BackgroundColor = Colors.Green,

        Title = "Main",

        IconImage = new Uri("/Assets/Tiles/IconicTileMediumLarge.png", UriKind.RelativeOrAbsolute),

        SmallIconImage = new Uri("/Assets/Tiles/IconicTileSmall.png", UriKind.RelativeOrAbsolute),

        WideContent1 = "Wide content 1",

        WideContent2 = "Wide content 2",

        WideContent3 = "Wide content 3",

};

    mainTile.Update(tileData);

This code snippet updates main tile using IconicTileData class (as application tile defined in app manifest as Iconic tile – see image above). This snippet uses all possible properties, many of them are optional (such as wide contents for example). The code snippet updates main tile which looks like the following:

Original tile	Update tile

* Numbers on small and medium tiles cut due to bug in early build of SDK used while writing this post

The templates used for main tile could be used to create and update also secondary tiles for application.

Let’s see how to create secondary tile using Flip template:

//Flip

FlipTileData tileData = new FlipTileData()

    Title = "Flip",

    Count = 12,

    BackgroundImage = new Uri("/Assets/Tiles/FlipCycleTileMedium.png", UriKind.RelativeOrAbsolute),

    BackBackgroundImage = new Uri("/Assets/Tiles/FlipCycleTileMedium.png", UriKind.RelativeOrAbsolute),

    BackTitle = "Flip back",

    BackContent = "Back content",

    SmallBackgroundImage = new Uri("/Assets/Tiles/FlipCycleTileSmall.png", UriKind.RelativeOrAbsolute),

    WideBackContent = "Wide back content",

    WideBackgroundImage = new Uri("/Assets/Tiles/FlipCycleTileLarge.png", UriKind.Relative),

    WideBackBackgroundImage = new Uri("/Assets/Tiles/FlipCycleTileLarge.png", UriKind.Relative)

};

ShellTile.Create(new Uri(uri, UriKind.Relative), tileData, true);

The code snippet is pretty self-descripting: it creates FlipTileData object, populates properties for front and back of the tile for normal and wide content (in case we want to support wide tile) and invokes ShellTile.Create function. Last parameter (in this case true) defines the support for wide tile. The result produced for this tile looks as follows:

Now, let us see the code to create third

(and most interesting in my opinion) tile type – cycle.

//Cycle

List<Uri> list = new List<Uri>();

list.Add(new Uri("/Images/WP1.jpg", UriKind.Relative));

list.Add(new Uri("/Images/WP2.jpg", UriKind.Relative));

list.Add(new Uri("/Images/WP3.jpg", UriKind.Relative));

list.Add(new Uri("/Images/WP4.jpg", UriKind.Relative));

list.Add(new Uri("/Images/WP5.jpg", UriKind.Relative));

CycleTileData tileData = new CycleTileData()

    Title = "Cycle",

    Count = 12,

    SmallBackgroundImage = new Uri("/Assets/Tiles/FlipCycleTileSmall.png", UriKind.RelativeOrAbsolute),

    CycleImages = list

};

ShellTile.Create(new Uri(uri, UriKind.RelativeOrAbsolute), tileData, true);

Most important in this this code block is the CycleImages list for CycleTileData object. It expects IEnumerabe<Uri> object with local images path. Remote images (not on the device) are not supported. The result of this code produces tile which looks like the following illustrations:

Tiles also could be updated using same push notification mechanism as in previous version. The only change would be in payload sent as new tiles needs more information.

That’s it for now. In next post I will how another end-user oriented feature – Lock Screen backgrounds and notifications.

Stay tuned,

Alex

Windows Phone 8 SDK available

Alex Golesh — Tue, 30 Oct 2012 17:43:23 GMT

Just announced at BUILD keynotes – Windows Phone 8 SDK available now! It includes Visual Studio Express 2012 edition for Windows Phone (which also works as add-on for paid versions of Visual Studio 2012), new Hyper-V based Windows Phone emulator and Expression Blend. It could be downloaded from the following location:

http://go.microsoft.com/fwlink/?LinkID=261873

Stay tuned for more exciting news to come,

Alex

Working with NFC–Take 2

Alex Golesh — Wed, 24 Oct 2012 16:59:19 GMT

Some time ago (I’ve blogged about working with proximity devices – NFC – in Windows 8 Consumer preview: http://blogs.microsoft.co.il/blogs/alex_golesh/archive/2012/02/29/windows-8-consumer-preview-and-visual-studio-11-beta-working-with-proximity-device-part-2-11.aspx). Then I’ve talked about a simple way performing NFC communication – using pub/sub communication pattern which is good for exchanging simple messages using PublishMessage and PublishBinaryMessage functions on ProximityDevice class.

Few days ago my client asked me to prepare a demo which uses proximity communication to transfer custom “Items” between two instances of the app (and also Windows Phone 8 version of this app). The app uses complex “items” which includes many textual fields, undefined number of attached images, locations, etc. To achieve this I’ve decided to use 2nd approach to proximity communication briefly described in my previous blog post – the TriggeredConnection and Sockets.

(I had additional “constraints” while engineered the solution: to minimize amount of changes in the app by using existing in-the-app load/save mechanisms and to be compatible as much as possible with Windows Phone 8 app and provide maximum code reuse between the platforms to avoid developing same functionality twice. Please keep in mind, that this blog post is not focused directly on dealing those constraints; I will blog more about sharing the code and my traditional “What’s New” series about Windows Phone 8 in a short while – so stay tuned).

Let’s get started. First of all – the app must specify proximity capability in app manifest:

The app has to support two sides of proximity communication – sender and receiver. Both called peers. In both cases, I am using PeerFinder class (form Windows.Networking.Proximity namespace). In my case I’ve decided to use Triggered discovery type which supports Tap-to-Connect scenario I needed for my purposes.

        1: public void StartConnect(string displayName)

       2: {

       3:     if (!String.IsNullOrEmpty(displayName))

       4:     {

       5:         //Optionally name the peer so it could be easily identified 

       6:         //and optionally presented to user

       7:         PeerFinder.DisplayName = displayName;

       8:     }

       9:  

    if ((PeerFinder.SupportedDiscoveryTypes & PeerDiscoveryTypes.Triggered) != PeerDiscoveryTypes.Triggered)

    {

        //The device doesn't support tap-and-send communication

        UpdateConnectionStatus(ConnectionStatus.NotSupported);

        return;

    }

  

    //Subscribe to connection triggers

    PeerFinder.TriggeredConnectionStateChanged += TriggeredConnectionStateChanged;

  

    //Declare alternate identities (if needed and supported)

    if (!PeerFinder.AlternateIdentities.ContainsKey(AlternateIdentityKey))

    {

        PeerFinder.AlternateIdentities.Add(AlternateIdentityKey, AlternateIdentity);

    }

  

    PeerFinder.AllowInfrastructure = true;

    PeerFinder.AllowBluetooth = true;

    PeerFinder.AllowWiFiDirect = false;

  

    //Start listening to proximity events

    PeerFinder.Start();

  

    UpdateConnectionStatus(ConnectionStatus.Ready);

}

The code snippet above starts the connectivity. It uses enables to optionally name the peer so it could be identified by other side, checks that device support required proximity discovery mode and subscribes to connection state changes.

The code above adds AlternateIdentities (see class declaration below). Alternate identities are used to enable communication between different applications and devices. As you remember, my demo requirement was to share the “items” between two instances of the app (which has same identity on all running devices) and Windows Phone 8 version of this app. Enabling the sharing between the app running Windows 8 and the app running on Windows Phone or different app running on Windows 8 requires adding alternate identities. The actual definition of the AlternateIdentityKey in my demo looks as follows:

       1: #if NETFX_CORE

       2:     readonly string AlternateIdentityKey = "WindowsPhone";

       3:     readonly string AlternateIdentity = "{04f1e621-039f-4829-b59f-47e71c6af98d}";

       4: #elif WINDOWS_PHONE

       5:     readonly string AlternateIdentityKey = "Windows";

       6:     readonly string AlternateIdentity = "a4ec8cdf-7759-4709-93af-5d2c2688ee46_cb1hhkscw5m06!App"; //Could be found using Windows.ApplicationModel.Package.Current.Id.FamilyName

       7: #endif

This code is a part of shared code which defines AlternateIdentity for other platform and could also define the AlternateIdentity for other app running on the same platform. When compiled for Windows 8, it adds “WindowsPhone” identity key and the ID of application running on the phone; when compiled for Windows Phone 8 it adds the “Windows” identity key and the full app ID of the Windows 8 app.

Note: The app id could be obtained from app manifest (Packaging tab).
For Windows it will be the value of “Package family name” field + “!” + app ID (the namesapce and name of the App class). It also could be obtained using Windows.ApplicationModel.Package.Current.Id.FamilyName API from within the code.
For Windows Phone app it will be the value of “Product ID”.

This way PeerFinder is aware about other apps which are allowed to connect to this app. Additionally, when two devices are in proximity and the trying to establish the proximity connection, but one of the devices is not running the application (not started or in background) this alternate ID will be using by platform to identify the “target” app and pop up a toast notification asking user’s permission to start the app and establish proximity connection.

When the connection is triggered, every app responds in slightly different way (depending of the app logic). In my case the TriggeredConnectionStateChanged event handler looks as follows:

       1: private void TriggeredConnectionStateChanged(object sender, TriggeredConnectionStateChangedEventArgs e)

       2: {

       3:     switch (e.State)

       4:     {

       5:         case TriggeredConnectState.PeerFound:

       6:             UpdateConnectionStatus(ConnectionStatus.PeerFound);

       7:             break;

       8:         case TriggeredConnectState.Connecting:

       9:             UpdateConnectionStatus(ConnectionStatus.Connecting);

      10:             break;

      11:         case TriggeredConnectState.Listening:

      12:             UpdateConnectionStatus(ConnectionStatus.Listening);

      13:             break;

      14:         case TriggeredConnectState.Canceled:

      15:             UpdateConnectionStatus(ConnectionStatus.Canceled);

      16:             break;

      17:         case TriggeredConnectState.Failed:

      18:             UpdateConnectionStatus(ConnectionStatus.Failed);

      19:             break;

      20:         case TriggeredConnectState.Completed:

      21:             socket = e.Socket;

      22:             UpdateConnectionStatus(ConnectionStatus.Completed);

      23:             break;

      24:     }

      25: }

For most cases my demo just informs the user with different connectivity state changes and when connection established (Completed state) saves a Socket for future use. The main app also listens to connectivity changes and when connection is established switches to either “receive” mode or “send” mode depending on the app logic. In both cases (will show then later in the post) a socket communication will be used to send/receive raw bytes and the actual information should be first converted to bytes representation (in case of send side) and parsed back (in case of receiving side).

To leverage the code we already had in the app I’ve decided to use objects serialized with JSON serializer. This also enabled me to write pretty “abstract” code which sending/receiving the items (you will see later). The next code block has two functions – GetItemStream which serializes my “item” to JSON format and ParseNewItem which deserializes received “item” from stream back to strongly typed object:

       1: public byte[] GetItemStream(Item note)

       2: {

       3:     List<Type> types = new List<Type>();

       4:     //Not required in this case, but should be used to 

       5:     //serializing/deserializing multiple object types

       6:     types.Add(typeof(Item)); 

       7:  

       8:     DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Item)/*, types*/);

       9:     MemoryStream ms = new MemoryStream();

      10:  

      11:     ser.WriteObject(ms, note);

      12:     byte[] json = ms.ToArray();

      13:     var value = System.Text.Encoding.UTF8.GetString(json, 0, json.Length);

      14:     Debug.WriteLine("Serialized JSON object:\n" + value);

      15:     return json;

      16: }

      17:  

      18: private Item ParseNewItem(MemoryStream ms)

      19: {

      20:     List<Type> types = new List<Type>();

      21:     //Not required in this case, but should be used to 

      22:     //serializing/deserializing multiple object types

      23:     types.Add(typeof(Item)); 

      24:     DataContractJsonSerializer des = new DataContractJsonSerializer(typeof(Item)/*, types*/);

      25:     var item = (Item)des.ReadObject(ms);

      26:     item.UniqueId = DataManager.GetUniqueId();

      27:  

      28:     return item;

      29: }

Once the object has been serialized and we got a stream it is ready to be sent.

       1: public async Task SendItemAsync([ReadOnlyArray] byte[] itemBytes, int imagesCount, [ReadOnlyArray] List<byte[]> images)

       2: {

       3:     if (itemBytes != null && socket != null)

       4:     {

       5:         //Start sending the item

       6:         try

       7:         {

       8:             DataWriter dw = new DataWriter(socket.OutputStream);

       9:  

            //Sending item length

            dw.WriteInt32(itemBytes.Length);

            await dw.StoreAsync();

  

            //Sending item bytes

            dw.WriteBytes(itemBytes);

            await dw.StoreAsync();

  

            if (null != images && imagesCount > 0) //The only app-specific part here...

            {

                foreach (var imageBytes in images)

                {

                    //Sending image length

                    dw.WriteInt32(imageBytes.Length);

                    await dw.StoreAsync();

  

                    //Sending image bytes

                    dw.WriteBytes(imageBytes);

                    await dw.StoreAsync();

                }

            }

  

            //Flushing buffers to make sure we pushed all the data over "the wire"

            await dw.FlushAsync();

  

            //Closing DataWriter

            dw.DetachStream();

            dw.Dispose();

        }

        catch (Exception ex)

        {

            Debug.WriteLine(ex.Message);

            //Reset the connection if case of communication error

            StopConnect();

#if NETFX_CORE

            string PeerName = "Win8_NFC Sample";

#elif WINDOWS_PHONE

            string PeerName = "WP8_NFC Sample";

#endif

            //Restart connection

            StartConnect(PeerName);

        }

    }

}

The function is relatively simple and straight forward – user DataWriter class (System.Networking.Sockets namespace) to send bytes over socketed connection. Same goes to images which were prepared in their raw/bytes format. The code snippet which prepares and calls the SendItemAsync looks as follows (and is not shared across platforms):

       1: //Get bytes from current item

       2: byte[] bytes = ProximityManager.Instance.GetItemStream(item);

       3: List<byte[]> images = null;

       4:  

       5: //If item has images attached - prepare images

       6: if (item.Images.Count > 0)

       7: {

       8:     images = new List<byte[]>();

       9:  

      10:     foreach (var imgSrc in item.Images)

      11:     {

      12:         //Read image from local storage

      13:         var filename = imgSrc.Replace("Images/", "");

      14:         var storage = Windows.Storage.ApplicationData.Current.LocalFolder;

      15:         var folder = await storage.GetFolderAsync("Images");

      16:         var file = await folder.GetFileAsync(filename);

      17:         var stream = await file.OpenReadAsync();

      18:         //Prepare image bytes

      19:         byte[] imageBytes = new byte[stream.Size];

      20:         var str = stream.AsStream();

      21:         await str.ReadAsync(imageBytes, 0, (int)stream.Size);

      22:  

      23:         images.Add(imageBytes);

      24:     }

      25: }

      26:  

      27: //Send the item

      28: await ProximityManager.Instance.SendItemAsync(bytes, item.Images.Count, images);

The second part of the equation is to receive a message. Since we know exactly how we sending the message, the receive function looks as follows:

       1: public async void ReceiveItemAsync()

       2: {

       3:     if (socket != null)

       4:     {

       5:         try

       6:         {

       7:             DataReader dr = new DataReader(socket.InputStream);

       8:  

       9:             // Receive the size of the byte array first

            if (await TryLoadAsync(dr, 4))

            {

                var count = dr.ReadInt32();

                uint ucount = (uint)count;

  

                if (await TryLoadAsync(dr, ucount))

                {

                    byte[] bytesIn = new byte[count];

                    dr.ReadBytes(bytesIn);

  

                    //Save/parse new item

                    MemoryStream ms = new MemoryStream(bytesIn);

                    Item theItem = ParseNewItem(ms);

  

                    var imagesCount = theItem.Images.Count;

                    //Receive "attached" images - app-specific functionality

                    if (imagesCount > 0)

                    {

                        for (int i = 0; i < imagesCount; i++)

                        {

                            if (await TryLoadAsync(dr, 4))

                            {

                                var imgSize = dr.ReadInt32();

                                uint uimgSize = (uint)imgSize;

  

                                if (await TryLoadAsync(dr, uimgSize))

                                {

                                    byte[] imgBytesIn = new byte[imgSize];

                                    dr.ReadBytes(imgBytesIn);

  

                                    MemoryStream imgMs = new MemoryStream(imgBytesIn);

  

                                    var imgName = theItem.Images[i];

                                    imgName = imgName.Replace("Images/", "");

                                    var fileName = await DataManager.SaveImageAsync(imgName, imgMs.AsInputStream(), Windows.Storage.CreationCollisionOption.GenerateUniqueName);

                                }

                            }

                        }

                    }

  

                    await DataManager.AddFileAsync(theItem);

  

                    //Raise evens, so main app "knows" about new item

#if NETFX_CORE

                    await ((NFCSample.App)App.Current).Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>

#elif WINDOWS_PHONE

                    ((WP8_NFC.App)System.Windows.Application.Current).Dispatcher.BeginInvoke((Action)(() =>

#endif

                    {

                        //Raise ItemReceived event

                        if (ItemReceived != null)

                        {

                            ItemReceivedEventArgs args = new ItemReceivedEventArgs();

                            args.NewItem = theItem;

                            ItemReceived(this, args);

                        }

                    }

#if WINDOWS_PHONE

                    )

#endif

                    );

                }

            }

  

            //Detach a stream and release it

            dr.DetachStream();

            dr.Dispose();

        }

        catch (Exception ex)

        {

            Debug.WriteLine(ex.Message);

            //Reset the connection in case of communication error

            StopConnect();

#if NETFX_CORE

            string PeerName = "Win8_NFC Sample";

#elif WINDOWS_PHONE

            string PeerName = "WP8_NFC Sample";

#endif

            // Restart connection

            StartConnect(PeerName);

        }

    }

}

In this code I am receiving the message parts in exactly the same order as sending them.

Note, that this code is share between Windows 8 and Windows Phone 8.

Last piece of puzzle here – the helper function which reads known amount of bytes from socket:

       1: private async Task<bool> TryLoadAsync(DataReader dr, uint count)

       2: {

       3:     //Get cancellation token 

       4:     cts = new CancellationTokenSource();

       5:     CancellationToken token = cts.Token;

       6:  

       7:     bool result = false;

       8:  

       9:     try

    {

        var countReceived = await dr.LoadAsync(count).AsTask(token);

  

        if (countReceived != count)

        {

            //Connection error - close it

            Debug.WriteLine("Bytes read {0} != {1} total bytes. Communucation error!", countReceived, count);

            //Reset connection

            StopConnect();

#if NETFX_CORE

            string PeerName = "Win8_NFC Sample";

#elif WINDOWS_PHONE

            string PeerName = "WP8_NFC Sample";

#endif

            // Restart connection

            StartConnect(PeerName);

            result = false;

        }

        else

            result = true;

    }

    catch (TaskCanceledException)

    {

        result = false;

    }

    finally

    {

        cts = null;

    }

  

    return result;

}

This is it. Now my class is shared between two apps on multiple platforms and my samples can exchange complex custom items between instances on same and different platforms.

To see this demo working – come to BUILD 2.0 conference taking place at Redmond, WA (October 30 - November 2, 2012) or the video I will try to film and publish after the BUILD.

Also – if you are at the BUILD – feel free to find me and say “Hi”. I will be there!

Teaser:

I have a massive ‘What’s new in Windows Phone 8” series ready to be published after official release!

Stay tuned to more posts to come.

Alex

I’m Microsoft MVP for another year!

Alex Golesh — Sun, 01 Jul 2012 14:38:17 GMT

About 10 minutes ago, I received an email presenting me with the Microsoft MVP Award in Silverlight!

I am very honored to receive an MVP Award for the fourth time in row and I will continue contributing to the online and offline developer community worldwide.

This is a great opportunity and place to thank quite a few people who helped me to win this Award again:

My wife and daughter for having so much patience and providing the best support I could only dream about!
My current and past managers (David, Ishai, Caro) and coworkers at Sela Group, which is easily the best software company to work for that I could think of;
All other peoples who helped me get this MVP award;

Stay tuned for news and posts on Windows Phone and Windows 8!

Alex

Windows 8 Release Preview

Alex Golesh — Thu, 31 May 2012 19:18:34 GMT

Windows 8 Release Preview (RP) was published and can be downloaded by anyone who want to try this great preview of upcoming OS!

More info about it here:

http://windows.microsoft.com/en-US/windows-8/release-preview

Download the version to try from here:

http://windows.microsoft.com/en-US/windows-8/download

For those, who want to grab ISO images links could be found at the following location:

http://windows.microsoft.com/en-US/windows-8/iso

(this link also provides the product key to use)

Developers, developers, developers! Updated version version of Visual Studio 2012 Express RC for Windows 8 can be downloaded from the following lcoation:

http://msdn.microsoft.com/en-us/windows/apps/br229516.aspx

Aside tools you can find updated design assets, sample apps and Live SDK!

Stay tuned for more updated to come!

Alex

Book review: Microsoft Silverlight 5 and Windows Azure Enterprise Integration

Alex Golesh — Sun, 20 May 2012 15:23:29 GMT

As promised here, here is overview of the book I just finished to read.

First of all – my congratulations to author of the book, David Burela, as the book written very clear and describes both, basics and advanced concepts, I very practical and professional way. From other hand, author made this book also enjoyable!

Now about the book itself. It has 12 chapter which overview whole spectrum of possibilities of how to integrate Windows Azure and Silverlight application.

It starts from traditional intro chapters – Intro to Visual Studio, tools, creating Windows Azure account and intro to Windows Azure itself.

Next, 3rd chapter, describes basics of creating Silverlight application and consuming some Azure functionality… While those 3 chapter lack some new info for me personally, I really enjoyed the way author overviewed the basics because it gives the less experienced audience nice starting point to dive deeper into the book.

In chapters 4-7 authors overviews all possible ways to use Windows Azure services (like Queues, Blob storage, Table storage, SQL Azure) from within Silverlight application. The chapters shows very clean and practical way to use this functionality and gives practical advises of how to make it work. In some cases I felt that presented scenarios is little bit simplified for real world enterprise apps, but from other hand it also enabled very clean sample code and good explanation of the topics.

Second part of the book (chapters 8 – 12) is where I really enjoyed every moment. Those chapters author explained more advanced concepts such as consuming SQL Azure data using RIA Services, consuming OData, authentication and caching techniques. Again, those chapters presented those concepts in very clear and very practical way.

To summarize, many great information in one place and a lot of walkthrough scenarios makes this book one of my favorites in this specific area. After reading and enjoying this book I can recommend it to anyone who looking for guidance in Silverlight and Azure integration!

More info about the book:

http://www.packtpub.com/microsoft-silverlight-5-enterprise-integration-on-windows-azure/book

Stay tuned,

Alex

Books, books, books

Alex Golesh — Thu, 10 May 2012 18:35:34 GMT

Seems like today is “books” day.

Working really hard for last few months, I completely forgot to blog about the book which I took part in!

Announcing: Real World .NET, C#, and Silverlight: Indispensible Experiences from 15 MVPs

Few months ago, 15 MVPs from around the globe joined together to write an ultimate resource book for discovering and understanding the C#, .NET 4 Framework and Windows Phone 7.5. Today the book is published, and available at Amazon.com:

http://www.amazon.com/Real-World-NET-Silverlight-Indispensible/dp/1118021967/

Whole book is very good but I especially recommend Chapter 8, written by yours truly

Stay tuned about more interesting updates to come,

Alex

It’s reading time!

Alex Golesh — Thu, 10 May 2012 18:18:17 GMT

Just got my hands on new book “Microsoft Silverlight 5 and Windows Azure Enterprise Integration” by David Burela.

The book overview looks very promising and should give me a details how create scalable enterprise applications using Silverlight 5 (yes, it is still my favorite technology!) and take advantage of Windows Azure key features. It also provides an overview of the Windows Azure platform and how the different technologies can be integrated within your enterprise application and examine ways that distributed asynchronous systems can be created to allow scalable processing.

More info about the book could be found here:

http://www.packtpub.com/microsoft-silverlight-5-enterprise-integration-on-windows-azure/book

I will post a short overview about the book after finishing with it.

Stay updated.

Alex

My Session at Sela SDP 2012

Alex Golesh — Mon, 26 Mar 2012 05:29:46 GMT

Yesterday I delivered a session about live tiles, toasts and push notifications in Windows 8. I like to thank all the participants – you were great and I had a great pleasure to present for such quality audience. I loved the questions and the conversation after the session.

The slides deck I used for presentation can be viewed online here.

Thanks and stay tuned for more updates,

Alex

Microsoft Official HTML5 Course

Alex Golesh — Thu, 15 Mar 2012 18:34:47 GMT

During last few months I was co-authoring the Microsoft Official Course (MOC) named “HTML5 programming” with my colleagues at Sela - Noam Kfir and Gil Fink. About a month ago I delivered a first Beta of this course in Redmond, WA and finally the course is scheduled to be published on April 20, 2012.

It was a very intensive experience with tight deadlines but we made it and the course is on its way for publishing.

A few details about the course:

It is three-day instructor-led course.
The course is lab oriented – the students will write a web application and enhance it with HTML5 features and APIs during the course.
The course covers many aspect of HTML5 such as the new elements, Canvas, SVG, animation, multimedia, CSS3, JavaScript APIs and more.

For more details about the course refer to the following location.

I had a great pleasure working with my outstanding colleagues at Sela and Microsoft Learning (all of them!) which all together made it possible! Thank you all!

Enjoy the course and stay tuned,

Alex