We've also updated the docs to help you develop for 256-MB devices. You will find a new icon     in relevant places to call  to call out considerations for developing for 256-MB devices. If you want to dig into the docs, a good place to start is the overview topic, Developing for 256-MB Devices. If you are developing with the XNA Framework, you can check out a new topic on reducing memory use in XNA games.

Making sure your applications run well on 256-MB devices will provide you with the greatest market reach for your apps, so check out the tools and docs today!

Along the lines of easy to consume are the control design guideline topics. There are design guideline topics for most controls that ship with the Windows Phone SDK. These topics typically contain an image of the control and describe the standard appearance of a control and its standard use. The best part of these topics, in my opinion, is the Design Guidelines section that lists the important points you need to remember when using the control in your UI. The following images show parts of the topic for the Button control.

So please, check out these topics and let us know what you think. Post a comment to this post or just use the feedback mechanism on the MSDN page.

--Cheryl

• Background Agent
• Background Transfer Service
• Quick Card
• Search Extensibility

We also added the following new sample that shows how to use types in the NetworkInformation namespace to get the network status of the device, mobile network and other information.

• Network and Device Information 

To get the latest samples go to the Code Samples page on MSDN. 

In addition, we made fixes to several docs, some based on your feedback on UserVoice. For example, we added links to the camera sample from the camera docs. Please keep your feedback coming and we'll keep updating and making changes!

To work around this issue, you can reset the volume when the playback rate is changed. The following code demonstrates one way to reset the volume.

void ME_RateChanged(object sender, RateChangedRoutedEventArgs e)

{

    // For playback rates that support audio playback, Enforce audio playback by resetting the MediaElement Volume property

    //to unmute audio after multiple playbackRate changes.

     if (e.NewRate <= 2  && e.NewRate >= 0.5)

     {

           ME.Volume = ME.Volume;

     }

}

-Nitya.

You can set a StringFormat value on the binding to format your string in many common formats such as currency, date, time, etc . For example, if you want the string to be formatted like currency, your binding would look like this:

      Text="{Binding StringFormat=C}"

The docs for StringFormat could use some work (don't worry--I've filed a bug and they should get fixed for the next update), but meanwhile look at the following topics for more information about what your format strings should look like:

             Standard Format Strings

             Date Format Strings

You can also set the FallbackValue property that is used when the binding can't return a value. In other words, this value will display in the UI when the binding doesn't resolve.

     Text="{Binding Name, FallbackValue=No Value}"

And finally set the TargetNullValue to display a value when the underlying source value is null or nothing.

     Text="{Binding Name, TargetNullValue=n/a}"

All of these properties will show in Intellisense and speed development for you.

Enjoy!

--Cheryl

Silverlight 5 offers many new features including:

• PivotViewer control
• Trusted applications in-browser
• 3D graphics
• Vector printing
• Improved text rendering including the RichTextBlock control.
• Hardware decode of H.264 media

For a detailed list of the new features see the Silverlight content on MSDN, specifically, the What's New for Silverlight 5 topic.

If you prefer your docs offline, here's the link to download the .chm containing Silverlight 5 docs.

Enjoy!

Cheryl

In Silverlight for Windows Phone you must always set the TargetName property to a value for the control to successfully navigate to the URL specified by NavigateUri when the hyperlink control is clicked. It doesn’t really matter what you set TargetName to, it just must be set. If you set TargetName and click the hyperlink control, the web browser will display with the correct page.

Here’s an example:

<HyperlinkButton Content="HyperlinkButton" Height="30" Name="hyperlinkButton1" Width="200"
         NavigateUri="https://www.microsoft.com" TargetName="_anything" />

This is different than the behavior for Silverlight for the desktop. On the desktop, you don’t need to explicitly set TargetName. If you do set it, the behavior is similar to the standard HTML TARGET attribute.

HTH

--Cheryl

You can get the Windows Phone 7.1 SDK from the download center. In addition, the docs and samples have been updated and finalized for this release as well. You can check out all the docs here. If you are just getting started building apps for Mango, you might what to check out the What's New in the Windows Phone SDK.

As we look forward to future releases, we would really love your feedback about the documentation and samples. Visit the Windows Phone Documentation UserVoice site to give us your feedback and vote on issues.

Thanks and enjoy!

Cheryl

The technology itself is pretty well-known and it’s been in .NET since version 1.0. Here is one of the tutorials for .NET that explains what pInvoke is about. So instead of explaining what pInvoke is, let me concentrate on how this feature works in Silverlight 5 and what differences with .NET you might expect.

First of all, calling native APIs is available only in full-trust applications. This is a security restriction; there is simply too much power in Windows APIs for a partial-trust Web application to have. The good news is that Silverlight 5 allows your application to be full trust and consequently use pInvoke in both in and out of the browser. One more restriction is that pInvoke is available only on Windows, there is no Mac support.

