在移动平台上使用Azure Media Services (AMS) 的第一大难点就是对于iOS, Android,Windows Store 或Windows Phone app,没有可以直接使用的AMS SDK，也没有相应的移动应用使用媒体服务的code 样例；此外，各个移动平台拥有不同的开发环境与开发语言，那是否意味着需要分别去学习objective-c/swift, java,C#/VB.Net等才能完成整个方案? 而且该过程所耗费的时间及成本都不低。虽然困难重重，但是我们还是有机会的：一是媒体服务提供了可供所有平台调用的REST APIs；二是Xamarin的出现为我们解决了高效开发跨平台应用的难题，当然Cordova也是一个选择；三是媒体服务有相应的.Net code 样例供参考使用。（总结如下图所示）                                           

基于AMS REST APIs和Xamarin, 整个方案如下图所示，主要分为移动客户端和媒体服务端，首先移动客户端负责将原始媒体文件上传到云端，再让媒体服务完成编码、流媒体发布等任务，最后再由客户端播放使用。那么针对不同的客户端，是不是就需要3个开发团队完成各自平台的项目开发及维护、修正等，有没有一种一次编写、到处运行的方案呢？

 Xamarin为我们解决了高效开发的难题，开发者基于Visual Studio, 使用C#便可同时开发出iOS, Android, Windows Phone和Windows Store App。如下图所示，Xamarin 由Mono .net framework开源项目的创始人创办，基于微软.Net Framework, 将 3大移动平台的SDK APIs 100%的移植成C#类库，由于拥有共同的类库，因此各个平台的项目可以共享与平台无关的code，如使用web service，当然每个平台也有其独特性，如UI 控件，只不过都是通过C#及描述性语言如XAML,XML活XIB实现。

基于以上信息，在共享项目code里使用媒体服务，各个移动平台再使用对应的流媒体播SDK API即完成整个方案的设计。

基于REST APIs使用媒体服务的详细过程在前面的系列文：基于Windows Azure Media Service REST API 进行Windows Store/Windows Phone 应用开发系列1,2,3,4,5 进行了详细的介绍，代码基本上可以直接复用（基于System.Net.Http. HttpClient ），只是有些响应的返回内容的解析，在Xamarin中使用System.Linq.XDocument 类；此外，在上传媒体文件时（如下代码所示），不再使用Windows Runtime 的Windows.Storage.StorageFolder 类（高亮显示部分），由于上传过程使用的是Stream类型的数据且Xamarin支持System.IO.Stream 类，所以可以在各个平台独立地读取video为System.IO.Stream 类型，再传给share code操作 ；PCL Storage extension可以进行文件系统的读取，类似于Windows.Storage.StorageFolder的作用。

            HttpClientHandler handler = new HttpClientHandler { MaxRequestContentBufferSize = 10000000 };

            HttpClient httpClient = new HttpClient(handler);              

            httpClient.DefaultRequestHeaders.Add("x-ms-version", "2011-08-18");

            httpClient.DefaultRequestHeaders.Add("x-ms-date", "2011-01-17");

            httpClient.DefaultRequestHeaders.Add("x-ms-blob-type", "BlockBlob");          

           StorageFolder library = Windows.Storage.KnownFolders.VideosLibrary;          

            var videoFile = await library.GetFileAsync(MediaFileName);

            var props = await videoFile.GetBasicPropertiesAsync();

            var stream = await videoFile.OpenStreamForReadAsync();

            ContentSize = props.Size;

            StreamContent streamContent = new StreamContent(stream, (int)props.Size);

            HttpResponseMessage response = await httpClient.PutAsync(uploadUrl, streamContent);

在使用模拟器进行测试时，可以直接使用System.Reflection.Assembly 类中的API读取项目中的资源，将读取的Stream传给share code 即可。

var assembly = Assembly.GetExecutingAssembly();

var resourceName = "iStream.Droid.Assets.FromAndroid.wmv";        

Stream videoStream = assembly.GetManifestResourceStream(resourceName);

在MERGE过程中，Xamarin中使用的System.Net.HttpWebRequest 类型的request没有GetRequestStreamAsync() 及GetResponseAsync() 函数，为便于操作，为HttpWebRequest添加扩展方法：

public static class HttpWebRequestExtensions

   {

       public static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request)

         {

             var tcs = new TaskCompletionSource<Stream>();

             try

             {

                 request.BeginGetRequestStream(iar =>

               {

                    try

                    {

                       var response = request.EndGetRequestStream(iar);

                       tcs.SetResult(response);

                   }

                    catch (Exception exc)

                  {

                       tcs.SetException(exc);

                   }

               }, null);

           }

            catch (Exception exc)

           {

               tcs.SetException(exc);

           }

           return tcs.Task;

      }

       public static Task<HttpWebResponse> GetResponseAsync(this HttpWebRequest request)

        {

           var tcs = new TaskCompletionSource<HttpWebResponse>();

           try

          {

              request.BeginGetResponse(iar =>

             {

                  try

                   {

                      var response = (HttpWebResponse)request.EndGetResponse(iar);

                      tcs.SetResult(response);

                  }

                  catch (Exception exc)

                   {

                      tcs.SetException(exc);

                  }

              }, null);

           }

            catch (Exception exc)

          {

              tcs.SetException(exc);

          }

            return tcs.Task;

      }

    }

 以上就是关于跨移动平台使用媒体服务制定自适应流媒体点播方案的介绍，通过对Xamarin及媒体服务 REST APIs的研究与编程实现，扩展了媒体服务在移动平台的运用，也极大地提高了开发效率，同时，该方案还可适用于其他基于REST API的服务，制定跨多平台的开发方案。

微软的云平台媒体服务为流媒体服务提供了多种选择，在使用流媒体服务为企业做流媒体方案时，首先需要确认要流媒体接收目标，如针对广大iOS, Android移动设备，由于它们都支持HLS 格式的流媒体，微软平台支持smooth streaming 格式，基于该认知，比较推荐的是使用动态封装，但是必须额外添加流式处理单元，方法是在Azure 门户，点击媒体服务，然后点击所使用的媒体服务，选择流式处理端点标签页，选择需要编辑的流媒体端点，然后再缩放标签页下设置，如下截图所示：

 使用动态封装制定支持Windows, iOS, Android 平台的视频点播方案的流程如下截图所示：原始媒体文件——>转码为MP4文件——>使用动态封装功能，按照客户端需求提供流媒体码流, 构造流媒体地址——>测试。

 此外我们还可以在编码过程中为视频创建缩略图, 需要使用到相应的配置文件Thumbnail_Configuration.xml，内容如下：

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

<Thumbnail Size="100%,*" Type="Jpeg" Filename="{OriginalFilename}_{Size}_{ThumbnailTime}_{ThumbnailIndex}_{Date}_{Time}.{DefaultExtension}">

    <Time Value="10%" Step="10%" Stop="95%"/>

</Thumbnail>

整个代码流程可以参考如下：（使用流媒体服务.Net SDK，注意指定媒体服务的账号名字(accName)及key(accKey)）

