• Activating the App.
• Suspending/Resuming/Terminating an app.
• App Bar activation.
• Snapping the app.
• Activate Sharing etc.

 I started off with the unmanaged code presented in the blog post http://blogs.msdn.com/b/windowsappdev/archive/2012/09/04/automating-the-testing-of-windows-8-apps.aspx

 --------------------------------------------------------------------------------------------------------------------------------

HRESULT LaunchApp(const std::wstring& strAppUserModelId, PDWORD pdwProcessId)
{
    CComPtr<IApplicationActivationManager> spAppActivationManager;
    HRESULT hrResult = E_INVALIDARG;
    if (!strAppUserModelId.empty())
    {
        // Instantiate IApplicationActivationManager
        hrResult = CoCreateInstance(CLSID_ApplicationActivationManager,
            NULL,
            CLSCTX_LOCAL_SERVER,
            IID_IApplicationActivationManager,
            (LPVOID*)&spAppActivationManager);

        if (SUCCEEDED(hrResult))
        {
            // This call ensures that the app is launched as the foreground window
            hrResult = CoAllowSetForegroundWindow(spAppActivationManager, NULL);
           
            // Launch the app
            if (SUCCEEDED(hrResult))
            {
                hrResult = spAppActivationManager->ActivateApplication(strAppUserModelId.c_str(),
                    NULL,
                    AO_NONE,
                    pdwProcessId);
            }
        }
    }

    return hrResult;
}

int _tmain(int argc, _TCHAR* argv[])
{
    HRESULT hrResult = S_OK;
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)))
    {
        if (argc == 2)
        {
            DWORD dwProcessId = 0;
            ++argv;
            hrResult = LaunchApp(*argv, &dwProcessId);
        }
        else
        {
            hrResult = E_INVALIDARG;
        }

        CoUninitialize();
    }

    return hrResult;
}

---------------------------------------------------------------------------------------------------------------------------------

 One of the requirements was to be able to execute this from managed code. I did some reading on how to call Unmanaged COM Code from managed code and decided to try the below options.

1. PINVOKE
2. COM Class Wrappers. (http://msdn.microsoft.com/en-us/library/aa645736%28v=VS.71%29.aspx)

This article documents my efforts in getting the above piece of code executed from  managed code using PINVOKE. I am not familiar with COM & Unmanaged Code (C++). I had to do a lot of learning before I attempted this.Some of the things that I write here can be very basic (as I mentioned this is my first try at Unmanaged COM code).

1. I started by creating a C++ Dynamic Linked Library project called MAF32.
2. Refactored the above code,

•  Moved everything into a single method (Moved the logic with the main method into the Launch app method.)
• Updated the first parameter type from constant pointer to std::wstring to LPWSTR. This was done to facilitate marshaling of managed types while using PINVOKE.

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

HRESULT LaunchApp(LPWSTR strAppUserModelId, PDWORD pdwProcessId)

{

HRESULT hrResult =

S_OK;

if (SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)))

{

CComPtr<IApplicationActivationManager> spAppActivationManager;

HRESULT hrResult = E_INVALIDARG;

size_t  strlength = wcslen(strAppUserModelId);

if (strlength != 0)

{

// Instantiate IApplicationActivationManager

hrResult = CoCreateInstance(CLSID_ApplicationActivationManager,

NULL,

CLSCTX_LOCAL_SERVER,

IID_IApplicationActivationManager,

(LPVOID*)&spAppActivationManager);

if (SUCCEEDED(hrResult))

{

// This call ensures that the app is launched as the foreground window

hrResult = CoAllowSetForegroundWindow(spAppActivationManager,

NULL);

// Launch the app

if (SUCCEEDED(hrResult))

{

hrResult = spAppActivationManager->ActivateApplication(strAppUserModelId,

NULL,

AO_NONE,

pdwProcessId);

}

}

}

CoUninitialize();

}

return hrResult;

}

---------------------------------------------------------------------------------------------------------------------------------------------------------

 In short, the above COM code does the following.