To get the things going, let me first re-introduce an example that Nick Kramer first presented at MIX. It shows how you can detect a removable drive (think about USB sticks or card readers). You click a button, and the program tells you whether you have a removable drive and if yes, what letter it’s assigned.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Runtime.InteropServices;

namespace SamplePInvoke
{
    public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();
        }

        // Import native method.
        [DllImport("kernel32.dll")]
        static extern int GetDriveType(string lpRootPathName);

        private void detectDrive_Click(object sender, 
                                       RoutedEventArgs e)
        {
            String[] drives = new string[] 
                { @"c:\", @"d:\", @"e:\", 
                  @"f:\", @"g:\", @"h:\", @"i:\" };
            bool driveInserted = false;
            string driveLetter = "";
            foreach (String drive in drives)
            {
                // Calling the native method. 
                // “2” means that the drive is a removable drive.
                if (GetDriveType(drive) == 2)
                {
                    driveInserted = true;
                    driveLetter = drive;
                }
            }
            if (driveInserted)
                textBlock1.Text = "Removable drive is " + driveLetter;
            else
                textBlock1.Text = "No removable drive";
        }
    }
}

As I mentioned already and as you can see from the example above, in most cases the feature works exactly the same as in .NET. This code is basically identical in both Silverlight and WPF.

However, there are also some differences as well, so keep on reading.

Marshaling

For marshaling, many applications use the methods from the System.Runtime.InteropServices.Marshal class. But you might notice that .NET and Silverlight versions of this class have different number of methods. As usual, Silverlight provides you with only a subset of the full .NET, which we believe represents the most used part. In fact, this is the same set of methods Silverlight itself uses for native interop and it is usually sufficient.

Many of the methods from the Marshal class in the full .NET Framework are just managed wrappers around native APIs. Often, if you can’t find a certain method from the Marshal class in Silverlight, you can use the native API directly.

For example, the method Marshal.AllocHGlobal exists in .NET and doesn’t exist in Silverlight. However, this method is just a wrapper around the Win32 LocalAlloc function from Kernel32.dll. So you need to call this native function directly instead of its managed wrapper and refactor you code accordingly.

[DllImport("kernel32.dll", EntryPoint = "LocalAlloc")]
internal static extern IntPtr LocalAlloc_NoSafeHandle(
    int uFlags, IntPtr sizetdwBytes);

Usually, you can find what native method is being wrapped in the documentation of the managed method itself.

Reverse pInvoke Calls

In the first example in this article, the only call I make is from managed code to native code. However, sometimes you need to do the opposite: call a managed method from within the native code. It usually happens when a native method uses a callback or accepts a pointer to a function as one of its parameters and you want to use your managed method for this callback.

In the full .NET such reverse calls and direct calls are treated the same. In Silverlight, however, you need to explicitly specify the “entry points” for reverse pInvoke calls by using the AllowReversePInvokeCalls attribute. Basically, all you need to do is to apply this attribute to managed methods that need to be called from the native code.

Here is an example. Consider that you have the following C++ method:

typedef int (*NumberSource) (void); 

int MultiplyByTen(NumberSource numberSource)
{
      int returnValue = numberSource() * 10;
      return returnValue;
}

This sample method takes a pointer to a function returning integer as a parameter and multiplies the function’s return value by 10.

In managed code, I need to declare this method as follows:

[DllImport("testCPlusPlus.dll")]
static extern int MultiplyByTen(NumberSource src);

public delegate int NumberSource();

Note that instead of the function pointer I use a delegate. Again, this is identical to what you would do in the full .NET. Next, I create a managed method and pass it to the native method through a delegate binding.

public int ManagedSource()
{
    return 42;
}

public MainPage()
{
    InitializeComponent();
    int res = MultiplyByTen(new NumberSource(ManagedSource));
}

This code works fine in the full .NET, but in Silverlight the last line throws a security exception with the following message:

Delegate 'SilverlightApplication1.MainPage+NumberSource' must be bound to a method in a fully-trusted assembly and the method must have the AllowReversePinvokeCallsAttribute.

To fix this problem, all I need to do is apply the AllowReversePinvokeCalls attribute to the ManagedSource method.

[AllowReversePInvokeCalls]
public int ManagedSource()
{
    return 42;
}

This feature is just an additional security measure, so you can have better control over what managed methods can and cannot be called by native APIs.

Processing Window Messages

Anybody familiar with Win32 API probably knows that Windows sends different messages to each registered window through the WindowProc function. For example, it sends messages whenever a USB device is inserted or removed.

