One of the developers on our team recently created a sample Windows Media Center Presentation Layer web application that demonstrates how to utilize a Host object to access data that is created dynamically on a server without requiring the page to reload.  This technique can be particularly useful when you want to update some content on a page that contains numerous assets that you do not want to re-download and/or if you want to avoid visible flashing and transitions for page reloads.

There are two components to this sample - the sample UI and the sample data generation file.

Sample UI component

A live version of the sample UI can be found at http://play.mediacentersandbox.com/Sample.DataTransfer.mcml.  It contains 2 UI elements: a DataTransfer UI, and the main UI.

DataTransfer UI

The DataTransfer UI is an abstraction layer that encapsulates the functionality of loading new data into an already visible MCML page. 

Consumers that want to use this DataTransfer object need to provide the following properties:

• A ResultSet (which is an ArrayListDataSet object) to store the results of the server-side data generation
• A RequestStatus (which is an EditableText object) to store the current status of the data transfer
• A TargetSource (which is a string) to specify the URL where the data should come from
• A RefreshCommand (which is a Command object) that will invoke a data refresh

Main UI

The main UI contains an example of a common usage scenario using the DataTransfer UI. It contains the following elements:

• An instance of the DataTransfer UI
• A button that triggers the DataTransfer object to refresh its data when invoked (this could be easily modified to automatically refresh the data by using a timer instead of a button that the user has to click)
• A Text field to display the status of the data transfer - it is bound to the RequestStatus that is returned by the DataTransfer object
• A Repeater to display the updated data - it is bound to the ResultSet that is returned by the DataTransfer object

Sample data generation file

A live version of the sample data generation file can be found at http://play.mediacentersandbox.com/RandomData.aspx.  The source code for it looks like this:

<%@ Page Language="C#" %>
<% Response.ContentType = "text/xml"; %><%Response.Expires=0; %>
<% Random r = new Random(); %>
<Mcml
    xmlns="http://schemas.microsoft.com/2006/mcml"
    xmlns:cor="assembly://MSCorLib/System"
    xmlns:me="Me"
>

  <UI Name="Result">
    <Properties>
      <ArrayListDataSet Name="ResultSet">
        <Source>
          <cor:String String="Random.Next = <%=r.Next()%>" />
          <cor:String String="Random.Next = <%=r.Next()%>" />
          <cor:String String="Random.Next = <%=r.Next()%>" />
          <cor:String String="Random.Next = <%=r.Next()%>" />
          <cor:String String="Random.Next = <%=r.Next()%>" />
          <cor:String String="Random.Next = <%=r.Next()%>" />
        </Source>
      </ArrayListDataSet>
    </Properties>
  </UI>

</Mcml>

You can try out this example on your Windows Vista Home Premium or Ultimate Edition RC1 or later system by downloading this RegisterMceApp XML file and running RegisterMceApp.exe <path to codeless_datatransfer_example.xml>

When you register this XML file, you will have an entry named Data Transfer Sample in the Program Library.  When you launch the sample in Windows Media Center and click the Load New Data button, the ResultSet object will be populated with 6 new random numbers, and since the ResultSet is bound to the repeater on the client UI, the data in the repeater will automatically update each time you click the button without requiring the entire page to refresh.  The UI will look like the following:

A couple of additional notes

1. Keep in mind that due to the security restrictions in place for Windows Media Center Presentation Layer Web Applications, the UI page and the data generation page must both be hosted on the same web domain for this scenario to work as expected.  For this sample, both are hosted on the play.mediacentersandbox.com domain
2. This scenario demonstrates a relatively simple dynamic data scenario.  For a more involved example of how to dynamically switch hosts, see the sample in McmlSampler named AdvancedMarkup.HostViewItem.mcml

Aaron

By default, when a user clicks on an entry point in the Windows Media Center UI to launch a Windows Media Center application, a new instance of the Windows Media Center hosting process (ehExtHost.exe) is created and a new instance of the application is started within that hosting process.

