前边介绍Push Notification时，其实已经谈到了Tile Notification。在Windows Phone 7.1中，Smart Tile得到了极大的提高。我们不但可以控制Tile的动画显示、内容和背景切换，而且还能够为同一个应用提供两个Tile，比如一个天气预报的应用程序，就可以在手机的首页上显示多个Tile，一个是北京的天气，另一个是上海的天气等。

实现Application Tile

MSDN上的文章写的又臭又长，其实挺简单的事情，弄得那么复杂。我试着改写了一下例子，加入到应用的一个Button点击事件里：

            // Application Tile is always the first Tile, even if it is not pinned to Start.
            ShellTile TileToFind = ShellTile.ActiveTiles.First();

            // Set the properties to update for the Application Tile.
            // Empty strings for the text values and URIs will result in the property being cleared.
            StandardTileData NewTileData = new StandardTileData
            {
                Title = "Title",
                BackgroundImage = new Uri("Background.png", UriKind.Relative),
                Count = 2,
                BackTitle = "Back Tilte",
                BackBackgroundImage = new Uri("Background2.png", UriKind.Relative),
                BackContent = "This is BackContent"
            };

            // Update the Application Tile
            TileToFind.Update(NewTileData);

首先，我们要引用Microsoft.Phone.Shell命名空间，然后通过ShellTile.ActiveTiles.First()方法来获取应用最主要的ShellTile.每个应用至少会有一个Tile，所以不用担心该对象为空。然后我们创建一个StandardTileData对象，为其中的属性赋值。属性分为两组，每组都会有背景图片、标题和内容，显示位置如下图所示。如果设置两组Tile属性，则Tile在显示一段时间后会自动切换。最后，我们调用ShellTile对象的Update方法，将StandardTileData对象传递进去，就完成了新Tile的设置。BackgroundImage和BackBackgroundImage指定的是图片的URI，可以是本地的图片，也可以是来自网络的图片。我们使用的两个图片，都是以Content方式加入到工程中的图片。

当我们将程序部署到设备或模拟器上时，首先会在Application List里出现对应的图标。我们长按图标，会出现一个菜单，选择Pin to start，会将应用程序的图标显示到手机首页上。

运行应用程序，点击Button后，Tile会被更新成新的式样。两张背景和内容会交替显示，显示效果如下图所示：

实现 Secondary Tile

在完成了Application Tile的显示之后，我们接下来要实现更复杂的Secondary Tile，当然，我们可以添加多个Tile。在实现Secondary Tile时，有两个技术点需要实现，一个是Tile的添加与显示；另一个则是，程序启动时如何区分是由哪个Tile点击启动应用的。

首先，我们来看如何添加Secondary Tile的代码：

            // Look to see whether the Tile already exists and if so, don't try to create it again.
            ShellTile TileToFind = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString().Contains("DefaultTitle=FromTile"));

            // Create the Tile if we didn't find that it already exists.
            if (TileToFind == null)
            {
                // Create the Tile object and set some initial properties for the Tile.
                // The Count value of 12 shows the number 12 on the front of the Tile. Valid values are 1-99.
                // A Count value of 0 indicates that the Count should not be displayed.
                StandardTileData NewTileData = new StandardTileData
                {
                    BackgroundImage = new Uri("Background.png", UriKind.Relative),
                    Title = "Secondary Tile",
                    Count = 12,
                    BackTitle = "Back of Tile",
                    BackContent = "Welcome to the back of the Tile",
                    BackBackgroundImage = new Uri("Background2.png", UriKind.Relative)
                };

                // Create the Tile and pin it to Start. This will cause a navigation to Start and a deactivation of our application.
                ShellTile.Create(new Uri("/MainPage.xaml?DefaultTitle=FromTile", UriKind.Relative), NewTileData);
            }
            else
            {
                TileToFind.Delete();
            }

首先调用ShellTile.ActiveTiles.FirstOrDefault方法，获取在NavigationUri属性中包含“DefaultTitle=FromTile”字样的ShellTile对象，如果获取到的ShellTile对象为空，则创建Secondary Tile，否则调用ShellTile的Delete方法，删除这个Tile。

创建Secondary Tile的过程，首先创建StandardTileData对象，将显示的各个参数进行赋值，这一步与Application Tile相同；然后，调用ShellTile的Create方法，第一个参数是URI，即点击该Tile后，调用Page的命令行，可以包含参数，第二个参数是StandardTileData对象，用于指定显示式样。

需要注意的是，如果Page命令行指定不对，会引起用户点击Tile时，应用直接退出，由于无法调试，第一次接触这个问题时，会找不到具体的原因。

Secondary Tile显示效果如下：

接下来，我们就要处理区分不同Tile点击的事件了，需要重载MainForm的OnNavigatedTo方法：

        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            string value = null;

            if (this.NavigationContext.QueryString != null)
            {
                this.NavigationContext.QueryString.TryGetValue("DefaultTitle", out value);
                if (value != null)
                {
                    textBoxTitle.Text = value;
                }
                else
                {
                    textBoxTitle.Text = "FromMain";
                }
            }

            base.OnNavigatedTo(e);
        }

通过NavigationContext.QueryString的TryGetValue方法来获取DefaultTitle参数的值，如果无法获取到该值，则认为该点击来自第一个Tile，相反则来自第二个Tile。我们将参数显示在主页面的文本框里，当然，实际应用中可以有更加复杂的业务逻辑。界面显示效果如下：

到这里，我们简单介绍了如何添加Tile、修改Tile内容，除此之外，还有如何修改Tile的初始值，指定Tile更新的时间间隔等。在这里，我们就不介绍了，大家可以参考又臭又长的MSDN文档，这部分不长，我可以保证。

写在最后

好了，到这里，我们正式将Windows Phone 7.1中的Tile编程的内容介绍完了。Windows Phone采用的是HUB方式，对于功能进行分类，所以，就要求Tile具备更丰富的显示方式和展现形式。而且，多个应用可以对应于一个Tile，同样一个应用也可以对应多个Tile，这样极大提高了主页与应用之间交互的丰富程度。

当然，具体的Tile，还要在实际的开发中使用，才能真正了解其优缺点。

OpenXLive杯Windows Phone游戏开发大赛

OpenXLive杯Windows Phone游戏开发大赛，是由OpenXLive联合国内知名的开发者社区：DevDiv、智机网、WPMind、Silverlight银光中国和XNA游戏世界，一起举办的针对Windows Phone游戏开发的比赛。

https://www.openxlive.net/posts/news/40

Push Notification并不是Windows Phone 7.1的新功能，但是之前的文章里对这部分都缺少详细的分析，所以姑且就把Push Notification放到这部分里吧。

很多iOS开发者都将WP7里的Push Notification说成抄袭iOS的产物，孰不知，微软才是Push Notification技术的先行者，Windows Mobile时代的Push Mail技术可以说是独步天下，连Symbian也要授权使用相关的技术。

Push Notification的技术为什么越来越重要，其实这跟移动设备的特点紧密相关，移动设备网络的不稳定性，决定了以Socket为代表的强连接方式并不适用，所以大家更多选择HTTP协议作为主要的通讯方式。但是HTTP的特点是，设备找服务器很容易，通过URL就可以了，但服务器找设备就难上加难了，因为设备会随时切换移动网络，IP地址之类的经常性失效。当然设备端轮询的方式可以解决这个问题，但移动设备的电源、网络都是稀缺资源。所以，OS级别的Push Notification技术就变成了一种珍贵的战略资源，而且，在封闭式的操作系统中，只有OS厂商提供的Push Notification才能够获得最好的效率。

Push Notification简介

目前，Windows Phone支持三种Push Notification方式：Toast Notifications、Tile Notifications和Raw Notifications，我不想翻译成中文名字了，因为“吐司”之类的翻译无法帮助理解。

Toast Notifications，当我们的程序没有运行时，我们希望有一种形式可以通知用户，并且让用户调用对应的应用，就像收到SMS时，调用Messaging程序一样。运行效果如下图，当用户点击Toast时，可以调用对应的程序。

Tile Notifications，用于更新启动界面上的Tile，可以通过Tile Notifications设置Tile的背景图片、Count和Title等属性，各属性显示位置如下图所示。我们可以通过该技术来提示用户，我们的应用有新的事件发生，比如SNS上有多少新的回复等。

Raw Notifications，最简单，当你的应用程序运行时，可以接收Raw Notification信息，如果程序没有运行，则接受不到Raw Notification。

接下来，我们会以Toast Notifications为例详细介绍，Push Notification的原理和使用方法。

首先，还是引用这张广为流传的图示吧，确实是目前能够找到的最详细的示意图了。下面是步骤叙述：

1-3，应用通过调用HttpNotificationChannel接口，向Microsoft Push Notification Service (MPNS)请求一个URI，这个URI会在服务器端发送Notification消息时，作为验证发送目标的唯一标识；这样做的一个好处是，当同一个设备上有多个应用在监听Notification时，不会相互干扰。

4. 应用会将获得的URI传到自己的服务器上，这个URI会存储在自己的服务器上，用于发送Push Notification时调用。URI的传递和存储方式，由开发者自己决定，不过要保证传输过程的加密，以及存储时的安全性。接下来的实例里，传递和存储URI的方式就很有创意。

5-6. 当服务器端有信息要通知应用时，需要向MPNS发起一个Http请求，而MPNS将请求转发到相应的设备上，设备上的应用接到Push Notification的消息后，进行相应的处理。

其实过程挺简单，被MSDN文档说得神乎其神。接下来，我们挨个看一下各个类型的Notification。偷点懒，不自己写Sample Code了，请大家去下面的链接里下载。不过注意Sample Code的更新，最近有同学因为更新不及时，而影响了开发进度。

https://msdn.microsoft.com/en-us/library/ff431744(VS.92).aspx

初始化 Notifications

首先是Toast Notifications，这种Notification在实际应用中最为有效，不但可以提示用户有新的消息，而且还让用户选择是否打开当时的应用。不过比起iOS的Notifications来，Toast Notifications能够容纳的信息量实在有限。所以，开发者要适当“浓缩”需要推送的消息。

我们按照调用的顺序，依次来分析代码，首先来看客户端部分ToastNotificationClient的代码：

            /// Holds the push channel that is created or found.
            HttpNotificationChannel pushChannel;

            // The name of our push channel.
            string channelName = "ToastSampleChannel";

            InitializeComponent();

            // Try to find the push channel.
            pushChannel = HttpNotificationChannel.Find(channelName);

            // If the channel was not found, then create a new connection to the push service.
            if (pushChannel == null)
            {
                pushChannel = new HttpNotificationChannel(channelName);

                // Register for all the events before attempting to open the channel.
                pushChannel.ChannelUriUpdated += new EventHandler<NotificationChannelUriEventArgs>(PushChannel_ChannelUriUpdated);
                pushChannel.ErrorOccurred += new EventHandler<NotificationChannelErrorEventArgs>(PushChannel_ErrorOccurred);

                // Register for this notification only if you need to receive the notifications while your application is running.
                pushChannel.ShellToastNotificationReceived += new EventHandler<NotificationEventArgs>(PushChannel_ShellToastNotificationReceived);

                pushChannel.Open();

                // Bind this new channel for toast events.
                pushChannel.BindToShellToast();

            }
            else
            {
                // The channel was already open, so just register for all the events.
                pushChannel.ChannelUriUpdated += new EventHandler<NotificationChannelUriEventArgs>(PushChannel_ChannelUriUpdated);
                pushChannel.ErrorOccurred += new EventHandler<NotificationChannelErrorEventArgs>(PushChannel_ErrorOccurred);

                // Register for this notification only if you need to receive the notifications while your application is running.
                pushChannel.ShellToastNotificationReceived += new EventHandler<NotificationEventArgs>(PushChannel_ShellToastNotificationReceived);

                // Display the URI for testing purposes. Normally, the URI would be passed back to your web service at this point.
                System.Diagnostics.Debug.WriteLine(pushChannel.ChannelUri.ToString());
                MessageBox.Show(String.Format("Channel Uri is {0}",
                    pushChannel.ChannelUri.ToString()));

            }

