async void OnDeferredDataRequestHandler(DataProviderRequest request)
{
var deferral = request.GetDeferral();
try
{
var clipboardFormat = StandardToCfFormat(request.FormatId);
var data = await(m_requesters?[m_lastCopyId]?.GetDataAsync(clipboardFormat)
?? Task.FromResult <string>(null));
// Get and put data in request
var norm = NormalizeClipboardData(new ClipboardData {
cf = clipboardFormat, data = data
});
if (norm.cf == request.FormatId)
{
request.SetData(norm.data);
}
}
catch (Exception) { }
finally
{
deferral.Complete();
}
}
private void OnUpdateAll()
{
var today = DateTime.Today;
foreach (var entry in Entries)
{
var request = DataProviderRequest.Create(entry.Stock, typeof(Price), today.Subtract(TimeSpan.FromDays(7)), today.AddDays(1));
request.WithPreview = false;
var series = new List <IFigure>();
// fetch some more data because of weekends and public holidays
// we will then take last one
DataProvider.Fetch(request, series);
entry.CurrentPrice = ( Price )series
.OrderByDescending(d => d.Period)
.First();
// connect to stock so that we can save it later
var existingPrice = entry.Stock.Prices.SingleOrDefault(p => p.Period.Equals(entry.CurrentPrice.Period));
if (existingPrice != null)
{
existingPrice.Value = entry.CurrentPrice.Value;
existingPrice.Currency = entry.CurrentPrice.Currency;
existingPrice.Source = entry.CurrentPrice.Source;
}
else
{
entry.Stock.Prices.Add(entry.CurrentPrice);
}
}
}
private async void OnDeferredImageRequestedHandler(DataProviderRequest request, DataPackage dp)
{
DataProviderDeferral deferral = request.GetDeferral();
try
{
StorageFile img = await PictureHandler.AsStorageFile(Items.SelectedItem.Pixels, "ToShare.jpg");
if (img != null)
{
List <IStorageFile> imageItems = new List <IStorageFile>
{
img
};
dp.SetStorageItems(imageItems);
RandomAccessStreamReference imageStreamRef = RandomAccessStreamReference.CreateFromFile(img);
dp.Properties.Thumbnail = imageStreamRef;
dp.SetBitmap(imageStreamRef);
}
}
catch (Exception e)
{
throw e;
}
deferral.Complete();
}
private async void OnDeferredImageRequestedHandler(DataProviderRequest providerRequest, StorageFile imageFile)
{
// In this delegate we provide updated Bitmap data using delayed rendering.
if (imageFile != null)
{
// If the delegate is calling any asynchronous operations it needs to acquire the deferral first. This lets the
// system know that you are performing some operations that might take a little longer and that the call to
// SetData could happen after the delegate returns. Once you acquired the deferral object you must call Complete
// on it after your final call to SetData.
DataProviderDeferral deferral = providerRequest.GetDeferral();
InMemoryRandomAccessStream inMemoryStream = new InMemoryRandomAccessStream();
// Make sure to always call Complete when done with the deferral.
try
{
// Decode the image and re-encode it at 50% width and height.
IRandomAccessStream imageStream = await imageFile.OpenAsync(FileAccessMode.Read);
BitmapDecoder imageDecoder = await BitmapDecoder.CreateAsync(imageStream);
BitmapEncoder imageEncoder = await BitmapEncoder.CreateForTranscodingAsync(inMemoryStream, imageDecoder);
imageEncoder.BitmapTransform.ScaledWidth = (uint)(imageDecoder.OrientedPixelWidth * 0.5);
imageEncoder.BitmapTransform.ScaledHeight = (uint)(imageDecoder.OrientedPixelHeight * 0.5);
await imageEncoder.FlushAsync();
providerRequest.SetData(RandomAccessStreamReference.CreateFromStream(inMemoryStream));
}
finally
{
deferral.Complete();
}
}
}
private async void OnDeferredPDFRequestedHandler(DataProviderRequest request)
{
LockDeferredPDFRequestedHandler = true;
exportfile = await Windows.Storage.ApplicationData.Current.TemporaryFolder.CreateFileAsync("test_pull_sharing.pdf", CreationCollisionOption.ReplaceExisting);
request.SetData(new List <IStorageItem> {
exportfile
});
await this.Dispatcher.RunIdleAsync(async delegate(IdleDispatchedHandlerArgs args)
{
try
{
var service = new StiPdfExportService();
await service.ExportPdfAsync(viewerControl.Report, exportfile, new StiPdfExportSettings());
}
finally
{
LockDeferredPDFRequestedHandler = false;
}
});
while (LockDeferredPDFRequestedHandler)
{
await Task.Delay(500);
}
var deferral = request.GetDeferral();
deferral.Complete();
}
async private static void OnDeferredImageRequestedHandler(DataProviderRequest request, StorageFile imageFile)
{
// Since this method is using "await" prior to setting the data in DataPackage,
// deferral object must be used
var deferral = request.GetDeferral();
// Use try/finally to ensure that we always complete the deferral.
try
{
using (var imageStream = await imageFile.OpenAsync(FileAccessMode.Read))
{
// Decode the image
var imageDecoder = await BitmapDecoder.CreateAsync(imageStream);
// Re-encode the image at 50% width and height
var inMemoryStream = new InMemoryRandomAccessStream();
var imageEncoder = await BitmapEncoder.CreateForTranscodingAsync(inMemoryStream, imageDecoder);
imageEncoder.BitmapTransform.ScaledWidth = (uint)(imageDecoder.OrientedPixelWidth * 0.5);
imageEncoder.BitmapTransform.ScaledHeight = (uint)(imageDecoder.OrientedPixelHeight * 0.5);
await imageEncoder.FlushAsync();
request.SetData(RandomAccessStreamReference.CreateFromStream(inMemoryStream));
}
}
finally
{
deferral.Complete();
}
MainPage.DisplayToast("Image has been set via deferral.");
}
// 用户点击了分享目标后会调用此方法
private async void OnDeferredImageRequestedHandler(DataProviderRequest providerRequest, StorageFile imageFile)
{
// 获取 DataProviderDeferral，以开始异步处理
DataProviderDeferral deferral = providerRequest.GetDeferral();
InMemoryRandomAccessStream inMemoryStream = new InMemoryRandomAccessStream();
try
{
// 将用户选中的图片缩小一倍，然后再分享
IRandomAccessStream imageStream = await imageFile.OpenAsync(FileAccessMode.Read);
BitmapDecoder imageDecoder = await BitmapDecoder.CreateAsync(imageStream);
BitmapEncoder imageEncoder = await BitmapEncoder.CreateForTranscodingAsync(inMemoryStream, imageDecoder);
imageEncoder.BitmapTransform.ScaledWidth = (uint)(imageDecoder.OrientedPixelWidth * 0.5);
imageEncoder.BitmapTransform.ScaledHeight = (uint)(imageDecoder.OrientedPixelHeight * 0.5);
await imageEncoder.FlushAsync();
// 停 3 秒，以模拟长时间任务
await Task.Delay(3000);
providerRequest.SetData(RandomAccessStreamReference.CreateFromStream(inMemoryStream));
}
finally
{
// 完成异步操作
deferral.Complete();
}
}
private async void renderer(DataProviderRequest request)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() => {
var deferral = request.GetDeferral();
request.SetData(await GetImage());
deferral.Complete();
});
}
private async Task ForcedDelayDataProviderCallback(DataProviderRequest request, Func <Object> valueRetrievalCallback)
{
var deferral = request.GetDeferral();
await Task.Delay(TimeSpan.FromSeconds(10));
request.SetData(valueRetrievalCallback());
deferral.Complete();
}
private async void ProvideData(DataProviderRequest request)
{
DataProviderDeferral deferral = request.GetDeferral();
var stream = new InMemoryRandomAccessStream();
await Graph.SaveImageAsync(stream);
request.SetData(RandomAccessStreamReference.CreateFromStream(stream));
deferral.Complete();
}
private void OnImport(FigureSeries series, bool withPreview)
{
var currentYear = DateTime.Now.Year;
var request = DataProviderRequest.Create(Stock, series.FigureType, currentYear - 10, currentYear);
request.WithPreview = withPreview;
DataProvider.Fetch(request, series);
}
public void Fetch(DataProviderRequest request, ICollection <IFigure> resultContainer)
{
var previewViewModel = new ImportPreviewModel(myStorageService, myLutService.CurrenciesLut)
{
Stock = request.Stock,
From = request.From,
To = request.To,
Series = resultContainer,
ThrowOnError = request.ThrowOnError,
CustomResolverCreator = CustomResolverCreator
};
if (request.WithPreview)
{
if (myCurrencyCache.Isin == request.Stock.Isin)
{
// take over last setting from user
previewViewModel.Currency = myCurrencyCache.Currency;
}
var preview = new ImportPreview(previewViewModel);
previewViewModel.FinishAction = () =>
{
preview.Close();
// remember last setting from user
if (previewViewModel.Currency != null)
{
myCurrencyCache.Isin = previewViewModel.Stock.Isin;
myCurrencyCache.Currency = previewViewModel.Currency;
}
};
preview.DataContext = previewViewModel;
previewViewModel.Fetch(request.FigureType);
preview.Top = 0;
preview.Left = 0;
preview.Show();
}
else
{
previewViewModel.Browser = new SafeWebBrowser();
previewViewModel.Fetch(request.FigureType);
previewViewModel.PublishData();
}
}
private void OnImportPrice(bool withPreview)
{
var today = DateTime.Today;
var request = DataProviderRequest.Create(Stock, typeof(Price), today.Subtract(TimeSpan.FromDays(7)), today.AddDays(1));
request.WithPreview = withPreview;
var series = new ObservableCollection <IFigure>();
CollectionChangedEventManager.AddHandler(series, OnSeriesChanged);
// fetch some more data because of weekends and public holidays
// we will then take last one
DataProvider.Fetch(request, series);
}
public void GetSeries()
{
var stock = new Stock {
Isin = "DE0005190003"
};
stock.Company = new Company {
Name = "BMW"
};
stock.Company.Stocks.Add(stock);
var dataProvider = new WebFigureProvider(new StorageService(myProjectHost.Object), myLutService.Object);
dataProvider.CustomResolverCreator = r => new CompositeMacroResolver(new MacroResolver(TestDataRoot), r);
var request = new DataProviderRequest(stock, typeof(Dividend), new YearPeriod(2001), new YearPeriod(2004))
{
WithPreview = false,
ThrowOnError = true
};
var series = new List <IFigure>();
dataProvider.Fetch(request, series);
Assert.That(series.Count, Is.EqualTo(4));
foreach (var dividend in series.Cast <Dividend>())
{
Assert.That(dividend.Company.Stocks.First().Isin, Is.EqualTo("DE0005190003"));
Assert.That(dividend.Period, Is.InstanceOf <YearPeriod>());
Assert.That(dividend.Source, Does.Contain("ariva").IgnoreCase.And.Contains("fundamentals").IgnoreCase);
Assert.That(dividend.Timestamp.Date, Is.EqualTo(DateTime.Today));
Assert.That(dividend.Currency, Is.Null);
}
Assert.That(series[0].Period, Is.EqualTo(new YearPeriod(2001)));
Assert.That(series[0].Value, Is.EqualTo(350000000d));
Assert.That(series[1].Period, Is.EqualTo(new YearPeriod(2002)));
Assert.That(series[1].Value, Is.EqualTo(351000000d));
Assert.That(series[2].Period, Is.EqualTo(new YearPeriod(2003)));
Assert.That(series[2].Value, Is.EqualTo(392000000d));
Assert.That(series[3].Period, Is.EqualTo(new YearPeriod(2004)));
Assert.That(series[3].Value, Is.EqualTo(419000000d));
}
private void OnShareBitmapData(DataProviderRequest request)
{
var deferral = request.GetDeferral();
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
try
{
var file = await ApplicationData.Current.TemporaryFolder.
CreateFileAsync("TempImage.png",
CreationCollisionOption.ReplaceExisting);
// Render XAML control to PNG image
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
var renderTargetBitmap = new RenderTargetBitmap();
await renderTargetBitmap.RenderAsync(SharedControl);
var pixelBuffer = await renderTargetBitmap.GetPixelsAsync();
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
encoder.SetPixelData(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Straight,
(uint)renderTargetBitmap.PixelWidth,
(uint)renderTargetBitmap.PixelHeight,
96, 96,
pixelBuffer.ToArray());
await encoder.FlushAsync();
}
// Share file
request.SetData(RandomAccessStreamReference.CreateFromFile(file));
}
finally
{
deferral.Complete();
}
});
}
async private void OnDeferredImageRequestedHandler(DataProviderRequest request, StorageFile imageFile)
{
if (imageFile != null)
{
// Since this method is using "await" prior to setting the data in DataPackage,
// deferral object must be used
var deferral = request.GetDeferral();
// Surround try catch to ensure that we always call Complete on defferal.
try
{
using (var imageStream = await imageFile.OpenAsync(FileAccessMode.Read))
{
// Decode the image
var imageDecoder = await BitmapDecoder.CreateAsync(imageStream);
// Re-encode the image at 50% width and height
var inMemoryStream = new InMemoryRandomAccessStream();
var imageEncoder = await BitmapEncoder.CreateForTranscodingAsync(inMemoryStream, imageDecoder);
imageEncoder.BitmapTransform.ScaledWidth = (uint)(imageDecoder.OrientedPixelWidth * 0.5);
imageEncoder.BitmapTransform.ScaledHeight = (uint)(imageDecoder.OrientedPixelHeight * 0.5);
await imageEncoder.FlushAsync();
request.SetData(RandomAccessStreamReference.CreateFromStream(inMemoryStream));
}
}
finally
{
deferral.Complete();
}
await log(OutputText, "Image has been set via deferral");
}
else
{
await log(OutputText, "Error: imageFile is null");
}
}
private async void OnDeferredImageRequestedHandler(DataProviderRequest request)
{
// Request deferral to wait for async calls
DataProviderDeferral deferral = request.GetDeferral();
// XAML objects can only be accessed on the UI thread, and the call may come in on a background thread
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
try
{
RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap();
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
// Render to an image at the current system scale and retrieve pixel contents
await renderTargetBitmap.RenderAsync(collageCanvas);
var pixelBuffer = await renderTargetBitmap.GetPixelsAsync();
// Encode image to an in-memory stream
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
encoder.SetPixelData(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Ignore,
(uint)renderTargetBitmap.PixelWidth,
(uint)renderTargetBitmap.PixelHeight,
DisplayInformation.GetForCurrentView().LogicalDpi,
DisplayInformation.GetForCurrentView().LogicalDpi,
pixelBuffer.ToArray());
await encoder.FlushAsync();
// Set content of the DataProviderRequest to the encoded image in memory
request.SetData(RandomAccessStreamReference.CreateFromStream(stream));
}
finally
{
deferral.Complete();
}
});
}
private void OnDeferredImageRequestedHandler(DataProviderRequest request)
{
if (_url != null)
{
// If the delegate is calling any asynchronous operations it needs to acquire
// the deferral first. This lets the system know that you are performing some
// operations that might take a little longer and that the call to SetData
// could happen after the delegate returns. Once you acquired the deferral object
// you must call Complete on it after your final call to SetData.
DataProviderDeferral deferral = request.GetDeferral();
// Make sure to always call Complete when finished with the deferral.
try
{
request.SetData(_url);
}
finally
{
deferral.Complete();
}
}
}
// <SnippetShareFileFunction_CS>
async void OnDeferredImageRequestedHandler(DataProviderRequest request)
{
// Provide updated bitmap data using delayed rendering.
if (this.imageStream != null)
{
DataProviderDeferral deferral = request.GetDeferral();
InMemoryRandomAccessStream inMemoryStream = new InMemoryRandomAccessStream();
// Decode the image.
BitmapDecoder imageDecoder = await BitmapDecoder.CreateAsync(this.imageStream);
// Re-encode the image at 50% width and height.
BitmapEncoder imageEncoder = await BitmapEncoder.CreateForTranscodingAsync(inMemoryStream, imageDecoder);
imageEncoder.BitmapTransform.ScaledWidth = (uint)(imageDecoder.OrientedPixelHeight * 0.5);
imageEncoder.BitmapTransform.ScaledHeight = (uint)(imageDecoder.OrientedPixelHeight * 0.5);
await imageEncoder.FlushAsync();
request.SetData(RandomAccessStreamReference.CreateFromStream(inMemoryStream));
deferral.Complete();
}
}
//<SnippetShareFileFunction_CS>
//<SnippetShareFileFunction>
async void OnDeferredImageRequestedHandler(DataProviderRequest request)
{
// Here we provide updated Bitmap data using delayed rendering
if (this.imageStream != null)
{
//<SnippetGetDefferal_CS>
//<SnippetGetDefferal>
DataProviderDeferral deferral = request.GetDeferral();
//</SnippetGetDefferal>
//</SnippetGetDefferal_CS>
try
{
InMemoryRandomAccessStream inMemoryStream = new InMemoryRandomAccessStream();
// Decode the image
BitmapDecoder imageDecoder = await BitmapDecoder.CreateAsync(this.imageStream);
// Re-encode the image at 50% width and height
BitmapEncoder imageEncoder = await BitmapEncoder.CreateForTranscodingAsync(inMemoryStream, imageDecoder);
imageEncoder.BitmapTransform.ScaledWidth = (uint)(imageDecoder.OrientedPixelHeight * 0.5);
imageEncoder.BitmapTransform.ScaledHeight = (uint)(imageDecoder.OrientedPixelHeight * 0.5);
await imageEncoder.FlushAsync();
request.SetData(RandomAccessStreamReference.CreateFromStream(inMemoryStream));
}
catch (Exception ex)
{
// Handle the exception
}
finally
{
deferral.Complete();
}
}
}
public void GetCell()
{
var stock = new Stock {
Isin = "DE0007664039"
};
stock.Company = new Company {
Name = "Volkswagen"
};
stock.Company.Stocks.Add(stock);
var dataProvider = new WebFigureProvider(new StorageService(myProjectHost.Object), myLutService.Object);
dataProvider.CustomResolverCreator = r => new CompositeMacroResolver(new MacroResolver(TestDataRoot), r);
var request = new DataProviderRequest(stock, typeof(Price), new DayPeriod(DateTime.MinValue), new DayPeriod(DateTime.MaxValue))
{
WithPreview = false,
ThrowOnError = true
};
var series = new List <IFigure>();
dataProvider.Fetch(request, series);
Assert.That(series.Count, Is.EqualTo(1));
var price = ( Price )series.Single();
Assert.That(price.Stock.Isin, Is.EqualTo("DE0007664039"));
Assert.That((( DayPeriod )price.Period).Day.Date, Is.EqualTo(DateTime.Today));
Assert.That(price.Source, Does.Contain("ariva").IgnoreCase.And.Contains("price").IgnoreCase);
Assert.That(price.Timestamp.Date, Is.EqualTo(DateTime.Today));
Assert.That(price.Value, Is.EqualTo(134.356d));
Assert.That(price.Currency.Symbol, Is.EqualTo("EUR"));
}
private void OnDeferredDataRequestedHandler(DataProviderRequest request)
{
}
private void OnDeferredTextRequestedHandler(DataProviderRequest providerRequest)
{
string text = "Hello World delayed";
providerRequest.SetData(text);
}