class Program

    {

        private static string accName = "[MediaService_accountName]";

        private static string accKey = "[MediaService_accountKey]";      

        private static readonly string _supportFiles =

            Path.GetFullPath(@"../..\..\..\..\");

        // Paths to support files (within the above base path).

        // provide paths to your own media files below to run.

        private static readonly string singleInputFilePath =

            Path.GetFullPath(_supportFiles + @"\azure.wmv");

        private static readonly string outputPath = _supportFiles;

        private static CloudMediaContext context;

        private static readonly string configFilePath = Path.GetFullPath(_supportFiles + @"\Thumbnail_Configuration.xml");

        static void Main(string[] args)

        {

            context = new CloudMediaContext(accName, accKey);

            string inputAssetId = CreateAssetAndUploadFile(context);

            //thumbnail

            IJob jobThumb = ThumbnailMaker(context, inputAssetId);

            string thumbnailUri = GetThumbnailUrl(context, jobThumb.OutputMediaAssets[0]);

            //encode to MP4

            IJob job = EncodeToMp4(context, inputAssetId);

            IAsset mp4Output = job.OutputMediaAssets.FirstOrDefault();                     

            //Dynamic Packaging

            var mp4Asset = job.OutputMediaAssets.FirstOrDefault();

            string mp4Url = GetDynamicStreamingUrl(context, mp4Asset.Id, LocatorType.Sas);

            string smoothStreamingUrl = GetDynamicStreamingUrl(context, mp4Asset.Id, LocatorType.OnDemandOrigin);

            string hlsStreamingUrl = smoothStreamingUrl + "(format=m3u8-aapl)";

            string mpegdashStreamingUrl = smoothStreamingUrl + "(format=mpd-time-csf)";

            //Output

            string content = "\n Thumbnail Url:    \n" + thumbnailUri

                              +"\n Mp4 Url:    \n" + mp4Url

                              + "\n Dynamic Packaging Smooth Url: \n" + smoothStreamingUrl

                              +"\n Dynamic Packaging HLS Url:    \n" + hlsStreamingUrl

                              +"\n Dynamic Packaging MPEG DASH Url:    \n" + mpegdashStreamingUrl;

            Console.WriteLine("\n Thumbnail Url:    \n" + thumbnailUri);

            Console.WriteLine("\n Mp4 Url:    \n" + mp4Url);

            Console.WriteLine("\n Smooth Url: \n" + smoothStreamingUrl);

            Console.WriteLine("\n HLS Url:    \n" + hlsStreamingUrl);

            Console.WriteLine("\n MPEG DASH Url:    \n" + mpegdashStreamingUrl);

            string outFilePath = Path.GetFullPath(outputPath + @"\" + "StreamingUrl.txt");

            WriteToFile(outFilePath, content);

            Console.ReadKey();

            Console.ReadKey();

        }

        private static string CreateAssetAndUploadFile(CloudMediaContext context)

        {

            var assetName = Path.GetFileNameWithoutExtension(singleInputFilePath);

            var inputAsset = context.Assets.Create(assetName, AssetCreationOptions.None);

            var assetFile = inputAsset.AssetFiles.Create(Path.GetFileName(singleInputFilePath));

            assetFile.UploadProgressChanged += new EventHandler<UploadProgressChangedEventArgs>(assetFile_UploadProgressChanged);          

            assetFile.Upload(singleInputFilePath);

            return inputAsset.Id;

        }

        static void assetFile_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)

        {

            Console.WriteLine(string.Format("{0}   Progress: {1:0}   Time: {2}", ((IAssetFile)sender).Name, e.Progress, DateTime.UtcNow.ToString(@"yyyy_M_d__hh_mm_ss")));

        }

        private static IJob EncodeToMp4(CloudMediaContext context, string inputAssetId)

        {

            var inputAsset = context.Assets.Where(a => a.Id == inputAssetId).FirstOrDefault();

            if (inputAsset == null)

                throw new ArgumentException("Could not find assetId: " + inputAssetId);         

            var encodingPreset = "H264 Adaptive Bitrate MP4 Set 720p";          

            IJob job = context.Jobs.Create(".Net Encoding  " + inputAsset.Name + " to MP4 job");

            IMediaProcessor latestWameMediaProcessor = (from p in context.MediaProcessors where p.Name == "Windows Azure Media Encoder" select p).ToList()

                                                                         .OrderBy(wame => new Version(wame.Version)).LastOrDefault();

            ITask encodeTask = job.Tasks.AddNew(".Net Encoding to Mp4 Task ", latestWameMediaProcessor, encodingPreset, TaskOptions.None);

            encodeTask.InputAssets.Add(inputAsset);

            encodeTask.OutputAssets.AddNew(inputAsset.Name + " as " + " mp4 output asset", AssetCreationOptions.None);

            job.StateChanged += new EventHandler<JobStateChangedEventArgs>(JobStateChanged);

            job.Submit();

            job.GetExecutionProgressTask(CancellationToken.None).Wait();

            return job;

        }

        static void JobStateChanged(object sender, JobStateChangedEventArgs e)

        {

            Console.WriteLine(string.Format("{0}\n  State: {1}\n  Time: {2}\n\n",

                                           ((IJob)sender).Name, e.CurrentState, DateTime.UtcNow.ToString(@"yyyy_M_d__hh_mm_ss")));

        }

        static void WriteToFile(string outFilePath, string fileContent)

        {

            StreamWriter sr = File.CreateText(outFilePath);

            sr.Write(fileContent);

            sr.Close();

        }

        private static string GetDynamicStreamingUrl(CloudMediaContext context, string outputAssetId, LocatorType type)

        {

            var daysForWhichStreamingUrlIsActive = 365;

            var outputAsset = context.Assets.Where(a => a.Id == outputAssetId).FirstOrDefault();

            var accessPolicy = context.AccessPolicies.Create(outputAsset.Name,

                                                             TimeSpan.FromDays(daysForWhichStreamingUrlIsActive),

                                                             AccessPermissions.Read | AccessPermissions.List);

            var assetFiles = outputAsset.AssetFiles.ToList();

            if (type == LocatorType.OnDemandOrigin)

            {

                var assetFile = assetFiles.Where(f => f.Name.ToLower().EndsWith(".ism")).FirstOrDefault();

                if (assetFile != null)

                {

                    var locator = context.Locators.CreateLocator(LocatorType.OnDemandOrigin, outputAsset, accessPolicy);

                    Uri smoothUri = new Uri(locator.Path + assetFile.Name + "/manifest");

                    return smoothUri.ToString();

                }

            }

            if (type == LocatorType.Sas)

            {

                var mp4Files = assetFiles.Where(f => f.Name.ToLower().EndsWith(".mp4")).ToList();

                var assetFile = mp4Files.OrderBy(f => f.ContentFileSize).LastOrDefault(); //Get Largest File

                if (assetFile != null)

                {

                    var locator = context.Locators.CreateLocator(LocatorType.Sas, outputAsset, accessPolicy);

                    var mp4Uri = new UriBuilder(locator.Path);

                    mp4Uri.Path += "/" + assetFile.Name;

                    return mp4Uri.ToString();

                }

            }

            return string.Empty;

        }

        private static IJob ThumbnailMaker(CloudMediaContext context, string inputAssetId)

        {

            var inputAsset = context.Assets.Where(a => a.Id == inputAssetId).FirstOrDefault();

            if (inputAsset == null)

                throw new ArgumentException("Could not find assetId: " + inputAssetId);

            IMediaProcessor latestWameMediaProcessor = (from p in context.MediaProcessors where p.Name == "Windows Azure Media Encoder" select p).ToList()

                                                                         .OrderBy(wame => new Version(wame.Version)).LastOrDefault();

            //thumbnail

            //Get thumbnail configuration from a XML file

            var ThumbnailConfig = File.ReadAllText(configFilePath);

            // Create a job

            IJob jobThumbnail = context.Jobs.Create("Thumbnail job Thumbnail Making " + inputAsset.Name);

            //Create a task

            ITask thumbnailTask = jobThumbnail.Tasks.AddNew("Thumbnail task",

                latestWameMediaProcessor,             

                ThumbnailConfig,

                TaskOptions.None);

            thumbnailTask.InputAssets.Add(inputAsset);

            thumbnailTask.OutputAssets.AddNew(inputAsset.Name + " as Thumbnail job", AssetCreationOptions.None);

            jobThumbnail.StateChanged += new EventHandler<JobStateChangedEventArgs>(JobStateChanged);

            jobThumbnail.Submit();

            jobThumbnail.GetExecutionProgressTask(CancellationToken.None).Wait();

            return jobThumbnail;

        }

        private static string GetThumbnailUrl(CloudMediaContext context, IAsset outputAsset)

        {           

            var output = outputAsset;

            var accessPolicy = context.AccessPolicies.Create("Read Policy", TimeSpan.FromDays(10), AccessPermissions.Read);         

            var locator = context.Locators.CreateSasLocator(output, accessPolicy);

            var primaryFile = (from a in output.AssetFiles

                               where a.IsPrimary == true

                               select a).FirstOrDefault();

            return locator.BaseUri + '/' + primaryFile.Name + locator.ContentAccessComponent;

        }

    }

最终我们可以获得编码后的视频缩略图地址、MP4 文件地址（可以直接用于网页，使用Video tag）、Smooth Streaming, HLS, MPEG-DASH地址：

Thumbnail URL: https://myappsstorage.blob.core.windows.net/asset-e157385d-1500-80c2-af19-f1e4cbb3271f/azure_1280x720_00.00.00.6346000_1_3-16-2015_8.06%20AM.jpg?sv=2012-02-12&sr=c&si=804d04b5-3450-4d00-9ed8-8d16913c2330&sig=n7chFUFuHRA3R9RMpknxvFBkCbsG2kDgx0VWd6AJfiE%3D&se=2015-03-26T08%3A06%3A18Z

MP4 URL: https://myappsstorage.blob.core.windows.net:443/asset-e157385d-1500-80c2-9cfd-f1e4cbb3517b/azure_H264_3400kbps_AAC_und_ch2_96kbps.mp4?sv=2012-02-12&sr=c&si=150c9ab8-a78c-4557-aab8-1deba001a998&sig=pcl58cJgJ8lxRPSic4tM0us5wMSON8MIEUPDZBsXa3Y%3D&se=2016-03-15T08%3A07%3A30Z

Smooth Streaming URL:   https://test20140404.origin.mediaservices.windows.net/e5b3f1e4-a662-41da-b8af-4423aaea492b/azure.ism/manifest

HLS：https://test20140404.origin.mediaservices.windows.net/e5b3f1e4-a662-41da-b8af-4423aaea492b/azure.ism/manifest(format=m3u8-aapl)

MPEG-DASH: https://test20140404.origin.mediaservices.windows.net/e5b3f1e4-a662-41da-b8af-4423aaea492b/azure.ism/manifest(format=mpd-time-csf)

自适应流媒体的最大的特征是根据客户端的网络带宽情况自适应地选择对应码流媒体内容进行传输，保证流畅的视频播放体验，因此需要特殊的客户端播放器。对于这3种常用的流媒体格式，可以使用如下播放器进行测试：

Smooth Streaming player: https://smf.cloudapp.net/healthmonitor

HLS: JW player: https://www.jwplayer.com/partners/azure/

MPEG-DASH player: https://dashplayer.azurewebsites.net/

更多关于微软云平台的媒体服务的使用实践内容，将在后续文章中介绍，敬请期待！

使用流式处理单元需要支付一定的费用，且最小单元就是200mbps，根据文档Windows Azure Media Services Pricing Details内容引用如下，我们可以计算出：在使用1个流式处理单元，使用H264 Adaptive Bitrate MP4 Set 720p（范围从 3400 kbps 到 400 kbps）编码方式的情况下，同时可以观看流媒体的客户端个数约为47 个（160/3.4）。

“Question: How do I estimate # of on-demand streaming reserved unit I need?

Answer: For the most conservative estimate you can go directly with SLA limitations - i.e. total bandwidth is 160 Mbps * # of RU’s. To obtain an initial estimate you can take the # of concurrent customers * top bitrate that you are encoding video at. For most video business, I think it is always better to be conservative first and if you end up over provisioning, you could always reduce # of reserved unit.

”

那么如果仅针对少数客户端，可能总数达不到47个，那么出于节省开支的目的，我们还有其他方法吗？答案是肯定的，本文将详细介绍该方案。

针对iOS, Android 客户端，同时观看的客户端数比较少的点播情况下，我们可以使用静态封装方法将编码后的文件包装成HLS即可，这样就可以不使用流式处理单元，需要注意的是，由于Microsoft Azure Media Packager 和 Microsoft Azure Media Encryptor 将在 2015 年 11 月 1 日终结使用，所以本文方案在此日期之后不推荐使用。

在封装为HLS格式之前，必须先将媒体文件转码成smooth streaming 格式，再使用“Windows Azure Media Packager”将其封装为HLS，然后再在iOS 设备和Android 设备上使用自带的浏览器测试HLS 格式的流媒体URL。所以整个流程为：

原始媒体文件——>转码为MP4文件——>将MP4编码为SmoothStreaming 格式——>将SmoothStreaming格式输出封装为HLS格式——>获取静态HLS流媒体URL——>设备测试

需要使用到2个配置文件：

1. 1.       MP4转为smooth streaming 格式的配置文件：MediaPackager_MP4ToSmooth.xml，内容如下：

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

<taskDefinition xmlns="https://schemas.microsoft.com/iis/media/v4/TM/TaskDefinition#">

  <name>MP4 to Smooth Streams</name>

  <id>5e1e1a1c-bba6-11df-8991-0019d1916af0</id>

  <description xml:lang="en" />

  <inputFolder />

  <properties namespace="https://schemas.microsoft.com/iis/media/V4/TM/MP4ToSmooth#" prefix="mp4">

    <property name="keepSourceNames" value="false" />

  </properties>

  <taskCode>

    <type>Microsoft.Web.Media.TransformManager.MP4toSmooth.MP4toSmooth_Task, Microsoft.Web.Media.TransformManager.MP4toSmooth, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35</type>

  </taskCode>

</taskDefinition>

1. 2.       packager 配置文件MediaPackager_MP4ToSmooth.xml，内容如下：

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

<taskDefinition xmlns="https://schemas.microsoft.com/iis/media/v4/TM/TaskDefinition#">

  <name>Smooth Streams to Apple HTTP Live Streams</name>

  <id>A72D7A5D-3022-45f2-89B4-1DDC5457C111</id>

  <description xml:lang="en">Converts on-demand Smooth Streams encoded with H.264 (AVC) video and AAC-LC audio codecs to Apple HTTP Live Streams (MPEG-2 TS) and creates an Apple HTTP Live Streaming playlist (.m3u8) file for the converted presentation.</description>

  <inputDirectory></inputDirectory>

  <outputFolder>TS_Out</outputFolder>

  <properties namespace="https://schemas.microsoft.com/iis/media/AppleHTTP#" prefix="hls">

    <property name="maxbitrate" required="true" value="6600000" helpText="The maximum bit rate, in bits per second (bps), to be converted to MPEG-2 TS. On-demand Smooth Streams at or below this value are converted to MPEG-2 TS segments. Smooth Streams above this value are not converted. Most Apple devices can play media encoded at bit rates up to 1,600 Kbps."/>

    <property name="manifest" required="false" value="" helpText="The file name to use for the converted Apple HTTP Live Streaming playlist file (a file with an .m3u8 file name extension). If no value is specified, the following default value is used: &lt;ISM_file_name&gt;-m3u8-aapl.m3u8"/>

    <property name="segment" required="false" value="10" helpText="The duration of each MPEG-2 TS segment, in seconds. 10 seconds is the Apple-recommended setting for most Apple mobile digital devices."/>

    <property name="log"  required="false" value="" helpText="The file name to use for a log file (with a .log file name extension) that records the conversion activity. If you specify a log file name, the file is stored in the task output folder." />

    <property name="encrypt"  required="false" value="false" helpText="Enables encryption of MPEG-2 TS segments by using the Advanced Encryption Standard (AES) with a 128-bit key (AES-128)." />

    <property name="pid"  required="false" value="" helpText="The program ID of the MPEG-2 TS presentation. Different encodings of MPEG-2 TS streams in the same presentation use the same program ID so that clients can easily switch between bit rates." />

    <property name="codecs"  required="false" value="false" helpText="Enables codec format identifiers, as defined by RFC 4281, to be included in the Apple HTTP Live Streaming playlist (.m3u8) file." />

    <property name="backwardcompatible"  required="false" value="false" helpText="Enables playback of the MPEG-2 TS presentation on devices that use the Apple iOS 3.0 mobile operating system." />

    <property name="allowcaching"  required="false" value="true" helpText="Enables the MPEG-2 TS segments to be cached on Apple devices for later playback." />

    <property name="key"  required="false" value="" helpText="The hexadecimal representation of the 16-octet content key value that is used for encryption." />

    <property name="keyuri"  required="false" value="" helpText="An alternate URI to be used by clients for downloading the key file. If no value is specified, it is assumed that the Live Smooth Streaming publishing point provides the key file." />

    <property name="overwrite"  required="false" value="true" helpText="Enables existing files in the output folder to be overwritten if converted output files have identical file names." />

  </properties>

  <taskCode>

    <type>Microsoft.Web.Media.TransformManager.SmoothToHLS.SmoothToHLSTask, Microsoft.Web.Media.TransformManager.SmoothToHLS, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35</type>

  </taskCode>

</taskDefinition>

代码可以参考如下：（使用流媒体服务.Net SDK，注意指定媒体服务的账号名字及key）

class Program

    {

        private static string accName = "[MediaService accountName]";

        private static string accKey = "[MediaService accountKey]";

        private static readonly string _supportFiles =

            Path.GetFullPath(@"../..\..\..\..\");

        // Paths to support files (within the above base path). You can use

        // the provided sample media files from the "supportFiles" folder, or

        // provide paths to your own media files below to run these samples.

        private static readonly string singleInputFilePath =

            Path.GetFullPath(_supportFiles + @"\azure.wmv");

        private static readonly string outputPath = _supportFiles;

        private static CloudMediaContext context;

        static void Main(string[] args)

        {

            context = new CloudMediaContext(accName, accKey);

            string inputAssetId = CreateAssetAndUploadFile(context);

            //encode to MP4

            IJob job = EncodeToMp4(context, inputAssetId);

            IAsset mp4Output = job.OutputMediaAssets.FirstOrDefault();

            //convert MP4 to smooth streaming

            IJob jobSS = ConvertMP4toSmooth(context, mp4Output, mp4Output.Id);

            IAsset ssAsset = jobSS.OutputMediaAssets.FirstOrDefault();

            string SSStreamingUrlStatic = GetStaticSS(context, ssAsset.Id, LocatorType.OnDemandOrigin);

            //package ss to HLS-Static Packaging

            IJob jobHLS = SmoothToHLS(context, ssAsset.Id, ssAsset);

            var hlsAsset = jobHLS.OutputMediaAssets.FirstOrDefault();

            string hlsStreamingUrlStatic = GetStaticHLS(context, hlsAsset.Id, LocatorType.OnDemandOrigin);           

            string content = "\n Static Packaging Smooth Streaming Url:    \n" + SSStreamingUrlStatic +

                              "\n Static Packaging HLS Url:    \n" + hlsStreamingUrlStatic +

                                 "\n Mp4 Url:    \n" + mp4StreamingUrl;

            Console.WriteLine("\n Static Packaging Smooth Streaming Url:    \n" + SSStreamingUrlStatic);

            Console.WriteLine("\n Static Packaging HLS Url:    \n" + hlsStreamingUrlStatic);

            Console.WriteLine("\n Mp4 Url:    \n" + mp4StreamingUrl);

            Console.WriteLine("\n Smooth Url: \n" + smoothStreamingUrl);

            string outFilePath = Path.GetFullPath(outputPath + @"\" + "StreamingUrl.txt");

            WriteToFile(outFilePath, content);

            Console.ReadKey();

            Console.ReadKey();

        }

        private static string CreateAssetAndUploadFile(CloudMediaContext context)

        {

            var assetName = Path.GetFileNameWithoutExtension(singleInputFilePath);

            var inputAsset = context.Assets.Create(assetName, AssetCreationOptions.None);

            var assetFile = inputAsset.AssetFiles.Create(Path.GetFileName(singleInputFilePath));

            assetFile.UploadProgressChanged += new EventHandler<UploadProgressChangedEventArgs>(assetFile_UploadProgressChanged);

            assetFile.Upload(singleInputFilePath);

            return inputAsset.Id;

        }

        static void assetFile_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)

        {

            Console.WriteLine(string.Format("{0}   Progress: {1:0}   Time: {2}", ((IAssetFile)sender).Name, e.Progress, DateTime.UtcNow.ToString(@"yyyy_M_d__hh_mm_ss")));

        }

        private static IJob EncodeToMp4(CloudMediaContext context, string inputAssetId)

        {

            var inputAsset = context.Assets.Where(a => a.Id == inputAssetId).FirstOrDefault();

            if (inputAsset == null)

                throw new ArgumentException("Could not find assetId: " + inputAssetId);

            var encodingPreset = "H264 Adaptive Bitrate MP4 Set 720p";

            //var encodingPreset = "H264 Broadband 720p";

            IJob job = context.Jobs.Create(".Net Encoding  " + inputAsset.Name + " to MP4 job");

            IMediaProcessor latestWameMediaProcessor = (from p in context.MediaProcessors where p.Name == "Windows Azure Media Encoder" select p).ToList()

                                                                         .OrderBy(wame => new Version(wame.Version)).LastOrDefault();

            ITask encodeTask = job.Tasks.AddNew(".Net Encoding to Mp4 Task ", latestWameMediaProcessor, encodingPreset, TaskOptions.None);

            encodeTask.InputAssets.Add(inputAsset);

            encodeTask.OutputAssets.AddNew(inputAsset.Name + " as " + " mp4 output asset", AssetCreationOptions.None);

            job.StateChanged += new EventHandler<JobStateChangedEventArgs>(JobStateChanged);

            job.Submit();

            job.GetExecutionProgressTask(CancellationToken.None).Wait();

            return job;

        }

        private static IJob ConvertMP4toSmooth(CloudMediaContext context, IAsset assetToConvert, string inputAssetId)

        {

            var inputAsset = context.Assets.Where(a => a.Id == inputAssetId).FirstOrDefault();

            if (inputAsset == null)

                throw new ArgumentException("Could not find assetId: " + inputAssetId);

            IJob job = context.Jobs.Create("Conversion  " + inputAsset.Name + " to Smooth Streaming job");

            string smoothconfig = Path.GetFullPath(_supportFiles + @"\MediaPackager_MP4ToSmooth.xml");

string configMp4ToSmooth = File.ReadAllText(Path.GetFullPath(smoothconfig));

            IMediaProcessor LatestPackager = (from p in context.MediaProcessors where p.Name == "Windows Azure Media Packager" select p).ToList()

                                                                        .OrderBy(wame => new Version(wame.Version)).LastOrDefault();

            ITask convertTask = job.Tasks.AddNew(".Net Conversion MP4 to Smooth Streaming Task for " + inputAsset.Name,

                LatestPackager, configMp4ToSmooth, TaskOptions.None);

            convertTask.InputAssets.Add(assetToConvert);

            convertTask.OutputAssets.AddNew(".Net output-MP4 converted Smooth Streaming-" + inputAsset.Name, AssetCreationOptions.None);

            job.StateChanged += new EventHandler<JobStateChangedEventArgs>(JobStateChanged);

            job.Submit();

            job.GetExecutionProgressTask(CancellationToken.None).Wait();

            return job;

        }

        private static IJob SmoothToHLS(CloudMediaContext context, string inputAssetId, IAsset asset)

        {

            var inputAsset = context.Assets.Where(a => a.Id == inputAssetId).FirstOrDefault();

            if (inputAsset == null)

                throw new ArgumentException("Could not find assetId: " + inputAssetId);

            var conversionPreset = "HLS";

            IJob job = context.Jobs.Create("Conversion " + inputAsset.Name + " to " + conversionPreset);

            //var ssOutput = encodeTask.OutputAssets.AddNew("output-Silverlight-" + inputAsset.Name,

            //     AssetCreationOptions.None);                      

            string smooth2HLSFilePath = Path.GetFullPath(_supportFiles + @"\MediaPackager_SmoothToHLS.xml");

            var packager = context.MediaProcessors.Where(m => m.Name == "Windows Azure Media Packager").First();

            var conversionTask = job.Tasks.AddNew("Conversion Task for " + inputAsset.Name, packager,

                File.ReadAllText(smooth2HLSFilePath), TaskOptions.None);

            conversionTask.InputAssets.Add(asset);

            conversionTask.OutputAssets.AddNew(

                "output-HLS-" + inputAsset.Name, AssetCreationOptions.None);

            job.StateChanged += new EventHandler<JobStateChangedEventArgs>(JobStateChanged);

            job.Submit();

            job.GetExecutionProgressTask(CancellationToken.None).Wait();

            return job;

        }

        static void JobStateChanged(object sender, JobStateChangedEventArgs e)

        {

            Console.WriteLine(string.Format("{0}\n  State: {1}\n  Time: {2}\n\n",

                                           ((IJob)sender).Name, e.CurrentState, DateTime.UtcNow.ToString(@"yyyy_M_d__hh_mm_ss")));

        }

        static void WriteToFile(string outFilePath, string fileContent)

        {

            StreamWriter sr = File.CreateText(outFilePath);

            sr.Write(fileContent);

            sr.Close();

        }

        private static string GetStaticSS(CloudMediaContext context, string outputAssetId, LocatorType type)

        {

            var daysForWhichStreamingUrlIsActive = 365;

            var outputAsset = context.Assets.Where(a => a.Id == outputAssetId).FirstOrDefault();

            var accessPolicy = context.AccessPolicies.Create(outputAsset.Name,

                                                             TimeSpan.FromDays(daysForWhichStreamingUrlIsActive),

                                                             AccessPermissions.Read | AccessPermissions.List);

            var assetFiles = outputAsset.AssetFiles.ToList();

            if (type == LocatorType.OnDemandOrigin)

            {

                var assetFile = assetFiles.Where(f => f.Name.ToLower().EndsWith(".ism")).FirstOrDefault();

                if (assetFile != null)

                {

                    var locator = context.Locators.CreateLocator(LocatorType.OnDemandOrigin, outputAsset, accessPolicy);

                    Uri smoothUri = new Uri(locator.Path + assetFile.Name + "/manifest");

                    return smoothUri.ToString();

                }

            }

            if (type == LocatorType.Sas)

            {

                var mp4Files = assetFiles.Where(f => f.Name.ToLower().EndsWith(".mp4")).ToList();

                var assetFile = mp4Files.OrderBy(f => f.ContentFileSize).LastOrDefault(); //Get Largest File

                if (assetFile != null)

                {

                    var locator = context.Locators.CreateLocator(LocatorType.Sas, outputAsset, accessPolicy);

                    var mp4Uri = new UriBuilder(locator.Path);

                    mp4Uri.Path += "/" + assetFile.Name;

                    return mp4Uri.ToString();

                }

            }

            return string.Empty;

        }

        private static string GetStaticHLS(CloudMediaContext context, string outputAssetId, LocatorType type)

        {

            var daysForWhichStreamingUrlIsActive = 365;

            var outputAsset = context.Assets.Where(a => a.Id == outputAssetId).FirstOrDefault();

            var accessPolicy = context.AccessPolicies.Create(outputAsset.Name,

                                                             TimeSpan.FromDays(daysForWhichStreamingUrlIsActive),

                                                             AccessPermissions.Read | AccessPermissions.List);

            var assetFiles = outputAsset.AssetFiles.ToList();

            foreach (var f in assetFiles.Where(x => x.Name.EndsWith(".ism")))

            {

                if (f.Name.Contains("m3u8"))

                {

                    #region publish HLS to a WAMS origin

                    Console.WriteLine("will create a new locator for HLS");

                    var originLocator = context.Locators.CreateLocator(LocatorType.OnDemandOrigin, outputAsset, accessPolicy);

                    string urlForClientStreaming = originLocator.Path + f.Name

                        + "/manifest(format=m3u8-aapl)";

                    return urlForClientStreaming.ToString();

                    #endregion

                }

            }

            return string.Empty;

        } 

    }

最终输出如：https://test20140404.origin.mediaservices.windows.net/1dcaef59-56b1-4bf9-9dd2-8502d62d5095/azure-m3u8-aapl.ism/manifest(format=m3u8-aapl)

更多关于微软云平台的媒体服务的使用实践内容，将在后续文章中介绍，敬请期待！

本文将基于前面4篇内容进一步讲解如何对编码输出的文件进行流媒体的发布工作。

使用REST API发布流媒体，主要流程是：

1. 创建具有读取权限的AccessPolicy
2. 创建用于传输媒体内容的源URL，再在此URL上构建最终的流媒体URL

请注意，如前文所强调的在使用REST API时访问媒体服务中的实体时，必须在HTTP请求中添加如下必须的标头字段和值；WAMS 的原始服务URI 为https://media.windows.net/，成功连接到此 URI后，会收到一个“301 重定向”响应指向另一个媒体服务URI，需要从该响应中提取出新的的媒体服务URI，随后的调用都是基于该 URI，详细内容参见Part2内容。

根据文档媒体服务 REST API 开发的设置可知，每次调用WAMS时，客户端必须在请求中包括必需的标头字段和值，列表如下：

在传输任何媒体内容之前，必须先创建具有读取权限的AccessPolicy，然后创建相应的定位符地址，以便指定将要传输的流媒体类型（如微软的自适应流媒体协议smooth streaming, apple 的HLS，国际标准MPEG DASH），此处AccessPolicy的请求如前文上传文件时所用的请求类似，唯一的区别在于构造请求body内容时指定Permission=1，当然，为了以示区别，也AccessPolicy 指定不同的Name。由于文章3已做讲解，这里省略了细节实现内容。

理论上来说接下来就可以创建用于传输媒体内容的源URL了，但是在此操作之前我们需要先获取编码输出文件所在的位置，进而发布此位置中包含的文件。

执行过程可参考如下代码，返回文件所在位置：

  private async Task<string> GetOutputAssetAsync(string acsToken, string wamsEndpoint, string jobId)

        { 

            AuthenticationHeaderValue header = CreateBasicAuthenticationHeader(acsToken); 

            HttpClient httpClient = new HttpClient();

            httpClient.MaxResponseContentBufferSize = int.MaxValue; 

            httpClient.DefaultRequestHeaders.Add("Authorization", header.ToString());

            httpClient.DefaultRequestHeaders.Add("x-ms-version", "2.7");

            httpClient.DefaultRequestHeaders.Add("DataServiceVersion", "3.0");

            httpClient.DefaultRequestHeaders.Add("MaxDataServiceVersion", "3.0");

            httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));        

            string url = wamsEndpoint + "Jobs('" + WebUtility.UrlEncode(jobId) + "')/OutputMediaAssets()"; 

            var response = await httpClient.GetAsync(url); 

            string ouputId = null;

            if (response.IsSuccessStatusCode)

            {

                var content = await response.Content.ReadAsStringAsync();

                JObject jsonObject = JObject.Parse(content);

                var value = jsonObject.Value<JArray>("value");

                ouputId = value.First.Value<string>("Id"); 

                return ouputId; 

            }

            else

                return null;

        }