代码比较多，我们逐步来看，首先要声明一个HttpNotificationChannel的变量，命名空间为Microsoft.Phone.Notification。接下来，声明该Notification Channel的名称，该名称是Channel的唯一标识名，不能与其他Channel重复。接下来，我们调用HttpNotificationChannel的静态方法Find来查找，当前的Channel是否存在，如果存在则返回HttpNotificationChannel对象实例，不存在则返回空。如果该程序从未在当前设备上运行过，则HttpNotificationChannel对象为空，只要运行过一次，则能够通过Find方法来获取对象实例。

先来说未创建Channel的情况，创建HttpNotificationChannel的对象，并将Channel名称作为参数传递进去。然后处理该对象的两个事件：ChannelUriUpdated和ErrorOccurred。当URI发生变化时，会触发ChannelUriUpdated事件，我们在创建Channel对象时，会触发该事件，另外一个ErrorOccurred事件，则用于错误处理。

当程序已经在运行时，默认是接收不到Toast Notification消息的，所以，我们还需要处理ShellToastNotificationReceived事件，当程序运行时，也可以接收到相应的消息。

然后调用HttpNotificationChannel的Open方法，打开该Channel，最后是BindToShellToast方法，通知Shell，该Notification的Channel已经被创建。

获取Channel后的代码与之大体类似，但我们可以通过HttpNotificationChannel的ChannelUri属性来获取Channel的URI，该URI值就是需要传递给我们自己服务器的唯一值，标记了该设备上的该Channel。

而创建Channel后，我们也可以获取URI的值，不过我们需要在ChannelUriUpdated事件处理函数里获取该URI值：

        void PushChannel_ChannelUriUpdated(object sender, NotificationChannelUriEventArgs e)
        {

            Dispatcher.BeginInvoke(() =>
            {
                // Display the new URI for testing purposes.   Normally, the URI would be passed back to your web service at this point.
                System.Diagnostics.Debug.WriteLine(e.ChannelUri.ToString());
                MessageBox.Show(String.Format("Channel Uri is {0}",
                    e.ChannelUri.ToString()));

            });
        }

到此为止，我们已经完成了Notification Channel的创建，并且获得了唯一标识的URI。

触发Notification

接下来，我们来看Server的代码。我们自己的Server与Microsoft Push Notification Server（MPNS）之间是通过Http协议，使用HttpWebRequest来发送请求。理论上来说，我们也可以使用客户端程序向MPNS发送Notification请求。为什么要用ASP.NET来编写，最主要的原因还是在于客户端应用要将URI传递给Server端，显然基于ASP.NET的Web应用在这方面是最容易的。

不过我们的实例中，没有客户端将URI传递给服务器端的代码，而是采用了最简单的办法：由开发者直接将URI拷贝到ASP.NET的Web应用中。

接下来，我们来看Server端的代码：

            try
            {
                // Get the Uri that the Microsoft Push Notification Service returns to the Push Client when creating a notification channel.
                // Normally, a web service would listen for Uri's coming from the web client and maintain a list of Uri's to send
                // notifications out to.
                string subscriptionUri = TextBoxUri.Text.ToString();


                HttpWebRequest sendNotificationRequest = (HttpWebRequest)WebRequest.Create(subscriptionUri);

                // We will create a HTTPWebRequest that posts the toast notification to the Microsoft Push Notification Service.
                // HTTP POST is the only allowed method to send the notification.
                sendNotificationRequest.Method = "POST";

                // The optional custom header X-MessageID uniquely identifies a notification message. 
                // If it is present, the // same value is returned in the notification response. It must be a string that contains a UUID.
                // sendNotificationRequest.Headers.Add("X-MessageID", "<UUID>");

                // Create the toast message.
                string toastMessage = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
                "<wp:Notification xmlns:wp=\"WPNotification\">" +
                   "<wp:Toast>" +
                        "<wp:Text1>" + TextBoxTitle.Text.ToString() + "</wp:Text1>" +
                        "<wp:Text2>" + TextBoxSubTitle.Text.ToString() + "</wp:Text2>" +
                        "<wp:Param>/Page2.xaml?NavigatedFrom=Toast Notification" + TextBoxSubTitle.Text.ToString() + "</wp:Param>" +
                   "</wp:Toast> " +
                "</wp:Notification>";

                // Sets the notification payload to send.
                byte[] notificationMessage = Encoding.Default.GetBytes(toastMessage);

                // Sets the web request content length.
                sendNotificationRequest.ContentLength = notificationMessage.Length;
                sendNotificationRequest.ContentType = "text/xml";
                sendNotificationRequest.Headers.Add("X-WindowsPhone-Target", "toast");
                sendNotificationRequest.Headers.Add("X-NotificationClass", "2");


                using (Stream requestStream = sendNotificationRequest.GetRequestStream())
                {
                    requestStream.Write(notificationMessage, 0, notificationMessage.Length);
                }

                // Send the notification and get the response.
                HttpWebResponse response = (HttpWebResponse)sendNotificationRequest.GetResponse();
                string notificationStatus = response.Headers["X-NotificationStatus"];
                string notificationChannelStatus = response.Headers["X-SubscriptionStatus"];
                string deviceConnectionStatus = response.Headers["X-DeviceConnectionStatus"];

                // Display the response from the Microsoft Push Notification Service.  
                // Normally, error handling code would be here.  In the real world, because data connections are not always available,
                // notifications may need to be throttled back if the device cannot be reached.
                TextBoxResponse.Text = notificationStatus + " | " + deviceConnectionStatus + " | " + notificationChannelStatus;
            }
            catch (Exception ex)
            {
                TextBoxResponse.Text = "Exception caught sending update: " + ex.ToString();
            }

Server端程序的主体是调用HttpWebRequest对象，来实现HTTP POST的方法。发送的消息以XML形式呈现，在上面代码中表现为toastMessage字符串，wp:Toast指定Notification类型，wp:Text1指定标题，wp:Text2指定子标题，wp:Param指定传递的参数。

请大家注意wp:Param，我们可以认为该参数相当于调用了客户端应用中NavigationService的Navigate方法，必须确认客户端有指定的页面可以进行跳转。当用户点击Toast Notification的提示条时，客户端应用会调用wp:Param，从而跳转到指定界面上。

我们可以通过该参数来传递一些参数，比如标识本次Notification是由哪条消息引发的。不过该参数中不应该包括敏感信息、安全信息，因为无法保证这些信息的安全。最好的办法是，传递一个ID值，当客户端访问服务器时，由服务器端判断该ID是否有效。

接下来，我们还要为HTTP 头添加自定义字段，这部分参考Sample Code就可以了。

接收Notification

当Server端代码完成后，我们回到客户端，看一下当MPNS找到设备后，如何触发我们的客户端代码。首先是Page2.xaml的OnNavigatedTo方法：

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

            //  If we navigated to this page
            // from the MainPage, the DefaultTitle parameter will be "FromMain".  If we navigated here
            // when the secondary Tile was tapped, the parameter will be "FromTile".
            textBlockFrom.Text = "Navigated here from " + this.NavigationContext.QueryString["NavigatedFrom"];
        }

通过NavigationContext.QueryString属性来获取自定义参数，试过传两个参数，后一个收到不到，目前成功的是传递一个参数的情况。

还有一种情况是，当客户端程序运行时，接收到Toast Notification时，该如何处理：

        void PushChannel_ShellToastNotificationReceived(object sender, NotificationEventArgs e)
        {
            StringBuilder message = new StringBuilder();
            string relativeUri = string.Empty;

            message.AppendFormat("Received Toast {0}:\n", DateTime.Now.ToShortTimeString());

            // Parse out the information that was part of the message.
            foreach (string key in e.Collection.Keys)
            {
                message.AppendFormat("{0}: {1}\n", key, e.Collection[key]);

                if (string.Compare(
                    key,
                    "wp:Param",
                    System.Globalization.CultureInfo.InvariantCulture,
                    System.Globalization.CompareOptions.IgnoreCase) == 0)
                {
                    relativeUri = e.Collection[key];
                }
            }

            // Display a dialog of all the fields in the toast.
            Dispatcher.BeginInvoke(() => MessageBox.Show(message.ToString()));

        }

该方法是HttpNotificationChannel的ShellToastNotificationReceived事件处理函数，具体内容不详细解释了。

Tile Notifications

Tile Notification是另一种Notification，主要用于在Windows Phone的首页上显示Smart Tile。很多内置的WP应用可以显示Tile上的自定义显示，比如Messaging程序里可以显示当前未读的短信有多少。Tile Notification可以帮助我们实现类似的功能，通常的一个用法是，首先发送一条Toast Notification，如果用户不理睬，可以发送一条Tile Notification，在Smart Tile上显示提示，让用户在方便时，再处理该条请求。

Tile Notification的实现代码与Toast Notification类似，所以，我们不在这里列出全部源代码了，只是列出与上面不同的部分代码。

首先来看Server部分的代码：

                // Create the tile message.
                string tileMessage = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
                "<wp:Notification xmlns:wp=\"WPNotification\">" +
                    "<wp:Tile>" +
                      "<wp:BackgroundImage>" + TextBoxBackgroundImage.Text + "</wp:BackgroundImage>" +
                      "<wp:Count>" + TextBoxCount.Text + "</wp:Count>" +
                      "<wp:Title>" + TextBoxTitle.Text + "</wp:Title>" +
                      "<wp:BackBackgroundImage>" + TextBoxBackBackgroundImage.Text + "</wp:BackBackgroundImage>" +
                      "<wp:BackTitle>" + TextBoxBackTitle.Text + "</wp:BackTitle>" +
                      "<wp:BackContent>" + TextBoxBackContent.Text + "</wp:BackContent>" +
                   "</wp:Tile> " +
                "</wp:Notification>";

                // Sets the notification payload to send.
                byte[] notificationMessage = Encoding.Default.GetBytes(tileMessage);

                // Sets the web request content length.
                sendNotificationRequest.ContentLength = notificationMessage.Length;
                sendNotificationRequest.ContentType = "text/xml";
                sendNotificationRequest.Headers.Add("X-WindowsPhone-Target", "token");
                sendNotificationRequest.Headers.Add("X-NotificationClass", "1");

TileMessage与ToastMessage大体类似，标签变为wp:Tile，而其中包括的数据分为两组：BackgroundImage、Title和Content，显示位置可以参考文章前面的示意图。BackgroundImage可以是本地的资源，也可以是远程的图片链接。

接下来是客户端的部分代码：

                pushChannel = new HttpNotificationChannel(channelName);

                // Register for all the events before attempting to open the channel.
                pushChannel.ChannelUriUpdated += new EventHandler<NotificationChannelUriEventArgs>(PushChannel_ChannelUriUpdated);
                pushChannel.ErrorOccurred += new EventHandler<NotificationChannelErrorEventArgs>(PushChannel_ErrorOccurred);

                pushChannel.Open();

                // Bind this new channel for Tile events.
                pushChannel.BindToShellTile();

Tile Notification无需添加任何额外的代码，在调用HttpNotificationChannel的Open方法后，还需要调用BindToShellTile的方法，通知Shell绑定该Tile Notification。

Raw Notifications

Raw Notification的用法最简单，在程序运行时，收到Raw Notification时，更新应用程序界面上的某些元素。