In addition, Windows Media Center maintains a back stack of up to 8 applications so that the user can press the back button on the remote control and return to the previous experience.  If a user clicks on an application entry point more than once, each instance of the application is also added to the Windows Media Center back stack up to the limit of 8 instances.

Because of this back stack behavior, it is possible to have up to 8 instances of the same Windows Media Center application running in separate ehExtHost processes on the user’s system.  Having multiple instances of the same Windows Media Center application running on the system simultaneously can cause the following problems: 

• Performance – large applications can quickly consume a lot of system resources and slow down the overall system performance.  This is particularly problematic for hosted XBAP applications because XBAPs are hosted by another executable named PresentationHost.exe in addition to ehExtHost.exe.
• Shared resources – if a Media Center application reads from and writes to shared data sources on the file system or in the registry, having multiple instances running at the same time can cause resource contention problems, race conditions and other problems in the application code. 

It is possible to code a Windows Media Center application to prevent multiple instances from being launched and running at the same time on the user’s system.  Jossef Goldberg, a program manager on the Windows Presentation Foundation (WPF) team, has posted a sample application to demonstrate how to accomplish this.  His example, which can be downloaded from this location, provides sample code for an XBAP application, but the concepts can be applied equally to Media Center Markup Language (MCML) applications or Windows Media Center Presentation Layer background applications.

This sample application includes 2 pieces:

1. A stub application entry point that is used to ensure single instancing
2. The “real” application entry point that contains the code and UI that the user sees within Windows Media Center

Both entry points are registered with Windows Media Center using the RegisterApplication API or the RegisterMceApp utility.  However, only the stub entry point will appear within the Windows Media Center UI and allow the user to click on it to invoke it.  The real entry point is registered with a hidden category so that the user cannot invoke it directly, which allows the stub entry point to manage invokation of the real entry point.

A mutex is created at the beginning of the Launch method in the stub entry point that is called by Windows Media Center when the user clicks on an entry point in the UI.  If the mutex is acquired successfully, the stub entry point code calls the LaunchEntryPoint API to create a new instance of the real entry point.  If the mutex is already held and cannot be created, the stub entry point code calls the ReturnToApplication API to navigate to the instance of the real entry point that is already running in the Windows Media Center back stack.

The following is an example implementation of the Launch method for a Windows Media Center stub entry point that can be used to ensure that at most a single instance of an application will be running at any given time.  You will need to replace <application_guid> and <entrypoint_guid> with the actual GUID values for your real entry point.

public void Launch(AddInHost host)
{
    // Create a named Mutex to check if an instance of this application is already running
    bool bMyMutexWasCreated;
    Mutex myMutex = new Mutex(true, "MyMediaCenterMutex", out bMyMutexWasCreated);

    if (!bMyMutexWasCreated) 
    {
      // If we get here, the application is already running; bring it to the foreground
      host.ApplicationContext.ReturnToApplication();
    }
    else
    {
      // If we get here, the application is not running; launch it now
      host.MediaCenterEnvironment.LaunchEntryPoint(new Guid("{<application_guid>}"), new Guid("{<entrypoint_guid>}"), null);     
    }
}

You can also try out a runnable XBAP sample application that implements the above algorithm by downloading the ZIP file at this location and following the instructions in LaunchSingleInstance_ReadMe.doc inside of the ZIP file.

Aaron

Update: I added a few stations and changed the registration to use the /allusers switch (so this will show up on Media Center Extender) so pay attention to the setup instructions below.

Coding Friday resulted in a little Windows Media Center Presentation Layer Web Application called Veronicas Radio, named after a Program Manager on the Windows Media Center team who came to me one day and said 'hey, it would be cool if I could have all of my favorite streaming radio stations in a customized UI, just for me'. At least I remember the conversation going something like that. Anywho...