现在我们就可以正式创建流媒体地址了，首先创建用于传输媒体内容的源URL-locatorURL，再在此URL上构建最终的流媒体URL，操作很简单，即根据流媒体类型，添加相应的后缀内容即可：

1） Smooth streaming:  locatorURL/filename.ism/manifest

2） HLS V4: locatorURL/filename.ism/manifest(format=m3u8-aapl)

3） HLS V3: locatorURL/filename.ism/manifest(format=m3u8-aapl-v3)

4） MPEG DASH: locatorURL/filename.ism/manifest(format=mpd-time-csf)

由于此处是针对windows 平台，只支持smooth streaming, 所以以下代码仅构建smooth streaming的URL.

创建用于传输的源URL的请求简要总结如下，详情请参见：使用 Media Services REST API 传送资产

{
     "AccessPolicyId": "< AccessPolicyId >"),
           “AssetId”: “<encoded output assetId>”,

          “StartTime”: “<DateTime.UtcNow >”,

          “Type”: “2”

}

执行过程可参考如下代码，

  private async Task<string> CreateSStreamingUrlAsync(string acsToken, string wamsEndPoint, string encodingJobId)

        {

            string outputAssetId = await GetOutputAssetAsync(acsToken, wamsEndPoint, encodingJobId);

            string apID = await CreateAccessPolicyAsync(acsToken, wamsEndPoint, "DownloadPolicy", 1); 

            AuthenticationHeaderValue header = CreateBasicAuthenticationHeader(acsToken); 

            HttpClient httpClient = new HttpClient();

            httpClient.MaxResponseContentBufferSize = int.MaxValue; 

            httpClient.DefaultRequestHeaders.Add("Authorization", header.ToString());

            httpClient.DefaultRequestHeaders.Add("x-ms-version", "2.7");

            httpClient.DefaultRequestHeaders.Add("DataServiceVersion", "3.0");

            httpClient.DefaultRequestHeaders.Add("MaxDataServiceVersion", "3.0"); 

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, wamsEndPoint);

            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));   

            String requestBody = "{ \"AccessPolicyId\" : \"" + apID + "\"," +

                           " \"AssetId\" : \"" + outputAssetId + "\", " +

                           " \"StartTime\" : \"" + DateTime.UtcNow.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss") + "\", " +

                           " \"Type\" : " + "2" + "}"; 

            HttpContent body = new StringContent(requestBody, Encoding.UTF8, "application/json");

            var response = await httpClient.PostAsync(wamsEndPoint + "Locators", body); 

            string ssUrl = null; ;

            if (response.IsSuccessStatusCode)

            {

                var content = await response.Content.ReadAsStringAsync(); 

                XmlDocument xmlDoc = new XmlDocument();

                xmlDoc.LoadXml(content);

                XmlNodeList elemListBase = xmlDoc.GetElementsByTagName("d:Path");               

                foreach (var ele in elemListBase)

                {

                    ssUrl = ele.InnerText;

                }

                ssUrl = ssUrl+MediaNamewithoutExtention + ".ism/manifest";            

            } 

            return ssUrl;

        }

 同时我们可以在portal上发现出现了发布链接，且可以直接播放流媒体内容了，帮住我们检查结果。