首先，我们来看Server端的代码：

                // Create the raw message.
                string rawMessage = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
                "<root>" +
                    "<Value1>" + TextBoxValue1.Text.ToString() + "<Value1>" +
                    "<Value2>" + TextBoxValue2.Text.ToString() + "<Value2>" +
                "</root>";

                // Sets the notification payload to send.
                byte[] notificationMessage = Encoding.Default.GetBytes(rawMessage);

                // Sets the web request content length.
                sendNotificationRequest.ContentLength = notificationMessage.Length;
                sendNotificationRequest.ContentType = "text/xml";
                sendNotificationRequest.Headers.Add("X-NotificationClass", "3");

RawMessage非常简单，只需要指定Value1, Value2就可以了，这些值是自定义的，然后指定HTTP头的X-NotificationgClass的值为3，代表Raw Notification。

接下来是客户端代码的片段：

pushChannel = new HttpNotificationChannel(channelName);
pushChannel.HttpNotificationReceived += new EventHandler<HttpNotificationEventArgs>(PushChannel_HttpNotificationReceived);
pushChannel.Open();


        void PushChannel_HttpNotificationReceived(object sender, HttpNotificationEventArgs e)
        {
            string message;

            using (System.IO.StreamReader reader = new System.IO.StreamReader(e.Notification.Body))
            {
                message = reader.ReadToEnd();
            }


            Dispatcher.BeginInvoke(() =>
                MessageBox.Show(String.Format("Received Notification {0}:\n{1}",
                    DateTime.Now.ToShortTimeString(), message))
                    );
        }

HttpNotificationChannel创建完成后，只需要调用Open方法即可，不需要绑定到Shell上。另外，还需要处理HttpNotificationChannel的HttpNotificationReceived事件处理函数，具体的代码不解释了。

写在最后

好了，到这里，我们正式将Windows Phone 7.1中的Push Notification介绍完了。为了增加用户黏性，Push Notification可能是一种非常有效的方式，但是请开发者谨慎使用，如果太多的垃圾信息影响用户体验，那是得不偿失的。另外，我们还需要为Push Notification搭建一个Web服务器，这对于普通开发人员来说，也是一个很难接受的成本。

OpenXLive杯Windows Phone游戏开发大赛

OpenXLive杯Windows Phone游戏开发大赛，是由OpenXLive联合国内知名的开发者社区：DevDiv、智机网、WPMind、Silverlight银光中国和XNA游戏世界，一起举办的针对Windows Phone游戏开发的比赛。

https://www.openxlive.net/posts/news/40

作者：马宁

Kinect SDK出来之后，不到24小时，很多Geek们已经将自己的示例发布到网上去了。可见，好东西肯定会被大家认可的，不好的东西投入再多的宣传也没用。

这一篇我们就要正式进入Kinect的编程世界了，介绍我们如何从Camera获取图像信息。先来介绍一下Kinect的整体结构，省得大家在后边的介绍中被某些名词弄晕。

Kinect一共有三个Camera，其中中间的一个是RGB Camera，用来获取640x480的彩色图像，每秒钟最多获取30帧图像；两侧是两个景深(3D Depth)传感器，用来检测玩家的相对位置，原理和人眼立体成像是一样的，不过这两个传感器使用的是红外线，所以说奥巴马玩不了Kinect的人一定是居心叵测。Kinect两侧是麦克风，下边还有一个可移动底座，用来调整Kinect的仰角。

Kinect开发环境

今天我们主要是操作RGB Camera和Depth Sensor，首先，我们要完成Kinect开发环境的配置：

第一步，创建WPF工程

打开Visual Studio 2010，创建一个WPF工程，名叫KinectWpfDemo：

当然，由于Kinect SDK中包含基于.NET的程序集，除了WPF外，我们使用.NET WinForm或XNA框架都可以，目前还没有人在Silverlight平台上实验成功。

第二步，添加Kinect程序集的引用

在Solution Explorer中，右键单击KinectWpfDemo，在右键菜单中选择“Add Reference…”。在弹出的对话框中，我们在.NET标签页里，选择“Microsoft.Research.Kinect”程序集。如下图所示：

第三步，添加Coding4Fun Kinect Toolkit

这是一个可选项，不过为了之后的编程方便，建议大家添加一个。Coding4Fun Kinect Toolkit的下载地址：

https://c4fkinect.codeplex.com/

解压缩后，一共有五个文件，针对WinForm、WPF平台，还有一个Microsoft.Expression.Drawing.dll。我们通过Add Reference，将Coding4Fun.Kinect.Wpf.dll添加进来。

获取RGB Camera数据

第四步，添加控件

双击打开MainWindow.xaml，在设计器中添加两个Image控件，一个用于显示RGB图像，另一个用于显示Depth信息。

第五步，引用命名空间

打开MainWindow.xaml.cs文件，在文件头部添加对于Kinect对象的引用：

using Microsoft.Research.Kinect.Nui;

using Microsoft.Research.Kinect.Audio;

using Coding4Fun.Kinect.Wpf;

回到MainWindow.xaml的设计器中，在属性窗口中选择Event，找到Loaded和Closed两个方法，分别双击，添加两个事件的处理函数：

在MainWindow.xaml.cs文件的MainWindow类中，声明Runtime的变量：

Runtime nui;

然后，在Loaded事件的处理函数中添加Runtime初始化的代码：

private void Window_Loaded(object sender, RoutedEventArgs e)

{

nui = new Runtime();

nui.Initialize(RuntimeOptions.UseColor| RuntimeOptions.UseDepth | RuntimeOptions.UseDepthAndPlayerIndex | RuntimeOptions.UseSkeletalTracking);

}

接下来是Closed事件中关闭Runtime的代码：

private void Window_Closed(object sender, EventArgs e)

{

nui.Uninitialize();

}

Runtime对象是Kinect SDK中最主要的一个类，所有针对Kinect的操作都由Runtime类进行了封装。Runtime的构造函数没有接受任何参数，但有一个显式的初始化函数Initialize，接受RuntimeOptions参数，指定调用Kinect的哪些功能。其中RuntimeOptions.UseColor表示使用RGB Camera，而RuntimeOptions.UseDepth则表示使用Depth传感器。

初始化工作完成之后，我们要通过RGB Camera来获取实时的图像数据了。我们首先要声明一个事件处理方法，来接收视频数据的信息：

nui.VideoFrameReady += new EventHandler<ImageFrameReadyEventArgs>(nui_VideoFrameReady);

然后是事件处理函数：

void nui_VideoFrameReady(object sender, ImageFrameReadyEventArgs e)

{

PlanarImage imageData = e.ImageFrame.Image;

image1.Source = BitmapSource.Create(imageData.Width, imageData.Height, 96, 96,

PixelFormats.Bgr32, null, imageData.Bits, imageData.Width * imageData.BytesPerPixel);

//image1.Source = e.ImageFrame.ToBitmapSource();

}

提示：Getting Started上提供的Sample Code有误，需要将最后一个参数中的data.Width改为imageData.Width才可以正常运行。

VideoFrameReady事件会传递一个ImageFrameReadyEventArgs参数给事件处理函数，其中的ImageFrame会包含关于图片的各种信息，比如Type变量指定了图像是来自RGB还是Depth，Resolution变量指定了分辨率，而Image中以byte[]数组的方式保存了图像的真实数据。

然后的工作就是根据PlanarImage中包括的数据来创建一个Bitmap对象，然后将其传递给Image控件，显示到WPF程序的界面上。

最后，我们还要在构造函数里打开视频流，来获取视频数据：

nui.VideoStream.Open(ImageStreamType.Video, 2, ImageResolution.Resolution640x480, ImageType.Color);

第一个参数是ImageStreamType，用来指定打开的设备流类型；第二个参数是PoolSize，指定缓冲区的数量，至少为2，保证一个Buffer进行绘制，另一个Buffer进行数据填充；第三个参数指定Camera的分辨率；第四个参数则是获取的图片类型。

显示效果如下图所示：

上面的示例代码，没有使用Coding4Fun的Helper类，如果使用的话，则代码如下：

void nui_VideoFrameReady(object sender, ImageFrameReadyEventArgs e)

{

image1.Source = e.ImageFrame.ToBitmapSource();

e.ImageFrame.ToBitmapSource().Save("catpure.jpg", ImageFormat.Jpeg);

}

Helper类使用了C#的Extension Methods，为ImageFrame增加了一些转换方法。我们还可以将图像保存为文件，考虑到文件系统存储的效率文件，建议大家不用每张都存。

获取Depth信息

接下来我们要获取Depth信息了，过程与RGB Camera类似。首先要确保Runtime对象被初始化时，已经添加了RuntimeOptions.UseDepth的属性，否则设备无法正常打开。

然后，添加获取Depth数据的事件处理，并打开Depth的数据流，这次的分辨率是320x240：

nui.DepthFrameReady += new EventHandler<ImageFrameReadyEventArgs>(nui_DepthFrameReady);

nui.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution320x240, ImageType.Depth);

下面是事件处理函数，在另外一个Image函数里，显示Depth图像：

void nui_DepthFrameReady(object sender, ImageFrameReadyEventArgs e)

{

image2.Source = e.ImageFrame.ToBitmapSource(); 

}

偷懒，所以使用了Coding4Fun的Helper类。程序运行的效果如下：

写到最后

这一篇中，我们完成了Kinect开发环境的配置、添加了Coding4Fun Kinect Toolkit、从RGB Camera和Depth Sensor中获取了图像信息。

接下来，我们就要进入Kinect动作捕捉部分了。

万众期待的Kinect for Windows SDK终于在广大开发者的千呼万唤中发布了beta版，作为历史上销售最快的消费电子产品，早就有无数人想将其用于其他领域了。微软虽然在硬件接口上制造了一点小障碍，但并没有对Kinect的输出做任何加密。于是，基于Kinect的各种应用层出不穷，也有开源社区提供了针对Kinect的USB驱动程序，比如OpenKinect等。

微软从谏如流，推出了官方版的Kinect for Windows SDK，终于让广大开发者可以名正言顺地使用Kinect SDK了。我希望能够在第一时间为国内开发者提供Kinect开发相关的介绍，根据微软官方提供的指南，从浅入深，将自己摸索Kinect SDK 的过程记录下来。

安装环境

首先来说，Kinect for Windows SDK的下载地址：

https://research.microsoft.com/en-us/um/redmond/projects/kinectsdk/download.aspx

Kinect SDK目前只支持Windows 7，分为x86和x64两个版本。开发工具方面还需要.NET Framework 4.0和Visual Studio 2010 （最低Express版本）的支持。

Kinect SDK的视频开发教程：

https://channel9.msdn.com/Series/KinectSDKQuickstarts?sort=recent#tab_sortBy_recent

Kinect SDK的开发指南：

https://research.microsoft.com/en-us/um/redmond/projects/kinectsdk/guides.aspx

Kinect SDK的官方论坛：

https://social.msdn.microsoft.com/Forums/en-US/kinectsdk/threads

硬件设备的需求是：Kinect for Xbox 360 sensor和Xbox 360 Kinect AC Adapter/ Power Supply。

如果您购买的是单独的Kinect，将包含Kinect AC Adapter/ Power Supply。但是如果您购买的是XBOX 360 Slim和Kinect的套装，就需要单独购买Kinect AC Adapter/ Power Supply。下面是亚马逊上的产品链接：

https://www.amazon.com/Xbox-360-Kinect-Adapter-Power-Supply/dp/B004IXRXGY/ref=sr_1_1?ie=UTF8&qid=1308247174&sr=8-1

安装步骤

1. 硬件安装

下面的图片是Kinect和AC Adapter/ Power Supply：

按照接口连接好后，将USB插入到PC上，AC Adapter电源是可以支持220V的，所以不需要转换器直接插到电源上就可以。

2. Kinect SDK安装

Kinect SDK的安装过程非常简单，无需任何设置，直接安装即可。

3. 环境测试