I took the helix we did for the Q app (see http://play.mediacentersandbox.com/mcml/rc1/helix.mcml for the codeless version) and added a call to PlayMedia to create a streaming radio URI. After applying a Gaussian blur to one of the sample pictures which ship with Windows to represent a background (nice pink) and station images (culled / created from their respective websites) we now have something that looks like this in Windows Media Center...

You can install this web app to your Diamond RC1 machine as follows:

1. Download http://play.mediacentersandbox.com/mcml/rc1/setup.veronicasradio.zip
2. Unzip the contents to your local machine.
3. Open a command prompt with Administrator priviledges.
4. Run setup.veronicasradio.cmd.
5. Launch Windows Media Center and Select ‘Veronicas Radio’ in Program Library.

We think it would be pretty cool to see what other mods or hacks folks could do with the helix. Hit this URL with IE > View Source: http://play.mediacentersandbox.com/mcml/rc1/veronicasradio.mcml, modify to your liking, post to your own web server, post an installer (everything you need is in the install download for Veronicas Radio) and let's see what neat mashups you can create.

Charlie

I have been working on some Windows Media Center application debugging and deployment scenarios recently so that we can enhance some of the documentation in the Windows Media Center SDK for Windows Vista.  I want to document one of the interesting configurations here in case it is useful in your Windows Media Center application development scenarios.

Before I get started, I want to note that the steps listed below work equally well if you are developing in Visual C# 2005 Express Edition or Visual Studio 2005 Standard or higher.  For simplicity's sake, I will refer to both by the single name "Visual Studio" in the instructions below.

Step 1: Getting started

I started by installing Windows Vista RC1 (Ultimate Edition), Visual C# 2005 Express Edition and the Windows Media Center SDK for Windows Vista RC1.  Then, I created a Visual C# Windows Media Center Presentation Layer (WMCPL) application in Visual C# Express.

By default, the WMCPL application is configured to launch the standalone version of McmlPad and navigate to the file default.mcml that is a part of the project.  The steps below allow you to configure the WMCPL project so that it will register the application with Windows Media Center and automatically launch the Windows Media Center shell and navigate to the application when pressing F5 to build and debug in Visual Studio.  The steps require you to make some modifications directly to the .csproj file, and then make some modifications to the project settings in the Visual Studio IDE.

Step 2: Modify settings in the .csproj file

Open the .csproj file for your WMCPL application project (located at c:\Users\<username>\Documents\Visual Studio 2005\Projects\<solution name>\<project name> by default) in a text editor such as notepad and make the following changes:

1. Override the pre-build target so that Visual Studio will ignore pre-build event errors using the technique described in this blog post.  You can do this by adding the following section to the bottom of the  .csproj file just before the closing </Project> tag:
   
     <Target Name="PreBuildEvent" Condition="'$(PreBuildEvent)'!=''" DependsOnTargets="$(PreBuildEventDependsOn)">
       <Exec WorkingDirectory="$(OutDir)" Command="$(PreBuildEvent)" IgnoreExitCode="true" />
     </Target>
   
2. Change the <StartProgram> to be $(windir)\eHome\ehshell.exe (replacing the default value of $(windir)\eHome\McmlPad.exe)
3. Change the <StartArguments> to be /entrypoint:{<app_guid>}\{<entrypoint_guid>} /addinfallbackpath:"$(FullyQualifiedOutputPath)" (where <app_guid> and <entrypoint_guid> are the GUIDs listed in the App.xml file that is generated when you create a new Windows Media Center Presentation Layer Application)
4. Save the changes and close the .csproj file

Step 3: Update project settings in the Visual Studio IDE

After modifying and saving the WMCPL application .csproj file using the steps listed above, open it in Visual Studio and perform the following steps:

1. Right-click on the project in Solution Explorer and choose Properties
2. Click on the Build Events tab in the Property Pages
3. Add the following text to the Pre-build event command line text box: %windir%\eHome\RegisterMceApp.exe /u App.xml
4. Add the following text to the end of the Post-build event command line text box (make sure to leave the command line there that appears by default to run mcmlverifier.exe to validate the MCML syntax in your project): %windir%\eHome\RegisterMceApp.exe App.xml
5. Click on the File menu and choose Save All to save the updated project settings

Once you have completed all of the above steps, you can press F5 in the Visual Studio IDE to build and run the WMCPL application, and it will launch Windows Media Center and navigate directly to the application by using the /entrypoint command line switch that is available for ehShell.exe.

I have found these steps useful when I want to rapidly preview a WMCPL application hosted within Windows Media Center because I do not need to manually register the application and add the application assembly to the global assembly cache (GAC) each time I rebuild it.  Note that you will want to eventually add a strong-name key to your assembly, create an installer for your application (using a technique such as this) and install the assembly to the GAC for real-world deployment scenarios.

Unfortunately, you cannot use Visual Studio to debug the application code if you directly launch it in Windows Media Center using the above steps.  Visual Studio attaches to the process that it launches (which in this case is the Windows Media Center shell application - ehShell.exe).  Each application hosted in Windows Media Center is then launched in a new instance of the Windows Media Center hosting application - ehExtHost.exe.  That ehExtHost process is the one that you need to attach to in order to debug the application code.  You can, however, use steps like the ones documented in this previous blog post to attach and debug application code within ehExtHost.exe.

Hopefully you will find this technique useful in some of your Windows Media Center application development scenarios.

Aaron

Hi, I'm Peter Dampier a Program Manager in the eHome division at Microsoft. Many thanks to Aaron and Charlie for this blog and the opportunity to post here.  One of the new features in Windows Vista Media Center post Beta 2 is extensibility for adding HD DVD and/or Blu-ray Disc movie playback to Windows Media Center in Vista.   I thought I'd spend a few moments here to explain this functionality...

There are two main features: 

1. The ability to launch a third party playback application when a HD DVD or BD disc is inserted into the drive and MCE is full screen.  If MCE is not full screen then the regular 2’ Windows auto play is used.
2. The ability to launch a third party application if a HD DVD or BD disc is in the optical drive and “Play DVD’ is selected from the MCE start menu

 To register your HD DVD or BD playback app there are two new categories for application registration:

 AutoPlay\HD DVD

 And

 AutoPlay\Blu-ray

Two examples are below.  These will register Notepad.exe to launch when MCE is full screen and a HD DVD is inserted and for Calc.exe to launch when a Blu-ray Disc is inserted.  These could also be regular native MCE applications (e.g. HTML/ActveX, MCML or XBAP).  For external .exe's the application developer will need to ensure that they restore MCE to its previous postion after the .exe closes.  A demonstration of how this can be done is available with the MCE games that ship in Vista (check out MCE's Program Library Game content).  Without this the user will be left in a state where they need to reach for the mouse or keyboard after finishing HD DVD playback in the external application versus automatically being returned to MCE. 