当然做为Windows Store/Phone应用，我们需要使用特定的客户端SDK播放流媒体内容，对于Windows Store 应用，使用Microsoft Smooth Streaming Client SDK for Windows 8；对于Windows Phone 应用，使用Smooth Streaming Client SDK for Windows Phone 8.1，而且文档How to Build a Smooth Streaming Windows Store Application详细讲解了其使用过程。

通过本系列文章，我们讲解了如何在WinRT 应用中使用媒体服务，为广大用户提供自适应流媒体体验。

使用REST API对媒体文件进行编码，主要流程是：

1. 创建作业
2. 编码过程交由媒体服务完成
3. 监视处理进程

请注意，如前文所强调的在使用REST API时访问媒体服务中的实体时，必须在HTTP请求中添加如下必须的标头字段和值；WAMS 的原始服务URI 为https://media.windows.net/，成功连接到此 URI后，会收到一个“301 重定向”响应指向另一个媒体服务URI，需要从该响应中提取出新的的媒体服务URI，随后的调用都是基于该 URI，详细内容参见Part2内容。

根据文档媒体服务 REST API 开发的设置可知，每次调用WAMS时，客户端必须在请求中包括必需的标头字段和值，列表如下：

首先创建作业，每个作业可以包含一个或多个任务，具体是什么任务视处理类型而定，如将媒体文件转换为MP4文件的任务，或将MP4文件编码为smooth streaming 输出的任务，或者进行编码后的文件进行静态封装或动态封装等任务。使用REST API可以创建多个作业及其相应的任务，