Kinect SDK安装完成后，我们将Kinect转接口的USB接口插入到PC中。PC会发现新硬件，并且自动查找驱动程序安装。下图是安装完成后的示意图：

4. 测试程序

我们打开Kinect SDK中自带的Sample Skeletal Viewer就可以很方便地检测Kinect设备是否与PC已经连接好了。

为了测试，逼得我不得不闪亮出镜了。以后Kinect调试，说不定还真要请一个人站在那里，实现敏捷开发中的“双人编程”……

写到最后

我们今天关于Kinect的介绍就到这里，在Kinect SDK的发布会上展示了很多有意思的DEMO，可见Kinect的应用前景是无限广阔的。下图就是一个Kinect与虚拟增强现实整合的案例：

下一节，我们会深入Kinect真实的开发环境，来编写第一个Kinect的应用程序。

普通用户对Mango的关注更多停留在多语言、多任务等方面，但对于开发者来说，Mango还有很多有趣的功能。我会试着将自己感兴趣的一些功能写出来，变成一个系列。

首先，大家要安装Windows Phone 7的SDK和Windows Phone 7.1 SDK的Beta 版，下载地址如下：

https://www.microsoft.com/downloads/en/details.aspx?FamilyID=77586864-ab15-40e1-bc38-713a95a56a05

创建工程

关于Windows Phone 7.1的第一个功能是XNA与Silverlight的集成。Windows Phone里有两个Framework，Silverlight是做应用的，而XNA是做游戏开发的。Silverlight有一套非常好用的UI设计工具和控件体系，而XNA对于动画效果的处理又远远超过Silverlight。但是在WP7里，Silverlight和XNA必须是分开的，所以当Silverlight应用需要高性能显示，或者XNA游戏里需要编写UI时，都会碰到很多困难。

于是，在WP 7.1里，提供了XNA与Silverlight集成的功能。接下来，我们就来看一下，如何创建一个Silverlight和XNA集成的应用。

打开Visual Studio 2010，选择File-New Project，在Visual C#里找到Silverlight for Windows Phone，然后选择其中的“Windows Phone 3D Graphics Application”，这个名字有足够的迷惑性，XNA的2D也是支持的。如下图：

创建过程没有什么特殊的地方，创建完成后的工程如下图所示：

说实话，XNA与Silverlight集成的实现并不算优雅，有点叠床架屋的感觉。整个Solution里分为三个Project，其中GraphicsApp1是我们的主程序，主要的逻辑代码都是在这个工程里的，这是一个典型的Silverlight程序，包含了App.xaml和MainPage.xmal，多出来一个GamePage.xaml，这个是XNA的页面。除此之外，还有两个Library，分别叫做GraphicsApp1Library和GraphicsApp1LibraryContent，后边是XNA的Content库，前边一个应该是为了能够让Silverlight加载XNA资源所做的适配库。

直接运行程序，我们会看到下面的界面，点击HomePage的Play按钮，我们就进入了XNA的GamePage界面：

GamePage探秘

接下来，我们看一下GamePage.xaml的结构，看看这个看似普通的XAML页面里具体做了什么事情。首先是GamePage.xaml，如下：

<phone:PhoneApplicationPage 
    x:Class="GraphicsApp2.GamePage"
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
    xmlns:d="https://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="https://schemas.openxmlformats.org/markup-compatibility/2006"
    FontFamily="{StaticResource PhoneFontFamilyNormal}"
    FontSize="{StaticResource PhoneFontSizeNormal}"
    Foreground="{StaticResource PhoneForegroundBrush}"
    SupportedOrientations="Portrait" Orientation="Portrait"
    mc:Ignorable="d" d:DesignHeight="800" d:DesignWidth="480"
    shell:SystemTray.IsVisible="False">

    <!--No XAML content as the page is rendered entirely with XNA-->
    
</phone:PhoneApplicationPage>

什么都没有……所有的显示都是由XNA控制的。接下来，我们去看GamePage.xaml.cs，首先来看引用程序集的部分：

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Content;

using Microsoft.Xna.Framework.Graphics;

引用了三个XNA的命名空间，接下来是变量声明：

GameTimer timer;

ContentManager content;

SpriteBatch spriteBatch;

Texture2D texture;

Vector2 spritePosition;

除了GameTimer是生面孔外，其他几个都是老熟人，GameTimer也好理解，Silverlight是事件驱动的Framework，如果想定时更新的话，必须要加入一个Timer。接下来，是GamePage的构造函数：

        public GamePage()
        {
            InitializeComponent();

            // Get the application's ContentManager
            content = (Application.Current as App).Content;

            // Create a timer for this page
            timer = new GameTimer();
            timer.UpdateInterval = TimeSpan.FromTicks(333333);
            timer.Update += OnUpdate;
            timer.Draw += OnDraw;
        }

ContentManager对象是来自于App的Content属性，我们不会再有一个派生自Microsoft.Xna.Framework.Game的Host类了。然后是GameTimer的初始化工作，指定更新时间间隔，然后为Update和Draw事件添加方法。我不知道理解的是否正确，但有可能是GameTimer类重新实现了XNA Framework的机制。

然后是两个重载的Navigated函数：

        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            // Set the sharing mode of the graphics device to turn on XNA rendering
            SharedGraphicsDeviceManager.Current.GraphicsDevice.SetSharingMode(true);

            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(SharedGraphicsDeviceManager.Current.GraphicsDevice);

            // TODO: use this.content to load your game content here

            // Start the timer
            timer.Start();

            base.OnNavigatedTo(e);
        }

        protected override void OnNavigatedFrom(NavigationEventArgs e)
        {
            // Stop the timer
            timer.Stop();

            // Set the sharing mode of the graphics device to turn off XNA rendering
            SharedGraphicsDeviceManager.Current.GraphicsDevice.SetSharingMode(false);

            base.OnNavigatedFrom(e);
        }

OnNavigatedTo函数实现了LoadContent的功能，第一句话值得注意，我们要首先打开GraphicsDevice的SetSharingMode为true，才能够让XNA元素正常的显示出来。这句话也交代了XNA最主要的类GraphicsDeviceManager的去向，被放到一个静态的SharedGraphicsDeviceManager对象里去了。

创建SpriteBatch和加载资源的过程不再叙述，最后要调用GameTimer的Start方法，来启动XNA的时间驱动机制，与之对应的是OnNavigatedFrom函数中，我们还需要调用GameTimer的Stop方法，来关闭时间驱动机制。

最后是熟悉的OnUpdate和OnDraw方法，就数这两个函数原汁原味地保留了XNA的特点。

        /// <summary>
        /// Allows the page to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        private void OnUpdate(object sender, GameTimerEventArgs e)
        {
            // TODO: Add your update logic here
        }

        /// <summary>
        /// Allows the page to draw itself.
        /// </summary>
        private void OnDraw(object sender, GameTimerEventArgs e)
        {
            SharedGraphicsDeviceManager.Current.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.CornflowerBlue);

            // TODO: Add your drawing code here
        }

添加Silverlight控件

如果只是在Silverlight应用里添加一个XNA的页面，恐怕还没有太大的吸引力。我们还应该让XNA和Silverlight能够在一个页面上显示。首先我们要打开GamePage.xaml文件，找到下面的代码：

<!--No XAML content as the page is rendered entirely with XNA-->

将下列代码替换上面的注释：

    <!-- LayoutRoot is the root grid where all page content is placed -->
    <Grid x:Name="LayoutRoot">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>

        <!-- Toggles the visibility of the ColorPanel -->
        <Button Grid.Row="0" x:Name="ColorPanelToggleButton" Click="ColorPanelToggleButton_Click" Margin="1,0,-1,0">Toggle Color Panel</Button>

        <!-- Arrange buttons in a horizontal line by using StackPanel -->
        <StackPanel x:Name="ColorPanel" Grid.Row="2"  Height="100" Orientation="Horizontal" HorizontalAlignment="Center" Visibility="Visible">
            <!-- Buttons to set the rectangle to specific colors -->
            <Button Click="redButton_Click" HorizontalAlignment="Center" Height="75" VerticalAlignment="Center" BorderThickness="3" Background="Firebrick" Width="75" />
            <Button Click="greenButton_Click" HorizontalAlignment="Center" Height="75" VerticalAlignment="Center" BorderThickness="3" Background="Lime" Width="75" />
            <Button Click="blueButton_Click" HorizontalAlignment="Center" Height="75" VerticalAlignment="Center" BorderThickness="3" Background="Blue" Width="75" />
        </StackPanel>
    </Grid>

如果编译的话，会提示没有Button对应的事件处理函数。

添加代码

下面部分和MSDN提供的示例代码不同，我试图找到一种更简单的办法来更改颜色。首先，我们在GraphicsApp1LibraryContent工程里找到redRect.jpg，右键单击，选择Open With，然后在列表里选择Paint，用画图打开文件后，将整个图片涂成白色。做完这个工作后，记得一定要重新编译整个工程。

接下来，我们声明Color变量，并且在构造函数里赋初始值。

Color bgColor;

public GamePage()

{

    // ...
 
    bgColor = Color.Red;

}

然后我们增加事件处理函数，首先是控制颜色是否显示的控件：

        // Toggle the visibility of the StackPanel named "ColorPanel"
        private void ColorPanelToggleButton_Click(object sender, RoutedEventArgs e)
        {
            if (System.Windows.Visibility.Visible == ColorPanel.Visibility)
            {
                ColorPanel.Visibility = System.Windows.Visibility.Collapsed;
            }
            else
            {
                ColorPanel.Visibility = System.Windows.Visibility.Visible;
            }
        }

然后是切换颜色的几个Button的处理函数：

        // Switch to the red rectangle
        private void redButton_Click(object sender, RoutedEventArgs e)
        {
            bgColor = Color.Red;
        }

        // Switch to the green rectangle
        private void greenButton_Click(object sender, RoutedEventArgs e)
        {
            bgColor = Color.Green;
        }

        // Switch to the blue rectangle
        private void blueButton_Click(object sender, RoutedEventArgs e)
        {
            bgColor = Color.Blue;
        }

最后，我们在OnDraw函数里，找到下面的代码：

spriteBatch.Draw(texture, spritePosition, Color.White);

换成下面的代码：

spriteBatch.Draw(texture, spritePosition, bgColor); 

这样我们就可以为白色的材质绘制出不同的颜色了。

现在程序可以编译通过了，但是运行程序后，Silverlight的控件却没办法显示出来。原因是Silverlight控件必须经过特殊的处理，才能够显示出来。首先要声明一个UIElementRenderer变量：

// For rendering the XAML onto a texture

UIElementRenderer elementRenderer;

然后，在GamePage的构造函数里，添加下面的代码：

// Use the LayoutUpdate event to know when the page layout 

// has completed so we can create the UIElementRenderer

LayoutUpdated += new EventHandler(GamePage_LayoutUpdated);

添加GamePage_LayoutUpdated的函数，在函数中创建UIElementRenderer的对象：

        void GamePage_LayoutUpdated(object sender, EventArgs e)
        {
            // Create the UIElementRenderer to draw the XAML page to a texture.

            // Check for 0 because when we navigate away the LayoutUpdate event
            // is raised but ActualWidth and ActualHeight will be 0 in that case.
            if (ActualWidth > 0 && ActualHeight > 0 && elementRenderer == null)
            {
                elementRenderer = new UIElementRenderer(this, (int)ActualWidth, (int)ActualHeight);
            }
        }