To use these samples save the XML below to c:\notepad.xml and c:\calc.xml.  Then register the apps with:

C:\Windows\ehome\RegisterMCEApp.exe /allusers c:\notepad.xml

C:\Windows\ehome\RegisterMCEApp.exe /allusers c:\calc.xml

To un-register:

C:\Windows\ehome\RegisterMCEApp.exe /u /allusers c:\notepad.xml

C:\Windows\ehome\RegisterMCEApp.exe /u /allusers c:\calc.xml

For the applications to show up in the regular MCE Program library they will also need to be registered against other categories with a separate registration.

XML for HD DVD – Launch notepad.exe:

 <application title="Notepad" id="{ABCE8379-F381-47b8-AE3D-EF6ADE750500}" companyname="Sample Company" companylogourl="http://company/icon2.jpg" description="HD DVD App">

    <entrypoint id="{ABCE8379-F381-47b8-AE3D-EF6ADE750501}" RUN="c:\windows\notepad.exe" title="Notepad (Sample HDDVD App)" description="Notepad - a text editor">

        <category category="AutoPlay\HD DVD"/>

    </entrypoint>

</application>

XML for Blu-ray Disc – Launch calc.exe

<application title="Notepad" id="{2C5ECB67-E585-4301-BAF4-5380FE6C26AB}" companyname="Sample Company" companylogourl=" http://company/icon2.jpg" description="BD App">

    <entrypoint id="{2C5ECB67-E585-4301-BAF4-5380FE6C26AB}" RUN="c:\windows\System32\Calc.exe" title="Calculator (Sample Blu-Ray App)" description="Calculator application ">

        <category category="AutoPlay\Blu-ray"/>

    </entrypoint>