• Initializes a COM instance (COM must be initialized for every thread that executes COM code).
• Creates an instance of the COM interface IApplicationActivationManager.
• Calls the activate application method.
• Un-Initializes the COM instance

3. Created a C# Console application project and added the following code which allows us to call the LaunchApp method from the Unmanaged dll (MAF32.dll).

 [DllImport("MAF32.dll")]      //Note: Name of the C++ dll that we created in Step 1. 

  public static extern int LaunchApp(        //Note: Name of the method must be exactly same as the one defined in C++ code.

    string processIdentifier,          

    out int processId); //The C++ code takes a pointer to DWORD as parameter. In C#, I am passing reference (note the out keyword) to a integer as a parameter.

4. Now in the Console application's Main method, I called the method as follows.

   uint processId;

   PlatformInvokeTest.LaunchApp(@"Microsoft.BingTravel_8wekyb3d8bbwe!AppexTravel", out processId);

   Console.WriteLine(processId);

Note: For this to work, the unmanaged dll created in step1 (MAF32.dll) must be present in the same directory as that of the C# application.

5. On executing the managed code, I got "EntryPointNotFoundException".

6. I downloaded the Depends.exe (SysInternals tool) to see the methods exposed by MAF32.dll) .

Even though "MAF.dll" contains a method call LaunchApp, it is not visible to the clients. In order to make this method visible to the clients we must do one of the following

• Explicitly define the dll's interface using the dll export attribute. http://msdn.microsoft.com/en-us/library/3y1sfaz2(v=VS.80).aspx
• Use Module definition  (.def) files to specify the methods that are exposed by the dll. http://msdn.microsoft.com/en-us/library/d91k01sh.aspx

I chose to follow the first method. So I made the below changes.

• Added the code "#define DllExport extern "C" __declspec( dllexport )" to the code.
• Decorated the LanuchApp method with the DllExport keyword.

Now on running the depends tool once again, you can see the LaunchApp method.

 7. I re-executed the C# Console application. I no longer got the EntryPointNotFound exception. However the method doesn't launch the app as expected. On debugging I found that the call to the method

      if(SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)))

always returns a failure and the rest of the code is not being executed. The CoInitializeEx method returns the error code "RPC_E_CHANGED_MODE" which means the COM has been already initialized on that thread in a different mode.  From .Net 2.0 onwards CLR initializes COM on every Dot net thread in Multi Threaded Apartment state by default. The C++ code is trying to initialize it in Single threaded apartment state, Hence the error. 

I have removed the call to CoInitializeEx and CoUninitialize since this is already handle by CLR.

8. On  further execution, the call to the ActivateApplication method return the error code "-2144927148" (0x80270254) which is "E_APPLICATION_NOT_REGISTERED" . After debugging for quiet sometime and trial and error, I figured out that this was because of marshaling issues. I changed the below marshaling code  as follows,

   [DllImport("MAF32.dll")]       

  public static extern int LaunchApp(

         [In, MarshalAs(UnmanagedType.LPWStr)]string processIdentifier,

         [Out, MarshalAs(UnmanagedType.U4)] out int processId);

For more info on marshaling see

http://msdn.microsoft.com/en-us/library/aa288468(v=VS.71).aspx#pinvoke_defaultmarshaling

http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshalasattribute(v=vs.71).aspx

http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.unmanagedtype(v=vs.71).aspx

After this I was able to launch the application from managed code.

Final Code for launching a modern app from Managed code is below.

*************Unmanaged code in MAF32.cpp************************

#include "stdafx.h"

#include "stdafx.h"

#include <shlobj.h>

#include <stdio.h>

#include <shobjidl.h>

#include <objbase.h>

#include <atlbase.h>

#include <string>

#define DllExport extern "C" __declspec( dllexport )

DllExport HRESULT LaunchApp(LPWSTRstrAppUserModelId, PDWORDpdwProcessId)