此处以一个作业一个视频编码任务为例，具体的可选的编码配置可以参见Media Services Encoder 的任务预设（如常用的H264 Smooth Streaming 720p，H264 Adaptive Bitrate MP4 Set 720p）。

创建编码作业请求简要总结如下，详情请参见：使用 Media Services REST API 创建编码作业

    "__metadata":{“uri”: “https://media.windows.net/api/Assets(‘AssetID’)”}}],(注意请换为重定向后的URI)

    “Tasks”:[{

            “Configration”: “<encoding preset name>”   (如H264 Broadband 720p)

            “MediaProcessorId”: ”nb:mpid:UUID:70bdc2c3-ebf4-42a9-8542-5afc1e55d217”

            “TaskBody”: "<?xml version=\"1.0\" encoding=\"utf-8\"?>

                                      <taskBody>

                                             <inputAsset>JobInputAsset(0)</inputAsset>

                                             <outputAsset>JobOutputAsset(0)</outputAsset>

                                      </taskBody>" }]

} 

 创建编码作业的代码参考如下，其中processorId 可以直接取自MSDN 文档： nb:mpid:UUID:70bdc2c3-ebf4-42a9-8542-5afc1e55d217，或者通过发送相应的请求获得。

    private async Task<bool> EncodeSmooth(string acsToken, string assetId, string jobName, string wamsEndpoint, string processorId)

        {

            AuthenticationHeaderValue header = CreateBasicAuthenticationHeader(acsToken);

            HttpClient httpClient = new HttpClient();

            httpClient.MaxResponseContentBufferSize = int.MaxValue; 

            httpClient.DefaultRequestHeaders.Add("Authorization", header.ToString());

            httpClient.DefaultRequestHeaders.Add("x-ms-version", "2.7");

            httpClient.DefaultRequestHeaders.Add("DataServiceVersion", "2.0");

            httpClient.DefaultRequestHeaders.Add("MaxDataServiceVersion", "3.0");  

            var assetURI = wamsEndpoint+"Assets('" + assetId + "')";

            String requestBody = "{ \"Name\" : \"" + jobName + "\"," +

                            " \"InputMediaAssets\" : [{\"__metadata\" : {\"uri\" : \"" + assetURI + "\"}}]," +

                            " \"Tasks\" : [{\"Configuration\" : \"H264 Smooth Streaming 720p\"," +

                             " \"MediaProcessorId\" : \"" + processorId + "\"," +

                           " \"TaskBody\" : \"<?xml version=\\\"1.0\\\" encoding=\\\"utf-8\\\"?><taskBody><inputAsset>JobInputAsset(0)</inputAsset><outputAsset>JobOutputAsset(0)</outputAsset></taskBody>\"}]}";

            HttpContent body = new StringContent(requestBody, Encoding.UTF8, "application/json");

            var response = await httpClient.PostAsync(wamsEndpoint+"Jobs", body);

     if (response.IsSuccessStatusCode)

     {              

          var content = await response.Content.ReadAsStringAsync();

          XmlDocument xmlDoc = new XmlDocument();

          xmlDoc.LoadXml(content);

          XmlNodeList elemListBase = xmlDoc.GetElementsByTagName("d:Id");

          string jobId = null;

          foreach (var ele in elemListBase)

          {

             jobId = ele.InnerText; 

          } 

          return jobId;

       }

       else

       {

           return null;

       }

        }

获取ProcessorID 的代码可以参考如下，注意，此处的processorName针对应用场景，可以是Windows Azure Media Encoder, 或者是Windows Azure Media Packager(在Static Packaging场景会用到)。

   private async Task<string> GetProcessorId(string acsToken, string wamsEndPoint, string processorName)

        {

             AuthenticationHeaderValue header = CreateBasicAuthenticationHeader(acsToken); 

            HttpClient httpClient = new HttpClient();

            httpClient.MaxResponseContentBufferSize = int.MaxValue; 

            httpClient.DefaultRequestHeaders.Add("Authorization", header.ToString());

            httpClient.DefaultRequestHeaders.Add("x-ms-version", "2.7");

            httpClient.DefaultRequestHeaders.Add("DataServiceVersion", "3.0");

            httpClient.DefaultRequestHeaders.Add("MaxDataServiceVersion", "3.0");

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, wamsEndPoint);

            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            string uri = Uri.EscapeUriString("Name eq "+"\'" +processorName +"\'");

            string endPoint = wamsEndPoint + "MediaProcessors()?$filter="+uri;

            var response = await httpClient.GetAsync(endPoint);

            string processorID = null;

            if (response.IsSuccessStatusCode)

            {

                var content = await response.Content.ReadAsStringAsync();

                XmlDocument xmlDoc = new XmlDocument();

                xmlDoc.LoadXml(content);

                XmlNodeList elemList = xmlDoc.GetElementsByTagName("d:Id");               

                foreach (var ele in elemList)

                {

                    processorID = ele.InnerText;                

                }

            }

            return processorID;

     }

创建好编码工作后，剩余的编码任务交由媒体服务负责完成，编码时间依赖于媒体文件的大小，在编码完成之后才能进行流媒体发布，但是客户端如何才能知道server端编码结束了呢？这里我们也可以对编码进程进行查询。查询作业状态的请求简要总结如下，详情请参见：使用 Media Services REST API 创建编码作业

执行代码参考如下，根据返回信息确定编码状态，如2-表示processing，3-表示finished，那么返回值为3时表示编码工作完成，即可进行后续的流媒体发布工作啦。

  private async Task<string> GetJobStateAsync(string acsToken, string wamsEndpoint, string jobId)

        {

            AuthenticationHeaderValue header = CreateBasicAuthenticationHeader(acsToken); 

            HttpClient httpClient = new HttpClient();

            httpClient.MaxResponseContentBufferSize = int.MaxValue; 

            httpClient.DefaultRequestHeaders.Add("Authorization", header.ToString());

            httpClient.DefaultRequestHeaders.Add("x-ms-version", "2.7");

            httpClient.DefaultRequestHeaders.Add("DataServiceVersion", "3.0");

            httpClient.DefaultRequestHeaders.Add("MaxDataServiceVersion", "3.0");

            httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));          

            string url = wamsEndpoint + "Jobs('" + WebUtility.UrlEncode(jobId) + "')/State"; 

            var response = await httpClient.GetAsync(url);

            if (response.IsSuccessStatusCode)

            {

                var content = await response.Content.ReadAsStringAsync();

                JObject jsonObject = JObject.Parse(content);

                string jobState = jsonObject.Value<string>("value");

                return jobState;               

            }

            else

                return null;    

        }

同时我们可以查看 Azure Porta以了解编码进展情况，如下截图所示编码已经完成：

完成文件的编码后后，便可以进行后续流媒体的发布，将在后续文章中详细讲述，敬请期待。

使用REST API将媒体文件上传到媒体服务包含许多步骤，主要流程是：

1. 创建资产（ASSET）
2. 对资产进行加密（可选项）—本文暂时不予以考虑
3. 将媒体文件上传到blob storage

请注意，在使用REST API时访问媒体服务时，必须在HTTP请求中添加如下必须的header；WAMS 的根 URI 为https://media.windows.net/，成功连接到此 URI后，会收到一个“301 重定向”响应并提取出新的媒体服务URI，随后调用新都是基于该 URI，详细内容参见Part2内容。

根据文档媒体服务 REST API 开发的设置可知，每次调用WAMS时，客户端必须在请求中包括必需的标头，列表如下：

 如Part 1中描述：资产（ASSET）是包含媒体信息的逻辑实体，可能包含了一个或多个需要处理的数字文件如audio，video等。资产实体是对资产的抽象，包含了一系列的属性如Id, State等，为便于处理，我们定义Asset类用于表示媒体服务中的一个资产：

创建资产：在媒体服务中创建一个新的资产

通常根据媒体文件名创建asset, 如下代码根据文件名在媒体服务中创建相应的资产实体，代码执行成功后可以提取相应的Id值（做为AssetId）如nb:cid:UUID:636363d9-7c66-42ca-add4-0a8c4d4464f6。

(为便于描述，本文先假设上传位于媒体库中名为interview3.wmv的文件，以Part2链接媒体服务的内容为基础)

private string AssetId;

private string AccessPolicyId;

private string UploadUrl;

private string UploadEndpoint;

private static readonly string mediaFileName = "interview3.wmv"; 