最后，在OnDraw函数里，添加下面的代码：

        /// <summary>
        /// Allows the page to draw itself.
        /// </summary>
        private void OnDraw(object sender, GameTimerEventArgs e)
        {
            SharedGraphicsDeviceManager.Current.GraphicsDevice.Clear(Color.Black);

            // TODO: Add your drawing code here
            // Render the Silverlight controls using the UIElementRenderer
            elementRenderer.Render();


            // Draw the sprite
            spriteBatch.Begin();
            spriteBatch.Draw(texture, spritePosition, bgColor); //Color.White);
            spriteBatch.DrawString(StartFont, "Hello, XNA", new Vector2(50), Color.Blue);

            // Using the texture from the UIElementRenderer, 
            // draw the Silverlight controls to the screen
            spriteBatch.Draw(elementRenderer.Texture, Vector2.Zero, Color.White);


            spriteBatch.End();
        }

再运行程序时，我们就可以看到Silverlight控件了，点击颜色控件，方块会切换成对应的颜色。如下图所示：

加载XNA资源

到这里，我们的体验基本上告一段落了，但是我试了一下是否能够正常加载XNA的字体，所以就写了最后这部分。

右键点击GraphicsApp1LibraryContent，选择Add – New Item。在对话框中选择Sprite Font，我们将字体命名为StartFont。在打开的字体文件中，我们将Size改成30，如下面所示：

    <!--
    Size is a float value, measured in points. Modify this value to change
    the size of the font.
    -->
    <Size>30</Size>

回到GamePage.xaml.cs文件中，我们首先声明SpriteFont变量：

SpriteFont StartFont;