{

    HRESULT hrResult = E_INVALIDARG;

   CComPtr<IApplicationActivationManager> spAppActivationManager;

   size_t  strlength = wcslen(strAppUserModelId);

  if (strlength != 0)

  {

       hrResult = CoCreateInstance(

         CLSID_ApplicationActivationManager,

        NULL,

       CLSCTX_LOCAL_SERVER,

       IID_IApplicationActivationManager,

     (LPVOID*)&spAppActivationManager);

    if (SUCCEEDED(hrResult))

   {

         hrResult = CoAllowSetForegroundWindow(

        spAppActivationManager,

        NULL);

       if (SUCCEEDED(hrResult))

      {

           hrResult = spAppActivationManager->ActivateApplication(

                            strAppUserModelId,

                           NULL,

                          AO_NONE,

                          pdwProcessId);

          }

      }

  }

return hrResult;

}

**********************************************************************************************************************************

***************Managed Code ********************************************************************

class Program

{

    static void Main(string[] args)

   {           

         int processId;        

        Console.WriteLine(PlatformInvokeTest.LaunchApp(@"Microsoft.BingTravel_8wekyb3d8bbwe!AppexTravel",    out processId));           

        Console.WriteLine(processId);

   }

 }   

public class PlatformInvokeTest

{

        [DllImport("MAF32.dll")]       

        public static extern int LaunchApp(

           [In, MarshalAs(UnmanagedType.LPWStr)]string processIdentifier,

          [Out, MarshalAs(UnmanagedType.U4)] outint processId);

 }

Similar code can then be used to perform other application level activities from managed code.

So as long as the control implements this interface, it can be used with in the Semantic zoom. I have played with this interface and was able to come up with a basic implementation.

Please note that the below scenario is a hypothetical example. The example doesn’t follow the guidelines for Semantic zoom and is a very crude implementation of ISemanticZoomInformation. But I am doing this just to demonstrate that other controls can be extended to use Semantic zoom.The hypothetical scenario is as follows.

I have a stack panel of buttons. In Zoomed in view I want to display the items Vertical orientation and in the Zoomed out view I want to display them in horizontal orientation.

• Create a custom stack panel which implements ISemanticZoomInformation.  

Right click on ISemanticZoomInformation and use the “Implement interface” menu item to implement the interface.This adds the following methods and properties to your class. These methods and
Properties are wired to throw exceptions when they are called by default. 

ISemanticZoomInformation Methods:  

Following ISemanticZoomInformation methods need to be implemented. For this basic example we don’t need to put any code in these methods. Just comment out the line which throws the “NotImplementedException”

ISemanticZoomInformation Properties:  

 Following properties have to be implemented.  Comment the lines which throw the exception. Change the code as follows.

That’s it, now our Stack Panel is ready to be used with in the Semantic Zoom control. Use the above Stack Panel with in the Semantic Zoom control.

Build and Run.

Personally I don’t see a reason for doing something like this in the real world. Semantic zoom is not meant for something like this. Thoroughly understand the purpose of Semantic Zoom before using it or before customizing
other controls to support Semantic zoom. Guidelines for Semantic Zoom can be found at.

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

Hope this helps.

Below is a snapshot of sample data.

Let’s start by taking a look at my Data Model. I have three classes.

1. MyDataSource – Contains an ObservableCollection of Group objects. This will be source of the CollectionViewSource (This collection view source is in turn used as an ItemSource of the GridView)

2. MyGroup – This represents a Group in the grouped grid view. It contains a collection of Items.

3. MyItem - Represents the individual item in the GridView. MyItem has a reference (cross reference) back to the Group that its part of.

 Set the Data Context of the Page to the collection of groups.

Set the CanDragItems property of the GridView to true. Also handle the event “DragItemsStarting”

While the GridView handles the initiation of dragging, I have implemented the Drop related code on the VariableSizedWrapGrid which handles the layout of the Group’s items.On the GroupStyle panel’s VariableSizedWrapGrid, set Allow Drop property to true  and also handle the Drop event.

When the user starts dragging an item, the Grid view’s “DragItemsStarting” event is raised. Within the even handler, I am saving a reference to the Dragged Item.