private async Task<string> CreateAssetAsync(string acsToken, string wamsEndPoint, string mediaName)

        { 

            AuthenticationHeaderValue header = CreateBasicAuthenticationHeader(acsToken); 

            HttpClient httpClient = new HttpClient();

            httpClient.MaxResponseContentBufferSize = int.MaxValue; 

            httpClient.DefaultRequestHeaders.Add("Authorization", header.ToString());

            httpClient.DefaultRequestHeaders.Add("x-ms-version", "2.7");

            httpClient.DefaultRequestHeaders.Add("DataServiceVersion", "3.0");

            httpClient.DefaultRequestHeaders.Add("MaxDataServiceVersion", "3.0"); 

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, wamsEndPoint);

            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));          

            string assetCreateRequestPayloadFormat = @"{0} ""Name"": {1} {2} {3} {4}";

            string requestBody = string.Format(CultureInfo.InvariantCulture, assetCreateRequestPayloadFormat, "{","\"", mediaName,"\"", "}");    

            HttpContent body = new StringContent(requestBody, Encoding.UTF8, "application/json");         

            var response = await httpClient.PostAsync(wamsEndPoint + "Assets", body); 

            string assetId = null;

            if (response.IsSuccessStatusCode)

            {

                var content = await response.Content.ReadAsStringAsync();

                XmlDocument xmlDoc = new XmlDocument();

                xmlDoc.LoadXml(content); 

                XmlNodeList elemList = xmlDoc.GetElementsByTagName("d:Id");

                foreach (var ele in elemList)

                {

                    assetId = ele.InnerText;

                }     

            }

            return assetId;

        }

此时再去创建该资产下的资产文件，获取资产实体下对应的资产文件的ID, 以便后续过程中将上传的媒体文件更新到该ID下（MergeAssetFilesAsync）:

   private async Task<string> CreateAssetFilesAsync(string acsToken, string wamsEndPoint, string assetId, string mediaFileName)

        {

            AuthenticationHeaderValue header = CreateBasicAuthenticationHeader(acsToken);

            HttpClient httpClient = new HttpClient();

            httpClient.MaxResponseContentBufferSize = int.MaxValue;

            httpClient.DefaultRequestHeaders.Add("Authorization", header.ToString());

            httpClient.DefaultRequestHeaders.Add("x-ms-version", "2.7");

            httpClient.DefaultRequestHeaders.Add("DataServiceVersion", "3.0");

            httpClient.DefaultRequestHeaders.Add("MaxDataServiceVersion", "3.0");

            String requestBody = "{ \"Name\" : \"" + mediaFileName + "\"," +

                                  " \"ContentFileSize\" : \"" + "0" + "\", " +

                                  " \"ParentAssetId\" : \"" + assetId + "\", " +

                                  " \"MimeType\" : \"" + "video/x-ms-wmv" + "\"}";

            HttpContent body = new StringContent(requestBody, Encoding.UTF8, "application/json");     

            var response = await httpClient.PostAsync(wamsEndPoint + "Files", body);

            string assetFileId = null;

            if (response.IsSuccessStatusCode)

            {

                var content = await response.Content.ReadAsStringAsync();

                XmlDocument xmlDoc = new XmlDocument();

                xmlDoc.LoadXml(content);

                XmlNodeList elemList = xmlDoc.GetElementsByTagName("d:Id");

                foreach (var ele in elemList)

                {

                    assetFileId = ele.InnerText;

                }           

            }

           return assetFileId;

        }

如Part 1中描述，每个WAMS 账户都有一个或多个相关联的Azure Storage 账户，用于存储关联的WAMS 账户控制的媒体内容，在将媒体文件上传至Blob Storage时要求对资产设置相应的写入权限，然后提取用于上传的Storage URL，最后使用 Azure Storage REST APIs进行传输。

将任何文件上载到 BLOB 存储之前，需要设置用于对资产执行写入操作的访问策略权限。为此，需要向 AccessPolicy 实体集发送一个 HTTP POST 请求，创建AccessPolicy 请求简要总结如下：

https://media.windows.net/API/AccessPolicies  

    "Permissions" : 2

 执行过程可参考如下代码, 此处是写的权限（Permissions=”2”），在 文章5媒体的发布过程中，同样需要指定资产“读”的权限（Permissions=”1”）,执行成功后，根据返回内容获得相应的AccessPolicyId， 如："nb:pid:UUID:58fcf51e-5219-4fea-8536-6c295d2c388a"。 

       /// <summary>

        ///apName

        /// for upload-NewUploadPolicy

        /// for download - DownloadPolicy

        /// accessType 2- upload(write), 1- read

        /// </summary>

        /// <param name="acsToken"></param>

        /// <param name="wamsEndPoint"></param>

        /// <param name="policyName"></param>

        /// <returns></returns>

        private async Task<string> CreateAccessPolicyAsync(string acsToken, string wamsEndPoint, string apName, int accessType)

        {

            AuthenticationHeaderValue header = CreateBasicAuthenticationHeader(acsToken);

            HttpClient httpClient = new HttpClient();

            httpClient.MaxResponseContentBufferSize = int.MaxValue;

            httpClient.DefaultRequestHeaders.Add("Authorization", header.ToString());

            httpClient.DefaultRequestHeaders.Add("x-ms-version", "2.7");

            httpClient.DefaultRequestHeaders.Add("DataServiceVersion", "3.0");

            httpClient.DefaultRequestHeaders.Add("MaxDataServiceVersion", "3.0");

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, wamsEndPoint);

            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));         

            String requestBody = "{ \"Name\" : \"" + apName + "\"," +

                                   " \"DurationInMinutes\" : \"" + "300" + "\", " +

                                   " \"Permissions\" : " + accessType.ToString() + "}";

            HttpContent body = new StringContent(requestBody, Encoding.UTF8, "application/json");

            var response = await httpClient.PostAsync(wamsEndPoint + "AccessPolicies", body);

            string accessPolicyId = null;

            if (response.IsSuccessStatusCode)

            {

                var content = await response.Content.ReadAsStringAsync();

                XmlDocument xmlDoc = new XmlDocument();

                xmlDoc.LoadXml(content);

                XmlNodeList elemList = xmlDoc.GetElementsByTagName("d:Id");

                foreach (var ele in elemList)

                {

                    accessPolicyId = ele.InnerText;

                }  

            }

            return accessPolicyId;

        }

创建 AccessPolicy 后，将该Id链接到某个定位符实体，该实体将为你提供用于将文件上载到 BLOB 存储的 URL 路径，创建上传URL的请求简要总结如下：

https://media.windows.net/API/Locators  

{
     " AccessPolicyId": “< AccessPolicyId>”,

    "StartTime" : < DateTime.UtcNow.AddMinutes(-5) >”,（必须为YYYY-MM-DDTHH:mm:ss 格式）

     “Type”: “<1>”

 执行过程可参考如下代码，执行成功后，根据返回内容构造相应的上传URL，注意必须将要上载的文件的文件名添加到在获取得到的URL中，如：https://myappsstorage.blob.core.windows.net/asset-636363d9-7c66-42ca-add4-0a8c4d4464f6/azure.wmv?sv=2012-02-12&sr=c&si=8561f64e-0392-47f6-a178-8397f6ee4352&sig=JjDaBdvxHqWsA%2FWrLMLkAqQjl92v03vwdOrqVIAjkV8%3D&st=2014-11-28T10%3A39%3A58Z&se=2014-11-28T15%3A39%3A58Z。

  private async Task CreateUploadURLAsync(string acsToken, string wamsEndPoint, string accessPolicyId, string assetId)

        { 

            AuthenticationHeaderValue header = CreateBasicAuthenticationHeader(acsToken);

            HttpClient httpClient = new HttpClient();

            httpClient.MaxResponseContentBufferSize = int.MaxValue;

            httpClient.DefaultRequestHeaders.Add("Authorization", header.ToString());

            httpClient.DefaultRequestHeaders.Add("x-ms-version", "2.7");

            httpClient.DefaultRequestHeaders.Add("DataServiceVersion", "3.0");

            httpClient.DefaultRequestHeaders.Add("MaxDataServiceVersion", "3.0");

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, wamsEndPoint);

            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); 

            String requestBody = "{ \"AccessPolicyId\" : \"" + accessPolicyId + "\"," +

                           " \"AssetId\" : \"" + assetId+ "\", " +

                           " \"StartTime\" : \"" + DateTime.UtcNow.AddMinutes(-5).ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss") + "\", " +  

                           " \"Type\" : " + "1" + "}";     

            HttpContent body = new StringContent(requestBody, Encoding.UTF8, "application/json");

            var response = await httpClient.PostAsync(wamsEndPoint + "Locators", body);

            if (response.IsSuccessStatusCode)

            {

                var content = await response.Content.ReadAsStringAsync();

                XmlDocument xmlDoc = new XmlDocument();

                xmlDoc.LoadXml(content);

                XmlNodeList elemListBase = xmlDoc.GetElementsByTagName("d:BaseUri");               

                XmlNodeList elemListSV = xmlDoc.GetElementsByTagName("d:ContentAccessComponent");

                string baseUrl=null;

                string sv=null;

                foreach (var ele in elemListBase)

                {

                    baseUrl = ele.InnerText;

                }

                foreach (var ele in elemListSV)

                {

                    sv = ele.InnerText;

                }

                UploadUrl = baseUrl + "/" +Path.GetFileName(MediaFileName) +  sv;              

                UploadEndpoint = baseUrl.Substring(0, baseUrl.IndexOf("/asset"));

            }     

        } 

获得上传地址且设置好访问权限后，即可使用存储 REST API 将具体的文件上载到 Azure BLOB 存储容器，上传文件请求简要总结如下：

x-ms-version: 2011-08-18

x-ms-date: 2011-01-17

x-ms-blob-type: BlockBlob

application/octet-stream

 执行过程可参考如下代码，需要注意的是二进制文件的添加，此处仅以本地Video库(Windows.Storage.KnownFolders.VideosLibrary)中的一个名为interview3.wmv媒体文件为例，可以做相应修改，如让用户选择要上传的文件（OpenFilePicker）或自带摄像头拍摄的视频，执行成功返回201创建成功。

  private async Task<bool> UploadFileAsync(string acsToken, string uploadEndPoint,string uploadUrl)

        {

            HttpClientHandler handler = new HttpClientHandler { MaxRequestContentBufferSize = 10000000 };

            HttpClient httpClient = new HttpClient(handler);       

            httpClient.DefaultRequestHeaders.Add("x-ms-version", "2011-08-18");

            httpClient.DefaultRequestHeaders.Add("x-ms-date", "2011-01-17");

            httpClient.DefaultRequestHeaders.Add("x-ms-blob-type", "BlockBlob");    

            StorageFolder library = Windows.Storage.KnownFolders.VideosLibrary;          

            var videoFile = await library.GetFileAsync(MediaFileName);

            var props = await videoFile.GetBasicPropertiesAsync();

            var stream = await videoFile.OpenStreamForReadAsync();

            ContentSize = props.Size;

            StreamContent streamContent = new StreamContent(stream, (int)props.Size);

            HttpResponseMessage response = await httpClient.PutAsync(uploadUrl, streamContent);

            if (response.IsSuccessStatusCode)

            {  

                return true;

            }

            else

            {

                 return false;

            }

        }

