Alex Golesh's Blog About Silverlight Development : Windows, XAML

Windows 8 Live Tiles – take 2

Alex Golesh — Tue, 29 Jan 2013 02:57:28 GMT

Quite some time ago I blogged about Live Tiles & Toast Notifications Windows 8 feature.

About a week ago I was delivering Windows 8 training and as a part of this course was delivering a sessions about Live Tiles and Windows 8 PLM (PLM = Process Lifetime Management, session which discusses when Windows 8 runs apps and some point about Windows 8 background tasks). The PLM session mentions, that Windows 8 apps are permitted to run background tasks, but they will be executed approximately once in 2 hour and will be getting few seconds of CPU time. I’ve also mentioned, that some apps, which got user permission to run under the lock screen will be able to run the background tasks based on system timer, but those apps will be scheduling to run once in 15 minutes as minimum timeslot between the execution. Right after the PLM session, at the break, one of my students came to me and asked how “clock” live tiles applications (already few published in the Store) are working. I had to admit, that I never saw this apps before and was not aware about them and how do they working. The student pointed out on one of them and after installing the app I saw that the app go a live tile with current clock and it updates the tile once in a minute. I have to admit, I was intrigued…

I checked the app permissions – it used background permissions, but this was not enough to update a tile once in a minute (remember – the minimum timeslot for such apps are 15 minutes). Then (after briefly chatting about this with my friend and colleague from MS DPE) I assumed that app probably uses push notifications. After further thoughts I failed also this option as the app is free and pushing 1440 messages daily per client is way above free limit of push notifications. I double checked myself by disconnecting network connections on my laptop to make sure. The app keep working and updated the tile. And suddenly it hit me – the app uses Scheduled Toast Notifications! It is possible to schedule many future toasts (I don’t remember exact number, but way more than 15 (needed for background service with lock screen permissions) and more than 120 (needed for regular background service). I tried to repro the app and here it is – for the sake of simplicity I didn’t create images of all minutes per day (actually half is enough as analogue clock has the same presentation once in 12 hours). Also I decided to make a sample without background service as for my demo it was not rally needed.

So I’ve create the super simple UI which gets a count number from user:

     <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">

        <Grid.RowDefinitions>

            <RowDefinition/>

            <RowDefinition/>

        </Grid.RowDefinitions>

        <TextBox x:Name="txtCount" Text="10" MaxHeight="40" MaxWidth="40" HorizontalAlignment="Left"/>

        <Button Content="Set" Click="Button_Click_1" Grid.Row="1"/>

    </Grid>

And here is button click event handler:

    private void Button_Click_1(object sender, RoutedEventArgs e)

    {

        //Remove old scheduled notifications as we are starting new countdown

        var oldNotifications = TileUpdateManager.CreateTileUpdaterForApplication().GetScheduledTileNotifications();

        foreach (var item in oldNotifications)

            TileUpdateManager.CreateTileUpdaterForApplication().RemoveFromSchedule(item);

        //Parse user input and get current time

        int val = int.Parse(txtCount.Text);

        DateTime startTime = DateTime.Now;

        //Set "Ready, Set, Go!" tile - displayed immediately

        ITileSquareText01 tile0 = TileContentFactory.CreateTileSquareText01();

        tile0.TextHeading.Text = "";

        tile0.TextBody1.Text = "Ready!";

        tile0.TextBody2.Text = "Set!";

        tile0.TextBody3.Text = "Go!";

        TileNotification theTile0 = new TileNotification(tile0.GetXml());

        TileUpdateManager.CreateTileUpdaterForApplication().Update(theTile0);

        //Loop and schedule required number of tiles

        for (int i = 1; i <=val; i++)

        {

            ITileSquareBlock tile = TileContentFactory.CreateTileSquareBlock();

            //Tile main presentation is the number of current counter and will be presented to user when the tile is shown

            tile.TextBlock.Text = i.ToString();

            tile.TextSubBlock.Text = "Counting...";

            //Create scheduled tile notification and schedule it to run once in 5 seconds staring from now

            //Note: from my checks, it is possible to schdule the tiles once in a seconds, but some of them were skipped (about each 2-3)

            ScheduledTileNotification scheduledTile = new ScheduledTileNotification(tile.GetXml(), startTime.AddSeconds(i * 5));

            TileUpdateManager.CreateTileUpdaterForApplication().AddToSchedule(scheduledTile);

        }

        //Create a tile with "All done" mesage

        ITileSquareText01 tile1 = TileContentFactory.CreateTileSquareText01();

        tile1.TextHeading.Text = "All Done!";

        tile1.TextBody2.Text = "Countdown stopped";

        //It is scheduled to run 5 seconds after last count ;)

        ScheduledTileNotification scheduledTile1 = new ScheduledTileNotification(tile1.GetXml(), startTime.AddSeconds((val + 1) * 5));

        TileUpdateManager.CreateTileUpdaterForApplication().AddToSchedule(scheduledTile1);

    }

Note: In this sample I am using NotificationsExtensions – the free windows component created by Microsoft and distributed for free as a part of Windows 8 SDK samples.

That’s it! Wow! So simple, but super creative! The video of my sample running (sorry for ugly UI):

My sample running and updating live tile every ~5 seconds

Clock app schedules the tiles using different tile template and points to images distributed with app. IMO it schedules 60-120 notifications, and every time background task runs adjust slightly the time and reschedules the tiles. I saw few times that the tile “skips” a minute sometime and jumps two minutes or stays on same minute instead of changing an image which makes me thing that at this time background task was running and adjusted an tiles schedule.

Enjoy and stay tuned!

//Alex

Working with NFC–Take 2

Alex Golesh — Wed, 24 Oct 2012 22: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

Windows 8 Release Preview

Alex Golesh — Fri, 01 Jun 2012 02: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

Windows 8 Consumer Preview and Visual Studio 11 Beta – Process Lifetime Management (Part 11/11)

Alex Golesh — Thu, 01 Mar 2012 03:46:00 GMT

Windows 8 Metro applications introduces new (for desktop version of Windows) philosophy behind application execution - when application runs and when it is terminated. In this post I will overview this process also known as Process Lifetime Management (or PLM in short). In addition, I will showcase creation of custom Splash Screen experience which becomes important especially with in PLM in mind.

Windows 8 designed to run not only on desktop PCs and laptops (which usually have descent amount of RAM and CPU resources), but also on tablets and low-powered PCs (with limited amount or RAM, slower CPU and usually running from battery). New Windows 8 Metro applications are full-screen applications (most of the time), meaning that for given time only one (in some scenarios, like snapping – two) application interacts with user. With this in mind, it is simply not optimal to have more than one active application; applications which are not in foreground can be “suspended”. For us, developers, the experience is like pausing application on break point in Visual Studio’s debugger: the application is alive, all memory (and thus all variables and objects) preserved, but it is not executed. Such applications keep holding memory resources but will not run any process meaning will not waste CPU resource (which leads to lower battery drain).

The application lifecycle

So what really happens? When user launches the application (I will explain the “launch” term more in depth later) it begins invocation, shows Splash Screen (as defined in application manifest) and have only 15 seconds to present a window to the user.

Note: If application is not capable with this requirement it will be terminated (crashed). I will overview the ways to work around this behavior in Custom Splash Screen section.

When user launches additional application, first application being moved to background – it gets “suspended” signal and have 5 seconds to save its state. After saving state application remains in-memory, but not receiving CPU allocation and other system resources. If user returns to the application it resumes immediately, since it preserved in-memory and it is just a matter of continue running from previous time (remember Tombstoning and Fast Application Switch/FAS in Windows Phone 7?). Application gets “resuming” signal in order to restore its previous state.

Note: If application is not capable of finish saving state with 5 seconds from receiving “suspend” signal it will be terminated (crashed).

At some point of time there will be too much applications “suspended” in memory. In low-memory devices it will happen more frequently, on powerful desktop PCs probably less frequently but also happen. In this case new application launch will cause to system look for oldest and most memory-consuming suspended application and will remove it from memory or in other words terminate the app. Since application is not running it will not get any notification about the termination.

Note: Application must use “suspend” signal save its state and prepare for potential termination.

If user launches the terminated application again it will follow full application initialization process as it was during first launch.

In order to support this behavior, application provided by Suspending and Resuming events which can be registered and handled:

public App()
{
    this.InitializeComponent();
    this.Resuming += App_Resuming;
    this.Suspending += App_Suspending;
}
void App_Suspending(object sender, Windows.ApplicationModel.SuspendingEventArgs e)
{
    //Get deferral opreation
    SuspendingDeferral deferral = e.SuspendingOperation.GetDeferral();
    //Save state - 5 seconds only!
    //...    
    Windows.Storage.ApplicationData.Current.LocalSettings.Values.Add("SUSPENDED", DateTime.Now.ToString());
    System.Diagnostics.Debug.WriteLine("Suspending the app");
    //Notify complete with 5 seconds - otherwise the app will be crashed
    deferral.Complete();
}
void App_Resuming(object sender, object e)
{
    System.Diagnostics.Debug.WriteLine("Resuming app");
    //Reload state if resuming
    //...
    DateTime suspendedAt = DateTime.Parse(Windows.Storage.ApplicationData.Current.LocalSettings.Values["SUSPENDED"].ToString());     Windows.Storage.ApplicationData.Current.LocalSettings.Values.Remove("SUSPENDED");     System.Diagnostics.Debug.WriteLine("Originally suspended at " + suspendedAt.ToString());
}

SuspendingDeferral is class responsible to managing suspending operation. If application has nothing to save in its state (rarely occurred), it can just safely skip getting the deferral object or simply get it and immediately report Complete.

To debug Suspend/Resume/Terminate behavior VS11 provides Debug Location menu, which can be added to the menus bar:

How application lunched?

In Windows 8 application can be executed using multiple possible actions: user taps on application’s tile on main screen (or in all applications list), invokes search with the application, shares data with application, etc. Also when launching application from main screen tile, it can be first time launch or launch after application was suspended and terminated (as described above). To deal with this, application provided with WinRT provides number of different overrideable functions at Application level – OnLauched and OnActivated (and all On_XXX_Activated).

OnLaunched event invokes when the application is launched normally by user and provides LaunchActivatedEventArgs which helps to deal with different possible launch conditions (launch kind, previous execution state, arguments, etc.).

LauchActivatedEventArgs.Kind helps manage different application launch scenarios depending on how it was launched:

LauchActivatedEventArgs.PreviousExecutionState helps to deal with situation when application was previously terminated/suspended to help create illusion of continues execution:

OnActivated (and other activated handlers like OnShareTargetActivated, OnFileActivated, OnSearchActivated, OnFileOpenPickerActivated and others) invoked when application activated either via file picker experience, share or search charm and provides relevant arguments for specific activation (like ShareOperation in case of share target activation, or search parameters in case of search activation) along with ActivationKing and PreviousExecutionState.

Custom Splash Screen

When application Activated or Launched it has only 15 seconds to present a windows. During this time system presents user with pre-defined Splash Screen. What if application needs potentially more time (for example getting data from cloud-based services)? What if application developer decides to provide some information about loading process? All those scenarios requires some custom splash screen (with potentially custom logic). But what happens with built-in one? How to deal with it?

For this scenarios OnLaunched and OnActivated events provide information about SplashScreen which used to get information about system-managed splash screen and provide seamless alternative with custom splash screen. In my sample I created custom splash screen, which “entertains” user for some time simulating real process behind the scene.

Let’s see the code. I created additional page, called ExtendedSplash which uses same image as declared in application manifest and have some additional elements to present text and waiting experience.

The page initialized as follows:

private SplashScreen splash;
private bool dismissed = false;
string activationArgs = null;
int count = 0;
string[] msgs = { "Loading...", 
                    "Please wait...", 
                    "Progressing really well...", 
                    "Just few more blinks...", 
                    "Finally! Done!" };
//Ctor
public ExtendedSplash(SplashScreen splashScreen, bool dismissed, string activationArgs)
{
    this.InitializeComponent();
    //Save system copy of splash screen for future reference and activation args
    splash = splashScreen;
    this.dismissed = dismissed;
    this.activationArgs = activationArgs;
    //move/resize local image exactly as on system splash screen
    extendedSplashImage.SetValue(Canvas.LeftProperty, splash.ImageLocation.X);
    extendedSplashImage.SetValue(Canvas.TopProperty, splash.ImageLocation.Y);
    extendedSplashImage.Height = splash.ImageLocation.Height;
    extendedSplashImage.Width = splash.ImageLocation.Width;
    //subscribe to resize event to handle new size of splash screen while active
    Window.Current.SizeChanged += new WindowSizeChangedEventHandler(ExtendedSplash_OnResize);
    //Simulate work by running timer...
    DispatcherTimer timer = new DispatcherTimer();
    timer.Interval = TimeSpan.FromSeconds(1);
    timer.Tick += (s, args) =>
    {
        count++;
        if (count < msgs.Length)
        {
            //Present next message to user to show some progress
            txtMessage.Text = msgs[count];
        }
        else if (count >= msgs.Length && this.dismissed)
        {
            timer.Stop();
            timer = null;            // When finished, navigate to real first page
            var rootFrame = new Frame();
            rootFrame.Navigate(typeof(BlankPage), activationArgs.Length == 0 ? null : activationArgs);
            // Place the frame in the current Window and ensure that it is active
            Window.Current.Content = rootFrame;
        }
    };
    timer.Start();
    txtMessage.Text = msgs[count];
}

When screen being resized:

void ExtendedSplash_OnResize(Object sender, Windows.UI.Core.WindowSizeChangedEventArgs e)
{
    // Safely update the splash screen image coordinates
    if (null != splash)
    {
        // Re-position the extended splash screen image due to window resize event.
        this.extendedSplashImage.SetValue(Canvas.LeftProperty, splash.ImageLocation.X);
        this.extendedSplashImage.SetValue(Canvas.TopProperty, splash.ImageLocation.Y);
        this.extendedSplashImage.Height = splash.ImageLocation.Height;
        this.extendedSplashImage.Width = splash.ImageLocation.Width;
    }
}

Finally, provide event handler function, which will be used in App class to subscribe for system splash screen dismiss event:

internal void dismissedEventHandler(Windows.ApplicationModel.Activation.SplashScreen sender, object e)
{
    this.dismissed = true;
}

In App class, redirect navigation to custom splash screen instead of real main screen:

protected override void OnLaunched(LaunchActivatedEventArgs args)
{
    SplashScreen splashScreen = args.SplashScreen;
    ExtendedSplash eSplash = new ExtendedSplash(splashScreen, false, args.Arguments);
    splashScreen.Dismissed += new TypedEventHandler<SplashScreen, object>(eSplash.dismissedEventHandler);
    Window.Current.Content = eSplash;
    Window.Current.Activate();
}

Running the app reveals seamless integration between system provided and custom splash screens:

Note: In my case I decided to provided system splash screen for OnActivated experience, but same technique applies also on application activation

Working extended splash screen video:

Custom Splash Screen

That’s it for now.

Stay tuned for more interesting stuff to come!

Alex

Windows 8 Consumer Preview and Visual Studio 11 Beta – Live tiles, toasts, badges and Push Notifications (Part 10/11)

Alex Golesh — Thu, 01 Mar 2012 03:39:04 GMT

Windows 8 provides interesting way to “interact” with user even when application is not active anymore.

Push Notifications

Windows Push Notifications (WNS) in Windows 8 is quite similar to the Windows Phone 7 Push Notification (MPNS) model. It uses cloud-based push notification services to deliver notifications to registered clients.

To enable application receiving push notifications developer must register it at Windows Push Notifications & Live Connect site. The process is very simple – developer provides Package display name and publisher found in application manifest:

and site provides with updated package name (looks like BUILD.XXXXXXXX-XXXX-XXXX-XXXX), client secret code and package security identifier (SID, looks like ms-app://s-1-15-2-2289547533-2580522492-1560851697-4285800683-875472074-159972757-1111111111). Developer must modify package name in application manifest. Created applications can be managed Live App management site and retrieve information about any registered application, usage, caps, etc.

After application registered and ready to receive notifications from WNS, let’s overview how the whole process works:

1. Metro style application uses WinRT APIs (Notification Client Platform on diagram) to open new channel to server (or reconnect with previously created channel). At the end of the process, application receives unique URI which will be used in next step.

2. Any 3rd party application (Metro, classic, WPF, cloud-based service), which has URI obtained in previous step + client secret/SID combination can request Authorization token from WNS and then POST message to provided URI using received authorization token.

3. 3rd party application (in my simplest case – console app) requests authorization token using client secret and SID, prepares XML payload (the message which WNS sends to client) and sends POST message to URI (from 1st step)

4. WNS verifies provided information, alters Windows 8 client machine and delivers the message payload to client notification platform. Client notification platform responsible on updating tile/badge, showing toast notification, updating lock screen (if application has lock screen access) and deliver notifications to Metro app if still active.

Now let’s see the application described in step 2. It has 2 main functions – GetAccessToken and Push:

private static Stream GetAccessToken(string sid, string secret)
{
    string url = "https://login.live.com/accesstoken.srf";
    var request = (HttpWebRequest)WebRequest.Create(url);
    request.Method = "POST";
    request.ContentType = "application/x-www-form-urlencoded";
    string content = "grant_type=client_credentials&client_id={0}&client_secret={1}&scope=notify.windows.com";
    string data = string.Format(content, sid, secret);
    byte[] notificationMessage = Encoding.Default.GetBytes(data);
    request.ContentLength = notificationMessage.Length;
    using (Stream requestStream = request.GetRequestStream())
    {
        requestStream.Write(notificationMessage, 0, notificationMessage.Length);
    }
    var response = (HttpWebResponse)request.GetResponse();
    Stream result = response.GetResponseStream();
    return result;
}
private static HttpStatusCode Push(string pushUri, string accessToken, string type, string notificationData)
{
    var subscriptionUri = new Uri(pushUri);
    var request = (HttpWebRequest)WebRequest.Create(subscriptionUri);
    request.Method = "POST";
    request.ContentType = "text/xml";
    request.Headers = new WebHeaderCollection();
    request.Headers.Add("X-WNS-Type", type);
    request.Headers.Add("Authorization", "Bearer " + accessToken);
    byte[] notificationMessage = Encoding.Default.GetBytes(notificationData);
    request.ContentLength = notificationMessage.Length;
    using (Stream requestStream = request.GetRequestStream())
    {
        requestStream.Write(notificationMessage, 0, notificationMessage.Length);
    }
    var response = (HttpWebResponse)request.GetResponse();
    return response.StatusCode;
}

The functions are pretty simple – first returns stream with Authorization token, second uses URI obtained in step 1 (see diagram) + authorization token + notification type (set as custom header, X-WNS-Type) and sends notification payload using HTTP PUSH method.

The main function:

static void Main(string[] args)
{
    string pushUri = args.Length > 0 ? args[0] : "https://db3.notify.windows.com/?token=AQQAAABS%2bAYaiRtCeOtc9bhaC2xYXo7lv5A5fHEIWuDUePmnl6fxnKMf6wTMgXKp7NqSdSZ3kygzJrak%2fnGhtYV0iqJ1jIuSRJx0%2ftc6tzao1rIX2awu0p4SnYn7K5PItwKeBcY%3d";
    string secret = HttpUtility.UrlEncode("MY_APP_SECRET");
    string sid = HttpUtility.UrlEncode("MY_APP_SID");
    var obj = System.Json.JsonObject.Load(GetAccessToken(sid, secret));
    string accessToken = obj["access_token"].ToString();
    HttpStatusCode status;
    //Send Badge notification
    string badgeNotification = "<?xml version='1.0' encoding='utf-8'?><badge value=\"2\"/>";
    status = Push(pushUri, accessToken, "wns/badge", badgeNotification);
    Console.WriteLine("Badge notification send reault: " + status.ToString());
    //Send Toast notification
    string tostNotification = "<?xml version='1.0' encoding='utf-8'?><toast><visual><binding template=\"ToastImageAndText02\"><image id=\"1\" src=\"Images/Love.png\" alt=\"Placeholder image\"/><text id=\"1\">Love is in the air (PUSHED)!</text><text id=\"2\">Someone sends you love waves!</text></binding></visual></toast>";
    status = Push(pushUri, accessToken, "wns/toast", tostNotification);
    Console.WriteLine("Toast notification send reault: " + status.ToString());
    //Send Tile notification
    string tileNotification = "<?xml version='1.0' encoding='utf-8'?><tile><visual><binding template=\"TileWideSmallImageAndText03\"><image id=\"1\" src=\"ms-appx:///Images/LoveInTheAir.jpg\"/><text id=\"1\">Someone loves you from the distance!</text></binding></visual></tile>";
    status = Push(pushUri, accessToken, "wns/tile",tileNotification);
    Console.WriteLine("Tile notification send reault: " + status.ToString());
    Console.WriteLine("Press ENTER to exit...");
    Console.ReadLine();
}

Also this code is pretty simple it has some important information – the notification payload XML formats. In case of Toast and Tile notification this format actually dictates which information and how it will be presented to user. To learn more about Toast/Tile formats please refer to documentation.

Now when external parts are ready, let’s write Metro app functionality.

Updating tiles/toasts/badges

Tile:

Note: Windows 8 enables developer to provide two tiles sizes. Please refer to documentation for full templates list.

Toast:

Note: WinRT provides multiple tile and toasts templates. Please refer to documentation for full templates list.

Badges:

Badge notification can be either number or one of pre-defined glyphs:

Note: The location of badge is predefined.

Let’s get started with updating those items. First I will show how to open push notification channel and obtain URI:

async Task SetupPushNotifications()
{
    var pushNotificationChannel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
    var channelUri = pushNotificationChannel.Uri;
    System.Diagnostics.Debug.WriteLine(channelUri); //This URI will be used in application described above
    //Optional for my sample - not really used
    //pushNotificationChannel.PushNotificationReceived += pushNotificationChannel_PushNotificationReceived;
}
void pushNotificationChannel_PushNotificationReceived(PushNotificationChannel sender, PushNotificationReceivedEventArgs args)
{
    switch (args.NotificationType)
    {
        case PushNotificationType.Badge:
            //Not used in sample, but usefull to process incoming badge notification messages
            //notificationContent = args.BadgeNotification.Content.GetXml(); 
            //...
            break;
        case PushNotificationType.Tile:
            //Not used in sample, but usefull to process incoming tile notification messages
            //notificationContent = args.TileNotification.Content.GetXml();
            //...
            break;
        case PushNotificationType.Toast:
            //Not used in sample, but usefull to process incoming toast notification messages
            //notificationContent = args.ToastNotification.Content.GetXml();
            //...
            break;
    }
    // prevent the notification from being delivered to the UI
    args.Cancel = true;
}

The code snippet creates push notification channel for main application tile and prints out received URI to debug console. I will be using this URI in app described above. Usually, application subscribes to received push notification messages using PushNotificationReceived event, but in my simple case I just provided the code snippet which is not really used.

Note: If application uses secondary tiles (additional tiles created from within application code – will be covered later in this post), it must use CreatePushNotificationChannelForSecondaryTileAsync method of PushNotificationChannelManager to get unique URI for the tile. As described above, delivered notification will be processed by client push notification platform and presented on main screen.

Now let’s see how to issue an update from within the application.

Generally, updating all the of tiles/badges/toasts boils down to creating correct XML according to selected template, populating values and invoking Update method of desired UpdaterManager. Example of building such XML (in this case toast notification):

StringBuilder builder = new StringBuilder("<toast");
if (!String.IsNullOrEmpty(Launch))
{
    builder.AppendFormat(" launch='{0}'", Util.HttpEncode(Launch));
}
if (Duration != ToastDuration.Short)
{
    builder.AppendFormat(" duration='{0}'", Duration.ToString().ToLowerInvariant());
}
builder.Append(">");
builder.AppendFormat("<visual version='{0}'", Util.NOTIFICATION_CONTENT_VERSION);
if (!String.IsNullOrWhiteSpace(Lang))
{
    builder.AppendFormat(" lang='{0}'", Util.HttpEncode(Lang));
}
if (!String.IsNullOrWhiteSpace(BaseUri))
{
    builder.AppendFormat(" baseUri='{0}'", Util.HttpEncode(BaseUri));
}
builder.Append(">");
            
builder.AppendFormat("<binding template='{0}'>{1}</binding>", TemplateName, SerializeProperties(Lang, BaseUri));
builder.Append("</visual>");
AppendAudioTag(builder);
            
builder.Append("</toast>");
return builder.ToString();//...
protected string SerializeProperties(string globalLang, string globalBaseUri)
{
    globalLang = (globalLang != null) ? globalLang : String.Empty;
    globalBaseUri = String.IsNullOrWhiteSpace(globalBaseUri) ? null : globalBaseUri;
    StringBuilder builder = new StringBuilder(String.Empty);
    for (int i = 0; i < m_Images.Length; i++)
    {
        if (!String.IsNullOrEmpty(m_Images[i].Src))
        {
            string escapedSrc = Util.HttpEncode(m_Images[i].Src);
            if (!String.IsNullOrWhiteSpace(m_Images[i].Alt))
            {
                string escapedAlt = Util.HttpEncode(m_Images[i].Alt);
                builder.AppendFormat("<image id='{0}' src='{1}' alt='{2}'/>", i + 1, escapedSrc, escapedAlt);
            }
            else
            {
                builder.AppendFormat("<image id='{0}' src='{1}'/>", i + 1, escapedSrc);
            }
        }
    }
    for (int i = 0; i < m_TextFields.Length; i++)
    {
        if (!String.IsNullOrWhiteSpace(m_TextFields[i].Text))
        {
            string escapedValue = Util.HttpEncode(m_TextFields[i].Text);
            if (!String.IsNullOrWhiteSpace(m_TextFields[i].Lang) && !m_TextFields[i].Lang.Equals(globalLang))
            {
                string escapedLang = Util.HttpEncode(m_TextFields[i].Lang);
                builder.AppendFormat("<text id='{0}' lang='{1}'>{2}</text>", i + 1, escapedLang, escapedValue);
            }
            else
            {
                builder.AppendFormat("<text id='{0}'>{1}</text>", i + 1, escapedValue);
            }
        }
    }
    return builder.ToString();
}

To ease on routine work, updated version of Metro samples includes reusable library named “NotificationsExtensions” which greatly simplifies this work. My sample uses this library and all the “ContentFactory” classes in code below are defined there:

//Update badge
BadgeNumericNotificationContent badgeContent = new BadgeNumericNotificationContent();
if (badgeCount > 0)
    badgeContent.Number = badgeCount;
BadgeUpdateManager.CreateBadgeUpdaterForApplication().Update(badgeContent.CreateNotification());
//Update application's main tile
ITileWideSmallImageAndText03 tileContent = TileContentFactory.CreateTileWideSmallImageAndText03();
tileContent.TextBodyWrap.Text = message;
tileContent.Image.Src = "ms-appx:///Images/" + image;
tileContent.RequireSquareContent = false;
TileUpdateManager.CreateTileUpdaterForApplication().Update(tileContent.CreateNotification());
//Fire toast notification
IToastImageAndText02 templateContent = ToastContentFactory.CreateToastImageAndText02();
templateContent.TextHeading.Text = "Love is in the air!";
templateContent.TextBodyWrap.Text = message;
templateContent.Image.Src = "Images/Love.png";
templateContent.Image.Alt = "Placeholder image";
IToastNotificationContent toastContent = templateContent;
ToastNotification toast = toastContent.CreateNotification();
ToastNotificationManager.CreateToastNotifier().Show(toast);

Once XXX_Content populated with data this code snippet uses relevant UpdateManager to update/show relevant item.

Secondary Tiles

Updating secondary tiles:

Uri logo = new Uri("ms-appx:///images/Love.png");
Uri wideLogo = new Uri("ms-appx:///images/WideSecondary.png");
SecondaryTile secondaryTile = new SecondaryTile("LoveCatcher.SecondaryTile",
                                _isABoy.Value ? "A Boy" : "A Girl",
                                _isABoy.Value ? "Lonely Boy" : "Lonely Girl",
                                "pinnedID=" + (_isABoy.Value ? "BOY" : "GIRL"),
                                TileOptions.ShowNameOnWideLogo | TileOptions.ShowNameOnLogo,
                                logo,
                                wideLogo);
bool isPinned = await secondaryTile.RequestCreateForSelectionAsync(GetElementRect(this));
txtStatus.Text = isPinned ? "Secondary tile successfully pinned." : "Secondary tile not pinned.";

User receives request to pin secondary tile and must approve/dismiss this request. Optionally he can change tile title:

If both tiles provided (regular and wide), the user can switch between them:

Pinned tile arguments can be used to provide alternative loading path – more about it in next post.

Enabling lock screen access

Content published at application’s tile (tile text and badge) can be presented also when PC is locked. To enable application work under lock screen and present badge/tile, application can require user agreement by invoking the following code:

BackgroundAccessStatus status = await BackgroundExecutionManager.RequestAccessAsync();
switch (status)
{
    case BackgroundAccessStatus.AllowedWithRealTimeConnectivity:
        //Allowed to work under lock screen (and in background) with real-time connectivity
        //...
        break;
    case BackgroundAccessStatus.AllowedWithoutRealTimeConnectivity:
        //Allowed to work under lock screen (and in background), but without real-time connectivity
        //...
        break;
    case BackgroundAccessStatus.Denied:
        //User declined to work under lock screen 
        //...
        break;
    case BackgroundAccessStatus.Unspecified:
        //The access status not known yet. Good indication to request it
        //...
        break;
}

If access status is not defined yet, user will be presented with system message:

Anytime application can request background access:

switch (BackgroundExecutionManager.GetAccessStatus())
{
    case BackgroundAccessStatus.AllowedWithRealTimeConnectivity:
        //...
        break;
    case BackgroundAccessStatus.AllowedWithoutRealTimeConnectivity:
        //...
        break;
    case BackgroundAccessStatus.Denied:
        //...
        break;
    case BackgroundAccessStatus.Unspecified:
        //...
        break;
}

Alternatively user can add/remove supporting application using control panel:

Badge and tile notification shown on lock screen:

Note: Lock screen tile notification includes only texts. If original tile notification had some graphics it will not be presented on lock screen.

Working demo:

Live tiles, toast notification and badges. Lock screen notifications

That’s it for now. Stay tuned to last part.

Alex

Windows 8 Consumer Preview and Visual Studio 11 Beta – Show Message Dialogs and Popup Menus (Part 9/11)

Alex Golesh — Thu, 01 Mar 2012 03:31:41 GMT

This post is about popups. Why popups? Who need them?

Popups needed to present some important info to the user in modal way or to present some overlays above other screen elements.

Lets start from Message Box.

WinRT lacks MessageBox support in classic understanding or this UI element.

While showing classic dialog box over Metro application is definitely possible from technical point of view (see screenshots in the post about In-App purchases), it completely destroys Metro look and feel of the application. For this reason WinRT provides MessageDialog class in Windows.UI.Popups namespace. This class not only enables showing popups directly over Metro application but also provides it integrated look and feel and enables customizing the dialog box buttons.

Show simple dialog with one standard button (labeled “Close”), simply create a new instance of MessageDialog class and invoke it asynchronously:

Windows.UI.Popups.MessageDialog dialog = 
     new Windows.UI.Popups.MessageDialog("Copyright by Alex Golesh, (c) 2012", 
                                         "Valentine Love Catcher");
dialog.ShowAsync();

This code produce the following dialog:

It is possible to customize the experience, and provide custom number of buttons, set default button, create custom button labels, define commands invoked on button press and get the command object after dismissing the dialog:

private async void btnAbout_Click(object sender, RoutedEventArgs e)
{
    Windows.UI.Popups.MessageDialog dialog = 
        new Windows.UI.Popups.MessageDialog("Copyright by Alex Golesh, (c) 2012", 
                                            "Valentine Love Catcher");
    //Customize dialog buttons
    dialog.Commands.Add(new UICommand("Good work!", new UICommandInvokedHandler((args) =>{
        //Executes code on closing dialig using this command
        loveFound = !loveFound;
    })));
    dialog.Commands.Add(new UICommand("Thanks!"));
    dialog.Commands.Add(new UICommand("Just close this dialog"));
    //Makes "Thanks!" a default button being invoed while user press Enter key
    dialog.DefaultCommandIndex = 1;
            
    //Returns UICommand object which makes possible to know how this dialog was dismissed
    var dismissedBy = await dialog.ShowAsync();
    txtStatus.Text = "Dismissed by button labeled '" + dismissedBy.Label + "'";
}

This code snippet produces the following message box:

Note: all buttons dismiss the dialog. To wire some functionality (like asking use question providing “Yes”/”No” buttons) on dialog dismiss, use “await” syntax. ow l

Now lets look at Context Menu.

Same namespace (Windows.UI.Popups) enables creating popup (formally context) menus by using new PopupMenu class. Working with this menu very similar to working with MessageDialog – the only real difference is that you cannot provide content/label texts but only UICommands.

private async void imgBoy_DoubleTapped(object sender, DoubleTappedRoutedEventArgs e)
{
    Windows.UI.Popups.PopupMenu popupMenu = new PopupMenu();
    popupMenu.Commands.Add(new UICommand("Look for soulmate", new UICommandInvokedHandler((args) =>
    {
        //Invoke some functionality
        btnSearch_Click(sender, e);
    })));
    if (null != licenseInformation)
    {
        //Add additional commands only if user purchased some in-app products
        if (licenseInformation.ProductLicenses["ValentineBouquet"].IsActive || 
            licenseInformation.ProductLicenses["NewYearGift"].IsActive)
            popupMenu.Commands.Add(new UICommandSeparator()); //Create separator line
        if (licenseInformation.ProductLicenses["ValentineBouquet"].IsActive)
            popupMenu.Commands.Add(new UICommand("Send valentine bouquet"));
        if (licenseInformation.ProductLicenses["NewYearGift"].IsActive)
            popupMenu.Commands.Add(new UICommand("Send New Year gift"));
    }
    var dismissedBy = await popupMenu.ShowAsync(e.GetPosition(this));
    txtStatus.Text = "Dismissed by command labeled '" + dismissedBy.Label + "'";
}

This code snippet produces the following result:

Note: like in MessageDialog, any command releases the popup menu. To wire some functionality on popup menu dismiss, use “await” syntax.

This is it about the popups.

Stay tuned for the next part.

Alex

Windows 8 Consumer Preview and Visual Studio 11 Beta – Licensing and In-app purchases (Part 7/11)

Alex Golesh — Thu, 01 Mar 2012 03:11:48 GMT

Windows 8 Metro applications are distributed by Windows Store. The store handles all installation tasks, updating to the new versions when published by developer. Also it handles purchasing the application, supporting trial mode (if application developer chooses to support it) and handles in-app purchases.

All licensing supported by Windows.ApplicationModel.Store namespace.

Note: CurrentApp provides license information for the current app.This object obtains its data from the Windows Store, which is not currently (Consumer Preview timeframe) supported.

For development purposes we will use CurrentAppSimulator class, which completely mimics APIs of CurrentApp class but enables developing licensing support before publishing the app.

Let’s see the licensing initialization code:

private async void InitializeLicenseEngine()
{
#if DEBUG
    //Point to XML infomration provoded with application instrad of getting data from Windows Store
    await InitializeProxyFolderAsync();
    await SetupProxyFile("LicenseInfo.xml");
#endif
    initializeLicense();
    UpdateCurrentLicenseMode();
}
private void initializeLicense()
{
#if DEBUG
    //Use simulator for debugging
    licenseInformation = CurrentAppSimulator.LicenseInformation;
#else
    //Use real Windows Store data
    licenseInformation = CurrentApp.LicenseInformation;
#endif
    //Subscribe to license changes
    licenseInformation.LicenseChanged += licenseInformation_LicenseChanged;
}
void licenseInformation_LicenseChanged()
{
    //Update application logic on license changes
    UpdateCurrentLicenseMode();
}

For development purposes two helpers functions are used to provide response as it is provided by Windows Store.

async Task InitializeProxyFolderAsync()
{
    // setup licensing proxy XML folder
    proxyFolder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("Microsoft\\Windows Store\\ApiData", CreationCollisionOption.OpenIfExists);
    installLocation = Windows.ApplicationModel.Package.Current.InstalledLocation;
}
async Task SetupProxyFile(string fileName)
{
    // open the proxy file
    StorageFile proxyFile = await installLocation.GetFileAsync(fileName);
    // create proxy file in application data
    StorageFile targetFile = await proxyFolder.CreateFileAsync("WindowsStoreProxy.xml", CreationCollisionOption.ReplaceExisting);
    // replace the contents
    await proxyFile.CopyAndReplaceAsync(targetFile);
}

The XML file with all license info packed with the application to enable debugging:

The file content uses same XML structure as real response from Windows Store:

<?xml version="1.0" encoding="utf-16" ?>
<CurrentApp>
  <ListingInformation>
    <App>
      <AppId>3C14D306-D8F8-4066-A45B-0FB3464C67F3</AppId>
      <LinkUri>http://apps.microsoft.com/app/3C14D306-D8F8-4066-A45B-0FB3464C67F3</LinkUri>
      <CurrentMarket>en-us</CurrentMarket>
      <AgeRating>4</AgeRating>
      <MarketData xml:lang="en-us">
        <Name>Valentine Love Catcher</Name>
        <Description>Sample application to demonstrate new APIs of Windows 8</Description>
        <Price>5.99</Price>
        <CurrencySymbol>$</CurrencySymbol>
      </MarketData>
    </App>
    <Product ProductId="NewYearGift">
      <MarketData xml:lang="en-us">
        <Name>Happy 2013 New Year Gift</Name>
        <Price>1.99</Price>
        <CurrencySymbol>$</CurrencySymbol>
      </MarketData>
    </Product>
    <Product ProductId="ValentineBouquet">
      <MarketData xml:lang="en-us">
        <Name>Valentine Bouquet</Name>
        <Price>2.99</Price>
        <CurrencySymbol>$</CurrencySymbol>
      </MarketData>
    </Product>
  </ListingInformation>
  <LicenseInformation>
    <App>
      <IsActive>true</IsActive>
      <IsTrial>true</IsTrial>
      <ExpirationDate>2012-05-01T00:00:00.00Z</ExpirationDate>
    </App>
    <Product ProductId="NewYearGift">
      <IsActive>false</IsActive>
      <ExpirationDate>2013-01-02T00:00:00.00Z</ExpirationDate>
    </Product>
    <Product ProductId="ValentineBouquet">
      <IsActive>false</IsActive>
    </Product>
  </LicenseInformation>
</CurrentApp>

It defines ListingInformation (product name, rating, price, etc.), in-app products (if supported) and licensing information (trial, active, expiration for application and all products).

Application uses this information to adjust its functionality. In case of my sample application all the proximity functionality is disabled and changes this support when license changed:

private async void UpdateCurrentLicenseMode()
{
    //Show/hide "Buy Now" button based on Trial mode
    btnBuyNow.Visibility = licenseInformation.IsTrial ? Visibility.Visible : Visibility.Collapsed;
    //Check trial/active to enable/disable NFC
    if (licenseInformation.IsTrial || !licenseInformation.IsActive)
    {
        //Disable proximity sensor if not active or in trial mode
        _proximityDevice = null;
        //Get Windows Store (or simulator) listing info and suggest to purchase the app
#if DEBUG
        ListingInformation listing = await CurrentAppSimulator.LoadListingInformationAsync();
#else
        ListingInformation listing = await CurrentApp.LoadListingInformationAsync();
#endif
        txtStatus.Text = "Proximity disabled in trial or non-licensed modes.\nPurchase this application for only " + listing.FormattedPrice;
    }
    else if (!licenseInformation.IsTrial && licenseInformation.IsActive && null == _proximityDevice)
    {
        //Enable proximity when application become active
        _proximityDevice = ProximityDevice.GetDefault();
        if (null != _proximityDevice)
            txtStatus.Text = "Proxmity device is available and ready to go!";
    }
    //Check supported in-app products to enable/disable some UI elements
    if (!licenseInformation.ProductLicenses["ValentineBouquet"].IsActive)
        btnFlower.IsEnabled = true;
    else
        btnFlower.IsEnabled = false;
    if (!licenseInformation.ProductLicenses["NewYearGift"].IsActive)
        btnBallons.IsEnabled = true;
    else
        btnBallons.IsEnabled = false;
}

This code snippet update application’s UI and enables buying application and in-app products:

Pressing “Buy now” button invokes purchasing process:

private async void btnBuyNow_Click(object sender, RoutedEventArgs e)
{
    //Invoke only if still in trial
    if (licenseInformation.IsTrial)
    {
        try
        {
            //Purchase the application
#if DEBUG
            await CurrentAppSimulator.RequestAppPurchaseAsync();
#else
            await CurrentApp.RequestAppPurchaseAsync();
#endif
            //Purchased finished successfully
            txtStatus.Text = "You successfully upgraded your app to the fully-licensed version.";
        }
        catch (Exception)
        {
            //If exception thrown, provide user with information why application were not purchased
            txtStatus.Text = "The upgrade transaction failed. You still have a trial license for this app.";
        }
    }
    else
    {
        txtStatus.Text = "You already bought this app and have a fully-licensed version.";
    }
    UpdateCurrentLicenseMode();
}

While using simulator simple dialog enables to simulate response form Windows Store to debug possible responses:

Almost same process is used to purchase in-app products:

private async Task PurchaseProduct(string ProductID)
{
    try
    {
       //Start produc purchaseing
#if DEBUG
        await CurrentAppSimulator.RequestProductPurchaseAsync(ProductID);
#else
        await CurrentApp.RequestProductPurchaseAsync(ProductID);
#endif
        //Provide user some feedback about purchase success
        ListingInformation listing = await CurrentAppSimulator.LoadListingInformationAsync();
        txtStatus.Text = "You successfully purchased " + listing.ProductListings[ProductID].Name + " for " + listing.ProductListings[ProductID].FormattedPrice;
    }
    catch (Exception)
    {
        //Handle purchase exception
        txtStatus.Text = "The upgrade transaction failed. You still have a trial license for this app.";
    }
    UpdateCurrentLicenseMode();
}

As with application purchase scenario, the simulator dialog enables to simulate response form Windows Store to debug possible responses:

Note: since this approach uses Windows Store simulator and embedded license information the purchases are not preserved between application launches (not activations – see PLM post to understand the differences) and not synced across different user devices.

That’s al I have to say about that © Forest Gump

Stay tuned for next part.

Alex

Windows 8 Consumer Preview and Visual Studio 11 Beta – Quick tip: using sensors (Part 6/11)

Alex Golesh — Thu, 01 Mar 2012 02:24:16 GMT

Windows 8 supports multiple sensors. Some of them could be installed on your device, some of them not.

When I planned this series, I had pretty hard choice to make about the sensor – which one to use. Accelerometer/Gyrometer/Compass/Inclinometer/Orientation are cool sensors, but their usage pretty tightly bound to specific scenarios like games (Accelerometer/Gyrometer/Inclinometer), some location aware applications (Compass) or at least orientation-aware apps (Orientation). I had to make a choice either create simple “show-the-values” boring sample or game which using those sensors (at least some of them) or showcase go with non-standard approach presenting LightSensor which was easy bound to my sample app.

Since all the sensors supports same APIs, I decided to go with latter approach.

Working with all sensors are roughly the same as scenario presented in this simple post. To initialize sensor, use GetDefault function:

//Initialize the sensor
lightSensor = LightSensor.GetDefault();
if (null != lightSensor)
{
    //Sensor is supported!
    //Optionally set reporting interval. Cannot exceed hardware supported minimum reporting inteval
    lightSensor.ReportInterval = lightSensor.MinimumReportInterval;
    //Subscribe to ReadingChanged event to handle new value
    lightSensor.ReadingChanged += new TypedEventHandler<LightSensor, LightSensorReadingChangedEventArgs>(LightSensor_ReadingChanged);
}
else
{
    //Sensor is not supported. Use alternative app path 
    //...
}

If specific sensor supported you can optionally update ReportInterval property specifying how fast/slow your app requires new data. Polling new data slowly helps to preserve battery life (on battery powered devices) but can possible degrade the application functionality (especially in game scenarios when sensor, such as accelerometer, is used for main input).

Note: ReportInterval cannot be lower than hardware reported MinimumReportInterval provided by sensor.

Working with sensor possible using two approaches – polling current reading when necessary using GetCurrentReading function:

var currentReading = lightSensor.GetCurrentReading();

or provide event handler function which invoked every time sensor has a new value (like showed in first code snippet). In both cases, sensor reading object provides all relevant information (for sensor) + reading timestamp. In my sample app LightSensorReading used to change application’s background color:

private void LightSensor_ReadingChanged(LightSensor sender, LightSensorReadingChangedEventArgs args)
{
    Dispatcher.InvokeAsync(CoreDispatcherPriority.Normal, (s, a) =>
    {
        LightSensorReading reading = (a.Context as LightSensorReadingChangedEventArgs).Reading;
        LayotRoot.Background = new SolidColorBrush(Windows.UI.Color.FromArgb(255, (byte)(reading.IlluminanceInLux), 0, 0));
    }, this, args);
}

Note: The event handler arrives out of UI thread, so Dispatcher.InvokeAsync technique must be used to access UI elements.

That’s in for now. Stay tuned for next post.

Alex

Windows 8 Consumer Preview and Visual Studio 11 Beta – Local and Roaming application data storage (Part 5/11)

Alex Golesh — Thu, 01 Mar 2012 02:18:51 GMT

In previous post (Settings – LINK) I explained how to create application’s settings screed and customize it with application specific UI and data. In this post I will explain how to preserve application settings and other application data.

Wind8 CP enables few locations to store application data. Application can use temporary directory to save any kind of information which was possible also before Windows 8. In addition WinRT provides native support saving data in application’s data store as collection of Key Value Pairs. This data can be stored locally or using roaming store. Roaming store will be synchronized by Windows if user permits data synchronization (and when such synchronization is permitted):

To take advantage of this mechanism application must use ApplicationData class from Windows.Storage namespace. This class provides access to both, LocalSettings and RemoteSettings. Both classes exposes sample APIs, which enables abstracting Save/Load functionality from actual data location.

In my sample application I am supporting both types of storages. As you probably remember from previous post, my settings screen supports switching between stores by enabling and disabling settings synchronization.

Let’s get started. Regardless to actual data location (local store or cloud), application subscribes to DataChanged event. This event occurs when roaming data is synchronized (in my scenario occurs when changed on some other device running same application).

Note: In my case application synchronizes only settings, then it reloads synchronized data once it was changed on other device. In other scenarios it might or might not make sense reloading synchronized data during application execution and depends exclusively on application.

protected override void OnNavigatedTo(NavigationEventArgs e)
{ 
    //Sunbscribe to DataChanged event to get notification if data changed in some other device
    ApplicationData.Current.DataChanged += (sender, args) =>
    {
        //Reload settings when they changes somewhere
        ReloadSettigns();
    };
    //Get settings
    ReloadSettigns();
    //...
}

Let’s see the ReloadSettings function:

private void ReloadSettigns()
{
    //Application logic prefers roaming storage over local one
    roamingSettings = ApplicationData.Current.RoamingSettings;
    if (roamingSettings.Values.Count == 0)
        roamingSettings = ApplicationData.Current.LocalSettings;
    //Application settings build from exactly 8 values. If something is missing use default values
    if (roamingSettings.Values.Count == 8)
    {
        //Value is object and must be cast to final type
        RemotePushEnabled = (bool)roamingSettings.Values["RemotePushEnabled"];
        LocationEnabled = (bool)roamingSettings.Values["LocationEnabled"];
        SensorsEnabled = (bool)roamingSettings.Values["SensorsEnabled"];
        LocalPushEnabled = (bool)roamingSettings.Values["LocalPushEnabled"];
        SharingEnabled = (bool)roamingSettings.Values["SharingEnabled"];
        ProximityEnabled = (bool)roamingSettings.Values["ProximityEnabled"];
        BackgroundAccess = (bool)roamingSettings.Values["BackgroundAccess"];
        SyncSettings = (bool)roamingSettings.Values["SyncSettings"];
    }
}

As you remember from previous post, when some value changed on Settings screen, the value assigned to corresponding variable and SaveSettings function being executed. Let’s see the function:

private void SaveSettings()
{
    //Clean previous values
    CleanSettings();
    //If user prefers to sync data in the cloud use RoamingSettings, otherwise use LocalSettings
    if (SyncSettings)
        roamingSettings = ApplicationData.Current.RoamingSettings;
    else
        roamingSettings = ApplicationData.Current.LocalSettings;
    //Add values to settings
    roamingSettings.Values.Add("RemotePushEnabled", RemotePushEnabled);
    roamingSettings.Values.Add("LocationEnabled", LocationEnabled);
    roamingSettings.Values.Add("SensorsEnabled", SensorsEnabled);
    roamingSettings.Values.Add("LocalPushEnabled", LocalPushEnabled);
    roamingSettings.Values.Add("SharingEnabled", SharingEnabled);
    roamingSettings.Values.Add("ProximityEnabled", ProximityEnabled);
    roamingSettings.Values.Add("BackgroundAccess", BackgroundAccess);
    roamingSettings.Values.Add("SyncSettings", SyncSettings);
    //Signal data changed which will trigger cloud sync process when system synchronizes data next time
    ApplicationData.Current.SignalDataChanged();
}
private void CleanSettings()
{
    if (null != roamingSettings)
        roamingSettings.Values.Clear();
}

Note: Cleaning all values instead of replacing them is probably not the best practice which can increase synchronization traffic usage, but in case of such simple example (and for code brevity) I preferred this approach.

In addition settings can be organized in Containers:

//Create new container
roamingSettings.CreateContainer("GeneralSettings", ApplicationDataCreateDisposition.Always);
//Setting named value in specific container
roamingSettings.Containers["GeneralSettings"].Values.Add("RegisteredUser", "AlexG");
//Getting named value form specific container
string user = (string)roamingSettings.Containers["GeneralSettings"].Values["RegisteredUser"];
//Delete container with all values
roamingSettings.DeleteContainer("GeneralSettings");

When using roaming settings important to know how much data being synced and how much could be synced. ApplicationData class provides information about roaming storage quota and usage:

ulong quota = ApplicationData.Current.RoamingStorageQuota;
ulong used = ApplicationData.Current.RoamingStorageUsage;

In addition, it is possible to create basic version management of data stored in any store by querying current version and setting new version:

//Get current version
uint version = ApplicationData.Current.Version;
//Set new version
await ApplicationData.Current.SetVersionAsync(123, new ApplicationDataSetVersionHandler((version) => {
    if (version.CurrentVersion == version.DesiredVersion)
    {
         //Worked
    }
    else
    {
         //Something went wrong...
    }
}));

Last, but not least, ApplicationData class provides access to Local/Roaming/Temporary folders. All classes exposes the sample API and enables managing files and folders using standard WinRT async patterns:

//Create file in roaming folder. Also possible to create file/folder in ApplicationData.Current.TemporaryFolder or ApplicationData.Current.LocalFolder
StorageFile file = await ApplicationData.Current.RoamingFolder.CreateFileAsync("settings.dat", CreationCollisionOption.ReplaceExisting);//Open file for writing and write some binary buffer...
Stream stream = await file.OpenStreamForWriteAsync();
stream.Write(buffer, offset, count);
await stream.FlushAsync();

That’s it for now.

Stay tuned for next part.

Alex

Windows 8 Consumer Preview and Visual dStudio 11 Beta – Customizing Settings Charm (Part 4/11)

Alex Golesh — Thu, 01 Mar 2012 02:04:00 GMT

Before Windows 8 every application invented its own way to present application settings. Here are very few of them:

Some apps even provided standalone applications to manage settings. Also from settings storage perspective every developer had to decide when, where and how those settings are saved and in some cases synchronized between different user’s machines.

With Windows 8 Metro applications most of those questions and hard choices are gone. Every Metro application can use system-wide standard way to present settings and collect them in predictable and system-standard way. Windows 8 provides “Settings” charm which is accessible as a part of system menu.

By default, if not customized, application will have only one (system provisioned) settings entry – Permissions.This menu item shows basic application package information and special permissions application uses (as provided by application manifest)

Application developer can customize the contents of Settings charm by adding custom menu entries (commands) and handling it in application.

When user opens the settings charm application gets a chance to provide custom commands. To get notified about this request subscribe to CommandsRequested event of SettingsPane class as in the following code snippet:

//Setup settings panel
SettingsPane.GetForCurrentView().CommandsRequested += OnCommandsRequested;

Application can provide customized UI to launch the settings charm. To show this charm invoke the following code as response your application corresponding UI request:

SettingsPane.Show();

Once user invokes this functionality or opens Settings charm by system gesture OnCommandsRequested handler being executed. In order to add new item (Command) to settings pane you have to create new instance of SettignsCommand class providing CommandId, Label and handler function (which will be executed in user invokes the command):

void BlankPage_CommandsRequested(SettingsPane sender, SettingsPaneCommandsRequestedEventArgs args)
{
    SettingsCommand SyncSettingsCommand = new SettingsCommand("SyncSettings", SyncSettings ? "Disable settings sync" : "Enable settings sync", new UICommandInvokedHandler(onSettingsSync));
    args.Request.ApplicationCommands.Add(SyncSettingsCommand);
    //...
    SettingsCommand helpCommand = new SettingsCommand("HelpPage", "Help", new UICommandInvokedHandler(onHelpCommand));
    args.Request.ApplicationCommands.Add(helpCommand);
}
private void onSettingsSync(IUICommand command)
{
    //Do application logic for setting change
    SyncSettings = !SyncSettings;
    SaveSettings();
}
private void onHelpCommand(IUICommand command)
{
    helpPage.Margin = ThicknessHelper.FromUniformLength(0);
}

Note: Most of the commands were skipped for brevity of the code. SaveSettigs functionality will be discussed in my next post.

Customized settings charm (permissions are provided by OS):

Let us see two typical settings commands: direct value change (like Sync settings) and “link” to some additional settings screen. In both cases, taping (clicking) the command on settings charm dismisses the charm. While in case of Sync settings the command is responsible for direct change of the setting, in case of Help we want to present some additional functionality and screen. Unfortunately it is not possible to integrate custom user control into settings charm, so application developer must provide the UI and system-like behavior.

System-like behavior assumes that changes made in custom panel are implemented/saved as they done, panel enables navigating back to system settings pane and supports light dismiss – clicking anywhere else of the panel dismisses the panel and saves the settings.

In my application I created simple user control, which were initially placed off main screen (using negative margin):

<local:HelpPage x:Name="helpPage" Margin="0,0,-346,0" HorizontalAlignment="Right">
    <local:HelpPage.Transitions>
        <TransitionCollection>
            <RepositionThemeTransition/>
        </TransitionCollection>
    </local:HelpPage.Transitions>
</local:HelpPage>

I defined transition effect for my custom control to enable repositioning using system-like animation (RepositionThemeTransition). Using this effect helps mimic “sliding out” effect like real system-provided settings charm does. Final custom settings panel looks like the following:

To support light-dismiss I’ve subscribed to PointerPressed event on parent UI element (in my case – Grid):

<Grid PointerPressed="Grid_PointerPressed">

And in handler function simply changed the Margin property of the control:

private void Grid_PointerPressed(object sender, Windows.UI.Xaml.Input.PointerEventArgs e)
{
    //Change margin only if control is visible
    if (helpPage.Margin.Right == 0)
        helpPage.Margin = ThicknessHelper.FromLengths(0, 0, -346, 0);
}

At the control level, I subscribed to back button Click event:

<Button x:Name="backButton" Click="GoBack" Style="{StaticResource BackButtonStyle}" Margin="0"/>

and in event handler I re-opened settings pane and hided the panel:

private void GoBack(object sender, RoutedEventArgs e)
{
    //Reopen settings pane
    SettingsPane.Show();
    //Hide this panel
    this.Margin = ThicknessHelper.FromLengths(0, 0, -346, 0);
}

Small trick here – you control must subscribe and handle PointerPressed event, otherwise parent control (Grid in my case) will dismiss it on any tap/click, even on control itself:

private void UserControl_PointerPressed(object sender, PointerEventArgs e)
{
    e.Handled = true;
}

The control logic (the rest of code you have to write) is absolutely unique for each application.

The working settings pane with custom help panel demonstrated here:

Integrating custom panel in settings panel

Using the techniques described above you application supports standard Windows 8 settings behaviour.

That’s it for now.

Stay tuned for next post.

Alex

Windows 8 Consumer Preview and Visual Studio 11 Beta – Working with Proximity Device (Part 2/11)

Alex Golesh — Thu, 01 Mar 2012 01:50:18 GMT

This post is about proximity devices and scenarios enabled by using this functionality.

WinRT supports Near Field Communication (NFC) scenarios by providing native support using Windows.Networking.Proximity namespace. This namespace enable working with proximity device in two different modes – direct communication using sockets (ProximityStreamSocket class) and publish/subscribe mode (using ProximityMessage class). ProximityDevice class provides gateway to hardware NFC device component (if present in computer/tablet, drivers are installed and user permits using such type of devices).

To use Proximity device it must be manifested in Capabilities section of application manifest:

In both cases first you need to acquire the proximity device:

.csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

     ProximityDevice _proximityDevice;

    _proximityDevice = ProximityDevice.GetDefault();

    //Check for proximity device presence

    if (null == _proximityDevice)

    {

        //Device is not present or not enabled. Have a "backup" plan

        //...

    }

    else

    {

        //Device is presend and working

        //...

    }

Using sockets requires using PeerFinder class which helps looking for devices, enables getting requests from arriving device and connection to them. Once two peers completer the connection cycle (PeerFinder.TriggeredConnectionState == TriggeredConnectState.Completed) event arguments provides an instance of ProximitryStreamSocket class which is used to transmit data between devices.

While this technique is relatively advanced and requires subscribing to multiple events and managing socketed connection, ProximityDevice class provides easier way to transmit messages between two PCs/Tablets. Using pub/sub model requires subscribing to known message type from one hand and publishing known message type from other hand. Once connection established and message delivered devices can stop publishing/listening to the messages:

    long _subscribedMessageId = -1;

    long _publishedMessageId = -1;

    //...

    //-----------------------------------------------------------------------------------------

    //Subscribing to messages

    if (_subscribedMessageId == -1)

    {

        //Start listening for messages

        _subscribedMessageId = _proximityDevice.SubscribeForMessage("Windows.TheLoveMessage", (_proximityDevice, message) =>

        {

            //When message arrives proceed with application logic

            if (message.DataAsString.Contains("LOVE;"))

            {

                ///...

            }

            //Optionally, stop listening to messgaes if applicaton logic requires so

            _proximityDevice.StopSubscribingForMessage(_subscribedMessageId);

        });

    }

    else

        //Already subscribed to message...

    //...

    //-----------------------------------------------------------------------------------------

    //Publish messages

    if (_publishedMessageId == -1)

    {

        //Start publishing messages

        _publishedMessageId = _proximityDevice.PublishMessage("Windows.TheLoveMessage", "LOVE;" + txtName.Text);

        //The rest of applciation logic after starting publishing the message

    }

    else

        //Already publishing the message...

    //...

    //-----------------------------------------------------------------------------------------

    //When not needed anymore, stop publishing the message

    _proximityDevice.StopPublishingMessage(_publishedMessageId);

In addition, ProximityDevice enables subscribing to DeviceArrived and DeviceDeparted events, which helps to maintain state of connected/disconnected devices and provides information about them:

    //Get proximity device

    _proximityDevice = ProximityDevice.GetDefault();

    //If device initialized successfully

    if (null != _proximityDevice)

    {

        //Subscribe to DeviceArrived event

        _proximityDevice.DeviceArrived += (arrivedProximityDevice) =>

            {

                //...

            };

        //Subscribe to DeviceADeparted event

        _proximityDevice.DeviceDeparted += (departedProximityDevice) =>

            {

                //...

            };

    }

Note: MessageType parameter in PublishMessage function must begin from “Windows.”

That’s it for now.

Stay tuned for next part.

Alex

Windows 8 Consumer Preview and Visual Studio 11 Beta – What’s New (Part 1/11)

Alex Golesh — Wed, 29 Feb 2012 23:30:00 GMT

Long awaited Windows 8 Consumer Preview (Win8 CP) just released!

It is not come alone, but accompanied with Visual Studio 11 Beta (VS11)! Both products available for download. The links are:

Win8 CP download is available here.

Visual Studio 11 Express Beta for Windows 8 download available here.

So what’s new for developers?

First think you will meet right after installing VS11 is facelift. Compare – VS2010 & VS11:

VS11 got Metro-ish face lift! The icons are flat and grey, windows got flat look and feel with grey title, even breakpoint marker (red dot) was flattened. Despite the fact I loved Win8 Metro main screen, my first reaction was “%@X&*@%$#@$@!” and I have to admit I was wrong. Now, after using it for quite some time I absolutely love it!

In next days you will see great many articles and blog posts discussing new features of Win8 CP and the VS11; I will focus on practical part part – how to take your //BUILD DP application run in Win8 CP.

Disclaimer: I love XAML and C#, thus all my posts will be focused only on those technologies of Win8 Metro development. If you are looking for XAML/C++ or HTML/JavaScript stuff, you should refer to some other wonderful blogs.

Let’s see how to migrate you BUILD DP timeframe app to Beta. Just opening the application's solution file with VS11 Beta will not work and you will be getting this kind of experience:

With the following problem in Output window:

C:\Users\Alex\Downloads\File access sample\C#\FileAccessSample.csproj : error : The imported project "C:\Program Files (x86)\MSBuild\Microsoft\WindowsXaml\v1.0\Microsoft.Windows.UI.Xaml.CSharp.targets" was not found. Confirm that the path in the <Import> declaration is correct, and that the file exists on disk. C:\Users\Alex\Downloads\File access sample\C#\FileAccessSample.csproj

While it is possible to open csproj file, change the “v1.0” to”v11.0” in file path and reload the project in some cases this will render following some of the following errors:

The best approach to migrate you existing application would be to start brand new “Blank Application” from Windows Metro Style templates and start pulling in your resources, XAML and code files:

After rebuilding your project structure, try to compile you application. It will not compile: the biggest change impacting your work will be accommodating the naming changes in Windows.UI.ViewManagement.ApplicationLayout. All names referencing “layout” were changed to “view”. Enumerations for ApplicationViewState now reflect different orientations, so ApplicationViewState.FullScreen was split up into FullScreenLandscape and FullScreenPortrait which you will have to accommodate in your code.

The event handlers for View state changes have changed and need to be migrated:

Windows.UI.ViewManagement.ApplicationView.GetForCurrentView().ViewStateChanged +=        
    new TypedEventHandler<Windows.UI.ViewManagement.ApplicationView, Windows.UI.ViewManagement.ApplicationViewStateChangedEventArgs>(MainPage_ViewStateChanged);

Also the handler function signature changed:

void MainPage_ViewStateChanged(Windows.UI.ViewManagement.ApplicationView sender, Windows.UI.ViewManagement.ApplicationViewStateChangedEventArgs args)
{
    //...
}

This is a common part for all applications, but this is only the beginning. After dealing with this part you are expected to change/fix breaking changes in WinRT APIs – the amount of those changes and possible solution depends entirely on your application’s functionality and used APIs.

Last, but not least, you must provide new resized graphics for application package such as package logo size is 50x50 (was 56x56), new splash screen size is 620x300 (old was 624x304), badge (if your application uses it) and maybe some others.

For complete list of breaking changes, please refer to the documentation here.

That’s it for now. In next posts I will show few new (or changed) APIs in Win8 CP. Here are the next planned posts in this series (in no specific order):

1. What’s New – this post

2. Proximity – in this post I will show how to use near field communication (NFC) to transmit information between NFC-enabled devices

3. Sharing data – in this post I will overview how to share the data from your application (“Share source”). Also, I will describe how to build simplest “Share target” application which helps to debug you share source app (and was really helpful for me, since at the time I wrote this series the marketplace apps were not available and I had no app to share my data with)

4. Settings – in this post I will overview how to use the settings charm and integrate your app settings into it

5. Local and roaming data – in this post I will overview how to save the data for your application and how to use Win8 CP built-in settings sync functionality to sync your app’s settings

6. Sensors – in this post I will overview working with some sensors. Since may posts will overview using accelerometer, inclinometer and other “orientation-related” sensors (easier to bind their data to input and showcase) I decided to overview using relatively exotic one- the light sensor and how to use its data in application.

7. Licensing (Trial/Full application) and In-App purchases – in this post I will overview the different modes of the application, the products which developer can supply for in-app usage and how to debug those features before your application is published.

8. Location Service – in this post I will overview how to use location information in your app

9. Popups – in this post I will show how to use new kind of “Message Box” in Win8 CP Metro apps.

10. Live tiles, toasts and badges and Push Notifications – in this post I will overview how to keep interacting with your user, even when you application is not running anymore. Also I will touch how to deliver push notifications to your application (which used to update tiles, toasts and badges as described in “Live tiles, toasts and badges” post)

11. PLM and Custom Splash Screen – in this post I will overview product lifecycle management and custom splash screen

If you are still thinking about downloading and trying Win8 CP and VS11 Beta – think no more! Just go and download!

Stay tuned for more posts to come,

Alex