public static TransferMonitorViewModel Create(BackgroundTransferRequest request)
        {
            var vm = new TransferMonitorViewModel(new TransferMonitor(request));
            vm.CreateJobData(request);

            return vm;
        }

        private void Button_Click_1(object sender, RoutedEventArgs e)
        {
            string mp3uri = "http://www.nmgwxc.com/m/yldcj.mp3";

            if (BackgroundTransferService.Requests.Count() >= 25)
            {
                MessageBox.Show("已经超过最大请求数量，请稍后");
                return;
            }
            if (BackgroundTransferService.Requests.Any(p => p.RequestUri.AbsoluteUri == mp3uri))
            {
                MessageBox.Show("文件已经在下载的请求中");
                return;
            }
            BackgroundTransferRequest transferRequest = new BackgroundTransferRequest(new Uri(mp3uri, UriKind.Absolute));
            transferRequest.Method = "GET";
            transferRequest.TransferPreferences = TransferPreferences.None;
            transferRequest.TransferStatusChanged += transferRequest_TransferStatusChanged;
            transferRequest.TransferProgressChanged += transferRequest_TransferProgressChanged;
            transferRequest.Tag = "yldcj.mp3";
            transferRequest.DownloadLocation = new Uri("shared/transfers/yldcj.mp3", UriKind.Relative);
            try
            {
                BackgroundTransferService.Add(transferRequest);
            }
            catch (Exception ee)
            {
                MessageBox.Show(ee.Message);
            }
        }

 private void PersistRequestToStorage(BackgroundTransferRequest request)
 {
     var requestUri = request.RequestUri;
     var requestUriHash = CryptoUtils.GetHash(requestUri.ToString());
     var trackerDir = FileUtils.GetDowloadTrackerDirectory(false, true);
     FileUtils.WriteFile(string.Format("{0}\\{1}", trackerDir, requestUriHash), request.RequestId);
 }

        private void Download_Click(object sender, EventArgs e)
        {
            try
            {
                // Sichergehen, dass der Download-Ordner existiert
                using (IsolatedStorageFile isoStore = IsolatedStorageFile.GetUserStoreForApplication())
                {
                    if (!isoStore.DirectoryExists(TransfersFolder))
                    {
                        isoStore.CreateDirectory(TransfersFolder);
                    }
                }

                var request = new BackgroundTransferRequest(new Uri("http://ralfe-software.net/Wildlife.wmv", UriKind.Absolute))
                    {
                        DownloadLocation = new Uri(DownloadLocation, UriKind.Relative),
                        Method = "GET",
                        TransferPreferences = TransferPreferences.AllowBattery
                    };
                BackgroundTransferService.Add(request);

                DownloadButton.IsEnabled = false;
                DeleteButton.IsEnabled = true;
                UpdateUI();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }
        }

        /// <summary>
        /// 继续一个下载任务
        /// </summary>
        /// <param name="info"></param>
        protected bool ResumeOneDownload(DownloadInfo info)
        {
            if (string.IsNullOrEmpty(info.RequestId)) return false;

            var transferRequest = BackgroundTransferService.Find(info.RequestId);
            if (transferRequest != null
                && transferRequest.TransferStatus == TransferStatus.Transferring)
            {
                try
                {
                    _isDownloading = true;
                    info.DownloadState = DownloadState.Downloading;
                    HandleDownload(transferRequest, info, false);
                    return true;
                }
                catch (Exception ex)
                {
                    DownloadFailture(info, ex.Message);
                    _isDownloading = false;
                }
            }
            else
            {
                _isDownloading = true;
                info.DownloadState = DownloadState.Downloading;
                transferRequest = new BackgroundTransferRequest(new Uri(info.DownloadUri), new Uri(info.LocalFileName, UriKind.Relative));
                HandleDownload(transferRequest, info, true);
                return true;
            }
            return false;
        }

        private ITransferRequest DownloadAsyncViaBackgroundTranfer(Uri serverUri, Uri phoneUri)
        {
            try
            {
                var request = new BackgroundTransferRequest(serverUri, phoneUri);
                request.Tag = serverUri.ToString();
                request.TransferPreferences = TransferPreferences.AllowCellularAndBattery;

                int count = 0;
                foreach (var r in BackgroundTransferService.Requests)
                {
                    count++;
                    if (r.RequestUri == serverUri)
                        return new WindowsTransferRequest(r);
                    if (r.TransferStatus == TransferStatus.Completed)
                    {
                        BackgroundTransferService.Remove(r);
                        count--;
                    }
                    // Max 5 downloads
                    if (count >= 5)
                        return null;
                }
                BackgroundTransferService.Add(request);
                PersistRequestToStorage(request);
                return new WindowsTransferRequest(request);
            }
            catch (InvalidOperationException)
            {
                return GetRequest(serverUri.ToString());
            }
        }

 public DownloadItemBackgroundViewModel(BackgroundTransferRequest backgroundTransferRequest)
 {
     this.BackgroundTransferRequest = backgroundTransferRequest;
     this.ProcessTransfer(backgroundTransferRequest);
     this.WatchTransfer();
     this.ProcessTransfer(backgroundTransferRequest);
 }

        /// <summary>
        /// Attaches a BackgroundUploadCompletedEventAdapter to the given BackgroundTransferRequest.
        /// This is to convert a BackgroundTransferRequest's status changes to a LiveOperationResult.
        /// </summary>
        /// <param name="request">Request to attach to.</param>
        /// <returns>A Task&lt;LiveOperationResult&gt; converted over from a BackgroundTransferEventArgs.</returns>
        public Task<LiveOperationResult> ConvertTransferStatusChangedToTask(BackgroundTransferRequest request)
        {
            var completedEventHandler =
                new BackgroundUploadCompletedEventAdapter(this.backgroundTransferService, this.tcs);
            completedEventHandler.BackgroundTransferRequestCompleted += this.OnBackgroundTransferRequestCompleted;

            return completedEventHandler.ConvertTransferStatusChangedToTask(request);
        }

        private void CreateJobData(BackgroundTransferRequest request)
        {
            var json = request.Tag;
            var jobData = JsonConvert.DeserializeObject<JobData>(json);
            JobData = jobData;

            Monitor.Name = jobData.Name;
        }

 public WindowsTransferRequest(BackgroundTransferRequest request)
 {
     this.request = request;
     if (this.request != null)
     {
         this.request.TransferProgressChanged += request_TransferProgressChanged;
         this.request.TransferStatusChanged += request_TransferStatusChanged;
     }
 }

        /// <summary>
        /// 开始下载一个新任务，此方法为后台线程调用
        /// </summary>
        /// <param name="info"></param>
        protected void StartOneDownload(DownloadInfo info)
        {
            _isDownloading = true;

            var destinationPath = string.Format("/shared/transfers/{0}", info.LocalFileName);
            var destinationFile = new Uri(destinationPath, UriKind.Relative);
            var transferRequest = new BackgroundTransferRequest(new Uri(info.DownloadUri), destinationFile);
            info.LocalFileName = transferRequest.DownloadLocation.OriginalString;
            HandleDownload(transferRequest, info, true);
        }

        public void startAsync(string options)
        {
            try
            {
                var optStings = JSON.JsonHelper.Deserialize<string[]>(options);
                
                var uriString = optStings[0];
                var filePath = optStings[1];


                if (_activDownloads.ContainsKey(uriString))
                {
                    return;
                }
    
                _activDownloads.Add(uriString, new Download(uriString, filePath, optStings[2]));
                
               
                var requestUri = new Uri(uriString);

                BackgroundTransferRequest transfer = FindTransferByUri(requestUri);

                if (transfer == null)
                {
                    // "shared\transfers" is the only working location for BackgroundTransferService download
                    // we use temporary file name to download content and then move downloaded file to the requested location
                    var downloadLocation = new Uri(@"\shared\transfers\" + Guid.NewGuid(), UriKind.Relative);

                    transfer = new BackgroundTransferRequest(requestUri, downloadLocation);

                    // Tag is used to make sure we run single background transfer for this file
                    transfer.Tag = uriString;

                    BackgroundTransferService.Add(transfer);
                }

                if (transfer.TransferStatus == TransferStatus.Completed)
                {
                    // file was already downloaded while we were in background and we didn't report this
                    MoveFile(transfer);
                    BackgroundTransferService.Remove(transfer);
                    DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
                }
                else
                {
                        transfer.TransferProgressChanged += ProgressChanged;
                        transfer.TransferStatusChanged += TransferStatusChanged;
                }
                
            }
            catch (Exception ex)
            {               
                DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, ex.Message));
            }
        }

 public ProgressInfo GetProgressInfo(BackgroundTransferRequest e)
 {
     P.FileProgress = (float)e.BytesReceived / (float)e.TotalBytesToReceive;
     string[] splitted_tag = e.Tag.Split('|');
     ts = DateTime.Now - last_time;
     P.Speed = (float)(e.BytesReceived - BytesTransferredLast) / (float)ts.TotalSeconds/1024;
     P.Title = splitted_tag[1];
     BytesTransferredLast = e.BytesReceived;
     last_time = DateTime.Now;
     return P;
 }

        internal LivePendingDownload(
            IBackgroundTransferService backgroundTransferService, 
            BackgroundTransferRequest request)
        {
            Debug.Assert(backgroundTransferService != null);
            Debug.Assert(request != null);
            Debug.Assert(BackgroundTransferHelper.IsDownloadRequest(request));

            this.request = request;
            this.backgroundTransferService = backgroundTransferService;
        }

        /// <summary>
        /// Attaches a BackgroundDownloadCompletedEventAdapter to the given BackgroundTransferRequest.
        /// This is to convert a BackgroundTransferRequest's status changes to a LiveOperationResult.
        /// </summary>
        /// <param name="request">Request to attach to.</param>
        /// <returns>A Task&lt;LiveOperationResult&gt; converted over from a BackgroundTransferEventArgs.</returns>
        public Task<LiveOperationResult> ConvertTransferStatusChangedToTask(BackgroundTransferRequest request)
        {
            Debug.Assert(request != null);

            var completedEventAdapter =
                new BackgroundDownloadCompletedEventAdapter(this.backgroundTransferService, this.tcs);

            completedEventAdapter.BackgroundTransferRequestCompleted +=
                this.OnBackgroundTransferRequestCompletedEventAdapter;
            return completedEventAdapter.ConvertTransferStatusChangedToTask(request);
        }

 protected BackgroundTransferRequest GetBackTXRequest(string src,string tag)
 {
     Uri src_uri = new Uri(src, UriKind.Absolute);
     Uri dst_uri = new Uri("shared\\transfers\\temp"+src_uri.GetHashCode()+".mp3", UriKind.Relative);
     BackgroundTransferRequest back_req = new BackgroundTransferRequest(src_uri, dst_uri);
     back_req.Tag = tag;
     bool use_cellular = false;
     IsolatedStorageSettings.ApplicationSettings.TryGetValue("use_cellular", out use_cellular);
     if (use_cellular)
         back_req.TransferPreferences = TransferPreferences.AllowCellularAndBattery;
     else
         back_req.TransferPreferences = TransferPreferences.AllowBattery;
     return back_req;
 }

        /// <summary>
        /// Attaches to this BackgroundTransferRequest's TransferStatusChanged event.
        /// </summary>
        /// <param name="request">request to attach to</param>
        public Task<LiveOperationResult> ConvertTransferStatusChangedToTask(BackgroundTransferRequest request)
        {
            Debug.Assert(BackgroundTransferHelper.IsUploadRequest(request));
            if (request.TransferStatus != TransferStatus.Completed)
            {
                request.TransferStatusChanged += this.HandleTransferStatusChanged;
            }
            else
            {
                // If we are working with an already completed request just handle it now.
                this.OnTransferStatusComplete(request);
            }

            return this.tcs.Task;
        }

        private void BeginDownload()
        {
            using (var storage = IsolatedStorageFile.GetUserStoreForApplication())
            {
                if (storage.FileExists("/shared/transfers/channel9.mp3"))
                    storage.DeleteFile("/shared/transfers/channel9.mp3");
            }

            _request = new BackgroundTransferRequest(
                        new Uri("http://media.ch9.ms/ch9/7e13/ce6ea97c-e233-4e7c-a74d-ee1c81e37e13/WP8JumpStart04.mp3",
                                UriKind.Absolute),
                        new Uri("/shared/transfers/channel9.mp3", UriKind.Relative)) { Tag = "Channel9Download", TransferPreferences = TransferPreferences.AllowBattery };
            _monitor = new TransferMonitor(_request);
            Control1.DataContext = _monitor;

            _monitor.RequestStart(); //This adds request to the BackgroundTransferService queue.
        }

        public void Upload(string username, string password, string filename)
        {
            using (System.IO.IsolatedStorage.IsolatedStorageFile iso = System.IO.IsolatedStorage.IsolatedStorageFile.GetUserStoreForApplication())
            {
                if (!iso.FileExists(localDBName))
                    return;

                iso.CopyFile(localDBName, "/" + TransfersFiles + "/" + localDBName, true);
            }

            BackgroundTransferRequest btr = new BackgroundTransferRequest(new Uri(serviceUploadLocationURL + localDBName, UriKind.Absolute));
            btr.TransferPreferences = TransferPreferences.AllowBattery;
            btr.Method = "POST";
            btr.UploadLocation = new Uri("/" + TransfersFiles + "/" + localDBName, UriKind.Relative);
            btr.TransferStatusChanged += new EventHandler<BackgroundTransferEventArgs>(btr_UploadTransferStatusChanged);
            btr.TransferProgressChanged += new EventHandler<BackgroundTransferEventArgs>(btr_TransferProgressChanged);
            Microsoft.Phone.BackgroundTransfer.BackgroundTransferService.Add(btr);
        }

        public BackgroundTransferRequest Build()
        {
            Debug.Assert(this.requestUri != null);
            Debug.Assert(this.accessToken != null);
            Debug.Assert(this.downloadLocationOnDevice != null);

            var request = new BackgroundTransferRequest(this.requestUri, this.downloadLocationOnDevice);

            request.Headers.Add(
                ApiOperation.AuthorizationHeader, 
                AuthConstants.BearerTokenType + " " + this.accessToken);
            request.Headers.Add(ApiOperation.LibraryHeader, Platform.GetLibraryHeaderValue());

            request.Tag = BackgroundTransferHelper.Tag;

            request.TransferPreferences = this.transferPreferences;

            return request;
        }