请注意到这一步为止，媒体文件已经上传至Blob Storage，但是还没有更新到我们的资产实体中，需要再发送一个更新请求才能完成整个媒体文件的上传工作，相应的执行过程可参考如下代码。

private async Task MergeAssetFilesAsync(string acsToken, string wamsEndPoint,string assetId, string assetFileId, string mediaFileName)

        {

            AuthenticationHeaderValue header = CreateBasicAuthenticationHeader(acsToken);

            String requestBody = "{ \"Name\" : \"" + mediaFileName + "\"," +

                                  " \"ContentFileSize\" : \"" + ContentSize + "\", " +

                                  " \"ParentAssetId\" : \"" + assetId + "\", " +

                                  " \"Id\" : \"" + assetFileId + "\", " +

                                   " \"MimeType\" : \"" + "video/x-ms-wmv" + "\"}"; 

            var request = (HttpWebRequest)HttpWebRequest.Create(wamsEndPoint + "Files('" + assetFileId + "')");

            request.Method = "MERGE";

            request.ContentType = "application/json;odata=verbose";

            request.Accept = "application/json;odata=verbose";

            request.Headers["DataServiceVersion"] = "3.0";

            request.Headers["MaxDataServiceVersion"] = "3.0";

            request.Headers["x-ms-version"] = "2.7";

            request.Headers["Authorization"] = header.ToString();

            var requestBytes = Encoding.UTF8.GetBytes(requestBody);

            var requestStream = await request.GetRequestStreamAsync();

            await requestStream.WriteAsync(requestBytes, 0, requestBytes.Length);

            await requestStream.FlushAsync();

            var response = await request.GetResponseAsync();

        }

完成文件的上传后，我们可以在Portal上看到该文件的大小，同时在页面底部的Encode按钮现在也可以使用了，之后便可以进行后续媒体的操作如编码，将在后续文章中详细讲述，敬请期待。

WAMS接受基于 OData 的 HTTP 请求并能够以详细 JSON 或 atom+pub 做出响应。由于WAMS遵循 Azure 设计准则，因此在连接到 WAMS时，每个客户端必须使用一组必需的 HTTP 标头。根据文档媒体服务 REST API 开发的设置可知，每次调用WAMS时，客户端必须在请求中包括一组必需标头，媒体服务支持的标准 HTTP 请求必须的标头列表如下：

若要直接通过 REST API 访问 WAMS，必须从 ACS 检索一个访问令牌，并在向WAMS提出每个 HTTP 请求期间使用该令牌; WAMS 的根 URI 为https://media.windows.net/，先连接到此 URI，如果在响应中收到“301 重定向”，则应随后调用新的 URI。所以访问 WAMS时需要两项内容：由 Azure 访问控制服务 (ACS) 提供的访问令牌(access token)和 WAMS自身的 URI。在创建这些请求时，可以使用任何方法，前提是在调用 WAMS时指定了正确的标头(Header)值，并且传入了正确的访问令牌。

使用 Media Services REST API 连接到 Media Services的常见流程是：

1.  获取访问令牌；
2. 连接到WAMS的 URI-https://media.windows.net:  成功连接到该URI后，将收到一个 301 重定向响应，指定另一个WAMS 的URI。开发者必须对这个新 URI 进行后续调用。还可能会收到包含 ODATA API 元数据说明的 HTTP/1.1 200 响应；
3. 将后续API调用发布到新的URL。

首先来看获取访问令牌的过程，HTTP请求的header及body内容：

POST https://wamsprodglobal001acs.accesscontrol.windows.net/v2/OAuth2-13 HTTP/1.1

Content-Type: application/x-www-form-urlencoded

Host: wamsprodglobal001acs.accesscontrol.windows.net

Content-Length: 120

Expect: 100-continue

Connection: Keep-Alive

          grant_type=client_credentials&client_id=client id value&client_secret=URL-encoded client secret value&scope=urn%3aWindowsAzureMediaServices

      其中client_id和client_secret对应媒体服务的账户名称和编码后的密钥。

为便于解析响应的JSON和HTML 内容，Nuget 添加工具Json.Net 和HtmlAgilityPack

由于HttpWebRequest 部分函数在WinRT下已被弃用，导致在WinRT下无法对一些header值进行修改如Content-Length，我们在此使用包含丰富的异步支持的HttpClient类。

先定义一些常用变量及函数（CreateBasicAuthenticationHeader）：

static string accountName = "MediaServiceAccountName";

static string accountKey = "MediaServiceAccountKey";

private const string acsEndpoint = "https://wamsprodglobal001acs.accesscontrol.windows.net/v2/OAuth2-13";

private const string acsRequestBodyFormat = "grant_type=client_credentials&client_id={0}&client_secret={1}&scope=urn%3aWindowsAzureMediaServices"; 

private string WAMSEndpoint = "https://media.windows.net/";

 private static AuthenticationHeaderValue CreateBasicAuthenticationHeader(string acsToken)

        {

            return new AuthenticationHeaderValue("Bearer", acsToken);

        }

获取access token的执行过程可参考如下代码：

    private async Task<string> GetAccessTokenAsync(string accountName, string accountKey)

        {           

            HttpClient httpClient = new HttpClient();

            httpClient.MaxResponseContentBufferSize = int.MaxValue;        

            string requestBody = string.Format(CultureInfo.InvariantCulture, acsRequestBodyFormat, accountName, WebUtility.UrlEncode(accountKey));        

            HttpContent body = new StringContent(requestBody);

            body.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");

            var response =await httpClient.PostAsync(acsEndpoint, body);

             if (response.IsSuccessStatusCode)

             {

                 var content = await response.Content.ReadAsStringAsync();            

                 JObject jsonObject = JObject.Parse(content);

                 string acsToken = jsonObject.Value<string>("access_token"); 

                 return acsToken;

             }

             else

             {

                 return null;

             }           

        }

执行成功后，获得ACS token如下：

获得ACS token后，再链接到媒体服务的原始URI https://media.windows.net/获取重定向响应以提取新的媒体服务URI, 抓取Fiddler trace可以看到在客户端链接到https://media.windows.net/后，会返回一个301响应，包含了新的媒体服务URI如下，需用从响应内容中解析出该URI，可以使用工具HtmlAgilityPack。获取到新的媒体服务 URI如：https://wamshknclus001rest-hs.cloudapp.net/api/。

 <html>

  <head><title>Object moved</title></head>

  <body>

       <h2>Object moved to <a href="https://wamshknclus001rest-hs.cloudapp.net/api/">here</a>.</h2>

   </body>

</html>

 private async Task<string> ConnectMediaServiceAsync(string acsToken)

        {           

            AuthenticationHeaderValue header = CreateBasicAuthenticationHeader(acsToken);         

            var handler = new HttpClientHandler()

            {

                AllowAutoRedirect = false

            };

            HttpClient httpClient = new HttpClient(handler);

            httpClient.MaxResponseContentBufferSize = int.MaxValue;

            httpClient.DefaultRequestHeaders.Add("Authorization", header.ToString());

            httpClient.DefaultRequestHeaders.Add("x-ms-version", "2.7");

            httpClient.DefaultRequestHeaders.Add("DataServiceVersion", "3.0");

            httpClient.DefaultRequestHeaders.Add("MaxDataServiceVersion", "3.0");

           HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, WAMSEndpoint);

           request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            var response = await httpClient.SendAsync(request);

            //after connecting to https://media.windows.net, you will receive a 301 redirect specifying another Media Services URI.

            // You must make subsequent calls to the new URI. 

            string wamsEndPointFinal = WAMSEndpoint;

            if (response.StatusCode == HttpStatusCode.Moved || response.StatusCode == HttpStatusCode.MovedPermanently)

            {

                var htmlcontent = await response.Content.ReadAsStringAsync();

                HtmlDocument htmlDocument = new HtmlDocument();

                htmlDocument.LoadHtml(htmlcontent);

                var inputs_a = htmlDocument.DocumentNode.Descendants("a"); 

                string newLocation = null;

                foreach (var input in inputs_a)

                {

                    newLocation = input.Attributes["href"].Value;                  

                }

                if (newLocation!=null)

                {

                    wamsEndPointFinal = newLocation;                  

                }    

            }

            return wamsEndPointFinal;

        }

完成以上设置，便可以进行后续媒体的上载，将在后续文章中详细讲述，敬请期待。

Windows Azure Media Service (Windows Azure 媒体服务，简称WAMS)是基于Windows Azure平台的灵活、可靠、可自定义的媒体服务。该服务为用户提供媒体上传、编码及视频下载、点播和实时播放等功能。

Azure 的管理门户针对WAMS提供丰富的UI操作，管理媒体服务的账户、内容、作业、点播流、编码及媒体处理器等。每个WAMS账户创建在一个特定的Windows Azure 数据中心，每个账户有一个帐户名称及账户密钥，在使用WAMS 的REST API或.NET API时，需要使用该账户名称及密钥发送验证请求及调用API进行后续编码、内容发布等。每个WAMS 账户都有一个或多个相关联的Azure Storage 账户，用于存储关联的WAMS 账户控制的媒体内容。用户可以登录https://www.windowsazure.cn/ 进行登记注册，成为Azure用户，登录后即可使用媒体服务。

在使用WAMS前，我们先来快速了解一些常用术语，部分内容可以参见 MSDN 文档Azure Media Services 概述：

资产（Asset）—— 资产是包含媒体信息的逻辑实体，它可能包含了一个或多个需要处理的数字文件（audio, video等）。

传送（Delivery）—— 传送/发布处理过的媒体，可能是以实时传送的方式或点播的方式发布到客户端，或者从cloud端获取/下载指定的媒体文件，或者部署媒体资产到其他的server端如Azure CDN server 等。

文件（File）—— 一个文件表示待处理的包含audio/video的blob对象 ，文件都是存储在Azure 的blob  storage里。一个文件总是与一个资产（asset）相关联，一个资产能够包含一个或多个文件。

引入/上载（Ingestion/uploading）—— 表示将资产上传给媒体服务的过程 。该过程包含上传文件到blob storage及对资产进行加密保护。

作业（Job）—— 一个作业表示包含一组任务的逻辑实体，即对资产和作业进行相关处理的过程如编码，该过程包含一个或多个任务，简言之即一个作业就是一组任务的集合，例如，有一个作业：将一个文件转换成多种格式的“编码”作业，则该作业包含多个任务，每个任务负责将该文件转换成一个特定的文件格式。