然后，在OnNavigatedTo函数中，添加字体加载的代码：

        protected override void OnNavigatedTo(NavigationEventArgs e)
        {

            // Set the sharing mode of the graphics device to turn on XNA rendering
            SharedGraphicsDeviceManager.Current.GraphicsDevice.SetSharingMode(true);

            spriteBatch = new SpriteBatch(SharedGraphicsDeviceManager.Current.GraphicsDevice);

            // TODO: use this.content to load your game content here
            texture = content.Load<Texture2D>("redRect");
            StartFont = content.Load<SpriteFont>("StartFont");

最后，在OnDraw函数里，添加字体的绘制函数：

spriteBatch.DrawString(StartFont, "Hello, XNA", new Vector2(50), Color.Blue);

程序运行的效果如下：

另一条路

除了在Silverlight for Windows Phone创建Windows Phone 3D Graphics Application外，我们还能够通过另一种方式创建XNA与Silverlight整合的应用程序。

在XNA Game Studio 4.0中，选择Windows Phone Rich Graphics Application：

通过这个向导创建的程序，与上面创建的程序大同小异，只是界面略有不同。运行界面如下：

写在最后

好了，到这里，我们正式将Windows Phone 7.1中的Silverlight与XNA整合应用介绍完了。在XNA游戏中，我们可以使用Silverlight来创建界面；也可以在Silverlight应用中编写高性能的3D界面。

OpenXLive杯Windows Phone游戏开发大赛

OpenXLive杯Windows Phone游戏开发大赛，是由OpenXLive联合国内知名的开发者社区：DevDiv、智机网、WPMind、Silverlight银光中国和XNA游戏世界，一起举办的针对Windows Phone游戏开发的比赛。

https://www.openxlive.net/posts/news/40

当OpenXLive在XNA游戏中大展身手的同时，我们也听到了一些来自Silverlight程序员的抱怨。在Windows Phone 7中虽然提供了XNA的游戏开发平台，但相当一部分的游戏是采用Silverlight开发的。毕竟对于显示性能不高的游戏来说，Silverlight是一个颇具魅力的快速开发工具。

幸好，我们在最初的架构设计上考虑了未来支持Silverlight的可能性，所以将业务逻辑部分封装到了OpenXLive.dll中，而将XNA上的XLiveForm窗体和控件库封装到了OpenXLive.Forms.dll中。我们只需要在Silverlight中调用OpenXLive中的功能即可。

在提供了一个OpenXLive on Silverlight的简单示例代码后，我们发现对Silverlight游戏的支持仍旧不够。首先，我们只提供了Leaderboard部分的示例代码，在缺乏文档的情况下，开发其他功能的UI是很困难的；其次，开发者并不希望自己动手写一个Silverlight UI，而只是想简单地在游戏中加入OpenXLive的支持，就像在XNA游戏中那样。

所以，我们重新定义了OpenXLive Silverlight的功能，实现了OpenXLive中的所有功能，并将其封装到了OpenXLive.Silverlight.dll中。在开发过程中，我们尽力保持XNA和Silverlight框架的一致性，如果您使用过OpenXLive XNA版本，在Silverlight版本中，您会有一种似曾相识的感觉，这正是我们所希望的。

需要提示的一点是，OpenXLive的Silverlight和XNA版本共同使用了一个逻辑程序集——OpenXLive.dll，所以他们在功能上是一致的。

未来，我们会将OpenXLive Silverlight加入到OpenXLive SDK中，并提供Visual Studio模板。在某一个时间点上，我们会考虑对OpenXLive Silverlight进行开源，让开发者能够方便的将OpenXLive Silverlight修改成自己想要的样子。

OpenXLive简介

微软为Windows Phone 7上的XNA和Silverlight游戏开发提供了非常好的开发工具和应用程序框架，使得开发者可以更加容易地开发出生动有趣的游戏来。但是随着开发的深入，我们发现，虽然我们开发的游戏品质可以和大公司的产品相媲美，但比起大公司游戏的用户体验还是相差很多。因为，我们必须将很多时间用于周边功能的开发，比如：启动界面(Splash Screen), 积分榜(Leaderboard)和游戏成就(Achievement)等，更不要奢谈为游戏加入SNS功能，比如：查看在线用户(Online Player)、云存储(Cloud Storage)等在线功能了。这些周边功能的开发时间，可能要超过游戏本身的开发时间，那我们该怎么办呢？

OpenXLive正在想办法帮助个人开发者和小团队开发者，使他们在最短的时间内拥有以上这些只有大公司才可能拥有的游戏功能。

OpenXLive是一种为Windows Phone 7智能手机游戏开发者提供的云端在线服务。支持开发者为单机游戏增加云端和SNS功能，帮助开发者以最小的工作量将云端服务集成到自己的游戏中。这些云端服务包括：积分榜、游戏成就、在线对战、Social Network和云端存储等功能。与Open XLive类似的服务，还有iOS上的OpenFeint。

OpenXLive目前支持Windows Phone的XNA与Silverlight开发框架，不需要开发者编写UI代码，即可在游戏中方便地调用OpenXLive的界面及功能。由于XNA和Silverlight是两个不同的应用程序框架，所以，OpenXLive提供了不同的引用方式来支持XNA和Silverlight游戏。

本文讨论的是如何将OpenXLive加入到Silverlight游戏中，如果您的游戏采用XNA编写，请查看《OpenXLive开发入门》，链接如下：

https://wiki.openxlive.net/Getting-Started-with-Open-XLive.ashx

添加引用

您可以在下面的链接中下载单独的OpenXLive Silverlight SDK:

https://resource.openxlive.com/resource/Download/ad686043-d477-4d5a-bc83-f27520a3d600

首先，我们假设您已经有了基于Silverlight开发的Windows Phone游戏。如果您想从头创建一个OpenXLive Silverlight游戏，您可以参考下一节《OpenXLive Silverlight向导使用》。

我们采用的示例工程OpenXLiveGameSilverlight，您可以在OpenXLive的资源网站中找到。

首先，我们在OpenXLive SDK的bin文件夹下找到OpenXLive.dll和OpenXLive.Silverlight.dll，将其拷贝到工程所在的目录中。

然后，在Visual Studio 2010中，打开OpenXLiveGameSilverlight工程，在Solution Explorer中找到References节点，右键单击啊，选择Add References，在对话框中选择Browse页面，找到工程目录下的OpenXLive.dll和OpenXLive.Silverlight.dll，将两个程序集的引用加入到工程中。

添加成功后，如下图所示：

修改初始页面

在引用添加完成之后，我们还要修改WMAppMainifest.xml文件，使Silverlight游戏启动时，启动OpenXLive.Silverlight中所包含的Startup页面。

在工程的Propertes节点下找到WMAppMainifest.xml文件，双击打开，如下图所示：

WMAppMainifest.xml文件的结构如下：

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

<Deployment xmlns="https://schemas.microsoft.com/windowsphone/2009/deployment" AppPlatformVersion="7.0">
  <App xmlns="" ProductID="{3cf35939-f7f6-4808-969c-22d520f6a526}" Title="OpenXLiveGameSilverlight" RuntimeType="Silverlight" Version="1.0.0.0" Genre="apps.normal"  Author="OpenXLiveGameSilverlight author" Description="Sample description" Publisher="OpenXLiveGameSilverlight">
    <IconPath IsRelative="true" IsResource="false">ApplicationIcon.png</IconPath>
    <Capabilities>
      <Capability Name="ID_CAP_GAMERSERVICES"/>
    </Capabilities>
    <Tasks>
      <DefaultTask  Name ="_default" NavigationPage="OpenXLive.Silverlight;component/Forms/StartupPage.xaml"/>
    </Tasks>
    <Tokens>
      <PrimaryToken TokenID="OpenXLiveGameSilverlightToken" TaskName="_default">
        <TemplateType5>
          <BackgroundImageURI IsRelative="true" IsResource="false">Background.png</BackgroundImageURI>
          <Count>0</Count>
          <Title>OpenXLiveGameSilverlight</Title>
        </TemplateType5>
      </PrimaryToken>
    </Tokens>
  </App>
</Deployment>

在WMAppMainifest.xml文件中找到DefaultTask节点，并将其中的NavigationPage改为”OpenXLive.Silverlight;component/Forms/StartupPage.xaml”。这样能保证Silverlight游戏启动之后，会首先启动OpenXLive的Startup页面。

接下来，我们还要完成对XLiveSLFormManager对象的初始化工作。打开工程中的App.xaml.cs文件，首先在文件顶部加入对OpenXLive.Silverlight的引用：

using OpenXLive.Silverlight;

然后，在App类中找到Application_Launching方法，加入XLiveSLFormManager对象的创建操作：

        // Code to execute when the application is launching (eg, from Start)
        // This code will not execute when the application is reactivated
        private void Application_Launching(object sender, LaunchingEventArgs e)
        {
            XLiveSLFormManager manager = new XLiveSLFormManager(this, "xxxxxxxxxxxxxxxx");
        }

其中，第一个参数为App实例的引用，第二个参数为SecretKey，该Key是在OpenXLive网站上创建游戏时，由系统生成的，作为OpenXLive系统识别游戏的唯一标识符，请保证这个SecretKey的安全，以防止其他游戏进行仿冒。

更多详细情况，请查看《在开发者网站上创建OpenXLive游戏》，链接如下：

https://wiki.openxlive.net/Tutorial-4-Create-OpenXLive-Game-in-website.ashx

当然，我们也可以在App类中创建一个static的FormManager属性，用于在程序的其他地方调用XLiveSLFormManager对象，但这一步不是必须的，代码如下：

        public static XLiveSLFormManager FromManager { get; internal set; }

        // Code to execute when the application is launching (eg, from Start)
        // This code will not execute when the application is reactivated
        private void Application_Launching(object sender, LaunchingEventArgs e)
        {
            FromManager = new XLiveSLFormManager(this, "xxxxxxxxxxxxxxxxxx");
        }

我们运行程序，能够看到下面的界面，是不是有一种似曾相识的感觉？点击Game Center和Leaderboards，我们可以进入相关的界面：

目前OpenXLive Silverlight只支持竖屏（Portrait）显示，未来我们会加入对于横屏（Landscape）的支持。另外，除了Startup界面之外，其他OpenXLive界面都是黑色背景，这样做主要是为了节省系统资源。

添加背景和事件处理

接下来，为了美化启动界面，我们要加入背景图片。添加背景图片的操作非常简单：在Solution Explorer中，选择Project节点，右键单击，选择Add – Existing Item，在选择一副PNG或JPG的图片，尺寸最好是800x480，这样能够有效保证图片不变形。

另外请确认一下，我们加入的图片Build Action为Resource，且Copy to Output Directory选择“Do not copy”。

然后，回到App.xaml.cs文件的Application_Launching方法中：

        // Code to execute when the application is launching (eg, from Start)
        // This code will not execute when the application is reactivated
        private void Application_Launching(object sender, LaunchingEventArgs e)
        {
            FromManager = new XLiveSLFormManager(this, "xxxxxxxxxxxxxxxxxxx");
            StartupPage.BackgroundPath = "/OpenXLiveGameSilverlight;component/OpenXLive.Portrait.png";
        }

我们要为StartupPage添加BackgroundPath，示例代码的写法是针对游戏本身的资源，也可以指定一个来自Web的链接，不过出于显示效果的考虑，建议您不要这么做。OpenXLiveGameSilverlight，是资源所在程序集的名称；component/OpenXLive.Portrait.png，是资源的引用路径，如果资源包含在一个文件夹中，写法应该是component/MyFolder/OpenXLive.Portrait.png。

最后提醒，请大家千万不要忘记字符串前面的“/”，没有这个符号，程序将抛出异常。

接下来，我们要加入Startup页面的事件处理函数，当用户点击某一个按钮时，会触发一个事件操作。我们在下面增加了其中两个按钮的事件处理方法：

        public static XLiveSLFormManager FromManager { get; internal set; }

        // Code to execute when the application is launching (eg, from Start)
        // This code will not execute when the application is reactivated
        private void Application_Launching(object sender, LaunchingEventArgs e)
        {
            FromManager = new XLiveSLFormManager(this, "xxxxxxxxxxxxxxxxxx");
            StartupPage.BackgroundPath = "/OpenXLiveGameSilverlight;component/OpenXLive.Portrait.png";
            StartupPage.NewGameButtonClick += new EventHandler(StartupPage_NewGameButtonClick);
            StartupPage.AboutButtonClick += new EventHandler(StartupPage_AboutButtonClick);
        }

        void StartupPage_AboutButtonClick(object sender, EventArgs e)
        {
            MessageBox.Show("OpenXLive Silverlight Demo 1.0");
        }

        void StartupPage_NewGameButtonClick(object sender, EventArgs e)
        {
            this.RootFrame.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
        }

AboutButtonClick的处理函数非常简单，只是调用了Message来显示游戏的版本信息。而NewGameButtonClick则是为了调用开发人员自己编写的Silverlight游戏界面，这个界面应该存在于Silverlight游戏的程序集中。

最后，我们得到的Silverlight启动界面就是上图这样。我们在Silverlight的界面中，没有增加Exit选项，因为Silverlight界面默认不支持退出操作，只能通过按Back键来退出程序。

使用Wizard创建新游戏

接下来，我们要介绍如何使用Visual Studio 2010的Template来创建一个OpenXLive Silverlight游戏。OpenXLive Silverlight的模板会包括在OpenXLive SDK中，如果您安装了OpenXLive SDK，就可以在Visual Studio 2010中创建基于Silverlight的游戏了。

首先，打开Visual Studio 2010，在File菜单中选择New-Project，在New Project对话框中，选择Visual C#下的Silverlight for Windows Phone中的OpenXLive Silverlight节点，然后选择创建OpenXLiveSilverlightGame。

OpenXLiveSilverlightGame工程创建完毕后，如果直接编译，会得到下列的错误提示：

这个错误是为了提醒开发者，要在OpenXLive开发者网站上创建自己的游戏，获取游戏对应的Secret Key，才能够正常使用OpenXLive的在线功能。

获取Secret Key的方法，请参考《在开发者网站上创建OpenXLive游戏》，链接如下：

https://wiki.openxlive.net/Tutorial-4-Create-OpenXLive-Game-in-website.ashx

打开App.xaml.cs文件，找到下面的代码：

public static XLiveSLFormManager FromManager { get; internal set; }

#error Please full your game Secret Key in below code
private string APISecretKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxx";

// Code to execute when the application is launching (eg, from Start)
// This code will not execute when the application is reactivated
private void Application_Launching(object sender, LaunchingEventArgs e)
{
    FromManager = new XLiveSLFormManager(this, APISecretKey);
    StartupPage.BackgroundPath = "/OpenXLiveSilverlightGame2;component/OpenXLive.Portrait.png";
    StartupPage.NewGameButtonClick += new EventHandler(StartupPage_NewGameButtonClick);
    StartupPage.AboutButtonClick += new EventHandler(StartupPage_AboutButtonClick);
}

开发者将Secret Key加入到高亮显示部分，并且注释掉#error代码，我们的工程就可以正常编译了。

我们也可以修改New Game Button的事件处理函数，来决定调用哪个Silverlight窗体。

void StartupPage_NewGameButtonClick(object sender, EventArgs e)
{
    this.RootFrame.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

到这里，我们就介绍完了如何通过Visual Studio 2010向导来创建OpenXLive Silverlight游戏的方法。

写在最后

我们用几乎与XNA版本相同的顺序，叙述了如何将OpenXLive Silverlight加入到Windows Phone Silverlight的游戏中去。接下来，我们会介绍，如何提交成绩、提交成就，考虑到Silverlight的界面编程更加容易，我们并不会提供一个标准的成绩提交界面，该界面只会以示例代码的形式出现。

https://wiki.openxlive.net/OpenXLive-Silverlight.ashx

引用

OpenXLive官方网站

https://www.openxlive.net/

OpenXLive开发者网站

https://developer.openxlive.net/

OpenXLive开发入门

https://wiki.openxlive.net/Getting-Started-with-Open-XLive.ashx

介绍

OpenXLive是Windows Phone 7上的游戏竞技和社交网络SNS平台，允许开发者以最小的工作量为自己的游戏增加游戏竞技服务和社交网络SNS功能。OpenXLive是由Fulcrum Mobile Networks, Inc.开发运营的。同类的应用还有iPhone上的OpenFeint和Plus+等。

背景

我们今天看到只是移动互联网的黎明，App Store无疑是移动互联网时代的第一缕曙光。App Store将开发者从传统软件公司、软件发布渠道中解放出来，只要有创意，哪怕是个人或者小团队，都可以获得巨大的成功。随着App Store模式的确立，无数开发者迎来了前所未有的机遇。

在迎来机遇的同时，困难也接踵而至。以游戏开发为例，优秀的个人、小团队开发者们可以完成创意、美工、编程等工作。但是，面对一些非核心领域时，个人开发者和小团队往往有些力不从心。比如，我们需要提供在线积分榜、游戏成就、社交网络，这些功能虽然不是必须的，但却有利于提高玩家的游戏体验和用户黏性。

但如果增加这些功能，对于小团队来说，成本无疑是高昂的，如果游戏数量比较少，那么这些非核心功能的开发量，甚至要超越游戏本身的开发量。

于是，Game Center应运而生，他们为开发者提供游戏在线功能、甚至将这些功能的UI也一并实现，用户只需要增加几行代码，就拥有了以前大型游戏公司才能拥有的在线功能。这其中，iPhone上的OpenFeint无疑是目前运营最为成功的第三方Game Center类在线服务。

Windows Phone 7为开发者提供了XBox Live的支持，但是开发者必须自己开发相应的UI来支持XBox Live。而且XBox Live是一个封闭式的收费系统，虽然拥有非常酷的功能，但比起开放的SNSN来，在社交性上要打一些折扣。

OpenXLive为开发者提供了完整的游戏竞技功能和相应UI的支持，使开发者可以方便地将OpenXLive嵌入到自己的游戏中，而无需为开发UI而烦恼。而且为开发者和玩家提供了SNS功能，只要轻轻一点，就可以添加好友、查看好友的游戏成就。

<客户端UI截图>

OpenXLive提供了真实的社交网络功能，允许玩家在手机客户端和Web上查看好友信息和游戏成绩的情况。OpenXLive为每一个玩家提供了个人主页，来展示自己在游戏中取得的丰功伟绩，还可以在好友的消息上进行转发和评论。未来，OpenXLive会和其他社交网络平台更加紧密地结合在一起。

移动互联网时代，我们真正需要的是，一个开放式、永远免费、欢迎所有人、跨越平台、没有疆域、不带有任何偏见的游戏社交平台。

<个人主页截图>

OpenXLive还为游戏开发者提供了游戏的官网服务。个人开发者和小团队很难有资源维护自己的网站，提供官网主页可以帮助开发者更好地推广自己的游戏，并且及时收集玩家反馈。游戏官网还提供了对于下载人数和在线人数的计数器功能。

<游戏官网>

功能

· Leaderboard积分榜

让全世界都知道你是这个游戏中的最强者！积分榜，用来记录你的游戏成绩，让你和全世界的玩家分享你超凡的游戏成绩。

积分榜，无疑是游戏中最核心的游戏功能之一。街机时代，我们甚至为将某台街机上的前三名都写上自己的名字而奋斗。互联网时代，我们不再满足于在一台游戏机上开疆拓土。看一下这个世界上最牛玩家的成绩，将来登顶那个世界之巅，也许是很多玩家的心愿。

OpenXLive提供了在线积分榜的功能，玩家可以查看这个游戏中积分最高的成绩，也可以查看好友在这个游戏中的表现，还可以查看自己在游戏积分榜中所处的位置。

对于开发者来说，OpenXLive提供了三种数据类型：整型数、浮点数和时间段。时间段成绩用于赛车类、竞速类的游戏。相比于其他积分榜服务只提供一种数据类型来说，OpenXLive无疑是一个进步。

除了Windows Phone上的积分榜外，我们还可以在WEB端查看游戏积分的情况。在游戏官网主页上，点击Leaderboard，就可以查看游戏的积分榜。

· Achievements游戏成就

一个个游戏成就，像一枚枚勋章，记录了你在游戏中的成长历程。篝火边，用成就，告诉你的朋友，你是如何成为游戏中最强的勇士。

游戏成就无疑是一个划时代的创新，将玩家以前只能通过口头传播的丰功伟绩，比如“我满血通关”，用可视化的方式呈现出来。游戏成就最早出现在XBox Live中，在SONY PSN的奖杯系统中壮大。现在，游戏成就已经成为设计精良的游戏大作中最吸引人的一部分，有的玩家甚至为了获取一些稀世成就，而反复通关，大大增加了游戏的生命周期。

同样，游戏成就的设计、实现难度也是非常巨大的。OpenXLive提供了一个在线平台，可以获取、展现玩家获取的游戏成就。开发者只需要在OpenXLive开发者网站上完成对于游戏成就的编辑，将成就代码加入到游戏中。获取、展现游戏成就的功能，都会有OpenXLive实现。

在游戏主页和玩家主页上，也会显示玩家所获取的游戏成就：

· Social Network社交网络

告诉你，这世界上还有多少兄弟姐妹和你一起在游戏中奋战。找到他们，和他们成为好友，一起开始一段冒险的路程。

SNS的魅力无法阻挡，在互联网上充满了SNS游戏时，手机游戏的领域仍然以单机游戏为主。这无疑是个充满想象力的空间。社交游戏，认为游戏应该和好友去玩；网络游戏，认为玩家是虚拟世界中的一个化身。

OpenXLive试图在游戏与好友之间搭起一座桥梁，你可以查看游戏中所有的在线用户，并且简单的将他们添加为好友；也可以查看好友的状态、成绩、游戏成就和最新的消息。

当然我们也支持WEB端的个人主页。

· My Center个人中心

这里有你过去、现在和将来的故事。你的积分、你的成就、你玩过的游戏、你的好友，这是你值得珍藏的一页。

还记得第一次玩仙剑奇侠传时流过的眼泪吗？人是一种回忆的动物，如果有一个地方，能够帮助你珍藏这些青葱岁月时的记忆，哪怕只是内心深处的一个小角落，你是否愿意经常去看看呢？

My Center提供的就是这么一个小角落，让你看到过往的记忆与荣耀。无论过去多少年，你的游戏、你的成就、你的成绩，就在那里，不失不灭。

· Cloud Storage云存储

不想让别人发现你在游戏中的秘密？把它放在云端吧。你可以在任何地方，打开尘封的秘密。

即将上线……

· Game Announcement游戏公告

告诉你游戏中发生的大事件，比如，你成为了NO.1。

即将上线……

下载SDK

访问https://developer.openxlive.com/ 点击“Install SDK”按钮下载OpenXLive SDK.

应用

XNA Tetris WP7 俄罗斯方块

https://game.openxlive.com/page/xnatetriswp7

Puzzle Sango 华容道

https://game.openxlive.com/page/puzzlesango

引用

OpenXLive官网：https://www.openxlive.com

OpenXLive中文网：https://www.openxlive.net

OpenXLive开发者网站：https://developer.openxlive.com

OpenXLive 开发指南: https://wiki.openxlive.com/Getting-Started-with-Open-XLive.ashx

Facebook: https://www.facebook.com/openxlive

Twitter: https://twitter.com/openxlive

新浪微博: https://t.sina.com.cn/openxlive

搜狐微博 https://openxlive.t.sohu.com/

腾讯微博 https://t.qq.com/open_xlive

www.openxlive.com 

Introduction

OpenXLive connects gamers on Windows Phone 7 with a social network (SNS) platform, and enables mobile game developers to add social networking features in games with minimal development efforts, including friends, leaderboards, forum, and more. OpenXLive was developed by Fulcrum Mobile Network, Inc. Similar platforms include OpenFeint and Plus+, both of which run on iOS devices.

Background

OpenXLive enables and simplifies the development of social networking features for Windows Phone 7 XNA games. OpenXLive provides gaming community and social network user interface to be integrated into XNA games, which is not supported by Xbox Live.

<Game UI>

OpenXLive provides real gaming social networking experience, and allows gamers to share with friends their gaming achievements and status. Every gamer is provided a user homepage, where all the leaderboard scores and achievements can be looked at and shared. In the near future, Open XLive will integrate more tightly with other SNS platforms.

<User Information Page >

Open XLive provides game official websites. Individual game developers and small development teams usually have a hard time finding resources to run their game website. Game official website supported by Open XLive saves the trouble of maintaining your own website. It helps to promote your games, and collect gamer feedbacks. Game office website also provides supports on download count and online gamer count.

<Game official website>

Getting Started on OpenXLive

With the introduction of XNA and related developer tools on Windows Phone 7, it became much easier to develop games on this new mobile platform than ever before. Individual developers can now build rich and interesting games on Windows Phone 7 with shorter timeframe and less development efforts. However, there are still huge gaps in terms of user experiences compared to games from major game studios. Individual developers spend a great amount of time working on features not directly related to game contents, for example, Start-up Screen, Leaderboard, Achievement, etc. It takes even longer time and more efforts to develop and integrate SNS functionalities, such as Online Player and Cloud Storage. Research shows that such features may take longer than the development of the game itself.

Now introducing Open XLive, which makes these features available for individual game developers and small development teams, so that their games can compete with those from major game studios.

Open XLive is a cloud service providing social networking services for Windows Phone 7 games. It brings cloud and SNS features to single player games, making it possible for developers to integrate cloud services into their games. These cloud services include, but are not limited to, Leaderboard, Achievements, Online Gaming, Social Networking, and Cloud Storage. OpenFeint on iOS provides similar services to iOS devices.

Now let’s get started on how to add Open XLive services to existing XNA games.

Download and Install SDK

Before we get started, we need to install Windows Phone 7 SDK:

Visit https://create.msdn.com/en-us/home/getting_started and click on “Install Now”.

Then, we need to download the latest version of Open XLive SDK:

https://developer.openxlive.com/

In Quick Start, the second step is “Download and install Open XLive SDK”. Click on the following icon to download the latest version of Open XLive SDK.

Open XLive SDK is ZIP format. After decompression, an MSI package will be available for installation:

After installation, we can find Open XLive sample projects and development guides in Windows Start menu. It will also install Visual Studio 2010 project template for Open XLive Games. For more information about using the template, please refer to:

Tutorial 2: Using OpenXLive Wizard

https://wiki.openxlive.com/Tutorial-2-Using-OpenXLive-Wizard.ashx

XNA Projects with Open XLive

To take a quick look at what Open XLive can offer and how it’s integrated into an XNA game, you can look at the XnaTetrisWP7 project before and after integration of Open XLive.

Please use below link to download XnaTetrisWP7 Sample Code：

https://resource.openxlive.com/resource/Download/168db9c3-53de-41d4-b963-bc2ea278459d

Project before the integration:

\\XnaTetrisWP7\Begin

After the integration:

\\ XnaTetrisWP7\End

Windows Phone 7 SDK needs to be installed for any Windows Phone 7 development, including for XNA games. Here is the link to the free download:

https://create.msdn.com/en-us/home/getting_started

After the SDK is installed, we can open the corresponding XNA project .sln file using Visual Studio 2010. Using XnaTetrisWP7 as an example, we’ll see the game running in Windows Phone 7 Emulator:

It contains all the game features, but to be a successful commercial product, it’s not enough. Now we take you through the steps of adding Open XLive services in the game.

Adding References

First of all, open OpenXLive folder under Open XLive SDK, and copy the 2 files OpenXLive.dll and OpenXLive.Form.dll to your XNA project directory, for example, XnaTetrisWP7. By copying these binary files to your project, they can always be found after you copy your projects files.

Now select the project (XnaTetrisWP7) from Solution Explorer in Visual Studio 2010, right click the project name, and choose “Add Reference…” form the context menu:

In the “Add Reference” dialog, select “Browse” tab, navigate to the project folder with file OpenXLive.dll and OpenXLive.Form.dll, select the two files, and click OK:

When this is done, check the References node in Solution Explorer, you should see the two files OpenXLive.dll and OpenXLive.Form.dll under it:

Coding

After references are added to the project, we’ll add code to XNA source code. Open the .cs file for the Microsoft.Xna.Framework.Game derived class (XnaTetris.cs in XnaTetrisWP7 project).

Add namespaces for OpenXLive classes:

using OpenXLive;
using OpenXLive.Forms;

In the Game class, add an XLiveFormManager member:

    public class XnaTetris : Microsoft.Xna.Framework.Game
    {
        XLiveFormManager manager;

In Initialize method in Game class, create the XLiveFormManager instance:

        protected override void Initialize()
        {
            // TODO: Add your initialization logic here
            manager = new XLiveFormManager(this, " xxxxxxxxxxxxxxxxxxx"); 
            Components.Add(manager);

            base.Initialize();
        }

Replace “xxxxxxxxxxxxx” with the Application Secret Key and assign it to APISecretKey.

Please note the second parameter in the XLiveFormManager constructor; this is what we called “API Secret Key”, a string to uniquely identify each application using Open XLive. The key can be applied on Open XLive website at https://www.openxlive.com/, and please refer to the document on how to apply on the website as well.

Now we’ll create a start-up page. Add the following lines in LoadContent method:

protected override void LoadContent()

        protected override void LoadContent()
        {
            // ...
            XLiveStartupForm form = new XLiveStartupForm(this.manager);
            form.Show();
            // ...
       }

Then we need to change the Update method. To prevent XNA game from quitting when user presses the Back button, comment out the following lines:

        // Allows the game to exit
        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
            this.Exit();

And add the highlighted lines:

        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            //if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
            //    this.Exit();

            // Allows the game to Pause
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
            {
                if (manager.IsRunning)
                {
                    XLiveFormFactory.Factory.ShowForm("Pause");
                }
            }

            if (manager.IsRunning)
            {
                // TODO: Add your update logic here
                UpdateTouchPanel();

                if (GameUsedGrid.GetfStarted && !fPause)
                {
                    GameUsedGrid.IncreaseTimeRecord(1);
                    if (GameUsedGrid.GetiTimeRecord == LevelTime[(GameUsedGrid.GetiLevel - 1) % 10])
                    {
                        GameUsedGrid.ResetTimeRecord();
                        GameUsedGrid.MoveDown();
                    }
                }
            }

            base.Update(gameTime);
        }

The first piece of code prevents the game from quitting when user presses Back button; rather, it will show a Pause screen. The second piece of code allows the game update logic to be executed only when XLiveFormManager.IsRunning is True.

Finally, we add similar logics into Draw method:

        protected override void Draw(GameTime gameTime)
        {
            if (manager.IsRunning)
            {

                GraphicsDevice.Clear(Color.CornflowerBlue);

                // TODO: Add your drawing code here
                spriteBatch.Begin();

                // ...

                spriteBatch.End();
            }

            base.Draw(gameTime);
        }

Now we can build and run the XNA project with Open XLive. And a nice beautiful background image would make it even more attractive.

Adding Background Image

Open XLive start-up UI supports any background image size, and it also supports animated background. If you would like to have background image animated, image size should be larger than 800x480 (landscape) or 480x800 (portrait). Please make sure the images used in background are legitimately licensed. Please follow the following guidelines for choosing background images.

Now we’ve picked a background image for XnaTetrisWP7, we can add it to the project. From Solution Explorer in Visual Studio 2010, select Content project (XnaTetrisWP7Content in the sample), right click and select “Add” -> “Existing Item”.

We place the background image into the Images folder. You can choose another folder as you prefer, and you should use the correct path when Content is loaded.

Now we will modify LoadContent method and changed the instantiation of XLivStartupForm to the following:

            Texture2D Startup = Content.Load<Texture2D>(@"Images\MyBackground");

            XLiveStartupForm form = new XLiveStartupForm(this.manager);
            form.Background = Startup;
            form.BackgroundAnimation = true;
            form.AnimationSpeed = 5;
            form.Show();

In this code, image is first loaded with ContentManager, and then assigned to XLiveStartupForm instance. To support animation, BackgroundAnimation property is set to true. Please note that the size of background image needs to be larger than the display area if BackgroundAnimation property is set to true. AnimationSpeed property is set to 5 (default value is 5).

We can now run our game by pressing F5. Pressing “New Game” will enter game UI:

What’s the next?

We’ve learned how to add Open XLive features to existing XNA games. Next, we’ll create a new Open XLive game using Visual Studio 2010 Open XLive template.

https://wiki.openxlive.com/Tutorial-2-Using-OpenXLive-Wizard.ashx

Reference

OpenXLive Website

https://www.openxlive.com/

OpenXLive Developer Website

https://developer.openxlive.com/

Getting Started with Open XLive

https://wiki.openxlive.com/Getting-Started-with-Open-XLive.ashx

作者：马宁

最近Windows Phone 7很火，Windows Phone 7的Marketplace也很火，开发者们都想趁Marketplace中应用数量还不算多的时候，抢占制高点。对于如何在Marketplace中发布软件的过程，相信大家都有所了解，我只是结合微软的官方流程，将自己的经验、教训写出来，希望能够节省开发者的时间。毕竟测试失败一次，就要耽误三至四天，同类的软件可能就会抢占先机。

至于Marketplace申请帐号的问题，我的经验可能无法给你什么实质性的帮助，所以请大家参考Jake Lin的文章《注册Windows Phone Marketplace经验》：

https://www.cnblogs.com/procoder/archive/2010/12/13/Windows-Phone-Marketplace.html

第一步：编译XAP

Visual Studio 2010每次编译后，会自动生成XAP文件，大家可以在工程文件的Bin目录下找到，千万记得要 Build一个Release版的出来。提交Debug版可能会造成很多意想不到的错误。

在编译XAP前，记得替换两个文件：Background.png(173x173)和GameThumbnail.png(64x64)。将这两个图片替换成与你的软件主题有关的图片，绝对不要使用默认提供的图片。这两个文件的长宽是有限制的，我们稍后会详细解释。

第二步：准备发布资料

很多开发者会以为写完了程序，编译出XAP就可以发布了。其实不是这样，建议大家在做提交前，还是仔细阅读一下微软的《App Hub Application Submission Walkthrough》：

https://create.msdn.com/en-US/home/about/app_submission_walkthrough_upload

下面是我总结出来的文件列表，大家可以逐项核对：

1. XAP文件(Release版，已经替换Background.png和GameThumbnail.png)

2. 应用程序名称(必须是Marketplace唯一的，所以做好改名准备)

3. 应用程序标题(显示在Marketplace和开始菜单里，最好不要超过16个字符)

4. 详细描述：

描述软件的主要功能、如何使用等情况。对于中国开发者来说，如果你的软件界面中主要使用了中文，必须在描述中用英文在首要位置上说明，并且提供英文、中文的两种描述，缺一不可。

5. 关键字（方便用户搜索，不多做解释了）

6. App tile

软件图标，三种尺寸的相同图片：173x173，99x99，200x200。图片尺寸必须是规定格式，系统不会为你做裁剪，所以要提前准备好，省得到时候抓狂。图片必须采用PNG格式。

7. Background art

可选项，Zune应用程序里的背景图，尺寸1000x800，可以提高软件的吸引力。

8. Screenshots

软件截图，至少一张，最多8张。尺寸是480x800。因为要竖着显示软件截图，所以横屏显示的软件要考虑好对策。

9. 软件价格

Tips

1， 建议将以上提到的资料放在一个文件夹里，文字资料则放到一个文本中。因为提交时要进行修改，存放到文本中便于保存和记录；

2， 三种尺寸的App Tile文件名保存为173x173.png，99x99.png，200x200.png；

3， 第一步中提到的Background.png(173x173)和GameThumbnail.png(64x64)，应和App Tile对应尺寸的文件一致。

第二步：软件提交过程

1. Upload Your Application

这一步要填写的是软件的基本信息。需要注意的是这几项内容：

Application Name：必须是Marketplace唯一，我一般的做法是将Application Title中的空格去掉，比如“My First Game”的Application Name为“MyFirstGame”或“My_First_Game”

Application Platform：废话，当然是Windows Phone 7

Default language：目前支持English(International)、English、French、German、Italian和Spanish，作为中国开发者，我们别无选择，只能选English(International)

Version：版本号

Application package：XAP软件包

在选择XAP软件包后，还会有几个选项，主要是提供软件验证过程中的信息。我们可以简单忽略掉。

Tips：XAP的上传是在你点击Next之后开始的，由于目前Marketplace系统还不稳定，所以经常会看到一个Exception出来(可怜的ASP.NET啊，连个Try-catch都没加)。别害怕，多试几次，直到没有异常了，再进入下一步。

2. Provide the Application Description

这部分提交的主要是文字部分，我们会结合提交内容和Zune、Marketplace的情况一起来看。

Application title：软件标题，会出现在四种情况下：Zune的应用程序列表中，Zune的应用程序详情中，Marketplace的列表中，Marketplace的详情中。由于WP7不能截图，Marketplace的图就请大家自己想象吧。

大家会发现，在Zune的列表里，由于Application title字体很小，所以图标的作用要远远大于标题。

而在Marketplace里，如果标题过长，最后的部分会被截断，什么是合适的长度？16个字符以下。下面这些都是好名字：Google Search、Send to WP7、Flight Control……

Category：分类，比较大的分类比如Game下，还会有Sub-category。建议大家在提交前，先看看Marketplace中同类软件或近似软件的分类，与他们放在在同一个分类里，会产生群聚效应。

Detailed description：详细描述，我提交失败就是坏在这一步上。所以再次提醒：如果你的软件界面中主要使用了中文，必须在描述中用英文在首要位置上说明，并且提供英文、中文的两种描述，缺一不可。

后边的optional就不多说了，主要是各种游戏分级的认证。

需要特别说一下的是Legal URL，很多开发者认为这是软件的主页，其实是法律文件的链接，会在安装时显示，如果你的软件有一些特殊的法律问题需要说明，比如涉及成人内容，最好还是提供一下，避免潜在的法律风险。

Zune的应用程序列表

3. Upload the artwork

这一步主要是美工的业务领域了，没有美术细胞的程序员们先找地方哭一会儿去。我挨个解释图片的。

Large mobile app tile

尺寸：173 x 173 x 96DPI。格式：PNG。当应用程序被显示到Start界面上时，需要显示的图标，如下图：

Small mobile app tile

尺寸：99 x 99 x 96DPI。格式：PNG。当应用程序在Application List中显示时，所需要的图标，如下图：

Large PC app tile

尺寸：200 x 200 x 96DPI。格式：PNG。当应用程序在Zune的软件列表中显示时，所需要的图标。见上图“Zune的应用程序列表”。

Background art

可选项。尺寸：1000 x 800 x 96DPI。格式：PNG。在Marketplace中作为软件背景显示的图片。目前使用Background art的软件不多，名气最大的是Flight control，如下图：

Screenshots

屏幕截图，尺寸：480 x 800 x 96DPI。格式：PNG。至少有一张，最多8张。大家请注意，屏幕截图是竖着显示的，对于横屏的软件来说，需要想个办法，让用户看起来舒服一些。

最后我们用一张图，来说明一下，填写的各种信息，最后在Zune上是如何显示的。

4. Set the Application Pricing

这一页我没有太多经验，因为没提交过收费软件。两个需要注意的地方：

Trial supported：是否支持验证版，免费软件不需要

Worldwide distribution：是否支持全球发布

5. Submit Your Application

最后一步，记得要选上“Automatically publish To Marketplace after passing certification”，测试过程完成后，会自动发布到Marketplace上。

第三步：错误报告

在提交之后，我们可以在APP HUB的my dashboard里看到整个测试流程的进展。

如果看到status里，状态是Testing failed，那就要赶紧去看看View details里的情况。

进入Detail页面，我们能看到软件提交状态，在Action里选择View test results，会下载一个pdf文件，里边会有一个非常详细的测试报告。如果熟悉微软BUG管理系统的人，会觉得格式很眼熟。

最后说一句，你的软件已经提交到Marketplace中，你想升级的话，在Action里会有“Submit application update”选项。

写到最后

好了，絮絮叨叨说这么多，希望大家能够对Marketplace软件发布的有足够的认识，毕竟，Marketplace玩的是注意力经济，再好的软件也要有好看的外表才能吸引人。

目前我的帐户主要想发布一些自己写的小东西，一个帐户有五个免费软件提交的名额，除去自己要用的，还剩两三个免费软件提交机会。如果大家找不到发布渠道，可以通过博客园、CSDN的站内信联系我(aawolf)，我可以帮大家提交。

示例代码下载地址：

WP7_aawolf_IronRubyWP7.rar

写这篇BLOG完全是因为看了MSDN上的这篇文章：

https://msdn.microsoft.com/en-us/magazine/ff960707.aspx

Windows Phone 7的开发工具不支持动态语言，所以IronRuby支持Windows Phone 7就显得格外重要了。刚看这篇文章的时候，还闹了个笑话，看了一遍代码，一句都不认识，心想难道语言换到.NET上，变化怎么这么大？仔细一看，原来是Ruby，而不是Python ^_^，小蟒蛇这次落后了。以前用Python写过自动化测试脚本，没接触过Ruby，所以，把Ruby看成Python了。

不支持动态语言，一直是Windows Mobile编程的痛，这次终于有搞头了。终于可以动态改变程序的逻辑了，光这一点就给我们提供了无限的想象空间。Windows Phone上的F#也快了吧？^_^

言归正传，这次我完全是照葫芦画瓢，只是将自己尝试中的一些关键点写出来，让大家少走弯路。更多信息大家可以参考Shay Friedman的BLOG：https://ironshay.com/

首先，我们要下载IronRuby for Windows Phone版本（.NET 3.5）：

https://ironruby.codeplex.com/releases/view/43540#DownloadId=133276

然后，在Visual Studio 2010中创建一个Silverlight for Windows Phone 7的工程，工程名叫做“IronRubyWP7”，然后选择“Project”菜单的“Add Reference”选项，在弹出的对话框中，选择“Browse”标签，我们可以找到解压后的IronRuby目录，将\silverlight\bin中的DLL文件加入到工程中来：

在忽略一些警告提示之后，程序集将被加入到工程中。我们可以在Solution Explorer中看到刚被加入的程序集：

接下来，我们在工程中添加一个文本文件，在Solution Explorer中选中IronRubyWP7，右键，“Add”-“New Item”，在对话框中选择“Text File”，将文件名改为“MainPage.rb”。

选中MainPage.rb文件，在属性中将“Build Action”设置为“Embedded Resource”。

我们打开MainPage.rb文件，输入下面的Ruby代码：

# Include namespaces for ease of use

include System::Windows::Media

include System::Windows::Controls

# Set the titles

Phone.find_name("ApplicationTitle").text = "aawolf.cnblogs.com"

Phone.find_name("PageTitle").text = "IronRuby& WP7"

# Create a new text block

textBlock = TextBlock.new

textBlock.text = "IronRuby is running on Windows Phone 7!"

textBlock.foreground = SolidColorBrush.new(Colors.Green)

textBlock.font_size = 48

textBlock.text_wrapping = System::Windows::TextWrapping.Wrap

# Add the text block to the page

Phone.find_name("ContentPanel").children.add(textBlock)

请注意，我修改了最后一行的容器控件名称，原示例中的名称是“ContentGrid”，但是Silverlight for Windows Phone向导默认创建的XAML文件中容器类名称是“ContentPanel”。这里会引起一个运行期错误，因为IronRuby不能Debug，所以第一次调试起来比较痛苦。

接下来，我们要打开MainPage.xaml.cs文件，将IronRuby初始化代码，加入到MainPage类的构造函数中：

    public partial class MainPage : PhoneApplicationPage
    {
        // Constructor
        public MainPage()
        {
            InitializeComponent();

            // Allow both portrait and landscape orientations
            SupportedOrientations = SupportedPageOrientation.PortraitOrLandscape;

            // Create an IronRuby engine and prevent compilation
            ScriptEngine engine = Ruby.CreateEngine();

            // Load the System.Windows.Media assembly to the IronRuby context
            engine.Runtime.LoadAssembly(typeof(Color).Assembly);

            // Add a global constant named Phone, which will allow access to this class
            engine.Runtime.Globals.SetVariable("Phone", this);

            // Read the IronRuby code
            Assembly execAssembly = Assembly.GetExecutingAssembly();
            Stream codeFile =
              execAssembly.GetManifestResourceStream("IronRubyWP7.MainPage.rb");
            string code = new StreamReader(codeFile).ReadToEnd();

            // Execute the IronRuby code
            engine.Execute(code);
        }
    }

请大家注意InitializeComponent方法的位置，在初始化IronRuby运行时之前，一定要先完成控件初始化的工作，这是我血和泪的教训。另外一个需要注意的地方，就是读取Ruby文件的路径。我们似乎也可以通过HttpRequest获取一个Stream是吧？笑而不语 ^_^

最后运行的效果是这样子的，整个开发过程历时两小时：

相关资源

马宁的Windows Phone 7开发教程（1）——Windows Phone开发工具初体验

马宁的Windows Phone 7开发教程（2）——Windows Phone XNA 4.0 3D游戏开发

马宁的Windows Phone 7开发教程（3）——XNA下使用MessageBox和软键盘

马宁的Windows Phone 7开发教程（4）——XNA显示中文字体