When the user Drop’s the item on another Group of items (wrapped in the VariableSizedWrapGrid) the wrapped grid’s Drop event is raised. Within the Drop item, I have added logic to
remove the item from the source group and then add it to the Target group. I am directly changing the source Groups and letting change notification do the rearranging.

 And this did the job for me.

 I will continue to work on improving the experience and try to find better options of implementing this. I will post a final update once the refinements are made. If you have suggestion or ideas, leave a comment. I will try them out.

Thanks

Note: I am not aware of the exact method used to create the contact view in people app. The below is the method that I used for creating a similar experience.

 The people apps Grid view has the following features

1. Contacts are grouped by the first character.

2. The items flow from one group (Based on First Character) to another Group. The flow is continuous without any gaps.

My first instinct was to use a “Grouped List View". However I soon realized that this doesn’t give the desired effect. There were huge gaps between items belonging to different groups, especially if the number
of items within each group varies drastically.

I decided to use a normal Grid view instead of a grouped view. I created a list of Comic characters to use as a source to my list view. The list contains the first characters, along with the actual names.

Set the Item Source property of the Grid View to the above list.

Now when displaying the Grid View, we have to use different Item Templates (Item Templates are used to specify the visualization of the data objects).

I created a Data Template called “FirstCharacterTemplate” to use while displaying the Characters. I have also created another template called the “NameTemplate” for displaying the actual names.

Once the templates are defined, we need to tie the above templates to the appropriate entries. For instance, if the string is a single character string, the FirstCharacterTemplate needs to be used. This can be done by using an ItemTemplateSelector.

• Create a new class called ContactListTemplateSelector and derive it from the DataTemplateSelector class.

• Override the method “SelectTemplateCore”. The method takes 2 parameters. The first parameter is the object that is being displayed (In our case the string) and the second parameter is Dependency object. Within this method check the length of the data. Based on the length of the data, return the appropriate Data Template.

Add an instance of this DataTemplateSelector to the page’s resource section.

 
Associate this DataTemplateSelector to the Grid view using the ItemTemplateSelector property.

 One more thing left to do. Even though we used different data templates to display the single character string and the names, the type of container for these items remains the same. In this case the container happens to be a GridViewItem. Because of this, the user will still be able to click on the “Single Character” item. Even though nothing happens, the click animation is still shown. We don’t want this to happen (as designed in the people app). 

This can be done by setting the GridViewItem’s (only the Single Character items) IsHitTestVisible property to false. One way of doing this is to use ContainerStyleSelector and set different Container styles based on the data (steps similar to the ones used with ItemTemplateSelector)

 I have used a different way of doing this. Remember our ContactListTemplateSelector class, where we have overridden the “SelectTemplateCore” method. The second parameter to that method is the container  In our case GridViewItem). We can set the IsHitTestVisible property to false (In case of a single character item) right here.

We are now ready to run our app.

Pretty close. Hope this helps.

Semantic Zoom

Semantic zoom is a technique used for presenting and navigating large data sets with in single view.

Problem:

Consider the app “Cars 2 Go”.

 
The Group details page lists huge number of car models, grouped by their manufacturer in alphabetical order. Take a look at the scroll bar at the bottom of the view and just imagine the amount of scrolling/panning that is needed to view cars manufactured by “Tesla”.  Panning and Scrolling are great for small sets of data; however navigation becomes cumbersome for huge data sets as above. Semantic zoom is tailored made for these situations.

Semantic Zoom uses two zoom levels

1. Zoomed In view / Low level View. Above Image is an example of a Zoomed in view, where all the manufactures and models are displayed.
2. Zoomed Out view /High level View. Below image is an example of a Zoomed out view, where only the manufacturers are displayed.

Now all that the user has to do is click on the manufacturer that he likes, and he will be taken back to the zoomed in view, and will be automatically panned/scrolled to the tapped/selected point.Consider for example, the user clicks on “Saab” in the Zoomed out view. The user will be zoomed in, and will be automatically panned to Saab. This automatic panning is handled by the Semantic Zoom control internally and happens when the user taps or selects an item in the Zoomed out view. This is also referred to as “Scroll Jump” in MSDN.