</application>

If more than one application is registered against each category then the user is presented with a page to select the playback app they wish to use.

If no applications are registered the following dialogs appear:

Peter.

I have been working on some debugging topics that will hopefully eventually be included in the Windows Media Center SDK for Windows Vista, and I wanted to put some of these topics together and create an end-to-end scenario demonstrating how you can use Visual Studio 2005 to debug your Windows Media Center application code as it is running within Windows Media Center.

Please note that these instructions require Visual Studio 2005 Professional Edition or higher because the lower editions of Visual Studio 2005 (such as the Express Editions) do not include a debugger that allows you to attach to running processes.

As I wrote this blog post, I tried out these steps with the Q podcast and video blog client sample application that is included in the Windows Media Center SDK.  However, the same set of steps can be used for any Windows Media Center application that includes an add-in assembly.

Step 1 - Build and install the Windows Media Center application

The first step to start debugging your application is to compile your code in Visual Studio 2005, install the resultant assembly to the GAC, and use RegisterMceApp.exe or RegisterApplication to register the application so that it can be launched from within Windows Media Center.

Step 2 - Enable Windows Media Center add-in launch debugging

Set the following registry value on your system to cause a Windows Media Center dialog to appear when attempting to launch any add-in. The dialog will display the process name and process ID that you can use to attach a debugger, set breakpoints, and step through the code in your add-in that is executed when Windows Media Center attempts to load and run it.

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Media Center\Settings\Extensibility]
EnableAddInLaunchDebugging = 1 (REG_DWORD)

Step 3 - Launch Windows Media Center and click on the entry point to start your add-in

After setting the EnableAddInLaunchDebugging registry value, launch Windows Media Center and click on the entry point for your application.  When doing this, a dialog box like the following will appear and you can use it to attach a debugger:

Step 4 - Attach to the ehexthost process in Visual Studio 2005

After launching your application in Windows Media Cener, leave the Debug Application dialog open and launch Visual Studio 2005 Professional or higher.  Click on the Tools menu and choose Attach to Process...  A dialog like the following will appear:

This dialog lists all running processes on your system.  Locate the process name and process ID that is listed in the Debug Application dialog in Windows Media Center, click on it to highlight it and then click the Attach button to cause the Visual Studio debugger to attach to the process.

Note that if Visual Studio 2005 was already running when you clicked on your Windows Media Center application, you may need to click the Refresh button in the Attach to Process dialog before the process you are looking for appears in the list.

Step 5 - Configure symbol settings for the add-in assembly in Visual Studio 2005

Now that you have attached to the process, you need to configure symbol settings so that you can set breakpoints and debug your add-in assembly code.  Open the Modules window in Visual Studio by pressing Ctrl + Alt + U or by going to the Debug menu, choosing Windows and then choosing Modules.

When the Modules window appears, locate the DLL that represents your add-in assembly, right-click on it and choose Symbol Settings...  A dialog like the following will appear:

Use the new folder icon to add a symbol file (.pdb) location.  Provide the full path to the \bin\<flavor> directory for the built binary for your add-in assembly.  Make sure to choose the correct <flavor> (either debug or release) depending on which flavor of the add-in assembly is currently running in Windows Media Center.  After adding the symbol file location, make sure that the check box next to the symbol path is checked and then click OK to dismiss the symbol settings Options dialog.

You can verify that you chose the correct symbol location by looking in the Module window and verifying that the Symbol Status for your add-in assembly now says Symbols Loaded.

Step 6 - Configure Visual Studio option to allow setting breakpoints in managed code