管理（Manage）—— 表示对媒体服务中的资产进行管理的过程，如枚举、删除、编辑资产，管理资产密钥，管理DRM 密钥等。

处理（Processing）—— WAMS非常重要的操作，该操作包含对资产进行处理如编码、输出转码后新建的资产，对资产进行复合使用，创建编码作业、创建作业模板、检查作业状态、取消作业等。

任务（Task）—— 表示对资产或作业的一项独立操作，一个任务总是与一个作业相关联，一个作业包含一个或多个任务 。

访问策略（Access Policies）—— 访问策略决定了客户端具有的对给定资产的访问权限和持续时间，包含的访问类型： read/write/delete/list/none。

定位符（Locator）—— 一个特殊的URL, 在一定时间段内有效的用于访问资产的链接，通常与访问策略一同使用。

客户端使用WAMS的基本流程包含4步：

      客户端初始设置链接到WAMS->媒体引入到WAMS–>WAMS 进行处理–>媒体发布

1. 客户端初始设置链接到WAMS: 配置客户端使用API访问WAMS 端点；
2. 媒体引入到WAMS：上传一个或多个媒体文件到Azure Blob storage，即上文提及的资产；
3. WAMS进行处理：WAMS进行所需的处理，如编码，创建转码后的输出资产等；
4. 媒体发布：创建定位符（URLs），用于输出资产的发布，可供下载或点播发布媒体流。

接下来，将基于WAMS 提供过的REST API进行进行windows store、window phone 的应用开发，整个开发过程严格按照使用WAMS的4个基本过程。首先是进行WAMS链接的过程：将在基于Windows Azure Media Service REST API 进行Windows Store/Windows Phone 应用开发系列-Part 2初始设置链接到WAMS进行详细讲解。

若感兴趣，还可以从WAMS的学习入口点媒体服务了解更多的信息。

微软官方文档Get started with authentication in Mobile Services详细介绍了如何使用所支持的identity provider 如Microsoft Account、Facebook login、Twitter login、Google login及Azure Active Directory（AAD）对移动应用提供身份验证功能，并且可以通过采用日志Expanded login scopes in Azure Mobile Services介绍的API获取用户ID信息，该文档介绍了如何通过Graph API获得Microsoft Account、Facebook login或Google login账号的用户信息，那么针对Azure Active Directory账号，该如何获取呢？AAD也提供了丰富的Graph API，可以用于获得用户信息。接下来我们以一个简单的Windows Store APP为例详细讲解如何使用Azure Active Directory进行用户身份认证并获取ID信息。 

首先在Azure Management Portal上创建一个Azure Mobile Service，如名为wamsaad,

点击新建的Mobile Service 的IDENTITY 标签，滚动到windows azure active directory，拷贝APP URL的值-如https://wamsaad.azure-mobile.net/login/aad，将用于后续Active Directory 配置。

切换到Active Directory，创建一个新的AAD domain 如名为icesmart，添加了两名用户test1@icesmart.onmicrosoft.com和test2@icesmart.onmicrosoft.com，当作测试账号。

点击icesmart 的APPLICATIONS标签，然后点击ADD按钮添加一个应用，在弹出的对话框选择“Add and application my organization is developing”

在Add Application向导窗口添加一个新的应用，如名为 wamsaad，选择类型为Web Application And/OR Web API，在SIGN-ON URL里，使用前文提及的mobile service 提供的active directory 身份认证的APP URL值（https://wamsaad.azure-mobile.net/login/aad），在APP ID URI同样使用一个唯一的URI，如https://wamsaad.azure-mobile.net/login/sso

应用添加完毕后，点击CONFIGURE标签，拷贝CLIENT ID值，粘贴到前文新建的Mobile Service wamsadd的IDENTITY标签下的windows azure active directory CLIEND ID区域

点击新建的AAD application-wamsaad，在CONFIGURE标签下，点击页面底部的“MANAGE MANIFEST”按钮下载manifest 文件，打开该文件将"appPermissions": [], 内容替换为如下内容后保存该文件，再点击“MANAGE MANIFEST”按钮上传该文件

"appPermissions": [

    {

        "claimValue": "user_impersonation",

        "description": "Allow the application access to the mobile service",

        "directAccessGrantTypes": [],

        "displayName": "Have full access to the mobile service",

        "impersonationAccessGrantTypes": [

            {

                "impersonated": "User",

                "impersonator": "Application"

            }

        ],

        "isDisabled": false,

        "origin": "Application",

        "permissionId": "b69ee3c9-c40d-4f2a-ac80-961cd1534e40",

        "resourceScopeType": "Personal",

        "userConsentDescription": "Allow the application full access to the mobile service on your behalf",

        "userConsentDisplayName": "Have full access to the mobile service"

    }

],

同时在该标签下Keys区域，选择创建一个key如1年有效期，然后点击下端的SAVE按钮，会生成一个Key，注意保存该Key，在使用Graph API时会用到，当离开该页面时，key值会被隐藏

再在该页面上的permissions to other applications 区域做相应配置，依次选择Windows Azure Active Directory, Read directory data等

在Azure Mobile Service-wamsaad端，点击API标签，然后点击“CREATE”按钮就创建一个API 如getUserInfo，其SCRIPT类容可参见文档，替换自己的clientID, key及AAD domain值如icesmart.onmicrosoft.com，该API用于与AAD通信，获得基本的Graph 数据；在移动设备端如Windows Store/Phone App中，调用该API，当用户使用AAD账号登录后，App获得用户数据，结果如下截图显示。

public class UserDetails

{

    public String userPrincipalName { get; set; }

    public String displayName { get; set; }

    public String usageLocation { get; set; }

}

private MobileServiceUser user;

private static MobileServiceClient MobileService = new MobileServiceClient(

           "https://wamsaad.azure-mobile.net/", "Application Key");

   private async System.Threading.Tasks.Task LoginAAD()

        {

            while (MobileService.CurrentUser == null)

            {

                string message;

                try

                {

                    user = await MobileService.LoginAsync("aad");

                    var result = await MobileService.InvokeApiAsync("getuserinfo", HttpMethod.Get, null);

                    UserDetails currentUser = JsonConvert.DeserializeObject<UserDetails>(result.ToString());               

                     message = string.Format("Welcome, {0}! You are now logged in.", result.ToString() + currentUser.userPrincipalName);

                }

                catch (InvalidOperationException)

                {

                    message = "You must log in. Login Required";

                }

            }

        }

我们从一个应用实例来看该测试过程的意义：有开发者发现对于Windows Phone OS 7.1的APP, 出于对用户安全隐私的考虑（如一些银行类的应用），其并没有在WMAppManifest.xml文件中声明使用ID_CAP_MEDIALIB（应用对媒体库的访问权限控制），但是当APP发布到Store后，App require 列表中却添加了Photo, music and video libraries内容，导致APP用户抱怨其安全隐患。这是为什么呢？原因在于Store在审核APP时，会使用一个工具对APP进行静态分析并自动添加所需要的Capabilities, 即若APP包含了使用媒体库的组件（如使用Microsoft.Xna.Framework.Media.MediaPlayer），那么ID_CAP_MEDIALIB会被自动添加。那么这个分析工具是什么呢？它即是Store Test Kit。这个工具集成在Windows Phone SDK8.0中，开发者可以使用Store Test Kit对使用某API的AP进行测试以判定其是否是依赖于某个capability。例如需要判别Microsoft.Xna.Framework.Media.MediaPlayer 类是否使用ID_CAP_MEDIALIB，使用Store Test Kit测试发现MediaPlayer 需要ID_CAP_MEDIALIB，简要过程为（基于Visual Studio 2012）：

1)  创建一个新的基于Windows Phone 7.1 OS的Project

2)  添加code, code中包含调用相应的API

3)   “Release”编译APP

4)  运行Store Test Kit（右击该project，选择“Open Store Test Kit”即可）

5)  在Automated Tests 标签下，点击 “Run Tests” 按钮进行测试，发现需要用到ID_CAP_MEDIALIB

 针对这种场景，可以使用其他的类做替代，如若是需要播放音乐（playing a sound），可以使用Soundeffect类，使用Store Test Kit发现不要求ID_CAP_MEDIALIB；或者若是需要添加背景音乐，可以参考 sample Background Audio Player Sample，在文档中How to play background audio for Windows Phone有所提及，Store Test Kit测试发现同样不要求ID_CAP_MEDIALIB。

以上仅以一个简单的实例说明使用Store Test Kit进行Capability的需求判别，当然该工具还包含许多其他内容的测试，可以详细参见MSDN 文档。该工具对Windows Phone OS 7.1 及Windows Phone 8.0 OS的APP进行测试，对于Windows Phone 8.1 OS的APP， 我们使用WACK工具。

使用最新版本的WACK（3.3）对Windows Phone 8.1 App进行测试，需要首先在Visual Studio 2013中创建Package，然后运行最新版本的Windows Cert App Kit, 过程大致与使用WACK 验证Windows Store App描述的UI运行WACK 对Windows Store App的审核过程类似，选择Validate Windows Phone App，在后续弹出的APP选择框中从文件系统对应Windows Phone 8.1 App package 文件，WACK对Windows Phone 的测试内容大致包含10个测试项，可以详见MSDN 文档。

除了使用UI方式，我们也可以通过命令行的方式，同使用WACK 验证Windows Store App介绍的命令行方式大致相同，同样使用C:\Program Files (x86)\Windows Kits\8.1\App Certification Kit目录下的appcert.exe工具，只不过运行的命令只能使用package的目录方式。过程如下：

1)  以Administrator权限运行cmd.exe

2)  运行如下命令：

   cd C:\Program Files (x86)\Windows Kits\8.1\App Certification Kit

    appcert.exe reset 

    appcert.exe test -apptype windowsphoneapp -appxpackagepath [path\xxx.appx] -reportoutputpath [report file name ]

例如：appcert test -apptype windowsphoneapp -appxpackagepath C:\Input\MyApp.appx -reportoutputpath c:\Output\MyReport.xml

Demo演示截图如下：

本文简要总结对Windows Phone App的本地验证，对于Windows Phone OS 7.1/8.0的APP，使用Windows Phone SDK8.0包含的Store Test Kit, 对于Windows Phone OS8.1的APP，则使用WACK工具进行测试，可以采用UI方式，也可以采用命令行方式，根据测试结果进行APP project 的修复，确保APP通过Store Test Kit 或WACK 测试，再进行APP提交，以加快APP的成功发布过程。