To begin with, I have a Data Source which returns a collection of Make objects (manufactures). Each Make object contains a list of Model (car models – exposed using the property AllModels) objects. I started with the default grid template which comes out of the box. The Grouped Items page will be my entry point and will act as my high level view. The grouped items page has a

1. Grouped Collection View source.
2. Grid view which displays the contents of the Grouped collection view source.

All I need to do to create a Zoomed In view is to hook up the Collection View Source to the collection.

Now we have a zoomed in view, which will display all the models, grouped by their manufactures. In order to tell the runtime that this is the Zoomed in view, do the following.

1. Add a Semantic zoom control to the Xaml, and define Zoomed In and Zoomed Out views as follows.

     2. Now make the above Grid View, part of the ZoomedInView definition as below

Now it is time to define the Zoomed out view. Following are the mistakes that I made.

1. When I did this the first time, I just copied the initial grid view and removed the Group Style and made it part of the Zoomed out View. Now both the grid views (one with Group Style and the other without Group Style) have the same grouped collection view source.

        Also remember we need to keep track of the selected group between the views in order to support Scroll Jump. Having the same collection view source as the Items Source for both the views should help. But there is one small problem. The CollectionViewSource is grouped by Manufacturer. So it basically behaves as a list of models (grouped by manufacturers). The first Grid view which defined Group Style knows how to display the data. The Second Grid View because of the absence of the Group Style is not aware of the Grouping Context (that is manufacturer) and considers the CollectionViewSource as a list of car models (without being aware of the manufacturers)

      In this scenario, the Zoom out view displays all the car models. We wanted it to display only the manufacturers.

2.  After the first failed attempt, I was thinking of setting the Data Context to the collection of Makes and then binding the Zoomed out Grid View to that data context. The Data Context is aware of only the top level collection (manufacturers, not car models). This worked. My Zoomed Out view now shows a list of manufacturers which is quiet small and can be displayed in a single view.  But there is a draw back. Because both the Grid Views are pointing to different Sources (one pointing to CVS and the other pointing to DC), current position cannot be tacked across the views. This will break “Scroll Jump” functionality.

After a bit of researching I found that, The CollectionViewSource contains a Collection View object. The Collection View defines a property called “Collection Groups” which is a collection of grouping contexts (In our case Manufacturer/Make). So we can bind the Zoom out view to the Collection groups (a list of manufacturers). And because of this both the Zoom In and Zoom Out views can be bound to the same collection view source (in different contexts), which means the current position can be tracked and therefore “Scroll Jump” can be supported.

Its amazing how easy it is to implement Semantic zoom. Hope this helps.

Thanks

Shiva.

Scenario 1:  Download image as Bytes and convert into RandomAccessStreamReference.

In order to share image data, we need object of type “RandomAccessStreamReference”.

• Download the image data using HttpClient class.

• Write this data into IRandomAccessStream. There are a few WinRT classes which implement the IRandomAccessStream interface. I will use InMemoryRandomAccessStream, as I do not need to store the data in a file, an in memory stream should suffice. In order to write to the InMemoryRandomAccessStream, we need to acquire it as a writable stream (IOutputStream) and then write to it using a DataWriter class.

• Create the RandomAccessStreamReference, to be used to set the bitmap data for the share data package

Scenario 2: Download image from a website as a stream and create a RandomAccessStreamReference from it  