Go to the Tools menu in Visual Studio 2005 and choose Options...  Expand the Debugging item in the options tree and select General.  Verify that the option named Enable Just My Code (Managed only) is checked.  Click OK to dismiss the options dialog.

Step 7 - Set breakpoints and start debugging

Now you are ready to set some breakpoints in your source code and start debugging.  Open up your source code files in the Visual Studio IDE and click on the line numbers you are interested in debugging to set breakpoints.  After you have set all of the breakpoints you want, click OK on the Debug Application dialog in Windows Media Center to resume execution of your application.  You should see breakpoints hit if you set them in the correct places, and you can use the Visual Studio debugger to step through your code.

Step 8 - Repeat as necessary

If you need to start a new debugging session, you can start again at step 3 of the above instructions.  The process ID in the Debug Application dialog will change each time you launch your application, so you will need to make sure to attach to the new instance of ehexthost.exe in Visual Studio 2005.

Hopefully these steps will be useful to you as you develop your Windows Media Center applications in Windows Vista.

Aaron

Jossef Goldberg (a program manager on the Windows Presentation Foundation team who focuses on integrating WPF with Windows Media Center) sent me a list of newsgroups and forums that he has found useful for customers who have questions related to developing XBAPs for Windows Media Center for Windows Vista:

• Windows Presentation Foundation (WPF) developer portal
• Windows Presentation Foundation (WPF) MSDN Forum
• Sample XBAP controls for Windows Media Center
• XBAP forum on the Media Center Sandbox site

Hopefully these resources will be helpful if you are working on XBAP solutions for Windows Media Center for Windows Vista.

Aaron

As many of you have probably noticed, it can be tricky to debug problems that occur while loading and running an add-in assembly hosted within Windows Media Center.  Fortunately, there are 2 fixes in post-beta 2 builds of Windows Vista that make Windows Media Center add-in debugging a little easier.

Enabling the Details button for the add-in crash dialog

The first debugging fix we have added is a registry value that will add a Details button to the error dialog that appears when a Windows Media Center add-in crashes.  The registry value is located at:

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Media Center\Settings\Extensibility]
EnableErrorDetails = 1 (REG_DWORD)

The Windows Media Center SDK for Windows Vista sets this value automatically starting with the 5456.5 build that is available on the Microsoft Connect site for Windows Vista beta program members, and you can also set it manually on a Windows Vista OS that contains Windows Media Center to gain the same functionality.

When you have this registry value set, you will see a dialog that looks like the following when an add-in crashes:

The Details button only appears if the registry value is set.  The rest of the dialog will look the same regardless of whether or not you have the registry value set.

When you click on the Details button, Windows Media Center will display the callstack that caused the crash.  It will look something like this:

Unfortunately, because of the way that Windows Media Center add-ins are hosted in an external process (ehexthost.exe) and how some of the exceptions thrown by Windows Media Center are wrapped and bubbled back up, the callstack may not always be particularly useful.  However, there are many cases where this has already proven useful to our development team while trying to track down add-in crashes.

Enabling a dialog to allow you to attach a debugger

The second debugging fix we have added is a registry value that will cause a Windows Media Center dialog to appear when attempting to launch any add-in.  The dialog will display the process name and process ID that you can use to attach a debugger, set breakpoints, and step through the code that is called in your add-in when Windows Media Center attempts to load and run it.  The registry value is located at:

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Media Center\Settings\Extensibility]
EnableAddInLaunchDebugging = 1 (REG_DWORD)

When you have this registry value set, you will see a dialog that looks like the following when attempting to launch any add-in within Windows Media Center:

While this dialog is on-screen, you can attach your debugger of choice to the specified process name/ID and then press OK to resume the Windows Media Center add-in launch process.

Unlike the previous registry value, the Windows Media Center SDK does not automatically set this value because it noticeably interferes with the ordinary usage of Windows Media Center in non-development scenarios.  You will have to set this registry value yourself to gain this functionality.

Hopefully these new registry tweaks will be useful to you as you develop and debug your Windows Media Center add-ins.

Aaron