In WPF and even in Windows Form, you could take an existing window or subclass a Window class and override its WndProc method. However, in Silverlight the Window class doesn’t expose this method. One way to solve this problem is to define a hidden window by using native APIs. Here is another code example that detects the removal and insertion of a USB.

public partial class MainPage : UserControl
{

// Importing a set of necessary native methods from Win32 API.
[DllImport("User32", EntryPoint = "CreateWindowEx", 
    CharSet = CharSet.Auto,SetLastError = true)]
static extern IntPtr CreateWindowEx(int dwExStyle, 
    string lpszClassName, string lpszWindowName, int style, 
    int x, int y, int width, int height,
    IntPtr hWndParent, IntPtr hMenu, IntPtr hInst,
    [MarshalAs(UnmanagedType.AsAny)] object pvParam);

[DllImport("user32.dll")]
static extern IntPtr DefWindowProc(IntPtr hWnd, int uMsg, 
    IntPtr wParam, IntPtr lParam);

[DllImport("user32", CharSet = CharSet.Auto, SetLastError = true)]
public static extern short RegisterClass(WNDCLASS wc);

// Marshaling the Window structure.
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public class WNDCLASS
{
    public int style;
    public WndProc lpfnWndProc;
    public int cbClsExtra;
    public int cbWndExtra;
    public IntPtr hInstance;
    public IntPtr hIcon;
    public IntPtr hCursor;
    public IntPtr hbrBackground;
    public string lpszMenuName;
    public string lpszClassName;
}

//system detects USB insertion/removal
const int WM_DEVICECHANGE = 0x0219;
// system detects a new device
const int DBT_DEVICEARRIVAL = 0x8000;
// device removed
const int DBT_DEVICEREMOVECOMPLETE = 0x8004;

// Callbacks must have AllowReversePInvokeCalls attribute.
[AllowReversePInvokeCalls]
private IntPtr Callback(
    IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam)
{
    if (msg == WM_DEVICECHANGE)
    {
        if (wparam.ToInt32() == DBT_DEVICEARRIVAL) 
            textBlock1.Text = "USB inserted";
        if (wparam.ToInt32() == DBT_DEVICEREMOVECOMPLETE) 
            textBlock1.Text = "USB removed";
    }
    return DefWindowProc(hWnd, msg, wparam, lparam);
}

public delegate IntPtr WndProc(
    IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);

// Preventing garbage collection of the delegate
private static WndProc dontGCthis;

public MainPage()
{
    InitializeComponent();

    WNDCLASS wc = new WNDCLASS();

    // Preventing garbage collection of the delegate
    dontGCthis = new WndProc(Callback);
    wc.lpfnWndProc = dontGCthis;

    // Note that you need to ensure unique names 
    // for each registered class.
    // For example, if you open the same plugin 
    // in two different tabs of the browser,
    // you still should not end up with 
    // two registered classes with identical names.
    wc.lpszClassName = "foobar" + (new Random()).Next();

    RegisterClass(wc);

    IntPtr createResult = CreateWindowEx(0, wc.lpszClassName, 
        "Window title", 0, 100, 100, 500, 500, 
        IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, 0);
}
}

This example prints to a text block when a USB device is removed or inserted. Note that if you use the same code in WPF, it will work just fine. However, it’s important to remember that porting your existing pInvoke code from WPF to Silverlight might require some extra work (as usual).

More Examples

There were several good articles about pInvoke already written after Silverlight RC. I just wanted to share the list, since there never can be too many code examples, especially when you are dealing with such advanced topics as interop between managed and advanced code.

• Silverlight 5 RC Released - Using PInvoke by Jeremy Likness
  A very simple article that shows how to call MessageBeep. The article takes you through initial marshaling concepts and introduces some best practices for interop coding.
• Silverlight 5 PInvoke fun - System Font Dialog by Peter Kuhn aka Mister Goodcat.
  Another good article for beginners, but with a more advanced example showing how to load system fonts.
• Enumerating MIDI Interfaces using Silverlight 5 PInvoke by Pete Brown.
  I liked this one, since working with devices is one of the primary scenarios for pInvoke in Silverlight 5.

This enables experience protection of DRM’d content, which is particularly useful for media that contains revenue-generating ad content.

To enable ARM for an application you must sign your content using an Authenticode x.509 certificate. You can use signtool.exe, which you also use to create a Silverlight trusted application, although the Silverlight application consuming content does not have to be a trusted application.  For example, you could a command like the following:

signtool sign /v /f certificateFile.pfx fileToSign

You can also use the signing mechanism in Visual Studio to sign your application. The following image shows the Signing tab in Visual Studio, which you access from Project Properties:

To learn more about DRM content in general, see Digital Rights Management.

--Cheryl