• Download the image as Stream. This returns a non seekable stream (this means we cannot read the size or length of the stream, during read operations. 

• Convert the Non Seekable stream into an IRandomAccessStream. I have created an extension method to do this .

• Use the IRandomAccessStream and created the RandomAccessStreamReference to set the bitmap data.

Following is the implementation using the SetDataProvider method.

While I was extending my App, I realized that I also need to set the Text data. And my method which returns Text data is also an asynchronous method. I have already used the SetDataProvider method, to set the callback for getting bitmap data. So I was thinking how can I use the SetDataProvider method again to get the text data. Apparently we can use the SetDataProvider method multiple times for different format's. So I modified my code as follows.

1. http://blogs.msdn.com/b/going_metro/archive/2012/05/02/integrating-with-windows-8-share-charm-part-1-sharing-data.aspx
2. http://blogs.msdn.com/b/going_metro/archive/2012/05/03/integrating-with-windows-8-share-charm-part-1-receiving-data.aspx

In this post, I will discuss the concept of Long Running Shares, using a sample App called "Bing Images" .

The Bing Images app can be used to search for images. In the previous posts I wrote code to share the Uri of the image. I am going to implement functionality to be able to share the image along with the Url. 

Following is the code, I used to share the image .

When I run the app and try to share the image, Win RT displays the message "Images Can't Share" as shown below.

Why is this ?

This is because of the code we added to download the image for sharing. Note that we are using asynchronous methods and also using the "await" keyword to download the image.

When the execution reaches an awaited asynchronous call which is not yet complete, it returns at that point. In our case, the method "Data Requested" handler returns before setting the contents of the data package, hence the message.

However WinRT supports asynchronous sharing operations, by creating a Deferral (DataRequestDeferral) and waiting for it to complete. I modified my code, to obtain a deferral using the "DataRequest.GetDeferral" method and to call the "DataRequestDeferral.Complete"  method once data content for the asynchronous share is ready.

Now when we will be able to share the data with other apps.

Note : This method will only work if the asynchronous operation completes within 200 mill seconds.

In our case, some of the images were taking more than 200 mill seconds to download, and in those cases Sharing failed. WinRT provides another mechanism for handling such situations using a delegate (callback method).

We can define a call back delegate using the "SetDataProvider" method.

Once the target app is selected in the sharing pane, the target app calls the Callback method.

Within the callback method, I added the asynchronous download code.

Note: We still have to acquire a "Deferral"  within the Callback method, and call the Complete method once the data is set

It got me thinking, why is this. In both the methods we acquired a deferral, but in the first method the asynchronous call should complete with-in 200 milli-seconds, but in the case of call back scenario, we do not have this restriction (200 MS). The secret lies in the DataRequest objects "Deadline" property.

In both the scenario's I have set a break point and observed the DeadLine property.

In first scenario, the Deadline (In our ex: it is 4:35:10) and the time at which sharing is initiated (In our ex it is 4:35:10), is the same to the second. This explains the 200 milli seconds restriction.

In the second scenario (Callback), the requests Deadline is set to approximately 6 minutes from the time the call back is initiated. In our example, the callback was initiated at 4:39:10, but the deadline was set to 4:45 (6 minutes).

So even in the case of the Callback, there is a limitation (from my experimentation, it is around 6 minutes). I think this is a good enough time for any share operations that I could think of.

Hope this helps.

In the previous blog post Integrating with Windows 8 Share Charm - Sharing Data  I have discussed how to Share data from an App. In this blog post I will discuss on how to create the target app capable of receiving the shared data.

I already created a simple application which will act as the target application. In order to enable it to receive shared data, the following needs to be done.

1. Mark this app as a share target, by adding the share target declaration in Package.appxmanifest file .

     2.  Add the supported file types. We can specify specific file types or we can choose to support all the file types. Since our Images app is sharing only URI data, I am adding only the URI type to the supported types.

3. Add a new page to the app which will be activated, when this app is chosen in the share pane. I have added a Web View to this page to display the content of the received URL.

4. Override the applications “OnShareTargetActivated” method. The OnShareTargetActivated method is called when the application is chosen in the share pane.

Within the OnShareTargetActivated method, I am instantiating the sharing page, and calling the Activate method of the share page and passing it the “ShareTargetActivateEventArgs” object as the parameter.

5. In the Activate method, write code to retrieve the Uri from the “ShareTargetActivateEventArgs” object. For every Set method used to set the data, there is a Get method to retrieve the data. If you remember in our source app I used the SetUri method to set the uri content of the data packet. In order to retrieve the uri we use the GetUriAsync method as shown below.

Note: In this app I am just displaying the received data. This can be extended to work with the received data. For example, I can write code to save this image within the target app .

Our target app is now ready to receive Uri data. When the user shares (using the share charm), our sample target application is listed under the list available applications.

Visual studio provides a “Share Contract” template which performs steps 1 to 5 for us. We just need to update the code within Activate method that is generated and modify the generated share UI to our needs.

This will generate a default share page Xaml and code behind (with a default activate method). The default share UI contains elements to display Title, Image and Description. The default share UI also contains “Share” button which can be used to process the Shared data.

Also the Share target declaration is automatically added Package.appxmanifest. However we still have to add Uri data type to the list of supported types.

Let us replace the Xaml with the Xaml used in the previous example and add a Share button to it. Also I am replacing the logic in the “Activate” method, with the code used in previous example.

We are ready to run the Images app once again and share.

Until now we are just displaying the shared content, I am going to add some code to handle the process the shared data. Before we start the processing we have to indicate to WinRT that the share operation has started by calling the ShareOperation's Report Started method, and once done we have to indicate to WinRT the operation is completed by calling the Report Completed method .

Note :

The  share UI is automatically dismissed when the share operation is reported as completed or an error is reported .

In case there is an exception, I am calling the ReportError method, which immediately closes the share pane and throws an error popup as shown below .

When this popup is clicked, another page opens which displays the actual error message.

In the next blog post I will implement Quick links and deferrals

                                                                                                           Windows 8 Share Charm – Sharing Data

This blog post describes the process of implementing sharing in Windows 8. Windows 8 share charms lets the users share content from within the app with other people or apps, and receive shared content. Below is a snapshot of the Images App that I will be using to demonstrate. The app uses “Bing Image Search” API to search for images based on the keyword provided by the user.

There are 2 parts to sharing content. One is to be able to share content with other apps and the other is the ability to receive content from other applications. I will implement the sharing logic with in the Bing Images app, and will create another target app to demonstrate how to receive the shared content. In this blog post I will only discuss the, Sharing part of the application.

When the user selects an image, it is displayed in its full view as shown below.

Within this view, I want to enable the user, to share this image with other apps.

There is a static class called DataTransferManager that allows apps to initiate sharing operations. Within the constructor of the full view page, get the reference to the DataTransferManager using the static method GetForCurrentView and register for the DataRequested event.

Pitfalls:

1. The method DataTransferManager.GetForCurrentView returns the reference to the DTM of the Window, not the page that is currently loaded within the Window. This will result in a situation, where sharing can be initiated from within any page. For instance once the user opens the image in FullImageView (for the first time) and then goes back to Main page, he will still be able to initiate sharing (from the Main page) even though our intention was to allow sharing  only in the FullImageView.
2. The second pitfall is that every time the user navigated to the FullImageView the constructor gets called and within the constructor we are registering to the DataRequested event. Everything is good when the user navigates to the FullImageView, but every subsequent navigation to the FullImageView will result in an exception, as shown below.

Solution:

One way to solve these problems is to unregister the DataRequested event, when we navigate away from the FullImageView by overriding the FullImageView’s OnNavigatedFrom method as shown below.

The DataRequested event that we have registered to is called whenever the Share contract is selected. Within the event handler we need to write logic to share the data. The DataRequestedEventArgs object passed to the event handler has the property called Request. The request property contains a Data property of type DataPackage that can be used to share data with other Apps. The DataPackage can contain various types Data including Text, URI, Bitmap, HtmlText etc. These can be set using the DataPackage classes “Set” methods.

For this example, we will set only the Uri content. In the DataRequested event handler, set the Uri content using the SetUri method.

Now we are ready to share data, by clicking the share charm, when in the FullPageView.

Windows RT returned the mail app only. This is because among the applications currently on the system, Mail is the only app which supports Uri data. If we supported other types of data like Text, Bitmap, HtmlContent then there might be more applications in the list. In short it is a good practice to share as many types of data as possible. When Mail app is selected, the Mail app will be activated. The logic for using the data that we have shared is implemented within the target app, in our case the mail app.

In the next blog post I will discuss the logic for receiving the shared data.